treeloom 0.0.0-stage → 2.1.0

package/dist/render/renderHtml.js

@@ -0,0 +1,57 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const documentItem_1 = __importDefault(require("../domItem/objects/documentItem"));
+const insertChild_1 = __importDefault(require("../domItem/tree/insertChild"));
+const itemIdIndex_1 = require("../domItem/tree/itemIdIndex");
+const setParentItemReferences_1 = __importDefault(require("../domItem/tree/setParentItemReferences"));
+const updateChildNodes_1 = __importDefault(require("./updateChildNodes"));
+const updateElements_1 = __importDefault(require("./updateElements"));
+/**
+ * This is a shortcut for syncing a Virtual DOM (DomItem tree) item onto the real HTML DOM: builds the real elements
+ * for it and its descendants, inserts them into parent's children (the document body by default), and binds their
+ * associated listeners.
+ * @param item - The DomItem that we want to render the element for
+ * @param parent - Where to insert item, when it does not already have a parent - defaults to the
+ * document body, so passing nothing keeps working exactly as before
+ * @param index - Where in parent's children to put item - defaults to the end (a plain append), so passing nothing
+ * keeps working exactly as before. To insert item among parent's already-rendered content (existing real HTML),
+ * parent's children must already reflect that content first - see {@link updateDomItems}, which captures the real
+ * DOM into items. Skipping that step and inserting anyway will make the next render remove the untracked content,
+ * since it is invisible to parent.children.
+ */
+const renderHtml = (item = null, parent = (0, documentItem_1.default)().body, index = parent.children.length) => {
+  const itemToRender = item === null ? (0, documentItem_1.default)() : item;
+  // Every descendant needs its parentItem chain in place before anything below tries to walk up it (a listener
+  // being bound looks up its root via getTopParentItem) - set it first, rather than after rendering the subtree.
+  (0, setParentItemReferences_1.default)(itemToRender);
+  if (itemToRender.parentItem === null) {
+    // excluding when documentItem was passed in, insert the item into parent, and place its real element among
+    // parent's real children - scoped to just this positioning, not a resync of parent's whole existing subtree
+    // (updateElements(parent) would walk every sibling's attributes too, reverting anything about them - like a
+    // style change some other, unrelated script made directly on the real DOM - that parent's items don't track)
+    (0, insertChild_1.default)(parent, item, index);
+    (0, updateChildNodes_1.default)(parent);
+  }
+  // Register this subtree (root item included) in its own root's id index - unconditionally, since this is
+  // correct and idempotent whichever branch above ran: a freshly-attached subtree needs it for the first time,
+  // an already-attached one being re-rendered just gets its own (unchanged) entries re-set, and the document
+  // root's own very first render (parentItem is {}, not null, so the branch above never runs for it) registers
+  // the root's own already-built initial content. Does nothing at all when itemToRender is rendered into some
+  // arbitrary, never-rooted container rather than a real DomItemRoot - see registerItemIds.
+  (0, itemIdIndex_1.registerItemIds)(itemToRender);
+  // Render the elements and return either to original reference, or updated documentItem (whichever is available)
+  const updatedItem = (0, updateElements_1.default)(itemToRender);
+  return item ?? updatedItem;
+};
+exports.default = renderHtml;

package/dist/render/renderHtml.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const documentItem_1=__importDefault(require("../domItem/objects/documentItem")),insertChild_1=__importDefault(require("../domItem/tree/insertChild")),itemIdIndex_1=require("../domItem/tree/itemIdIndex"),setParentItemReferences_1=__importDefault(require("../domItem/tree/setParentItemReferences")),updateChildNodes_1=__importDefault(require("./updateChildNodes")),updateElements_1=__importDefault(require("./updateElements")),renderHtml=(e=null,t=(0,documentItem_1.default)().body,r=t.children.length)=>{const d=null===e?(0,documentItem_1.default)():e;(0,setParentItemReferences_1.default)(d),null===d.parentItem&&((0,insertChild_1.default)(t,e,r),(0,updateChildNodes_1.default)(t)),(0,itemIdIndex_1.registerItemIds)(d);const u=(0,updateElements_1.default)(d);return e??u};exports.default=renderHtml;

package/dist/render/updateChildNodes.d.ts

@@ -0,0 +1,7 @@
+import type { DomItem } from '../domItem/types';
+/**
+ * Update all the childNodes for this domItem element to mach domItem children.
+ * @param domItem
+ */
+declare const updateChildNodes: (domItem: DomItem) => DomItem;
+export default updateChildNodes;

package/dist/render/updateChildNodes.js

@@ -0,0 +1,53 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const updateElement_1 = __importDefault(require("./updateElement"));
+/**
+ * Update all the childNodes for this domItem element to mach domItem children.
+ * @param domItem
+ */
+const updateChildNodes = domItem => {
+  if (!domItem.element) {
+    domItem = (0, updateElement_1.default)(domItem);
+  }
+  if (!domItem.children || !domItem.children.length) {
+    domItem.children = [];
+    return domItem;
+  }
+  const element = domItem.element;
+  const childNodes = domItem.children.map(child => {
+    const childNode = child.element ?? (0, updateElement_1.default)(child).element;
+    child.element = childNode;
+    return childNode;
+  });
+  // Anything in the element that isn't one of the children's nodes goes (as before, when it ended up past the last child)
+  const wanted = new Set(childNodes);
+  Array.from(element.childNodes).forEach(node => {
+    if (!wanted.has(node)) {
+      element.removeChild(node);
+    }
+  });
+  // Put the nodes in order from the last one back: a node is moved only when it isn't already right before the one that
+  // follows it. So [1, 2, 3, 4] -> [2, 3, 4, 1] moves only 1, not 2, 3 and 4: a node that moves loses focus (and restarts
+  // transitions), so as few as possible move. insertBefore, not replaceChild, so nothing in the way is detached.
+  let following = null;
+  for (let index = childNodes.length - 1; index >= 0; index--) {
+    const childNode = childNodes[index];
+    if (childNode.parentNode !== element || childNode.nextSibling !== following) {
+      element.insertBefore(childNode, following);
+    }
+    following = childNode;
+  }
+  return domItem;
+};
+exports.default = updateChildNodes;

package/dist/render/updateChildNodes.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const updateElement_1=__importDefault(require("./updateElement")),updateChildNodes=e=>{if(e.element||(e=(0,updateElement_1.default)(e)),!e.children||!e.children.length)return e.children=[],e;const t=e.element,l=e.children.map(e=>{const t=e.element??(0,updateElement_1.default)(e).element;return e.element=t,t}),n=new Set(l);Array.from(t.childNodes).forEach(e=>{n.has(e)||t.removeChild(e)});let r=null;for(let e=l.length-1;e>=0;e--){const n=l[e];n.parentNode===t&&n.nextSibling===r||t.insertBefore(n,r),r=n}return e};exports.default=updateChildNodes;

package/dist/render/updateElement.d.ts

@@ -0,0 +1,14 @@
+import type { DomItem } from '../domItem/types';
+/**
+ * Update a single objects.DomItem element with the provided attributes / style / elementProperties.
+ *
+ * Safe to call standalone (not just through {@link updateElements}/{@link renderHtml}): whenever this ends up
+ * (re)generating domItem.element - because it had none yet, or because nodeName changed - it also re-attaches
+ * domItem's direct children onto that element via {@link updateChildNodes}, so a bare call never orphans an
+ * existing child subtree. The plain attribute/style patch path below doesn't touch domItem.element itself, so it
+ * doesn't need to.
+ * @param domItem - The DomItem having domItem changes to be applied to its
+ * element
+ */
+declare const updateElement: (domItem: DomItem) => DomItem;
+export default updateElement;

package/dist/render/updateElement.js

@@ -0,0 +1,113 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+require("core-js/modules/es.array.includes.js");
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const bindListeners_1 = __importDefault(require("../events/functions/bindListeners"));
+const deactivateListeners_1 = __importDefault(require("../events/functions/deactivateListeners"));
+const domItemChanges_1 = __importDefault(require("../diff/domItemChanges"));
+const appliedSnapshot_1 = require("../diff/appliedSnapshot");
+const si_funciona_1 = __importDefault(require("si-funciona"));
+const generateElement_1 = __importDefault(require("./generateElement"));
+const updateChildNodes_1 = __importDefault(require("./updateChildNodes"));
+/**
+ * Update a single objects.DomItem element with the provided attributes / style / elementProperties.
+ *
+ * Safe to call standalone (not just through {@link updateElements}/{@link renderHtml}): whenever this ends up
+ * (re)generating domItem.element - because it had none yet, or because nodeName changed - it also re-attaches
+ * domItem's direct children onto that element via {@link updateChildNodes}, so a bare call never orphans an
+ * existing child subtree. The plain attribute/style patch path below doesn't touch domItem.element itself, so it
+ * doesn't need to.
+ * @param domItem - The DomItem having domItem changes to be applied to its
+ * element
+ */
+const updateElement = domItem => {
+  if (!domItem.element) {
+    return (0, updateChildNodes_1.default)((0, generateElement_1.default)((0, deactivateListeners_1.default)(domItem)));
+  }
+  const changes = (0, domItemChanges_1.default)(domItem);
+  // From here on the item has an element (an element which is missing was generated above)
+  const element = domItem.element;
+  const properties = element;
+  if (changes.removed.nodeName || changes.added.nodeName) {
+    // if the nodeName has changed then remove the element and create a new one
+    element.remove();
+    return (0, updateChildNodes_1.default)((0, generateElement_1.default)((0, deactivateListeners_1.default)(domItem)));
+  }
+  for (const dotKey in changes.removed) {
+    const value = changes.removed[dotKey];
+    if (!dotKey.includes('.')) {
+      if (dotKey in element) {
+        delete properties[dotKey];
+        continue;
+      }
+      element.removeAttribute(dotKey);
+      continue;
+    }
+    const baseKey = si_funciona_1.default.strBefore(dotKey, '.');
+    if (baseKey !== 'class' && baseKey !== 'style') {
+      throw new Error('Unhandled dotKey: ' + dotKey);
+    }
+    if (baseKey === 'class') {
+      element.classList.remove(value);
+      continue;
+    }
+    // The key is usually already kebab-case here (domItemChanges normalizes it), but not always - see the fix
+    // notes on the matching line below. kabobCase on an already-kebab string is a harmless no-op.
+    element.style.removeProperty(si_funciona_1.default.kabobCase(si_funciona_1.default.strAfter(dotKey, '.')));
+  }
+  for (const dotKey in changes.added) {
+    const value = changes.added[dotKey];
+    if (dotKey === 'className') {
+      element.className = value;
+      continue;
+    }
+    if (dotKey === 'style') {
+      // Update all styles based on incoming style object
+      // setProperty wants CSS names (background-color), but the style object is written in camelCase (backgroundColor)
+      for (const style in value) {
+        element.style.setProperty(si_funciona_1.default.kabobCase(style), value[style]);
+      }
+      continue;
+    }
+    if (!dotKey.includes('.')) {
+      if (dotKey in element && dotKey !== 'form') {
+        // Some things can be assigned directly, but 'form' attribute cannot
+        properties[dotKey] = value;
+        continue;
+      }
+      element.setAttribute(dotKey, value);
+      continue;
+    }
+    const baseKey = si_funciona_1.default.strBefore(dotKey, '.');
+    if (baseKey !== 'class' && baseKey !== 'style') {
+      throw new Error('Unhandled dotKey: ' + dotKey);
+    }
+    if (baseKey === 'class' && (/\s/.test(value) || !value)) {
+      // Skip this empty class name
+      continue;
+    }
+    if (baseKey === 'class') {
+      element.classList.add(value);
+      continue;
+    }
+    // domItemChanges is expected to hand this key through already kebab-cased, but a style property which was
+    // already assigned on the element (changed, not newly added) can come back through as its original camelCase
+    // form; CSSOM silently ignores setProperty with an invalid (camelCase) name, so the style is dropped with no
+    // error. kabobCase here is a harmless no-op when the key is already kebab, and a real fix when it is not.
+    element.style.setProperty(si_funciona_1.default.kabobCase(si_funciona_1.default.strAfter(dotKey, '.')), value);
+  }
+  // The element now matches the item: the next update compares against this rather than reading the element back
+  (0, appliedSnapshot_1.recordApplied)(domItem);
+  return (0, bindListeners_1.default)(domItem);
+};
+exports.default = updateElement;

package/dist/render/updateElement.min.js

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/es.array.includes.js");var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const bindListeners_1=__importDefault(require("../events/functions/bindListeners")),deactivateListeners_1=__importDefault(require("../events/functions/deactivateListeners")),domItemChanges_1=__importDefault(require("../diff/domItemChanges")),appliedSnapshot_1=require("../diff/appliedSnapshot"),si_funciona_1=__importDefault(require("si-funciona")),generateElement_1=__importDefault(require("./generateElement")),updateChildNodes_1=__importDefault(require("./updateChildNodes")),updateElement=e=>{if(!e.element)return(0,updateChildNodes_1.default)((0,generateElement_1.default)((0,deactivateListeners_1.default)(e)));const t=(0,domItemChanges_1.default)(e),s=e.element,n=s;if(t.removed.nodeName||t.added.nodeName)return s.remove(),(0,updateChildNodes_1.default)((0,generateElement_1.default)((0,deactivateListeners_1.default)(e)));for(const e in t.removed){const i=t.removed[e];if(!e.includes(".")){if(e in s){delete n[e];continue}s.removeAttribute(e);continue}const a=si_funciona_1.default.strBefore(e,".");if("class"!==a&&"style"!==a)throw new Error("Unhandled dotKey: "+e);"class"!==a?s.style.removeProperty(si_funciona_1.default.kabobCase(si_funciona_1.default.strAfter(e,"."))):s.classList.remove(i)}for(const e in t.added){const i=t.added[e];if("className"===e){s.className=i;continue}if("style"===e){for(const e in i)s.style.setProperty(si_funciona_1.default.kabobCase(e),i[e]);continue}if(!e.includes(".")){if(e in s&&"form"!==e){n[e]=i;continue}s.setAttribute(e,i);continue}const a=si_funciona_1.default.strBefore(e,".");if("class"!==a&&"style"!==a)throw new Error("Unhandled dotKey: "+e);("class"!==a||!/\s/.test(i)&&i)&&("class"!==a?s.style.setProperty(si_funciona_1.default.kabobCase(si_funciona_1.default.strAfter(e,".")),i):s.classList.add(i))}return(0,appliedSnapshot_1.recordApplied)(e),(0,bindListeners_1.default)(e)};exports.default=updateElement;

package/dist/render/updateElements.d.ts

@@ -0,0 +1,9 @@
+import type { DomItem } from '../domItem/types';
+/**
+ * Generate HTML element data for each object in the matrix
+ * WARNING: This is a recursive function.
+ * @param config - The DomItem having child DomItems with config changes to be
+ * applied
+ */
+declare const updateElements: (config: DomItem) => DomItem;
+export default updateElements;

package/dist/render/updateElements.js

@@ -0,0 +1,33 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const updateChildNodes_1 = __importDefault(require("./updateChildNodes"));
+const updateElement_1 = __importDefault(require("./updateElement"));
+/**
+ * Generate HTML element data for each object in the matrix
+ * WARNING: This is a recursive function.
+ * @param config - The DomItem having child DomItems with config changes to be
+ * applied
+ */
+const updateElements = config => {
+  if (config.nodeName === '#document') {
+    for (const child of config.children) {
+      updateElements(child);
+    }
+    return config;
+  }
+  const domItem = (0, updateChildNodes_1.default)((0, updateElement_1.default)(config));
+  domItem.children.forEach(updateElements);
+  return domItem;
+};
+exports.default = updateElements;

package/dist/render/updateElements.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const updateChildNodes_1=__importDefault(require("./updateChildNodes")),updateElement_1=__importDefault(require("./updateElement")),updateElements=e=>{if("#document"===e.nodeName){for(const t of e.children)updateElements(t);return e}const t=(0,updateChildNodes_1.default)((0,updateElement_1.default)(e));return t.children.forEach(updateElements),t};exports.default=updateElements;

package/dist/renderOnly.d.ts

@@ -0,0 +1,2 @@
+declare const treeloomRenderOnly: any;
+export = treeloomRenderOnly;

package/dist/renderOnly.js

@@ -0,0 +1,27 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+/**
+ * The render-only subset of treeloom: build and sync a Virtual DOM (DomItem tree) to the real
+ * HTML DOM, and forward fired events elsewhere (see events/objects/setForwardEvents) instead of
+ * running local business logic - a consumer that never needs to run that logic locally never
+ * needs to go the other way (DOM back to JSON) either, so this excludes deflate, the one part of
+ * the full build with no other internal code path depending on it.
+ */
+const index_1 = __importDefault(require("./events/index"));
+const index_2 = __importDefault(require("./domItem/index"));
+const documentItem_1 = require("./domItem/objects/documentItem");
+const index_3 = __importDefault(require("./inflate/index"));
+const index_4 = __importDefault(require("./render/index"));
+const index_5 = __importDefault(require("./sync/index"));
+const index_6 = __importDefault(require("./diff/index"));
+// documentItem is a getter (see withDocumentItem), so loading treeloom never touches a real document
+const treeloomRenderOnly = (0, documentItem_1.withDocumentItem)(Object.assign({}, index_1.default, index_2.default, index_3.default, index_4.default, index_5.default, index_6.default));
+module.exports = treeloomRenderOnly;

package/dist/renderOnly.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};const index_1=__importDefault(require("./events/index")),index_2=__importDefault(require("./domItem/index")),documentItem_1=require("./domItem/objects/documentItem"),index_3=__importDefault(require("./inflate/index")),index_4=__importDefault(require("./render/index")),index_5=__importDefault(require("./sync/index")),index_6=__importDefault(require("./diff/index")),treeloomRenderOnly=(0,documentItem_1.withDocumentItem)(Object.assign({},index_1.default,index_2.default,index_3.default,index_4.default,index_5.default,index_6.default));module.exports=treeloomRenderOnly;

package/dist/sync/index.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    updateChildren: (domItem: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    updateDomItem: (config: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+    updateDomItems: (config: import("../domItem/types").DomItem) => import("../domItem/types").DomItem;
+};
+export default _default;

package/dist/sync/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const updateChildren_1 = __importDefault(require("./updateChildren"));
+const updateDomItem_1 = __importDefault(require("./updateDomItem"));
+const updateDomItems_1 = __importDefault(require("./updateDomItems"));
+exports.default = {
+  updateChildren: updateChildren_1.default,
+  updateDomItem: updateDomItem_1.default,
+  updateDomItems: updateDomItems_1.default
+};

package/dist/sync/index.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const updateChildren_1=__importDefault(require("./updateChildren")),updateDomItem_1=__importDefault(require("./updateDomItem")),updateDomItems_1=__importDefault(require("./updateDomItems"));exports.default={updateChildren:updateChildren_1.default,updateDomItem:updateDomItem_1.default,updateDomItems:updateDomItems_1.default};

package/dist/sync/updateChildren.d.ts

@@ -0,0 +1,7 @@
+import type { DomItem } from '../domItem/types';
+/**
+ * Update all the children for this domItem to match the domItem element childNodes.
+ * @param domItem
+ */
+declare const updateChildren: (domItem: DomItem) => DomItem;
+export default updateChildren;

package/dist/sync/updateChildren.js

@@ -0,0 +1,38 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const createDomItem_1 = __importDefault(require("../domItem/objects/createDomItem"));
+/**
+ * Update all the children for this domItem to match the domItem element childNodes.
+ * @param domItem
+ */
+const updateChildren = domItem => {
+  if (!domItem.element) {
+    domItem.children = [];
+    return domItem;
+  }
+  const previousChildren = domItem.children;
+  domItem.children = [];
+  domItem.element.childNodes.forEach((childNode, index) => {
+    const existing = previousChildren.find(child => child.element === childNode);
+    const child = existing ?? (0, createDomItem_1.default)({
+      nodeName: childNode.nodeName.toLowerCase(),
+      nodeValue: childNode.nodeValue,
+      element: childNode
+    });
+    domItem.children[index] = child;
+    child.parentItem = domItem;
+  });
+  return domItem;
+};
+exports.default = updateChildren;

package/dist/sync/updateChildren.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const createDomItem_1=__importDefault(require("../domItem/objects/createDomItem")),updateChildren=e=>{if(!e.element)return e.children=[],e;const t=e.children;return e.children=[],e.element.childNodes.forEach((r,n)=>{const o=t.find(e=>e.element===r),d=o??(0,createDomItem_1.default)({nodeName:r.nodeName.toLowerCase(),nodeValue:r.nodeValue,element:r});e.children[n]=d,d.parentItem=e}),e};exports.default=updateChildren;

package/dist/sync/updateDomItem.d.ts

@@ -0,0 +1,8 @@
+import type { DomItem } from '../domItem/types';
+/**
+ * Update a single objects.DomItem element with the provided attributes / style / elementProperties
+ * @param config - The DomItem having config changes to be applied to its
+ * element
+ */
+declare const updateDomItem: (config: DomItem) => DomItem;
+export default updateDomItem;

package/dist/sync/updateDomItem.js

@@ -0,0 +1,53 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const si_funciona_1 = __importDefault(require("si-funciona"));
+const elementChanges_1 = __importDefault(require("../diff/elementChanges"));
+const appliedSnapshot_1 = require("../diff/appliedSnapshot");
+/**
+ * Update a single objects.DomItem element with the provided attributes / style / elementProperties
+ * @param config - The DomItem having config changes to be applied to its
+ * element
+ */
+const updateDomItem = config => {
+  if (!config.element) {
+    // if element is not a valid element then return the config without changes
+    return config;
+  }
+  const changes = (0, elementChanges_1.default)(config);
+  for (const dotKey in changes.removed) {
+    const attributeKey = si_funciona_1.default.strAfter(dotKey, '.');
+    if (si_funciona_1.default.strBefore(attributeKey, '.') === 'className') {
+      const classList = config.attributes.className.split(' ');
+      classList.splice(si_funciona_1.default.strAfterLast(attributeKey, '.'), 1);
+      config.attributes.className = classList.join(' ');
+      continue;
+    }
+    si_funciona_1.default.dotUnset(config, dotKey);
+  }
+  for (const dotKey in changes.added) {
+    const attributeKey = si_funciona_1.default.strAfter(dotKey, '.');
+    if (si_funciona_1.default.strBefore(attributeKey, '.') === 'className') {
+      const classList = config.attributes.className.split(' ');
+      classList.push(changes.added[dotKey]);
+      config.attributes.className = classList.join(' ');
+      continue;
+    }
+    si_funciona_1.default.dotSet(config, dotKey, changes.added[dotKey]);
+  }
+  // The item now holds what the element has, which may not be what treeloom last wrote: compare the next update with
+  // the element itself again, or setting the item back to the old value would look like no change at all
+  (0, appliedSnapshot_1.forgetApplied)(config.element);
+  return config;
+};
+exports.default = updateDomItem;

package/dist/sync/updateDomItem.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const si_funciona_1=__importDefault(require("si-funciona")),elementChanges_1=__importDefault(require("../diff/elementChanges")),appliedSnapshot_1=require("../diff/appliedSnapshot"),updateDomItem=e=>{if(!e.element)return e;const t=(0,elementChanges_1.default)(e);for(const s in t.removed){const t=si_funciona_1.default.strAfter(s,".");if("className"===si_funciona_1.default.strBefore(t,".")){const s=e.attributes.className.split(" ");s.splice(si_funciona_1.default.strAfterLast(t,"."),1),e.attributes.className=s.join(" ");continue}si_funciona_1.default.dotUnset(e,s)}for(const s in t.added){const a=si_funciona_1.default.strAfter(s,".");if("className"===si_funciona_1.default.strBefore(a,".")){const a=e.attributes.className.split(" ");a.push(t.added[s]),e.attributes.className=a.join(" ");continue}si_funciona_1.default.dotSet(e,s,t.added[s])}return(0,appliedSnapshot_1.forgetApplied)(e.element),e};exports.default=updateDomItem;

package/dist/sync/updateDomItems.d.ts

@@ -0,0 +1,9 @@
+import type { DomItem } from '../domItem/types';
+/**
+ * Generate HTML element data for each object in the matrix
+ * WARNING: This is a recursive function.
+ * @param config - The DomItem having child DomItems with config changes to be
+ * applied
+ */
+declare const updateDomItems: (config: DomItem) => DomItem;
+export default updateDomItems;

package/dist/sync/updateDomItems.js

@@ -0,0 +1,33 @@
+"use strict";
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const updateChildren_1 = __importDefault(require("./updateChildren"));
+const updateDomItem_1 = __importDefault(require("./updateDomItem"));
+/**
+ * Generate HTML element data for each object in the matrix
+ * WARNING: This is a recursive function.
+ * @param config - The DomItem having child DomItems with config changes to be
+ * applied
+ */
+const updateDomItems = config => {
+  if (config.nodeName === '#document') {
+    for (const child of config.children) {
+      updateDomItems(child);
+    }
+    return config;
+  }
+  const domItem = (0, updateChildren_1.default)((0, updateDomItem_1.default)(config));
+  domItem.children.forEach(updateDomItems);
+  return domItem;
+};
+exports.default = updateDomItems;

package/dist/sync/updateDomItems.min.js

@@ -0,0 +1 @@
+"use strict";var __importDefault=function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const updateChildren_1=__importDefault(require("./updateChildren")),updateDomItem_1=__importDefault(require("./updateDomItem")),updateDomItems=e=>{if("#document"===e.nodeName){for(const t of e.children)updateDomItems(t);return e}const t=(0,updateChildren_1.default)((0,updateDomItem_1.default)(e));return t.children.forEach(updateDomItems),t};exports.default=updateDomItems;

package/package.json

@@ -1,6 +1,76 @@
 {
   "name": "treeloom",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "author": "Joshua Heagle <joshuaheagle@gmail.com> (https://joshuaheagle.com)",
+  "license": "MPL-2.0",
+  "description": "State management with JSON.",
+  "homepage": "https://github.com/jheagle/treeloom#readme",
+  "keywords": [
+    "json",
+    "tree",
+    "virtual dom",
+    "dom",
+    "state management",
+    "serialization",
+    "typescript"
+  ],
+  "version": "2.1.0",
+  "bugs": {
+    "url": "https://github.com/jheagle/treeloom/issues"
+  },
+  "scripts": {
+    "build": "gulp build",
+    "dev": "gulp",
+    "docs": "gulp docs",
+    "lint": "gulp lint",
+    "prepublishOnly": "npm run build",
+    "publish:bundle": "gulp copyFiles",
+    "release": "release-it",
+    "release:dry-run": "release-it --dry-run",
+    "resolutions": "npx npm-force-resolutions",
+    "test": "gulp testFull",
+    "test:quick": "gulp testQuick",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.type-tests.json",
+    "watch": "gulp watchFull",
+    "watch:test": "gulp watchTest"
+  },
+  "dependencies": {
+    "collect-your-stuff": "^2.2.1",
+    "core-js": "^3.51.0",
+    "si-funciona": "^2.10.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^8.1.0",
+    "@babel/plugin-transform-modules-commonjs": "^8.0.1",
+    "@babel/preset-env": "^8.0.7",
+    "gulp": "^5.0.1",
+    "js-build-tools": "^8.2.0",
+    "release-it": "^21.1.2",
+    "standard": "^17.1.2",
+    "test-filesystem": "^2.0.0",
+    "typedoc": "^0.28.20"
+  },
+  "resolutions": {},
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jheagle/treeloom.git"
+  },
+  "main": "dist/main.js",
+  "types": "dist/main.d.ts",
+  "files": [
+    "dist",
+    "browser"
+  ],
+  "standard": {
+    "env": [
+      "jest",
+      "browser"
+    ]
+  },
+  "allowScripts": {
+    "core-js": false,
+    "core-js-pure": false,
+    "@parcel/watcher": false,
+    "unrs-resolver": false,
+    "esbuild": false
+  }
+}