Use keyof to improve type inference in helpers

types/helpers.d.ts

@@ -6,39 +6,45 @@ type Computed = () => any;
 type MutationMethod = (...args: any[]) => void;
 type ActionMethod = (...args: any[]) => Promise<any>;
 type CustomVue = Vue & Dictionary<any>
+type TypedDictionary<K extends string, V> = { [key in K]: V }
+type CompleteObject = { [key: string]: string };
 
 interface Mapper<R> {
-  (map: string[]): Dictionary<R>;
-  (map: Dictionary<string>): Dictionary<R>;
+  <T extends CompleteObject, K extends keyof T>(map: K[]): TypedDictionary<K, R>;
+  <T extends CompleteObject, K extends keyof T>(map: { [key in K]: string }): TypedDictionary<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[]): TypedDictionary<K, R>;
+  <T extends CompleteObject, K extends keyof T>(namespace: string, map: { [key in K]: string }): TypedDictionary<K, R>;
 }
 
+type MappingFunction<F> = (this: CustomVue, fn: F, ...args: any[]) => any
+
 interface FunctionMapper<F, R> {
-  (map: Dictionary<(this: CustomVue, fn: F, ...args: any[]) => any>): Dictionary<R>;
+  <T extends CompleteObject, K extends keyof T>(map: { [key in K]: MappingFunction<F> }): TypedDictionary<K, R>;
 }
 
 interface FunctionMapperWithNamespace<F, R> {
-  (
+  <T extends CompleteObject, K extends keyof T>(
     namespace: string,
-    map: Dictionary<(this: CustomVue, fn: F, ...args: any[]) => any>
-  ): Dictionary<R>;
+    map: { [key in K]: MappingFunction<F> }
+  ): TypedDictionary<K, R>;
 }
 
+type StateMappingFunction<S> = (this: CustomVue, state: S, getters: any) => any
+
 interface MapperForState {
-  <S>(
-    map: Dictionary<(this: CustomVue, state: S, getters: any) => any>
-  ): Dictionary<Computed>;
+  <S, T extends CompleteObject, K extends keyof T>(
+    map: { [key in K]: StateMappingFunction<S> }
+  ): TypedDictionary<K, Computed>;
 }
 
 interface MapperForStateWithNamespace {
-  <S>(
+  <S, T extends CompleteObject, K extends keyof T>(
     namespace: string,
-    map: Dictionary<(this: CustomVue, state: S, getters: any) => any>
-  ): Dictionary<Computed>;
+    map: { [key in K]: StateMappingFunction<S> }
+  ): TypedDictionary<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');
@@ -65,7 +67,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',
@@ -80,7 +82,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',
@@ -96,7 +98,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',
@@ -111,7 +113,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',
@@ -127,7 +129,7 @@ new Vue({
       m: "m"
     }),
     helpers.mapActions({
-      m (dispatch, value: string) {
+      m (dispatch: Dispatch, value: string) {
         dispatch('m', value)
       }
     }),
@@ -137,13 +139,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()