@design-edito/tools 0.3.3 → 0.3.4

package/agnostic/html/hyper-json/transformer/index.js

@@ -1,9 +1,127 @@
-import {
-  Transformer
-} from "../../../../chunks/chunk-JVMFT3IT.js";
-import "../../../../chunks/chunk-RW7VAKJW.js";
-import "../../../../chunks/chunk-QEKI6WGQ.js";
-import "../../../../chunks/chunk-XCBH6NLF.js";
+// src/agnostic/html/hyper-json/transformer/index.ts
+import * as Outcome from "../../../misc/outcome/index.js";
+import { Method } from "../method/index.js";
+var Transformer = class _Transformer {
+  name;
+  mode;
+  innerValue;
+  typeChecks;
+  func;
+  sourceTree;
+  static clone(transformer) {
+    const { name, mode, innerValue, typeChecks, func, sourceTree } = transformer;
+    return new _Transformer(name, mode, innerValue, typeChecks, func, sourceTree);
+  }
+  constructor(name, mode, innerValue, typeChecks, func, sourceTree) {
+    this.apply = this.apply.bind(this);
+    this.getMainAndArgsValue = this.getMainAndArgsValue.bind(this);
+    this.makeMainValueError = this.makeMainValueError.bind(this);
+    this.makeArgsValueError = this.makeArgsValueError.bind(this);
+    this.makeTransformationError = this.makeTransformationError.bind(this);
+    this.toMethod = this.toMethod.bind(this);
+    this.name = name;
+    this.mode = mode;
+    this.innerValue = innerValue;
+    this.typeChecks = typeChecks;
+    this.func = func;
+    this.sourceTree = sourceTree;
+  }
+  getMainAndArgsValue(outerValue) {
+    const { mode, innerValue } = this;
+    let mainValue;
+    let argsValue;
+    if (mode === "isolation") {
+      if (Array.isArray(innerValue)) {
+        innerValue;
+        mainValue = innerValue.at(0) ?? [];
+        argsValue = innerValue.slice(1);
+      } else {
+        mainValue = innerValue;
+        argsValue = [];
+      }
+    } else {
+      mainValue = outerValue;
+      argsValue = Array.isArray(innerValue) ? innerValue : [innerValue];
+    }
+    return { mainValue, argsValue };
+  }
+  makeMainValueError(mainValue, argsValue, expected, found, details) {
+    const { name, sourceTree } = this;
+    return {
+      message: "BAD_MAIN_VALUE",
+      expected,
+      found,
+      details,
+      transformerName: name,
+      path: sourceTree.pathString,
+      mainValue,
+      argsValue
+    };
+  }
+  makeArgsValueError(mainValue, argsValue, expected, found, position, details) {
+    const { name, sourceTree } = this;
+    return {
+      message: "BAD_ARGUMENTS_VALUE",
+      expected,
+      found,
+      position,
+      details,
+      transformerName: name,
+      path: sourceTree.pathString,
+      mainValue,
+      argsValue
+    };
+  }
+  makeTransformationError(mainValue, argsValue, details) {
+    const { name, sourceTree } = this;
+    return {
+      message: "TRANSFORMATION_ERROR",
+      details,
+      transformerName: name,
+      path: sourceTree.pathString,
+      mainValue,
+      argsValue
+    };
+  }
+  apply(outerValue) {
+    const {
+      getMainAndArgsValue,
+      typeChecks,
+      makeMainValueError,
+      makeArgsValueError,
+      makeTransformationError,
+      func
+    } = this;
+    const { mainValue, argsValue } = getMainAndArgsValue(outerValue);
+    const mainChecked = typeChecks.mainValue(mainValue);
+    if (!mainChecked.success) return Outcome.makeFailure(makeMainValueError(
+      mainValue,
+      argsValue,
+      mainChecked.error.expected,
+      mainChecked.error.found
+    ));
+    const validMainValue = mainChecked.payload;
+    const argsChecked = typeChecks.argsValue(argsValue, validMainValue);
+    if (!argsChecked.success) return Outcome.makeFailure(makeArgsValueError(
+      mainValue,
+      argsValue,
+      argsChecked.error.expected,
+      argsChecked.error.found,
+      argsChecked.error.position
+    ));
+    const validArgsValue = argsChecked.payload;
+    const called = func(validMainValue, validArgsValue, { name: this.name, sourceTree: this.sourceTree });
+    if (!called.success) return Outcome.makeFailure(makeTransformationError(
+      mainValue,
+      argsValue,
+      called.error
+    ));
+    return Outcome.makeSuccess(called.payload);
+  }
+  toMethod() {
+    return new Method(this);
+  }
+};
 export {
   Transformer
 };

package/agnostic/html/hyper-json/tree/index.js

@@ -1,25 +1,426 @@
-import {
-  Tree
-} from "../../../../chunks/chunk-TAURL7GX.js";
-import "../../../../chunks/chunk-AKNR3U25.js";
-import "../../../../chunks/chunk-ZKIQ753F.js";
-import "../../../../chunks/chunk-USIYKRNX.js";
-import "../../../../chunks/chunk-XEQ2PBT2.js";
-import "../../../../chunks/chunk-DUCLFPGE.js";
-import "../../../../chunks/chunk-HEY7J6GI.js";
-import "../../../../chunks/chunk-JVMFT3IT.js";
-import "../../../../chunks/chunk-RW7VAKJW.js";
-import "../../../../chunks/chunk-XA4HVHJ4.js";
-import "../../../../chunks/chunk-XNF5MLCQ.js";
-import "../../../../chunks/chunk-E6MSDKON.js";
-import "../../../../chunks/chunk-YDIBNEGA.js";
-import "../../../../chunks/chunk-EPUHVR7J.js";
-import "../../../../chunks/chunk-6XL25OZX.js";
-import "../../../../chunks/chunk-QEKI6WGQ.js";
-import "../../../../chunks/chunk-ROWPCMQY.js";
-import "../../../../chunks/chunk-FENXVJYO.js";
-import "../../../../chunks/chunk-HQLRJ7XW.js";
-import "../../../../chunks/chunk-XCBH6NLF.js";
+// src/agnostic/html/hyper-json/tree/index.ts
+import * as Window from "../../../misc/crossenv/window/index.js";
+import { trimStart, trimEnd } from "../../../strings/trim/index.js";
+import { Serialize } from "../serialize/index.js";
+import { Transformer } from "../transformer/index.js";
+import { Utils } from "../utils/index.js";
+import { Cast } from "../cast/index.js";
+import { any } from "../smart-tags/isolated/any/index.js";
+import { array } from "../smart-tags/isolated/array/index.js";
+import { boolean } from "../smart-tags/isolated/boolean/index.js";
+import { element } from "../smart-tags/isolated/element/index.js";
+import { get as get2 } from "../smart-tags/isolated/get/index.js";
+import { global } from "../smart-tags/isolated/global/index.js";
+import { guess } from "../smart-tags/isolated/guess/index.js";
+import { nodelist } from "../smart-tags/isolated/nodelist/index.js";
+import { nullFunc } from "../smart-tags/isolated/null/index.js";
+import { number } from "../smart-tags/isolated/number/index.js";
+import { record } from "../smart-tags/isolated/record/index.js";
+import { ref } from "../smart-tags/isolated/ref/index.js";
+import { string } from "../smart-tags/isolated/string/index.js";
+import { text } from "../smart-tags/isolated/text/index.js";
+import { add } from "../smart-tags/coalesced/add/index.js";
+import { addclass } from "../smart-tags/coalesced/addclass/index.js";
+import { and } from "../smart-tags/coalesced/and/index.js";
+import { append } from "../smart-tags/coalesced/append/index.js";
+import { at } from "../smart-tags/coalesced/at/index.js";
+import { call } from "../smart-tags/coalesced/call/index.js";
+import { clone } from "../smart-tags/coalesced/clone/index.js";
+import { deleteproperties } from "../smart-tags/coalesced/deleteproperties/index.js";
+import { equals } from "../smart-tags/coalesced/equals/index.js";
+import { getattribute } from "../smart-tags/coalesced/getattribute/index.js";
+import { getproperties } from "../smart-tags/coalesced/getproperties/index.js";
+import { getproperty } from "../smart-tags/coalesced/getproperty/index.js";
+import { hjparse } from "../smart-tags/coalesced/hjparse/index.js";
+import { hjstringify } from "../smart-tags/coalesced/hjstringify/index.js";
+import { ifFunc } from "../smart-tags/coalesced/if/index.js";
+import { initialize } from "../smart-tags/coalesced/initialize/index.js";
+import { join } from "../smart-tags/coalesced/join/index.js";
+import { length } from "../smart-tags/coalesced/length/index.js";
+import { map } from "../smart-tags/coalesced/map/index.js";
+import { negate } from "../smart-tags/coalesced/negate/index.js";
+import { notrailing } from "../smart-tags/coalesced/notrailing/index.js";
+import { or } from "../smart-tags/coalesced/or/index.js";
+import { pickrandom } from "../smart-tags/coalesced/pickrandom/index.js";
+import { print } from "../smart-tags/coalesced/print/index.js";
+import { populate } from "../smart-tags/coalesced/populate/index.js";
+import { push } from "../smart-tags/coalesced/push/index.js";
+import { pusheach } from "../smart-tags/coalesced/pusheach/index.js";
+import { recordtoarray } from "../smart-tags/coalesced/recordtoarray/index.js";
+import { removeattribute } from "../smart-tags/coalesced/removeattribute/index.js";
+import { removeclass } from "../smart-tags/coalesced/removeclass/index.js";
+import { renameproperty } from "../smart-tags/coalesced/renameproperty/index.js";
+import { replace } from "../smart-tags/coalesced/replace/index.js";
+import { select } from "../smart-tags/coalesced/select/index.js";
+import { set } from "../smart-tags/coalesced/set/index.js";
+import { setattribute } from "../smart-tags/coalesced/setattribute/index.js";
+import { setproperty } from "../smart-tags/coalesced/setproperty/index.js";
+import { sorton } from "../smart-tags/coalesced/sorton/index.js";
+import { split } from "../smart-tags/coalesced/split/index.js";
+import { spread } from "../smart-tags/coalesced/spread/index.js";
+import { toarray } from "../smart-tags/coalesced/toarray/index.js";
+import { toboolean } from "../smart-tags/coalesced/toboolean/index.js";
+import { toelement } from "../smart-tags/coalesced/toelement/index.js";
+import { toggleclass } from "../smart-tags/coalesced/toggleclass/index.js";
+import { tonodelist } from "../smart-tags/coalesced/tonodelist/index.js";
+import { tonull } from "../smart-tags/coalesced/tonull/index.js";
+import { tonumber } from "../smart-tags/coalesced/tonumber/index.js";
+import { torecord } from "../smart-tags/coalesced/torecord/index.js";
+import { toref } from "../smart-tags/coalesced/toref/index.js";
+import { tostring } from "../smart-tags/coalesced/tostring/index.js";
+import { totext } from "../smart-tags/coalesced/totext/index.js";
+import { transformselected } from "../smart-tags/coalesced/transformselected/index.js";
+import { trim } from "../smart-tags/coalesced/trim/index.js";
+var Tree;
+((_Tree) => {
+  class Tree2 {
+    node;
+    options;
+    parent;
+    parents;
+    pathFromParent;
+    root;
+    isRoot;
+    path;
+    pathString;
+    attributes;
+    isMethod;
+    tagName;
+    smartTagName;
+    smartTagsRegister;
+    smartTagData;
+    mode;
+    isPreserved;
+    isLiteral;
+    isolationInitType;
+    subtrees = /* @__PURE__ */ new Map();
+    static actionAttribute = "_action";
+    static keyAttribute = "_key";
+    static methodAttribute = "_method";
+    static initAttribute = "_init";
+    static modeAttribute = "_mode";
+    static preserveAttribute = "_preserve";
+    static literalAttribute = "_literal";
+    static defaultOptions = {
+      globalObject: {},
+      logger: null,
+      loggerThread: "hyperjson"
+    };
+    static from(nodes, options) {
+      const merged = Utils.Tree.mergeNodes(nodes);
+      return new Tree2(merged, null, null, options);
+    }
+    constructor(node, parent, pathFromParent, options) {
+      const { Element, Text, document } = Window.get();
+      this.resolve = this.resolve.bind(this);
+      this.setVariable = this.setVariable.bind(this);
+      this.getVariable = this.getVariable.bind(this);
+      this.performSafetyChecks = this.performSafetyChecks.bind(this);
+      this.computeValue = this.computeValue.bind(this);
+      this.enforceEvaluation = this.enforceEvaluation.bind(this);
+      this.getCachedValue = this.getCachedValue.bind(this);
+      this.setCachedValue = this.setCachedValue.bind(this);
+      this.evaluate = this.evaluate.bind(this);
+      this.node = node;
+      this.options = options ?? Tree2.defaultOptions;
+      if (parent !== null && pathFromParent !== null) {
+        this.isRoot = false;
+        this.parent = parent;
+        this.parents = [parent, ...parent.parents];
+        this.pathFromParent = pathFromParent;
+        this.root = this.parent.root;
+      } else {
+        this.isRoot = true;
+        this.parent = null;
+        this.parents = [];
+        this.pathFromParent = null;
+        this.root = this;
+      }
+      this.path = this.isRoot ? [] : [...this.parent.path, this.pathFromParent];
+      this.pathString = `/${this.path.join("/")}`;
+      this.attributes = node instanceof Element ? Array.from(node.attributes) : null;
+      if (node instanceof Element) {
+        const rawTagName = node.tagName.trim().toLowerCase();
+        const hasTrailingUnderscore = rawTagName.endsWith("_");
+        const hasMethodAttribute = this.attributes?.find((attr) => attr.name === Tree2.methodAttribute) !== void 0;
+        const isMethod = hasTrailingUnderscore || hasMethodAttribute;
+        this.isMethod = isMethod;
+        this.tagName = rawTagName;
+        this.smartTagName = hasTrailingUnderscore ? rawTagName.replace(/_+$/g, "") : rawTagName;
+      } else {
+        this.isMethod = false;
+        this.tagName = null;
+        this.smartTagName = null;
+      }
+      this.smartTagsRegister = new Map([
+        any,
+        array,
+        boolean,
+        element,
+        get2,
+        global,
+        guess,
+        nodelist,
+        nullFunc,
+        number,
+        record,
+        ref,
+        string,
+        text,
+        add,
+        addclass,
+        and,
+        append,
+        at,
+        call,
+        clone,
+        deleteproperties,
+        equals,
+        getattribute,
+        getproperties,
+        getproperty,
+        hjparse,
+        hjstringify,
+        ifFunc,
+        initialize,
+        join,
+        length,
+        map,
+        negate,
+        notrailing,
+        or,
+        pickrandom,
+        print,
+        populate,
+        push,
+        pusheach,
+        recordtoarray,
+        removeattribute,
+        removeclass,
+        renameproperty,
+        replace,
+        select,
+        set,
+        setattribute,
+        spread,
+        setproperty,
+        sorton,
+        split,
+        toarray,
+        toboolean,
+        toelement,
+        toggleclass,
+        tonodelist,
+        tonull,
+        tonumber,
+        toref,
+        torecord,
+        tostring,
+        totext,
+        transformselected,
+        trim
+      ]);
+      if (this.smartTagName === null) {
+        this.smartTagData = null;
+      } else {
+        this.smartTagData = this.smartTagsRegister.get(this.smartTagName) ?? null;
+      }
+      const hasModeAttribute = this.attributes?.find((attr) => {
+        return attr.name === Tree2.modeAttribute && Utils.Tree.TypeChecks.isTreeMode(attr.value);
+      });
+      this.mode = hasModeAttribute?.value ?? this.smartTagData?.defaultMode ?? "isolation";
+      const hasLiteralAttribute = this.attributes?.find((attr) => attr.name === Tree2.literalAttribute) !== void 0;
+      this.isLiteral = hasLiteralAttribute;
+      const hasPreservedAttribute = this.attributes?.find((attr) => attr.name === Tree2.preserveAttribute) !== void 0;
+      this.isPreserved = hasPreservedAttribute;
+      const hasInitAttribute = this.attributes?.find((attr) => {
+        if (attr.name !== Tree2.initAttribute) return false;
+        const val = attr.value.trim().toLowerCase();
+        if (!Utils.Tree.TypeChecks.isValueTypeName(val)) return false;
+        if (val === "transformer") return false;
+        if (val === "method") return false;
+        return true;
+      });
+      if (this.mode === "coalescion") {
+        this.isolationInitType = "array";
+      } else {
+        const initAttributeValue = hasInitAttribute?.value;
+        if (initAttributeValue !== void 0) {
+          this.isolationInitType = initAttributeValue;
+        } else if (this.smartTagData !== null) {
+          this.isolationInitType = this.smartTagData?.isolationInitType ?? "array";
+        } else {
+          this.isolationInitType = "nodelist";
+        }
+      }
+      const { childNodes } = node;
+      let positionnedChildrenCount = 0;
+      const mutableSubtrees = /* @__PURE__ */ new Map();
+      Array.from(childNodes).filter((child, _, childNodes2) => {
+        if (child instanceof Element) return true;
+        if (child instanceof Text) return true;
+        return false;
+      }).reduce((reduced, child) => {
+        if (reduced.length === 0) return [child];
+        if (child instanceof Element) return [...reduced, child];
+        const lastReducedItem = reduced[reduced.length - 1];
+        if (lastReducedItem instanceof Element) return [...reduced, child];
+        const lastReducedTrimmed = trimEnd(lastReducedItem.textContent ?? "");
+        const childTrimmed = trimStart(child.textContent ?? "");
+        const merged = document.createTextNode(`${lastReducedTrimmed}${childTrimmed}`);
+        const returned = [...reduced];
+        returned.pop();
+        returned.push(merged);
+        return returned;
+      }, []).filter((child) => {
+        if (child instanceof Element) return true;
+        const textContent = child.textContent ?? "";
+        return textContent.trim() !== "";
+      }).forEach((childNode) => {
+        if (childNode instanceof Text) {
+          const rawTextContent = childNode.textContent ?? "";
+          const textContent = rawTextContent.replace(/^\s*\n+\s*/, "").replace(/\s*\n+\s*$/, "");
+          const returnedChildNode = document.createTextNode(textContent);
+          mutableSubtrees.set(
+            positionnedChildrenCount,
+            new Tree2(returnedChildNode, this, positionnedChildrenCount, this.options)
+          );
+          positionnedChildrenCount += 1;
+        } else {
+          const propertyName = childNode.getAttribute(Tree2.keyAttribute);
+          if (propertyName === null) {
+            mutableSubtrees.set(
+              positionnedChildrenCount,
+              new Tree2(childNode, this, positionnedChildrenCount, this.options)
+            );
+            positionnedChildrenCount += 1;
+          } else {
+            mutableSubtrees.set(
+              propertyName,
+              new Tree2(childNode, this, propertyName, this.options)
+            );
+          }
+        }
+      });
+      this.subtrees = mutableSubtrees;
+    }
+    resolve = function(path) {
+      let currentTree = this;
+      for (const chunk of path) {
+        if (chunk === ".") continue;
+        if (chunk === "..") {
+          currentTree = currentTree.parent ?? this;
+          continue;
+        }
+        const { subtrees } = currentTree;
+        const foundSubtree = subtrees.get(chunk);
+        if (foundSubtree === void 0) return void 0;
+        currentTree = foundSubtree;
+      }
+      return currentTree;
+    };
+    // [WIP] variablesStore is actually only used on root Tree
+    variablesStore = /* @__PURE__ */ new Map();
+    setVariable(name, value) {
+      const { root, isRoot, variablesStore } = this;
+      if (!isRoot) return root.setVariable(name, value);
+      variablesStore.set(name, Serialize.serialize(value));
+    }
+    getVariable(name) {
+      const { root } = this;
+      const found = root.variablesStore.get(name);
+      if (found === void 0) return void 0;
+      const deserialized = Serialize.deserialize(found);
+      if (deserialized instanceof Transformer) throw "A transformer should not be stored as a variable, this happening denotes an implementation error.";
+      return deserialized;
+    }
+    performSafetyChecks() {
+      const { node, smartTagData, isMethod, mode, isRoot } = this;
+      const { Text } = Window.get();
+      if (node instanceof Text || smartTagData === null) {
+        if (isMethod) throw new Error(`A Text or HTMLElement node cannot be used as a method @ ${this.pathString}`);
+        if (mode === "coalescion") throw new Error(`A Text or HTMLElement node cannot be used in coalescion mode @ ${this.pathString}`);
+      }
+      if (isRoot && mode === "coalescion") throw new Error(`The root node cannot be used in coalescion mode @ ${this.pathString}`);
+    }
+    computeValue() {
+      const {
+        isolationInitType,
+        subtrees,
+        node,
+        smartTagData,
+        isMethod,
+        mode,
+        performSafetyChecks
+      } = this;
+      performSafetyChecks();
+      const { Text } = Window.get();
+      if (node instanceof Text) return node.cloneNode(true);
+      const initialInnerValue = Utils.Tree.getInitialValueFromTypeName(isolationInitType);
+      const innerValue = Array.from(subtrees).reduce((reduced, [subpath, subtree]) => {
+        const subvalue = subtree.evaluate();
+        const coalesced = Utils.coalesceValues(reduced, subpath, subvalue);
+        return coalesced;
+      }, initialInnerValue);
+      if (smartTagData === null) {
+        const nodelist2 = Cast.toNodeList(innerValue);
+        const clone2 = node.cloneNode();
+        clone2.append(...Array.from(nodelist2));
+        return clone2;
+      }
+      const { transformer, method } = smartTagData.generator(innerValue, mode, this);
+      if (isMethod) return method;
+      if (mode === "isolation") {
+        const applied = transformer.apply(null);
+        if (applied.success) return applied.payload;
+        throw {
+          error: "Transformation error",
+          details: applied.error,
+          transformer: transformer.name,
+          path: this.pathString
+        };
+      }
+      return transformer;
+    }
+    enforceEvaluation() {
+      const { isPreserved, node, computeValue, isLiteral, attributes } = this;
+      const { Element } = Window.get();
+      if (isPreserved) return Utils.clone(node);
+      const evaluated = computeValue();
+      if (!isLiteral) return evaluated;
+      const asLiteral = Utils.toHyperJson(evaluated);
+      if (asLiteral instanceof Element) attributes?.forEach(({ name, value }) => asLiteral.setAttribute(name, value));
+      return asLiteral;
+    }
+    cachedValue = void 0;
+    getCachedValue() {
+      const { cachedValue } = this;
+      if (cachedValue === void 0) return void 0;
+      const deserialized = Serialize.deserialize(cachedValue);
+      return deserialized;
+    }
+    setCachedValue(evaluated) {
+      this.cachedValue = Serialize.serialize(evaluated);
+    }
+    evaluate() {
+      const start = Date.now();
+      const {
+        getCachedValue,
+        setCachedValue,
+        enforceEvaluation
+      } = this;
+      const cached = getCachedValue();
+      if (cached !== void 0) return cached;
+      const evaluated = enforceEvaluation();
+      setCachedValue(evaluated);
+      const end = Date.now();
+      const time = end - start;
+      if (time > 20) console.warn(`${this.pathString} took ${time}ms to evaluate, maybe there's something wrong here`);
+      return evaluated;
+    }
+  }
+  _Tree.Tree = Tree2;
+})(Tree || (Tree = {}));
 export {
   Tree
 };

package/agnostic/html/hyper-json/types/index.js

@@ -1,7 +1,19 @@
-import {
-  Types
-} from "../../../../chunks/chunk-XEQ2PBT2.js";
-import "../../../../chunks/chunk-XCBH6NLF.js";
+// src/agnostic/html/hyper-json/types/index.ts
+var Types;
+((Types2) => {
+  let Tree;
+  ((Tree2) => {
+    let Merge;
+    ((Merge2) => {
+      let Action;
+      ((Action2) => {
+        Action2["APPEND"] = "append";
+        Action2["PREPEND"] = "prepend";
+        Action2["REPLACE"] = "replace";
+      })(Action = Merge2.Action || (Merge2.Action = {}));
+    })(Merge = Tree2.Merge || (Tree2.Merge = {}));
+  })(Tree = Types2.Tree || (Types2.Tree = {}));
+})(Types || (Types = {}));
 export {
   Types
 };