vuex-tstore
Version:
Provides a low-overhead TypeScript wrapper around Vuex that can trigger compilation errors and IntelliSense tips.
57 lines • 9.14 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.wrapActions = void 0;
const util_1 = require("./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>
* ```
*/
function wrapActions(namespace, store, actions) {
return Object.entries(actions).reduce((dispatch, [key, action]) => {
// Get the key that Vuex knows this action by.
const actionKey = util_1.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 });
}, {});
}
exports.wrapActions = wrapActions;
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIuL3NyYy8iLCJzb3VyY2VzIjpbImFjdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBSUEsaUNBQTREO0FBaUQ1RDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBMkJHO0FBQ0gsU0FBZ0IsV0FBVyxDQUt6QixTQUFpQixFQUNqQixLQUE0QixFQUM1QixPQUFpQjtJQUVqQixPQUFPLE1BQU0sQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsUUFBUSxFQUFFLENBQUMsR0FBRyxFQUFFLE1BQU0sQ0FBQyxFQUFFLEVBQUU7UUFDaEUsOENBQThDO1FBQzlDLE1BQU0sU0FBUyxHQUFHLGlCQUFVLENBQUMsTUFBTSxFQUFFLFNBQVMsQ0FBQyxDQUFDO1FBS2hELE1BQU0sUUFBUSxHQUFtQixPQUFPLENBQUMsRUFBRSxDQUN6QyxLQUFLLENBQUMsUUFBUSxDQUFDLFNBQVMsRUFBRSxPQUFPLEVBQUUsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUVyRCxRQUFRLENBQUMsTUFBTSxHQUFHLENBQUMsT0FBNkMsRUFBRSxFQUFFLENBQ2xFLEtBQUssQ0FBQyxlQUFlLENBQUM7WUFDcEIsTUFBTSxFQUFFLENBQUMsRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLEVBQUUsRUFBRTtnQkFDNUIsSUFBSSxJQUFJLEtBQUssU0FBUyxFQUFFO29CQUNyQixPQUFlLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxPQUFPLENBQUMsQ0FBQztpQkFDdEM7WUFDSCxDQUFDO1NBQ0YsQ0FBQyxDQUFDO1FBQ0wsUUFBUSxDQUFDLEtBQUssR0FBRyxDQUFDLE9BQTZDLEVBQUUsRUFBRSxDQUNqRSxLQUFLLENBQUMsZUFBZSxDQUFDO1lBQ3BCLEtBQUssRUFBRSxDQUFDLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxFQUFFLEVBQUU7Z0JBQzNCLElBQUksSUFBSSxLQUFLLFNBQVMsRUFBRTtvQkFDckIsT0FBZSxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUM7aUJBQ3RDO1lBQ0gsQ0FBQztTQUNGLENBQUMsQ0FBQztRQUVMLGlEQUFpRDtRQUNqRCxPQUFPLE1BQU0sQ0FBQyxjQUFjLENBQUMsUUFBUSxFQUFFLEdBQUcsRUFBRSxFQUFFLEtBQUssRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBQ25FLENBQUMsRUFBRSxFQUFFLENBQW9CLENBQUM7QUFDNUIsQ0FBQztBQXZDRCxrQ0F1Q0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIERlZmluZXMgaG93IHRvIG1hbmFnZSBhY3Rpb24gcHJveGllcy5cbiAqL1xuaW1wb3J0IHsgU3RvcmUgYXMgVnVleFN0b3JlIH0gZnJvbSBcInZ1ZXhcIjtcbmltcG9ydCB7IFBheWxvYWQsIFBheWxvYWRSZXR1cm4sIHF1YWxpZnlLZXkgfSBmcm9tIFwiLi91dGlsXCI7XG5cbi8qKlxuICogRXh0cmFjdHMgYW4gaW50ZXJmYWNlIGZvciB3cmFwcGVkIGFjdGlvbiBhY2Nlc3NvcnMuXG4gKlxuICogVGhpcyBzb21ld2hhdCBiZWFzdGx5IGxvb2tpbmcgdGVtcGxhdGUgaXMgdXNlZCB0byBnZW5lcmF0ZSBhbiBpbnRlcmZhY2UgZm9yXG4gKiBhIHdyYXBwZXIgYXJvdW5kIGEgYWN0aW9uIG9iamVjdC4gVGhhdCBpcywgZ2l2ZW4gYW4gb2JqZWN0IHdoZXJlIGVhY2hcbiAqIHByb3BlcnR5IGlzIGEgZnVuY3Rpb24gaW4gdGhlIGZvcm0gYChzdG9yZSwgcGF5bG9hZD8pID0+IHZvaWRgLCBhIHdyYXBwZXJcbiAqIGNvdWxkIGJlIG1hZGUgd2l0aCBtYXRjaGluZyBwcm9wZXJ0aWVzIHdoZXJlIGVhY2ggcHJvcGVydHkgaXMgaW4gdGhlIGZvcm1cbiAqIGAocGF5bG9hZD8pID0+IHZvaWRgLiBJbiBzdWNoIGFuIG9iamVjdCwgdGhlIGBzdG9yZWAgYXJndW1lbnQgc2hvdWxkIGJlXG4gKiBhdXRvbWF0aWNhbGx5IGZpbGxlZCBpbiB3aXRoIHRoZSBzdG9yZSBvYmplY3QgYmVpbmcgd3JhcHBlZC5cbiAqXG4gKiBHaXZlbiBhbiBvYmplY3Qgb2YgdHlwZSBgVEFjdGlvbnNgIChiZWxvdyksIHRoaXMgdHlwZSByZWZsZWN0cyBhbiBpbnRlcmZhY2VcbiAqIG9mIHR5cGUgYFRXcmFwcGVkQWN0aW9uc2AgKGJlbG93KS5cbiAqXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBpbnRlcmZhY2UgVEFjdGlvbnMge1xuICogICBba2V5OiBzdHJpbmcgfCBudW1iZXIgfCBTeW1ib2xdOiAoY29udGV4dDogVENvbnRleHQsIHBheWxvYWQ/OiBUUGF5bG9hZCkgPT4gVFJlc3VsdFxuICogfVxuICpcbiAqIHR5cGUgVFdyYXBwZWRBY3Rpb25zID0ge1xuICogICBba2V5IGluIGtleW9mIFRBY3Rpb25zXTogKHBheWxvYWQ/OiBUUGF5bG9hZCkgPT4gVFJlc3VsdFxuICogfVxuICogYGBgXG4gKi9cbmV4cG9ydCBkZWNsYXJlIHR5cGUgV3JhcHBlZEFjdGlvbnM8VEFjdGlvbnM+ID0ge1xuICBbS2V5IGluIGtleW9mIFRBY3Rpb25zXTogV3JhcHBlZEFjdGlvbkhhbmRsZXI8VEFjdGlvbnNbS2V5XT4gJiB7XG4gICAgYWZ0ZXIoaGFuZGxlcjogQWN0aW9uTGlzdGVuZXJIYW5kbGVyPFRBY3Rpb25zW0tleV0+KTogKCkgPT4gdm9pZDtcbiAgICBiZWZvcmUoaGFuZGxlcjogQWN0aW9uTGlzdGVuZXJIYW5kbGVyPFRBY3Rpb25zW0tleV0+KTogKCkgPT4gdm9pZDtcbiAgfVxufTtcblxuLyoqXG4gKiBQcm92aWRlcyBhIGdlbmVyaWMgaW50ZXJmYWNlIGZvciBhIHdyYXBwZXIgYXJvdW5kIGEgYFRBY3Rpb25gIGZ1bmN0aW9uLlxuICpcbiAqIFRoaXMgYXV0b21hdGljYWxseSBkaWZmZXJlbnRpYXRlcyB0aGUgYWN0aW9ucyB0aGF0IGhhdmUgcGF5bG9hZHMgZnJvbSB0aGVcbiAqIGFjdGlvbnMgdGhhdCBkbyBub3QgaGF2ZSBwYXlsb2Fkcy5cbiAqL1xudHlwZSBXcmFwcGVkQWN0aW9uSGFuZGxlcjxUQWN0aW9uPiA9IFRBY3Rpb24gZXh0ZW5kcyAoc3RvcmU6IGFueSkgPT4gYW55XG4gID8gKCkgPT4gUmV0dXJuVHlwZTxUQWN0aW9uPlxuICA6IChwYXlsb2FkOiBQYXlsb2FkPFRBY3Rpb24+KSA9PiBQYXlsb2FkUmV0dXJuPFRBY3Rpb24+O1xuXG4vKipcbiAqIFByb3ZpZGVzIGEgZ2VuZXJpYyBpbnRlcmZhY2UgZm9yIGFuIGFjdGlvbiBldmVudC1saXN0ZW5lciBmdW5jdGlvbi5cbiAqL1xudHlwZSBBY3Rpb25MaXN0ZW5lckhhbmRsZXI8VEFjdGlvbj4gPSBUQWN0aW9uIGV4dGVuZHMgKHN0b3JlOiBhbnkpID0+IGFueVxuICA/ICgpID0+IHZvaWRcbiAgOiAocGF5bG9hZDogUGF5bG9hZDxUQWN0aW9uPikgPT4gdm9pZDtcblxuLyoqXG4gKiBXcmFwcyBhY3Rpb25zIGFjY2Vzc29ycyB0byBjcmVhdGUgYSBzZXQgb2YgYWN0aW9uIHByb3hpZXMuXG4gKlxuICogVGhpcyBmdW5jdGlvbiAqbG9va3MqIGFyY2FuZSwgYnV0IGRvZXMgZXhhY3RseSB3aGF0IGl0IGNsYWltcyB0byBkby4gSXQnc1xuICogd3JpdHRlbiB0aGlzIHdheSBiZWNhdXNlIHRoaXMgeWllbGRzIHByZWNpc2VseSB0aGUgZGVzaXJlZCByZXN1bHRzIHdlIHdhbnQsXG4gKiBidXQgd2l0aG91dCBuZWVkaW5nIHRvIGZpZ2h0IFR5cGVTY3JpcHQgdG8gZG8gaXQuXG4gKlxuICogQHBhcmFtIHN0b3JlIFRoZSBzdG9yZSB0byB3cmFwIGFjdGlvbiBhcm91bmQuXG4gKiBAcGFyYW0gYWN0aW9ucyBUaGUgYWN0aW9uIGFjY2Vzc29ycyB0byB3cmFwLlxuICpcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIGltcG9ydCB7IFN0b3JlIH0gZnJvbSAndnVleCc7XG4gKiBpbXBvcnQgeyB3cmFwQWN0aW9ucyB9IGZyb20gJ3Z1ZXgtdHN0b3JlJztcbiAqXG4gKiBjb25zdCBvcHRpb25zID0ge1xuICogICBhY3Rpb25zOiB7XG4gKiAgICAgYXN5bmMgd2l0aEZvbyhzdG9yZSwgcGF5bG9hZDogeyBmb286IHN0cmluZyB9KSB7fSxcbiAqICAgICBhc3luYyB3aXRob3V0Rm9vKHN0b3JlKSB7fSxcbiAqICAgfSxcbiAqIH07XG4gKlxuICogY29uc3Qgc3RvcmUgPSBuZXcgU3RvcmUob3B0aW9ucyk7XG4gKiBjb25zdCBhY3Rpb25zID0gd3JhcEFjdGlvbnMoc3RvcmUsIG9wdGlvbnMuYWN0aW9ucyk7XG4gKlxuICogYWN0aW9ucy53aXRoRm9vKHsgZm9vOiAnZm9vJyB9KTsgLy8gUHJvbWlzZTx2b2lkPlxuICogYWN0aW9ucy53aXRob3V0Rm9vKCk7ICAgICAgICAgICAgLy8gUHJvbWlzZTx2b2lkPlxuICogYGBgXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB3cmFwQWN0aW9uczxcbiAgVFJvb3RTdGF0ZSxcbiAgVEFjdGlvbnMgZXh0ZW5kcyBvYmplY3QsXG4gIFRXcmFwcGVkQWN0aW9ucyA9IFdyYXBwZWRBY3Rpb25zPFRBY3Rpb25zPlxuPihcbiAgbmFtZXNwYWNlOiBzdHJpbmcsXG4gIHN0b3JlOiBWdWV4U3RvcmU8VFJvb3RTdGF0ZT4sXG4gIGFjdGlvbnM6IFRBY3Rpb25zXG4pOiBUV3JhcHBlZEFjdGlvbnMge1xuICByZXR1cm4gT2JqZWN0LmVudHJpZXMoYWN0aW9ucykucmVkdWNlKChkaXNwYXRjaCwgW2tleSwgYWN0aW9uXSkgPT4ge1xuICAgIC8vIEdldCB0aGUga2V5IHRoYXQgVnVleCBrbm93cyB0aGlzIGFjdGlvbiBieS5cbiAgICBjb25zdCBhY3Rpb25LZXkgPSBxdWFsaWZ5S2V5KGFjdGlvbiwgbmFtZXNwYWNlKTtcblxuICAgIC8vIFByZXBhcmUgdGhlIGZ1bmN0aW9uL2xpc3RlbmVycyB0byBnaXZlIGJhY2sgdG8gdGhlIHN0b3JlLlxuICAgIHR5cGUgVEFjdGlvbkhhbmRsZXIgPSBXcmFwcGVkQWN0aW9uSGFuZGxlcjx0eXBlb2YgYWN0aW9uPiAmXG4gICAgICBQYXJ0aWFsPHR5cGVvZiBhY3Rpb24+O1xuICAgIGNvbnN0IGRlZmVycmVkOiBUQWN0aW9uSGFuZGxlciA9IHBheWxvYWQgPT5cbiAgICAgIHN0b3JlLmRpc3BhdGNoKGFjdGlvbktleSwgcGF5bG9hZCwgeyByb290OiB0cnVlIH0pO1xuXG4gICAgZGVmZXJyZWQuYmVmb3JlID0gKGhhbmRsZXI6IEFjdGlvbkxpc3RlbmVySGFuZGxlcjx0eXBlb2YgYWN0aW9uPikgPT5cbiAgICAgIHN0b3JlLnN1YnNjcmliZUFjdGlvbih7XG4gICAgICAgIGJlZm9yZTogKHsgdHlwZSwgcGF5bG9hZCB9KSA9PiB7XG4gICAgICAgICAgaWYgKHR5cGUgPT09IGFjdGlvbktleSkge1xuICAgICAgICAgICAgKGhhbmRsZXIgYXMgYW55KS5jYWxsKG51bGwsIHBheWxvYWQpO1xuICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgfSk7XG4gICAgZGVmZXJyZWQuYWZ0ZXIgPSAoaGFuZGxlcjogQWN0aW9uTGlzdGVuZXJIYW5kbGVyPHR5cGVvZiBhY3Rpb24+KSA9PlxuICAgICAgc3RvcmUuc3Vic2NyaWJlQWN0aW9uKHtcbiAgICAgICAgYWZ0ZXI6ICh7IHR5cGUsIHBheWxvYWQgfSkgPT4ge1xuICAgICAgICAgIGlmICh0eXBlID09PSBhY3Rpb25LZXkpIHtcbiAgICAgICAgICAgIChoYW5kbGVyIGFzIGFueSkuY2FsbChudWxsLCBwYXlsb2FkKTtcbiAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICAgIH0pO1xuXG4gICAgLy8gQXR0YWNoIHRoZSBkZWZlcm1lbnQgdG8gdGhlIGRpc3BhdGNoIGZ1bmN0aW9uLlxuICAgIHJldHVybiBPYmplY3QuZGVmaW5lUHJvcGVydHkoZGlzcGF0Y2gsIGtleSwgeyB2YWx1ZTogZGVmZXJyZWQgfSk7XG4gIH0sIHt9KSBhcyBUV3JhcHBlZEFjdGlvbnM7XG59XG4iXX0=