vuex-tstore/dist/cjs/store.js

Provides a low-overhead TypeScript wrapper around Vuex that can trigger compilation errors and IntelliSense tips.

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Store = void 0;
const vuex_1 = require("vuex");
const actions_1 = require("./actions");
const getters_1 = require("./getters");
const mutations_1 = require("./mutations");
const state_1 = require("./state");
/**
 * Creates a type-aware wrapper around a Vuex store.
 *
 * This class generates type-aware bindings to a wrapped Vuex store in order to
 * expose typing information to the store consumer via a series of Generics
 * which reference the configuration object. This means that this Store wrapper
 * enables IntelliSense (VSCode), Linters, and the TypeScript Compiler to be
 * able to validate that code is actually using the store correctly.
 *
 * ```typescript
 * import Store from 'vuex-tstore';
 *
 * const options = {
 *   state: () => ({ title: "Hello, world!" }),
 *   getters: {
 *     title: (state) => state.title
 *   },
 *   mutations: {
 *     resetTitle: (state) => { state.title = ''; },
 *     setTitle: (state, payload: { title: string }) => { state.title = title; }
 *   },
 *   actions: {
 *     resetTitle: async (context) => context.commit('resetTitle'),
 *     setTitle: (context, payload: { title: string }) => {
 *       setTimeout(() => context.commit('setTitle', payload), 1000);
 *     }
 *   }
 * };
 *
 * const store = new Store(options);
 *
 * store.getters.title; // "Hello, world!"
 * store.mutations.resetTitle(); // ""
 * store.mutations.setTitle({ title: "foo" }); // "foo"
 *
 * store.actions.resetTitle();
 * store.actions.setTitle({ title: "bar" });
 * ```
 */
class Store {
    constructor(options, store = new vuex_1.Store(options), name = "") {
        const opts = options || {};
        this.store = store;
        this.actions = actions_1.wrapActions(name, this.store, opts.actions || {});
        this.getters = getters_1.wrapGetters(name, this.store, opts.getters || {});
        this.modules = wrapModules(name, this.store, opts.modules || {});
        this.state = state_1.wrapState(name, this.store);
        this.mutations = mutations_1.wrapMutations(name, this.store, opts.mutations || {});
    }
    commit(type, payload, options) {
        return this.store.commit(type, payload, options);
    }
    dispatch(type, payload, options) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.store.dispatch(type, payload, options);
        });
    }
    registerModule(path, module, options) {
        // This cast is just to pass the linter. Vuex wasn't built for TypeScript.
        return this.store.registerModule(path, module, options);
    }
    unregisterModule(path) {
        // This cast is just to pass the linter. Vuex wasn't built for TypeScript.
        return this.store.unregisterModule(path);
    }
    hotUpdate(options) {
        return this.store.hotUpdate(options);
    }
    subscribe(fn) {
        return this.store.subscribe(fn);
    }
    subscribeAction(fn) {
        return this.store.subscribeAction(fn);
    }
    watch(getter, cb, options) {
        return this.store.watch(getter, cb, options);
    }
}
exports.Store = Store;
/**
 * Creates a dictionary of modules.
 *
 * @param parent The name of the parent module.
 * @param store The store to wrap.
 * @param modules The list of modules to process.
 */
function wrapModules(parent, store, modules) {
    return Object.entries(modules).reduce((mods, [key, options]) => {
        const name = options.namespaced
            ? `${parent}${parent === "" ? "" : "/"}${key}`
            : "";
        return Object.defineProperty(mods, key, {
            value: new Store(options, store, name),
        });
    }, {});
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"./src/","sources":["store.ts"],"names":[],"mappings":"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","sourcesContent":["import { WatchOptions } from \"vue\";\nimport {\n  ActionPayload,\n  ActionTree,\n  CommitOptions,\n  DispatchOptions,\n  GetterTree,\n  Module,\n  ModuleOptions,\n  ModuleTree,\n  MutationPayload,\n  MutationTree,\n  Store as VuexStore,\n  StoreOptions,\n  SubscribeActionOptions,\n} from \"vuex\";\nimport { wrapActions, WrappedActions } from \"./actions\";\nimport { GetAccessors, wrapGetters, WrappedGetters } from \"./getters\";\nimport { wrapMutations, WrappedMutations } from \"./mutations\";\nimport { wrapState, TState } from \"./state\";\n\nexport interface Options {\n  state?: object;\n  getters?: object;\n  mutations?: object;\n  actions?: object;\n  namespaced?: boolean;\n  modules?: {\n    [key: string]: Options;\n  };\n}\n\n/**\n * Creates a type-aware wrapper around a Vuex store.\n *\n * This class generates type-aware bindings to a wrapped Vuex store in order to\n * expose typing information to the store consumer via a series of Generics\n * which reference the configuration object. This means that this Store wrapper\n * enables IntelliSense (VSCode), Linters, and the TypeScript Compiler to be\n * able to validate that code is actually using the store correctly.\n *\n * ```typescript\n * import Store from 'vuex-tstore';\n *\n * const options = {\n *   state: () => ({ title: \"Hello, world!\" }),\n *   getters: {\n *     title: (state) => state.title\n *   },\n *   mutations: {\n *     resetTitle: (state) => { state.title = ''; },\n *     setTitle: (state, payload: { title: string }) => { state.title = title; }\n *   },\n *   actions: {\n *     resetTitle: async (context) => context.commit('resetTitle'),\n *     setTitle: (context, payload: { title: string }) => {\n *       setTimeout(() => context.commit('setTitle', payload), 1000);\n *     }\n *   }\n * };\n *\n * const store = new Store(options);\n *\n * store.getters.title; // \"Hello, world!\"\n * store.mutations.resetTitle(); // \"\"\n * store.mutations.setTitle({ title: \"foo\" }); // \"foo\"\n *\n * store.actions.resetTitle();\n * store.actions.setTitle({ title: \"bar\" });\n * ```\n */\nexport class Store<\n  TModuleState,\n  TRootState,\n  TOptions extends Options,\n  TWrappedMutations = WrappedMutations<\n    TOptions extends { mutations?: infer T } ? T : undefined\n  >,\n  TWrappedActions = WrappedActions<\n    TOptions extends { actions?: infer T } ? T : undefined\n  >,\n  TWrappedGetters = WrappedGetters<\n    GetAccessors<\n      TModuleState,\n      TRootState,\n      TOptions extends { getters?: infer T } ? T : undefined\n    >\n  >,\n  TModuleList = ModuleList<\n    TModuleState,\n    TRootState,\n    TOptions extends { modules?: infer T } ? T : undefined\n  >\n> {\n  /**\n   * Read-only property that holds the getters for this store.\n   */\n  public readonly getters: Readonly<TWrappedGetters>;\n\n  /**\n   * Read-only property that holds references to the store state.\n   */\n\n  public readonly state: Readonly<TState<TOptions[\"state\"]>>;\n\n  /**\n   * Read-only property that holds the mutations for this store.\n   *\n   * Every wrapped module can be executed with an attached function, and comes\n   * with two options that may be executed from the wrapper:\n   *\n   * ```typescript\n   * wrapper.mutations.myMutation(payload);\n   * wrapper.mutations.myMutation.listen((payload) => {\n   *   // Do things after the mutation is executed.\n   * });\n   * ```\n   */\n  public readonly mutations: Readonly<TWrappedMutations>;\n\n  /**\n   * Read-only property that holds the actions for this store.\n   *\n   * Every wrapped action can be executed with an attached function, and comes\n   * with two options that may be executed from the wrapper:\n   *\n   * ```typescript\n   * wrapper.actions.myAction(payload);\n   * wrapper.actions.myAction.before((payload) => {\n   *   // Do things before the action is executed.\n   * });\n   * wrapper.actions.myAction.after((payload) => {\n   *   // Do things after the action is executed.\n   * });\n   * ```\n   */\n  public readonly actions: Readonly<TWrappedActions>;\n\n  /**\n   * Read-only property that holds the modules for this store.\n   */\n  public readonly modules: TModuleList;\n\n  /**\n   * Read-only reference to the Vuex store.\n   */\n  public readonly store: Readonly<VuexStore<TRootState>>;\n\n  /**\n   * Instantiates a new wrapper.\n   *\n   * @param options The options to use when constructing the Vuex Store.\n   * @param store A pre-existing store to wrap.\n   * @param name The module name to use for this object.\n   */\n  constructor(options?: TOptions & StoreOptions<TRootState>);\n  constructor(\n    options: TOptions & StoreOptions<TRootState>,\n    store: VuexStore<TRootState>,\n    name: string\n  );\n  constructor(\n    options: TOptions & StoreOptions<TRootState>,\n    store = new VuexStore(options),\n    name = \"\"\n  ) {\n    const opts = options || {};\n\n    this.store = store;\n    this.actions = wrapActions(name, this.store, opts.actions || {});\n    this.getters = wrapGetters(name, this.store, opts.getters || {});\n    this.modules = wrapModules(name, this.store, opts.modules || {});\n    this.state = wrapState(name, this.store);\n    this.mutations = wrapMutations(name, this.store, opts.mutations || {});\n  }\n\n  public commit(type: string, payload?: any, options?: CommitOptions) {\n    return this.store.commit(type, payload, options);\n  }\n\n  public async dispatch(\n    type: string,\n    payload?: any,\n    options?: DispatchOptions\n  ): Promise<any> {\n    return this.store.dispatch(type, payload, options);\n  }\n\n  public registerModule<T>(\n    path: string[] | string,\n    module: Module<T, TRootState>,\n    options?: ModuleOptions\n  ): void {\n    // This cast is just to pass the linter. Vuex wasn't built for TypeScript.\n    return this.store.registerModule(path as string, module, options);\n  }\n\n  public unregisterModule(path: string | string[]): void {\n    // This cast is just to pass the linter. Vuex wasn't built for TypeScript.\n    return this.store.unregisterModule(path as string);\n  }\n\n  public hotUpdate(options: {\n    actions?: ActionTree<TRootState, TRootState>;\n    mutations?: MutationTree<TRootState>;\n    getters?: GetterTree<TRootState, TRootState>;\n    modules?: ModuleTree<TRootState>;\n  }): void {\n    return this.store.hotUpdate(options);\n  }\n\n  public subscribe<P extends MutationPayload>(\n    fn: (mutation: P, state: TRootState) => any\n  ): () => void {\n    return this.store.subscribe(fn);\n  }\n\n  public subscribeAction<P extends ActionPayload>(\n    fn: SubscribeActionOptions<P, TRootState>\n  ): () => void {\n    return this.store.subscribeAction(fn);\n  }\n\n  public watch<\n    TGetterFn extends (state: TRootState, getters: TWrappedGetters) => any,\n    TCbFn extends (\n      value: ReturnType<TGetterFn>,\n      oldValue: ReturnType<TGetterFn>\n    ) => void\n  >(getter: TGetterFn, cb: TCbFn, options?: WatchOptions): () => void {\n    return this.store.watch(getter, cb, options);\n  }\n}\n\n/**\n * Creates a dictionary of modules.\n *\n * @param parent The name of the parent module.\n * @param store The store to wrap.\n * @param modules The list of modules to process.\n */\nfunction wrapModules<\n  TModuleState,\n  TRootState,\n  TModules extends { [key: string]: Options },\n  TModuleList = ModuleList<TModuleState, TRootState, TModules>\n>(\n  parent: string,\n  store: VuexStore<TRootState>,\n  modules: TModules\n): TModuleList {\n  return Object.entries(modules).reduce((mods, [key, options]) => {\n    const name = options.namespaced\n      ? `${parent}${parent === \"\" ? \"\" : \"/\"}${key}`\n      : \"\";\n    return Object.defineProperty(mods, key, {\n      value: new Store(\n        options as Options & StoreOptions<TRootState>,\n        store,\n        name\n      ),\n    });\n  }, {}) as TModuleList;\n}\n\ntype ModuleList<\n  TModuleState,\n  TRootState,\n  TModules extends { [key: string]: Options }\n> = { [key in keyof TModules]: Store<TModuleState, TRootState, TModules[key]> };\n"]}