@jbt/ng-rx/bundles/jbt-ng-rx.umd.js

Configurable ngrx

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs'), require('rxjs/operators'), require('@jbt/utils'), require('@ngrx/store'), require('@angular/core'), require('@ngrx/effects')) :
    typeof define === 'function' && define.amd ? define('@jbt/ng-rx', ['exports', 'rxjs', 'rxjs/operators', '@jbt/utils', '@ngrx/store', '@angular/core', '@ngrx/effects'], factory) :
    (global = global || self, factory((global.jbt = global.jbt || {}, global.jbt['ng-rx'] = {}), global.rxjs, global.rxjs.operators, global.utils, global.store, global.ng.core, global.effects$1));
}(this, (function (exports, rxjs$1, operators$1, utils, store, core, effects$1) { 'use strict';

    rxjs$1 = rxjs$1 && rxjs$1.hasOwnProperty('default') ? rxjs$1['default'] : rxjs$1;
    operators$1 = operators$1 && operators$1.hasOwnProperty('default') ? operators$1['default'] : operators$1;
    utils = utils && utils.hasOwnProperty('default') ? utils['default'] : utils;
    store = store && store.hasOwnProperty('default') ? store['default'] : store;
    core = core && core.hasOwnProperty('default') ? core['default'] : core;
    effects$1 = effects$1 && effects$1.hasOwnProperty('default') ? effects$1['default'] : effects$1;

    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

    function commonjsRequire () {
    	throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
    }

    function unwrapExports (x) {
    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
    }

    function createCommonjsModule(fn, module) {
    	return module = { exports: {} }, fn(module, module.exports), module.exports;
    }

    function getCjsExportFromNamespace (n) {
    	return n && n['default'] || n;
    }

    var effectType = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });
    /** @enum {string} */
    var EFFECT_TYPE = {
        ACTION: 'action',
        SEQUENCE: 'sequence',
        PARALLEL: 'parallel',
    };
    exports.EFFECT_TYPE = EFFECT_TYPE;

    });

    var effectType$1 = unwrapExports(effectType);
    var effectType_1 = effectType.EFFECT_TYPE;

    var mergeHotStreamHandlerArray = createCommonjsModule(function (module, exports) {
    "use strict";
    var __extends = (commonjsGlobal && commonjsGlobal.__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 (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });


    /** @type {?} */
    var ERRORS = {
        HEADER: "\n    MergeHotStreamHandlerArraySubscriber Error.\n\n    ",
        NOT_A_FUNCTION: "\n    Supplied handler ignored: It is not a function\n\n    ",
        NOT_AN_OBSERVABLE: "\n    Supplied handler ignored: It does not return an observable\n\n    "
    };
    var MergeHotStreamHandlerArraySubscriber = /** @class */ (function (_super) {
        __extends(MergeHotStreamHandlerArraySubscriber, _super);
        function MergeHotStreamHandlerArraySubscriber(sub, effects) {
            var _this = _super.call(this, sub) || this;
            _this._handlers = [];
            _this._handlers = effects || _this._handlers;
            return _this;
        }
        /**
         * @param {?} value
         * @return {?}
         */
        MergeHotStreamHandlerArraySubscriber.prototype._next = /**
         * @param {?} value
         * @return {?}
         */
        function (value) {
            var _this = this;
            /** @type {?} */
            var inner$ = rxjs$1.merge(this._handlers
                .filter((/**
             * @param {?} handler
             * @return {?}
             */
            function (handler) {
                /** @type {?} */
                var condition = typeof handler === 'function';
                if (!condition) {
                    console.warn(ERRORS.HEADER + ERRORS.NOT_A_FUNCTION, handler);
                }
                return condition;
            }))
                .filter((/**
             * @param {?} handler
             * @return {?}
             */
            function (handler) {
                /** @type {?} */
                var condition = rxjs$1.isObservable(handler(value));
                if (!condition) {
                    console.warn(ERRORS.HEADER + ERRORS.NOT_AN_OBSERVABLE, handler);
                }
                return condition;
            }))
                .map((/**
             * @param {?} handler
             * @return {?}
             */
            function (handler) {
                return handler(value);
            }))).pipe(operators$1.mergeAll());
            inner$.subscribe({
                next: (/**
                 * @param {?} v
                 * @return {?}
                 */
                function (v) {
                    _this.destination.next(v);
                })
            });
        };
        return MergeHotStreamHandlerArraySubscriber;
    }(rxjs$1.Subscriber));
    if (false) {
        /**
         * @type {?}
         * @private
         */
        MergeHotStreamHandlerArraySubscriber.prototype._handlers;
    }
    /** @type {?} */
    exports.mergeHotStreamHandlerArray = (/**
     * @param {?} handlers
     * @return {?}
     */
    function (handlers) { return (/**
     * @param {?} source
     * @return {?}
     */
    function (source) { return source.lift({
        call: /**
         * @param {?} sub
         * @param {?} s
         * @return {?}
         */
        function (sub, s) {
            s.subscribe(new MergeHotStreamHandlerArraySubscriber(sub, handlers));
        }
    }); }); });

    });

    var mergeHotStreamHandlerArray$1 = unwrapExports(mergeHotStreamHandlerArray);
    var mergeHotStreamHandlerArray_1 = mergeHotStreamHandlerArray.mergeHotStreamHandlerArray;

    var operators = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });

    exports.mergeHotStreamHandlerArray = mergeHotStreamHandlerArray.mergeHotStreamHandlerArray;

    });

    var index = unwrapExports(operators);
    var operators_1 = operators.mergeHotStreamHandlerArray;

    var rxjs = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });

    exports.mergeHotStreamHandlerArray = operators.mergeHotStreamHandlerArray;

    });

    var index$1 = unwrapExports(rxjs);
    var rxjs_1 = rxjs.mergeHotStreamHandlerArray;

    var effectsConfigurator = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });




    /**
     * ***************************************************
     *
     * EffectsConfigurator
     *
     * ****************************************************
     */
    var /**
     * ***************************************************
     *
     * EffectsConfigurator
     *
     * ****************************************************
     */
    EffectsConfigurator = /** @class */ (function () {
        function EffectsConfigurator(effectsRepository, actions$, store) {
            var _this = this;
            var _a;
            this._setupMethodMap = (_a = {},
                _a[effectType.EFFECT_TYPE.SEQUENCE] = this._setUpSequentialEffect,
                _a[effectType.EFFECT_TYPE.PARALLEL] = this._setUpParallelEffect,
                _a[effectType.EFFECT_TYPE.ACTION] = this._setUpActionEffect,
                _a);
            this._effects = [];
            this._effectsRepository = effectsRepository;
            this._effect = actions$.pipe(rxjs.mergeHotStreamHandlerArray(this._effects), operators$1.filter((/**
             * @param {?} action
             * @return {?}
             */
            function (action) { return _this._isAction(action); })));
            this._effect.subscribe((/**
             * @param {?} action
             * @return {?}
             */
            function (action) {
                store.dispatch(action);
            }));
        }
        /**
         * @param {?=} effectsConfig
         * @return {?}
         */
        EffectsConfigurator.prototype.addEffects = /**
         * @param {?=} effectsConfig
         * @return {?}
         */
        function (effectsConfig) {
            var _this = this;
            if (effectsConfig === void 0) { effectsConfig = []; }
            effectsConfig.forEach((/**
             * @param {?} config
             * @return {?}
             */
            function (config) {
                /** @type {?} */
                var method = _this._setupMethodMap[config.type].call(_this, config);
                _this._effects.push(method);
            }));
        };
        /**
         * @private
         * @param {?} action
         * @return {?}
         */
        EffectsConfigurator.prototype._isAction = /**
         * @private
         * @param {?} action
         * @return {?}
         */
        function (action) {
            return action && action.type && (typeof action.type === 'string');
        };
        /**
         * @private
         * @param {?} config
         * @return {?}
         */
        EffectsConfigurator.prototype._setUpSequentialEffect = /**
         * @private
         * @param {?} config
         * @return {?}
         */
        function (config) {
            var _this = this;
            return (/**
             * @param {?} action
             * @return {?}
             */
            function (action) { return rxjs$1.of(action).pipe(operators$1.filter((/**
             * @param {?} action
             * @return {?}
             */
            function (action) { return _this._filterAction(action, config); })), operators$1.concatMap((/**
             * @param {?} action
             * @return {?}
             */
            function (action) { return config.handlers.map((/**
             * @param {?} handler
             * @return {?}
             */
            function (handler) {
                /** @type {?} */
                var handlerFn = _this._getHandler(handler, config);
                return handlerFn(action, config);
            })); })), operators$1.concatAll()); });
        };
        /**
         * @private
         * @param {?} config
         * @return {?}
         */
        EffectsConfigurator.prototype._setUpParallelEffect = /**
         * @private
         * @param {?} config
         * @return {?}
         */
        function (config) {
            var _this = this;
            return (/**
             * @param {?} action
             * @return {?}
             */
            function (action) { return rxjs$1.of(action).pipe(operators$1.filter((/**
             * @param {?} action
             * @return {?}
             */
            function (action) { return _this._filterAction(action, config); })), operators$1.mergeMap((/**
             * @param {?} action
             * @return {?}
             */
            function (action) { return config.handlers.map((/**
             * @param {?} handler
             * @return {?}
             */
            function (handler) {
                /** @type {?} */
                var handlerFn = _this._getHandler(handler, config);
                return handlerFn(action, config);
            })); })), operators$1.mergeAll()); });
        };
        /**
         * @private
         * @param {?} config
         * @return {?}
         */
        EffectsConfigurator.prototype._setUpActionEffect = /**
         * @private
         * @param {?} config
         * @return {?}
         */
        function (config) {
            var _this = this;
            return (/**
             * @param {?} action
             * @return {?}
             */
            function (action) { return rxjs$1.of(action).pipe(operators$1.filter((/**
             * @param {?} action
             * @return {?}
             */
            function (action) { return _this._filterAction(action, config); })), operators$1.map((/**
             * @param {?} action
             * @return {?}
             */
            function (action) {
                return {
                    type: config.result,
                    payload: action['payload']
                };
            }))); });
        };
        /**
         * @private
         * @param {?} action
         * @param {?} effectsConfig
         * @return {?}
         */
        EffectsConfigurator.prototype._filterAction = /**
         * @private
         * @param {?} action
         * @param {?} effectsConfig
         * @return {?}
         */
        function (action, effectsConfig) {
            /** @type {?} */
            var isCause = effectsConfig.causes.indexOf(action.type) > -1;
            /** @type {?} */
            var isWildcard = effectsConfig.causes.indexOf('*') > -1;
            return isWildcard || isCause;
        };
        /**
         * @private
         * @param {?} handler
         * @param {?} config
         * @return {?}
         */
        EffectsConfigurator.prototype._getHandler = /**
         * @private
         * @param {?} handler
         * @param {?} config
         * @return {?}
         */
        function (handler, config) {
            return (typeof handler === 'function')
                ? handler
                : this._effectsRepository.get(handler);
        };
        return EffectsConfigurator;
    }());
    exports.EffectsConfigurator = EffectsConfigurator;
    if (false) {
        /**
         * @type {?}
         * @private
         */
        EffectsConfigurator.prototype._setupMethodMap;
        /**
         * @type {?}
         * @private
         */
        EffectsConfigurator.prototype._effectsRepository;
        /**
         * @type {?}
         * @private
         */
        EffectsConfigurator.prototype._effect;
        /**
         * @type {?}
         * @private
         */
        EffectsConfigurator.prototype._effects;
    }

    });

    var effectsConfigurator$1 = unwrapExports(effectsConfigurator);
    var effectsConfigurator_1 = effectsConfigurator.EffectsConfigurator;

    var effectsRepository = createCommonjsModule(function (module, exports) {
    "use strict";
    var __extends = (commonjsGlobal && commonjsGlobal.__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 (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });


    var EffectsRepository = /** @class */ (function (_super) {
        __extends(EffectsRepository, _super);
        function EffectsRepository() {
            var _this = _super.call(this, {
                id: 'EffectsRepository',
                fallbackKey: 'default'
            }) || this;
            _this.addByMap({
                default: (/**
                 * @return {?}
                 */
                function () { return rxjs$1.of({ type: 'VOID' }); })
            });
            return _this;
        }
        return EffectsRepository;
    }(utils.Repository));
    exports.EffectsRepository = EffectsRepository;

    });

    var effectsRepository$1 = unwrapExports(effectsRepository);
    var effectsRepository_1 = effectsRepository.EffectsRepository;

    var effects = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });

    exports.EFFECT_TYPE = effectType.EFFECT_TYPE;

    exports.EffectsConfigurator = effectsConfigurator.EffectsConfigurator;

    exports.EffectsRepository = effectsRepository.EffectsRepository;

    });

    var index$2 = unwrapExports(effects);
    var effects_1 = effects.EFFECT_TYPE;
    var effects_2 = effects.EffectsConfigurator;
    var effects_3 = effects.EffectsRepository;

    var reducerConfiguration = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });
    /**
     * @record
     */
    function ReducerSingleConfiguration() { }
    exports.ReducerSingleConfiguration = ReducerSingleConfiguration;
    if (false) {
        /** @type {?} */
        ReducerSingleConfiguration.prototype.id;
        /** @type {?|undefined} */
        ReducerSingleConfiguration.prototype.initialState;
        /** @type {?|undefined} */
        ReducerSingleConfiguration.prototype.handlers;
    }
    /**
     * @record
     */
    function ReducerGroupConfiguration() { }
    exports.ReducerGroupConfiguration = ReducerGroupConfiguration;
    if (false) {
        /** @type {?} */
        ReducerGroupConfiguration.prototype.id;
        /** @type {?} */
        ReducerGroupConfiguration.prototype.children;
    }

    });

    var reducerConfiguration$1 = unwrapExports(reducerConfiguration);
    var reducerConfiguration_1 = reducerConfiguration.ReducerSingleConfiguration;
    var reducerConfiguration_2 = reducerConfiguration.ReducerGroupConfiguration;

    var reducersRepository = createCommonjsModule(function (module, exports) {
    "use strict";
    var __extends = (commonjsGlobal && commonjsGlobal.__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 (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });

    var ReducersRepository = /** @class */ (function (_super) {
        __extends(ReducersRepository, _super);
        function ReducersRepository() {
            var _this = _super.call(this, {
                id: 'ReducersRepository',
                fallbackKey: 'default'
            }) || this;
            _this.addByMap({
                default: (/**
                 * @param {?} state
                 * @return {?}
                 */
                function (state) { return state; })
            });
            return _this;
        }
        return ReducersRepository;
    }(utils.Repository));
    exports.ReducersRepository = ReducersRepository;

    });

    var reducersRepository$1 = unwrapExports(reducersRepository);
    var reducersRepository_1 = reducersRepository.ReducersRepository;

    var reducersConfigurator = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });


    var ReducersConfigurator = /** @class */ (function () {
        function ReducersConfigurator(store, reducersRepository) {
            this._config = {};
            this._store = store;
            this._reducersRepository = reducersRepository;
        }
        /**
         * @param {?} config
         * @return {?}
         */
        ReducersConfigurator.prototype.addReducers = /**
         * @param {?} config
         * @return {?}
         */
        function (config) {
            var _this = this;
            this._config[config.id] = (this._config[config.id])
                ? utils.ObjectUtils.mergeTrees(this._config[config.id], config)
                : config;
            Object.keys(this._config).forEach((/**
             * @param {?} key
             * @return {?}
             */
            function (key) { return _this._addReducer(_this._config[key]); }));
        };
        /**
         * @private
         * @param {?} reducerConfig
         * @return {?}
         */
        ReducersConfigurator.prototype._addReducer = /**
         * @private
         * @param {?} reducerConfig
         * @return {?}
         */
        function (reducerConfig) {
            this._store.addReducer(reducerConfig.id, this._createReducerFn(reducerConfig));
        };
        /**
         * @private
         * @param {?} config
         * @return {?}
         */
        ReducersConfigurator.prototype._createReducerFn = /**
         * @private
         * @param {?} config
         * @return {?}
         */
        function (config) {
            var _this = this;
            return (config.children)
                ? this._createReducersByConfig(config.children)
                : (/**
                 * @param {?} state
                 * @param {?} action
                 * @return {?}
                 */
                function (state, action) { return _this._mainReducer(state, action, config); });
        };
        /**
         * @private
         * @param {?=} config
         * @return {?}
         */
        ReducersConfigurator.prototype._createReducersByConfig = /**
         * @private
         * @param {?=} config
         * @return {?}
         */
        function (config) {
            if (config === void 0) { config = []; }
            /** @type {?} */
            var self = this;
            return store.combineReducers(config.reduce((/**
             * @param {?} reducers
             * @param {?} item
             * @return {?}
             */
            function (reducers, item) {
                reducers[item.id] = self._createReducerFn(item);
                return reducers;
            }), {}));
        };
        /**
         * @param {?} state
         * @param {?} action
         * @param {?} config
         * @return {?}
         */
        ReducersConfigurator.prototype._mainReducer = /**
         * @param {?} state
         * @param {?} action
         * @param {?} config
         * @return {?}
         */
        function (state, action, config) {
            if (!state) {
                return config.initialState;
            }
            config.handlers = config.handlers || {};
            /** @type {?} */
            var handler = this._getReducerHandlers(config.handlers[action.type]);
            return handler(state, action);
        };
        /**
         * @private
         * @param {?} handler
         * @return {?}
         */
        ReducersConfigurator.prototype._getReducerHandlers = /**
         * @private
         * @param {?} handler
         * @return {?}
         */
        function (handler) {
            return (typeof handler === 'function')
                ? handler
                : this._reducersRepository.get(handler);
        };
        return ReducersConfigurator;
    }());
    exports.ReducersConfigurator = ReducersConfigurator;
    if (false) {
        /**
         * @type {?}
         * @private
         */
        ReducersConfigurator.prototype._store;
        /**
         * @type {?}
         * @private
         */
        ReducersConfigurator.prototype._reducersRepository;
        /**
         * @type {?}
         * @private
         */
        ReducersConfigurator.prototype._config;
    }

    });

    var reducersConfigurator$1 = unwrapExports(reducersConfigurator);
    var reducersConfigurator_1 = reducersConfigurator.ReducersConfigurator;

    var reducerHandlers = createCommonjsModule(function (module, exports) {
    "use strict";
    var __assign = (commonjsGlobal && commonjsGlobal.__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);
    };
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });
    var DefaultReducerHandlers = /** @class */ (function () {
        function DefaultReducerHandlers() {
        }
        /**
         * @param {?} state
         * @param {?} action
         * @return {?}
         */
        DefaultReducerHandlers.set = /**
         * @param {?} state
         * @param {?} action
         * @return {?}
         */
        function (state, action) {
            return action.payload;
        };
        /**
         * @param {?} state
         * @param {?} action
         * @return {?}
         */
        DefaultReducerHandlers.override = /**
         * @param {?} state
         * @param {?} action
         * @return {?}
         */
        function (state, action) {
            return __assign({}, state, action.payload);
        };
        /**
         * @param {?} state
         * @param {?} action
         * @return {?}
         */
        DefaultReducerHandlers.noop = /**
         * @param {?} state
         * @param {?} action
         * @return {?}
         */
        function (state, action) {
            return state;
        };
        return DefaultReducerHandlers;
    }());
    exports.DefaultReducerHandlers = DefaultReducerHandlers;

    });

    var reducerHandlers$1 = unwrapExports(reducerHandlers);
    var reducerHandlers_1 = reducerHandlers.DefaultReducerHandlers;

    var reducers = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });


    exports.ReducersRepository = reducersRepository.ReducersRepository;

    exports.ReducersConfigurator = reducersConfigurator.ReducersConfigurator;

    exports.DefaultReducerHandlers = reducerHandlers.DefaultReducerHandlers;

    });

    var index$3 = unwrapExports(reducers);
    var reducers_1 = reducers.ReducersRepository;
    var reducers_2 = reducers.ReducersConfigurator;
    var reducers_3 = reducers.DefaultReducerHandlers;

    var selector = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });

    var Selector = /** @class */ (function () {
        function Selector() {
        }
        /**
         * @param {?} path
         * @return {?}
         */
        Selector.selectByPath = /**
         * @param {?} path
         * @return {?}
         */
        function (path) {
            /** @type {?} */
            var slices = path.split('.');
            /** @type {?} */
            var sel = slices
                .slice(1)
                .reduce((/**
             * @param {?} acc
             * @param {?} current
             * @return {?}
             */
            function (acc, current) { return store.createSelector(acc, (/**
             * @param {?} state
             * @return {?}
             */
            function (state) { return state[current]; })); }), store.createSelector((/**
             * @param {?} state
             * @return {?}
             */
            function (state) { return state[slices[0]]; }), (/**
             * @param {?} state
             * @return {?}
             */
            function (state) { return state; })));
            return store.select(sel);
        };
        return Selector;
    }());
    exports.Selector = Selector;

    });

    var selector$1 = unwrapExports(selector);
    var selector_1 = selector.Selector;

    var internals = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });

    exports.EffectsConfigurator = effects.EffectsConfigurator;
    exports.EffectsRepository = effects.EffectsRepository;
    exports.EFFECT_TYPE = effects.EFFECT_TYPE;

    exports.ReducersConfigurator = reducers.ReducersConfigurator;
    exports.ReducersRepository = reducers.ReducersRepository;

    exports.Selector = selector.Selector;

    });

    var index$4 = unwrapExports(internals);
    var internals_1 = internals.EffectsConfigurator;
    var internals_2 = internals.EffectsRepository;
    var internals_3 = internals.EFFECT_TYPE;
    var internals_4 = internals.ReducersConfigurator;
    var internals_5 = internals.ReducersRepository;
    var internals_6 = internals.Selector;

    var state = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });

    var State = /** @class */ (function () {
        function State(store, reducersConfigurator, effectsConfigurator, reducersRepository, effectsRepository) {
            this._store = store;
            this._reducersConfigurator = reducersConfigurator;
            this._effectsConfigurator = effectsConfigurator;
            this._reducersRepository = reducersRepository;
            this._effectsRepository = effectsRepository;
        }
        /**
         * @param {?} config
         * @return {?}
         */
        State.prototype.configure = /**
         * @param {?} config
         * @return {?}
         */
        function (config) {
            if (config.state) {
                this.configureReducers(config.state);
            }
            if (config.effects) {
                this.configureEffects(config.effects);
            }
        };
        /**
         * @param {?} config
         * @return {?}
         */
        State.prototype.configureReducers = /**
         * @param {?} config
         * @return {?}
         */
        function (config) {
            this._reducersConfigurator.addReducers(config);
        };
        /**
         * @param {?} config
         * @return {?}
         */
        State.prototype.configureEffects = /**
         * @param {?} config
         * @return {?}
         */
        function (config) {
            this._effectsConfigurator.addEffects(config);
        };
        /**
         * @param {?} reducersMap
         * @return {?}
         */
        State.prototype.addReducerHandlers = /**
         * @param {?} reducersMap
         * @return {?}
         */
        function (reducersMap) {
            this._reducersRepository.addByMap(reducersMap);
        };
        /**
         * @param {?} effectsMap
         * @return {?}
         */
        State.prototype.addEffectHandlers = /**
         * @param {?} effectsMap
         * @return {?}
         */
        function (effectsMap) {
            this._effectsRepository.addByMap(effectsMap);
        };
        /**
         * @param {?} type
         * @param {?=} payload
         * @return {?}
         */
        State.prototype.dispatch = /**
         * @param {?} type
         * @param {?=} payload
         * @return {?}
         */
        function (type, payload) {
            this._store.dispatch({
                type: type,
                payload: payload
            });
        };
        /**
         * @param {?} path
         * @return {?}
         */
        State.prototype.select = /**
         * @param {?} path
         * @return {?}
         */
        function (path) {
            return this._store.pipe(internals.Selector.selectByPath(path));
        };
        return State;
    }());
    exports.State = State;
    if (false) {
        /**
         * @type {?}
         * @private
         */
        State.prototype._store;
        /**
         * @type {?}
         * @private
         */
        State.prototype._reducersConfigurator;
        /**
         * @type {?}
         * @private
         */
        State.prototype._reducersRepository;
        /**
         * @type {?}
         * @private
         */
        State.prototype._effectsConfigurator;
        /**
         * @type {?}
         * @private
         */
        State.prototype._effectsRepository;
    }

    });

    var state$1 = unwrapExports(state);
    var state_1 = state.State;

    var internals_module = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });





    var ProviderFactory = /** @class */ (function () {
        function ProviderFactory() {
        }
        /**
         * @param {?} store
         * @param {?} reducersRepository
         * @return {?}
         */
        ProviderFactory.createReducersConfigurator = /**
         * @param {?} store
         * @param {?} reducersRepository
         * @return {?}
         */
        function (store, reducersRepository) {
            return new reducers.ReducersConfigurator(store, reducersRepository);
        };
        /**
         * @param {?} effectsRepository
         * @param {?} actions$
         * @param {?} store
         * @return {?}
         */
        ProviderFactory.createEffectsConfigurator = /**
         * @param {?} effectsRepository
         * @param {?} actions$
         * @param {?} store
         * @return {?}
         */
        function (effectsRepository, actions$, store) {
            return new effects.EffectsConfigurator(effectsRepository, actions$, store);
        };
        return ProviderFactory;
    }());
    exports.ProviderFactory = ProviderFactory;
    var InternalsModule = /** @class */ (function () {
        function InternalsModule() {
        }
        InternalsModule.decorators = [
            { type: core.NgModule, args: [{
                        imports: [
                            store.StoreModule.forRoot({}),
                            effects$1.EffectsModule.forRoot([])
                        ],
                        providers: [{
                                provide: reducers.ReducersConfigurator,
                                useFactory: ProviderFactory.createReducersConfigurator,
                                deps: [
                                    store.Store,
                                    reducers.ReducersRepository
                                ]
                            }, {
                                provide: effects.EffectsConfigurator,
                                useFactory: ProviderFactory.createEffectsConfigurator,
                                deps: [
                                    effects.EffectsRepository,
                                    effects$1.Actions,
                                    store.Store,
                                    effects$1.EffectSources,
                                ]
                            },
                            effects.EffectsRepository,
                            reducers.ReducersRepository,
                        ],
                        exports: [
                            store.StoreModule
                        ]
                    },] }
        ];
        return InternalsModule;
    }());
    exports.InternalsModule = InternalsModule;

    });

    var internals_module$1 = unwrapExports(internals_module);
    var internals_module_1 = internals_module.ProviderFactory;
    var internals_module_2 = internals_module.InternalsModule;

    var state_module = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });





    /**
     * @param {?} store
     * @param {?} reducer
     * @param {?} effects
     * @param {?} reducersRepository
     * @param {?} effectsRepository
     * @return {?}
     */
    function createState(store, reducer, effects, reducersRepository, effectsRepository) {
        return new state.State(store, reducer, effects, reducersRepository, effectsRepository);
    }
    exports.createState = createState;
    var StateModule = /** @class */ (function () {
        function StateModule() {
        }
        /**
         * @return {?}
         */
        StateModule.forRoot = /**
         * @return {?}
         */
        function () {
            return {
                ngModule: StateModule,
                providers: [{
                        provide: state.State,
                        useFactory: createState,
                        deps: [
                            store.Store,
                            internals.ReducersConfigurator,
                            internals.EffectsConfigurator,
                            internals.ReducersRepository,
                            internals.EffectsRepository
                        ]
                    }]
            };
        };
        /**
         * @return {?}
         */
        StateModule.forChild = /**
         * @return {?}
         */
        function () {
            return {
                ngModule: StateModule,
                providers: []
            };
        };
        StateModule.decorators = [
            { type: core.NgModule, args: [{
                        imports: [internals_module.InternalsModule],
                    },] }
        ];
        return StateModule;
    }());
    exports.StateModule = StateModule;

    });

    var state_module$1 = unwrapExports(state_module);
    var state_module_1 = state_module.createState;
    var state_module_2 = state_module.StateModule;

    var lib = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });

    exports.State = state.State;

    exports.StateModule = state_module.StateModule;

    exports.EFFECT_TYPE = internals.EFFECT_TYPE;

    });

    var index$5 = unwrapExports(lib);
    var lib_1 = lib.State;
    var lib_2 = lib.StateModule;
    var lib_3 = lib.EFFECT_TYPE;

    var esm5 = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });
    /*
     * Public API Surface of ng-rx
     */

    exports.State = lib.State;
    exports.StateModule = lib.StateModule;
    exports.EFFECT_TYPE = lib.EFFECT_TYPE;

    });

    var index$6 = unwrapExports(esm5);
    var esm5_1 = esm5.State;
    var esm5_2 = esm5.StateModule;
    var esm5_3 = esm5.EFFECT_TYPE;

    var jbtNgRx = createCommonjsModule(function (module, exports) {
    "use strict";
    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
     */
    Object.defineProperty(exports, "__esModule", { value: true });
    /**
     * Generated bundle index. Do not edit.
     */

    exports.State = esm5.State;
    exports.StateModule = esm5.StateModule;
    exports.EFFECT_TYPE = esm5.EFFECT_TYPE;

    exports.ɵb = effectsConfigurator.EffectsConfigurator;

    exports.ɵc = effectsRepository.EffectsRepository;

    exports.ɵg = internals_module.InternalsModule;
    exports.ɵf = internals_module.ProviderFactory;

    exports.ɵe = reducersConfigurator.ReducersConfigurator;

    exports.ɵd = reducersRepository.ReducersRepository;

    exports.ɵa = state_module.createState;

    });

    var jbtNgRx$1 = unwrapExports(jbtNgRx);
    var jbtNgRx_1 = jbtNgRx.State;
    var jbtNgRx_2 = jbtNgRx.StateModule;
    var jbtNgRx_3 = jbtNgRx.EFFECT_TYPE;

    exports.EFFECT_TYPE = jbtNgRx_3;
    exports.State = jbtNgRx_1;
    exports.StateModule = jbtNgRx_2;
    exports.default = jbtNgRx$1;

    Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=jbt-ng-rx.umd.js.map