@tko/bind 4.0.0-alpha9.0 → 4.0.0-beta1.0

package/dist/arrayToDomNodeChildren.js

@@ -0,0 +1,171 @@
+// @tko/bind 🥊 4.0.0-beta1.0 ESM
+import {
+  fixUpContinuousNodeArray,
+  replaceDomNodes,
+  arrayPushAll,
+  anyDomNodeIsAttachedToDocument,
+  domData,
+  arrayMap,
+  arrayForEach,
+  virtualElements,
+  extend,
+  cleanNode,
+  removeNode,
+  compareArrays
+} from "@tko/utils";
+import {
+  dependencyDetection,
+  observable
+} from "@tko/observable";
+import { computed } from "@tko/computed";
+function mapNodeAndRefreshWhenChanged(containerNode, mapping, valueToMap, callbackAfterAddingNodes, index) {
+  var mappedNodes = [];
+  var dependentObservable = computed(function() {
+    var newMappedNodes = mapping(valueToMap, index, fixUpContinuousNodeArray(mappedNodes, containerNode)) || [];
+    if (mappedNodes.length > 0) {
+      replaceDomNodes(mappedNodes, newMappedNodes);
+      if (callbackAfterAddingNodes) {
+        dependencyDetection.ignore(callbackAfterAddingNodes, null, [valueToMap, newMappedNodes, index]);
+      }
+    }
+    mappedNodes.length = 0;
+    arrayPushAll(mappedNodes, newMappedNodes);
+  }, null, { disposeWhenNodeIsRemoved: containerNode, disposeWhen: function() {
+    return !anyDomNodeIsAttachedToDocument(mappedNodes);
+  } });
+  return { mappedNodes, dependentObservable: dependentObservable.isActive() ? dependentObservable : void 0 };
+}
+var lastMappingResultDomDataKey = domData.nextKey();
+let deletedItemDummyValue = domData.nextKey();
+export function setDomNodeChildrenFromArrayMapping(domNode, array, mapping, options, callbackAfterAddingNodes, editScript) {
+  array = array || [];
+  if (typeof array.length === "undefined") {
+    array = [array];
+  }
+  options = options || {};
+  let lastMappingResult = domData.get(domNode, lastMappingResultDomDataKey);
+  let isFirstExecution = !lastMappingResult;
+  var newMappingResult = [];
+  var lastMappingResultIndex = 0;
+  var newMappingResultIndex = 0;
+  var nodesToDelete = [];
+  var itemsToProcess = [];
+  var itemsForBeforeRemoveCallbacks = [];
+  var itemsForMoveCallbacks = [];
+  var itemsForAfterAddCallbacks = [];
+  var mapData;
+  let countWaitingForRemove = 0;
+  function itemAdded(value) {
+    mapData = { arrayEntry: value, indexObservable: observable(newMappingResultIndex++) };
+    newMappingResult.push(mapData);
+    itemsToProcess.push(mapData);
+    if (!isFirstExecution) {
+      itemsForAfterAddCallbacks.push(mapData);
+    }
+  }
+  function itemMovedOrRetained(oldPosition) {
+    mapData = lastMappingResult[oldPosition];
+    if (newMappingResultIndex !== oldPosition) {
+      itemsForMoveCallbacks.push(mapData);
+    }
+    mapData.indexObservable(newMappingResultIndex++);
+    fixUpContinuousNodeArray(mapData.mappedNodes, domNode);
+    newMappingResult.push(mapData);
+    itemsToProcess.push(mapData);
+  }
+  function callCallback(callback, items) {
+    if (callback) {
+      for (var i2 = 0, n = items.length; i2 < n; i2++) {
+        arrayForEach(items[i2].mappedNodes, function(node2) {
+          callback(node2, i2, items[i2].arrayEntry);
+        });
+      }
+    }
+  }
+  if (isFirstExecution) {
+    arrayForEach(array, itemAdded);
+  } else {
+    if (!editScript || lastMappingResult && lastMappingResult["_countWaitingForRemove"]) {
+      var lastArray = isFirstExecution ? [] : arrayMap(lastMappingResult, function(x) {
+        return x.arrayEntry;
+      });
+      var compareOptions = {
+        "dontLimitMoves": options["dontLimitMoves"],
+        "sparse": true
+      };
+      editScript = compareArrays(lastArray, array, compareOptions);
+    }
+    for (var i = 0, editScriptItem, movedIndex, itemIndex; editScriptItem = editScript[i]; i++) {
+      movedIndex = editScriptItem["moved"];
+      itemIndex = editScriptItem["index"];
+      switch (editScriptItem["status"]) {
+        case "deleted":
+          while (lastMappingResultIndex < itemIndex) {
+            itemMovedOrRetained(lastMappingResultIndex++);
+          }
+          if (movedIndex === void 0) {
+            mapData = lastMappingResult[lastMappingResultIndex];
+            if (mapData.dependentObservable) {
+              mapData.dependentObservable.dispose();
+              mapData.dependentObservable = void 0;
+            }
+            if (fixUpContinuousNodeArray(mapData.mappedNodes, domNode).length) {
+              if (options["beforeRemove"]) {
+                newMappingResult.push(mapData);
+                itemsToProcess.push(mapData);
+                countWaitingForRemove++;
+                if (mapData.arrayEntry === deletedItemDummyValue) {
+                  mapData = null;
+                } else {
+                  itemsForBeforeRemoveCallbacks.push(mapData);
+                }
+              }
+              if (mapData) {
+                nodesToDelete.push.apply(nodesToDelete, mapData.mappedNodes);
+              }
+            }
+          }
+          lastMappingResultIndex++;
+          break;
+        case "added":
+          while (newMappingResultIndex < itemIndex) {
+            itemMovedOrRetained(lastMappingResultIndex++);
+          }
+          if (movedIndex !== void 0) {
+            itemMovedOrRetained(movedIndex);
+          } else {
+            itemAdded(editScriptItem["value"]);
+          }
+          break;
+      }
+    }
+    while (newMappingResultIndex < array.length) {
+      itemMovedOrRetained(lastMappingResultIndex++);
+    }
+    newMappingResult["_countWaitingForRemove"] = countWaitingForRemove;
+  }
+  domData.set(domNode, lastMappingResultDomDataKey, newMappingResult);
+  callCallback(options["beforeMove"], itemsForMoveCallbacks);
+  arrayForEach(nodesToDelete, options["beforeRemove"] ? cleanNode : removeNode);
+  i = 0;
+  for (var nextNode = virtualElements.firstChild(domNode), lastNode, node; mapData = itemsToProcess[i]; i++) {
+    if (!mapData.mappedNodes) {
+      extend(mapData, mapNodeAndRefreshWhenChanged(domNode, mapping, mapData.arrayEntry, callbackAfterAddingNodes, mapData.indexObservable));
+    }
+    for (var j = 0; node = mapData.mappedNodes[j]; nextNode = node.nextSibling, lastNode = node, j++) {
+      if (node !== nextNode) {
+        virtualElements.insertAfter(domNode, node, lastNode);
+      }
+    }
+    if (!mapData.initialized && callbackAfterAddingNodes) {
+      callbackAfterAddingNodes(mapData.arrayEntry, mapData.mappedNodes, mapData.indexObservable);
+      mapData.initialized = true;
+    }
+  }
+  callCallback(options["beforeRemove"], itemsForBeforeRemoveCallbacks);
+  for (i = 0; i < itemsForBeforeRemoveCallbacks.length; ++i) {
+    itemsForBeforeRemoveCallbacks[i].arrayEntry = deletedItemDummyValue;
+  }
+  callCallback(options["afterMove"], itemsForMoveCallbacks);
+  callCallback(options["afterAdd"], itemsForAfterAddCallbacks);
+}

package/dist/arrayToDomNodeChildren.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/arrayToDomNodeChildren.ts"],
+  "sourcesContent": ["/* eslint no-cond-assign: 0 */\nimport {\n  fixUpContinuousNodeArray, replaceDomNodes, arrayPushAll,\n  anyDomNodeIsAttachedToDocument, domData, arrayMap, arrayForEach,\n  virtualElements, extend, cleanNode, removeNode, compareArrays\n} from '@tko/utils'\n\nimport {\n  dependencyDetection, observable\n} from '@tko/observable'\n\nimport { computed } from '@tko/computed'\n\n// Objective:\n// * Given an input array, a container DOM node, and a function from array elements to arrays of DOM nodes,\n//   map the array elements to arrays of DOM nodes, concatenate together all these arrays, and use them to populate the container DOM node\n// * Next time we're given the same combination of things (with the array possibly having mutated), update the container DOM node\n//   so that its children is again the concatenation of the mappings of the array elements, but don't re-map any array elements that we\n//   previously mapped - retain those nodes, and just insert/delete other ones\n\n// \"callbackAfterAddingNodes\" will be invoked after any \"mapping\"-generated nodes are inserted into the container node\n// You can use this, for example, to activate bindings on those nodes.\n\nfunction mapNodeAndRefreshWhenChanged (containerNode, mapping, valueToMap, callbackAfterAddingNodes, index) {\n  // Map this array value inside a dependentObservable so we re-map when any dependency changes\n  var mappedNodes = []\n  var dependentObservable = computed(function () {\n    var newMappedNodes = mapping(valueToMap, index, fixUpContinuousNodeArray(mappedNodes, containerNode)) || []\n\n    // On subsequent evaluations, just replace the previously-inserted DOM nodes\n    if (mappedNodes.length > 0) {\n      replaceDomNodes(mappedNodes, newMappedNodes)\n      if (callbackAfterAddingNodes) { dependencyDetection.ignore(callbackAfterAddingNodes, null, [valueToMap, newMappedNodes, index]) }\n    }\n\n    // Replace the contents of the mappedNodes array, thereby updating the record\n    // of which nodes would be deleted if valueToMap was itself later removed\n    mappedNodes.length = 0\n    arrayPushAll(mappedNodes, newMappedNodes)\n  }, null, { disposeWhenNodeIsRemoved: containerNode, disposeWhen: function () { return !anyDomNodeIsAttachedToDocument(mappedNodes) } })\n  return { mappedNodes: mappedNodes, dependentObservable: (dependentObservable.isActive() ? dependentObservable : undefined) }\n}\n\nvar lastMappingResultDomDataKey = domData.nextKey()\nlet deletedItemDummyValue = domData.nextKey()\n\nexport function setDomNodeChildrenFromArrayMapping (domNode, array, mapping, options, callbackAfterAddingNodes, editScript) {\n  // Compare the provided array against the previous one\n  array = array || []\n  if (typeof array.length === 'undefined') {\n    array = [array]\n  }\n  options = options || {}\n  let lastMappingResult = domData.get(domNode, lastMappingResultDomDataKey)\n  let isFirstExecution = !lastMappingResult\n\n  // Build the new mapping result\n  var newMappingResult = []\n  var lastMappingResultIndex = 0\n  var newMappingResultIndex = 0\n\n  var nodesToDelete = []\n  var itemsToProcess = []\n  var itemsForBeforeRemoveCallbacks = []\n  var itemsForMoveCallbacks = []\n  var itemsForAfterAddCallbacks = []\n  var mapData\n  let countWaitingForRemove = 0\n\n  function itemAdded (value) {\n    mapData = { arrayEntry: value, indexObservable: observable(newMappingResultIndex++) }\n    newMappingResult.push(mapData)\n    itemsToProcess.push(mapData)\n    if (!isFirstExecution) {\n      itemsForAfterAddCallbacks.push(mapData)\n    }\n  }\n\n  function itemMovedOrRetained (oldPosition) {\n    mapData = lastMappingResult[oldPosition]\n    if (newMappingResultIndex !== oldPosition) {\n      itemsForMoveCallbacks.push(mapData)\n    }\n    // Since updating the index might change the nodes, do so before calling fixUpContinuousNodeArray\n    mapData.indexObservable(newMappingResultIndex++)\n    fixUpContinuousNodeArray(mapData.mappedNodes, domNode)\n    newMappingResult.push(mapData)\n    itemsToProcess.push(mapData)\n  }\n\n  function callCallback (callback, items) {\n    if (callback) {\n      for (var i = 0, n = items.length; i < n; i++) {\n        arrayForEach(items[i].mappedNodes, function (node) {\n          callback(node, i, items[i].arrayEntry)\n        })\n      }\n    }\n  }\n\n  if (isFirstExecution) {\n    arrayForEach(array, itemAdded)\n  } else {\n    if (!editScript || (lastMappingResult && lastMappingResult['_countWaitingForRemove'])) {\n      // Compare the provided array against the previous one\n      var lastArray = isFirstExecution ? [] : arrayMap(lastMappingResult, function (x) { return x.arrayEntry })\n      var compareOptions = {\n        'dontLimitMoves': options['dontLimitMoves'],\n        'sparse': true\n      }\n      editScript = compareArrays(lastArray, array, compareOptions)\n    }\n\n    for (var i = 0, editScriptItem, movedIndex, itemIndex; editScriptItem = editScript[i]; i++) {\n      movedIndex = editScriptItem['moved']\n      itemIndex = editScriptItem['index']\n      switch (editScriptItem['status']) {\n        case 'deleted':\n          while (lastMappingResultIndex < itemIndex) {\n            itemMovedOrRetained(lastMappingResultIndex++)\n          }\n          if (movedIndex === undefined) {\n            mapData = lastMappingResult[lastMappingResultIndex]\n\n            // Stop tracking changes to the mapping for these nodes\n            if (mapData.dependentObservable) {\n              mapData.dependentObservable.dispose()\n              mapData.dependentObservable = undefined\n            }\n\n            // Queue these nodes for later removal\n            if (fixUpContinuousNodeArray(mapData.mappedNodes, domNode).length) {\n              if (options['beforeRemove']) {\n                newMappingResult.push(mapData)\n                itemsToProcess.push(mapData)\n                countWaitingForRemove++\n                if (mapData.arrayEntry === deletedItemDummyValue) {\n                  mapData = null\n                } else {\n                  itemsForBeforeRemoveCallbacks.push(mapData)\n                }\n              }\n              if (mapData) {\n                nodesToDelete.push.apply(nodesToDelete, mapData.mappedNodes)\n              }\n            }\n          }\n          lastMappingResultIndex++\n          break\n\n        case 'added':\n          while (newMappingResultIndex < itemIndex) {\n            itemMovedOrRetained(lastMappingResultIndex++)\n          }\n          if (movedIndex !== undefined) {\n            itemMovedOrRetained(movedIndex)\n          } else {\n            itemAdded(editScriptItem['value'])\n          }\n          break\n      }\n    }\n\n    while (newMappingResultIndex < array.length) {\n      itemMovedOrRetained(lastMappingResultIndex++)\n    }\n\n    // Record that the current view may still contain deleted items\n    // because it means we won't be able to use a provided editScript.\n    newMappingResult['_countWaitingForRemove'] = countWaitingForRemove\n  }\n\n  // Store a copy of the array items we just considered so we can difference it next time\n  domData.set(domNode, lastMappingResultDomDataKey, newMappingResult)\n\n  // Call beforeMove first before any changes have been made to the DOM\n  callCallback(options['beforeMove'], itemsForMoveCallbacks)\n\n  // Next remove nodes for deleted items (or just clean if there's a beforeRemove callback)\n  arrayForEach(nodesToDelete, options['beforeRemove'] ? cleanNode : removeNode)\n\n  // Next add/reorder the remaining items (will include deleted items if there's a beforeRemove callback)\n  i = 0\n  for (var nextNode = virtualElements.firstChild(domNode), lastNode, node; mapData = itemsToProcess[i]; i++) {\n    // Get nodes for newly added items\n    if (!mapData.mappedNodes) { extend(mapData, mapNodeAndRefreshWhenChanged(domNode, mapping, mapData.arrayEntry, callbackAfterAddingNodes, mapData.indexObservable)) }\n\n    // Put nodes in the right place if they aren't there already\n    for (var j = 0; node = mapData.mappedNodes[j]; nextNode = node.nextSibling, lastNode = node, j++) {\n      if (node !== nextNode) { virtualElements.insertAfter(domNode, node, lastNode) }\n    }\n\n    // Run the callbacks for newly added nodes (for example, to apply bindings, etc.)\n    if (!mapData.initialized && callbackAfterAddingNodes) {\n      callbackAfterAddingNodes(mapData.arrayEntry, mapData.mappedNodes, mapData.indexObservable)\n      mapData.initialized = true\n    }\n  }\n\n  // If there's a beforeRemove callback, call it after reordering.\n  // Note that we assume that the beforeRemove callback will usually be used to remove the nodes using\n  // some sort of animation, which is why we first reorder the nodes that will be removed. If the\n  // callback instead removes the nodes right away, it would be more efficient to skip reordering them.\n  // Perhaps we'll make that change in the future if this scenario becomes more common.\n  callCallback(options['beforeRemove'], itemsForBeforeRemoveCallbacks)\n\n  // Replace the stored values of deleted items with a dummy value. This provides two benefits: it marks this item\n  // as already \"removed\" so we won't call beforeRemove for it again, and it ensures that the item won't match up\n  // with an actual item in the array and appear as \"retained\" or \"moved\".\n  for (i = 0; i < itemsForBeforeRemoveCallbacks.length; ++i) {\n    itemsForBeforeRemoveCallbacks[i].arrayEntry = deletedItemDummyValue\n  }\n\n  // Finally call afterMove and afterAdd callbacks\n  callCallback(options['afterMove'], itemsForMoveCallbacks)\n  callCallback(options['afterAdd'], itemsForAfterAddCallbacks)\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/bindingContext.js

@@ -0,0 +1,122 @@
+// @tko/bind 🥊 4.0.0-beta1.0 ESM
+import { extend, options, domData, isObjectLike } from "@tko/utils";
+import {
+  pureComputed
+} from "@tko/computed";
+import {
+  unwrap,
+  isObservable
+} from "@tko/observable";
+import {
+  contextAncestorBindingInfo
+} from "./bindingEvent";
+export const boundElementDomDataKey = domData.nextKey();
+export const contextSubscribeSymbol = Symbol("Knockout Context Subscription");
+const inheritParentIndicator = Symbol("Knockout Parent Indicator");
+export function bindingContext(dataItemOrAccessor, parentContext, dataItemAlias, extendCallback, settings) {
+  const self = this;
+  const shouldInheritData = dataItemOrAccessor === inheritParentIndicator;
+  const realDataItemOrAccessor = shouldInheritData ? void 0 : dataItemOrAccessor;
+  const isFunc = typeof realDataItemOrAccessor === "function" && !isObservable(realDataItemOrAccessor);
+  self.ko = options.knockoutInstance;
+  let nodes;
+  let subscribable;
+  function updateContext() {
+    const dataItemOrObservable = isFunc ? realDataItemOrAccessor() : realDataItemOrAccessor;
+    let dataItem = unwrap(dataItemOrObservable);
+    if (parentContext) {
+      if (parentContext[contextSubscribeSymbol]) {
+        parentContext[contextSubscribeSymbol]();
+      }
+      extend(self, parentContext);
+      if (contextAncestorBindingInfo in parentContext) {
+        self[contextAncestorBindingInfo] = parentContext[contextAncestorBindingInfo];
+      }
+    } else {
+      self.$parents = [];
+      self.$root = dataItem;
+    }
+    self[contextSubscribeSymbol] = subscribable;
+    if (shouldInheritData) {
+      dataItem = self.$data;
+    } else {
+      self.$rawData = dataItemOrObservable;
+      self.$data = dataItem;
+    }
+    if (dataItemAlias) {
+      self[dataItemAlias] = dataItem;
+    }
+    if (extendCallback) {
+      extendCallback(self, parentContext, dataItem);
+    }
+    return self.$data;
+  }
+  if (settings && settings.exportDependencies) {
+    updateContext();
+  } else {
+    subscribable = pureComputed(updateContext);
+    subscribable.peek();
+    if (subscribable.isActive()) {
+      self[contextSubscribeSymbol] = subscribable;
+      subscribable["equalityComparer"] = null;
+    } else {
+      self[contextSubscribeSymbol] = void 0;
+    }
+  }
+}
+Object.assign(bindingContext.prototype, {
+  lookup(token, globals, node) {
+    switch (token) {
+      case "$element":
+        return node;
+      case "$context":
+        return this;
+      case "this":
+      case "$data":
+        return this.$data;
+    }
+    const $data = this.$data;
+    if (isObjectLike($data) && token in $data) {
+      return $data[token];
+    }
+    if (token in this) {
+      return this[token];
+    }
+    if (token in globals) {
+      return globals[token];
+    }
+    throw new Error(`The variable "${token}" was not found on $data, $context, or globals.`);
+  },
+  createChildContext(dataItemOrAccessor, dataItemAlias, extendCallback, settings) {
+    return new bindingContext(dataItemOrAccessor, this, dataItemAlias, function(self, parentContext) {
+      self.$parentContext = parentContext;
+      self.$parent = parentContext.$data;
+      self.$parents = (parentContext.$parents || []).slice(0);
+      self.$parents.unshift(self.$parent);
+      if (extendCallback) {
+        extendCallback(self);
+      }
+    }, settings);
+  },
+  extend(properties) {
+    return new bindingContext(inheritParentIndicator, this, null, function(self, parentContext) {
+      extend(self, typeof properties === "function" ? properties.call(self) : properties);
+    });
+  },
+  createStaticChildContext(dataItemOrAccessor, dataItemAlias) {
+    return this.createChildContext(dataItemOrAccessor, dataItemAlias, null, { "exportDependencies": true });
+  }
+});
+export function storedBindingContextForNode(node) {
+  const bindingInfo = domData.get(node, boundElementDomDataKey);
+  return bindingInfo && bindingInfo.context;
+}
+export function contextFor(node) {
+  if (node && (node.nodeType === 1 || node.nodeType === 8)) {
+    return storedBindingContextForNode(node);
+  }
+}
+export function dataFor(node) {
+  var context = contextFor(node);
+  return context ? context.$data : void 0;
+}

package/dist/bindingContext.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/bindingContext.ts"],
+  "sourcesContent": ["import { extend, options, domData, isObjectLike } from '@tko/utils'\n\nimport {\n    pureComputed\n} from '@tko/computed'\n\nimport {\n    unwrap, isObservable\n} from '@tko/observable'\n\nimport {\n  contextAncestorBindingInfo\n} from './bindingEvent'\n\nexport const boundElementDomDataKey = domData.nextKey()\n\nexport const contextSubscribeSymbol = Symbol('Knockout Context Subscription')\n\n// Unique stub to indicate inheritance.\nconst inheritParentIndicator = Symbol('Knockout Parent Indicator')\n\n// The bindingContext constructor is only called directly to create the root context. For child\n// contexts, use bindingContext.createChildContext or bindingContext.extend.\nexport function bindingContext (dataItemOrAccessor, parentContext, dataItemAlias, extendCallback, settings) {\n  const self = this\n  const shouldInheritData = dataItemOrAccessor === inheritParentIndicator\n  const realDataItemOrAccessor = shouldInheritData ? undefined : dataItemOrAccessor\n  const isFunc = typeof realDataItemOrAccessor === 'function' && !isObservable(realDataItemOrAccessor)\n\n  // Export 'ko' in the binding context so it will be available in bindings and templates\n  // even if 'ko' isn't exported as a global, such as when using an AMD loader.\n  // See https://github.com/SteveSanderson/knockout/issues/490\n  self.ko = options.knockoutInstance\n\n  let nodes\n  let subscribable\n\n    // The binding context object includes static properties for the current, parent, and root view models.\n    // If a view model is actually stored in an observable, the corresponding binding context object, and\n    // any child contexts, must be updated when the view model is changed.\n  function updateContext () {\n        // Most of the time, the context will directly get a view model object, but if a function is given,\n        // we call the function to retrieve the view model. If the function accesses any observables or returns\n        // an observable, the dependency is tracked, and those observables can later cause the binding\n        // context to be updated.\n    const dataItemOrObservable = isFunc ? realDataItemOrAccessor() : realDataItemOrAccessor\n    let dataItem = unwrap(dataItemOrObservable)\n\n    if (parentContext) {\n            // When a \"parent\" context is given, register a dependency on the parent context. Thus whenever the\n            // parent context is updated, this context will also be updated.\n      if (parentContext[contextSubscribeSymbol]) {\n        parentContext[contextSubscribeSymbol]()\n      }\n\n            // Copy $root and any custom properties from the parent context\n      extend(self, parentContext)\n\n       // Copy Symbol properties\n      if (contextAncestorBindingInfo in parentContext) {\n        self[contextAncestorBindingInfo] = parentContext[contextAncestorBindingInfo]\n      }\n    } else {\n      self.$parents = []\n      self.$root = dataItem\n    }\n\n    self[contextSubscribeSymbol] = subscribable\n\n    if (shouldInheritData) {\n      dataItem = self.$data\n    } else {\n      self.$rawData = dataItemOrObservable\n      self.$data = dataItem\n    }\n\n    if (dataItemAlias) { self[dataItemAlias] = dataItem }\n\n        // The extendCallback function is provided when creating a child context or extending a context.\n        // It handles the specific actions needed to finish setting up the binding context. Actions in this\n        // function could also add dependencies to this binding context.\n    if (extendCallback) { extendCallback(self, parentContext, dataItem) }\n\n    return self.$data\n  }\n\n  if (settings && settings.exportDependencies) {\n        // The \"exportDependencies\" option means that the calling code will track any dependencies and re-create\n        // the binding context when they change.\n    updateContext()\n  } else {\n    subscribable = pureComputed(updateContext)\n    subscribable.peek()\n\n    // At this point, the binding context has been initialized, and the \"subscribable\" computed observable is\n    // subscribed to any observables that were accessed in the process. If there is nothing to track, the\n    // computed will be inactive, and we can safely throw it away. If it's active, the computed is stored in\n    // the context object.\n    if (subscribable.isActive()) {\n      self[contextSubscribeSymbol] = subscribable\n\n      // Always notify because even if the model ($data) hasn't changed, other context properties might have changed\n      subscribable['equalityComparer'] = null\n    } else {\n      self[contextSubscribeSymbol] = undefined\n    }\n  }\n}\n\nObject.assign(bindingContext.prototype, {\n\n  lookup (token, globals, node) {\n    // short circuits\n    switch (token) {\n      case '$element': return node\n      case '$context': return this\n      case 'this': case '$data': return this.$data\n    }\n    const $data = this.$data\n    // instanceof Object covers 1. {}, 2. [], 3. function() {}, 4. new *;  it excludes undefined, null, primitives.\n    if (isObjectLike($data) && token in $data) { return $data[token] }\n    if (token in this) { return this[token] }\n    if (token in globals) { return globals[token] }\n\n    throw new Error(`The variable \"${token}\" was not found on $data, $context, or globals.`)\n  },\n\n  // Extend the binding context hierarchy with a new view model object. If the parent context is watching\n  // any observables, the new child context will automatically get a dependency on the parent context.\n  // But this does not mean that the $data value of the child context will also get updated. If the child\n  // view model also depends on the parent view model, you must provide a function that returns the correct\n  // view model on each update.\n  createChildContext (dataItemOrAccessor, dataItemAlias, extendCallback, settings) {\n    return new bindingContext(dataItemOrAccessor, this, dataItemAlias, function (self, parentContext) {\n          // Extend the context hierarchy by setting the appropriate pointers\n      self.$parentContext = parentContext\n      self.$parent = parentContext.$data\n      self.$parents = (parentContext.$parents || []).slice(0)\n      self.$parents.unshift(self.$parent)\n      if (extendCallback) { extendCallback(self) }\n    }, settings)\n  },\n\n  // Extend the binding context with new custom properties. This doesn't change the context hierarchy.\n  // Similarly to \"child\" contexts, provide a function here to make sure that the correct values are set\n  // when an observable view model is updated.\n  extend (properties) {\n    // If the parent context references an observable view model, \"_subscribable\" will always be the\n    // latest view model object. If not, \"_subscribable\" isn't set, and we can use the static \"$data\" value.\n    return new bindingContext(inheritParentIndicator, this, null, function (self, parentContext) {\n      extend(self, typeof properties === 'function' ? properties.call(self) : properties)\n    })\n  },\n\n  createStaticChildContext (dataItemOrAccessor, dataItemAlias) {\n    return this.createChildContext(dataItemOrAccessor, dataItemAlias, null, { 'exportDependencies': true })\n  }\n})\n\nexport function storedBindingContextForNode (node) {\n  const bindingInfo = domData.get(node, boundElementDomDataKey)\n  return bindingInfo && bindingInfo.context\n}\n\n// Retrieving binding context from arbitrary nodes\nexport function contextFor (node) {\n  // We can only do something meaningful for elements and comment nodes (in particular, not text nodes, as IE can't store domdata for them)\n  if (node && (node.nodeType === 1 || node.nodeType === 8)) {\n    return storedBindingContextForNode(node)\n  }\n}\n\nexport function dataFor (node) {\n  var context = contextFor(node)\n  return context ? context.$data : undefined\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/bindingEvent.js

@@ -0,0 +1,24 @@
+// @tko/bind 🥊 4.0.0-beta1.0 ESM
+import { domData } from "@tko/utils";
+import { subscribable } from "@tko/observable";
+export const contextAncestorBindingInfo = Symbol("_ancestorBindingInfo");
+const boundElementDomDataKey = domData.nextKey();
+export const bindingEvent = {
+  childrenComplete: "childrenComplete",
+  descendantsComplete: "descendantsComplete",
+  subscribe(node, event, callback, context) {
+    const bindingInfo = domData.getOrSet(node, boundElementDomDataKey, {});
+    if (!bindingInfo.eventSubscribable) {
+      bindingInfo.eventSubscribable = new subscribable();
+    }
+    return bindingInfo.eventSubscribable.subscribe(callback, context, event);
+  },
+  notify(node, event) {
+    const bindingInfo = domData.get(node, boundElementDomDataKey);
+    if (bindingInfo) {
+      if (bindingInfo.eventSubscribable) {
+        bindingInfo.eventSubscribable.notifySubscribers(node, event);
+      }
+    }
+  }
+};

package/dist/bindingEvent.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/bindingEvent.ts"],
+  "sourcesContent": ["\nimport { domData } from '@tko/utils'\nimport { subscribable } from '@tko/observable'\n\nexport const contextAncestorBindingInfo = Symbol('_ancestorBindingInfo')\nconst boundElementDomDataKey = domData.nextKey()\n\nexport const bindingEvent = {\n  childrenComplete: 'childrenComplete',\n  descendantsComplete: 'descendantsComplete',\n\n  subscribe (node, event, callback, context) {\n    const bindingInfo = domData.getOrSet(node, boundElementDomDataKey, {})\n    if (!bindingInfo.eventSubscribable) {\n      bindingInfo.eventSubscribable = new subscribable()\n    }\n    return bindingInfo.eventSubscribable.subscribe(callback, context, event)\n  },\n\n  notify (node, event) {\n    const bindingInfo = domData.get(node, boundElementDomDataKey)\n    if (bindingInfo) {\n      if (bindingInfo.eventSubscribable) {\n        bindingInfo.eventSubscribable.notifySubscribers(node, event)\n      }\n    }\n  }\n}\n\n"],
+  "mappings": ";AACA;AACA;AAEO,aAAM,6BAA6B,OAAO,sBAAsB;AACvE,MAAM,yBAAyB,QAAQ,QAAQ;AAExC,aAAM,eAAe;AAAA,EAC1B,kBAAkB;AAAA,EAClB,qBAAqB;AAAA,EAErB,UAAW,MAAM,OAAO,UAAU,SAAS;AACzC,UAAM,cAAc,QAAQ,SAAS,MAAM,wBAAwB,CAAC,CAAC;AACrE,QAAI,CAAC,YAAY,mBAAmB;AAClC,kBAAY,oBAAoB,IAAI,aAAa;AAAA,IACnD;AACA,WAAO,YAAY,kBAAkB,UAAU,UAAU,SAAS,KAAK;AAAA,EACzE;AAAA,EAEA,OAAQ,MAAM,OAAO;AACnB,UAAM,cAAc,QAAQ,IAAI,MAAM,sBAAsB;AAC5D,QAAI,aAAa;AACf,UAAI,YAAY,mBAAmB;AACjC,oBAAY,kBAAkB,kBAAkB,MAAM,KAAK;AAAA,MAC7D;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}