vuex-tstore/dist/es/mutations.js

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

import { qualifyKey } from "./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.
 */
export function wrapMutations(namespace, store, mutations) {
    return Object.entries(mutations).reduce((commit, [key, mutation]) => {
        // Get the key that Vuex knows this mutation by.
        const mutationKey = 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 });
    }, {});
}
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXV0YXRpb25zLmpzIiwic291cmNlUm9vdCI6Ii4vc3JjLyIsInNvdXJjZXMiOlsibXV0YXRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sRUFBMEIsVUFBVSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBZ0Q1RDs7Ozs7Ozs7Ozs7O0dBWUc7QUFDSCxNQUFNLFVBQVUsYUFBYSxDQUszQixTQUFpQixFQUNqQixLQUE0QixFQUM1QixTQUFxQjtJQUVyQixPQUFPLE1BQU0sQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsTUFBTSxFQUFFLENBQUMsR0FBRyxFQUFFLFFBQVEsQ0FBQyxFQUFFLEVBQUU7UUFDbEUsZ0RBQWdEO1FBQ2hELE1BQU0sV0FBVyxHQUFHLFVBQVUsQ0FBQyxRQUFRLEVBQUUsU0FBUyxDQUFDLENBQUM7UUFNcEQsTUFBTSxRQUFRLEdBQXFCLE9BQU8sQ0FBQyxFQUFFLENBQzNDLEtBQUssQ0FBQyxNQUFNLENBQUMsV0FBVyxFQUFFLE9BQU8sRUFBRSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBRXJELFFBQVEsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxPQUFpRCxFQUFFLEVBQUUsQ0FDdEUsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxFQUFFLEVBQUU7WUFDcEMsSUFBSSxJQUFJLEtBQUssV0FBVyxFQUFFO2dCQUN2QixPQUFlLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxPQUFPLENBQUMsQ0FBQzthQUN0QztRQUNILENBQUMsQ0FBQyxDQUFDO1FBRUwsK0NBQStDO1FBQy9DLE9BQU8sTUFBTSxDQUFDLGNBQWMsQ0FBQyxNQUFNLEVBQUUsR0FBRyxFQUFFLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDakUsQ0FBQyxFQUFFLEVBQUUsQ0FBc0IsQ0FBQztBQUM5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBEZWZpbmVzIGhvdyB0byBtYW5hZ2UgdGhlIG11dGF0aW9uIHByb3hpZXMuXG4gKi9cbmltcG9ydCB7IFN0b3JlIGFzIFZ1ZXhTdG9yZSB9IGZyb20gXCJ2dWV4XCI7XG5pbXBvcnQgeyBQYXlsb2FkLCBQYXlsb2FkUmV0dXJuLCBxdWFsaWZ5S2V5IH0gZnJvbSBcIi4vdXRpbFwiO1xuXG4vKipcbiAqIEV4dHJhY3RzIGFuIGludGVyZmFjZSBmb3Igd3JhcHBlZCBtdXRhdGlvbiBhY2Nlc3NvcnMuXG4gKlxuICogVGhpcyBzb21ld2hhdCBiZWFzdGx5IGxvb2tpbmcgdGVtcGxhdGUgaXMgdXNlZCB0byBnZW5lcmF0ZSBhbiBpbnRlcmZhY2UgZm9yXG4gKiBhIHdyYXBwZXIgYXJvdW5kIGEgbXV0YXRpb24gb2JqZWN0LiBUaGF0IGlzLCBnaXZlbiBhbiBvYmplY3Qgd2hlcmUgZWFjaFxuICogcHJvcGVydHkgaXMgYSBmdW5jdGlvbiBpbiB0aGUgZm9ybSBgKHN0b3JlLCBwYXlsb2FkPykgPT4gdm9pZGAsIGEgd3JhcHBlclxuICogY291bGQgYmUgbWFkZSB3aXRoIG1hdGNoaW5nIHByb3BlcnRpZXMgd2hlcmUgZWFjaCBwcm9wZXJ0eSBpcyBpbiB0aGUgZm9ybVxuICogYChwYXlsb2FkPykgPT4gdm9pZGAuIEluIHN1Y2ggYW4gb2JqZWN0LCB0aGUgYHN0b3JlYCBhcmd1bWVudCBzaG91bGQgYmVcbiAqIGF1dG9tYXRpY2FsbHkgZmlsbGVkIGluIHdpdGggdGhlIHN0b3JlIG9iamVjdCBiZWluZyB3cmFwcGVkLlxuICpcbiAqIEdpdmVuIGFuIG9iamVjdCBvZiB0eXBlIGBUTXV0YXRpb25zYCAoYmVsb3cpLCB0aGlzIHR5cGUgcmVmbGVjdHMgdGhhdCB0aGVyZVxuICogZXhpc3RzIGFuIGludGVyZmFjZSBvZiB0eXBlIGBUV3JhcHBlZE11dGF0aW9uc2AgKGJlbG93KS5cbiAqXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBpbnRlcmZhY2UgVE11dGF0aW9ucyB7XG4gKiAgIFtrZXk6IHN0cmluZyB8IG51bWJlciB8IFN5bWJvbF06IChjb250ZXh0OiBUQ29udGV4dCwgcGF5bG9hZD86IFRQYXlsb2FkKSA9PiBUUmVzdWx0XG4gKiB9XG4gKlxuICogdHlwZSBUV3JhcHBlZE11dGF0aW9ucyA9IHtcbiAqICAgW2tleSBpbiBrZXlvZiBUTXV0YXRpb25zXTogKHBheWxvYWQ/OiBUUGF5bG9hZCkgPT4gVFJlc3VsdFxuICogfVxuICogYGBgXG4gKi9cbmV4cG9ydCB0eXBlIFdyYXBwZWRNdXRhdGlvbnM8VE11dGF0aW9ucz4gPSB7XG4gIFtLZXkgaW4ga2V5b2YgVE11dGF0aW9uc106IFdyYXBwZWRNdXRhdGlvbkhhbmRsZXI8VE11dGF0aW9uc1tLZXldPiAmIHtcbiAgICBsaXN0ZW4oaGFuZGxlcjogTXV0YXRpb25MaXN0ZW5lckhhbmRsZXI8VE11dGF0aW9uc1tLZXldPik6ICgpID0+IHZvaWQ7XG4gIH1cbn07XG5cbi8qKlxuICogUHJvdmlkZXMgYSBnZW5lcmljIGludGVyZmFjZSBmb3IgYSB3cmFwcGVyIGFyb3VuZCBhIGBUTXV0YXRpb25gIGZ1bmN0aW9uLlxuICpcbiAqIFRoaXMgYXV0b21hdGljYWxseSBkaWZmZXJlbnRpYXRlcyB0aGUgbXV0YXRpb25zIHRoYXQgaGF2ZSBwYXlsb2FkcyBmcm9tIHRoZVxuICogbXV0YXRpb25zIHRoYXQgZG8gbm90IGhhdmUgcGF5bG9hZHMuXG4gKi9cbnR5cGUgV3JhcHBlZE11dGF0aW9uSGFuZGxlcjxUTXV0YXRpb24+ID0gVE11dGF0aW9uIGV4dGVuZHMgKHN0b3JlOiBhbnkpID0+IHZvaWRcbiAgPyAoKSA9PiBSZXR1cm5UeXBlPFRNdXRhdGlvbj5cbiAgOiAocGF5bG9hZDogUGF5bG9hZDxUTXV0YXRpb24+KSA9PiBQYXlsb2FkUmV0dXJuPFRNdXRhdGlvbj47XG5cbi8qKlxuICogUHJvdmlkZXMgYSBnZW5lcmljIGludGVyZmFjZSBmb3IgYSBtdXRhdGlvbiBldmVudC1saXN0ZW5lciBmdW5jdGlvbi5cbiAqL1xudHlwZSBNdXRhdGlvbkxpc3RlbmVySGFuZGxlcjxUTXV0YXRpb24+ID0gVE11dGF0aW9uIGV4dGVuZHMgKHN0b3JlOiBhbnkpID0+IHZvaWRcbiAgPyAoKSA9PiB2b2lkXG4gIDogKHBheWxvYWQ6IFBheWxvYWQ8VE11dGF0aW9uPikgPT4gdm9pZDtcblxuLyoqXG4gKiBXcmFwcyBtdXRhdGlvbiBhY2Nlc3NvcnMgdG8gY3JlYXRlIGEgc2V0IG9mIG11dGF0aW9uIHByb3hpZXMuXG4gKlxuICogWWV0IGFub3RoZXIgZnVuY3Rpb24gdGhhdCBieXBhc3NlcyB0aGUgdHlwZSBzeXN0ZW0gZm9yIGNvbnZlbmllbmNlLiBUaGlzXG4gKiBmdW5jdGlvbiBkb2VzIHdoYXQgaXQgY2xhaW1zIHRvIGRvLCBidXQgaGFzIHRvIHRlbGwgVHlwZVNjcmlwdCB0byB0cnVzdCB0aGF0XG4gKiB3ZSBrbm93IHdoYXQgd2UgYXJlIGRvaW5nLiBBcyBhbHdheXMsIGNoYW5nZSB0aGlzIGZ1bmN0aW9uIHdpdGggY2F1dGlvbixcbiAqIGJlY2F1c2UgaWYgdGhpcyBmdW5jdGlvbiBicmVha3MgdGhlbiB3ZSBsb3NlIEludGVsbGlTZW5zZSBhcm91bmQgbXV0YXRpb25zLlxuICpcbiAqIEBwYXJhbSBvbk11dGF0ZSBUaGUgbXV0YXRpb24gZnVuY3Rpb24gZnJvbSB0aGUgc3RvcmUuXG4gKiBAcGFyYW0gYWNjZXNzb3JzIFRoZSBhY2Nlc3NvciBmdW5jdGlvbnMuXG4gKiBAcGFyYW0gc3RvcmUgVGhlIHN0b3JlIHRvIHdyYXAgbXV0YXRpb25zIGFyb3VuZC5cbiAqIEBwYXJhbSBtdXRhdGlvbnMgVGhlIG11dGF0aW9uIGFjY2Vzc29ycyB0byB3cmFwLlxuICovXG5leHBvcnQgZnVuY3Rpb24gd3JhcE11dGF0aW9uczxcbiAgVFJvb3RTdGF0ZSxcbiAgVE11dGF0aW9ucyBleHRlbmRzIG9iamVjdCxcbiAgVFdyYXBwZWRNdXRhdGlvbnMgPSBXcmFwcGVkTXV0YXRpb25zPFRNdXRhdGlvbnM+XG4+KFxuICBuYW1lc3BhY2U6IHN0cmluZyxcbiAgc3RvcmU6IFZ1ZXhTdG9yZTxUUm9vdFN0YXRlPixcbiAgbXV0YXRpb25zOiBUTXV0YXRpb25zXG4pOiBUV3JhcHBlZE11dGF0aW9ucyB7XG4gIHJldHVybiBPYmplY3QuZW50cmllcyhtdXRhdGlvbnMpLnJlZHVjZSgoY29tbWl0LCBba2V5LCBtdXRhdGlvbl0pID0+IHtcbiAgICAvLyBHZXQgdGhlIGtleSB0aGF0IFZ1ZXgga25vd3MgdGhpcyBtdXRhdGlvbiBieS5cbiAgICBjb25zdCBtdXRhdGlvbktleSA9IHF1YWxpZnlLZXkobXV0YXRpb24sIG5hbWVzcGFjZSk7XG5cbiAgICAvLyBQcmVwYXJlIHRoZSBmdW5jdGlvbi9saXN0ZW5lcnMgdG8gZ2l2ZSBiYWNrIHRvIHRoZSBzdG9yZS5cbiAgICB0eXBlIFRNdXRhdGlvbkhhbmRsZXIgPSBXcmFwcGVkTXV0YXRpb25IYW5kbGVyPHR5cGVvZiBtdXRhdGlvbj4gJlxuICAgICAgUGFydGlhbDx0eXBlb2YgbXV0YXRpb24+O1xuXG4gICAgY29uc3QgZGVmZXJyZWQ6IFRNdXRhdGlvbkhhbmRsZXIgPSBwYXlsb2FkID0+XG4gICAgICBzdG9yZS5jb21taXQobXV0YXRpb25LZXksIHBheWxvYWQsIHsgcm9vdDogdHJ1ZSB9KTtcblxuICAgIGRlZmVycmVkLmxpc3RlbiA9IChoYW5kbGVyOiBNdXRhdGlvbkxpc3RlbmVySGFuZGxlcjx0eXBlb2YgbXV0YXRpb24+KSA9PlxuICAgICAgc3RvcmUuc3Vic2NyaWJlKCh7IHR5cGUsIHBheWxvYWQgfSkgPT4ge1xuICAgICAgICBpZiAodHlwZSA9PT0gbXV0YXRpb25LZXkpIHtcbiAgICAgICAgICAoaGFuZGxlciBhcyBhbnkpLmNhbGwobnVsbCwgcGF5bG9hZCk7XG4gICAgICAgIH1cbiAgICAgIH0pO1xuXG4gICAgLy8gQXR0YWNoIHRoZSBkZWZlcm1lbnQgdG8gdGhlIGNvbW1pdCBmdW5jdGlvbi5cbiAgICByZXR1cm4gT2JqZWN0LmRlZmluZVByb3BlcnR5KGNvbW1pdCwga2V5LCB7IHZhbHVlOiBkZWZlcnJlZCB9KTtcbiAgfSwge30pIGFzIFRXcmFwcGVkTXV0YXRpb25zO1xufVxuIl19