@tko/computed 4.0.0-alpha8.0 → 4.0.0-beta1.0

package/dist/computed.js

@@ -1,668 +1,425 @@
-/*!
- * TKO Computed Observables 🥊  @tko/computed@4.0.0-alpha8.0
- * (c) The Knockout.js Team - https://tko.io
- * License: MIT (http://www.opensource.org/licenses/mit-license.php)
- */
-
-import { addDisposeCallback, arrayForEach, createSymbolOrString, domNodeIsAttachedToDocument, extend, options, hasOwnProperty, objectForEach, removeDisposeCallback, safeSetTimeout } from '@tko/utils';
-import { dependencyDetection, extenders, valuesArePrimitiveAndEqual, observable, subscribable, LATEST_VALUE, observableArray, unwrap } from '@tko/observable';
-
-var _a;
-var computedState = createSymbolOrString('_state');
-var DISPOSED_STATE = {
-    dependencyTracking: null,
-    dependenciesCount: 0,
-    isDisposed: true,
-    isStale: false,
-    isDirty: false,
-    isSleeping: false,
-    disposeWhenNodeIsRemoved: null,
-    readFunction: null,
-    _options: null
-};
-function computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, options$$1) {
-    if (typeof evaluatorFunctionOrOptions === 'object') {
-        // Single-parameter syntax - everything is on this "options" param
-        options$$1 = evaluatorFunctionOrOptions;
-    }
-    else {
-        // Multi-parameter syntax - construct the options according to the params passed
-        options$$1 = options$$1 || {};
-        if (evaluatorFunctionOrOptions) {
-            options$$1.read = evaluatorFunctionOrOptions;
-        }
-    }
-    if (typeof options$$1.read !== 'function') {
-        throw Error('Pass a function that returns the value of the computed');
-    }
-    var writeFunction = options$$1.write;
-    var state = {
-        latestValue: undefined,
-        isStale: true,
-        isDirty: true,
-        isBeingEvaluated: false,
-        suppressDisposalUntilDisposeWhenReturnsFalse: false,
-        isDisposed: false,
-        pure: false,
-        isSleeping: false,
-        readFunction: options$$1.read,
-        evaluatorFunctionTarget: evaluatorFunctionTarget || options$$1.owner,
-        disposeWhenNodeIsRemoved: options$$1.disposeWhenNodeIsRemoved || options$$1.disposeWhenNodeIsRemoved || null,
-        disposeWhen: options$$1.disposeWhen || options$$1.disposeWhen,
-        domNodeDisposalCallback: null,
-        dependencyTracking: {},
-        dependenciesCount: 0,
-        evaluationTimeoutInstance: null
-    };
-    function computedObservable() {
-        if (arguments.length > 0) {
-            if (typeof writeFunction === 'function') {
-                // Writing a value
-                writeFunction.apply(state.evaluatorFunctionTarget, arguments);
-            }
-            else {
-                throw new Error("Cannot write a value to a computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters.");
-            }
-            return this; // Permits chained assignments
-        }
-        else {
-            // Reading the value
-            if (!state.isDisposed) {
-                dependencyDetection.registerDependency(computedObservable);
-            }
-            if (state.isDirty || (state.isSleeping && computedObservable.haveDependenciesChanged())) {
-                computedObservable.evaluateImmediate();
-            }
-            return state.latestValue;
-        }
-    }
-    computedObservable[computedState] = state;
-    computedObservable.isWriteable = typeof writeFunction === 'function';
-    subscribable.fn.init(computedObservable);
-    // Inherit from 'computed'
-    Object.setPrototypeOf(computedObservable, computed.fn);
-    if (options$$1.pure) {
-        state.pure = true;
-        state.isSleeping = true; // Starts off sleeping; will awake on the first subscription
-        extend(computedObservable, pureComputedOverrides);
-    }
-    else if (options$$1.deferEvaluation) {
-        extend(computedObservable, deferEvaluationOverrides);
-    }
-    if (options.deferUpdates) {
-        extenders.deferred(computedObservable, true);
-    }
-    if (options.debug) {
-        // #1731 - Aid debugging by exposing the computed's options
-        computedObservable._options = options$$1;
-    }
-    if (state.disposeWhenNodeIsRemoved) {
-        // Since this computed is associated with a DOM node, and we don't want to dispose the computed
-        // until the DOM node is *removed* from the document (as opposed to never having been in the document),
-        // we'll prevent disposal until "disposeWhen" first returns false.
-        state.suppressDisposalUntilDisposeWhenReturnsFalse = true;
-        // disposeWhenNodeIsRemoved: true can be used to opt into the "only dispose after first false result"
-        // behavior even if there's no specific node to watch. In that case, clear the option so we don't try
-        // to watch for a non-node's disposal. This technique is intended for KO's internal use only and shouldn't
-        // be documented or used by application code, as it's likely to change in a future version of KO.
-        if (!state.disposeWhenNodeIsRemoved.nodeType) {
-            state.disposeWhenNodeIsRemoved = null;
-        }
-    }
-    // Evaluate, unless sleeping or deferEvaluation is true
-    if (!state.isSleeping && !options$$1.deferEvaluation) {
-        computedObservable.evaluateImmediate();
-    }
-    // Attach a DOM node disposal callback so that the computed will be proactively disposed as soon as the node is
-    // removed using ko.removeNode. But skip if isActive is false (there will never be any dependencies to dispose).
-    if (state.disposeWhenNodeIsRemoved && computedObservable.isActive()) {
-        addDisposeCallback(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback = function () {
-            computedObservable.dispose();
-        });
-    }
-    return computedObservable;
-}
-// Utility function that disposes a given dependencyTracking entry
-function computedDisposeDependencyCallback(id, entryToDispose) {
-    if (entryToDispose !== null && entryToDispose.dispose) {
-        entryToDispose.dispose();
-    }
-}
-// This function gets called each time a dependency is detected while evaluating a computed.
-// It's factored out as a shared function to avoid creating unnecessary function instances during evaluation.
-function computedBeginDependencyDetectionCallback(subscribable$$1, id) {
-    var computedObservable = this.computedObservable, state = computedObservable[computedState];
-    if (!state.isDisposed) {
-        if (this.disposalCount && this.disposalCandidates[id]) {
-            // Don't want to dispose this subscription, as it's still being used
-            computedObservable.addDependencyTracking(id, subscribable$$1, this.disposalCandidates[id]);
-            this.disposalCandidates[id] = null; // No need to actually delete the property - disposalCandidates is a transient object anyway
-            --this.disposalCount;
-        }
-        else if (!state.dependencyTracking[id]) {
-            // Brand new subscription - add it
-            computedObservable.addDependencyTracking(id, subscribable$$1, state.isSleeping ? { _target: subscribable$$1 } : computedObservable.subscribeToDependency(subscribable$$1));
-        }
-        // If the observable we've accessed has a pending notification, ensure
-        // we get notified of the actual final value (bypass equality checks)
-        if (subscribable$$1._notificationIsPending) {
-            subscribable$$1._notifyNextChangeIfValueIsDifferent();
-        }
-    }
-}
-computed.fn = (_a = {
-        equalityComparer: valuesArePrimitiveAndEqual,
-        getDependenciesCount: function () {
-            return this[computedState].dependenciesCount;
-        },
-        getDependencies: function () {
-            var dependencyTracking = this[computedState].dependencyTracking;
-            var dependentObservables = [];
-            objectForEach(dependencyTracking, function (id, dependency) {
-                dependentObservables[dependency._order] = dependency._target;
-            });
-            return dependentObservables;
-        },
-        addDependencyTracking: function (id, target, trackingObj) {
-            if (this[computedState].pure && target === this) {
-                throw Error("A 'pure' computed must not be called recursively");
-            }
-            this[computedState].dependencyTracking[id] = trackingObj;
-            trackingObj._order = this[computedState].dependenciesCount++;
-            trackingObj._version = target.getVersion();
-        },
-        haveDependenciesChanged: function () {
-            var id, dependency, dependencyTracking = this[computedState].dependencyTracking;
-            for (id in dependencyTracking) {
-                if (hasOwnProperty(dependencyTracking, id)) {
-                    dependency = dependencyTracking[id];
-                    if ((this._evalDelayed && dependency._target._notificationIsPending) || dependency._target.hasChanged(dependency._version)) {
-                        return true;
-                    }
-                }
-            }
-        },
-        markDirty: function () {
-            // Process "dirty" events if we can handle delayed notifications
-            if (this._evalDelayed && !this[computedState].isBeingEvaluated) {
-                this._evalDelayed(false /* notifyChange */);
-            }
-        },
-        isActive: function () {
-            var state = this[computedState];
-            return state.isDirty || state.dependenciesCount > 0;
-        },
-        respondToChange: function () {
-            // Ignore "change" events if we've already scheduled a delayed notification
-            if (!this._notificationIsPending) {
-                this.evaluatePossiblyAsync();
-            }
-            else if (this[computedState].isDirty) {
-                this[computedState].isStale = true;
-            }
-        },
-        subscribeToDependency: function (target) {
-            if (target._deferUpdates) {
-                var dirtySub = target.subscribe(this.markDirty, this, 'dirty'), changeSub = target.subscribe(this.respondToChange, this);
-                return {
-                    _target: target,
-                    dispose: function () {
-                        dirtySub.dispose();
-                        changeSub.dispose();
-                    }
-                };
-            }
-            else {
-                return target.subscribe(this.evaluatePossiblyAsync, this);
-            }
-        },
-        evaluatePossiblyAsync: function () {
-            var computedObservable = this, throttleEvaluationTimeout = computedObservable.throttleEvaluation;
-            if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {
-                clearTimeout(this[computedState].evaluationTimeoutInstance);
-                this[computedState].evaluationTimeoutInstance = safeSetTimeout(function () {
-                    computedObservable.evaluateImmediate(true /* notifyChange */);
-                }, throttleEvaluationTimeout);
-            }
-            else if (computedObservable._evalDelayed) {
-                computedObservable._evalDelayed(true /* notifyChange */);
-            }
-            else {
-                computedObservable.evaluateImmediate(true /* notifyChange */);
-            }
-        },
-        evaluateImmediate: function (notifyChange) {
-            var computedObservable = this, state = computedObservable[computedState], disposeWhen = state.disposeWhen, changed = false;
-            if (state.isBeingEvaluated) {
-                // If the evaluation of a ko.computed causes side effects, it's possible that it will trigger its own re-evaluation.
-                // This is not desirable (it's hard for a developer to realise a chain of dependencies might cause this, and they almost
-                // certainly didn't intend infinite re-evaluations). So, for predictability, we simply prevent ko.computeds from causing
-                // their own re-evaluation. Further discussion at https://github.com/SteveSanderson/knockout/pull/387
-                return;
-            }
-            // Do not evaluate (and possibly capture new dependencies) if disposed
-            if (state.isDisposed) {
-                return;
-            }
-            if (state.disposeWhenNodeIsRemoved && !domNodeIsAttachedToDocument(state.disposeWhenNodeIsRemoved) || disposeWhen && disposeWhen()) {
-                // See comment above about suppressDisposalUntilDisposeWhenReturnsFalse
-                if (!state.suppressDisposalUntilDisposeWhenReturnsFalse) {
-                    computedObservable.dispose();
-                    return;
-                }
-            }
-            else {
-                // It just did return false, so we can stop suppressing now
-                state.suppressDisposalUntilDisposeWhenReturnsFalse = false;
-            }
-            state.isBeingEvaluated = true;
-            try {
-                changed = this.evaluateImmediate_CallReadWithDependencyDetection(notifyChange);
-            }
-            finally {
-                state.isBeingEvaluated = false;
-            }
-            return changed;
-        },
-        evaluateImmediate_CallReadWithDependencyDetection: function (notifyChange) {
-            // This function is really just part of the evaluateImmediate logic. You would never call it from anywhere else.
-            // Factoring it out into a separate function means it can be independent of the try/catch block in evaluateImmediate,
-            // which contributes to saving about 40% off the CPU overhead of computed evaluation (on V8 at least).
-            var computedObservable = this, state = computedObservable[computedState], changed = false;
-            // Initially, we assume that none of the subscriptions are still being used (i.e., all are candidates for disposal).
-            // Then, during evaluation, we cross off any that are in fact still being used.
-            var isInitial = state.pure ? undefined : !state.dependenciesCount, // If we're evaluating when there are no previous dependencies, it must be the first time
-            dependencyDetectionContext = {
-                computedObservable: computedObservable,
-                disposalCandidates: state.dependencyTracking,
-                disposalCount: state.dependenciesCount
-            };
-            dependencyDetection.begin({
-                callbackTarget: dependencyDetectionContext,
-                callback: computedBeginDependencyDetectionCallback,
-                computed: computedObservable,
-                isInitial: isInitial
-            });
-            state.dependencyTracking = {};
-            state.dependenciesCount = 0;
-            var newValue = this.evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext);
-            if (!state.dependenciesCount) {
-                computedObservable.dispose();
-                changed = true; // When evaluation causes a disposal, make sure all dependent computeds get notified so they'll see the new state
-            }
-            else {
-                changed = computedObservable.isDifferent(state.latestValue, newValue);
-            }
-            if (changed) {
-                if (!state.isSleeping) {
-                    computedObservable.notifySubscribers(state.latestValue, 'beforeChange');
-                }
-                else {
-                    computedObservable.updateVersion();
-                }
-                state.latestValue = newValue;
-                if (options.debug) {
-                    computedObservable._latestValue = newValue;
-                }
-                computedObservable.notifySubscribers(state.latestValue, 'spectate');
-                if (!state.isSleeping && notifyChange) {
-                    computedObservable.notifySubscribers(state.latestValue);
-                }
-                if (computedObservable._recordUpdate) {
-                    computedObservable._recordUpdate();
-                }
-            }
-            if (isInitial) {
-                computedObservable.notifySubscribers(state.latestValue, 'awake');
-            }
-            return changed;
-        },
-        evaluateImmediate_CallReadThenEndDependencyDetection: function (state, dependencyDetectionContext) {
-            // This function is really part of the evaluateImmediate_CallReadWithDependencyDetection logic.
-            // You'd never call it from anywhere else. Factoring it out means that evaluateImmediate_CallReadWithDependencyDetection
-            // can be independent of try/finally blocks, which contributes to saving about 40% off the CPU
-            // overhead of computed evaluation (on V8 at least).
-            try {
-                var readFunction = state.readFunction;
-                return state.evaluatorFunctionTarget ? readFunction.call(state.evaluatorFunctionTarget) : readFunction();
-            }
-            finally {
-                dependencyDetection.end();
-                // For each subscription no longer being used, remove it from the active subscriptions list and dispose it
-                if (dependencyDetectionContext.disposalCount && !state.isSleeping) {
-                    objectForEach(dependencyDetectionContext.disposalCandidates, computedDisposeDependencyCallback);
-                }
-                state.isStale = state.isDirty = false;
-            }
-        },
-        peek: function (forceEvaluate) {
-            // Peek won't ordinarily re-evaluate, except while the computed is sleeping
-            //  or to get the initial value when "deferEvaluation" is set.
-            var state = this[computedState];
-            if ((state.isDirty && (forceEvaluate || !state.dependenciesCount)) || (state.isSleeping && this.haveDependenciesChanged())) {
-                this.evaluateImmediate();
-            }
-            return state.latestValue;
-        }
-    },
-    Object.defineProperty(_a, LATEST_VALUE, {
-        get: function () {
-            return this.peek();
-        },
-        enumerable: true,
-        configurable: true
-    }),
-    _a.limit = function (limitFunction) {
-        var state = this[computedState];
-        // Override the limit function with one that delays evaluation as well
-        subscribable.fn.limit.call(this, limitFunction);
-        Object.assign(this, {
-            _evalIfChanged: function () {
-                if (!this[computedState].isSleeping) {
-                    if (this[computedState].isStale) {
-                        this.evaluateImmediate();
-                    }
-                    else {
-                        this[computedState].isDirty = false;
-                    }
-                }
-                return state.latestValue;
-            },
-            _evalDelayed: function (isChange) {
-                this._limitBeforeChange(state.latestValue);
-                // Mark as dirty
-                state.isDirty = true;
-                if (isChange) {
-                    state.isStale = true;
-                }
-                // Pass the observable to the "limit" code, which will evaluate it when
-                // it's time to do the notification.
-                this._limitChange(this, !isChange /* isDirty */);
-            }
-        });
-    },
-    _a.dispose = function () {
-        var state = this[computedState];
-        if (!state.isSleeping && state.dependencyTracking) {
-            objectForEach(state.dependencyTracking, function (id, dependency) {
-                if (dependency.dispose) {
-                    dependency.dispose();
-                }
-            });
-        }
-        if (state.disposeWhenNodeIsRemoved && state.domNodeDisposalCallback) {
-            removeDisposeCallback(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback);
-        }
-        Object.assign(state, DISPOSED_STATE);
-    },
-    _a);
-var pureComputedOverrides = {
-    beforeSubscriptionAdd: function (event) {
-        // If asleep, wake up the computed by subscribing to any dependencies.
-        var computedObservable = this, state = computedObservable[computedState];
-        if (!state.isDisposed && state.isSleeping && event === 'change') {
-            state.isSleeping = false;
-            if (state.isStale || computedObservable.haveDependenciesChanged()) {
-                state.dependencyTracking = null;
-                state.dependenciesCount = 0;
-                if (computedObservable.evaluateImmediate()) {
-                    computedObservable.updateVersion();
-                }
-            }
-            else {
-                // First put the dependencies in order
-                var dependenciesOrder = [];
-                objectForEach(state.dependencyTracking, function (id, dependency) {
-                    dependenciesOrder[dependency._order] = id;
-                });
-                // Next, subscribe to each one
-                arrayForEach(dependenciesOrder, function (id, order) {
-                    var dependency = state.dependencyTracking[id], subscription = computedObservable.subscribeToDependency(dependency._target);
-                    subscription._order = order;
-                    subscription._version = dependency._version;
-                    state.dependencyTracking[id] = subscription;
-                });
-                // Waking dependencies may have triggered effects
-                if (computedObservable.haveDependenciesChanged()) {
-                    if (computedObservable.evaluateImmediate()) {
-                        computedObservable.updateVersion();
-                    }
-                }
-            }
-            if (!state.isDisposed) { // test since evaluating could trigger disposal
-                computedObservable.notifySubscribers(state.latestValue, 'awake');
-            }
-        }
-    },
-    afterSubscriptionRemove: function (event) {
-        var state = this[computedState];
-        if (!state.isDisposed && event === 'change' && !this.hasSubscriptionsForEvent('change')) {
-            objectForEach(state.dependencyTracking, function (id, dependency) {
-                if (dependency.dispose) {
-                    state.dependencyTracking[id] = {
-                        _target: dependency._target,
-                        _order: dependency._order,
-                        _version: dependency._version
-                    };
-                    dependency.dispose();
-                }
-            });
-            state.isSleeping = true;
-            this.notifySubscribers(undefined, 'asleep');
-        }
-    },
-    getVersion: function () {
-        // Because a pure computed is not automatically updated while it is sleeping, we can't
-        // simply return the version number. Instead, we check if any of the dependencies have
-        // changed and conditionally re-evaluate the computed observable.
-        var state = this[computedState];
-        if (state.isSleeping && (state.isStale || this.haveDependenciesChanged())) {
-            this.evaluateImmediate();
-        }
-        return subscribable.fn.getVersion.call(this);
-    }
-};
-var deferEvaluationOverrides = {
-    beforeSubscriptionAdd: function (event) {
-        // This will force a computed with deferEvaluation to evaluate when the first subscription is registered.
-        if (event === 'change' || event === 'beforeChange') {
-            this.peek();
-        }
-    }
-};
-Object.setPrototypeOf(computed.fn, subscribable.fn);
-// Set the proto values for ko.computed
-var protoProp = observable.protoProperty; // == "__ko_proto__"
-computed.fn[protoProp] = computed;
-/* This is used by ko.isObservable */
-observable.observablePrototypes.add(computed);
-function isComputed(instance) {
-    return (typeof instance === 'function' && instance[protoProp] === computed);
-}
-function isPureComputed(instance) {
-    return isComputed(instance) && instance[computedState] && instance[computedState].pure;
-}
-function pureComputed(evaluatorFunctionOrOptions, evaluatorFunctionTarget) {
-    if (typeof evaluatorFunctionOrOptions === 'function') {
-        return computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, { 'pure': true });
-    }
-    else {
-        evaluatorFunctionOrOptions = extend({}, evaluatorFunctionOrOptions); // make a copy of the parameter object
-        evaluatorFunctionOrOptions.pure = true;
-        return computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget);
-    }
+// @tko/computed 🥊 4.0.0-beta1.0 ESM
+import {
+  addDisposeCallback,
+  arrayForEach,
+  createSymbolOrString,
+  domNodeIsAttachedToDocument,
+  extend,
+  options,
+  hasOwnProperty,
+  objectForEach,
+  options as koOptions,
+  removeDisposeCallback,
+  safeSetTimeout
+} from "@tko/utils";
+import {
+  dependencyDetection,
+  extenders,
+  valuesArePrimitiveAndEqual,
+  observable,
+  subscribable,
+  LATEST_VALUE
+} from "@tko/observable";
+const computedState = createSymbolOrString("_state");
+const DISPOSED_STATE = {
+  dependencyTracking: null,
+  dependenciesCount: 0,
+  isDisposed: true,
+  isStale: false,
+  isDirty: false,
+  isSleeping: false,
+  disposeWhenNodeIsRemoved: null,
+  readFunction: null,
+  _options: null
+};
+export function computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, options2) {
+  if (typeof evaluatorFunctionOrOptions === "object") {
+    options2 = evaluatorFunctionOrOptions;
+  } else {
+    options2 = options2 || {};
+    if (evaluatorFunctionOrOptions) {
+      options2.read = evaluatorFunctionOrOptions;
+    }
+  }
+  if (typeof options2.read !== "function") {
+    throw Error("Pass a function that returns the value of the computed");
+  }
+  var writeFunction = options2.write;
+  var state = {
+    latestValue: void 0,
+    isStale: true,
+    isDirty: true,
+    isBeingEvaluated: false,
+    suppressDisposalUntilDisposeWhenReturnsFalse: false,
+    isDisposed: false,
+    pure: false,
+    isSleeping: false,
+    readFunction: options2.read,
+    evaluatorFunctionTarget: evaluatorFunctionTarget || options2.owner,
+    disposeWhenNodeIsRemoved: options2.disposeWhenNodeIsRemoved || options2.disposeWhenNodeIsRemoved || null,
+    disposeWhen: options2.disposeWhen || options2.disposeWhen,
+    domNodeDisposalCallback: null,
+    dependencyTracking: {},
+    dependenciesCount: 0,
+    evaluationTimeoutInstance: null
+  };
+  function computedObservable() {
+    if (arguments.length > 0) {
+      if (typeof writeFunction === "function") {
+        writeFunction.apply(state.evaluatorFunctionTarget, arguments);
+      } else {
+        throw new Error("Cannot write a value to a computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters.");
+      }
+      return this;
+    } else {
+      if (!state.isDisposed) {
+        dependencyDetection.registerDependency(computedObservable);
+      }
+      if (state.isDirty || state.isSleeping && computedObservable.haveDependenciesChanged()) {
+        computedObservable.evaluateImmediate();
+      }
+      return state.latestValue;
+    }
+  }
+  computedObservable[computedState] = state;
+  computedObservable.isWriteable = typeof writeFunction === "function";
+  subscribable.fn.init(computedObservable);
+  Object.setPrototypeOf(computedObservable, computed.fn);
+  if (options2.pure) {
+    state.pure = true;
+    state.isSleeping = true;
+    extend(computedObservable, pureComputedOverrides);
+  } else if (options2.deferEvaluation) {
+    extend(computedObservable, deferEvaluationOverrides);
+  }
+  if (koOptions.deferUpdates) {
+    extenders.deferred(computedObservable, true);
+  }
+  if (koOptions.debug) {
+    computedObservable._options = options2;
+  }
+  if (state.disposeWhenNodeIsRemoved) {
+    state.suppressDisposalUntilDisposeWhenReturnsFalse = true;
+    if (!state.disposeWhenNodeIsRemoved.nodeType) {
+      state.disposeWhenNodeIsRemoved = null;
+    }
+  }
+  if (!state.isSleeping && !options2.deferEvaluation) {
+    computedObservable.evaluateImmediate();
+  }
+  if (state.disposeWhenNodeIsRemoved && computedObservable.isActive()) {
+    addDisposeCallback(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback = function() {
+      computedObservable.dispose();
+    });
+  }
+  return computedObservable;
 }
-
-function throttleExtender(target, timeout) {
-    // Throttling means two things:
-    // (1) For dependent observables, we throttle *evaluations* so that, no matter how fast its dependencies
-    //     notify updates, the target doesn't re-evaluate (and hence doesn't notify) faster than a certain rate
-    target.throttleEvaluation = timeout;
-    // (2) For writable targets (observables, or writable dependent observables), we throttle *writes*
-    //     so the target cannot change value synchronously or faster than a certain rate
-    var writeTimeoutInstance = null;
-    return computed({
-        read: target,
-        write: function (value) {
-            clearTimeout(writeTimeoutInstance);
-            writeTimeoutInstance = setTimeout(function () {
-                target(value);
-            }, timeout);
-        }
-    });
-}
-extenders.throttle = throttleExtender;
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-
-function __values(o) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
-    if (m) return m.call(o);
-    return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-}
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spread() {
-    for (var ar = [], i = 0; i < arguments.length; i++)
-        ar = ar.concat(__read(arguments[i]));
-    return ar;
+function computedDisposeDependencyCallback(id, entryToDispose) {
+  if (entryToDispose !== null && entryToDispose.dispose) {
+    entryToDispose.dispose();
+  }
 }
-
-/**
- * Create an ES
- */
-var PROXY_SYM = Symbol('Knockout Proxied Object');
-var MIRROR_SYM = Symbol('Knockout Proxied Observables');
-function makeComputed(proxy, fn) {
-    return computed({
-        owner: proxy,
-        read: fn,
-        write: fn,
-        pure: 'pure' in fn ? fn.pure : true,
-        deferEvaluation: 'deferEvaluation' in fn ? fn.deferEvaluation : true
-    }).extend({ deferred: true });
-}
-function setOrCreate(mirror, prop, value, proxy) {
-    if (!mirror[prop]) {
-        var ctr = Array.isArray(value) ? observableArray
-            : typeof value === 'function' ? makeComputed.bind(null, proxy)
-                : observable;
-        mirror[prop] = ctr(value);
-    }
-    else {
-        mirror[prop](value);
-    }
-}
-function assignOrUpdate(mirror, object, proxy) {
-    var e_1, _a;
-    try {
-        for (var _b = __values(Object.keys(object)), _c = _b.next(); !_c.done; _c = _b.next()) {
-            var key = _c.value;
-            setOrCreate(mirror, key, object[key], proxy);
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
-    return object;
-}
-function proxy(object) {
-    var _a;
-    var mirror = (_a = {}, _a[PROXY_SYM] = object, _a);
-    mirror[MIRROR_SYM] = mirror;
-    var proxy = new Proxy(function () { }, {
-        has: function (target, prop) { return prop in mirror; },
-        get: function (target, prop) { return unwrap(mirror[prop]); },
-        set: function (target, prop, value, receiver) {
-            setOrCreate(mirror, prop, value, proxy);
-            object[prop] = value;
-            return true;
-        },
-        deleteProperty: function (property) {
-            delete mirror[property];
-            return delete object[property];
-        },
-        apply: function (target, thisArg, _a) {
-            var _b = __read(_a, 1), props = _b[0];
-            if (props) {
-                assignOrUpdate(mirror, props, proxy);
-                return Object.assign(object, props);
-            }
-            return object;
-        },
-        getPrototypeOf: function () { return Object.getPrototypeOf(object); },
-        setPrototypeOf: function (target, proto) { return Object.setPrototypeOf(object, proto); },
-        defineProperty: function (target, prop, desc) { return Object.defineProperty(object, prop, desc); },
-        preventExtensions: function () { return Object.preventExtensions(object); },
-        isExtensible: function () { return Object.isExtensible(object); },
-        ownKeys: function () {
-            return __spread(Object.getOwnPropertyNames(object), Object.getOwnPropertySymbols(object));
-        }
-    });
-    assignOrUpdate(mirror, object, proxy);
-    return proxy;
-}
-function getObservable(proxied, prop) { return proxied[MIRROR_SYM][prop]; }
-function peek(proxied, prop) { return getObservable(proxied, prop).peek(); }
-function isProxied(proxied) { return PROXY_SYM in proxied; }
-Object.assign(proxy, { getObservable: getObservable, peek: peek, isProxied: isProxied });
-
-function kowhen(predicate, context, resolve) {
-    var observable$$1 = pureComputed(predicate, context).extend({ notify: 'always' });
-    var subscription = observable$$1.subscribe(function (value) {
-        if (value) {
-            subscription.dispose();
-            resolve(value);
-        }
-    });
-    // In case the initial value is true, process it right away
-    observable$$1.notifySubscribers(observable$$1.peek());
-    return subscription;
-}
-function when(predicate, callback, context) {
-    var whenFn = kowhen.bind(null, predicate, context);
-    return callback ? whenFn(callback.bind(context)) : new Promise(whenFn);
+function computedBeginDependencyDetectionCallback(subscribable2, id) {
+  var computedObservable = this.computedObservable, state = computedObservable[computedState];
+  if (!state.isDisposed) {
+    if (this.disposalCount && this.disposalCandidates[id]) {
+      computedObservable.addDependencyTracking(id, subscribable2, this.disposalCandidates[id]);
+      this.disposalCandidates[id] = null;
+      --this.disposalCount;
+    } else if (!state.dependencyTracking[id]) {
+      computedObservable.addDependencyTracking(id, subscribable2, state.isSleeping ? { _target: subscribable2 } : computedObservable.subscribeToDependency(subscribable2));
+    }
+    if (subscribable2._notificationIsPending) {
+      subscribable2._notifyNextChangeIfValueIsDifferent();
+    }
+  }
+}
+computed.fn = {
+  equalityComparer: valuesArePrimitiveAndEqual,
+  getDependenciesCount() {
+    return this[computedState].dependenciesCount;
+  },
+  getDependencies() {
+    const dependencyTracking = this[computedState].dependencyTracking;
+    const dependentObservables = [];
+    objectForEach(dependencyTracking, function(id, dependency) {
+      dependentObservables[dependency._order] = dependency._target;
+    });
+    return dependentObservables;
+  },
+  addDependencyTracking(id, target, trackingObj) {
+    if (this[computedState].pure && target === this) {
+      throw Error("A 'pure' computed must not be called recursively");
+    }
+    this[computedState].dependencyTracking[id] = trackingObj;
+    trackingObj._order = this[computedState].dependenciesCount++;
+    trackingObj._version = target.getVersion();
+  },
+  haveDependenciesChanged() {
+    var id, dependency, dependencyTracking = this[computedState].dependencyTracking;
+    for (id in dependencyTracking) {
+      if (hasOwnProperty(dependencyTracking, id)) {
+        dependency = dependencyTracking[id];
+        if (this._evalDelayed && dependency._target._notificationIsPending || dependency._target.hasChanged(dependency._version)) {
+          return true;
+        }
+      }
+    }
+  },
+  markDirty() {
+    if (this._evalDelayed && !this[computedState].isBeingEvaluated) {
+      this._evalDelayed(false);
+    }
+  },
+  isActive() {
+    const state = this[computedState];
+    return state.isDirty || state.dependenciesCount > 0;
+  },
+  respondToChange() {
+    if (!this._notificationIsPending) {
+      this.evaluatePossiblyAsync();
+    } else if (this[computedState].isDirty) {
+      this[computedState].isStale = true;
+    }
+  },
+  subscribeToDependency(target) {
+    if (target._deferUpdates) {
+      var dirtySub = target.subscribe(this.markDirty, this, "dirty"), changeSub = target.subscribe(this.respondToChange, this);
+      return {
+        _target: target,
+        dispose() {
+          dirtySub.dispose();
+          changeSub.dispose();
+        }
+      };
+    } else {
+      return target.subscribe(this.evaluatePossiblyAsync, this);
+    }
+  },
+  evaluatePossiblyAsync() {
+    var computedObservable = this, throttleEvaluationTimeout = computedObservable.throttleEvaluation;
+    if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {
+      clearTimeout(this[computedState].evaluationTimeoutInstance);
+      this[computedState].evaluationTimeoutInstance = safeSetTimeout(function() {
+        computedObservable.evaluateImmediate(true);
+      }, throttleEvaluationTimeout);
+    } else if (computedObservable._evalDelayed) {
+      computedObservable._evalDelayed(true);
+    } else {
+      computedObservable.evaluateImmediate(true);
+    }
+  },
+  evaluateImmediate(notifyChange) {
+    var computedObservable = this, state = computedObservable[computedState], disposeWhen = state.disposeWhen, changed = false;
+    if (state.isBeingEvaluated) {
+      return;
+    }
+    if (state.isDisposed) {
+      return;
+    }
+    if (state.disposeWhenNodeIsRemoved && !domNodeIsAttachedToDocument(state.disposeWhenNodeIsRemoved) || disposeWhen && disposeWhen()) {
+      if (!state.suppressDisposalUntilDisposeWhenReturnsFalse) {
+        computedObservable.dispose();
+        return;
+      }
+    } else {
+      state.suppressDisposalUntilDisposeWhenReturnsFalse = false;
+    }
+    state.isBeingEvaluated = true;
+    try {
+      changed = this.evaluateImmediate_CallReadWithDependencyDetection(notifyChange);
+    } finally {
+      state.isBeingEvaluated = false;
+    }
+    return changed;
+  },
+  evaluateImmediate_CallReadWithDependencyDetection(notifyChange) {
+    var computedObservable = this, state = computedObservable[computedState], changed = false;
+    var isInitial = state.pure ? void 0 : !state.dependenciesCount, dependencyDetectionContext = {
+      computedObservable,
+      disposalCandidates: state.dependencyTracking,
+      disposalCount: state.dependenciesCount
+    };
+    dependencyDetection.begin({
+      callbackTarget: dependencyDetectionContext,
+      callback: computedBeginDependencyDetectionCallback,
+      computed: computedObservable,
+      isInitial
+    });
+    state.dependencyTracking = {};
+    state.dependenciesCount = 0;
+    var newValue = this.evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext);
+    if (!state.dependenciesCount) {
+      computedObservable.dispose();
+      changed = true;
+    } else {
+      changed = computedObservable.isDifferent(state.latestValue, newValue);
+    }
+    if (changed) {
+      if (!state.isSleeping) {
+        computedObservable.notifySubscribers(state.latestValue, "beforeChange");
+      } else {
+        computedObservable.updateVersion();
+      }
+      state.latestValue = newValue;
+      if (options.debug) {
+        computedObservable._latestValue = newValue;
+      }
+      computedObservable.notifySubscribers(state.latestValue, "spectate");
+      if (!state.isSleeping && notifyChange) {
+        computedObservable.notifySubscribers(state.latestValue);
+      }
+      if (computedObservable._recordUpdate) {
+        computedObservable._recordUpdate();
+      }
+    }
+    if (isInitial) {
+      computedObservable.notifySubscribers(state.latestValue, "awake");
+    }
+    return changed;
+  },
+  evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext) {
+    try {
+      var readFunction = state.readFunction;
+      return state.evaluatorFunctionTarget ? readFunction.call(state.evaluatorFunctionTarget) : readFunction();
+    } finally {
+      dependencyDetection.end();
+      if (dependencyDetectionContext.disposalCount && !state.isSleeping) {
+        objectForEach(dependencyDetectionContext.disposalCandidates, computedDisposeDependencyCallback);
+      }
+      state.isStale = state.isDirty = false;
+    }
+  },
+  peek(forceEvaluate) {
+    const state = this[computedState];
+    if (state.isDirty && (forceEvaluate || !state.dependenciesCount) || state.isSleeping && this.haveDependenciesChanged()) {
+      this.evaluateImmediate();
+    }
+    return state.latestValue;
+  },
+  get [LATEST_VALUE]() {
+    return this.peek();
+  },
+  limit(limitFunction) {
+    const state = this[computedState];
+    subscribable.fn.limit.call(this, limitFunction);
+    Object.assign(this, {
+      _evalIfChanged() {
+        if (!this[computedState].isSleeping) {
+          if (this[computedState].isStale) {
+            this.evaluateImmediate();
+          } else {
+            this[computedState].isDirty = false;
+          }
+        }
+        return state.latestValue;
+      },
+      _evalDelayed(isChange) {
+        this._limitBeforeChange(state.latestValue);
+        state.isDirty = true;
+        if (isChange) {
+          state.isStale = true;
+        }
+        this._limitChange(this, !isChange);
+      }
+    });
+  },
+  dispose() {
+    var state = this[computedState];
+    if (!state.isSleeping && state.dependencyTracking) {
+      objectForEach(state.dependencyTracking, function(id, dependency) {
+        if (dependency.dispose) {
+          dependency.dispose();
+        }
+      });
+    }
+    if (state.disposeWhenNodeIsRemoved && state.domNodeDisposalCallback) {
+      removeDisposeCallback(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback);
+    }
+    Object.assign(state, DISPOSED_STATE);
+  }
+};
+var pureComputedOverrides = {
+  beforeSubscriptionAdd(event) {
+    var computedObservable = this, state = computedObservable[computedState];
+    if (!state.isDisposed && state.isSleeping && event === "change") {
+      state.isSleeping = false;
+      if (state.isStale || computedObservable.haveDependenciesChanged()) {
+        state.dependencyTracking = null;
+        state.dependenciesCount = 0;
+        if (computedObservable.evaluateImmediate()) {
+          computedObservable.updateVersion();
+        }
+      } else {
+        var dependenciesOrder = [];
+        objectForEach(state.dependencyTracking, function(id, dependency) {
+          dependenciesOrder[dependency._order] = id;
+        });
+        arrayForEach(dependenciesOrder, function(id, order) {
+          var dependency = state.dependencyTracking[id], subscription = computedObservable.subscribeToDependency(dependency._target);
+          subscription._order = order;
+          subscription._version = dependency._version;
+          state.dependencyTracking[id] = subscription;
+        });
+        if (computedObservable.haveDependenciesChanged()) {
+          if (computedObservable.evaluateImmediate()) {
+            computedObservable.updateVersion();
+          }
+        }
+      }
+      if (!state.isDisposed) {
+        computedObservable.notifySubscribers(state.latestValue, "awake");
+      }
+    }
+  },
+  afterSubscriptionRemove(event) {
+    var state = this[computedState];
+    if (!state.isDisposed && event === "change" && !this.hasSubscriptionsForEvent("change")) {
+      objectForEach(state.dependencyTracking, function(id, dependency) {
+        if (dependency.dispose) {
+          state.dependencyTracking[id] = {
+            _target: dependency._target,
+            _order: dependency._order,
+            _version: dependency._version
+          };
+          dependency.dispose();
+        }
+      });
+      state.isSleeping = true;
+      this.notifySubscribers(void 0, "asleep");
+    }
+  },
+  getVersion() {
+    var state = this[computedState];
+    if (state.isSleeping && (state.isStale || this.haveDependenciesChanged())) {
+      this.evaluateImmediate();
+    }
+    return subscribable.fn.getVersion.call(this);
+  }
+};
+var deferEvaluationOverrides = {
+  beforeSubscriptionAdd(event) {
+    if (event === "change" || event === "beforeChange") {
+      this.peek();
+    }
+  }
+};
+Object.setPrototypeOf(computed.fn, subscribable.fn);
+var protoProp = observable.protoProperty;
+computed.fn[protoProp] = computed;
+observable.observablePrototypes.add(computed);
+export function isComputed(instance) {
+  return typeof instance === "function" && instance[protoProp] === computed;
+}
+export function isPureComputed(instance) {
+  return isComputed(instance) && instance[computedState] && instance[computedState].pure;
+}
+export function pureComputed(evaluatorFunctionOrOptions, evaluatorFunctionTarget) {
+  if (typeof evaluatorFunctionOrOptions === "function") {
+    return computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, { "pure": true });
+  } else {
+    evaluatorFunctionOrOptions = extend({}, evaluatorFunctionOrOptions);
+    evaluatorFunctionOrOptions.pure = true;
+    return computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget);
+  }
 }
-
-//
-
-export { computed, isComputed, isPureComputed, pureComputed, throttleExtender, proxy, when };
-//# sourceMappingURL=computed.js.map