@design-edito/tools 0.1.21 → 0.1.23

package/chunks/chunk-UODQZRY2.js

@@ -0,0 +1,620 @@
+import {
+  toNull
+} from "./chunk-RJ5E22H5.js";
+import {
+  toRecord
+} from "./chunk-F5YMP5WU.js";
+import {
+  toString
+} from "./chunk-DMDOCC72.js";
+import {
+  toRef
+} from "./chunk-4RDW62CU.js";
+import {
+  toTransformer
+} from "./chunk-SMLKMOAX.js";
+import {
+  toText
+} from "./chunk-3PHPA25U.js";
+import {
+  replace
+} from "./chunk-MDEDNPU5.js";
+import {
+  querySelector
+} from "./chunk-BNB7LEMQ.js";
+import {
+  split
+} from "./chunk-6CM2SWSX.js";
+import {
+  toArray
+} from "./chunk-Q52UJOBC.js";
+import {
+  toBoolean
+} from "./chunk-SH3Y2I5P.js";
+import {
+  toElement
+} from "./chunk-S5XDYLJH.js";
+import {
+  toNumber
+} from "./chunk-F7XWUG2V.js";
+import {
+  toNodeList
+} from "./chunk-DBAJ66BR.js";
+import {
+  append
+} from "./chunk-K3OQEJI3.js";
+import {
+  classList
+} from "./chunk-VRUJR6WR.js";
+import {
+  join
+} from "./chunk-RWUPHV54.js";
+import {
+  print
+} from "./chunk-2DMWYLFG.js";
+import {
+  length
+} from "./chunk-S42P73SC.js";
+import {
+  push
+} from "./chunk-FWHUASVA.js";
+import {
+  ref
+} from "./chunk-3X6RXJBR.js";
+import {
+  Cast
+} from "./chunk-QO64L4KB.js";
+import {
+  Serialize
+} from "./chunk-DRNK3RLE.js";
+import {
+  Crossenv
+} from "./chunk-3LVR6KZH.js";
+import {
+  Types
+} from "./chunk-7QMAYGNV.js";
+import {
+  Utils
+} from "./chunk-YEBOL67V.js";
+import {
+  insertNode
+} from "./chunk-XA4HVHJ4.js";
+import {
+  replaceInElement
+} from "./chunk-GBMHGF7P.js";
+import {
+  isRecord
+} from "./chunk-YDIBNEGA.js";
+
+// src/agnostic/html/hyper-json/transformers/transformSelected/index.ts
+var transformSelected = (callerTagName, ...args) => {
+  return Utils.toNamedTransformer(callerTagName, (currentValue, callerTree) => {
+    const { NodeList, Element, Text } = Crossenv.getWindow();
+    if (!(currentValue instanceof Element) && !(currentValue instanceof NodeList)) return Utils.makeTransformerError({
+      message: "Current value must be Element or NodeList",
+      input: currentValue
+    });
+    const [selector, ...transformerDescriptors] = args;
+    if (typeof selector !== "string" && !(selector instanceof Text)) return Utils.makeTransformerError({
+      message: "Selector argument must be string or text",
+      input: selector !== void 0 ? selector : "<undefined>"
+    });
+    if (transformerDescriptors.length === 0) return Utils.makeTransformerError("No transformer descriptor provided");
+    let transformers = [];
+    for (const descriptor of transformerDescriptors) {
+      const errorResponse = Utils.makeTransformerError({
+        message: "Transformer descriptors must be of shape { name: string, arguments: Value[] }",
+        input: descriptor
+      });
+      if (!isRecord(descriptor)) return errorResponse;
+      if (!("name" in descriptor) || typeof descriptor.name !== "string") return errorResponse;
+      if (!("arguments" in descriptor) || !Array.isArray(descriptor.arguments)) return errorResponse;
+      const { name, arguments: args2 } = descriptor;
+      const generator = callerTree.getGenerator(name);
+      if (generator === void 0) return Utils.makeTransformerError(`No transformer found under the name ${name}`);
+      transformers.push(generator(name, ...args2));
+    }
+    const elementInput = Cast.toElement(currentValue);
+    const strSelector = Cast.toString(selector);
+    const selected = Array.from(elementInput.querySelectorAll(strSelector));
+    const transformationErrors = [];
+    const transformed = selected.map((input) => {
+      const output = transformers.reduce((reduced, transformer, transformerPos) => {
+        const result = transformer(reduced, callerTree);
+        if (result.action === "REPLACE") return result.value;
+        else if (result.action === "MERGE") {
+          const merged = Tree.mergeValues(
+            reduced,
+            result.value,
+            transformerPos,
+            callerTree
+          );
+          return merged;
+        }
+        if (result.action === "ERROR") transformationErrors.push({
+          message: result.value,
+          transformerName: transformer.transformerName,
+          transformerPos,
+          transforming: reduced
+        });
+        return reduced;
+      }, input);
+      return { input, output };
+    });
+    if (transformationErrors.length !== 0) return Utils.makeTransformerError({
+      message: "Some nested transformers returned an error",
+      errors: transformationErrors
+    });
+    const nonElementTransformResult = transformed.find((item) => !(item.output instanceof Element));
+    if (nonElementTransformResult !== void 0) return Utils.makeTransformerError({
+      message: "Some transformations resulted in a non Element output",
+      inputElement: nonElementTransformResult.input,
+      outputValue: nonElementTransformResult.output
+    });
+    const transformMap = new Map(transformed.map((e) => [e.input, e.output]));
+    const elementOutput = replaceInElement(elementInput, transformMap);
+    return {
+      action: "REPLACE",
+      value: elementOutput
+    };
+  });
+};
+
+// src/agnostic/html/hyper-json/transformers/index.ts
+var Transformers;
+((Transformers2) => {
+  Transformers2.defaultGeneratorsMap = /* @__PURE__ */ new Map([
+    ["append", append],
+    ["classList", classList],
+    ["join", join],
+    ["length", length],
+    ["print", print],
+    ["push", push],
+    ["querySelector", querySelector],
+    ["ref", ref],
+    ["replace", replace],
+    ["split", split],
+    ["toArray", toArray],
+    ["toBoolean", toBoolean],
+    ["toElement", toElement],
+    ["toNodeList", toNodeList],
+    ["toNull", toNull],
+    ["toNumber", toNumber],
+    ["toRecord", toRecord],
+    ["toRef", toRef],
+    ["toString", toString],
+    ["toText", toText],
+    ["toTransformer", toTransformer],
+    ["transformSelected", transformSelected]
+    // ['trim', trim]
+  ]);
+})(Transformers || (Transformers = {}));
+
+// src/agnostic/html/hyper-json/tree/index.ts
+var getWindow = Crossenv.getWindow;
+var isElement = (node) => node.nodeType === getWindow().Node.ELEMENT_NODE;
+var isText = (node) => node.nodeType === getWindow().Node.TEXT_NODE;
+var Tree;
+((_Tree) => {
+  _Tree.defaultOptions = {
+    generatorsMap: Transformers.defaultGeneratorsMap,
+    keyAttribute: "_name",
+    actionAttribute: "_action"
+  };
+  function fillOptions(options) {
+    return {
+      ..._Tree.defaultOptions,
+      ...options
+    };
+  }
+  _Tree.fillOptions = fillOptions;
+  function mergeValues(currentValue, incomingValue, mergeKey, initiatorTree) {
+    const { Element, Text, NodeList, document: document2 } = getWindow();
+    if (typeof incomingValue === "function") {
+      const evaluated = incomingValue(currentValue, initiatorTree);
+      if (evaluated.action === null) return currentValue;
+      if (evaluated.action === "REPLACE") return evaluated.value;
+      if (evaluated.action === "ERROR") {
+        const errorMessage = `Tranformer error:
+from: ${incomingValue.transformerName}
+at: ${initiatorTree.pathString.slice(1)}/${mergeKey}
+message:`;
+        console.warn(errorMessage, evaluated.value);
+        return currentValue;
+      }
+      return mergeValues(
+        currentValue,
+        evaluated.value,
+        mergeKey,
+        initiatorTree
+      );
+    }
+    if (Array.isArray(currentValue)) {
+      if (typeof mergeKey === "string") return currentValue;
+      return [...currentValue, incomingValue];
+    }
+    if (currentValue === null || typeof currentValue === "boolean" || typeof currentValue === "number" || typeof currentValue === "string" || typeof currentValue === "function" || currentValue instanceof Text || currentValue instanceof Element) {
+      if (incomingValue === null || typeof incomingValue === "boolean" || typeof incomingValue === "number" || typeof incomingValue === "string" || Array.isArray(incomingValue) || isRecord(incomingValue)) {
+        return incomingValue;
+      }
+      const frag = document2.createDocumentFragment();
+      if (currentValue instanceof Element || currentValue instanceof Text) frag.append(currentValue.cloneNode(true));
+      else frag.append(`${currentValue}`);
+      if (incomingValue instanceof Element || incomingValue instanceof Text) {
+        frag.append(incomingValue.cloneNode(true));
+        return frag.childNodes;
+      }
+      frag.append(...Array.from(incomingValue).map((e) => e.cloneNode(true)));
+      return frag.childNodes;
+    }
+    if (currentValue instanceof NodeList) {
+      if (incomingValue instanceof Element || incomingValue instanceof Text) {
+        const frag = document2.createDocumentFragment();
+        frag.append(...Array.from(currentValue).map((e) => e.cloneNode(true)), incomingValue);
+        return frag.childNodes;
+      }
+      if (incomingValue instanceof NodeList) {
+        const frag = document2.createDocumentFragment();
+        frag.append(
+          ...Array.from(currentValue).map((e) => e.cloneNode(true)),
+          ...Array.from(incomingValue).map((e) => e.cloneNode(true))
+        );
+        return frag.childNodes;
+      }
+      if (incomingValue === null || typeof incomingValue === "string" || typeof incomingValue === "number" || typeof incomingValue === "boolean") {
+        const frag = document2.createDocumentFragment();
+        frag.append(...Array.from(currentValue).map((e) => e.cloneNode(true)), `${incomingValue}`);
+        return frag.childNodes;
+      }
+      if (Array.isArray(incomingValue)) return [
+        ...Array.from(currentValue),
+        ...incomingValue
+      ];
+      return { ...incomingValue };
+    }
+    if (typeof mergeKey === "number") return currentValue;
+    return {
+      ...currentValue,
+      [mergeKey]: incomingValue
+    };
+  }
+  _Tree.mergeValues = mergeValues;
+  function mergeRootElements(...rootElements) {
+    const output = document.createElement("data");
+    rootElements.forEach((rootElement) => {
+      const nodes = [...Array.from(rootElement.cloneNode(true).childNodes)];
+      output.append(...nodes);
+    });
+    return output;
+  }
+  _Tree.mergeRootElements = mergeRootElements;
+  function reduceRootElement(rootElement, options) {
+    const { Element, Text, document: document2 } = getWindow();
+    const _options = fillOptions(options ?? {});
+    const { keyAttribute, actionAttribute } = _options;
+    const outputRootElement = rootElement.cloneNode();
+    let positionnedChildrenCount = 0;
+    const childrenMap = /* @__PURE__ */ new Map();
+    const children = Array.from(rootElement.childNodes).filter((e) => {
+      if (e instanceof Element) return true;
+      if (e instanceof Text) return true;
+      return false;
+    });
+    children.forEach((child) => {
+      if (child instanceof Text) {
+        childrenMap.set(positionnedChildrenCount, child);
+        outputRootElement.appendChild(child);
+        positionnedChildrenCount += 1;
+        return;
+      }
+      const foundKey = child.getAttribute(keyAttribute);
+      const actionType = child.getAttribute(actionAttribute);
+      const targetKey = foundKey ?? positionnedChildrenCount;
+      if (foundKey === null) {
+        positionnedChildrenCount += 1;
+      }
+      const existingElement = childrenMap.get(targetKey);
+      if (existingElement === void 0) {
+        childrenMap.set(targetKey, child);
+        outputRootElement.appendChild(child);
+        return;
+      }
+      if (actionType === Types.ReductionAction.APPEND || actionType === Types.ReductionAction.PREPEND) {
+        if (existingElement instanceof Text) {
+          if (child instanceof Text) {
+            const newTextNode = actionType === Types.ReductionAction.APPEND ? document2.createTextNode(`${existingElement.textContent}${child.textContent}`) : document2.createTextNode(`${child.textContent}${existingElement.textContent}`);
+            childrenMap.set(targetKey, newTextNode);
+            insertNode(newTextNode, "after", existingElement);
+            existingElement.remove();
+            return;
+          } else {
+            childrenMap.set(targetKey, child);
+            insertNode(child, "after", existingElement);
+            existingElement.remove();
+            return;
+          }
+        } else {
+          if (child instanceof Text) {
+            childrenMap.set(targetKey, child);
+            insertNode(child, "after", existingElement);
+            existingElement.remove();
+          } else {
+            if (actionType === Types.ReductionAction.APPEND) existingElement.append(...Array.from(child.childNodes));
+            else existingElement.prepend(...Array.from(child.childNodes));
+          }
+        }
+      }
+      insertNode(child, "after", existingElement);
+      existingElement.remove();
+      childrenMap.set(targetKey, child);
+    });
+    const outputChildren = Array.from(outputRootElement.childNodes);
+    outputChildren.forEach((outputChild) => {
+      if (outputChild instanceof Element) {
+        const reduced = reduceRootElement(outputChild);
+        insertNode(reduced, "after", outputChild);
+        outputChild.remove();
+      }
+    });
+    return outputRootElement;
+  }
+  _Tree.reduceRootElement = reduceRootElement;
+  class Tree2 {
+    node;
+    name;
+    parent;
+    root;
+    isRoot;
+    path;
+    pathString;
+    tagName;
+    attributes;
+    subtrees = /* @__PURE__ */ new Map();
+    children;
+    type;
+    generators;
+    keyAttribute;
+    actionAttribute;
+    constructor(node, parentOrOptions, pathFromParent, options) {
+      this.resolve = this.resolve.bind(this);
+      this.getGenerator = this.getGenerator.bind(this);
+      this.initValue = this.initValue.bind(this);
+      this.getInnerValue = this.getInnerValue.bind(this);
+      this.wrapInnerValue = this.wrapInnerValue.bind(this);
+      this.setCache = this.setCache.bind(this);
+      this.getPerfCounters = this.getPerfCounters.bind(this);
+      this.printPerfCounters = this.printPerfCounters.bind(this);
+      this.pushToEvalCallStack = this.pushToEvalCallStack.bind(this);
+      this.flushEvalCallStack = this.flushEvalCallStack.bind(this);
+      this.evaluate = this.evaluate.bind(this);
+      const { Element, Text } = getWindow();
+      const _node = node;
+      const _parent = parentOrOptions instanceof Tree2 ? parentOrOptions : void 0;
+      this.node = _node;
+      this.parent = _parent ?? null;
+      this.root = this.parent === null ? this : this.parent.root;
+      this.isRoot = this.root === this;
+      const _options = options ?? parentOrOptions instanceof Tree2 ? fillOptions({}) : fillOptions(parentOrOptions ?? {});
+      this.keyAttribute = _options.keyAttribute;
+      this.actionAttribute = _options.actionAttribute;
+      this.generators = this.isRoot ? _options.generatorsMap : this.root.generators;
+      this.name = this.node instanceof Element ? this.node.getAttribute(this.keyAttribute) : null;
+      const _pathFromParent = pathFromParent !== void 0 ? pathFromParent : void 0;
+      if (this.parent === null) this.path = [];
+      else if (_pathFromParent === void 0) {
+        this.path = [...this.parent.path, 0];
+      } else {
+        this.path = [...this.parent.path, _pathFromParent];
+      }
+      this.pathString = `/${this.path.join("/")}`;
+      this.tagName = node instanceof Element ? node.tagName.toLowerCase() : null;
+      this.attributes = isElement(node) ? Array.from(node.attributes) : null;
+      const { childNodes } = node;
+      let positionnedChildrenCount = 0;
+      const mutableSubtrees = /* @__PURE__ */ new Map();
+      Array.from(childNodes).filter((node2, _, nodes) => {
+        if (isElement(node2)) return true;
+        if (isText(node2)) {
+          const hasContent = (node2.textContent ?? "").trim() !== "";
+          if (hasContent) return true;
+          if (nodes.some((n) => n instanceof Element)) return false;
+          return true;
+        }
+        return false;
+      }).forEach((childNode) => {
+        if (childNode instanceof Text) {
+          mutableSubtrees.set(
+            positionnedChildrenCount,
+            new Tree2(childNode, this, positionnedChildrenCount)
+          );
+          positionnedChildrenCount += 1;
+        } else {
+          const propertyName = childNode.getAttribute(this.keyAttribute);
+          if (propertyName === null) {
+            mutableSubtrees.set(
+              positionnedChildrenCount,
+              new Tree2(childNode, this, positionnedChildrenCount)
+            );
+            positionnedChildrenCount += 1;
+          } else {
+            mutableSubtrees.set(
+              propertyName,
+              new Tree2(childNode, this, propertyName)
+            );
+          }
+        }
+      });
+      this.subtrees = mutableSubtrees;
+      this.children = Array.from(this.subtrees.values());
+      if (this.tagName === null) {
+        this.type = "text";
+      } else if (this.tagName === Types.TyperTagName.NULL) {
+        this.type = "null";
+      } else if (this.tagName === Types.TyperTagName.BOOLEAN) {
+        this.type = "boolean";
+      } else if (this.tagName === Types.TyperTagName.NUMBER) {
+        this.type = "number";
+      } else if (this.tagName === Types.TyperTagName.STRING) {
+        this.type = "string";
+      } else if (this.tagName === Types.TyperTagName.TEXT) {
+        this.type = "text";
+      } else if (this.tagName === Types.TyperTagName.NODELIST) {
+        this.type = "nodelist";
+      } else if (this.tagName === Types.TyperTagName.ARRAY) {
+        this.type = "array";
+      } else if (this.tagName === Types.TyperTagName.RECORD) {
+        this.type = "record";
+      } else if (this.generators.get(this.tagName) !== void 0) {
+        this.type = "transformer";
+      } else {
+        this.type = "element";
+      }
+    }
+    resolve = function(path) {
+      let currentTree = this.root;
+      for (const chunk of path) {
+        const { subtrees } = currentTree;
+        const foundSubtree = subtrees.get(chunk);
+        if (foundSubtree === void 0) return void 0;
+        currentTree = foundSubtree;
+      }
+      return currentTree;
+    };
+    getGenerator(name) {
+      return this.generators.get(name);
+    }
+    initValue() {
+      const { type } = this;
+      let currentValue;
+      if (type === "null") {
+        currentValue = null;
+      } else if (type === "boolean") {
+        currentValue = false;
+      } else if (type === "number") {
+        currentValue = 0;
+      } else if (type === "string") {
+        currentValue = "";
+      } else if (type === "text") {
+        currentValue = this.node.textContent;
+      } else if (type === "element") {
+        currentValue = getWindow().document.createDocumentFragment().childNodes;
+      } else if (type === "nodelist") {
+        currentValue = getWindow().document.createDocumentFragment().childNodes;
+      } else if (type === "array") {
+        currentValue = [];
+      } else if (type === "record") {
+        currentValue = {};
+      } else if (type === "transformer") {
+        currentValue = [];
+      } else {
+        currentValue = null;
+      }
+      return currentValue;
+    }
+    getInnerValue(initialValue) {
+      const { subtrees } = this;
+      const innerValue = Array.from(subtrees.entries()).reduce((currentValue, [subpath, subtree]) => mergeValues(
+        currentValue,
+        subtree.evaluate(),
+        subpath,
+        this
+      ), initialValue);
+      return innerValue;
+    }
+    wrapInnerValue(innerValue) {
+      const { type } = this;
+      if (type === "transformer") {
+        const transformerName = this.tagName;
+        if (transformerName === null) return innerValue;
+        const generator = this.getGenerator(transformerName);
+        if (generator === void 0) return innerValue;
+        const transformer = Array.isArray(innerValue) ? generator(transformerName, ...innerValue) : generator(transformerName, innerValue);
+        return transformer;
+      }
+      if (type === "null") return Cast.toNull();
+      if (type === "boolean") return Cast.toBoolean(innerValue);
+      if (type === "number") return Cast.toNumber(innerValue);
+      if (type === "string") return Cast.toString(innerValue);
+      if (type === "array") return Cast.toArray(innerValue);
+      if (type === "record") return Cast.toRecord(innerValue);
+      if (type === "text") return Cast.toText(innerValue);
+      if (type === "element") return Cast.toElement(innerValue);
+      if (type === "nodelist") return Cast.toNodeList(innerValue);
+      return Cast.toNull();
+    }
+    cache = void 0;
+    setCache(value) {
+      this.cache = Serialize.serialize(value);
+    }
+    perfCounters = {
+      computed: 0,
+      computeTime: 0,
+      computeTimeAvg: 0,
+      cached: 0,
+      cacheTime: 0,
+      cacheTimeAvg: 0,
+      totalTime: 0
+    };
+    getPerfCounters() {
+      const { subtrees } = this;
+      const subCounters = [];
+      subCounters.push([this.pathString, this.perfCounters]);
+      subtrees.forEach((subtree) => subCounters.push(...subtree.getPerfCounters()));
+      return subCounters;
+    }
+    printPerfCounters() {
+      const perfCounters = this.getPerfCounters().sort((a, b) => b[1].totalTime - a[1].totalTime).map((e) => ({
+        path: e[0],
+        totalMs: e[1].totalTime,
+        computeMs: e[1].computeTime,
+        cacheMs: e[1].cacheTime,
+        ops: `${e[1].computed}/${e[1].cached}`
+      }));
+      console.table(perfCounters);
+    }
+    callstack = [];
+    pushToEvalCallStack(path) {
+      this.callstack.push(path);
+      this.parent?.pushToEvalCallStack(path);
+    }
+    flushEvalCallStack() {
+      this.callstack.length = 0;
+    }
+    evaluate() {
+      const start = Date.now();
+      const circularPatternDetected = this.callstack.some((p) => p.startsWith(this.pathString));
+      if (circularPatternDetected) throw new Error(`Circular reference pattern detected @ ${this.pathString}`);
+      this.pushToEvalCallStack(this.pathString);
+      const { perfCounters, cache } = this;
+      if (cache !== void 0) {
+        const deserialized = Serialize.deserialize(cache);
+        const end2 = Date.now();
+        const time2 = end2 - start;
+        perfCounters.cached++;
+        perfCounters.cacheTime += time2;
+        perfCounters.cacheTimeAvg = perfCounters.cacheTime / perfCounters.cached;
+        perfCounters.totalTime = perfCounters.computeTime + perfCounters.cacheTime;
+        return deserialized;
+      }
+      const init = this.initValue();
+      const inner = this.getInnerValue(init);
+      const wrapped = this.wrapInnerValue(inner);
+      this.setCache(wrapped);
+      const end = Date.now();
+      const time = end - start;
+      perfCounters.computed++;
+      perfCounters.computeTime += time;
+      perfCounters.computeTimeAvg = perfCounters.computeTime / perfCounters.computed;
+      perfCounters.totalTime = perfCounters.computeTime + perfCounters.cacheTime;
+      this.flushEvalCallStack();
+      return wrapped;
+    }
+  }
+  _Tree.Tree = Tree2;
+})(Tree || (Tree = {}));
+
+export {
+  Tree,
+  transformSelected,
+  Transformers
+};

package/chunks/chunk-UOULDS6J.js

@@ -0,0 +1,33 @@
+import {
+  Cast,
+  Transformers,
+  Tree
+} from "./chunk-ILEM73XB.js";
+import {
+  Serialize
+} from "./chunk-DRNK3RLE.js";
+import {
+  Crossenv
+} from "./chunk-3LVR6KZH.js";
+import {
+  Utils
+} from "./chunk-F7EVMWVG.js";
+import {
+  Types
+} from "./chunk-7QMAYGNV.js";
+
+// src/agnostic/html/hyper-json/index.ts
+var HyperJson;
+((HyperJson2) => {
+  HyperJson2.Cast = Cast;
+  HyperJson2.Crossenv = Crossenv;
+  HyperJson2.Serialize = Serialize;
+  HyperJson2.Transformers = Transformers;
+  HyperJson2.Tree = Tree;
+  HyperJson2.Types = Types;
+  HyperJson2.Utils = Utils;
+})(HyperJson || (HyperJson = {}));
+
+export {
+  HyperJson
+};