@tko/observable 4.0.0-alpha7.4 → 4.0.0-beta1.3

package/dist/observable.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"observable.js","sources":["../../../node_modules/tslib/tslib.es6.js"],"sourcesContent":["/*! *****************************************************************************\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 = 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\r\nexport function __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\nexport var __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\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __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\nexport function __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}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{
+  "version": 3,
+  "sources": ["../src/observable.ts"],
+  "sourcesContent": ["//\n//  Observable values\n//  ---\n//\nimport {\n  options, overwriteLengthPropertyIfSupported\n} from '@tko/utils'\n\nimport * as dependencyDetection from './dependencyDetection'\nimport { deferUpdates } from './defer'\nimport { subscribable, defaultEvent, LATEST_VALUE } from './subscribable'\nimport { valuesArePrimitiveAndEqual } from './extenders'\n\nexport function observable (initialValue) {\n  function Observable () {\n    if (arguments.length > 0) {\n            // Write\n            // Ignore writes if the value hasn't changed\n      if (Observable.isDifferent(Observable[LATEST_VALUE], arguments[0])) {\n        Observable.valueWillMutate()\n        Observable[LATEST_VALUE] = arguments[0]\n        Observable.valueHasMutated()\n      }\n      return this // Permits chained assignments\n    } else {\n            // Read\n      dependencyDetection.registerDependency(Observable) // The caller only needs to be notified of changes if they did a \"read\" operation\n      return Observable[LATEST_VALUE]\n    }\n  }\n\n  overwriteLengthPropertyIfSupported(Observable, { value: undefined })\n\n  Observable[LATEST_VALUE] = initialValue\n\n  subscribable.fn.init(Observable)\n\n    // Inherit from 'observable'\n  Object.setPrototypeOf(Observable, observable.fn)\n\n  if (options.deferUpdates) {\n    deferUpdates(Observable)\n  }\n\n  return Observable\n}\n\n// Define prototype for observables\nobservable.fn = {\n  equalityComparer: valuesArePrimitiveAndEqual,\n  peek () { return this[LATEST_VALUE] },\n  valueHasMutated () {\n    this.notifySubscribers(this[LATEST_VALUE], 'spectate')\n    this.notifySubscribers(this[LATEST_VALUE])\n  },\n  valueWillMutate () {\n    this.notifySubscribers(this[LATEST_VALUE], 'beforeChange')\n  },\n\n  modify (fn, peek = true) {\n    return this(fn(peek ? this.peek() : this()))\n  },\n\n  // Some observables may not always be writeable, notably computeds.\n  isWriteable: true\n}\n\n// Moved out of \"limit\" to avoid the extra closure\nfunction limitNotifySubscribers (value, event) {\n  if (!event || event === defaultEvent) {\n    this._limitChange(value)\n  } else if (event === 'beforeChange') {\n    this._limitBeforeChange(value)\n  } else {\n    this._origNotifySubscribers(value, event)\n  }\n}\n\n// Add `limit` function to the subscribable prototype\nsubscribable.fn.limit = function limit (limitFunction) {\n  var self = this\n  var selfIsObservable = isObservable(self)\n  var beforeChange = 'beforeChange'\n  var ignoreBeforeChange, notifyNextChange, previousValue, pendingValue, didUpdate\n\n  if (!self._origNotifySubscribers) {\n    self._origNotifySubscribers = self.notifySubscribers\n    self.notifySubscribers = limitNotifySubscribers\n  }\n\n  var finish = limitFunction(function () {\n    self._notificationIsPending = false\n\n    // If an observable provided a reference to itself, access it to get the latest value.\n    // This allows computed observables to delay calculating their value until needed.\n    if (selfIsObservable && pendingValue === self) {\n      pendingValue = self._evalIfChanged ? self._evalIfChanged() : self()\n    }\n    const shouldNotify = notifyNextChange || (\n      didUpdate && self.isDifferent(previousValue, pendingValue)\n    )\n    self._notifyNextChange = didUpdate = ignoreBeforeChange = false\n    if (shouldNotify) {\n      self._origNotifySubscribers(previousValue = pendingValue)\n    }\n  })\n\n  Object.assign(self, {\n    _limitChange  (value, isDirty) {\n      if (!isDirty || !self._notificationIsPending) {\n        didUpdate = !isDirty\n      }\n      self._changeSubscriptions = [...self._subscriptions[defaultEvent]]\n      self._notificationIsPending = ignoreBeforeChange = true\n      pendingValue = value\n      finish()\n    },\n\n    _limitBeforeChange (value) {\n      if (!ignoreBeforeChange) {\n        previousValue = value\n        self._origNotifySubscribers(value, beforeChange)\n      }\n    },\n\n    _notifyNextChangeIfValueIsDifferent () {\n      if (self.isDifferent(previousValue, self.peek(true /* evaluate */))) {\n        notifyNextChange = true\n      }\n    },\n\n    _recordUpdate () {\n      didUpdate = true\n    }\n  })\n}\n\nObject.setPrototypeOf(observable.fn, subscribable.fn)\n\nvar protoProperty = observable.protoProperty = options.protoProperty\nobservable.fn[protoProperty] = observable\n\n// Subclasses can add themselves to observableProperties so that\n// isObservable will be `true`.\nobservable.observablePrototypes = new Set([observable])\n\nexport function isObservable (instance) {\n  const proto = typeof instance === 'function' && instance[protoProperty]\n  if (proto && !observable.observablePrototypes.has(proto)) {\n    throw Error('Invalid object that looks like an observable; possibly from another Knockout instance')\n  }\n  return !!proto\n}\n\nexport function unwrap (value) {\n  return isObservable(value) ? value() : value\n}\n\nexport function peek (value) {\n  return isObservable(value) ? value.peek() : value\n}\n\nexport function isWriteableObservable (instance) {\n  return isObservable(instance) && instance.isWriteable\n}\n\nexport { isWriteableObservable as isWritableObservable }\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/observableArray.changeTracking.js

@@ -0,0 +1,126 @@
+// @tko/observable 🥊 4.0.0-beta1.3 ESM
+import {
+  extend,
+  compareArrays,
+  findMovesInArrayComparison
+} from "@tko/utils";
+import { defaultEvent } from "./subscribable";
+import { extenders } from "./extenders";
+export var arrayChangeEventName = "arrayChange";
+export function trackArrayChanges(target, options) {
+  target.compareArrayOptions = {};
+  if (options && typeof options === "object") {
+    extend(target.compareArrayOptions, options);
+  }
+  target.compareArrayOptions.sparse = true;
+  if (target.cacheDiffForKnownOperation) {
+    return;
+  }
+  let trackingChanges = false;
+  let cachedDiff = null;
+  let arrayChangeSubscription;
+  let pendingNotifications = 0;
+  let underlyingNotifySubscribersFunction;
+  let underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd;
+  let underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove;
+  target.beforeSubscriptionAdd = function(event) {
+    if (underlyingBeforeSubscriptionAddFunction) {
+      underlyingBeforeSubscriptionAddFunction.call(target, event);
+    }
+    if (event === arrayChangeEventName) {
+      trackChanges();
+    }
+  };
+  target.afterSubscriptionRemove = function(event) {
+    if (underlyingAfterSubscriptionRemoveFunction) {
+      underlyingAfterSubscriptionRemoveFunction.call(target, event);
+    }
+    if (event === arrayChangeEventName && !target.hasSubscriptionsForEvent(arrayChangeEventName)) {
+      if (underlyingNotifySubscribersFunction) {
+        target.notifySubscribers = underlyingNotifySubscribersFunction;
+        underlyingNotifySubscribersFunction = void 0;
+      }
+      if (arrayChangeSubscription) {
+        arrayChangeSubscription.dispose();
+      }
+      arrayChangeSubscription = null;
+      trackingChanges = false;
+    }
+  };
+  function trackChanges() {
+    if (trackingChanges) {
+      return;
+    }
+    trackingChanges = true;
+    underlyingNotifySubscribersFunction = target["notifySubscribers"];
+    target.notifySubscribers = function(valueToNotify, event) {
+      if (!event || event === defaultEvent) {
+        ++pendingNotifications;
+      }
+      return underlyingNotifySubscribersFunction.apply(this, arguments);
+    };
+    var previousContents = [].concat(target.peek() === void 0 ? [] : target.peek());
+    cachedDiff = null;
+    arrayChangeSubscription = target.subscribe(function(currentContents) {
+      let changes;
+      currentContents = [].concat(currentContents || []);
+      if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {
+        changes = getChanges(previousContents, currentContents);
+      }
+      previousContents = currentContents;
+      cachedDiff = null;
+      pendingNotifications = 0;
+      if (changes && changes.length) {
+        target.notifySubscribers(changes, arrayChangeEventName);
+      }
+    });
+  }
+  function getChanges(previousContents, currentContents) {
+    if (!cachedDiff || pendingNotifications > 1) {
+      cachedDiff = trackArrayChanges.compareArrays(previousContents, currentContents, target.compareArrayOptions);
+    }
+    return cachedDiff;
+  }
+  target.cacheDiffForKnownOperation = function(rawArray, operationName, args) {
+    if (!trackingChanges || pendingNotifications) {
+      return;
+    }
+    var diff = [], arrayLength = rawArray.length, argsLength = args.length, offset = 0;
+    function pushDiff(status, value, index) {
+      return diff[diff.length] = { "status": status, "value": value, "index": index };
+    }
+    switch (operationName) {
+      case "push":
+        offset = arrayLength;
+      case "unshift":
+        for (let index = 0; index < argsLength; index++) {
+          pushDiff("added", args[index], offset + index);
+        }
+        break;
+      case "pop":
+        offset = arrayLength - 1;
+      case "shift":
+        if (arrayLength) {
+          pushDiff("deleted", rawArray[offset], offset);
+        }
+        break;
+      case "splice":
+        var startIndex = Math.min(Math.max(0, args[0] < 0 ? arrayLength + args[0] : args[0]), arrayLength), endDeleteIndex = argsLength === 1 ? arrayLength : Math.min(startIndex + (args[1] || 0), arrayLength), endAddIndex = startIndex + argsLength - 2, endIndex = Math.max(endDeleteIndex, endAddIndex), additions = [], deletions = [];
+        for (let index = startIndex, argsIndex = 2; index < endIndex; ++index, ++argsIndex) {
+          if (index < endDeleteIndex) {
+            deletions.push(pushDiff("deleted", rawArray[index], index));
+          }
+          if (index < endAddIndex) {
+            additions.push(pushDiff("added", args[argsIndex], index));
+          }
+        }
+        findMovesInArrayComparison(deletions, additions);
+        break;
+      default:
+        return;
+    }
+    cachedDiff = diff;
+  };
+}
+trackArrayChanges.compareArrays = compareArrays;
+extenders.trackArrayChanges = trackArrayChanges;

package/dist/observableArray.changeTracking.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/observableArray.changeTracking.ts"],
+  "sourcesContent": ["//\n// Observable Array - Change Tracking Extender\n// ---\n//\n/* eslint no-fallthrough: 0 */\n\nimport {\n    extend, compareArrays, findMovesInArrayComparison\n} from '@tko/utils'\n\nimport { defaultEvent } from './subscribable'\nimport { extenders } from './extenders'\n\nexport var arrayChangeEventName = 'arrayChange'\n\nexport function trackArrayChanges (target, options) {\n    // Use the provided options--each call to trackArrayChanges overwrites the previously set options\n  target.compareArrayOptions = {}\n  if (options && typeof options === 'object') {\n    extend(target.compareArrayOptions, options)\n  }\n  target.compareArrayOptions.sparse = true\n\n    // Only modify the target observable once\n  if (target.cacheDiffForKnownOperation) {\n    return\n  }\n  let trackingChanges = false\n  let cachedDiff = null\n  let arrayChangeSubscription\n  let pendingNotifications = 0\n  let underlyingNotifySubscribersFunction\n  let underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd\n  let underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove\n\n    // Watch \"subscribe\" calls, and for array change events, ensure change tracking is enabled\n  target.beforeSubscriptionAdd = function (event) {\n    if (underlyingBeforeSubscriptionAddFunction) {\n      underlyingBeforeSubscriptionAddFunction.call(target, event)\n    }\n    if (event === arrayChangeEventName) {\n      trackChanges()\n    }\n  }\n\n    // Watch \"dispose\" calls, and for array change events, ensure change tracking is disabled when all are disposed\n  target.afterSubscriptionRemove = function (event) {\n    if (underlyingAfterSubscriptionRemoveFunction) {\n      underlyingAfterSubscriptionRemoveFunction.call(target, event)\n    }\n    if (event === arrayChangeEventName && !target.hasSubscriptionsForEvent(arrayChangeEventName)) {\n      if (underlyingNotifySubscribersFunction) {\n        target.notifySubscribers = underlyingNotifySubscribersFunction\n        underlyingNotifySubscribersFunction = undefined\n      }\n      if (arrayChangeSubscription) {\n        arrayChangeSubscription.dispose()\n      }\n      arrayChangeSubscription = null\n      trackingChanges = false\n    }\n  }\n\n  function trackChanges () {\n        // Calling 'trackChanges' multiple times is the same as calling it once\n    if (trackingChanges) {\n      return\n    }\n\n    trackingChanges = true\n\n        // Intercept \"notifySubscribers\" to track how many times it was called.\n    underlyingNotifySubscribersFunction = target['notifySubscribers']\n    target.notifySubscribers = function (valueToNotify, event) {\n      if (!event || event === defaultEvent) {\n        ++pendingNotifications\n      }\n      return underlyingNotifySubscribersFunction.apply(this, arguments)\n    }\n\n        // Each time the array changes value, capture a clone so that on the next\n        // change it's possible to produce a diff\n    var previousContents = [].concat(target.peek() === undefined ? [] : target.peek())\n    cachedDiff = null\n    arrayChangeSubscription = target.subscribe(function (currentContents) {\n      let changes\n            // Make a copy of the current contents and ensure it's an array\n      currentContents = [].concat(currentContents || [])\n\n            // Compute the diff and issue notifications, but only if someone is listening\n      if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {\n        changes = getChanges(previousContents, currentContents)\n      }\n\n            // Eliminate references to the old, removed items, so they can be GCed\n      previousContents = currentContents\n      cachedDiff = null\n      pendingNotifications = 0\n\n      if (changes && changes.length) {\n        target.notifySubscribers(changes, arrayChangeEventName)\n      }\n    })\n  }\n\n  function getChanges (previousContents, currentContents) {\n        // We try to re-use cached diffs.\n        // The scenarios where pendingNotifications > 1 are when using rate-limiting or the Deferred Updates\n        // plugin, which without this check would not be compatible with arrayChange notifications. Normally,\n        // notifications are issued immediately so we wouldn't be queueing up more than one.\n    if (!cachedDiff || pendingNotifications > 1) {\n      cachedDiff = trackArrayChanges.compareArrays(previousContents, currentContents, target.compareArrayOptions)\n    }\n\n    return cachedDiff\n  }\n\n  target.cacheDiffForKnownOperation = function (rawArray, operationName, args) {\n      // Only run if we're currently tracking changes for this observable array\n      // and there aren't any pending deferred notifications.\n    if (!trackingChanges || pendingNotifications) {\n      return\n    }\n    var diff = [],\n      arrayLength = rawArray.length,\n      argsLength = args.length,\n      offset = 0\n\n    function pushDiff (status, value, index) {\n      return diff[diff.length] = { 'status': status, 'value': value, 'index': index }\n    }\n    switch (operationName) {\n      case 'push':\n        offset = arrayLength\n      case 'unshift':\n        for (let index = 0; index < argsLength; index++) {\n          pushDiff('added', args[index], offset + index)\n        }\n        break\n\n      case 'pop':\n        offset = arrayLength - 1\n      case 'shift':\n        if (arrayLength) {\n          pushDiff('deleted', rawArray[offset], offset)\n        }\n        break\n\n      case 'splice':\n            // Negative start index means 'from end of array'. After that we clamp to [0...arrayLength].\n            // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice\n        var startIndex = Math.min(Math.max(0, args[0] < 0 ? arrayLength + args[0] : args[0]), arrayLength),\n          endDeleteIndex = argsLength === 1 ? arrayLength : Math.min(startIndex + (args[1] || 0), arrayLength),\n          endAddIndex = startIndex + argsLength - 2,\n          endIndex = Math.max(endDeleteIndex, endAddIndex),\n          additions = [], deletions = []\n        for (let index = startIndex, argsIndex = 2; index < endIndex; ++index, ++argsIndex) {\n          if (index < endDeleteIndex) { deletions.push(pushDiff('deleted', rawArray[index], index)) }\n          if (index < endAddIndex) { additions.push(pushDiff('added', args[argsIndex], index)) }\n        }\n        findMovesInArrayComparison(deletions, additions)\n        break\n\n      default:\n        return\n    }\n    cachedDiff = diff\n  }\n}\n\n// Expose compareArrays for testing.\ntrackArrayChanges.compareArrays = compareArrays\n\n// Add the trackArrayChanges extender so we can use\n// obs.extend({ trackArrayChanges: true })\nextenders.trackArrayChanges = trackArrayChanges\n"],
+  "mappings": ";AAMA;AAAA;AAAA;AAAA;AAAA;AAIA;AACA;AAEO,WAAI,uBAAuB;AAE3B,kCAA4B,QAAQ,SAAS;AAElD,SAAO,sBAAsB,CAAC;AAC9B,MAAI,WAAW,OAAO,YAAY,UAAU;AAC1C,WAAO,OAAO,qBAAqB,OAAO;AAAA,EAC5C;AACA,SAAO,oBAAoB,SAAS;AAGpC,MAAI,OAAO,4BAA4B;AACrC;AAAA,EACF;AACA,MAAI,kBAAkB;AACtB,MAAI,aAAa;AACjB,MAAI;AACJ,MAAI,uBAAuB;AAC3B,MAAI;AACJ,MAAI,0CAA0C,OAAO;AACrD,MAAI,4CAA4C,OAAO;AAGvD,SAAO,wBAAwB,SAAU,OAAO;AAC9C,QAAI,yCAAyC;AAC3C,8CAAwC,KAAK,QAAQ,KAAK;AAAA,IAC5D;AACA,QAAI,UAAU,sBAAsB;AAClC,mBAAa;AAAA,IACf;AAAA,EACF;AAGA,SAAO,0BAA0B,SAAU,OAAO;AAChD,QAAI,2CAA2C;AAC7C,gDAA0C,KAAK,QAAQ,KAAK;AAAA,IAC9D;AACA,QAAI,UAAU,wBAAwB,CAAC,OAAO,yBAAyB,oBAAoB,GAAG;AAC5F,UAAI,qCAAqC;AACvC,eAAO,oBAAoB;AAC3B,8CAAsC;AAAA,MACxC;AACA,UAAI,yBAAyB;AAC3B,gCAAwB,QAAQ;AAAA,MAClC;AACA,gCAA0B;AAC1B,wBAAkB;AAAA,IACpB;AAAA,EACF;AAEA,0BAAyB;AAEvB,QAAI,iBAAiB;AACnB;AAAA,IACF;AAEA,sBAAkB;AAGlB,0CAAsC,OAAO;AAC7C,WAAO,oBAAoB,SAAU,eAAe,OAAO;AACzD,UAAI,CAAC,SAAS,UAAU,cAAc;AACpC,UAAE;AAAA,MACJ;AACA,aAAO,oCAAoC,MAAM,MAAM,SAAS;AAAA,IAClE;AAIA,QAAI,mBAAmB,CAAC,EAAE,OAAO,OAAO,KAAK,MAAM,SAAY,CAAC,IAAI,OAAO,KAAK,CAAC;AACjF,iBAAa;AACb,8BAA0B,OAAO,UAAU,SAAU,iBAAiB;AACpE,UAAI;AAEJ,wBAAkB,CAAC,EAAE,OAAO,mBAAmB,CAAC,CAAC;AAGjD,UAAI,OAAO,yBAAyB,oBAAoB,GAAG;AACzD,kBAAU,WAAW,kBAAkB,eAAe;AAAA,MACxD;AAGA,yBAAmB;AACnB,mBAAa;AACb,6BAAuB;AAEvB,UAAI,WAAW,QAAQ,QAAQ;AAC7B,eAAO,kBAAkB,SAAS,oBAAoB;AAAA,MACxD;AAAA,IACF,CAAC;AAAA,EACH;AAEA,sBAAqB,kBAAkB,iBAAiB;AAKtD,QAAI,CAAC,cAAc,uBAAuB,GAAG;AAC3C,mBAAa,kBAAkB,cAAc,kBAAkB,iBAAiB,OAAO,mBAAmB;AAAA,IAC5G;AAEA,WAAO;AAAA,EACT;AAEA,SAAO,6BAA6B,SAAU,UAAU,eAAe,MAAM;AAG3E,QAAI,CAAC,mBAAmB,sBAAsB;AAC5C;AAAA,IACF;AACA,QAAI,OAAO,CAAC,GACV,cAAc,SAAS,QACvB,aAAa,KAAK,QAClB,SAAS;AAEX,sBAAmB,QAAQ,OAAO,OAAO;AACvC,aAAO,KAAK,KAAK,UAAU,EAAE,UAAU,QAAQ,SAAS,OAAO,SAAS,MAAM;AAAA,IAChF;AACA,YAAQ;AAAA,WACD;AACH,iBAAS;AAAA,WACN;AACH,iBAAS,QAAQ,GAAG,QAAQ,YAAY,SAAS;AAC/C,mBAAS,SAAS,KAAK,QAAQ,SAAS,KAAK;AAAA,QAC/C;AACA;AAAA,WAEG;AACH,iBAAS,cAAc;AAAA,WACpB;AACH,YAAI,aAAa;AACf,mBAAS,WAAW,SAAS,SAAS,MAAM;AAAA,QAC9C;AACA;AAAA,WAEG;AAGH,YAAI,aAAa,KAAK,IAAI,KAAK,IAAI,GAAG,KAAK,KAAK,IAAI,cAAc,KAAK,KAAK,KAAK,EAAE,GAAG,WAAW,GAC/F,iBAAiB,eAAe,IAAI,cAAc,KAAK,IAAI,aAAc,MAAK,MAAM,IAAI,WAAW,GACnG,cAAc,aAAa,aAAa,GACxC,WAAW,KAAK,IAAI,gBAAgB,WAAW,GAC/C,YAAY,CAAC,GAAG,YAAY,CAAC;AAC/B,iBAAS,QAAQ,YAAY,YAAY,GAAG,QAAQ,UAAU,EAAE,OAAO,EAAE,WAAW;AAClF,cAAI,QAAQ,gBAAgB;AAAE,sBAAU,KAAK,SAAS,WAAW,SAAS,QAAQ,KAAK,CAAC;AAAA,UAAE;AAC1F,cAAI,QAAQ,aAAa;AAAE,sBAAU,KAAK,SAAS,SAAS,KAAK,YAAY,KAAK,CAAC;AAAA,UAAE;AAAA,QACvF;AACA,mCAA2B,WAAW,SAAS;AAC/C;AAAA;AAGA;AAAA;AAEJ,iBAAa;AAAA,EACf;AACF;AAGA,kBAAkB,gBAAgB;AAIlC,UAAU,oBAAoB;",
+  "names": []
+}

package/dist/observableArray.js

@@ -0,0 +1,130 @@
+// @tko/observable 🥊 4.0.0-beta1.3 ESM
+import {
+  arrayIndexOf,
+  arrayForEach,
+  overwriteLengthPropertyIfSupported
+} from "@tko/utils";
+import { observable, isObservable } from "./observable";
+import { trackArrayChanges } from "./observableArray.changeTracking";
+export function observableArray(initialValues) {
+  initialValues = initialValues || [];
+  if (typeof initialValues !== "object" || !("length" in initialValues)) {
+    throw new Error("The argument passed when initializing an observable array must be an array, or null, or undefined.");
+  }
+  var result = observable(initialValues);
+  Object.setPrototypeOf(result, observableArray.fn);
+  trackArrayChanges(result);
+  overwriteLengthPropertyIfSupported(result, { get: () => result().length });
+  return result;
+}
+export function isObservableArray(instance) {
+  return isObservable(instance) && typeof instance.remove === "function" && typeof instance.push === "function";
+}
+observableArray.fn = {
+  remove(valueOrPredicate) {
+    var underlyingArray = this.peek();
+    var removedValues = [];
+    var predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value2) {
+      return value2 === valueOrPredicate;
+    };
+    for (var i = 0; i < underlyingArray.length; i++) {
+      var value = underlyingArray[i];
+      if (predicate(value)) {
+        if (removedValues.length === 0) {
+          this.valueWillMutate();
+        }
+        if (underlyingArray[i] !== value) {
+          throw Error("Array modified during remove; cannot remove item");
+        }
+        removedValues.push(value);
+        underlyingArray.splice(i, 1);
+        i--;
+      }
+    }
+    if (removedValues.length) {
+      this.valueHasMutated();
+    }
+    return removedValues;
+  },
+  removeAll(arrayOfValues) {
+    if (arrayOfValues === void 0) {
+      var underlyingArray = this.peek();
+      var allValues = underlyingArray.slice(0);
+      this.valueWillMutate();
+      underlyingArray.splice(0, underlyingArray.length);
+      this.valueHasMutated();
+      return allValues;
+    }
+    if (!arrayOfValues) {
+      return [];
+    }
+    return this["remove"](function(value) {
+      return arrayIndexOf(arrayOfValues, value) >= 0;
+    });
+  },
+  destroy(valueOrPredicate) {
+    var underlyingArray = this.peek();
+    var predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value2) {
+      return value2 === valueOrPredicate;
+    };
+    this.valueWillMutate();
+    for (var i = underlyingArray.length - 1; i >= 0; i--) {
+      var value = underlyingArray[i];
+      if (predicate(value)) {
+        value["_destroy"] = true;
+      }
+    }
+    this.valueHasMutated();
+  },
+  destroyAll(arrayOfValues) {
+    if (arrayOfValues === void 0) {
+      return this.destroy(function() {
+        return true;
+      });
+    }
+    if (!arrayOfValues) {
+      return [];
+    }
+    return this.destroy(function(value) {
+      return arrayIndexOf(arrayOfValues, value) >= 0;
+    });
+  },
+  indexOf(item) {
+    return arrayIndexOf(this(), item);
+  },
+  replace(oldItem, newItem) {
+    var index = this.indexOf(oldItem);
+    if (index >= 0) {
+      this.valueWillMutate();
+      this.peek()[index] = newItem;
+      this.valueHasMutated();
+    }
+  },
+  sorted(compareFn) {
+    return [...this()].sort(compareFn);
+  },
+  reversed() {
+    return [...this()].reverse();
+  },
+  [Symbol.iterator]: function* () {
+    yield* this();
+  }
+};
+Object.setPrototypeOf(observableArray.fn, observable.fn);
+arrayForEach(["pop", "push", "reverse", "shift", "sort", "splice", "unshift"], function(methodName) {
+  observableArray.fn[methodName] = function() {
+    var underlyingArray = this.peek();
+    this.valueWillMutate();
+    this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments);
+    var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);
+    this.valueHasMutated();
+    return methodCallResult === underlyingArray ? this : methodCallResult;
+  };
+});
+arrayForEach(["slice"], function(methodName) {
+  observableArray.fn[methodName] = function() {
+    var underlyingArray = this();
+    return underlyingArray[methodName].apply(underlyingArray, arguments);
+  };
+});
+observableArray.trackArrayChanges = trackArrayChanges;

package/dist/observableArray.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/observableArray.ts"],
+  "sourcesContent": ["//\n// Observable Arrays\n// ===\n//\nimport {\n    arrayIndexOf, arrayForEach, overwriteLengthPropertyIfSupported\n} from '@tko/utils'\n\nimport { observable, isObservable } from './observable'\n\nimport { trackArrayChanges } from './observableArray.changeTracking'\n\nexport function observableArray (initialValues) {\n  initialValues = initialValues || []\n\n  if (typeof initialValues !== 'object' || !('length' in initialValues)) { throw new Error('The argument passed when initializing an observable array must be an array, or null, or undefined.') }\n\n  var result = observable(initialValues)\n  Object.setPrototypeOf(result, observableArray.fn)\n  trackArrayChanges(result)\n        // ^== result.extend({ trackArrayChanges: true })\n  overwriteLengthPropertyIfSupported(result, { get: () => result().length })\n  return result\n}\n\nexport function isObservableArray (instance) {\n  return isObservable(instance) && typeof instance.remove === 'function' && typeof instance.push === 'function'\n}\n\nobservableArray.fn = {\n  remove (valueOrPredicate) {\n    var underlyingArray = this.peek()\n    var removedValues = []\n    var predicate = typeof valueOrPredicate === 'function' && !isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate }\n    for (var i = 0; i < underlyingArray.length; i++) {\n      var value = underlyingArray[i]\n      if (predicate(value)) {\n        if (removedValues.length === 0) {\n          this.valueWillMutate()\n        }\n        if (underlyingArray[i] !== value) {\n          throw Error(\"Array modified during remove; cannot remove item\")\n        }\n        removedValues.push(value)\n        underlyingArray.splice(i, 1)\n        i--\n      }\n    }\n    if (removedValues.length) {\n      this.valueHasMutated()\n    }\n    return removedValues\n  },\n\n  removeAll (arrayOfValues) {\n        // If you passed zero args, we remove everything\n    if (arrayOfValues === undefined) {\n      var underlyingArray = this.peek()\n      var allValues = underlyingArray.slice(0)\n      this.valueWillMutate()\n      underlyingArray.splice(0, underlyingArray.length)\n      this.valueHasMutated()\n      return allValues\n    }\n        // If you passed an arg, we interpret it as an array of entries to remove\n    if (!arrayOfValues) {\n      return []\n    }\n    return this['remove'](function (value) {\n      return arrayIndexOf(arrayOfValues, value) >= 0\n    })\n  },\n\n  destroy (valueOrPredicate) {\n    var underlyingArray = this.peek()\n    var predicate = typeof valueOrPredicate === 'function' && !isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate }\n    this.valueWillMutate()\n    for (var i = underlyingArray.length - 1; i >= 0; i--) {\n      var value = underlyingArray[i]\n      if (predicate(value)) {\n        value['_destroy'] = true\n      }\n    }\n    this.valueHasMutated()\n  },\n\n  destroyAll (arrayOfValues) {\n        // If you passed zero args, we destroy everything\n    if (arrayOfValues === undefined) { return this.destroy(function () { return true }) }\n\n        // If you passed an arg, we interpret it as an array of entries to destroy\n    if (!arrayOfValues) {\n      return []\n    }\n    return this.destroy(function (value) {\n      return arrayIndexOf(arrayOfValues, value) >= 0\n    })\n  },\n\n  indexOf (item) {\n    return arrayIndexOf(this(), item)\n  },\n\n  replace (oldItem, newItem) {\n    var index = this.indexOf(oldItem)\n    if (index >= 0) {\n      this.valueWillMutate()\n      this.peek()[index] = newItem\n      this.valueHasMutated()\n    }\n  },\n\n  sorted (compareFn) {\n    return [...this()].sort(compareFn)\n  },\n\n  reversed () {\n    return [...this()].reverse()\n  },\n\n  [Symbol.iterator]: function * () {\n    yield * this()\n  }\n}\n\nObject.setPrototypeOf(observableArray.fn, observable.fn)\n\n// Populate ko.observableArray.fn with read/write functions from native arrays\n// Important: Do not add any additional functions here that may reasonably be used to *read* data from the array\n// because we'll eval them without causing subscriptions, so ko.computed output could end up getting stale\narrayForEach(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function (methodName) {\n  observableArray.fn[methodName] = function () {\n        // Use \"peek\" to avoid creating a subscription in any computed that we're executing in the context of\n        // (for consistency with mutating regular observables)\n    var underlyingArray = this.peek()\n    this.valueWillMutate()\n    this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments)\n    var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments)\n    this.valueHasMutated()\n        // The native sort and reverse methods return a reference to the array, but it makes more sense to return the observable array instead.\n    return methodCallResult === underlyingArray ? this : methodCallResult\n  }\n})\n\n// Populate ko.observableArray.fn with read-only functions from native arrays\narrayForEach(['slice'], function (methodName) {\n  observableArray.fn[methodName] = function () {\n    var underlyingArray = this()\n    return underlyingArray[methodName].apply(underlyingArray, arguments)\n  }\n})\n\n// Expose for testing.\nobservableArray.trackArrayChanges = trackArrayChanges\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/subscribable.js

@@ -0,0 +1,137 @@
+// @tko/observable 🥊 4.0.0-beta1.3 ESM
+import {
+  arrayRemoveItem,
+  objectForEach,
+  options
+} from "@tko/utils";
+import Subscription from "./Subscription";
+import { SUBSCRIBABLE_SYM } from "./subscribableSymbol";
+import { applyExtenders } from "./extenders";
+import * as dependencyDetection from "./dependencyDetection";
+export { isSubscribable } from "./subscribableSymbol";
+export const LATEST_VALUE = Symbol("Knockout latest value");
+if (!Symbol.observable) {
+  Symbol.observable = Symbol.for("@tko/Symbol.observable");
+}
+export function subscribable() {
+  Object.setPrototypeOf(this, ko_subscribable_fn);
+  ko_subscribable_fn.init(this);
+}
+export var defaultEvent = "change";
+var ko_subscribable_fn = {
+  [SUBSCRIBABLE_SYM]: true,
+  [Symbol.observable]() {
+    return this;
+  },
+  init(instance) {
+    instance._subscriptions = { change: [] };
+    instance._versionNumber = 1;
+  },
+  subscribe(callback, callbackTarget, event) {
+    const isTC39Callback = typeof callback === "object" && callback.next;
+    event = event || defaultEvent;
+    const observer = isTC39Callback ? callback : {
+      next: callbackTarget ? callback.bind(callbackTarget) : callback
+    };
+    const subscriptionInstance = new Subscription(this, observer, () => {
+      arrayRemoveItem(this._subscriptions[event], subscriptionInstance);
+      if (this.afterSubscriptionRemove) {
+        this.afterSubscriptionRemove(event);
+      }
+    });
+    if (this.beforeSubscriptionAdd) {
+      this.beforeSubscriptionAdd(event);
+    }
+    if (!this._subscriptions[event]) {
+      this._subscriptions[event] = [];
+    }
+    this._subscriptions[event].push(subscriptionInstance);
+    if (isTC39Callback && LATEST_VALUE in this) {
+      observer.next(this[LATEST_VALUE]);
+    }
+    return subscriptionInstance;
+  },
+  notifySubscribers(valueToNotify, event) {
+    event = event || defaultEvent;
+    if (event === defaultEvent) {
+      this.updateVersion();
+    }
+    if (this.hasSubscriptionsForEvent(event)) {
+      const subs = event === defaultEvent && this._changeSubscriptions || [...this._subscriptions[event]];
+      try {
+        dependencyDetection.begin();
+        for (let i = 0, subscriptionInstance; subscriptionInstance = subs[i]; ++i) {
+          if (!subscriptionInstance._isDisposed) {
+            subscriptionInstance._callback(valueToNotify);
+          }
+        }
+      } finally {
+        dependencyDetection.end();
+      }
+    }
+  },
+  getVersion() {
+    return this._versionNumber;
+  },
+  hasChanged(versionToCheck) {
+    return this.getVersion() !== versionToCheck;
+  },
+  updateVersion() {
+    ++this._versionNumber;
+  },
+  hasSubscriptionsForEvent(event) {
+    return this._subscriptions[event] && this._subscriptions[event].length;
+  },
+  getSubscriptionsCount(event) {
+    if (event) {
+      return this._subscriptions[event] && this._subscriptions[event].length || 0;
+    } else {
+      var total = 0;
+      objectForEach(this._subscriptions, function(eventName, subscriptions) {
+        if (eventName !== "dirty") {
+          total += subscriptions.length;
+        }
+      });
+      return total;
+    }
+  },
+  isDifferent(oldValue, newValue) {
+    return !this.equalityComparer || !this.equalityComparer(oldValue, newValue);
+  },
+  once(cb) {
+    const subs = this.subscribe((nv) => {
+      subs.dispose();
+      cb(nv);
+    });
+  },
+  when(test, returnValue) {
+    const current = this.peek();
+    const givenRv = arguments.length > 1;
+    const testFn = typeof test === "function" ? test : (v) => v === test;
+    if (testFn(current)) {
+      return options.Promise.resolve(givenRv ? returnValue : current);
+    }
+    return new options.Promise((resolve, reject) => {
+      const subs = this.subscribe((newValue) => {
+        if (testFn(newValue)) {
+          subs.dispose();
+          resolve(givenRv ? returnValue : newValue);
+        }
+      });
+    });
+  },
+  yet(test, ...args) {
+    const testFn = typeof test === "function" ? test : (v) => v === test;
+    const negated = (v) => !testFn(v);
+    return this.when(negated, ...args);
+  },
+  next() {
+    return new Promise((resolve) => this.once(resolve));
+  },
+  toString() {
+    return "[object Object]";
+  },
+  extend: applyExtenders
+};
+Object.setPrototypeOf(ko_subscribable_fn, Function.prototype);
+subscribable.fn = ko_subscribable_fn;

package/dist/subscribable.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/subscribable.ts"],
+  "sourcesContent": ["/* eslint no-cond-assign: 0 */\nimport {\n    arrayRemoveItem, objectForEach, options\n} from '@tko/utils'\n\nimport Subscription from './Subscription'\nimport { SUBSCRIBABLE_SYM } from './subscribableSymbol'\nimport { applyExtenders } from './extenders'\nimport * as dependencyDetection from './dependencyDetection'\nexport { isSubscribable } from './subscribableSymbol'\n\n// Descendants may have a LATEST_VALUE, which if present\n// causes TC39 subscriptions to emit the latest value when\n// subscribed.\nexport const LATEST_VALUE = Symbol('Knockout latest value')\n\n\nif (!Symbol.observable) {\n  Symbol.observable = Symbol.for('@tko/Symbol.observable')\n}\n\nexport function subscribable () {\n  Object.setPrototypeOf(this, ko_subscribable_fn)\n  ko_subscribable_fn.init(this)\n}\n\nexport var defaultEvent = 'change'\n\nvar ko_subscribable_fn = {\n  [SUBSCRIBABLE_SYM]: true,\n  [Symbol.observable] () { return this },\n\n  init (instance) {\n    instance._subscriptions = { change: [] }\n    instance._versionNumber = 1\n  },\n\n  subscribe (callback, callbackTarget, event) {\n    // TC39 proposed standard Observable { next: () => ... }\n    const isTC39Callback = typeof callback === 'object' && callback.next\n\n    event = event || defaultEvent\n    const observer = isTC39Callback ? callback : {\n      next: callbackTarget ? callback.bind(callbackTarget) : callback\n    }\n\n    const subscriptionInstance = new Subscription(this, observer, () => {\n      arrayRemoveItem(this._subscriptions[event], subscriptionInstance)\n      if (this.afterSubscriptionRemove) {\n        this.afterSubscriptionRemove(event)\n      }\n    })\n\n    if (this.beforeSubscriptionAdd) {\n      this.beforeSubscriptionAdd(event)\n    }\n\n    if (!this._subscriptions[event]) {\n      this._subscriptions[event] = []\n    }\n    this._subscriptions[event].push(subscriptionInstance)\n\n    // Have TC39 `subscribe` immediately emit.\n    // https://github.com/tc39/proposal-observable/issues/190\n\n    if (isTC39Callback && LATEST_VALUE in this) {\n      observer.next(this[LATEST_VALUE])\n    }\n\n    return subscriptionInstance\n  },\n\n  notifySubscribers (valueToNotify, event) {\n    event = event || defaultEvent\n    if (event === defaultEvent) {\n      this.updateVersion()\n    }\n    if (this.hasSubscriptionsForEvent(event)) {\n      const subs = event === defaultEvent && this._changeSubscriptions\n        || [...this._subscriptions[event]]\n\n      try {\n        dependencyDetection.begin() // Begin suppressing dependency detection (by setting the top frame to undefined)\n        for (let i = 0, subscriptionInstance; subscriptionInstance = subs[i]; ++i) {\n                    // In case a subscription was disposed during the arrayForEach cycle, check\n                    // for isDisposed on each subscription before invoking its callback\n          if (!subscriptionInstance._isDisposed) {\n            subscriptionInstance._callback(valueToNotify)\n          }\n        }\n      } finally {\n        dependencyDetection.end() // End suppressing dependency detection\n      }\n    }\n  },\n\n  getVersion () {\n    return this._versionNumber\n  },\n\n  hasChanged (versionToCheck) {\n    return this.getVersion() !== versionToCheck\n  },\n\n  updateVersion () {\n    ++this._versionNumber\n  },\n\n  hasSubscriptionsForEvent (event) {\n    return this._subscriptions[event] && this._subscriptions[event].length\n  },\n\n  getSubscriptionsCount (event) {\n    if (event) {\n      return this._subscriptions[event] && this._subscriptions[event].length || 0\n    } else {\n      var total = 0\n      objectForEach(this._subscriptions, function (eventName, subscriptions) {\n        if (eventName !== 'dirty') {\n          total += subscriptions.length\n        }\n      })\n      return total\n    }\n  },\n\n  isDifferent (oldValue, newValue) {\n    return !this.equalityComparer ||\n               !this.equalityComparer(oldValue, newValue)\n  },\n\n  once (cb) {\n    const subs = this.subscribe((nv) => {\n      subs.dispose()\n      cb(nv)\n    })\n  },\n\n  when (test, returnValue) {\n    const current = this.peek()\n    const givenRv = arguments.length > 1\n    const testFn = typeof test === 'function' ? test : v => v === test\n    if (testFn(current)) {\n      return options.Promise.resolve(givenRv ? returnValue : current)\n    }\n    return new options.Promise((resolve, reject) => {\n      const subs = this.subscribe(newValue => {\n        if (testFn(newValue)) {\n          subs.dispose()\n          resolve(givenRv ? returnValue : newValue)\n        }\n      })\n    })\n  },\n\n  yet (test, ...args) {\n    const testFn = typeof test === 'function' ? test : v => v === test\n    const negated = v => !testFn(v)\n    return this.when(negated, ...args)\n  },\n\n  next () { return new Promise(resolve => this.once(resolve)) },\n\n  toString () { return '[object Object]' },\n\n  extend: applyExtenders\n}\n\n// For browsers that support proto assignment, we overwrite the prototype of each\n// observable instance. Since observables are functions, we need Function.prototype\n// to still be in the prototype chain.\nObject.setPrototypeOf(ko_subscribable_fn, Function.prototype)\n\nsubscribable.fn = ko_subscribable_fn\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/subscribableSymbol.js

@@ -0,0 +1,5 @@
+// @tko/observable 🥊 4.0.0-beta1.3 ESM
+export const SUBSCRIBABLE_SYM = Symbol("Knockout Subscribable");
+export function isSubscribable(instance) {
+  return instance && instance[SUBSCRIBABLE_SYM] || false;
+}

package/dist/subscribableSymbol.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/subscribableSymbol.ts"],
+  "sourcesContent": ["/**\n * Create a subscribable symbol that's used to identify subscribables.\n */\nexport const SUBSCRIBABLE_SYM = Symbol('Knockout Subscribable')\n\nexport function isSubscribable (instance) {\n  return (instance && instance[SUBSCRIBABLE_SYM]) || false\n}\n"],
+  "mappings": ";AAGO,aAAM,mBAAmB,OAAO,uBAAuB;AAEvD,+BAAyB,UAAU;AACxC,SAAQ,YAAY,SAAS,qBAAsB;AACrD;",
+  "names": []
+}

package/package.json

@@ -1,14 +1,21 @@
 {
+  "version": "4.0.0-beta1.3",
   "name": "@tko/observable",
-  "version": "4.0.0-alpha7.4",
   "description": "TKO subscribables and observables",
-  "module": "dist/observable.js",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/knockout/tko.observable.git"
+    "url": "git+https://github.com/knockout/tko.git"
+  },
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    },
+    "./helpers/*": "./helpers/*"
   },
   "files": [
-    "dist/"
+    "dist/",
+    "helpers/"
   ],
   "keywords": [
     "knockout",
@@ -17,42 +24,26 @@
     "object",
     "subscribable"
   ],
-  "author": "Knockout",
+  "author": "The Knockout Team",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/knockout/tko.observable/issues"
+    "url": "https://github.com/knockout/tko/issues"
   },
   "homepage": "https://tko.io",
   "dependencies": {
-    "@tko/utils": "^4.0.0-alpha7.4",
-    "tslib": "^1.8.0"
+    "@tko/utils": "^4.0.0-beta1.3",
+    "tslib": "^2.2.0"
   },
   "karma": {
     "frameworks": [
       "jasmine"
     ]
   },
-  "__about__shared.package.json": "These properties are copied into all packages/*/package.json.  Run `yarn repackage`",
-  "standard": {
-    "env": [
-      "browser",
-      "jasmine",
-      "mocha"
-    ]
-  },
-  "scripts": {
-    "test": "karma start ../../karma.conf.js --once",
-    "build": "rollup -c ../../rollup.config.js",
-    "watch": "karma start ../../karma.conf.js",
-    "prepare": "rollup -c ../../rollup.config.js"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
   "licenses": [
     {
       "type": "MIT",
-      "url": "http://www.opensource.org/licenses/mit-license.php"
+      "url": "https://opensource.org/licenses/MIT"
     }
-  ]
+  ],
+  "gitHead": "a8843acb8ae085915115e53a4e057b30731c635e"
 }