@steroidsjs/core 3.1.8 → 3.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@steroidsjs/core",
-    "version": "3.1.8",
+    "version": "3.1.9",
     "description": "",
     "author": "Vladimir Kozhin <hello@kozhindev.com>",
     "repository": {

package/src/components/ClientStorageComponent.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+/* eslint-disable import/no-extraneous-dependencies */
+var dayjs_1 = __importDefault(require("dayjs"));
+var cookie = __importStar(require("js-cookie"));
+/**
+ * Client Storage Component
+ * Слой хранения данных в браузере (cookie, local/session storage) или ReactNative
+ */
+var ClientStorageComponent = /** @class */ (function () {
+    function ClientStorageComponent(components, config) {
+        var _a;
+        this.localStorageAvailable = !process.env.IS_SSR;
+        this.sessionStorageAvailable = !process.env.IS_SSR;
+        this.STORAGE_SESSION = 'session';
+        this.STORAGE_LOCAL = 'local';
+        this.STORAGE_COOKIE = 'cookie';
+        if (this.localStorageAvailable) {
+            try {
+                window.localStorage.setItem('localStorageAvailable', '1');
+                this.localStorageAvailable = window.localStorage.getItem('localStorageAvailable') === '1';
+                window.localStorage.removeItem('localStorageAvailable');
+            }
+            catch (e) {
+                this.localStorageAvailable = false;
+            }
+        }
+        if (this.sessionStorageAvailable) {
+            try {
+                window.sessionStorage.setItem('sessionStorageAvailable', '1');
+                this.sessionStorageAvailable = window.sessionStorage.getItem('sessionStorageAvailable') === '1';
+                window.sessionStorage.removeItem('sessionStorageAvailable');
+            }
+            catch (e) {
+                this.sessionStorageAvailable = false;
+            }
+        }
+        this.shareBetweenSubdomains = (_a = config === null || config === void 0 ? void 0 : config.shareBetweenSubdomains) !== null && _a !== void 0 ? _a : false;
+        this._ssrCookie = config === null || config === void 0 ? void 0 : config.ssrCookie;
+    }
+    ClientStorageComponent.prototype.get = function (name, storageName) {
+        storageName = storageName || this.STORAGE_LOCAL;
+        if (this.localStorageAvailable && storageName === this.STORAGE_LOCAL) {
+            return window.localStorage.getItem(name);
+        }
+        if (this.sessionStorageAvailable
+            && storageName === this.STORAGE_SESSION) {
+            return window.sessionStorage.getItem(name);
+        }
+        return process.env.IS_SSR ? this._ssrCookie.get(name) : cookie.get(name);
+    };
+    ClientStorageComponent.prototype.set = function (name, value, storageName, expires) {
+        if (expires === void 0) { expires = null; }
+        storageName = storageName || this.STORAGE_LOCAL;
+        if (this.localStorageAvailable && storageName === this.STORAGE_LOCAL) {
+            window.localStorage.setItem(name, value);
+        }
+        else if (this.sessionStorageAvailable
+            && storageName === this.STORAGE_SESSION) {
+            window.sessionStorage.setItem(name, value);
+        }
+        else {
+            var domain = this._getDomain();
+            var options = {
+                expires: expires
+            };
+            if (domain) {
+                options.domain = domain;
+            }
+            if (expires && process.env.IS_SSR) {
+                options.expires = (0, dayjs_1["default"])().add(options.expires, 'days').utc().toDate();
+            }
+            // eslint-disable-next-line no-unused-expressions
+            process.env.IS_SSR ? this._ssrCookie.set(name, value, options) : cookie.set(name, value, options);
+        }
+    };
+    ClientStorageComponent.prototype.remove = function (name, storageName) {
+        storageName = storageName || this.STORAGE_LOCAL;
+        if (this.localStorageAvailable && storageName === this.STORAGE_LOCAL) {
+            window.localStorage.removeItem(name);
+        }
+        else if (this.sessionStorageAvailable
+            && storageName === this.STORAGE_SESSION) {
+            window.sessionStorage.removeItem(name);
+        }
+        else {
+            var domain = this._getDomain();
+            var options = {};
+            if (domain) {
+                options.domain = domain;
+            }
+            // eslint-disable-next-line no-unused-expressions
+            process.env.IS_SSR ? this._ssrCookie.remove(name, options) : cookie.remove(name, options);
+        }
+    };
+    ClientStorageComponent.prototype._getDomain = function () {
+        if (this.shareBetweenSubdomains) {
+            var host = typeof window !== 'undefined' ? window.location.hostname : '';
+            var isIp = /^\d{1,3}(\.\d{1,3}){3}$/.test(host);
+            var isLocalhost = host === 'localhost';
+            if (!isIp && !isLocalhost) {
+                return host
+                    .split('.')
+                    .slice(-2)
+                    .join('.');
+            }
+        }
+        return null;
+    };
+    return ClientStorageComponent;
+}());
+exports["default"] = ClientStorageComponent;

package/src/components/JwtHttpComponent.d.ts

@@ -0,0 +1,39 @@
+import BaseHttpComponent from './HttpComponent';
+export interface IRefreshTokenRequest {
+    url: string;
+    method: string;
+}
+export interface IJwtHttpComponentConfig {
+    /**
+     * Запрос на обновление токена авторизации
+     */
+    refreshTokenRequest?: IRefreshTokenRequest;
+    /**
+     * Ключ токена авторизации для локального хранилища
+     */
+    refreshTokenKey?: string;
+}
+/**
+ * JwtHttpComponent
+ * Вариация HttpComponent с функционалом обновления токена авторизации
+ */
+export default class JwtHttpComponent extends BaseHttpComponent implements IJwtHttpComponentConfig {
+    refreshTokenRequest?: IRefreshTokenRequest;
+    refreshTokenKey?: string;
+    _refreshToken: any;
+    constructor(components: any, config?: any);
+    getAxiosConfig(): Promise<{
+        withCredentials: boolean;
+        headers: any;
+    }>;
+    private setRefreshTokenInterceptor;
+    getAxiosInstance(): Promise<any>;
+    removeRefreshToken(): void;
+    setRefreshToken(value: any): void;
+    getRefreshToken(): Promise<any>;
+    onLogout(): void;
+    onLogin(params: {
+        accessToken: string;
+        refreshToken: string;
+    }): void;
+}

package/src/components/JwtHttpComponent.js

@@ -0,0 +1,206 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+var __generator = (this && this.__generator) || function (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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var axios_1 = __importDefault(require("axios"));
+var HttpComponent_1 = __importDefault(require("./HttpComponent"));
+var auth_1 = require("../actions/auth");
+/**
+ * JwtHttpComponent
+ * Вариация HttpComponent с функционалом обновления токена авторизации
+ */
+var JwtHttpComponent = /** @class */ (function (_super) {
+    __extends(JwtHttpComponent, _super);
+    function JwtHttpComponent(components, config) {
+        if (config === void 0) { config = {}; }
+        var _this = _super.call(this, components, config) || this;
+        _this.refreshTokenKey = 'refreshToken';
+        _this.refreshTokenKey = config.refreshTokenKey || 'refreshToken';
+        _this.refreshTokenRequest = config.refreshTokenRequest;
+        return _this;
+    }
+    JwtHttpComponent.prototype.getAxiosConfig = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var config, clientStorage, tokenValue, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        config = _super.prototype.getAxiosConfig.call(this);
+                        if (!!this._refreshToken) return [3 /*break*/, 4];
+                        clientStorage = this._components.clientStorage;
+                        tokenValue = clientStorage.get(this.refreshTokenKey, this.clientStorageName)
+                            || clientStorage.get(this.refreshTokenKey)
+                            || null;
+                        _a = this;
+                        if (!(tokenValue instanceof Promise)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, tokenValue];
+                    case 1:
+                        _b = _c.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _b = tokenValue;
+                        _c.label = 3;
+                    case 3:
+                        _a._refreshToken = _b;
+                        if (this._refreshToken) {
+                            clientStorage.set(this.refreshTokenKey, this._refreshToken, this.clientStorageName, this.clientStorageExpiresIn);
+                        }
+                        _c.label = 4;
+                    case 4: return [2 /*return*/, config];
+                }
+            });
+        });
+    };
+    JwtHttpComponent.prototype.setRefreshTokenInterceptor = function (axiosInstance) {
+        var _this = this;
+        axiosInstance.interceptors.response.use(function (config) { return config; }, function (error) { return __awaiter(_this, void 0, void 0, function () {
+            var originalRequest, store, response, accessToken, _a;
+            var _b;
+            var _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        originalRequest = error.config;
+                        if (!(error.response.status === 401
+                            && error.config
+                            && !error.config._isRetry
+                            && originalRequest.url !== this.getUrl((_c = this.refreshTokenRequest) === null || _c === void 0 ? void 0 : _c.url))) return [3 /*break*/, 5];
+                        this.removeAccessToken();
+                        store = this._components.store;
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.send(this.refreshTokenRequest.method, this.refreshTokenRequest.url, (_b = {},
+                                _b[this.refreshTokenKey] = this._refreshToken,
+                                _b))];
+                    case 2:
+                        response = _e.sent();
+                        accessToken = (_d = response === null || response === void 0 ? void 0 : response.data) === null || _d === void 0 ? void 0 : _d[this.accessTokenKey];
+                        if (accessToken) {
+                            this.setAccessToken(accessToken);
+                            originalRequest._isRetry = true;
+                            originalRequest.headers.Authorization = 'Bearer ' + accessToken;
+                            return [2 /*return*/, axiosInstance.request(originalRequest)];
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _a = _e.sent();
+                        store.dispatch((0, auth_1.logout)());
+                        return [3 /*break*/, 4];
+                    case 4:
+                        store.dispatch((0, auth_1.logout)());
+                        _e.label = 5;
+                    case 5: throw error;
+                }
+            });
+        }); });
+    };
+    JwtHttpComponent.prototype.getAxiosInstance = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!!this._axios) return [3 /*break*/, 2];
+                        _a = this;
+                        _c = (_b = axios_1["default"]).create;
+                        return [4 /*yield*/, this.getAxiosConfig()];
+                    case 1:
+                        _a._axios = _c.apply(_b, [_d.sent()]);
+                        this.setRefreshTokenInterceptor(this._axios);
+                        _d.label = 2;
+                    case 2: return [2 /*return*/, this._axios];
+                }
+            });
+        });
+    };
+    JwtHttpComponent.prototype.removeRefreshToken = function () {
+        this._refreshToken = null;
+        this.resetConfig();
+        this._components.clientStorage.remove(this.refreshTokenKey, this.clientStorageName);
+    };
+    JwtHttpComponent.prototype.setRefreshToken = function (value) {
+        this._refreshToken = value;
+        this.resetConfig();
+        this._components.clientStorage.set(this.refreshTokenKey, value, this.clientStorageName, this.clientStorageExpiresIn);
+    };
+    JwtHttpComponent.prototype.getRefreshToken = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(this._refreshToken === false)) return [3 /*break*/, 2];
+                        _a = this;
+                        return [4 /*yield*/, this._components.clientStorage.get(this.refreshTokenKey, this.clientStorageName)];
+                    case 1:
+                        _a._refreshToken = (_b.sent()) || null;
+                        _b.label = 2;
+                    case 2: return [2 /*return*/, this._refreshToken];
+                }
+            });
+        });
+    };
+    JwtHttpComponent.prototype.onLogout = function () {
+        this.removeAccessToken();
+        this.removeRefreshToken();
+    };
+    JwtHttpComponent.prototype.onLogin = function (params) {
+        this.setAccessToken(params.accessToken);
+        this.setRefreshToken(params.refreshToken);
+    };
+    return JwtHttpComponent;
+}(HttpComponent_1["default"]));
+exports["default"] = JwtHttpComponent;

package/src/components/StoreComponent.d.ts

@@ -0,0 +1,95 @@
+import { RouterState } from 'connected-react-router';
+import { History, LocationState } from 'history';
+import { Store, Dispatch, Unsubscribe, Reducer, AnyAction } from 'redux';
+import { IComponents } from '../providers/ComponentsProvider';
+declare global {
+    interface Window {
+        APP_REDUX_PRELOAD_STATES?: [any];
+        __REDUX_DEVTOOLS_EXTENSION__?: any;
+    }
+}
+interface IStoreComponentConfig {
+    initialState: Record<string, any>;
+    history: History;
+}
+type AsyncReducersMap = {
+    router?: Reducer<RouterState<LocationState>, AnyAction>;
+    [key: string]: Reducer<any, AnyAction> | undefined;
+};
+type RootState<R extends AsyncReducersMap> = {
+    [K in keyof R]: R[K] extends Reducer<infer S, AnyAction> ? S : never;
+};
+type CreateRootReducer = <R extends AsyncReducersMap>(reducers: R) => Reducer<RootState<R>, AnyAction>;
+export interface IStoreComponent {
+    /**
+     * Редьюсеры
+     */
+    reducers: CreateRootReducer;
+    /**
+     * Хранилище
+     */
+    store: Store;
+    /**
+     * Инициализация
+     */
+    init(config: IStoreComponentConfig): void;
+    /**
+     * Инициализация хранилища
+     */
+    initStore(config: IStoreComponentConfig): void;
+    /**
+     * Конфигурация
+     */
+    configurate(): void;
+    /**
+     * Метод для dispatch
+     * @param action Экшен для изменения состояния.
+     */
+    dispatch: Dispatch<any>;
+    /**
+     * Получение состояния
+     */
+    getState(): Record<string, any>;
+    /**
+     * Подписка
+     * @param handler Обработчик изменения состояния.
+     */
+    subscribe(handler: () => void): Unsubscribe;
+    /**
+     * Добавление редьюсеров
+     * @param asyncReducers Коллекция редьюсеров.
+     */
+    addReducers(asyncReducers: any): void;
+    /**
+     * Метод, который вызывается при ошибке
+     * @param error Объект ошибки.
+     * @param action Callback функция вызываемая при ошибке.
+     */
+    errorHandler(error: any, action: any): void;
+    [key: string]: any;
+}
+/**
+ * Store Component
+ * Обертка над Redux Store со встроенными middleware (thunk, multi, promise..) и react-router.
+ */
+export default class StoreComponent implements IStoreComponent {
+    _asyncReducers: AsyncReducersMap;
+    _components: IComponents;
+    reducers: CreateRootReducer;
+    _routerReducer: Reducer<RouterState<LocationState>>;
+    history: History | null;
+    navigationNative: any;
+    store: Store | null;
+    lastAction: string;
+    constructor(components: IComponents, config: any, lazyInit?: boolean);
+    init(config: IStoreComponentConfig): void;
+    initStore(config: IStoreComponentConfig): void;
+    configurate(): void;
+    dispatch(action: any): any;
+    getState(): any;
+    subscribe(handler: any): Unsubscribe;
+    addReducers(asyncReducers: AsyncReducersMap): void;
+    errorHandler(error: any, action: any): void;
+    _prepare(action: any, dispatch: Dispatch<any>, getState: Record<string, any>): any;
+}
+export {};

package/src/components/StoreComponent.js

@@ -0,0 +1,146 @@
+"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;
+/* eslint-disable no-restricted-globals */
+var connected_react_router_1 = require("connected-react-router");
+var history_1 = require("history");
+var get_1 = __importDefault(require("lodash-es/get"));
+var isPlainObject_1 = __importDefault(require("lodash-es/isPlainObject"));
+var merge_1 = __importDefault(require("lodash-es/merge"));
+var redux_1 = require("redux");
+/**
+ * Store Component
+ * Обертка над Redux Store со встроенными middleware (thunk, multi, promise..) и react-router.
+ */
+var StoreComponent = /** @class */ (function () {
+    function StoreComponent(components, config, lazyInit) {
+        if (lazyInit === void 0) { lazyInit = false; }
+        var _a;
+        this._components = components;
+        this.reducers = config.reducers;
+        this.history = null;
+        this.store = (_a = config.store) !== null && _a !== void 0 ? _a : null;
+        this.lastAction = null;
+        this._asyncReducers = {};
+        this.getState = this.getState.bind(this);
+        this.dispatch = this.dispatch.bind(this);
+        this.subscribe = this.subscribe.bind(this);
+        if (!lazyInit) {
+            this.initStore(config);
+        }
+    }
+    StoreComponent.prototype.init = function (config) {
+        this.initStore(config);
+        this.configurate();
+    };
+    StoreComponent.prototype.initStore = function (config) {
+        var _this = this;
+        var initialState = __assign(__assign({}, (process.env.IS_WEB
+            ? merge_1["default"].apply(void 0, (window.APP_REDUX_PRELOAD_STATES || [{}])) : {})), config.initialState);
+        if (window === null || window === void 0 ? void 0 : window.APP_REDUX_PRELOAD_STATES) {
+            delete window.APP_REDUX_PRELOAD_STATES;
+        }
+        if (process.env.PLATFORM !== 'mobile') {
+            var createHistory = process.env.IS_SSR || typeof location === 'undefined'
+                ? history_1.createMemoryHistory
+                : location.protocol === 'file:'
+                    ? history_1.createHashHistory
+                    : history_1.createBrowserHistory;
+            this.history = createHistory(__assign(__assign({}, (0, get_1["default"])(initialState, 'config.store.history', {})), config.history));
+            // Add '?' for fix connected-react-router
+            if (process.env.IS_SSR && !this.history.location.search) {
+                this.history.location.search = '?';
+            }
+            this._routerReducer = (0, connected_react_router_1.connectRouter)(this.history);
+        }
+        if (!this.store) {
+            this.store = (0, redux_1.createStore)(this.reducers(this._routerReducer ? {
+                router: this._routerReducer
+            } : {}), initialState, (0, redux_1.compose)((0, redux_1.applyMiddleware)(function (_a) {
+                var getState = _a.getState;
+                return function (next) { return function (action) { return _this._prepare(action, next, getState); }; };
+            }), (0, redux_1.applyMiddleware)((0, connected_react_router_1.routerMiddleware)(this.history)), !process.env.IS_SSR && window.__REDUX_DEVTOOLS_EXTENSION__ && process.env.PLATFORM !== 'mobile'
+                ? window.__REDUX_DEVTOOLS_EXTENSION__()
+                : function (f) { return f; }));
+        }
+    };
+    StoreComponent.prototype.configurate = function () {
+        // Apply configuration
+        var customConfig = this.getState().config || {};
+        var components = this._components;
+        (0, merge_1["default"])(components.clientStorage, customConfig.clientStorage);
+        (0, merge_1["default"])(components.html, customConfig.html);
+        (0, merge_1["default"])(components.http, customConfig.http);
+        (0, merge_1["default"])(components.locale, customConfig.locale);
+        (0, merge_1["default"])(components.resource, customConfig.resource);
+        (0, merge_1["default"])(components.store, customConfig.store);
+        (0, merge_1["default"])(components.ui, customConfig.ui);
+        (0, merge_1["default"])(components.widget, customConfig.widget);
+    };
+    StoreComponent.prototype.dispatch = function (action) {
+        return this.store.dispatch(action);
+    };
+    StoreComponent.prototype.getState = function () {
+        return this.store.getState();
+    };
+    StoreComponent.prototype.subscribe = function (handler) {
+        return this.store.subscribe(handler);
+    };
+    StoreComponent.prototype.addReducers = function (asyncReducers) {
+        this._asyncReducers = __assign(__assign({ router: this._routerReducer }, this._asyncReducers), asyncReducers);
+        this.store.replaceReducer(this.reducers(this._asyncReducers));
+    };
+    StoreComponent.prototype.errorHandler = function (error, action) {
+        throw error;
+    };
+    StoreComponent.prototype._prepare = function (action, dispatch, getState) {
+        var _this = this;
+        // Multiple dispatch (redux-multi)
+        if (Array.isArray(action)) {
+            return action
+                .filter(function (v) { return v; })
+                .map(function (p) { return _this._prepare(p, dispatch, getState); });
+        }
+        // Function wraper (redux-thunk)
+        if (typeof action === 'function') {
+            return action(function (p) { return _this._prepare(p, dispatch, getState); }, getState, this._components);
+        }
+        // Promise, detect errors on rejects
+        // eslint-disable-next-line max-len
+        // Detect action through instanceof Promise is not working in production mode, then used single detection by type
+        if (typeof action === 'object'
+            && typeof action.then === 'function'
+            && typeof action["catch"] === 'function') {
+            return action
+                .then(function (payload) { return _this._prepare(payload, dispatch, getState); })["catch"](function (e) {
+                _this.errorHandler(e, function (p) { return _this._prepare(p, dispatch, getState); });
+            });
+        }
+        // Default case
+        if ((0, isPlainObject_1["default"])(action) && action.type) {
+            this.lastAction = action.type;
+            try {
+                return dispatch(action);
+            }
+            catch (e) {
+                this.errorHandler(e, function (p) { return _this._prepare(p, dispatch, getState); });
+            }
+        }
+        return action;
+    };
+    return StoreComponent;
+}());
+exports["default"] = StoreComponent;