@thi.ng/hdom 9.3.31 → 9.4.1

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-18T13:41:20Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,12 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+## [9.4.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/hdom@9.4.0) (2023-12-11)
+
+#### 🚀 Features
+
+- update setAttrib(), more alignment w/ rdom logic ([639ca71](https://github.com/thi-ng/umbrella/commit/639ca71))
+
 ### [9.3.27](https://github.com/thi-ng/umbrella/tree/@thi.ng/hdom@9.3.27) (2023-11-09)
 
 #### ♻️ Refactoring

package/README.md

@@ -157,7 +157,7 @@ yarn install
 yarn start
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 3.42 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 3.49 KB
 
 ## Dependencies
 

package/api.js

@@ -1 +0,0 @@
-export {};

package/default.js

@@ -1,31 +1,42 @@
 import { diffTree } from "./diff.js";
-import { createElement, createTextElement, createTree, getChild, hydrateTree, removeAttribs, removeChild, replaceChild, setAttrib, setContent, } from "./dom.js";
+import {
+  createElement,
+  createTextElement,
+  createTree,
+  getChild,
+  hydrateTree,
+  removeAttribs,
+  removeChild,
+  replaceChild,
+  setAttrib,
+  setContent
+} from "./dom.js";
 import { normalizeTree } from "./normalize.js";
-/**
- * Default target implementation to manipulate browser DOM.
- */
-export const DEFAULT_IMPL = {
-    createTree(opts, parent, tree, child, init) {
-        return createTree(opts, this, parent, tree, child, init);
-    },
-    hydrateTree(opts, parent, tree, child) {
-        return hydrateTree(opts, this, parent, tree, child);
-    },
-    diffTree(opts, parent, prev, curr, child) {
-        diffTree(opts, this, parent, prev, curr, child);
-    },
-    normalizeTree,
-    getElementById(id) {
-        return document.getElementById(id);
-    },
-    getChild,
-    createElement,
-    createTextElement,
-    replaceChild(opts, parent, child, tree, init) {
-        replaceChild(opts, this, parent, child, tree, init);
-    },
-    removeChild,
-    setContent,
-    removeAttribs,
-    setAttrib,
+const DEFAULT_IMPL = {
+  createTree(opts, parent, tree, child, init) {
+    return createTree(opts, this, parent, tree, child, init);
+  },
+  hydrateTree(opts, parent, tree, child) {
+    return hydrateTree(opts, this, parent, tree, child);
+  },
+  diffTree(opts, parent, prev, curr, child) {
+    diffTree(opts, this, parent, prev, curr, child);
+  },
+  normalizeTree,
+  getElementById(id) {
+    return document.getElementById(id);
+  },
+  getChild,
+  createElement,
+  createTextElement,
+  replaceChild(opts, parent, child, tree, init) {
+    replaceChild(opts, this, parent, child, tree, init);
+  },
+  removeChild,
+  setContent,
+  removeAttribs,
+  setAttrib
+};
+export {
+  DEFAULT_IMPL
 };

package/diff.js

@@ -1,285 +1,248 @@
 import { SEMAPHORE } from "@thi.ng/api/api";
 import { diffArray } from "@thi.ng/diff/array";
 import { diffObject } from "@thi.ng/diff/object";
-import { equiv as _equiv, equivArrayLike, equivMap, equivObject, equivSet, } from "@thi.ng/equiv";
+import {
+  equiv as _equiv,
+  equivArrayLike,
+  equivMap,
+  equivObject,
+  equivSet
+} from "@thi.ng/equiv";
 const isArray = Array.isArray;
 const max = Math.max;
 const OBJP = Object.getPrototypeOf({});
 const FN = "function";
 const STR = "string";
-// child index tracking template buffer
 const INDEX = (() => {
-    const res = new Array(2048);
-    for (let i = 2, n = res.length; i < n; i++) {
-        res[i] = i - 2;
-    }
-    return res;
+  const res = new Array(2048);
+  for (let i = 2, n = res.length; i < n; i++) {
+    res[i] = i - 2;
+  }
+  return res;
 })();
 const buildIndex = (n) => {
-    if (n <= INDEX.length) {
-        return INDEX.slice(0, n);
-    }
-    const res = new Array(n);
-    while (n-- > 2) {
-        res[n] = n - 2;
-    }
-    return res;
+  if (n <= INDEX.length) {
+    return INDEX.slice(0, n);
+  }
+  const res = new Array(n);
+  while (n-- > 2) {
+    res[n] = n - 2;
+  }
+  return res;
 };
-/**
- * See {@link HDOMImplementation} interface for further details.
- *
- * @param opts - hdom config options
- * @param impl - hdom implementation
- * @param parent - parent element (DOM node)
- * @param prev - previous tree
- * @param curr - current tree
- * @param child - child index
- */
-export const diffTree = (opts, impl, parent, prev, curr, child = 0) => {
-    const attribs = curr[1];
-    if (attribs.__skip) {
-        return;
-    }
-    // always replace element if __diff = false
-    if (attribs.__diff === false) {
-        releaseTree(prev);
-        impl.replaceChild(opts, parent, child, curr);
-        return;
-    }
-    const pattribs = prev[1];
-    if (pattribs && pattribs.__skip) {
-        impl.replaceChild(opts, parent, child, curr, false);
-        return;
-    }
-    // delegate to branch-local implementation
-    let _impl = attribs.__impl;
-    if (_impl && _impl !== impl) {
-        return _impl.diffTree(opts, _impl, parent, prev, curr, child);
-    }
-    const delta = diffArray(prev, curr, "only-distance-linear", equiv);
-    if (delta.distance === 0) {
-        return;
-    }
-    const edits = delta.linear;
-    const el = impl.getChild(parent, child);
-    let i;
-    let ii;
-    let status;
-    let val;
-    if (edits[0] !== 0 || prev[1].key !== attribs.key) {
-        // LOGGER.fine("replace:", prev, curr);
-        releaseTree(prev);
-        impl.replaceChild(opts, parent, child, curr);
-        return;
-    }
-    if ((val = prev.__release) && val !== curr.__release) {
-        releaseTree(prev);
-    }
-    if (edits[3] !== 0) {
-        diffAttributes(impl, el, prev[1], curr[1]);
-        // if attribs changed & distance == 2 then we're done here...
-        if (delta.distance === 2) {
-            return;
-        }
-    }
-    const numEdits = edits.length;
-    const prevLength = prev.length - 1;
-    const equivKeys = extractEquivElements(edits);
-    const offsets = buildIndex(prevLength + 1);
-    for (i = 2, ii = 6; ii < numEdits; i++, ii += 3) {
-        status = edits[ii];
-        if (!status)
-            continue;
-        if (status === -1) {
-            diffDeleted(opts, impl, el, prev, curr, edits, ii, equivKeys, offsets, prevLength);
-        }
-        else {
-            diffAdded(opts, impl, el, edits, ii, equivKeys, offsets, prevLength);
-        }
-    }
-    // call __init after all children have been added/updated
-    if ((val = curr.__init) && val != prev.__init) {
-        val.apply(curr, [el, ...curr.__args]);
-    }
+const diffTree = (opts, impl, parent, prev, curr, child = 0) => {
+  const attribs = curr[1];
+  if (attribs.__skip) {
+    return;
+  }
+  if (attribs.__diff === false) {
+    releaseTree(prev);
+    impl.replaceChild(opts, parent, child, curr);
+    return;
+  }
+  const pattribs = prev[1];
+  if (pattribs && pattribs.__skip) {
+    impl.replaceChild(opts, parent, child, curr, false);
+    return;
+  }
+  let _impl = attribs.__impl;
+  if (_impl && _impl !== impl) {
+    return _impl.diffTree(opts, _impl, parent, prev, curr, child);
+  }
+  const delta = diffArray(prev, curr, "only-distance-linear", equiv);
+  if (delta.distance === 0) {
+    return;
+  }
+  const edits = delta.linear;
+  const el = impl.getChild(parent, child);
+  let i;
+  let ii;
+  let status;
+  let val;
+  if (edits[0] !== 0 || prev[1].key !== attribs.key) {
+    releaseTree(prev);
+    impl.replaceChild(opts, parent, child, curr);
+    return;
+  }
+  if ((val = prev.__release) && val !== curr.__release) {
+    releaseTree(prev);
+  }
+  if (edits[3] !== 0) {
+    diffAttributes(impl, el, prev[1], curr[1]);
+    if (delta.distance === 2) {
+      return;
+    }
+  }
+  const numEdits = edits.length;
+  const prevLength = prev.length - 1;
+  const equivKeys = extractEquivElements(edits);
+  const offsets = buildIndex(prevLength + 1);
+  for (i = 2, ii = 6; ii < numEdits; i++, ii += 3) {
+    status = edits[ii];
+    if (!status)
+      continue;
+    if (status === -1) {
+      diffDeleted(
+        opts,
+        impl,
+        el,
+        prev,
+        curr,
+        edits,
+        ii,
+        equivKeys,
+        offsets,
+        prevLength
+      );
+    } else {
+      diffAdded(
+        opts,
+        impl,
+        el,
+        edits,
+        ii,
+        equivKeys,
+        offsets,
+        prevLength
+      );
+    }
+  }
+  if ((val = curr.__init) && val != prev.__init) {
+    val.apply(curr, [el, ...curr.__args]);
+  }
 };
 const diffDeleted = (opts, impl, el, prev, curr, edits, ii, equivKeys, offsets, prevLength) => {
-    const val = edits[ii + 2];
-    if (isArray(val)) {
-        let k = val[1].key;
-        if (k !== undefined && equivKeys[k][2] !== undefined) {
-            const eq = equivKeys[k];
-            k = eq[0];
-            // LOGGER.fine(`diff equiv key @ ${k}:`, prev[k], curr[eq[2]]);
-            diffTree(opts, impl, el, prev[k], curr[eq[2]], offsets[k]);
-        }
-        else {
-            const idx = edits[ii + 1];
-            // LOGGER.fine("remove @", offsets[idx], val);
-            releaseTree(val);
-            impl.removeChild(el, offsets[idx]);
-            incOffsets(offsets, prevLength, idx);
-        }
-    }
-    else if (typeof val === STR) {
-        impl.setContent(el, "");
-    }
+  const val = edits[ii + 2];
+  if (isArray(val)) {
+    let k = val[1].key;
+    if (k !== void 0 && equivKeys[k][2] !== void 0) {
+      const eq = equivKeys[k];
+      k = eq[0];
+      diffTree(opts, impl, el, prev[k], curr[eq[2]], offsets[k]);
+    } else {
+      const idx = edits[ii + 1];
+      releaseTree(val);
+      impl.removeChild(el, offsets[idx]);
+      incOffsets(offsets, prevLength, idx);
+    }
+  } else if (typeof val === STR) {
+    impl.setContent(el, "");
+  }
 };
 const diffAdded = (opts, impl, el, edits, ii, equivKeys, offsets, prevLength) => {
-    const val = edits[ii + 2];
-    if (typeof val === STR) {
-        impl.setContent(el, val);
-    }
-    else if (isArray(val)) {
-        const k = val[1].key;
-        if (k === undefined || equivKeys[k][0] === undefined) {
-            const idx = edits[ii + 1];
-            // LOGGER.fine("insert @", offsets[idx], val);
-            impl.createTree(opts, el, val, offsets[idx]);
-            decOffsets(offsets, prevLength, idx);
-        }
-    }
+  const val = edits[ii + 2];
+  if (typeof val === STR) {
+    impl.setContent(el, val);
+  } else if (isArray(val)) {
+    const k = val[1].key;
+    if (k === void 0 || equivKeys[k][0] === void 0) {
+      const idx = edits[ii + 1];
+      impl.createTree(opts, el, val, offsets[idx]);
+      decOffsets(offsets, prevLength, idx);
+    }
+  }
 };
 const incOffsets = (offsets, j, idx) => {
-    for (; j > idx; j--) {
-        offsets[j] = max(offsets[j] - 1, 0);
-    }
+  for (; j > idx; j--) {
+    offsets[j] = max(offsets[j] - 1, 0);
+  }
 };
 const decOffsets = (offsets, j, idx) => {
-    for (; j >= idx; j--) {
-        offsets[j]++;
-    }
+  for (; j >= idx; j--) {
+    offsets[j]++;
+  }
+};
+const diffAttributes = (impl, el, prev, curr) => {
+  const delta = diffObject(prev, curr, "full", _equiv);
+  impl.removeAttribs(el, delta.dels, prev);
+  let val = SEMAPHORE;
+  let i, e, edits;
+  for (edits = delta.edits, i = edits.length; (i -= 2) >= 0; ) {
+    e = edits[i];
+    e[0] === "o" && e[1] === "n" && impl.removeAttribs(el, [e], prev);
+    e !== "value" ? impl.setAttrib(el, e, edits[i + 1], curr) : val = edits[i + 1];
+  }
+  for (edits = delta.adds, i = edits.length; i-- > 0; ) {
+    e = edits[i];
+    e !== "value" ? impl.setAttrib(el, e, curr[e], curr) : val = curr[e];
+  }
+  val !== SEMAPHORE && impl.setAttrib(el, "value", val, curr);
 };
-/**
- * Helper function for {@link diffTree} to compute & apply the difference
- * between a node's `prev` and `curr` attributes.
- *
- * @param impl - hdom implementation
- * @param el - DOM element
- * @param prev - previous attributes
- * @param curr - current attributes
- *
- * @internal
- */
-export const diffAttributes = (impl, el, prev, curr) => {
-    const delta = diffObject(prev, curr, "full", _equiv);
-    impl.removeAttribs(el, delta.dels, prev);
-    let val = SEMAPHORE;
-    let i, e, edits;
-    for (edits = delta.edits, i = edits.length; (i -= 2) >= 0;) {
-        e = edits[i];
-        e[0] === "o" && e[1] === "n" && impl.removeAttribs(el, [e], prev);
-        e !== "value"
-            ? impl.setAttrib(el, e, edits[i + 1], curr)
-            : (val = edits[i + 1]);
+const releaseTree = (tree) => {
+  if (isArray(tree)) {
+    let x;
+    if ((x = tree[1]) && x.__release === false) {
+      return;
     }
-    for (edits = delta.adds, i = edits.length; i-- > 0;) {
-        e = edits[i];
-        e !== "value" ? impl.setAttrib(el, e, curr[e], curr) : (val = curr[e]);
+    if (tree.__release) {
+      tree.__release.apply(tree.__this, tree.__args);
+      delete tree.__release;
     }
-    val !== SEMAPHORE && impl.setAttrib(el, "value", val, curr);
-};
-/**
- * Recursively attempts to call the {@link ILifecycle.release} lifecycle
- * method on every element in given tree (branch), using depth-first
- * descent. Each element is checked for the presence of the `__release`
- * control attribute. If (and only if) it is set to `false`, further
- * descent into that element's branch is skipped.
- *
- * @param tree - hdom sub-tree
- *
- * @internal
- */
-export const releaseTree = (tree) => {
-    if (isArray(tree)) {
-        let x;
-        if ((x = tree[1]) && x.__release === false) {
-            return;
-        }
-        if (tree.__release) {
-            // LOGGER.fine("call __release", tag);
-            tree.__release.apply(tree.__this, tree.__args);
-            delete tree.__release;
-        }
-        for (x = tree.length; x-- > 2;) {
-            releaseTree(tree[x]);
-        }
+    for (x = tree.length; x-- > 2; ) {
+      releaseTree(tree[x]);
     }
+  }
 };
 const extractEquivElements = (edits) => {
-    let k;
-    let val;
-    let ek;
-    const equiv = {};
-    for (let i = edits.length; (i -= 3) >= 0;) {
-        val = edits[i + 2];
-        if (isArray(val) && (k = val[1].key) !== undefined) {
-            ek = equiv[k];
-            !ek && (equiv[k] = ek = [, ,]);
-            ek[edits[i] + 1] = edits[i + 1];
-        }
-    }
-    return equiv;
+  let k;
+  let val;
+  let ek;
+  const equiv2 = {};
+  for (let i = edits.length; (i -= 3) >= 0; ) {
+    val = edits[i + 2];
+    if (isArray(val) && (k = val[1].key) !== void 0) {
+      ek = equiv2[k];
+      !ek && (equiv2[k] = ek = [, ,]);
+      ek[edits[i] + 1] = edits[i + 1];
+    }
+  }
+  return equiv2;
 };
-/**
- * Customized version
- * [`equiv()`](https://docs.thi.ng/umbrella/equiv/functions/equiv.html) which
- * takes `__diff` attributes into account (at any nesting level). If an hdom
- * element's attribute object contains `__diff: false`, the object will ALWAYS
- * be considered unequal, even if all other attributes in the object are
- * equivalent.
- *
- * @param a -
- * @param b -
- *
- * @internal
- */
-export const equiv = (a, b) => {
-    let proto;
-    if (a === b) {
-        return true;
-    }
-    if (a != null) {
-        if (typeof a.equiv === FN) {
-            return a.equiv(b);
-        }
-    }
-    else {
-        return a == b;
-    }
-    if (b != null) {
-        if (typeof b.equiv === FN) {
-            return b.equiv(a);
-        }
-    }
-    else {
-        return a == b;
-    }
-    if (typeof a === STR || typeof b === STR) {
-        return false;
-    }
-    if (((proto = Object.getPrototypeOf(a)), proto == null || proto === OBJP) &&
-        ((proto = Object.getPrototypeOf(b)), proto == null || proto === OBJP)) {
-        return (!(a.__diff === false || b.__diff === false) &&
-            equivObject(a, b, equiv));
-    }
-    if (typeof a !== FN &&
-        a.length !== undefined &&
-        typeof b !== FN &&
-        b.length !== undefined) {
-        return equivArrayLike(a, b, equiv);
-    }
-    if (a instanceof Set && b instanceof Set) {
-        return equivSet(a, b, equiv);
-    }
-    if (a instanceof Map && b instanceof Map) {
-        return equivMap(a, b, equiv);
-    }
-    if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime();
-    }
-    if (a instanceof RegExp && b instanceof RegExp) {
-        return a.toString() === b.toString();
-    }
-    // NaN
-    return a !== a && b !== b;
+const equiv = (a, b) => {
+  let proto;
+  if (a === b) {
+    return true;
+  }
+  if (a != null) {
+    if (typeof a.equiv === FN) {
+      return a.equiv(b);
+    }
+  } else {
+    return a == b;
+  }
+  if (b != null) {
+    if (typeof b.equiv === FN) {
+      return b.equiv(a);
+    }
+  } else {
+    return a == b;
+  }
+  if (typeof a === STR || typeof b === STR) {
+    return false;
+  }
+  if ((proto = Object.getPrototypeOf(a), proto == null || proto === OBJP) && (proto = Object.getPrototypeOf(b), proto == null || proto === OBJP)) {
+    return !(a.__diff === false || b.__diff === false) && equivObject(a, b, equiv);
+  }
+  if (typeof a !== FN && a.length !== void 0 && typeof b !== FN && b.length !== void 0) {
+    return equivArrayLike(a, b, equiv);
+  }
+  if (a instanceof Set && b instanceof Set) {
+    return equivSet(a, b, equiv);
+  }
+  if (a instanceof Map && b instanceof Map) {
+    return equivMap(a, b, equiv);
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.toString() === b.toString();
+  }
+  return a !== a && b !== b;
+};
+export {
+  diffAttributes,
+  diffTree,
+  equiv,
+  releaseTree
 };