/**
* Takes the properties on object from parameter source and adds them to the object
* parameter target
* @param {object} target Object to have properties copied onto from y
* @param {object} source Object with properties to be copied to x
*/
function addPropertiesToObject(target, source) {
var _loop_1 = function (k) {
Object.defineProperty(target, k, {
get: function () { return source[k]; }
});
};
for (var _i = 0, _a = Object.keys(source || {}); _i < _a.length; _i++) {
var k = _a[_i];
_loop_1(k);
}
}
/**
* Returns a namespaced name of the module to be used as a store getter
* @param module
*/
function getModuleName(module) {
if (!module._vmdModuleName) {
throw new Error("ERR_GET_MODULE_NAME : Could not get module accessor.\n Make sure your module has name, we can't make accessors for unnamed modules\n i.e. @Module({ name: 'something' })");
}
return "vuexModuleDecorators/".concat(module._vmdModuleName);
}
var VuexModule = /** @class */ (function () {
function VuexModule(module) {
this.actions = module.actions;
this.mutations = module.mutations;
this.state = module.state;
this.getters = module.getters;
this.namespaced = module.namespaced;
this.modules = module.modules;
}
return VuexModule;
}());
function getModule(moduleClass, store) {
var moduleName = getModuleName(moduleClass);
if (store && store.getters[moduleName]) {
return store.getters[moduleName];
}
else if (moduleClass._statics) {
return moduleClass._statics;
}
var genStatic = moduleClass._genStatic;
if (!genStatic) {
throw new Error("ERR_GET_MODULE_NO_STATICS : Could not get module accessor.\n Make sure your module has name, we can't make accessors for unnamed modules\n i.e. @Module({ name: 'something' })");
}
var storeModule = genStatic(store);
if (store) {
store.getters[moduleName] = storeModule;
}
else {
moduleClass._statics = storeModule;
}
return storeModule;
}
var reservedKeys = ['actions', 'getters', 'mutations', 'modules', 'state', 'namespaced', 'commit'];
function stateFactory(module) {
var state = new module.prototype.constructor({});
var s = {};
Object.keys(state).forEach(function (key) {
if (reservedKeys.indexOf(key) !== -1) {
if (typeof state[key] !== 'undefined') {
throw new Error("ERR_RESERVED_STATE_KEY_USED: You cannot use the following\n ['actions', 'getters', 'mutations', 'modules', 'state', 'namespaced', 'commit']\n as fields in your module. These are reserved as they have special purpose in Vuex");
}
return;
}
if (state.hasOwnProperty(key)) {
if (typeof state[key] !== 'function') {
s[key] = state[key];
}
}
});
return s;
}
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
function __spreadArray(to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
}
function staticStateGenerator(module, modOpt, statics) {
var state = modOpt.stateFactory ? module.state() : module.state;
Object.keys(state).forEach(function (key) {
if (state.hasOwnProperty(key)) {
// If not undefined or function means it is a state value
if (['undefined', 'function'].indexOf(typeof state[key]) === -1) {
Object.defineProperty(statics, key, {
get: function () {
var path = modOpt.name.split('/');
var data = statics.store.state;
for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {
var segment = path_1[_i];
data = data[segment];
}
return data[key];
}
});
}
}
});
}
function staticGetterGenerator(module, modOpt, statics) {
Object.keys(module.getters).forEach(function (key) {
if (module.namespaced) {
Object.defineProperty(statics, key, {
get: function () {
return statics.store.getters["".concat(modOpt.name, "/").concat(key)];
}
});
}
else {
Object.defineProperty(statics, key, {
get: function () {
return statics.store.getters[key];
}
});
}
});
}
function staticMutationGenerator(module, modOpt, statics) {
Object.keys(module.mutations).forEach(function (key) {
if (module.namespaced) {
statics[key] = function () {
var _a;
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
(_a = statics.store).commit.apply(_a, __spreadArray(["".concat(modOpt.name, "/").concat(key)], args, false));
};
}
else {
statics[key] = function () {
var _a;
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
(_a = statics.store).commit.apply(_a, __spreadArray([key], args, false));
};
}
});
}
function staticActionGenerators(module, modOpt, statics) {
Object.keys(module.actions).forEach(function (key) {
if (module.namespaced) {
statics[key] = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return __awaiter(this, void 0, void 0, function () {
var _a;
return __generator(this, function (_b) {
return [2 /*return*/, (_a = statics.store).dispatch.apply(_a, __spreadArray(["".concat(modOpt.name, "/").concat(key)], args, false))];
});
});
};
}
else {
statics[key] = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return __awaiter(this, void 0, void 0, function () {
var _a;
return __generator(this, function (_b) {
return [2 /*return*/, (_a = statics.store).dispatch.apply(_a, __spreadArray([key], args, false))];
});
});
};
}
});
}
function registerDynamicModule(module, modOpt) {
if (!modOpt.name) {
throw new Error('Name of module not provided in decorator options');
}
if (!modOpt.store) {
throw new Error('Store not provided in decorator options when using dynamic option');
}
modOpt.store.registerModule(modOpt.name, // TODO: Handle nested modules too in future
module, { preserveState: modOpt.preserveState || false });
}
function addGettersToModule(targetModule, srcModule) {
Object.getOwnPropertyNames(srcModule.prototype).forEach(function (funcName) {
var descriptor = Object.getOwnPropertyDescriptor(srcModule.prototype, funcName);
if (descriptor.get && targetModule.getters) {
targetModule.getters[funcName] = function (state, getters, rootState, rootGetters) {
var thisObj = { context: { state: state, getters: getters, rootState: rootState, rootGetters: rootGetters } };
addPropertiesToObject(thisObj, state);
addPropertiesToObject(thisObj, getters);
var got = descriptor.get.call(thisObj);
return got;
};
}
});
}
function moduleDecoratorFactory(moduleOptions) {
return function (constructor) {
var module = constructor;
var stateFactory$1 = function () { return stateFactory(module); };
if (!module.state) {
module.state = moduleOptions && moduleOptions.stateFactory ? stateFactory$1 : stateFactory$1();
}
if (!module.getters) {
module.getters = {};
}
if (!module.namespaced) {
module.namespaced = moduleOptions && moduleOptions.namespaced;
}
var parentModule = Object.getPrototypeOf(module);
while (parentModule.name !== 'VuexModule' && parentModule.name !== '') {
addGettersToModule(module, parentModule);
parentModule = Object.getPrototypeOf(parentModule);
}
addGettersToModule(module, module);
var modOpt = moduleOptions;
if (modOpt.name) {
Object.defineProperty(constructor, '_genStatic', {
value: function (store) {
var statics = { store: store || modOpt.store };
if (!statics.store) {
throw new Error("ERR_STORE_NOT_PROVIDED: To use getModule(), either the module\n should be decorated with store in decorator, i.e. @Module({store: store}) or\n store should be passed when calling getModule(), i.e. getModule(MyModule, this.$store)");
}
// =========== For statics ==============
// ------ state -------
staticStateGenerator(module, modOpt, statics);
// ------- getters -------
if (module.getters) {
staticGetterGenerator(module, modOpt, statics);
}
// -------- mutations --------
if (module.mutations) {
staticMutationGenerator(module, modOpt, statics);
}
// -------- actions ---------
if (module.actions) {
staticActionGenerators(module, modOpt, statics);
}
return statics;
}
});
Object.defineProperty(constructor, '_vmdModuleName', {
value: modOpt.name
});
}
if (modOpt.dynamic) {
registerDynamicModule(module, modOpt);
}
return constructor;
};
}
function Module(modOrOpt) {
if (typeof modOrOpt === 'function') {
/*
* @Module decorator called without options (directly on the class definition)
*/
moduleDecoratorFactory({})(modOrOpt);
}
else {
/*
* @Module({...}) decorator called with options
*/
return moduleDecoratorFactory(modOrOpt);
}
}
var config = {};
function actionDecoratorFactory(params) {
var _a = params || {}, _b = _a.commit, commit = _b === void 0 ? undefined : _b, _c = _a.rawError, rawError = _c === void 0 ? !!config.rawError : _c, _d = _a.root, root = _d === void 0 ? false : _d;
return function (target, key, descriptor) {
var module = target.constructor;
if (!module.hasOwnProperty('actions')) {
module.actions = Object.assign({}, module.actions);
}
var actionFunction = descriptor.value;
var action = function (context, payload) {
return __awaiter(this, void 0, void 0, function () {
var actionPayload, moduleName, moduleAccessor, thisObj, e_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 5, , 6]);
actionPayload = null;
if (!module._genStatic) return [3 /*break*/, 2];
moduleName = getModuleName(module);
moduleAccessor = context.rootGetters[moduleName]
? context.rootGetters[moduleName]
: getModule(module);
moduleAccessor.context = context;
return [4 /*yield*/, actionFunction.call(moduleAccessor, payload)];
case 1:
actionPayload = _a.sent();
return [3 /*break*/, 4];
case 2:
thisObj = { context: context };
addPropertiesToObject(thisObj, context.state);
addPropertiesToObject(thisObj, context.getters);
return [4 /*yield*/, actionFunction.call(thisObj, payload)];
case 3:
actionPayload = _a.sent();
_a.label = 4;
case 4:
if (commit) {
context.commit(commit, actionPayload);
}
return [2 /*return*/, actionPayload];
case 5:
e_1 = _a.sent();
throw rawError
? e_1
: new Error('ERR_ACTION_ACCESS_UNDEFINED: Are you trying to access ' +
'this.someMutation() or this.someGetter inside an @Action? \n' +
'That works only in dynamic modules. \n' +
'If not dynamic use this.context.commit("mutationName", payload) ' +
'and this.context.getters["getterName"]' +
'\n' +
new Error("Could not perform action ".concat(key.toString())).stack +
'\n' +
e_1.stack);
case 6: return [2 /*return*/];
}
});
});
};
module.actions[key] = root ? { root: root, handler: action } : action;
};
}
/**
* The @Action decorator turns an async function into an Vuex action
*
* @param targetOrParams the module class
* @param key name of the action
* @param descriptor the action function descriptor
* @constructor
*/
function Action(targetOrParams, key, descriptor) {
if (!key && !descriptor) {
/*
* This is the case when `targetOrParams` is params.
* i.e. when used as -
*
@Action({commit: 'incrCount'})
async getCountDelta() {
return 5
}
*
*/
return actionDecoratorFactory(targetOrParams);
}
else {
/*
* This is the case when @Action is called on action function
* without any params
*
* @Action
* async doSomething() {
* ...
* }
*
*/
actionDecoratorFactory()(targetOrParams, key, descriptor);
}
}
function Mutation(target, key, descriptor) {
var module = target.constructor;
if (!module.hasOwnProperty('mutations')) {
module.mutations = Object.assign({}, module.mutations);
}
var mutationFunction = descriptor.value;
var mutation = function (state, payload) {
mutationFunction.call(state, payload);
};
module.mutations[key] = mutation;
}
function mutationActionDecoratorFactory(params) {
return function (target, key, descriptor) {
var module = target.constructor;
if (!module.hasOwnProperty('mutations')) {
module.mutations = Object.assign({}, module.mutations);
}
if (!module.hasOwnProperty('actions')) {
module.actions = Object.assign({}, module.actions);
}
var mutactFunction = descriptor.value;
var action = function (context, payload) {
return __awaiter(this, void 0, void 0, function () {
var thisObj, actionPayload, e_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 2, , 3]);
thisObj = { context: context };
addPropertiesToObject(thisObj, context.state);
addPropertiesToObject(thisObj, context.getters);
return [4 /*yield*/, mutactFunction.call(thisObj, payload)];
case 1:
actionPayload = _a.sent();
if (actionPayload === undefined)
return [2 /*return*/];
context.commit(key, actionPayload);
return [3 /*break*/, 3];
case 2:
e_1 = _a.sent();
if (params.rawError) {
throw e_1;
}
else {
console.error('Could not perform action ' + key.toString());
console.error(e_1);
return [2 /*return*/, Promise.reject(e_1)];
}
case 3: return [2 /*return*/];
}
});
});
};
var mutation = function (state, payload) {
if (!params.mutate) {
params.mutate = Object.keys(payload);
}
for (var _i = 0, _a = params.mutate; _i < _a.length; _i++) {
var stateItem = _a[_i];
if (state.hasOwnProperty(stateItem) && payload.hasOwnProperty(stateItem)) {
state[stateItem] = payload[stateItem];
}
else {
throw new Error("ERR_MUTATE_PARAMS_NOT_IN_PAYLOAD\n In @MutationAction, mutate: ['a', 'b', ...] array keys must\n match with return type = {a: {}, b: {}, ...} and must\n also be in state.");
}
}
};
module.actions[key] = params.root ? { root: true, handler: action } : action;
module.mutations[key] = mutation;
};
}
/**
* The @MutationAction decorator turns this into an action that further calls a mutation
* Both the action and the mutation are generated for you
*
* @param paramsOrTarget the params or the target class
* @param key the name of the function
* @param descriptor the function body
* @constructor
*/
function MutationAction(paramsOrTarget, key, descriptor) {
if (!key && !descriptor) {
/*
* This is the case when `paramsOrTarget` is params.
* i.e. when used as -
*
@MutationAction({mutate: ['incrCount']})
async getCountDelta() {
return {incrCount: 5}
}
*
*/
return mutationActionDecoratorFactory(paramsOrTarget);
}
else {
/*
* This is the case when `paramsOrTarget` is target.
* i.e. when used as -
*
@MutationAction
async getCountDelta() {
return {incrCount: 5}
}
*
*/
mutationActionDecoratorFactory({})(paramsOrTarget, key, descriptor);
}
}
export { Action, Module, Mutation, MutationAction, VuexModule, config, getModule };
//# sourceMappingURL=index.js.map