@steroidsjs/core 2.2.75 → 2.2.78

package/reducers/auth.js

@@ -0,0 +1,61 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.getData = exports.getUserRole = exports.getUserId = exports.getUser = exports.isAuthorized = exports.getInitializeCounter = exports.isInitialized = void 0;
+var merge_1 = __importDefault(require("lodash-es/merge"));
+var auth_1 = require("../actions/auth");
+var initialState = {
+    isInitialized: false,
+    initializeCounter: 0,
+    redirectPageId: null,
+    user: null,
+    data: null
+};
+exports["default"] = (function (state, action) {
+    var _a;
+    if (state === void 0) { state = initialState; }
+    switch (action.type) {
+        case auth_1.AUTH_INIT:
+            return __assign(__assign({}, state), { initializeCounter: state.initializeCounter + 1, redirectPageId: action.redirectPageId || null });
+        case auth_1.AUTH_INIT_USER:
+            return __assign(__assign({}, state), { isInitialized: true, user: action.user });
+        case auth_1.AUTH_SET_DATA:
+            return __assign(__assign({}, state), { data: merge_1["default"]({}, state.data, action.data) });
+        case auth_1.AUTH_ADD_SOCIAL:
+            return __assign(__assign({}, state), { user: __assign(__assign({}, state.user), { socials: __spreadArray(__spreadArray([], (((_a = state.user) === null || _a === void 0 ? void 0 : _a.socials) || [])), (action.social || [])) }) });
+        default:
+            return state;
+    }
+});
+var isInitialized = function (state) { return state.auth.isInitialized; };
+exports.isInitialized = isInitialized;
+var getInitializeCounter = function (state) { return state.auth.initializeCounter; };
+exports.getInitializeCounter = getInitializeCounter;
+var isAuthorized = function (state) { return !!state.auth.user; };
+exports.isAuthorized = isAuthorized;
+var getUser = function (state) { return state.auth.user; };
+exports.getUser = getUser;
+var getUserId = function (state) { return (state.auth.user && state.auth.user.id) || null; };
+exports.getUserId = getUserId;
+var getUserRole = function (state) { return (state.auth.user && state.auth.user.role) || null; };
+exports.getUserRole = getUserRole;
+var getData = function (state) { return state.auth.data; };
+exports.getData = getData;

package/reducers/fields.d.ts

@@ -0,0 +1,14 @@
+declare const _default: (state: {
+    props: {};
+    dataProvider: {};
+    meta: any;
+}, action: any) => {
+    props: {};
+    dataProvider: {};
+    meta: any;
+};
+export default _default;
+export declare const isMetaFetched: (state: any) => boolean;
+export declare const getEnumLabels: (state: any, name: any) => any;
+export declare const getModel: (state: any, name: any) => any;
+export declare const getDataProviderItems: (state: any, dataProviderId: any) => any;

package/reducers/fields.js

@@ -0,0 +1,61 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.getDataProviderItems = exports.getModel = exports.getEnumLabels = exports.isMetaFetched = void 0;
+var isString_1 = __importDefault(require("lodash-es/isString"));
+var get_1 = __importDefault(require("lodash-es/get"));
+var fields_1 = require("../actions/fields");
+var initialState = {
+    props: {},
+    dataProvider: {},
+    meta: null
+};
+var normalizeName = function (name) { return name.replace(/\\/g, '.').replace(/^\./, ''); };
+exports["default"] = (function (state, action) {
+    var _a;
+    if (state === void 0) { state = initialState; }
+    switch (action.type) {
+        case fields_1.FIELDS_SET_META:
+            Object.keys(action.meta).forEach(function (name) {
+                action.meta[name].className = name;
+            });
+            return __assign(__assign({}, state), { meta: __assign(__assign({}, state.meta), action.meta) });
+        case fields_1.FIELDS_DATA_PROVIDER_SET_ITEMS:
+            return __assign(__assign({}, state), { dataProvider: __assign(__assign({}, state.dataProvider), (_a = {}, _a[action.dataProviderId] = action.items, _a)) });
+        default:
+            return state;
+    }
+});
+var isMetaFetched = function (state) { return get_1["default"](state, ['fields', 'meta']) !== null; };
+exports.isMetaFetched = isMetaFetched;
+var getEnumLabels = function (state, name) { return get_1["default"](state, ['fields', 'meta', name, 'labels']) || null; };
+exports.getEnumLabels = getEnumLabels;
+var warnings = {};
+var getModel = function (state, name) {
+    if (isString_1["default"](name)) {
+        name = normalizeName(name);
+        var meta = get_1["default"](state, ['fields', 'meta', name]) || null;
+        if (!meta && exports.isMetaFetched(state) && !warnings[name]) {
+            warnings[name] = true;
+            console.warn('Steroids: Not found model meta:', name); // eslint-disable-line no-console
+        }
+        return meta;
+    }
+    return name || null;
+};
+exports.getModel = getModel;
+var getDataProviderItems = function (state, dataProviderId) { var _a, _b; return ((_b = (_a = state === null || state === void 0 ? void 0 : state.fields) === null || _a === void 0 ? void 0 : _a.dataProvider) === null || _b === void 0 ? void 0 : _b[dataProviderId]) || null; };
+exports.getDataProviderItems = getDataProviderItems;

package/reducers/form.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Редьюрес для одной формы. Используется как для Redux, так и для React Reducer
+ * @param state
+ * @param action
+ */
+export declare function reducerItem(state: any, action: any): any;
+declare const _default: (state: {}, action: any) => any;
+export default _default;
+export declare const formSelector: (state: any, formId: any, selector: any) => any;
+export declare const getFormValues: (state: any, formId: any) => any;

package/reducers/form.js

@@ -0,0 +1,86 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.getFormValues = exports.formSelector = exports.reducerItem = void 0;
+var get_1 = __importDefault(require("lodash-es/get"));
+var isEqual_1 = __importDefault(require("lodash-es/isEqual"));
+var cloneDeep_1 = __importDefault(require("lodash-es/cloneDeep"));
+var isObject_1 = __importDefault(require("lodash-es/isObject"));
+var isEmpty_1 = __importDefault(require("lodash-es/isEmpty"));
+var dot_prop_immutable_1 = require("dot-prop-immutable");
+var form_1 = require("../actions/form");
+/**
+ * Редьюрес для одной формы. Используется как для Redux, так и для React Reducer
+ * @param state
+ * @param action
+ */
+function reducerItem(state, action) {
+    if (!state && action.type !== form_1.FORM_INITIALIZE) {
+        state = reducerItem(state, {
+            type: form_1.FORM_INITIALIZE,
+            formId: action.formId
+        });
+    }
+    switch (action.type) {
+        case form_1.FORM_INITIALIZE:
+            return __assign(__assign({ errors: {}, isInvalid: false, isSubmitting: false }, state), { values: cloneDeep_1["default"](action.values) || (state === null || state === void 0 ? void 0 : state.values) || {}, initialValues: action.values || (state === null || state === void 0 ? void 0 : state.values) || null });
+        case form_1.FORM_CHANGE:
+            if (isObject_1["default"](action.nameOrObject)) {
+                var newValues = __assign(__assign({}, state.values), action.nameOrObject);
+                if (!isEqual_1["default"](state.values, newValues)) {
+                    return __assign(__assign({}, state), { values: __assign(__assign({}, state.values), action.nameOrObject) });
+                }
+                return state;
+            }
+            return dot_prop_immutable_1.set(state, 'values.' + action.nameOrObject, action.value);
+        case form_1.FORM_SET_ERRORS:
+            return __assign(__assign({}, state), { errors: action.errors, isInvalid: !isEmpty_1["default"](action.errors) });
+        case form_1.FORM_SUBMIT:
+            return dot_prop_immutable_1.set(state, 'submitCounter', (state.submitCounter || 0) + 1);
+        case form_1.FORM_SET_SUBMITTING:
+            return dot_prop_immutable_1.set(state, 'isSubmitting', action.isSubmitting);
+        case form_1.FORM_RESET:
+            return __assign(__assign({}, state), { values: cloneDeep_1["default"](state.initialValues || {}) });
+        case form_1.FORM_HARD_RESET:
+            return __assign(__assign({}, state), { initialValues: null, values: {}, errors: {}, isInvalid: false, isSubmitting: false });
+        case form_1.FORM_DESTROY:
+            return null;
+        case form_1.FORM_ARRAY_ADD:
+            // eslint-disable-next-line no-case-declarations
+            var newValue = [].concat(get_1["default"](state, 'values.' + action.name) || []);
+            for (var i = 0; i < action.rowsCount; i += 1) {
+                newValue.push(cloneDeep_1["default"](action.initialValues || {}));
+            }
+            return dot_prop_immutable_1.set(state, 'values.' + action.name, newValue);
+        case form_1.FORM_ARRAY_REMOVE:
+            return dot_prop_immutable_1["delete"](state, 'values.' + action.name + '.' + action.index);
+        default:
+            return state;
+    }
+}
+exports.reducerItem = reducerItem;
+var initialState = {};
+exports["default"] = (function (state, action) {
+    if (state === void 0) { state = initialState; }
+    if (action.formId) {
+        return dot_prop_immutable_1.set(state, action.formId, reducerItem(state[action.formId], action));
+    }
+    return state;
+});
+var formSelector = function (state, formId, selector) { var _a; return selector(((_a = state.form) === null || _a === void 0 ? void 0 : _a[formId]) || {}); };
+exports.formSelector = formSelector;
+var getFormValues = function (state, formId) { var _a, _b; return ((_b = (_a = state.form) === null || _a === void 0 ? void 0 : _a[formId]) === null || _b === void 0 ? void 0 : _b.values) || null; };
+exports.getFormValues = getFormValues;

package/reducers/index.d.ts

@@ -0,0 +1,13 @@
+import auth from './auth';
+import fields from './fields';
+import form from './form';
+import list from './list';
+import notifications from './notifications';
+import modal from './modal';
+import router from './router';
+import screen from './screen';
+export { form, auth, fields, list, notifications, modal, router, screen, };
+declare const _default: (asyncReducers: any) => import("redux").Reducer<import("redux").CombinedState<{
+    [x: string]: unknown;
+}>, never>;
+export default _default;

package/reducers/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.screen = exports.router = exports.modal = exports.notifications = exports.list = exports.fields = exports.auth = exports.form = void 0;
+var redux_1 = require("redux");
+var auth_1 = __importDefault(require("./auth"));
+exports.auth = auth_1["default"];
+var fields_1 = __importDefault(require("./fields"));
+exports.fields = fields_1["default"];
+var form_1 = __importDefault(require("./form"));
+exports.form = form_1["default"];
+var list_1 = __importDefault(require("./list"));
+exports.list = list_1["default"];
+var notifications_1 = __importDefault(require("./notifications"));
+exports.notifications = notifications_1["default"];
+var modal_1 = __importDefault(require("./modal"));
+exports.modal = modal_1["default"];
+var router_1 = __importDefault(require("./router"));
+exports.router = router_1["default"];
+var screen_1 = __importDefault(require("./screen"));
+exports.screen = screen_1["default"];
+exports["default"] = (function (asyncReducers) { return redux_1.combineReducers(__assign(__assign({ form: form_1["default"],
+    auth: auth_1["default"],
+    fields: fields_1["default"],
+    list: list_1["default"],
+    notifications: notifications_1["default"],
+    modal: modal_1["default"],
+    screen: screen_1["default"] }, asyncReducers), { router: function (state, action) { return router_1["default"](asyncReducers.router ? asyncReducers.router(state, action) : {}, action); } })); });

package/reducers/list.d.ts

@@ -0,0 +1,12 @@
+declare const _default: (state: {
+    lists: {};
+    selectedIds: {};
+}, action: any) => any;
+export default _default;
+export declare const isListInitialized: (state: any, listId: any) => boolean;
+export declare const getList: (state: any, listId: any) => any;
+export declare const getIds: (state: any, listId: any) => any;
+export declare const getListItems: (state: any, listId: any) => any;
+export declare const getCheckedIds: (state: any, listId: any) => any;
+export declare const isChecked: (state: any, listId: any, itemId: any) => any;
+export declare const isCheckedAll: (state: any, listId: any) => any;

package/reducers/list.js

@@ -0,0 +1,141 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+exports.__esModule = true;
+exports.isCheckedAll = exports.isChecked = exports.getCheckedIds = exports.getListItems = exports.getIds = exports.getList = exports.isListInitialized = void 0;
+var get_1 = __importDefault(require("lodash-es/get"));
+var isMatch_1 = __importDefault(require("lodash-es/isMatch"));
+var every_1 = __importDefault(require("lodash-es/every"));
+var extend_1 = __importDefault(require("lodash-es/extend"));
+var list_1 = require("../actions/list");
+var initialState = {
+    lists: {},
+    selectedIds: {}
+};
+var reducerMap = (_a = {},
+    _a[list_1.LIST_INIT] = function (state, action) {
+        var _a;
+        return (__assign(__assign({}, state), { lists: __assign(__assign({}, state.lists), (_a = {}, _a[action.payload.listId] = __assign({ meta: {}, total: action.payload.total || (action.payload.items ? action.payload.items.length : 0), isFetched: !!action.payload.items, isLoading: false }, action.payload), _a)) }));
+    },
+    _a[list_1.LIST_SET_ITEMS] = function (state, action) {
+        var _a;
+        return (__assign(__assign({}, state), { lists: __assign(__assign({}, state.lists), (_a = {}, _a[action.listId] = __assign(__assign({}, state.lists[action.listId]), { items: action.items }), _a)) }));
+    },
+    _a[list_1.LIST_BEFORE_FETCH] = function (state, action) {
+        var _a;
+        return (__assign(__assign({}, state), { lists: __assign(__assign({}, state.lists), (_a = {}, _a[action.listId] = __assign(__assign({}, state.lists[action.listId]), { isLoading: true }), _a)) }));
+    },
+    _a[list_1.LIST_AFTER_FETCH] = function (state, action) {
+        var _a;
+        var items;
+        var list = state.lists[action.listId];
+        if (list.items === action.items) {
+            // No changes
+            items = list.items;
+        }
+        else if (list && list.items && list.loadMore && action.page > 1) {
+            items = [].concat(list.items);
+            action.items.forEach(function (entry, i) {
+                var index = (action.page - 1) * action.pageSize + i;
+                items[index] = entry;
+            });
+        }
+        else {
+            items = [].concat(action.items);
+        }
+        return __assign(__assign({}, state), { lists: __assign(__assign({}, state.lists), (_a = {}, _a[action.listId] = __assign(__assign(__assign({}, list), action), { items: items, isFetched: true, isLoading: false }), _a)) });
+    },
+    _a[list_1.LIST_ITEM_ADD] = function (state, action) {
+        var _a;
+        if (state.lists[action.listId]) {
+            return __assign(__assign({}, state), { lists: __assign(__assign({}, state.lists), (_a = {}, _a[action.listId] = __assign(__assign({}, state.lists[action.listId]), { items: action.prepend
+                        ? []
+                            .concat(action.item)
+                            .concat(state.lists[action.listId].items)
+                        : []
+                            .concat(state.lists[action.listId].items)
+                            .concat(action.item) }), _a)) });
+        }
+        return [];
+    },
+    _a[list_1.LIST_ITEM_UPDATE] = function (state, action) {
+        var _a;
+        return (__assign(__assign({}, state), { lists: __assign(__assign({}, state.lists), (_a = {}, _a[action.listId] = __assign(__assign({}, state.lists[action.listId]), { items: state.lists[action.listId].items.map(function (item) {
+                    if (isMatch_1["default"](item, action.condition)) {
+                        item = extend_1["default"]({}, item, action.item);
+                    }
+                    return item;
+                }) }), _a)) }));
+    },
+    _a[list_1.LIST_DESTROY] = function (state, action) {
+        delete state.lists[action.listId];
+        return __assign(__assign({}, state), { lists: __assign({}, state.lists) });
+    },
+    _a[list_1.LIST_TOGGLE_ITEM] = function (state, action) {
+        var _a;
+        var selectedIds = get_1["default"](state, ['selectedIds', action.listId]) || [];
+        var index = selectedIds.indexOf(action.itemId);
+        if (index === -1) {
+            selectedIds.push(action.itemId);
+        }
+        else {
+            selectedIds.splice(index, 1);
+        }
+        return __assign(__assign({}, state), { selectedIds: __assign(__assign({}, state.selectedIds), (_a = {}, _a[action.listId] = [].concat(selectedIds), _a)) });
+    },
+    _a[list_1.LIST_TOGGLE_ALL] = function (state, action) {
+        var _a;
+        var list4 = state.lists[action.listId];
+        if (list4) {
+            var ids = list4.items.map(function (item) { return item[list4.primaryKey]; }) || [];
+            var isAll = state.selectedIds[action.listId]
+                && every_1["default"](ids.map(function (id) { return state.selectedIds[action.listId].includes(id); }));
+            return __assign(__assign({}, state), { selectedIds: __assign(__assign({}, state.selectedIds), (_a = {}, _a[action.listId] = isAll ? [] : ids, _a)) });
+        }
+        return [];
+    },
+    _a[list_1.LIST_SET_LAYOUT] = function (state, action) {
+        var _a;
+        return (__assign(__assign({}, state), { lists: __assign(__assign({}, state.lists), (_a = {}, _a[action.listId] = __assign(__assign({}, state.lists[action.listId]), { layoutName: action.layoutName }), _a)) }));
+    },
+    _a);
+exports["default"] = (function (state, action) {
+    if (state === void 0) { state = initialState; }
+    return reducerMap[action.type]
+        ? reducerMap[action.type](state, action)
+        : state;
+});
+var isListInitialized = function (state, listId) { return !!get_1["default"](state, ['list', 'lists', listId]); };
+exports.isListInitialized = isListInitialized;
+var getList = function (state, listId) { return get_1["default"](state, ['list', 'lists', listId]) || null; };
+exports.getList = getList;
+var getIds = function (state, listId) {
+    var list = exports.getList(state, listId);
+    return ((list && list.items && list.items.map(function (item) { return item[list.primaryKey]; })) || []);
+};
+exports.getIds = getIds;
+var getListItems = function (state, listId) { return get_1["default"](state, ['list', 'lists', listId, 'items']); };
+exports.getListItems = getListItems;
+var getCheckedIds = function (state, listId) { return get_1["default"](state, ['list', 'selectedIds', listId]) || []; };
+exports.getCheckedIds = getCheckedIds;
+var isChecked = function (state, listId, itemId) { return exports.getCheckedIds(state, listId).includes(itemId); };
+exports.isChecked = isChecked;
+var isCheckedAll = function (state, listId) {
+    var selectedIds = exports.getCheckedIds(state, listId);
+    return (selectedIds.length > 0
+        && every_1["default"](exports.getIds(state, listId).map(function (id) { return selectedIds.includes(id); })));
+};
+exports.isCheckedAll = isCheckedAll;

package/reducers/modal.d.ts

@@ -0,0 +1,12 @@
+export declare const MODAL_DEFAULT_GROUP = "modal";
+export interface IModal {
+    id: string | number;
+    modal: any;
+    props: any;
+    isClosing: boolean;
+}
+declare const _default: (state: {
+    opened: Record<string, IModal[]>;
+}, action: any) => any;
+export default _default;
+export declare const getOpened: (state: any, group?: string) => IModal[];

package/reducers/modal.js

@@ -0,0 +1,78 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.getOpened = exports.MODAL_DEFAULT_GROUP = void 0;
+var get_1 = __importDefault(require("lodash-es/get"));
+var dot_prop_immutable_1 = require("dot-prop-immutable");
+var modal_1 = require("../actions/modal");
+exports.MODAL_DEFAULT_GROUP = 'modal';
+var initialState = {
+    opened: {}
+};
+exports["default"] = (function (state, action) {
+    if (state === void 0) { state = initialState; }
+    switch (action.type) {
+        case modal_1.MODAL_OPEN:
+            return (function () {
+                var group = action.group || exports.MODAL_DEFAULT_GROUP;
+                var items = get_1["default"](state, ['opened', group]) || [];
+                var index = items.findIndex(function (item) { return item.id === action.id; });
+                if (index !== -1) {
+                    return dot_prop_immutable_1.set(state, "opened." + group + "." + index + ".props", __assign(__assign({}, items[index].props), action.props));
+                }
+                return dot_prop_immutable_1.set(state, "opened." + group, __spreadArray(__spreadArray([], items), [
+                    {
+                        id: action.id,
+                        modal: action.modal,
+                        props: action.props,
+                        isClosing: false
+                    },
+                ]));
+            })();
+        case modal_1.MODAL_MARK_CLOSING:
+            return (function () {
+                var group = action.group || exports.MODAL_DEFAULT_GROUP;
+                var items = get_1["default"](state, ['opened', group]) || [];
+                var index = items.findIndex(function (item) { return item.id === action.id; });
+                if (index !== -1) {
+                    return dot_prop_immutable_1.set(state, "opened." + group + "." + index + ".isClosing", true);
+                }
+                return state;
+            })();
+        case modal_1.MODAL_CLOSE:
+            return (function () {
+                var group = action.group || exports.MODAL_DEFAULT_GROUP;
+                var items = get_1["default"](state, ['opened', group]) || [];
+                var index = items.findIndex(function (item) { return item.id === action.id; });
+                if (index !== -1) {
+                    return dot_prop_immutable_1["delete"](state, "opened." + group + "." + index);
+                }
+                return state;
+            })();
+        default:
+            return state;
+    }
+});
+var getOpened = function (state, group) {
+    if (group === void 0) { group = exports.MODAL_DEFAULT_GROUP; }
+    return get_1["default"](state, ['modal', 'opened', group]) || null;
+};
+exports.getOpened = getOpened;

package/reducers/notifications.d.ts

@@ -0,0 +1,10 @@
+declare const _default: (state: {
+    items: any[];
+    position: string;
+}, action: any) => {
+    items: any[];
+    position: any;
+};
+export default _default;
+export declare const getNotifications: (state: any) => any;
+export declare const getPosition: (state: any) => any;

package/reducers/notifications.js

@@ -0,0 +1,44 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+exports.__esModule = true;
+exports.getPosition = exports.getNotifications = void 0;
+var notifications_1 = require("../actions/notifications");
+var initialState = {
+    items: [],
+    position: ''
+};
+exports["default"] = (function (state, action) {
+    if (state === void 0) { state = initialState; }
+    switch (action.type) {
+        case notifications_1.NOTIFICATIONS_SHOW:
+            return __assign(__assign({}, state), { items: []
+                    .concat(state.items)
+                    .concat([
+                    {
+                        id: action.id,
+                        level: action.level || 'info',
+                        message: action.message,
+                        isClosing: false,
+                        position: action.position
+                    },
+                ]), position: action.position });
+        case notifications_1.NOTIFICATIONS_CLOSE:
+            return __assign(__assign({}, state), { items: state.items.filter(function (item) { return item.id !== action.id; }) });
+        default:
+            return state;
+    }
+});
+var getNotifications = function (state) { return state.notifications.items; };
+exports.getNotifications = getNotifications;
+var getPosition = function (state) { return state.notifications.position; };
+exports.getPosition = getPosition;

package/reducers/router.d.ts

@@ -0,0 +1,49 @@
+import { IRouteItem } from '../ui/nav/Router/Router';
+interface IRouterInitialState {
+    location: {
+        pathname: string;
+        search: string;
+        hash: string;
+        query: Record<string, unknown>;
+    };
+    routesTree: IRouteItem;
+    routesMap: {
+        [key: string]: IRouteItem;
+    };
+    activeIds: string[];
+    match: {
+        path: string;
+        url: string;
+        isExact: string;
+        params: Record<string, unknown>;
+    };
+    params: Record<string, unknown>;
+    configs: any;
+    data: Record<string, unknown>;
+    counters: Record<string, unknown>;
+}
+/**
+ * Generate url for route by path and params
+ * @param path
+ * @param params
+ */
+export declare const buildUrl: (path: any, params?: any) => any;
+declare const _default: (state: IRouterInitialState, action: any) => any;
+export default _default;
+export declare const isRouterInitialized: (state: any) => boolean;
+export declare const getRouterParams: (state: any) => any;
+export declare const getActiveRouteIds: (state: any) => any;
+export declare const getRoutesMap: (state: any) => any;
+export declare const getRouteId: (state: any) => any;
+export declare const getRoute: (state: any, routeId?: any) => IRouteItem;
+export declare const getRouteProp: (state: any, routeId: any, param: any) => any;
+export declare const getRouteParams: (state: any) => any;
+export declare const getRouteParam: (state: any, param: any) => any;
+export declare const getRouteBreadcrumbs: (state: any, routeId?: any) => IRouteItem[];
+export declare const getRouteChildren: (state: any, routeId?: any) => IRouteItem[] | {
+    [key: string]: IRouteItem;
+};
+export declare const getRouteParent: (state: any, routeId?: any, level?: number) => IRouteItem;
+export declare const getNavItems: (state: any, routeId: any) => IRouteItem[] | {
+    [key: string]: IRouteItem;
+};