@nimel/directorr
Version:
Like Redux but using decorators
1,115 lines (1,092 loc) • 66.3 kB
JavaScript
/* (c) Nikita Melnikov - MIT Licensed 2020 - now */
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = global || self, factory(global.index = {}));
}(this, (function (exports) { 'use strict';
var errorWhenWrongEnv = function () {
return "Directorr requires Symbol and Map objects. If your environment doesn't support, magic won`t work.";
};
var notFindStoreName = function () { return 'Store name not found'; };
var notObserver = function () { return 'Expected the observer to be an object'; };
var callWithArg = function (moduleName, arg, errorMessage) {
return "".concat(moduleName, ": call decorator with arg=").concat(arg, " ").concat(errorMessage);
};
var callDecoratorWithNotActionType = function (moduleName, arg) {
return callWithArg(moduleName, arg, 'not equal to string/class/MSTModel or array of string/class/MSTModel');
};
var callDecoratorWithNotConsrtactorType = function (moduleName, arg) {
return callWithArg(moduleName, arg, 'not constuctor');
};
var callDecoratorWithNotActionChecker = function (moduleName, checker) {
return callWithArg(moduleName, checker, 'not like object or function');
};
var callDecoratorWithNotConvertPayload = function (moduleName, converter) {
return callWithArg(moduleName, converter, 'not like function');
};
var useForNotPropDecorator = function (moduleName, property) {
return "".concat(moduleName, ": use for property=").concat(property, " not like property decorator");
};
var callWithPropNotEquallFunc = function (moduleName, property) {
return "".concat(moduleName, ": use decorator for prop=").concat(property, " equal func");
};
var useForPropNotEquallObject = function (moduleName, property) {
return "".concat(moduleName, ": use decorator for prop=").concat(property, " equal object");
};
var notFoundDirectorrStore = function (moduleName, StoreConstructor) {
return "".concat(moduleName, ": store with constuctor=").concat(StoreConstructor.name, " not add to Dirrector");
};
var notFoundStoreInDirectorrStore = function (moduleName, StoreConstructor, currentStore) {
return "".concat(moduleName, ": for some reason, not found store or model with constuctor=").concat(StoreConstructor.name, ", may be worth adding storage=").concat(StoreConstructor.name, " earlier than the current=").concat(currentStore.name);
};
var callWithNotAction = function (moduleName, action) {
return "".concat(moduleName, ": call with action=").concat(JSON.stringify(action), " not like action type");
};
var dontUseWithAnotherDecorator = function (moduleName) {
return "".concat(moduleName, ": dont use with another decorators");
};
var haveCycleInjectedStore = function (moduleName) {
return "".concat(moduleName, ": call stack out of range, this usually happens with cyclical dependency of injected stores");
};
var callWithStoreNotConnectedToDirrectorr = function (moduleName, store) { var _a; return "".concat(moduleName, ": call with not connected to directorr store=").concat((_a = store === null || store === void 0 ? void 0 : store.construnctor) === null || _a === void 0 ? void 0 : _a.name); };
if (typeof Symbol === 'undefined') {
throw new TypeError(errorWhenWrongEnv());
}
/******************************************************************************
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.
***************************************************************************** */
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
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));
}
var _a;
var EFFECTS_FIELD_NAME = Symbol.for('dirrector: effects');
var DISPATCH_ACTION_FIELD_NAME = Symbol.for('dirrector: dispatchAction');
var DISPATCH_EFFECTS_FIELD_NAME = Symbol.for('dirrector: dispatchEffects');
var STORES_FIELD_NAME = Symbol.for('dirrector: stores');
var INJECTED_STORES_FIELD_NAME = Symbol.for('dirrector: injected stores');
var INJECTED_FROM_FIELD_NAME = Symbol.for('dirrector: injected from stores');
var DEPENDENCY_FIELD_NAME = Symbol.for('dirrector: external dependency');
var TIMERS_FIELD_NAME = Symbol.for('dirrector: timers');
var CLEAR_TIMERS_EFFECT_FIELD_NAME = Symbol.for('dirrector: clear timers');
var SUBSCRIBE_FIELD_NAME = Symbol.for('dirrector: subscribe');
var DISPATHERS_FIELD_NAME = Symbol.for('dirrector: dispatchers');
var DISPATHERS_EFFECT_FIELD_NAME = Symbol.for('dirrector: clear dispatchers');
var EMPTY_FUNC = function () { };
var RETURN_ARG_FUNC = function (a) { return a; };
var TRUPHY_FUNC = function () { return true; };
var EMPTY_STRING = '';
var EMPTY_OBJECT = Object.freeze({});
var DIRECTORR_INIT_STORE_ACTION = '@@DIRECTORR.INIT_STORE';
var DIRECTORR_DESTROY_STORE_ACTION = '@@DIRECTORR.DESTROY_STORE';
var DIRECTORR_RELOAD_STORE_ACTION = '@@DIRECTORR.RELOAD_STORE';
var DIRECTORR_ANY_ACTION_TYPE = '@@DIRECTORR.ANY_ACTION';
var ACTION_TYPE_DIVIDER = '.';
var isDev = process.env.NODE_ENV === 'development';
var TYPEOF = {
STRING: 'string',
};
var DESCRIPTOR = {
writable: false,
enumerable: false,
configurable: true,
value: null,
};
var PROPERTY_DESCRIPTOR = {
enumerable: false,
configurable: true,
get: EMPTY_FUNC,
set: EMPTY_FUNC,
};
function createValueDescriptor(value) {
DESCRIPTOR.value = value;
return DESCRIPTOR;
}
function createPropertyDescriptor(get, set) {
if (get === void 0) { get = EMPTY_FUNC; }
if (set === void 0) { set = EMPTY_FUNC; }
PROPERTY_DESCRIPTOR.get = get;
PROPERTY_DESCRIPTOR.set = set;
return PROPERTY_DESCRIPTOR;
}
var isArray = Array.isArray;
var defineProperty = Object.defineProperty, toString = (_a = Object.prototype, _a.toString), hasOwnPropertyFromPrototype = _a.hasOwnProperty;
function createPromiseCancelable(executor) {
var resolvecb = EMPTY_FUNC;
var rejectcb = EMPTY_FUNC;
var callback = EMPTY_FUNC;
var pending = true;
function whenCancel(cb) {
callback = cb;
}
function resolver(arg) {
pending = false;
return resolvecb(arg);
}
function rejector(arg) {
pending = false;
return rejectcb(arg);
}
function cancel() {
resolvecb(Promise.resolve(undefined));
if (pending)
callback();
}
var promise = new Promise(function (resolve, reject) {
resolvecb = resolve;
rejectcb = reject;
executor(resolver, rejector, whenCancel);
});
promise.cancel = cancel;
return promise;
}
var STRING_OBJECT = '[object Object]';
function isObject(obj) {
return toString.call(obj) === STRING_OBJECT;
}
function isString(str) {
return typeof str === TYPEOF.STRING;
}
// eslint-disable-next-line @typescript-eslint/ban-types
function isFunction(func) {
return !!(func && func.constructor && func.call && func.apply);
}
function isPromise(promise) {
return !!(promise && promise.then && promise.catch);
}
function hasOwnProperty(target, prop) {
return hasOwnPropertyFromPrototype.call(target, prop);
}
function pickSameStore(payload, store) {
return store === payload.store;
}
function isLikeActionType(actionType) {
if (!actionType)
return false;
if (isArray(actionType)) {
if (!actionType.length)
return false;
for (var i = 0, l = actionType.length, at = void 0; i < l; ++i) {
at = actionType[i];
if (!isLikeActionType(at))
return false;
}
return true;
}
return isString(actionType) || isFunction(actionType);
}
function isLikeAction(action) {
if (!action)
return false;
return isObject(action) && action.type !== undefined;
}
function getStoreName(classOrModel) {
if (isFunction(classOrModel))
return classOrModel.storeName || classOrModel.name;
if (classOrModel.constructor)
return getStoreName(classOrModel.constructor);
throw new Error(notFindStoreName());
}
function isDecoratorWithCtx(decorator) {
return !!decorator.type;
}
function calcActionType(someActionType) {
if (isFunction(someActionType)) {
return isDecoratorWithCtx(someActionType) ? someActionType.type : getStoreName(someActionType);
}
return someActionType;
}
function createActionType(actionType, divider) {
if (isArray(actionType)) {
var result = EMPTY_STRING;
for (var i = 0, l = actionType.length, action = void 0, type = void 0; i < l; ++i) {
type = actionType[i];
action = isArray(type) ? createActionType(type, divider) : calcActionType(type);
result += i > 0 ? divider + action : action;
}
return result;
}
return calcActionType(actionType);
}
function batchFunction(f) {
return f;
}
function createAction(type, payload) {
if (payload)
return { type: type, payload: payload };
return { type: type };
}
function isChecker(sample) {
if (!sample)
return false;
return isFunction(sample) || isObject(sample);
}
function isConverter(func) {
return isFunction(func);
}
function dispatchEffects(action) {
var effectsMap = this[EFFECTS_FIELD_NAME];
var effectsForActionType = effectsMap.get(action.type);
if (effectsForActionType) {
for (var i = 0, l = effectsForActionType.length; i < l; ++i) {
this[effectsForActionType[i]](action.payload);
}
}
var effectsForAnyActionType = effectsMap.get(DIRECTORR_ANY_ACTION_TYPE);
if (effectsForAnyActionType) {
for (var i = 0, l = effectsForAnyActionType.length; i < l; ++i) {
this[effectsForAnyActionType[i]](action);
}
}
}
function isLikePropertyDecorator(decorator) {
return !!(decorator === null || decorator === void 0 ? void 0 : decorator.initializer) || !(decorator === null || decorator === void 0 ? void 0 : decorator.value);
}
function createTypescriptDescriptor(descriptor, property, initializer, ctx) {
var key = Symbol.for(property);
var set = descriptor.set, get = descriptor.get;
function newSet(newValue) {
var value;
if (set && get) {
set.call(this, newValue);
value = get.call(this);
}
else {
value = newValue;
}
defineProperty(this, key, createValueDescriptor(initializer(this, value, property, ctx)));
}
function newGet() {
return this[key];
}
return createPropertyDescriptor(newGet, newSet);
}
function isBabelDecorator(decorator) {
return !!(decorator && decorator.initializer !== undefined);
}
function isTypescriptDecorator(decorator) {
return !!(decorator && !isBabelDecorator(decorator));
}
function createBabelDescriptor(descriptor, property, initializer, ctx) {
descriptor.writable = false;
var oldInitializer = descriptor.initializer;
descriptor.initializer = function initializerDirectorr() {
return initializer(this, oldInitializer && oldInitializer.call(this), property, ctx);
};
return descriptor;
}
function createDescriptor(d, property, init, ctx) {
return d && isBabelDecorator(d)
? createBabelDescriptor(d, property, init, ctx)
: createTypescriptDescriptor(d || EMPTY_OBJECT, property, init, ctx);
}
function composePropertyDecorators(decorators) {
return function (target, property, descriptor) {
var resultDescriptor = descriptor;
for (var i = decorators.length - 1; i >= 0; --i) {
resultDescriptor = decorators[i](target, property, resultDescriptor);
}
return resultDescriptor;
};
}
function isStoreReady(store) {
return (store.isReady === undefined || (isFunction(store.isReady) ? store.isReady() : store.isReady));
}
function checkStoresState(directorrStores, isStoreState, storesNames) {
var e_1, _a;
if (storesNames) {
for (var i = 0, l = storesNames.length, store = void 0; i < l; ++i) {
store = directorrStores.get(storesNames[i]);
if (!store)
continue;
if (!isStoreState(store))
return false;
}
}
else {
try {
for (var _b = __values(directorrStores.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
var store = _c.value;
if (!isStoreState(store))
return false;
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
}
return true;
}
function isStoreError(store) {
return store.isError !== undefined && store.isError;
}
function findStoreStateInStores(directorrStores, isStoreState) {
var e_2, _a;
try {
for (var _b = __values(directorrStores.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
var store = _c.value;
if (isStoreState(store))
return store;
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_2) throw e_2.error; }
}
}
function mergeStateToStore(storeState, directorrStore) {
if (directorrStore.fromJSON) {
directorrStore.fromJSON(storeState);
}
else {
for (var prop in storeState) {
if (hasOwnProperty(directorrStore, prop)) {
var store = storeState[prop];
if (isObject(store) && directorrStore[prop]) {
mergeStateToStore(store, directorrStore[prop]);
}
else {
directorrStore[prop] = store;
}
}
}
}
}
function setStateToStore(storeState, directorrStore) {
if (directorrStore.fromJSON) {
directorrStore.fromJSON(storeState);
}
else {
for (var prop in storeState) {
var store = storeState[prop];
if (isObject(store) && directorrStore[prop]) {
setStateToStore(store, directorrStore[prop]);
}
else {
directorrStore[prop] = store;
}
}
}
}
function hydrateStoresToState(directorrStores) {
var e_3, _a;
var obj = {};
try {
for (var _b = __values(directorrStores.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
var _d = __read(_c.value, 2), storeName = _d[0], store = _d[1];
obj[storeName] = store;
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_3) throw e_3.error; }
}
return JSON.parse(JSON.stringify(obj));
}
function compareObjectWithPattern(objectPattern, obj) {
if (!obj)
return false;
for (var prop in objectPattern) {
var value = objectPattern[prop];
if (isFunction(value)) {
if (!value(obj[prop]))
return false;
}
else if (obj[prop] !== value) {
return false;
}
}
return true;
}
function isActionHave(_a, someType, checkPattern) {
var type = _a.type, payload = _a.payload;
if (type === someType) {
return compareObjectWithPattern(checkPattern, payload);
}
return false;
}
function clearTimersEffect(payload) {
var e_4, _a;
if (this === payload.store) {
var timers = this[TIMERS_FIELD_NAME];
try {
for (var timers_1 = __values(timers), timers_1_1 = timers_1.next(); !timers_1_1.done; timers_1_1 = timers_1.next()) {
var timer = timers_1_1.value;
isFunction(timer) ? timer() : clearTimeout(timer);
}
}
catch (e_4_1) { e_4 = { error: e_4_1 }; }
finally {
try {
if (timers_1_1 && !timers_1_1.done && (_a = timers_1.return)) _a.call(timers_1);
}
finally { if (e_4) throw e_4.error; }
}
}
}
function isPayloadChecked(payload, checker) {
if (checker === void 0) { checker = TRUPHY_FUNC; }
if (isFunction(checker))
return checker(payload);
for (var prop in checker) {
var value = checker[prop];
if (!hasOwnProperty(payload, prop))
return false;
if (isFunction(value)) {
if (!value(payload, prop))
return false;
continue;
}
if (payload[prop] !== value)
return false;
}
return true;
}
function createActionTypes(type) {
return {
type: type,
typeLoading: "".concat(type, "_LOADING"),
typeSuccess: "".concat(type, "_SUCCESS"),
typeError: "".concat(type, "_ERROR"),
};
}
var Config = /** @class */ (function () {
function Config() {
var _this = this;
this.batchFunction = batchFunction;
this.createAction = createAction;
this.createActionType = function (actionType) {
return createActionType(actionType, _this.actionTypeDivider);
};
this.actionTypeDivider = ACTION_TYPE_DIVIDER;
this.dispatchEffectsOrig = dispatchEffects;
this.dispatchEffects = dispatchEffects;
this.hydrateStoresToState = hydrateStoresToState;
this.mergeStateToStore = mergeStateToStore;
this.setStateToStore = setStateToStore;
this.configure = function (_a) {
var batchFunction = _a.batchFunction, createAction = _a.createAction, actionTypeDivider = _a.actionTypeDivider, createActionType = _a.createActionType, dispatchEffects = _a.dispatchEffects, hydrateStoresToState = _a.hydrateStoresToState, mergeStateToStore = _a.mergeStateToStore, setStateToStore = _a.setStateToStore;
if (batchFunction) {
_this.batchFunction = batchFunction;
_this.dispatchEffects = batchFunction(_this.dispatchEffectsOrig);
}
if (createAction)
_this.createAction = createAction;
if (createActionType)
_this.createActionType = createActionType;
if (actionTypeDivider)
_this.actionTypeDivider = actionTypeDivider;
if (dispatchEffects) {
_this.dispatchEffectsOrig = dispatchEffects;
_this.dispatchEffects = _this.batchFunction(dispatchEffects);
}
if (hydrateStoresToState)
_this.hydrateStoresToState = hydrateStoresToState;
if (mergeStateToStore)
_this.mergeStateToStore = mergeStateToStore;
if (setStateToStore)
_this.setStateToStore = setStateToStore;
};
}
return Config;
}());
var config = new Config();
var MiddlewareAdapter = /** @class */ (function () {
function MiddlewareAdapter(middleware, runNextMiddleware, index, directorr) {
this.middleware = middleware;
this.directorr = directorr;
this.next = function (action) { return runNextMiddleware(index, action); };
}
MiddlewareAdapter.prototype.run = function (action) {
this.middleware(action, this.next, this.directorr);
};
return MiddlewareAdapter;
}());
var ReduxMiddlewareAdapter = /** @class */ (function () {
function ReduxMiddlewareAdapter(middleware, runNextMiddleware, index, store, reduxStore) {
// Keep for test
this.next = function (action) { return runNextMiddleware(index, action); };
this.middleware = middleware(reduxStore)(this.next);
}
ReduxMiddlewareAdapter.prototype.run = function (action) {
this.middleware(action);
};
return ReduxMiddlewareAdapter;
}());
var MODULE_NAME = 'Directorr';
var GLOBAL_DEP = { global: true };
var OMIT_ACTIONS = ['@APPLY_SNAPSHOT'];
var Directorr = /** @class */ (function () {
function Directorr(_a) {
var _b;
var _c = _a === void 0 ? EMPTY_OBJECT : _a, _d = _c.initState, initState = _d === void 0 ? EMPTY_OBJECT : _d;
var _this = this;
this.stores = new Map();
this.setStateToStore = config.batchFunction(function (storeState) {
var e_1, _a;
try {
for (var _b = __values(_this.stores.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
var _d = __read(_c.value, 2), storeName = _d[0], store = _d[1];
if (hasOwnProperty(storeState, storeName)) {
config.setStateToStore(storeState[storeName], store);
}
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
});
this.mergeStateToStore = config.batchFunction(function (storeState) {
var e_2, _a;
try {
for (var _b = __values(_this.stores.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
var _d = __read(_c.value, 2), storeName = _d[0], store = _d[1];
if (hasOwnProperty(storeState, storeName)) {
config.mergeStateToStore(storeState[storeName], store);
}
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_2) throw e_2.error; }
}
});
this.subscribeHandlers = [];
this.subscribe = function (handler) {
_this.subscribeHandlers = __spreadArray(__spreadArray([], __read(_this.subscribeHandlers), false), [handler], false);
return function () { return _this.unsubscribe(handler); };
};
this.unsubscribe = function (handler) {
_this.subscribeHandlers = _this.subscribeHandlers.filter(function (h) { return h !== handler; });
};
this.middlewares = [];
this.findNextMiddleware = function (nextIndex, action) {
var nextMiddleware = _this.middlewares[nextIndex + 1];
if (nextMiddleware) {
nextMiddleware.run(action);
}
else {
_this.runEffects(action);
}
};
this.dispatch = config.batchFunction(function (action) {
if (!isLikeAction(action))
throw new Error(callWithNotAction(MODULE_NAME, action));
_this.findNextMiddleware(-1, action);
return action;
});
this.dispatchType = function (type, payload) { return _this.dispatch(config.createAction(type, payload)); };
this.reduxStore = (_b = {
getState: function () { return _this.getHydrateStoresState(); },
dispatch: this.dispatch,
subscribe: this.subscribe,
replaceReducer: EMPTY_FUNC
},
_b[Symbol.observable] = function () {
var _a;
var subscribe = _this.subscribe;
return _a = {
subscribe: function (observer) {
if (observer === null || !isObject(observer)) {
throw new TypeError(notObserver());
}
return {
unsubscribe: observer.next ? subscribe(function (stores) { return observer.next(stores); }) : EMPTY_FUNC,
};
}
},
_a[Symbol.observable] = function () {
return this;
},
_a;
},
_b);
this.afterwares = [];
this.initState = initState;
}
Directorr.prototype.getStore = function (StoreConstructor) {
return this.stores.get(getStoreName(StoreConstructor));
};
Directorr.prototype.getHydrateStoresState = function () {
return config.hydrateStoresToState(this.stores);
};
Directorr.prototype.addStores = function (modelOrConstructor) {
var _this = this;
modelOrConstructor.forEach(function (sm) { return _this.addStore(sm); });
};
Directorr.prototype.addStore = function (storeConstructor) {
return this.addStoreDependency(storeConstructor, GLOBAL_DEP);
};
Directorr.prototype.removeStore = function (storeConstructor) {
return this.removeStoreDependency(storeConstructor, GLOBAL_DEP);
};
Directorr.prototype.addStoreDependency = function (StoreConstructor, depName) {
var store = this.initStore(StoreConstructor);
store[DEPENDENCY_FIELD_NAME].push(depName);
return store;
};
Directorr.prototype.removeStoreDependency = function (StoreConstructor, depName) {
var store = this.getStore(StoreConstructor);
if (store) {
var dependency = store[DEPENDENCY_FIELD_NAME];
var index = dependency.indexOf(depName);
if (index !== -1)
dependency.splice(index, 1);
if (!dependency.length)
this.destroyStore(StoreConstructor);
}
};
Directorr.prototype.initStore = function (StoreConstructor) {
var e_3, _a;
var _this = this;
var storeName = getStoreName(StoreConstructor);
if (this.stores.has(storeName))
return this.stores.get(storeName);
// add injected stores
if (hasOwnProperty(StoreConstructor, INJECTED_STORES_FIELD_NAME)) {
var injectedModelsOrConstructors = StoreConstructor[INJECTED_STORES_FIELD_NAME];
try {
try {
for (var injectedModelsOrConstructors_1 = __values(injectedModelsOrConstructors), injectedModelsOrConstructors_1_1 = injectedModelsOrConstructors_1.next(); !injectedModelsOrConstructors_1_1.done; injectedModelsOrConstructors_1_1 = injectedModelsOrConstructors_1.next()) {
var modelOrConstructor = injectedModelsOrConstructors_1_1.value;
var store_1 = this.initStore(modelOrConstructor);
store_1[INJECTED_FROM_FIELD_NAME].push(StoreConstructor);
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (injectedModelsOrConstructors_1_1 && !injectedModelsOrConstructors_1_1.done && (_a = injectedModelsOrConstructors_1.return)) _a.call(injectedModelsOrConstructors_1);
}
finally { if (e_3) throw e_3.error; }
}
}
catch (error) {
if (error instanceof RangeError) {
throw new TypeError(haveCycleInjectedStore(MODULE_NAME));
}
throw error;
}
}
// add afterware
if (StoreConstructor.afterware)
this.addAfterware(StoreConstructor.afterware);
// create store
var store = new StoreConstructor(StoreConstructor.storeInitOptions);
if (!hasOwnProperty(store, INJECTED_FROM_FIELD_NAME)) {
defineProperty(store, INJECTED_FROM_FIELD_NAME, createValueDescriptor([]));
defineProperty(store, DEPENDENCY_FIELD_NAME, createValueDescriptor([]));
}
// attach to directorr
defineProperty(store, STORES_FIELD_NAME, createValueDescriptor(this.stores));
defineProperty(store, DISPATCH_ACTION_FIELD_NAME, createValueDescriptor(this.dispatch));
defineProperty(store, SUBSCRIBE_FIELD_NAME, createValueDescriptor(this.subscribe));
if (!hasOwnProperty(store, DISPATCH_EFFECTS_FIELD_NAME))
defineProperty(store, DISPATCH_EFFECTS_FIELD_NAME, createValueDescriptor(EMPTY_FUNC));
// add store
this.stores.set(storeName, store);
// merge init state
if (hasOwnProperty(this.initState, storeName)) {
config.mergeStateToStore(this.initState[storeName], store);
// remove outdated data
delete this.initState[storeName];
}
// call init action
if (hasOwnProperty(StoreConstructor, INJECTED_STORES_FIELD_NAME)) {
var injectedModelsOrConstructors = StoreConstructor[INJECTED_STORES_FIELD_NAME];
var storeNames = injectedModelsOrConstructors.map(function (s) { return getStoreName(s); });
if (checkStoresState(this.stores, isStoreReady, storeNames)) {
this.dispatchType(DIRECTORR_INIT_STORE_ACTION, { store: store });
}
else {
void this.waitStoresState(injectedModelsOrConstructors).then(function () {
_this.dispatchType(DIRECTORR_INIT_STORE_ACTION, { store: store });
});
}
}
else {
this.dispatchType(DIRECTORR_INIT_STORE_ACTION, { store: store });
}
return store;
};
Directorr.prototype.destroyStore = function (StoreConstructor, FromStoreConstructor) {
var e_4, _a;
var storeName = getStoreName(StoreConstructor);
var store = this.stores.get(storeName);
if (store) {
// remove injected stores
if (hasOwnProperty(StoreConstructor, INJECTED_STORES_FIELD_NAME)) {
var injectedModelsOrConstructors = StoreConstructor[INJECTED_STORES_FIELD_NAME];
try {
try {
for (var injectedModelsOrConstructors_2 = __values(injectedModelsOrConstructors), injectedModelsOrConstructors_2_1 = injectedModelsOrConstructors_2.next(); !injectedModelsOrConstructors_2_1.done; injectedModelsOrConstructors_2_1 = injectedModelsOrConstructors_2.next()) {
var modelOrConstructor = injectedModelsOrConstructors_2_1.value;
this.destroyStore(modelOrConstructor, StoreConstructor);
}
}
catch (e_4_1) { e_4 = { error: e_4_1 }; }
finally {
try {
if (injectedModelsOrConstructors_2_1 && !injectedModelsOrConstructors_2_1.done && (_a = injectedModelsOrConstructors_2.return)) _a.call(injectedModelsOrConstructors_2);
}
finally { if (e_4) throw e_4.error; }
}
}
catch (error) {
if (error instanceof RangeError) {
throw new TypeError(haveCycleInjectedStore(MODULE_NAME));
}
throw error;
}
}
// remove injected from stores
if (FromStoreConstructor) {
var injectedFrom = store[INJECTED_FROM_FIELD_NAME];
var index = injectedFrom.indexOf(FromStoreConstructor);
injectedFrom.splice(index, 1);
}
// when dont have dependencies
if (!store[INJECTED_FROM_FIELD_NAME].length && !store[DEPENDENCY_FIELD_NAME].length) {
// remove afterware
if (StoreConstructor.afterware)
this.removeAfterware(StoreConstructor.afterware);
this.dispatchType(DIRECTORR_DESTROY_STORE_ACTION, { store: store });
defineProperty(store, DISPATCH_ACTION_FIELD_NAME, createValueDescriptor(EMPTY_FUNC));
// remove store
this.stores.delete(storeName);
}
}
};
Directorr.prototype.waitAllStoresState = function (isStoreState) {
var _this = this;
if (isStoreState === void 0) { isStoreState = isStoreReady; }
return createPromiseCancelable(function (res, rej, whenCancel) {
if (checkStoresState(_this.stores, isStoreState))
return res(undefined);
var unsub = _this.subscribe(function (stores) {
if (checkStoresState(stores, isStoreState)) {
unsub();
return res(undefined);
}
});
whenCancel(unsub);
});
};
Directorr.prototype.waitStoresState = function (stores, isStoreState) {
var _this = this;
if (isStoreState === void 0) { isStoreState = isStoreReady; }
var storeNames = stores.map(function (s) { return getStoreName(s); });
return createPromiseCancelable(function (res, rej, whenCancel) {
if (checkStoresState(_this.stores, isStoreState, storeNames))
return res(undefined);
var unsub = _this.subscribe(function (stores) {
if (checkStoresState(stores, isStoreState, storeNames)) {
unsub();
return res(undefined);
}
});
whenCancel(unsub);
});
};
Directorr.prototype.findStoreState = function (isStoreState) {
var _this = this;
if (isStoreState === void 0) { isStoreState = isStoreError; }
return createPromiseCancelable(function (res, rej, whenCancel) {
var store = findStoreStateInStores(_this.stores, isStoreState);
if (store)
return res(store);
var unsub = _this.subscribe(function (stores) {
var store = findStoreStateInStores(stores, isStoreState);
if (store) {
unsub();
return res(store);
}
});
whenCancel(unsub);
});
};
Directorr.prototype.addSomeMiddlewares = function (middlewares, someMiddlewareAdapter) {
var totalMiddlewares = this.middlewares.length;
var _loop_1 = function (i, l, m) {
m = middlewares[i];
if (this_1.middlewares.some(function (mid) { return mid.middleware === m; }))
return out_m_1 = m, "continue";
this_1.middlewares.push(new someMiddlewareAdapter(m, this_1.findNextMiddleware, totalMiddlewares + i, this_1, this_1.reduxStore));
out_m_1 = m;
};
var this_1 = this, out_m_1;
for (var i = 0, l = middlewares.length, m = void 0; i < l; ++i) {
_loop_1(i, l, m);
m = out_m_1;
}
};
Directorr.prototype.addReduxMiddlewares = function (middlewares) {
this.addSomeMiddlewares(middlewares, ReduxMiddlewareAdapter);
};
Directorr.prototype.addMiddlewares = function (middlewares) {
this.addSomeMiddlewares(middlewares, MiddlewareAdapter);
};
Directorr.prototype.removeMiddleware = function (middleware) {
var idx = this.middlewares.findIndex(function (m) { return m.middleware === middleware; });
this.middlewares.splice(idx, 1);
};
Directorr.prototype.addAfterware = function (afterware) {
this.afterwares = __spreadArray(__spreadArray([], __read(this.afterwares), false), [afterware], false);
};
Directorr.prototype.removeAfterware = function (afterware) {
this.afterwares = this.afterwares.filter(function (a) { return a !== afterware; });
};
Directorr.prototype.runEffects = function (action) {
var e_5, _a, e_6, _b, e_7, _c;
try {
for (var _d = __values(this.stores.values()), _e = _d.next(); !_e.done; _e = _d.next()) {
var store = _e.value;
store[DISPATCH_EFFECTS_FIELD_NAME](action);
}
}
catch (e_5_1) { e_5 = { error: e_5_1 }; }
finally {
try {
if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
}
finally { if (e_5) throw e_5.error; }
}
try {
for (var _f = __values(this.afterwares), _g = _f.next(); !_g.done; _g = _f.next()) {
var afterware = _g.value;
afterware(action, this.dispatchType, this);
}
}
catch (e_6_1) { e_6 = { error: e_6_1 }; }
finally {
try {
if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
}
finally { if (e_6) throw e_6.error; }
}
try {
for (var _h = __values(this.subscribeHandlers), _j = _h.next(); !_j.done; _j = _h.next()) {
var handler = _j.value;
handler(this.stores, action);
}
}
catch (e_7_1) { e_7 = { error: e_7_1 }; }
finally {
try {
if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
}
finally { if (e_7) throw e_7.error; }
}
};
return Directorr;
}());
function propOneOf(args) {
return function (payload, prop) { return args.includes(payload[prop]); };
}
function propIsNotEqual(arg) {
return function (payload, prop) { return payload[prop] !== arg; };
}
function propIsNotEqualOneOf(arg) {
return function (payload, prop) { return !arg.includes(payload[prop]); };
}
function dispatchEffectInStore(store, actionType, payload) {
if (DISPATCH_EFFECTS_FIELD_NAME in store)
store[DISPATCH_EFFECTS_FIELD_NAME](config.createAction(actionType, payload));
}
function dispatchInitEffectInStore(store) {
dispatchEffectInStore(store, DIRECTORR_INIT_STORE_ACTION, {
store: store,
});
}
function dispatchDestroyEffectInStore(store) {
dispatchEffectInStore(store, DIRECTORR_DESTROY_STORE_ACTION, {
store: store,
});
}
function dispatchReloadEffectInStore(store, payload) {
dispatchEffectInStore(store, DIRECTORR_RELOAD_STORE_ACTION, payload);
}
function dispatchActionInStore(store, actionType, payload) {
if (DISPATCH_ACTION_FIELD_NAME in store)
store[DISPATCH_ACTION_FIELD_NAME](config.createAction(actionType, payload));
}
function returnArgs(moduleName, arg1, arg2) {
return [arg1, arg2];
}
function createDecoratorFactory(moduleName, decorator, initializer, createContext, convertDecorator) {
if (createContext === void 0) { createContext = returnArgs; }
if (convertDecorator === void 0) { convertDecorator = RETURN_ARG_FUNC; }
return function decoratorFactory(arg1, arg2) {
var context = createContext(moduleName, arg1, arg2);
return convertDecorator(function (target, property, descriptor) {
return decorator(target, property, descriptor, moduleName, initializer, context);
}, context);
};
}
function decorator(target, property, descriptor, moduleName, initializerForInitObject, ctx, buildDescriptor) {
if (buildDescriptor === void 0) { buildDescriptor = createDescriptor; }
if (!isLikePropertyDecorator(descriptor))
throw new Error(useForNotPropDecorator(moduleName, property));
return buildDescriptor(descriptor, property, initializerForInitObject, ctx);
}
function createPropertyDecoratorFactory(moduleName, initializer, createContext) {
return createDecoratorFactory(moduleName, decorator, initializer, createContext);
}
function createActionTypeContext(moduleName, actionType, options) {
if (!isLikeActionType(actionType)) {
throw new Error(callDecoratorWithNotActionType(moduleName, actionType));
}
return [config.createActionType(actionType), options];
}
function addInitFields(initObject) {
if (!hasOwnProperty(initObject, DISPATCH_EFFECTS_FIELD_NAME)) {
defineProperty(initObject, DISPATCH_EFFECTS_FIELD_NAME, createValueDescriptor(config.dispatchEffects));
defineProperty(initObject, DISPATCH_ACTION_FIELD_NAME, createValueDescriptor(config.dispatchEffects));
defineProperty(initObject, EFFECTS_FIELD_NAME, createValueDescriptor(new Map()));
defineProperty(initObject, DEPENDENCY_FIELD_NAME, createValueDescriptor([]));
defineProperty(initObject, INJECTED_FROM_FIELD_NAME, createValueDescriptor([]));
defineProperty(initObject, STORES_FIELD_NAME, createValueDescriptor(null));
}
}
var MODULE_NAME$1 = 'action';
function runDispatcher(args, actionType, valueFunc, store, addToPayload) {
var result = valueFunc.apply(void 0, __spreadArray([], __read(args), false));
if (result !== null) {
if (isPromise(result)) {
void result.then(function (data) {
if (data !== null) {
store[DISPATCH_ACTION_FIELD_NAME](config.createAction(actionType, addToPayload(data, store)));
}
});
}
else {
store[DISPATCH_ACTION_FIELD_NAME](config.createAction(actionType, addToPayload(result, store)));
}
}
return result;
}
function initializer(initObject, value, property, _a, dispatcher, addFields) {
var _b = __read(_a, 2), actionType = _b[0], _c = _b[1], addToPayload = _c === void 0 ? RETURN_ARG_FUNC : _c;
if (dispatcher === void 0) { dispatcher = runDispatcher; }
if (addFields === void 0) { addFields = addInitFields; }
if (!isFunction(value))
throw new Error(callWithPropNotEquallFunc(MODULE_NAME$1, property));
addFields(initObject);
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return dispatcher(args, actionType, value, initObject, addToPayload);
};
}
function addTypeToDecorator(decorator, context) {
decorator.type = context[0];
decorator.createAction = function (payload) { return config.createAction(decorator.type, payload); };
decorator.isAction = function (action) { return decorator.type === action.type; };
return decorator;
}
var action = createDecoratorFactory(MODULE_NAME$1, decorator, initializer, createActionTypeContext, addTypeToDecorator);
var MODULE_NAME$2 = 'effect';
function initializer$1(initObject, value, property, _a, addFields) {
var _b = __read(_a, 1), actionType = _b[0];
if (addFields === void 0) { addFields = addInitFields; }
if (!isFunction(value))
throw new Error(callWithPropNotEquallFunc(MODULE_NAME$2, property));
addFields(initObject);
var effectsMap = initObject[EFFECTS_FIELD_NAME];
var effects = effectsMap.get(actionType);
if (effects) {
effects.push(property);
}
else {
effectsMap.set(actionType, [property]);
}
return value;
}
function addTypeToDecorator$1(decorator, context) {
decorator.type = context[0];
decorator.createAction = function (payload) { return config.createAction(decorator.type, payload); };
decorator.isAction = function (action) { return decorator.type === action.type; };
return decorator;
}
var effect = createDecoratorFactory(MODULE_NAME$2, decorator, initializer$1, createActionTypeContext, addTypeToDecorator$1);
function createActionAndEffect(actionType) {
var _a = createActionTypes(config.createActionType(actionType)), type = _a.type, typeSuccess = _a.typeSuccess, typeError = _a.typeError, typeLoading = _a.typeLoading;
return [
action(type),
effect(type),
action(typeSuccess),
effect(typeSuccess),
action(typeError),
effect(typeError),
action(typeLoading),
effect(typeLoading)