{"version":3,"file":"knockout-utils.js","sources":["requirejs/utility/knockout-utils.js"],"sourcesContent":["define([\"require\", \"exports\", \"knockout\", \"./deterministic-stringify\"], function (require, exports, ko, deterministic_stringify_1) {\n    \"use strict\";\n    Object.defineProperty(exports, \"__esModule\", { value: true });\n    exports.ignoreArray = exports.HandleOrProxy = void 0;\n    function HandleOrProxy(handler) {\n        return (handlerOrData, e, ...args) => {\n            if (typeof handlerOrData == \"function\") {\n                const wrappedHandler = (data, e, ...args) => {\n                    handler(data, e, ...args);\n                    return !!handlerOrData(data, e, ...args);\n                };\n                return wrappedHandler;\n            }\n            else {\n                return handler(handlerOrData, e, ...args);\n            }\n        };\n    }\n    exports.HandleOrProxy = HandleOrProxy;\n    class KnockoutUtils {\n        constructor() { }\n        static isObservableArray(instance) {\n            return ko.isObservable(instance) &&\n                typeof instance[\"remove\"] == \"function\" &&\n                typeof instance[\"removeAll\"] == \"function\" &&\n                typeof instance[\"destroy\"] == \"function\" &&\n                typeof instance[\"destroyAll\"] == \"function\" &&\n                typeof instance[\"indexOf\"] == \"function\" &&\n                typeof instance[\"replace\"] == \"function\";\n        }\n        static asObservable(obsArray) {\n            let proxyObs = ko.observable(null);\n            let internalModify = false;\n            this.onObservableHashChanged(obsArray, newValues => {\n                if (internalModify) {\n                    return;\n                }\n                internalModify = true;\n                if (!newValues || newValues.length === 0) {\n                    proxyObs(null);\n                }\n                else {\n                    proxyObs(newValues[0]);\n                }\n                internalModify = false;\n            }, 25, true);\n            proxyObs.subscribe(newValue => {\n                if (internalModify) {\n                    return;\n                }\n                internalModify = true;\n                const oldValues = obsArray.peek();\n                if (oldValues.length > 1) {\n                    oldValues.splice(1, oldValues.length - 1);\n                }\n                if (KnockoutUtils.isObservableArray(obsArray)) {\n                    if (newValue != null) {\n                        if (oldValues.length < 1) {\n                            obsArray.push(newValue);\n                        }\n                        else if (obsArray.indexOf(newValue) < 0) {\n                            obsArray.replace(oldValues[0], newValue);\n                        }\n                    }\n                    else if (oldValues.length > 0) {\n                        obsArray.removeAll();\n                    }\n                }\n                else {\n                    if (newValue != null) {\n                        obsArray([newValue]);\n                    }\n                    else {\n                        obsArray([]);\n                    }\n                }\n                internalModify = false;\n            });\n            return proxyObs;\n        }\n        static asObservableArray(obs, canEmpty = false) {\n            if (typeof canEmpty !== \"function\") {\n                const canEmptyBool = !!canEmpty;\n                canEmpty = () => canEmptyBool;\n            }\n            const initialValue = obs.peek();\n            const obsArray = ko.observableArray(initialValue ? [initialValue] : []);\n            let internalModify = false;\n            obs.subscribe(newValue => {\n                if (internalModify) {\n                    return;\n                }\n                internalModify = true;\n                const oldValues = obsArray.peek();\n                if (oldValues.length > 1) {\n                    oldValues.splice(1, oldValues.length - 1);\n                }\n                if (newValue != null) {\n                    if (oldValues.length < 1) {\n                        obsArray.push(newValue);\n                    }\n                    else if (obsArray.indexOf(newValue) < 0) {\n                        obsArray.replace(oldValues[0], newValue);\n                    }\n                }\n                else if (oldValues.length > 0) {\n                    obsArray.removeAll();\n                }\n                internalModify = false;\n            });\n            let oldArrValues = [];\n            obsArray.subscribe(oldValues => {\n                oldArrValues = oldValues.slice();\n            }, this, \"beforeChange\");\n            obsArray.subscribe(newValues => {\n                if (internalModify) {\n                    return;\n                }\n                internalModify = true;\n                if (newValues.length > 1) {\n                    newValues.splice(0, 1, newValues[newValues.length - 1]);\n                    newValues.splice(1, newValues.length - 1);\n                }\n                if (!newValues.length && oldArrValues.length && !canEmpty(oldArrValues[oldArrValues.length - 1])) {\n                    newValues.push(oldArrValues[oldArrValues.length - 1]);\n                }\n                if (newValues.length) {\n                    obs(newValues[0]);\n                }\n                else {\n                    obs(null);\n                }\n                internalModify = false;\n            });\n            return obsArray;\n        }\n        static stringifyObservable(obs) {\n            const value = obs();\n            let target = value;\n            if (ko.mapping.isMapped(value)) {\n                target = ko.mapping.toJS(value);\n            }\n            else if (Array.isArray(value) && value.length > 0 && ko.mapping.isMapped(value[0])) {\n                target = value.map(item => ko.mapping.toJS(item));\n            }\n            return (0, deterministic_stringify_1.deterministicStringify)(target);\n        }\n        static onObservableHashChanged(obs, onChanged, timeout, fireImmediate = true) {\n            let computed = ko.pureComputed(() => KnockoutUtils.stringifyObservable(obs));\n            if (!!timeout)\n                computed = computed.extend({ rateLimit: { method: \"notifyWhenChangesStop\", timeout: timeout } });\n            const subscription = computed.subscribe(() => onChanged(obs.peek()));\n            if (fireImmediate)\n                onChanged(obs.peek());\n            return subscription;\n        }\n        static linkedObservable(valueAccessor) {\n            let internalObs;\n            let valueSubscription;\n            const destroyInternalObservable = () => {\n                internalObs = null;\n                if (valueSubscription)\n                    valueSubscription.dispose();\n            };\n            const createInternalObservable = (value) => {\n                internalObs = ko.observable(value);\n                valueSubscription = ko.pureComputed(() => ko.unwrap(valueAccessor()))\n                    .subscribe(internalObs);\n            };\n            const getObservable = () => {\n                const value = valueAccessor();\n                if (ko.isWriteableObservable(value)) {\n                    destroyInternalObservable();\n                    return value;\n                }\n                if (internalObs == null) {\n                    createInternalObservable(value);\n                }\n                return internalObs;\n            };\n            return ko.pureComputed({\n                read: () => getObservable()(),\n                write: value => getObservable()(value)\n            });\n        }\n        static whenForever(predicate, callback, context) {\n            function kowhen(resolve) {\n                var observable = ko.pureComputed(predicate, context).extend({ notify: 'always' });\n                var subscription = observable.subscribe(function (value) {\n                    if (value) {\n                        resolve(value);\n                    }\n                });\n                // In case the initial value is true, process it right away\n                observable['notifySubscribers'](observable.peek());\n                return subscription;\n            }\n            if (typeof Promise === \"function\" && !callback) {\n                return new Promise(kowhen);\n            }\n            else {\n                return kowhen(callback.bind(context));\n            }\n        }\n        ;\n        static rateLimit(target, options) {\n            ko.extenders.rateLimit(target, options);\n            return target;\n        }\n        static createSubscription(subscribable, callback, target = this, event = \"change\", afterDisposalExecutionCount = 0) {\n            let isDisposed = false;\n            let disposedExecutionCount = 0;\n            const subscription = subscribable.subscribe(x => {\n                callback(x);\n                if (isDisposed) {\n                    disposedExecutionCount++;\n                    if (disposedExecutionCount >= afterDisposalExecutionCount) {\n                        subscription.dispose();\n                    }\n                }\n            }, target, event);\n            return {\n                dispose: () => {\n                    if (afterDisposalExecutionCount === 0) {\n                        subscription.dispose();\n                    }\n                    else {\n                        isDisposed = true;\n                    }\n                }\n            };\n        }\n    }\n    exports.default = KnockoutUtils;\n    /**\n    * Helper function that returns another function which takes `string[]` rest parameter(s) and gives back these same parameters as an array.\n    *\n    * Typing ensures that the resulting array implements `T`, which is useful when building a `ko.mapping` \"ignore\" array\n    * which needs to be a comprehensive list of property names for a given type (`T`)\n    *\n    * @example\n    * class Rectangle {\n    *     len: KnockoutObservable<number>, width: KnockoutObservable<number>;\n    *     area: KnockoutComputed<number>, description: KnockoutComputed<string>;\n    *\n    *     constructor(l: number, w: number) {\n    *         this.len = ko.observable(l);\n    *         this.width = ko.observable(w);\n    *         this.area = ko.computed(() => this.len() * this.width());\n    *         this.description = ko.computed(() => \"Length: \" + this.len() + \", Width: \" + this.width())\n    *     }\n    * }\n    * const sourceObj = new Rectangle(10, 20);\n    *\n    * type computedRectangleProps = keyof({\n    *     [p in keyof Rectangle as Rectangle[p] extends KnockoutComputed<any> ? p : never]: Rectangle[p]\n    * });\n    *\n    * // NOTE: TypeScript gives an error if we do not include both 'area' AND 'description' in the params\n    * const mappingIgnore = ignoreArray<computedRectangleProps>()('area', 'description')\n    *\n    * const destinationObj = ko.mapping.fromJS(sourceObj, { ignore: mappingIgnore });\n    */\n    const ignoreArray = () => (...x) => x;\n    exports.ignoreArray = ignoreArray;\n});\n//# sourceMappingURL=knockout-utils.js.map"],"names":["define","require","exports","ko","deterministic_stringify_1","Object","defineProperty","value","ignoreArray","HandleOrProxy","handler","handlerOrData","e","args","data","KnockoutUtils","constructor","isObservableArray","instance","isObservable","asObservable","obsArray","let","proxyObs","observable","internalModify","this","onObservableHashChanged","newValues","length","subscribe","newValue","oldValues","peek","splice","push","indexOf","replace","removeAll","asObservableArray","obs","canEmpty","canEmptyBool","initialValue","observableArray","oldArrValues","slice","stringifyObservable","target","mapping","isMapped","toJS","Array","isArray","map","item","deterministicStringify","onChanged","timeout","fireImmediate","computed","pureComputed","subscription","extend","rateLimit","method","linkedObservable","valueAccessor","internalObs","valueSubscription","getObservable","isWriteableObservable","dispose","unwrap","read","write","whenForever","predicate","callback","context","kowhen","resolve","notify","Promise","bind","options","extenders","createSubscription","subscribable","event","afterDisposalExecutionCount","isDisposed","disposedExecutionCount","x","default"],"mappings":"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"}