vuex-tstore/dist/cjs/mutations.js

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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.wrapMutations = void 0;
const util_1 = require("./util");
/**
 * Wraps mutation accessors to create a set of mutation proxies.
 *
 * Yet another function that bypasses the type system for convenience. This
 * function does what it claims to do, but has to tell TypeScript to trust that
 * we know what we are doing. As always, change this function with caution,
 * because if this function breaks then we lose IntelliSense around mutations.
 *
 * @param onMutate The mutation function from the store.
 * @param accessors The accessor functions.
 * @param store The store to wrap mutations around.
 * @param mutations The mutation accessors to wrap.
 */
function wrapMutations(namespace, store, mutations) {
    return Object.entries(mutations).reduce((commit, [key, mutation]) => {
        // Get the key that Vuex knows this mutation by.
        const mutationKey = util_1.qualifyKey(mutation, namespace);
        const deferred = payload => store.commit(mutationKey, payload, { root: true });
        deferred.listen = (handler) => store.subscribe(({ type, payload }) => {
            if (type === mutationKey) {
                handler.call(null, payload);
            }
        });
        // Attach the deferment to the commit function.
        return Object.defineProperty(commit, key, { value: deferred });
    }, {});
}
exports.wrapMutations = wrapMutations;
//# sourceMappingURL=data:application/json;base64,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