vuex-tstore/dist/es/actions.js

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

import { qualifyKey } from "./util";
/**
 * Wraps actions accessors to create a set of action proxies.
 *
 * This function *looks* arcane, but does exactly what it claims to do. It's
 * written this way because this yields precisely the desired results we want,
 * but without needing to fight TypeScript to do it.
 *
 * @param store The store to wrap action around.
 * @param actions The action accessors to wrap.
 *
 * ```typescript
 * import { Store } from 'vuex';
 * import { wrapActions } from 'vuex-tstore';
 *
 * const options = {
 *   actions: {
 *     async withFoo(store, payload: { foo: string }) {},
 *     async withoutFoo(store) {},
 *   },
 * };
 *
 * const store = new Store(options);
 * const actions = wrapActions(store, options.actions);
 *
 * actions.withFoo({ foo: 'foo' }); // Promise<void>
 * actions.withoutFoo();            // Promise<void>
 * ```
 */
export function wrapActions(namespace, store, actions) {
    return Object.entries(actions).reduce((dispatch, [key, action]) => {
        // Get the key that Vuex knows this action by.
        const actionKey = qualifyKey(action, namespace);
        const deferred = payload => store.dispatch(actionKey, payload, { root: true });
        deferred.before = (handler) => store.subscribeAction({
            before: ({ type, payload }) => {
                if (type === actionKey) {
                    handler.call(null, payload);
                }
            }
        });
        deferred.after = (handler) => store.subscribeAction({
            after: ({ type, payload }) => {
                if (type === actionKey) {
                    handler.call(null, payload);
                }
            }
        });
        // Attach the deferment to the dispatch function.
        return Object.defineProperty(dispatch, key, { value: deferred });
    }, {});
}
//# sourceMappingURL=data:application/json;base64,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