vuex-tstore
Version:
Provides a low-overhead TypeScript wrapper around Vuex that can trigger compilation errors and IntelliSense tips.
44 lines • 6.64 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.wrapGetters = void 0;
const util_1 = require("./util");
/**
* Converts a dictionary of GetAccessors into a WrappedGetters implementation.
*
* This looks like a scary way to handle this, but it works. I'm explicitly
* choosing to bypass the type system to tell the compiler "trust me, this
* does what we expect it to do" in order to avoid having to make an already
* complex type system *even more* complex. Basically, we're creating a wrapper
* around the getters so that they don't need to reference the store all
* the time.
*
* @param store Provides a reference to the store to execute getters against.
* @param getters Provides a reference to the getter definitions to create wrappers around.
*
* ```typescript
* import { Store } from 'vuex';
* import { wrapGetters } from 'vuex-tstore';
*
* const options = {
* getters: {
* foo(state) { return 'bar'; },
* hello(state) { return (name: string) => `Hello, ${name}`; },
* },
* };
*
* const store = new Store(options);
* const getters = wrapGetters(store, options.getters);
*
* getters.foo; // 'bar'
* getters.hello('world'); // 'Hello, world'
* ```
*/
function wrapGetters(namespace, store, options) {
return Object.entries(options).reduce((getters, [key, getter]) => {
return Object.defineProperty(getters, key, {
get: () => store.getters[util_1.qualifyKey(getter, namespace)]
});
}, {});
}
exports.wrapGetters = wrapGetters;
//# sourceMappingURL=data:application/json;base64,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