Use keyof to improve type inference in helpers

Author: Demivan

types/helpers.d.ts

@@ -1,43 +1,47 @@
 import Vue from 'vue';
 import { Dispatch, Commit } from './index';
 
-type Dictionary<T> = { [key: string]: T };
+type CompleteObject = { [key: string]: string };
 type Computed = () => any;
 type MutationMethod = (...args: any[]) => void;
 type ActionMethod = (...args: any[]) => Promise<any>;
 
 interface Mapper<R> {
-  (map: string[]): Dictionary<R>;
-  (map: Dictionary<string>): Dictionary<R>;
+  <T extends CompleteObject, K extends keyof T>(map: K[]): { [key in K]: R };
+  <T extends CompleteObject, K extends keyof T>(map: { [key in K]: string }): { [key in K]: R };
 }
 
 interface MapperWithNamespace<R> {
-  (namespace: string, map: string[]): Dictionary<R>;
-  (namespace: string, map: Dictionary<string>): Dictionary<R>;
+  <T extends CompleteObject, K extends keyof T>(namespace: string, map: K[]): { [key in K]: R };
+  <T extends CompleteObject, K extends keyof T>(namespace: string, map: { [key in K]: string }): { [key in K]: R };
 }
 
+type MappingFunction<F> = (this: typeof Vue, fn: F, ...args: any[]) => any
+
 interface FunctionMapper<F, R> {
-  (map: Dictionary<(this: typeof Vue, fn: F, ...args: any[]) => any>): Dictionary<R>;
+  <T extends CompleteObject, K extends keyof T>(map: { [key in K]: MappingFunction<F> }): { [key in K]: R };
 }
 
 interface FunctionMapperWithNamespace<F, R> {
-  (
+  <T extends CompleteObject, K extends keyof T>(
     namespace: string,
-    map: Dictionary<(this: typeof Vue, fn: F, ...args: any[]) => any>
-  ): Dictionary<R>;
+    map: { [key in K]: MappingFunction<F> }
+  ): { [key in K]: R };
 }
 
+type StateMappingFunction<S> = (this: typeof Vue, state: S, getters: any) => any
+
 interface MapperForState {
-  <S>(
-    map: Dictionary<(this: typeof Vue, state: S, getters: any) => any>
-  ): Dictionary<Computed>;
+  <S, T extends CompleteObject, K extends keyof T>(
+    map: { [key in K]: StateMappingFunction<S> }
+  ): { [key in K]: Computed };
 }
 
 interface MapperForStateWithNamespace {
-  <S>(
+  <S, T extends CompleteObject, K extends keyof T>(
     namespace: string,
-    map: Dictionary<(this: typeof Vue, state: S, getters: any) => any>
-  ): Dictionary<Computed>;
+    map: { [key in K]: StateMappingFunction<S> }
+  ): { [key in K]: Computed };
 }
 
 interface NamespacedMappers {

types/test/helpers.ts

@@ -5,7 +5,9 @@ import {
   mapGetters,
   mapActions,
   mapMutations,
-  createNamespacedHelpers
+  createNamespacedHelpers,
+  Commit,
+  Dispatch
 } from "../index";
 
 const helpers = createNamespacedHelpers('foo');
@@ -62,7 +64,7 @@ new Vue({
       h: "h"
     }),
     mapActions({
-      g (dispatch, a: string, b: number, c: boolean): void {
+      g (dispatch: Dispatch, a: string, b: number, c: boolean): void {
         dispatch('g', { a, b, c })
         dispatch({
           type: 'g',
@@ -77,7 +79,7 @@ new Vue({
       h: "h"
     }),
     mapActions('foo', {
-      g (dispatch, a: string, b: number, c: boolean): void {
+      g (dispatch: Dispatch, a: string, b: number, c: boolean): void {
         dispatch('g', { a, b, c })
         dispatch({
           type: 'g',
@@ -93,7 +95,7 @@ new Vue({
       j: "j"
     }),
     mapMutations({
-      i (commit, a: string, b: number, c: boolean): void {
+      i (commit: Commit, a: string, b: number, c: boolean): void {
         commit('i', { a, b, c })
         commit({
           type: 'i',
@@ -108,7 +110,7 @@ new Vue({
       j: "j"
     }),
     mapMutations('foo', {
-      i (commit, a: string, b: number, c: boolean): void {
+      i (commit: Commit, a: string, b: number, c: boolean): void {
         commit('i', { a, b, c })
         commit({
           type: 'i',
@@ -124,7 +126,7 @@ new Vue({
       m: "m"
     }),
     helpers.mapActions({
-      m (dispatch, value: string) {
+      m (dispatch: Dispatch, value: string) {
         dispatch('m', value)
       }
     }),
@@ -134,13 +136,35 @@ new Vue({
       n: "n"
     }),
     helpers.mapMutations({
-      n (commit, value: string) {
+      n (commit: Commit, value: string) {
         commit('m', value)
       }
     }),
+    helpers.mapMutations({
+      n: "n",
+      m: "m"
+    }),
 
     {
       otherMethod () {}
     }
   )
 });
+
+const actions = mapActions({
+  mAlias: "m"
+})
+
+actions.mAlias()
+
+const actionsNamespaced = mapActions('namespace', {
+  mAlias: "m"
+})
+
+actionsNamespaced.mAlias()
+
+const actionsNamespaced2 = helpers.mapActions({
+  mAlias: "m"
+})
+
+actionsNamespaced2.mAlias()