@design-edito/tools 0.1.32 → 0.1.34

package/chunks/chunk-HDALT7XM.js

@@ -1,620 +0,0 @@
-import {
-  toRef
-} from "./chunk-4RDW62CU.js";
-import {
-  toNumber
-} from "./chunk-F7XWUG2V.js";
-import {
-  toRecord
-} from "./chunk-F5YMP5WU.js";
-import {
-  toString
-} from "./chunk-DMDOCC72.js";
-import {
-  toText
-} from "./chunk-3PHPA25U.js";
-import {
-  toTransformer
-} from "./chunk-SMLKMOAX.js";
-import {
-  trim
-} from "./chunk-7IGZP4TV.js";
-import {
-  replace
-} from "./chunk-MDEDNPU5.js";
-import {
-  ref
-} from "./chunk-3X6RXJBR.js";
-import {
-  toArray
-} from "./chunk-Q52UJOBC.js";
-import {
-  split
-} from "./chunk-6CM2SWSX.js";
-import {
-  toBoolean
-} from "./chunk-SH3Y2I5P.js";
-import {
-  toElement
-} from "./chunk-S5XDYLJH.js";
-import {
-  toNodeList
-} from "./chunk-DBAJ66BR.js";
-import {
-  toNull
-} from "./chunk-RJ5E22H5.js";
-import {
-  append
-} from "./chunk-K3OQEJI3.js";
-import {
-  join
-} from "./chunk-RWUPHV54.js";
-import {
-  classList
-} from "./chunk-VRUJR6WR.js";
-import {
-  length
-} from "./chunk-S42P73SC.js";
-import {
-  print
-} from "./chunk-2DMWYLFG.js";
-import {
-  querySelector
-} from "./chunk-BNB7LEMQ.js";
-import {
-  push
-} from "./chunk-FWHUASVA.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 {
-  replaceInElement
-} from "./chunk-GBMHGF7P.js";
-import {
-  isInEnum
-} from "./chunk-E6MSDKON.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) => {
-  function fillOptions(options) {
-    const defaultOptions = {
-      generatorsMap: Transformers.defaultGeneratorsMap,
-      keyAttribute: "_name",
-      actionAttribute: "_action"
-    };
-    return {
-      ...defaultOptions,
-      ...options
-    };
-  }
-  _Tree.fillOptions = fillOptions;
-  function mergeValues(currentValue, incomingValue, mergeKey, initiatorTree) {
-    const { Element, Text, NodeList, document } = 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 = document.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 = document.createDocumentFragment();
-        frag.append(...Array.from(currentValue).map((e) => e.cloneNode(true)), incomingValue);
-        return frag.childNodes;
-      }
-      if (incomingValue instanceof NodeList) {
-        const frag = document.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 = document.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 merge(nodes, options = {}) {
-    const [first, ...rest] = nodes;
-    const defaultOptions = fillOptions({});
-    const actionAttribute = options?.actionAttribute ?? defaultOptions.actionAttribute;
-    const keyAttribute = options?.keyAttribute ?? defaultOptions.keyAttribute;
-    if (first === void 0) throw new Error("Expecting at least one node");
-    const { Text, Element, document } = getWindow();
-    const wrapper = document.createElement("div");
-    wrapper.append(first);
-    rest.forEach((node) => {
-      const current = wrapper.childNodes[0];
-      if (current === void 0) return wrapper.append(node);
-      if (node instanceof Text) return replaceElement(node, current);
-      const actionRaw = node.getAttribute(actionAttribute);
-      const action = isInEnum(Types.ReductionAction, actionRaw) ? actionRaw : Types.ReductionAction.REPLACE;
-      if (action === Types.ReductionAction.REPLACE) return replaceElement(node, current);
-      if (current instanceof Text) {
-        if (node instanceof Text) {
-          const appended = action === Types.ReductionAction.APPEND ? document.createTextNode(`${current.textContent}${node.textContent}`) : document.createTextNode(`${node.textContent}${current.textContent}`);
-          return replaceElement(appended, current);
-        }
-        return replaceElement(node, current);
-      }
-      if (node instanceof Text) return replaceElement(node, current);
-      return action === Types.ReductionAction.APPEND ? appendInElement(node, current) : prependInElement(node, current);
-    });
-    const wrapperChildren = Array.from(wrapper.childNodes);
-    const subpaths = /* @__PURE__ */ new Map();
-    let positionnedChildrenCount = 0;
-    wrapperChildren.forEach((child) => {
-      if (child instanceof Text) {
-        const childKey = positionnedChildrenCount;
-        const found = subpaths.get(childKey) ?? [];
-        found.push(child);
-        subpaths.set(childKey, found);
-        positionnedChildrenCount += 1;
-      } else {
-        const rawChildKey = child.getAttribute(keyAttribute);
-        const childKey = rawChildKey ?? positionnedChildrenCount;
-        const found = subpaths.get(childKey) ?? [];
-        found.push(child);
-        subpaths.set(childKey, found);
-        if (rawChildKey === null) {
-          positionnedChildrenCount += 1;
-        }
-      }
-    });
-    subpaths.forEach((nodes2) => {
-      if (nodes2.length < 2) return;
-      return merge(nodes2, {
-        actionAttribute,
-        keyAttribute
-      });
-    });
-    const wrapperFirstChild = wrapper.childNodes[0];
-    if (wrapperFirstChild === void 0) throw new Error("Empty output");
-    return wrapperFirstChild;
-    function replaceElement(replacer, element) {
-      element.parentNode?.replaceChild(replacer, element);
-    }
-    function isTextOrElement(node) {
-      return node instanceof Text || node instanceof Element;
-    }
-    function appendInElement(appender, element) {
-      const appenderChildren = Array.from(appender.childNodes).filter(isTextOrElement);
-      element.append(...appenderChildren);
-    }
-    function prependInElement(prepender, element) {
-      const prependerChildren = Array.from(prepender.childNodes).filter(isTextOrElement);
-      element.prepend(...prependerChildren);
-    }
-  }
-  _Tree.merge = merge;
-  function create(...args) {
-    return new Tree2(...args);
-  }
-  _Tree.create = create;
-  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
-};