TypeScript declarations for 2.0 (#301)

* Modify type files to external module definition format to publish them via npm (#242)

* Rewrite d.ts in external module definition format

* Publish type files via npm

* update d.ts for 2.0

* update d.ts tests for 2.0

* provide helpers.d.ts via npm

Author: ktsn

logger.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Types for the logger plugin.
+ * This file must be put alongside the JavaScript file of the logger.
+ */
+
+import { Payload, Plugin } from './types/index'
+
+export interface LoggerOption<S> {
+  collapsed?: boolean;
+  transformer?: (state: S) => any;
+  mutationTransformer?: <P extends Payload>(mutation: P) => any;
+}
+
+export default function createLogger<S>(option: LoggerOption<S>): Plugin<S>;

package.json

@@ -3,10 +3,15 @@
   "version": "2.0.0-rc.5",
   "description": "state management for Vue.js",
   "main": "dist/vuex.js",
+  "typings": "types/index.d.ts",
   "files": [
     "dist",
     "src",
-    "logger.js"
+    "types/index.d.ts",
+    "types/helpers.d.ts",
+    "types/vue.d.ts",
+    "logger.js",
+    "logger.d.ts"
   ],
   "scripts": {
     "dev": "node examples/server.js",

types/helpers.d.ts

@@ -0,0 +1,18 @@
+type Dictionary<T> = { [key: string]: T };
+
+export function mapState (map: string[]): Dictionary<() => any>;
+export function mapState (map: Dictionary<string>): Dictionary<() => any>;
+export function mapState <S>(
+  map: Dictionary<(this: vuejs.Vue, state: S, getters: any) => any>
+): Dictionary<() => any>;
+
+type MutationMethod = (...args: any[]) => void;
+export function mapMutations (map: string[]): Dictionary<MutationMethod>;
+export function mapMutations (map: Dictionary<string>): Dictionary<MutationMethod>;
+
+export function mapGetters (map: string[]): Dictionary<() => any>;
+export function mapGetters (map: Dictionary<string>): Dictionary<() => any>;
+
+type ActionMethod = (...args: any[]) => Promise<any[]>;
+export function mapActions (map: string[]): Dictionary<ActionMethod>;
+export function mapActions (map: Dictionary<string>): Dictionary<ActionMethod>;

types/index.d.ts

@@ -1,92 +1,103 @@
-declare namespace Vuex {
-  class Store<S> {
-    constructor(options: StoreOption<S>);
+import "./vue";
 
-    state: S;
+export * from "./helpers";
 
-    dispatch(mutationName: string, ...args: any[]): void;
-    dispatch<P>(mutation: MutationObject<P>): void;
+export declare class Store<S> {
+  constructor(options: StoreOptions<S>);
 
-    replaceState(state: S): void;
+  readonly state: S;
+  readonly getters: any;
 
-    watch<T>(getter: Getter<S, T>, cb: (value: T) => void, options?: WatchOption): void;
+  replaceState(state: S): void;
 
-    hotUpdate(options: {
-      mutations?: MutationTree<S>;
-      modules?: ModuleTree;
-    }): void;
+  dispatch: Dispatch;
+  commit: Commit;
 
-    subscribe(cb: (mutation: MutationObject<any>, state: S) => void): () => void;
-  }
+  subscribe<P extends Payload>(fn: (mutation: P, state: S) => any): () => void;
+  watch<T>(getter: (state: S) => T, cb: (value: T) => void, options?: WatchOption): void;
 
-  function install(Vue: vuejs.VueStatic): void;
+  registerModule<T>(path: string, module: Module<T, S>): void;
+  registerModule<T>(path: string[], module: Module<T, S>): void;
 
-  interface StoreOption<S> {
-    state?: S;
+  unregisterModule(path: string): void;
+  unregisterModule(path: string[]): void;
+
+  hotUpdate(options: {
+    actions?: ActionTree<S, S>;
     mutations?: MutationTree<S>;
-    modules?: ModuleTree;
-    plugins?: Plugin<S>[];
-    strict?: boolean;
-  }
-
-  type Getter<S, T> = (state: S) => T;
-  type Action<S> = (store: Store<S>, ...args: any[]) => any;
-  type Mutation<S> = (state: S, ...args: any[]) => void;
-  type Plugin<S> = (store: Store<S>) => void;
-
-  interface MutationTree<S> {
-    [key: string]: Mutation<S>;
-  }
-
-  interface MutationObject<P> {
-    type: string;
-    silent?: boolean;
-    payload?: P;
-  }
-
-  interface Module<S> {
-    state: S;
-    mutations: MutationTree<S>;
-  }
-
-  interface ModuleTree {
-    [key: string]: Module<any>;
-  }
-
-  interface ComponentOption<S> {
-    getters: { [key: string]: Getter<S, any> };
-    actions: { [key: string]: Action<S> };
-  }
-
-  interface WatchOption {
-    deep?: boolean;
-    immidiate?: boolean;
-  }
-
-  function createLogger<S>(option: LoggerOption<S>): Plugin<S>;
-
-  interface LoggerOption<S> {
-    collapsed?: boolean;
-    transformer?: (state: S) => any;
-    mutationTransformer?: (mutation: MutationObject<any>) => any;
-  }
+    getters?: GetterTree<S, S>;
+    modules?: ModuleTree<S>;
+  }): void;
+}
+
+export declare function install(Vue: vuejs.VueStatic): void;
+
+export interface Dispatch {
+  (type: string, payload?: any): Promise<any[]>;
+  <P extends Payload>(payloadWithType: P): Promise<any[]>;
+}
+
+export interface Commit {
+  (type: string, payload?: any, options?: CommitOptions): void;
+  <P extends Payload>(payloadWithType: P, options?: CommitOptions): void;
+}
+
+export interface ActionInjectee<S, R> {
+  dispatch: Dispatch;
+  commit: Commit;
+  state: S;
+  getters: any;
+  rootState: R;
+}
+
+export interface Payload {
+  type: string;
 }
 
-declare namespace vuejs {
-  interface ComponentOption {
-    vuex?: Vuex.ComponentOption<any>;
-    store?: Vuex.Store<any>;
-  }
+export interface CommitOptions {
+  silent?: boolean;
+}
+
+export interface StoreOptions<S> {
+  state?: S;
+  getters?: GetterTree<S, S>;
+  actions?: ActionTree<S, S>;
+  mutations?: MutationTree<S>;
+  modules?: ModuleTree<S>;
+  plugins?: Plugin<S>[];
+  strict?: boolean;
+}
+
+export type Getter<S, R> = (state: S, getters: any, rootState: R) => any;
+export type Action<S, R> = (injectee: ActionInjectee<S, R>, payload: any) => any;
+export type Mutation<S> = (state: S, payload: any) => any;
+export type Plugin<S> = (store: Store<S>) => any;
+
+export interface Module<S, R> {
+  state?: S;
+  getters?: GetterTree<S, R>;
+  actions?: ActionTree<S, R>;
+  mutations?: MutationTree<S>;
+  modules?: ModuleTree<R>;
+}
+
+export interface GetterTree<S, R> {
+  [key: string]: Getter<S, R>;
+}
+
+export interface ActionTree<S, R> {
+  [key: string]: Action<S, R>;
+}
 
-  interface Vue {
-    $store?: Vuex.Store<any>;
-  }
+export interface MutationTree<S> {
+  [key: string]: Mutation<S>;
 }
 
-declare module 'vuex' {
-  export = Vuex
+export interface ModuleTree<R> {
+  [key: string]: Module<any, R>;
 }
 
-declare module 'vuex/logger' {
-  export default Vuex.createLogger;
+export interface WatchOption {
+  deep?: boolean;
+  immediate?: boolean;
 }

types/test/helpers.ts

@@ -0,0 +1,47 @@
+import * as Vue from "vue";
+
+import {
+  mapState,
+  mapGetters,
+  mapActions,
+  mapMutations
+} from "../index";
+
+new Vue({
+  computed: Object.assign({},
+    mapState(["a"]),
+    mapState({
+      b: "b"
+    }),
+    mapState({
+      c: (state: any, getters: any) => state.c + getters.c
+    }),
+
+    mapGetters(["d"]),
+    mapGetters({
+      e: "e"
+    }),
+
+    {
+      otherComputed () {
+        return "f";
+      }
+    }
+  ),
+
+  methods: Object.assign({},
+    mapActions(["g"]),
+    mapActions({
+      h: "h"
+    }),
+
+    mapMutations(["i"]),
+    mapMutations({
+      j: "j"
+    }),
+
+    {
+      otherMethod () {}
+    }
+  )
+});