{"version":3,"sources":["webpack:///./node_modules/aurelia-store/dist/native-modules/aurelia-store.js"],"names":["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","_markNames","Set","_measureNames","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","mark","map","get","join","reduce","logDispatchedActions","info","executeMiddlewares","getValue","Before","clearMarks","clearMeasures","After","measurePerformance","StartEnd","measure","performance","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","markName","add","forEach","clear","measureName","startMarkName","endMarkName","dispatchify","store","instance","executeSteps","shouldLogResults","steps","logStep","tryStep","lastStep","stepIdx","res","group","log","groupEnd","err","currentStep","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":"vendors~27da0bf4.fbbaedcaaf6184e24cbe.chunk.js","sourcesContent":["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._markNames = new Set();\n        this._measureNames = new Set();\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                        this.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                            this.clearMarks();\n                            this.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                            this.clearMarks();\n                            this.clearMeasures();\n                            return [2 /*return*/];\n                        }\n                        this.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                            this.clearMarks();\n                            this.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                        this.mark(\"dispatch-end\");\n                        if (this.options.measurePerformance === PerformanceMeasurement.StartEnd) {\n                            this.measure(\"startEndDispatchDuration\", \"dispatch-start\", \"dispatch-end\");\n                            measures = PLATFORM.performance.getEntriesByName(\"startEndDispatchDuration\", \"measure\");\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                        this.clearMarks();\n                        this.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                        this.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    Store.prototype.mark = function (markName) {\n        this._markNames.add(markName);\n        PLATFORM.performance.mark(markName);\n    };\n    Store.prototype.clearMarks = function () {\n        this._markNames.forEach(function (markName) {\n            return PLATFORM.performance.clearMarks(markName);\n        });\n        this._markNames.clear();\n    };\n    Store.prototype.measure = function (measureName, startMarkName, endMarkName) {\n        this._measureNames.add(measureName);\n        PLATFORM.performance.measure(measureName, startMarkName, endMarkName);\n    };\n    Store.prototype.clearMeasures = function () {\n        this._measureNames.forEach(function (measureName) {\n            return PLATFORM.performance.clearMeasures(measureName);\n        });\n        this._measureNames.clear();\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":""}