{"version":3,"sources":["webpack:///./node_modules/aurelia-store/dist/native-modules/aurelia-store.js?b961","webpack:///./node_modules/aurelia-store/dist/native-modules/aurelia-store.js"],"names":["module","exports","cb","require","Object","entries","obj","ownProps","keys","i","length","resArray","Array","extendStatics","d","b","setPrototypeOf","__proto__","p","hasOwnProperty","__extends","__","this","constructor","prototype","create","__assign","assign","t","s","n","arguments","call","apply","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","value","step","next","e","rejected","result","done","then","__generator","body","f","y","g","_","label","sent","trys","ops","verb","Symbol","iterator","v","op","TypeError","pop","push","jump","state","isStateHistory","index","future","past","present","newPast","concat","slice","newPresent","newFuture","jumpToFuture","jumpToPast","nextStateHistory","presentStateHistory","nextPresent","applyLimits","limit","history","isArray","MiddlewarePlacement","LogLevel","DEFAULT_LOCAL_STORAGE_KEY","logMiddleware","settings","logType","console","localStorageMiddleware","global","localStorage","key","setItem","JSON","stringify","rehydrateFromLocalStorage","storedState","getItem","parse","PerformanceMeasurement","LoggerIndexed","_super","getLogType","options","definition","defaultLevel","logDefinitions","values","includes","UnregisteredActionError","reducer","name","Error","Store","initialState","logger","devToolsAvailable","actions","Map","middlewares","dispatchQueue","isUndoable","undoable","_state","asObservable","devToolsOptions","disable","setupDevTools","registerHistoryMethods","registerMiddleware","placement","set","unregisterMiddleware","has","delete","isMiddlewareRegistered","middleware","registerAction","type","unregisterAction","isActionRegistered","undefined","from","find","action","resetToState","dispatch","params","_i","lookupAction","queueDispatch","pipe","_this","pipeline","dispatchPipe","nextReducer","nextParams","_a","handleQueue","queueItem","e_1","internalDispatch","shift","unregisteredAction","pipedActions","callingAction","beforeMiddleswaresResult","pipedActions_1","resultingState","measures","marks","totalDuration","a","performance","mark","map","get","join","reduce","logDispatchedActions","info","executeMiddlewares","getValue","Before","clearMarks","clearMeasures","After","measurePerformance","StartEnd","measure","getEntriesByName","duration","All","getEntriesByType","startTime","updateDevToolsState","filter","prev","curr","_arr","_b","_c","e_2","_d","propagateError","devToolsExtension","debug","devTools","__REDUX_DEVTOOLS_EXTENSION__","connect","init","subscribe","message","payload","byName","args","arg","parsedState","send","dispatchify","store","instance","executeSteps","shouldLogResults","steps","logStep","tryStep","lastStep","stepIdx","res","group","log","groupEnd","err","currentStep","forEach","defaultSelector","connectTo","$store","_settings","selector","getSource","source","createSelectors","isSelectorObj","fallbackSelector","target","targets","changeHandlers","onChanged","originalCreated","created","originalSetup","setup","bind","originalTeardown","teardown","unbind","view","container","_stateSubscriptions","lastTargetIdx","oldState","accu","handlerName","idx","sub","closed","unsubscribe","configure","aurelia","initState","registerInstance"],"mappings":"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","file":"vendor.aurelia-store~d1763766.00defeb1f929a909a6f8.chunk.js","sourcesContent":["module.exports = function(cb) {\n\trequire.ensure([], function(require) {\n\t\tcb(require(\"!!./aurelia-store.js\"));\n\t}, \"store\");\n}","import { BehaviorSubject, Subscription, Observable } from 'rxjs';\nimport { Container } from 'aurelia-dependency-injection';\nimport { Logger, getLogger } from 'aurelia-logging';\nimport { PLATFORM } from 'aurelia-pal';\nimport { skip, take, delay } from 'rxjs/operators';\n\n/* istanbul ignore next */\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries#Polyfill\nif (!Object.entries) {\n    Object.entries = function (obj) {\n        var ownProps = Object.keys(obj), i = ownProps.length, resArray = new Array(i); // preallocate the Array\n        while (i--) {\n            resArray[i] = [ownProps[i], obj[ownProps[i]]];\n        }\n        return resArray;\n    };\n}\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nfunction __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nvar __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\n\r\nfunction __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nfunction __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            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;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\n\nfunction jump(state, n) {\n    if (!isStateHistory(state)) {\n        return state;\n    }\n    if (n > 0)\n        return jumpToFuture(state, n - 1);\n    if (n < 0)\n        return jumpToPast(state, state.past.length + n);\n    return state;\n}\nfunction jumpToFuture(state, index) {\n    if (index < 0 || index >= state.future.length) {\n        return state;\n    }\n    var past = state.past, future = state.future, present = state.present;\n    var newPast = past.concat([present], future.slice(0, index));\n    var newPresent = future[index];\n    var newFuture = future.slice(index + 1);\n    return { past: newPast, present: newPresent, future: newFuture };\n}\nfunction jumpToPast(state, index) {\n    if (index < 0 || index >= state.past.length) {\n        return state;\n    }\n    var past = state.past, future = state.future, present = state.present;\n    var newPast = past.slice(0, index);\n    var newFuture = past.slice(index + 1).concat([present], future);\n    var newPresent = past[index];\n    return { past: newPast, present: newPresent, future: newFuture };\n}\nfunction nextStateHistory(presentStateHistory, nextPresent) {\n    return Object.assign({}, presentStateHistory, {\n        past: presentStateHistory.past.concat([presentStateHistory.present]),\n        present: nextPresent,\n        future: []\n    });\n}\nfunction applyLimits(state, limit) {\n    if (isStateHistory(state)) {\n        if (state.past.length > limit) {\n            state.past = state.past.slice(state.past.length - limit);\n        }\n        if (state.future.length > limit) {\n            state.future = state.future.slice(0, limit);\n        }\n    }\n    return state;\n}\nfunction isStateHistory(history) {\n    return typeof history.present !== \"undefined\" &&\n        typeof history.future !== \"undefined\" &&\n        typeof history.past !== \"undefined\" &&\n        Array.isArray(history.future) &&\n        Array.isArray(history.past);\n}\n\nvar DEFAULT_LOCAL_STORAGE_KEY = \"aurelia-store-state\";\nvar MiddlewarePlacement;\n(function (MiddlewarePlacement) {\n    MiddlewarePlacement[\"Before\"] = \"before\";\n    MiddlewarePlacement[\"After\"] = \"after\";\n})(MiddlewarePlacement || (MiddlewarePlacement = {}));\nfunction logMiddleware(state, _, settings) {\n    var logType = settings && settings.logType && console.hasOwnProperty(settings.logType) ? settings.logType : \"log\";\n    console[logType](\"New state: \", state);\n}\nfunction localStorageMiddleware(state, _, settings) {\n    if (PLATFORM.global.localStorage) {\n        var key = settings && settings.key || DEFAULT_LOCAL_STORAGE_KEY;\n        PLATFORM.global.localStorage.setItem(key, JSON.stringify(state));\n    }\n}\nfunction rehydrateFromLocalStorage(state, key) {\n    if (!PLATFORM.global.localStorage) {\n        return state;\n    }\n    var storedState = PLATFORM.global.localStorage.getItem(key || DEFAULT_LOCAL_STORAGE_KEY);\n    if (!storedState) {\n        return state;\n    }\n    try {\n        return JSON.parse(storedState);\n    }\n    catch (e) { }\n    return state;\n}\n\nvar LogLevel;\n(function (LogLevel) {\n    LogLevel[\"trace\"] = \"trace\";\n    LogLevel[\"debug\"] = \"debug\";\n    LogLevel[\"info\"] = \"info\";\n    LogLevel[\"log\"] = \"log\";\n    LogLevel[\"warn\"] = \"warn\";\n    LogLevel[\"error\"] = \"error\";\n})(LogLevel || (LogLevel = {}));\nvar LoggerIndexed = /** @class */ (function (_super) {\n    __extends(LoggerIndexed, _super);\n    function LoggerIndexed() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    return LoggerIndexed;\n}(Logger));\nfunction getLogType(options, definition, defaultLevel) {\n    if (definition &&\n        options.logDefinitions &&\n        options.logDefinitions.hasOwnProperty(definition) &&\n        options.logDefinitions[definition] &&\n        Object.values(LogLevel).includes(options.logDefinitions[definition])) {\n        return options.logDefinitions[definition];\n    }\n    return defaultLevel;\n}\n\nvar PerformanceMeasurement;\n(function (PerformanceMeasurement) {\n    PerformanceMeasurement[\"StartEnd\"] = \"startEnd\";\n    PerformanceMeasurement[\"All\"] = \"all\";\n})(PerformanceMeasurement || (PerformanceMeasurement = {}));\nvar UnregisteredActionError = /** @class */ (function (_super) {\n    __extends(UnregisteredActionError, _super);\n    function UnregisteredActionError(reducer) {\n        return _super.call(this, \"Tried to dispatch an unregistered action \" + (reducer && (typeof reducer === \"string\" ? reducer : reducer.name))) || this;\n    }\n    return UnregisteredActionError;\n}(Error));\nvar Store = /** @class */ (function () {\n    function Store(initialState, options) {\n        this.initialState = initialState;\n        this.logger = getLogger(\"aurelia-store\");\n        this.devToolsAvailable = false;\n        this.actions = new Map();\n        this.middlewares = new Map();\n        this.dispatchQueue = [];\n        this.options = options || {};\n        var isUndoable = this.options.history && this.options.history.undoable === true;\n        this._state = new BehaviorSubject(initialState);\n        this.state = this._state.asObservable();\n        if (!this.options.devToolsOptions || this.options.devToolsOptions.disable !== true) {\n            this.setupDevTools();\n        }\n        if (isUndoable) {\n            this.registerHistoryMethods();\n        }\n    }\n    Store.prototype.registerMiddleware = function (reducer, placement, settings) {\n        this.middlewares.set(reducer, { placement: placement, settings: settings });\n    };\n    Store.prototype.unregisterMiddleware = function (reducer) {\n        if (this.middlewares.has(reducer)) {\n            this.middlewares.delete(reducer);\n        }\n    };\n    Store.prototype.isMiddlewareRegistered = function (middleware) {\n        return this.middlewares.has(middleware);\n    };\n    Store.prototype.registerAction = function (name, reducer) {\n        if (reducer.length === 0) {\n            throw new Error(\"The reducer is expected to have one or more parameters, where the first will be the present state\");\n        }\n        this.actions.set(reducer, { type: name });\n    };\n    Store.prototype.unregisterAction = function (reducer) {\n        if (this.actions.has(reducer)) {\n            this.actions.delete(reducer);\n        }\n    };\n    Store.prototype.isActionRegistered = function (reducer) {\n        if (typeof reducer === \"string\") {\n            return Array.from(this.actions).find(function (action) { return action[1].type === reducer; }) !== undefined;\n        }\n        return this.actions.has(reducer);\n    };\n    Store.prototype.resetToState = function (state) {\n        this._state.next(state);\n    };\n    Store.prototype.dispatch = function (reducer) {\n        var params = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            params[_i - 1] = arguments[_i];\n        }\n        var action = this.lookupAction(reducer);\n        if (!action) {\n            return Promise.reject(new UnregisteredActionError(reducer));\n        }\n        return this.queueDispatch([{\n                reducer: action,\n                params: params\n            }]);\n    };\n    Store.prototype.pipe = function (reducer) {\n        var _this = this;\n        var params = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            params[_i - 1] = arguments[_i];\n        }\n        var pipeline = [];\n        var dispatchPipe = {\n            dispatch: function () { return _this.queueDispatch(pipeline); },\n            pipe: function (nextReducer) {\n                var nextParams = [];\n                for (var _i = 1; _i < arguments.length; _i++) {\n                    nextParams[_i - 1] = arguments[_i];\n                }\n                var action = _this.lookupAction(nextReducer);\n                if (!action) {\n                    throw new UnregisteredActionError(reducer);\n                }\n                pipeline.push({ reducer: action, params: nextParams });\n                return dispatchPipe;\n            }\n        };\n        return dispatchPipe.pipe.apply(dispatchPipe, [reducer].concat(params));\n    };\n    Store.prototype.lookupAction = function (reducer) {\n        if (typeof reducer === \"string\") {\n            var result = Array.from(this.actions).find(function (_a) {\n                var _ = _a[0], action = _a[1];\n                return action.type === reducer;\n            });\n            if (result) {\n                return result[0];\n            }\n        }\n        else if (this.actions.has(reducer)) {\n            return reducer;\n        }\n        return undefined;\n    };\n    Store.prototype.queueDispatch = function (actions) {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            _this.dispatchQueue.push({ actions: actions, resolve: resolve, reject: reject });\n            if (_this.dispatchQueue.length === 1) {\n                _this.handleQueue();\n            }\n        });\n    };\n    Store.prototype.handleQueue = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            var queueItem, e_1;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        if (!(this.dispatchQueue.length > 0)) return [3 /*break*/, 5];\n                        queueItem = this.dispatchQueue[0];\n                        _a.label = 1;\n                    case 1:\n                        _a.trys.push([1, 3, , 4]);\n                        return [4 /*yield*/, this.internalDispatch(queueItem.actions)];\n                    case 2:\n                        _a.sent();\n                        queueItem.resolve();\n                        return [3 /*break*/, 4];\n                    case 3:\n                        e_1 = _a.sent();\n                        queueItem.reject(e_1);\n                        return [3 /*break*/, 4];\n                    case 4:\n                        this.dispatchQueue.shift();\n                        this.handleQueue();\n                        _a.label = 5;\n                    case 5: return [2 /*return*/];\n                }\n            });\n        });\n    };\n    Store.prototype.internalDispatch = function (actions) {\n        return __awaiter(this, void 0, void 0, function () {\n            var unregisteredAction, pipedActions, callingAction, beforeMiddleswaresResult, result, _i, pipedActions_1, action, resultingState, measures, marks, totalDuration;\n            var _this = this;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        unregisteredAction = actions.find(function (a) { return !_this.actions.has(a.reducer); });\n                        if (unregisteredAction) {\n                            throw new UnregisteredActionError(unregisteredAction.reducer);\n                        }\n                        PLATFORM.performance.mark(\"dispatch-start\");\n                        pipedActions = actions.map(function (a) { return ({\n                            type: _this.actions.get(a.reducer).type,\n                            params: a.params,\n                            reducer: a.reducer\n                        }); });\n                        callingAction = {\n                            name: pipedActions.map(function (a) { return a.type; }).join(\"->\"),\n                            params: pipedActions.reduce(function (p, a) { return p.concat(a.params); }, []),\n                            pipedActions: pipedActions.map(function (a) { return ({\n                                name: a.type,\n                                params: a.params\n                            }); })\n                        };\n                        if (this.options.logDispatchedActions) {\n                            this.logger[getLogType(this.options, \"dispatchedActions\", LogLevel.info)](\"Dispatching: \" + callingAction.name);\n                        }\n                        return [4 /*yield*/, this.executeMiddlewares(this._state.getValue(), MiddlewarePlacement.Before, callingAction)];\n                    case 1:\n                        beforeMiddleswaresResult = _a.sent();\n                        if (beforeMiddleswaresResult === false) {\n                            PLATFORM.performance.clearMarks();\n                            PLATFORM.performance.clearMeasures();\n                            return [2 /*return*/];\n                        }\n                        result = beforeMiddleswaresResult;\n                        _i = 0, pipedActions_1 = pipedActions;\n                        _a.label = 2;\n                    case 2:\n                        if (!(_i < pipedActions_1.length)) return [3 /*break*/, 5];\n                        action = pipedActions_1[_i];\n                        return [4 /*yield*/, action.reducer.apply(action, [result].concat(action.params))];\n                    case 3:\n                        result = _a.sent();\n                        if (result === false) {\n                            PLATFORM.performance.clearMarks();\n                            PLATFORM.performance.clearMeasures();\n                            return [2 /*return*/];\n                        }\n                        PLATFORM.performance.mark(\"dispatch-after-reducer-\" + action.type);\n                        if (!result && typeof result !== \"object\") {\n                            throw new Error(\"The reducer has to return a new state\");\n                        }\n                        _a.label = 4;\n                    case 4:\n                        _i++;\n                        return [3 /*break*/, 2];\n                    case 5: return [4 /*yield*/, this.executeMiddlewares(result, MiddlewarePlacement.After, callingAction)];\n                    case 6:\n                        resultingState = _a.sent();\n                        if (resultingState === false) {\n                            PLATFORM.performance.clearMarks();\n                            PLATFORM.performance.clearMeasures();\n                            return [2 /*return*/];\n                        }\n                        if (isStateHistory(resultingState) &&\n                            this.options.history &&\n                            this.options.history.limit) {\n                            resultingState = applyLimits(resultingState, this.options.history.limit);\n                        }\n                        this._state.next(resultingState);\n                        PLATFORM.performance.mark(\"dispatch-end\");\n                        if (this.options.measurePerformance === PerformanceMeasurement.StartEnd) {\n                            PLATFORM.performance.measure(\"startEndDispatchDuration\", \"dispatch-start\", \"dispatch-end\");\n                            measures = PLATFORM.performance.getEntriesByName(\"startEndDispatchDuration\");\n                            this.logger[getLogType(this.options, \"performanceLog\", LogLevel.info)](\"Total duration \" + measures[0].duration + \" of dispatched action \" + callingAction.name + \":\", measures);\n                        }\n                        else if (this.options.measurePerformance === PerformanceMeasurement.All) {\n                            marks = PLATFORM.performance.getEntriesByType(\"mark\");\n                            totalDuration = marks[marks.length - 1].startTime - marks[0].startTime;\n                            this.logger[getLogType(this.options, \"performanceLog\", LogLevel.info)](\"Total duration \" + totalDuration + \" of dispatched action \" + callingAction.name + \":\", marks);\n                        }\n                        PLATFORM.performance.clearMarks();\n                        PLATFORM.performance.clearMeasures();\n                        this.updateDevToolsState({ type: callingAction.name, params: callingAction.params }, resultingState);\n                        return [2 /*return*/];\n                }\n            });\n        });\n    };\n    Store.prototype.executeMiddlewares = function (state, placement, action) {\n        var _this = this;\n        return Array.from(this.middlewares)\n            .filter(function (middleware) { return middleware[1].placement === placement; })\n            .reduce(function (prev, curr, _, _arr) { return __awaiter(_this, void 0, void 0, function () {\n            var result, _a, _b, _c, e_2;\n            return __generator(this, function (_d) {\n                switch (_d.label) {\n                    case 0:\n                        _d.trys.push([0, 5, 7, 8]);\n                        _b = (_a = curr)[0];\n                        return [4 /*yield*/, prev];\n                    case 1: return [4 /*yield*/, _b.apply(_a, [_d.sent(), this._state.getValue(), curr[1].settings, action])];\n                    case 2:\n                        result = _d.sent();\n                        if (result === false) {\n                            _arr = [];\n                            return [2 /*return*/, false];\n                        }\n                        _c = result;\n                        if (_c) return [3 /*break*/, 4];\n                        return [4 /*yield*/, prev];\n                    case 3:\n                        _c = (_d.sent());\n                        _d.label = 4;\n                    case 4: return [2 /*return*/, _c];\n                    case 5:\n                        e_2 = _d.sent();\n                        if (this.options.propagateError) {\n                            _arr = [];\n                            throw e_2;\n                        }\n                        return [4 /*yield*/, prev];\n                    case 6: return [2 /*return*/, _d.sent()];\n                    case 7:\n                        PLATFORM.performance.mark(\"dispatch-\" + placement + \"-\" + curr[0].name);\n                        return [7 /*endfinally*/];\n                    case 8: return [2 /*return*/];\n                }\n            });\n        }); }, state);\n    };\n    Store.prototype.setupDevTools = function () {\n        var _this = this;\n        if (PLATFORM.global.devToolsExtension) {\n            this.logger[getLogType(this.options, \"devToolsStatus\", LogLevel.debug)](\"DevTools are available\");\n            this.devToolsAvailable = true;\n            this.devTools = PLATFORM.global.__REDUX_DEVTOOLS_EXTENSION__.connect(this.options.devToolsOptions);\n            this.devTools.init(this.initialState);\n            this.devTools.subscribe(function (message) {\n                _this.logger[getLogType(_this.options, \"devToolsStatus\", LogLevel.debug)](\"DevTools sent change \" + message.type);\n                if (message.type === \"ACTION\" && message.payload) {\n                    var byName = Array.from(_this.actions).find(function (_a) {\n                        var reducer = _a[0];\n                        return reducer.name === message.payload.name;\n                    });\n                    var action = _this.lookupAction(message.payload.name) || byName && byName[0];\n                    if (!action) {\n                        throw new Error(\"Tried to remotely dispatch an unregistered action\");\n                    }\n                    if (!message.payload.args || message.payload.args.length < 1) {\n                        throw new Error(\"No action arguments provided\");\n                    }\n                    _this.dispatch.apply(_this, [action].concat(message.payload.args.slice(1).map(function (arg) { return JSON.parse(arg); })));\n                    return;\n                }\n                if (message.type === \"DISPATCH\" && message.payload) {\n                    switch (message.payload.type) {\n                        case \"JUMP_TO_STATE\":\n                        case \"JUMP_TO_ACTION\":\n                            _this._state.next(JSON.parse(message.state));\n                            return;\n                        case \"COMMIT\":\n                            _this.devTools.init(_this._state.getValue());\n                            return;\n                        case \"RESET\":\n                            _this.devTools.init(_this.initialState);\n                            _this.resetToState(_this.initialState);\n                            return;\n                        case \"ROLLBACK\":\n                            var parsedState = JSON.parse(message.state);\n                            _this.resetToState(parsedState);\n                            _this.devTools.init(parsedState);\n                            return;\n                    }\n                }\n            });\n        }\n    };\n    Store.prototype.updateDevToolsState = function (action, state) {\n        if (this.devToolsAvailable) {\n            this.devTools.send(action, state);\n        }\n    };\n    Store.prototype.registerHistoryMethods = function () {\n        this.registerAction(\"jump\", jump);\n    };\n    return Store;\n}());\nfunction dispatchify(action) {\n    var store = Container.instance.get(Store);\n    return function () {\n        var params = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            params[_i] = arguments[_i];\n        }\n        return store.dispatch.apply(store, [action].concat(params));\n    };\n}\n\nfunction executeSteps(store, shouldLogResults) {\n    var steps = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        steps[_i - 2] = arguments[_i];\n    }\n    return __awaiter(this, void 0, void 0, function () {\n        var logStep, tryStep, lastStep;\n        return __generator(this, function (_a) {\n            logStep = function (step, stepIdx) { return function (res) {\n                if (shouldLogResults) {\n                    console.group(\"Step \" + stepIdx);\n                    console.log(res);\n                    console.groupEnd();\n                }\n                step(res);\n            }; };\n            tryStep = function (step, reject) {\n                return function (res) {\n                    try {\n                        step(res);\n                    }\n                    catch (err) {\n                        reject(err);\n                    }\n                };\n            };\n            lastStep = function (step, resolve) {\n                return function (res) {\n                    step(res);\n                    resolve();\n                };\n            };\n            return [2 /*return*/, new Promise(function (resolve, reject) {\n                    var currentStep = 0;\n                    steps.slice(0, -1).forEach(function (step) {\n                        store.state.pipe(skip(currentStep), take(1), delay(0)).subscribe(tryStep(logStep(step, currentStep), reject));\n                        currentStep++;\n                    });\n                    store.state.pipe(skip(currentStep), take(1)).subscribe(lastStep(tryStep(logStep(steps[steps.length - 1], currentStep), reject), resolve));\n                })];\n        });\n    });\n}\n\nvar defaultSelector = function (store) { return store.state; };\nfunction connectTo(settings) {\n    var $store;\n    // const store = Container.instance.get(Store) as Store<T>;\n    var _settings = __assign({ selector: typeof settings === \"function\" ? settings : defaultSelector }, settings);\n    function getSource(selector) {\n        // if for some reason getSource is invoked before setup (bind lifecycle, typically)\n        // then we have no choice but to get the store instance from global container instance\n        // otherwise, assume that $store variable in the closure would be already assigned the right\n        // value from created callback\n        // Could also be in situation where it doesn't come from custom element, or some exotic setups/scenarios\n        var store = $store || ($store = Container.instance.get(Store));\n        var source = selector(store);\n        if (source instanceof Observable) {\n            return source;\n        }\n        return store.state;\n    }\n    function createSelectors() {\n        var _a;\n        var isSelectorObj = typeof _settings.selector === \"object\";\n        var fallbackSelector = (_a = {},\n            _a[_settings.target || \"state\"] = _settings.selector || defaultSelector,\n            _a);\n        return Object.entries(__assign({}, (isSelectorObj ? _settings.selector : fallbackSelector))).map(function (_a) {\n            var target = _a[0], selector = _a[1];\n            var _b;\n            return ({\n                targets: _settings.target && isSelectorObj ? [_settings.target, target] : [target],\n                selector: selector,\n                // numbers are the starting index to slice all the change handling args, \n                // which are prop name, new state and old state\n                changeHandlers: (_b = {},\n                    _b[_settings.onChanged || \"\"] = 1,\n                    _b[(_settings.target || target) + \"Changed\"] = _settings.target ? 0 : 1,\n                    _b[\"propertyChanged\"] = 0,\n                    _b)\n            });\n        });\n    }\n    return function (target) {\n        var originalCreated = target.prototype.created;\n        var originalSetup = typeof settings === \"object\" && settings.setup\n            ? target.prototype[settings.setup]\n            : target.prototype.bind;\n        var originalTeardown = typeof settings === \"object\" && settings.teardown\n            ? target.prototype[settings.teardown]\n            : target.prototype.unbind;\n        // only override if prototype callback is a function\n        if (typeof originalCreated === \"function\" || originalCreated === undefined) {\n            target.prototype.created = function created(_, view) {\n                // here we relies on the fact that the class Store\n                // has not been registered somewhere in one of child containers, instead of root container\n                // if there is any issue with this approach, needs to walk all the way up to resolve from root\n                // typically like invoking from global Container.instance\n                $store = view.container.get(Store);\n                if (originalCreated !== undefined) {\n                    return originalCreated.call(this, _, view);\n                }\n            };\n        }\n        target.prototype[typeof settings === \"object\" && settings.setup ? settings.setup : \"bind\"] = function () {\n            var _this = this;\n            if (typeof settings == \"object\" &&\n                typeof settings.onChanged === \"string\" &&\n                !(settings.onChanged in this)) {\n                throw new Error(\"Provided onChanged handler does not exist on target VM\");\n            }\n            this._stateSubscriptions = createSelectors().map(function (s) { return getSource(s.selector).subscribe(function (state) {\n                var lastTargetIdx = s.targets.length - 1;\n                var oldState = s.targets.reduce(function (accu, curr) {\n                    if (accu === void 0) { accu = {}; }\n                    return accu[curr];\n                }, _this);\n                Object.entries(s.changeHandlers).forEach(function (_a) {\n                    var handlerName = _a[0], args = _a[1];\n                    if (handlerName in _this) {\n                        _this[handlerName].apply(_this, [s.targets[lastTargetIdx], state, oldState].slice(args, 3));\n                    }\n                });\n                s.targets.reduce(function (accu, curr, idx) {\n                    accu[curr] = idx === lastTargetIdx ? state : accu[curr] || {};\n                    return accu[curr];\n                }, _this);\n            }); });\n            if (originalSetup) {\n                return originalSetup.apply(this, arguments);\n            }\n        };\n        target.prototype[typeof settings === \"object\" && settings.teardown ? settings.teardown : \"unbind\"] = function () {\n            if (this._stateSubscriptions && Array.isArray(this._stateSubscriptions)) {\n                this._stateSubscriptions.forEach(function (sub) {\n                    if (sub instanceof Subscription && sub.closed === false) {\n                        sub.unsubscribe();\n                    }\n                });\n            }\n            if (originalTeardown) {\n                return originalTeardown.apply(this, arguments);\n            }\n        };\n    };\n}\n\nfunction configure(aurelia, options) {\n    if (!options || !options.initialState) {\n        throw new Error(\"initialState must be provided via options\");\n    }\n    var initState = options.initialState;\n    if (options && options.history && options.history.undoable && !isStateHistory(options.initialState)) {\n        initState = { past: [], present: options.initialState, future: [] };\n    }\n    delete options.initialState;\n    aurelia.container\n        .registerInstance(Store, new Store(initState, options));\n}\n\nexport { configure, PerformanceMeasurement, UnregisteredActionError, Store, dispatchify, executeSteps, jump, nextStateHistory, applyLimits, isStateHistory, DEFAULT_LOCAL_STORAGE_KEY, MiddlewarePlacement, logMiddleware, localStorageMiddleware, rehydrateFromLocalStorage, LogLevel, LoggerIndexed, getLogType, connectTo };\n"],"sourceRoot":""}