@design-edito/tools 0.1.32 → 0.1.33

package/chunks/chunk-LGECI2WL.js

@@ -1,306 +0,0 @@
-import {
-  Serialize
-} from "./chunk-DRNK3RLE.js";
-import {
-  Transformers
-} from "./chunk-GQSPY2CV.js";
-import {
-  Types
-} from "./chunk-3KQRMKQJ.js";
-import {
-  Cast
-} from "./chunk-AMS3FB24.js";
-import {
-  Crossenv
-} from "./chunk-3LVR6KZH.js";
-import {
-  isRecord
-} from "./chunk-YDIBNEGA.js";
-import {
-  isInEnum
-} from "./chunk-E6MSDKON.js";
-
-// 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 = class _Tree {
-  node;
-  name;
-  parent;
-  root;
-  path;
-  pathString;
-  tagName;
-  attributes;
-  subtrees = /* @__PURE__ */ new Map();
-  children;
-  type;
-  constructor(node, parent, pathFromParent) {
-    this.resolve = this.resolve.bind(this);
-    this.initValue = this.initValue.bind(this);
-    this.mergeValues = this.mergeValues.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.evaluate = this.evaluate.bind(this);
-    this.node = node;
-    this.name = this.node instanceof getWindow().Element ? this.node.getAttribute("_name") : null;
-    this.parent = parent ?? null;
-    this.root = this.parent === null ? this : this.parent.root;
-    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 getWindow().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 getWindow().Element)) return false;
-        return true;
-      }
-      return false;
-    }).forEach((childNode) => {
-      if (childNode instanceof getWindow().Text) {
-        mutableSubtrees.set(
-          positionnedChildrenCount,
-          new _Tree(childNode, this, positionnedChildrenCount)
-        );
-        positionnedChildrenCount += 1;
-      } else {
-        const propertyName = childNode.getAttribute("_name");
-        if (propertyName === null) {
-          mutableSubtrees.set(
-            positionnedChildrenCount,
-            new _Tree(childNode, this, positionnedChildrenCount)
-          );
-          positionnedChildrenCount += 1;
-        } else {
-          mutableSubtrees.set(
-            propertyName,
-            new _Tree(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 (isInEnum(Types.TransformerTagName, this.tagName)) {
-      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;
-  };
-  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;
-  }
-  mergeValues(currentValue, incomingValue, mergeKey) {
-    const { Element, Text, NodeList, document } = getWindow();
-    if (typeof incomingValue === "function") {
-      const evaluated = incomingValue(currentValue, { resolver: this.resolve });
-      if (evaluated.action === null) return currentValue;
-      if (evaluated.action === "REPLACE") return evaluated.value;
-      return this.mergeValues(currentValue, evaluated.value, mergeKey);
-    }
-    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
-    };
-  }
-  getInnerValue(initialValue) {
-    const { subtrees } = this;
-    const innerValue = Array.from(subtrees.entries()).reduce((currentValue, [subpath, subtree]) => this.mergeValues(
-      currentValue,
-      subtree.evaluate(),
-      subpath
-    ), initialValue);
-    return innerValue;
-  }
-  wrapInnerValue(innerValue) {
-    const { type } = this;
-    if (type === "transformer") {
-      const transformerName = this.tagName;
-      const generator = Transformers.get(transformerName);
-      if (generator === void 0) return innerValue;
-      const transformer = Array.isArray(innerValue) ? generator(...innerValue) : generator(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);
-  }
-  evaluate() {
-    const start = Date.now();
-    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;
-    return wrapped;
-  }
-};
-
-export {
-  Tree
-};

package/chunks/chunk-LGUEB5L5.js

@@ -1,211 +0,0 @@
-import {
-  Random
-} from "./chunk-R6KCN6CK.js";
-import {
-  isArrayOf
-} from "./chunk-6RGDWX4A.js";
-import {
-  findDuplicates
-} from "./chunk-YS6WMSWC.js";
-import {
-  make
-} from "./chunk-RLAZR3NL.js";
-import {
-  RANDOM_PICK_ERR_SYMBOL,
-  randomPick
-} from "./chunk-FCU6IHKD.js";
-
-// src/agnostic/arrays/index.tsx
-var Arrays;
-((Arrays2) => {
-  Arrays2.findDuplicates = findDuplicates;
-  Arrays2.isArrayOf = isArrayOf;
-  Arrays2.make = make;
-  Arrays2.RANDOM_PICK_ERR_SYMBOL = RANDOM_PICK_ERR_SYMBOL;
-  Arrays2.randomPick = randomPick;
-})(Arrays || (Arrays = {}));
-
-// src/agnostic/misc/lorem-ipsum/index.ts
-var LoremIpsum;
-((LoremIpsum2) => {
-  LoremIpsum2.words = [
-    "a",
-    "ac",
-    "accumsan",
-    "adipiscing",
-    "aenean",
-    "aliquam",
-    "aliquet",
-    "amet",
-    "ante",
-    "arcu",
-    "at",
-    "auctor",
-    "augue",
-    "bibendum",
-    "blandit",
-    "condimentum",
-    "consectetur",
-    "consequat",
-    "convallis",
-    "cras",
-    "curabitur",
-    "cursus",
-    "dapibus",
-    "diam",
-    "dictum",
-    "dictumst",
-    "dignissim",
-    "dolor",
-    "donec",
-    "dui",
-    "duis",
-    "efficitur",
-    "egestas",
-    "eget",
-    "eleifend",
-    "elementum",
-    "elit",
-    "enim",
-    "erat",
-    "eros",
-    "est",
-    "et",
-    "eu",
-    "euismod",
-    "ex",
-    "facilisis",
-    "faucibus",
-    "felis",
-    "feugiat",
-    "finibus",
-    "fringilla",
-    "fusce",
-    "gravida",
-    "habitasse",
-    "hac",
-    "hendrerit",
-    "iaculis",
-    "id",
-    "imperdiet",
-    "in",
-    "integer",
-    "interdum",
-    "ipsum",
-    "justo",
-    "lacinia",
-    "lacus",
-    "laoreet",
-    "lectus",
-    "leo",
-    "libero",
-    "ligula",
-    "lobortis",
-    "lorem",
-    "luctus",
-    "maecenas",
-    "magna",
-    "malesuada",
-    "massa",
-    "mattis",
-    "mauris",
-    "maximus",
-    "metus",
-    "mi",
-    "molestie",
-    "mollis",
-    "morbi",
-    "nam",
-    "nec",
-    "neque",
-    "nibh",
-    "nisi",
-    "nisl",
-    "non",
-    "nulla",
-    "nullam",
-    "nunc",
-    "odio",
-    "orci",
-    "ornare",
-    "pellentesque",
-    "pharetra",
-    "phasellus",
-    "placerat",
-    "platea",
-    "porta",
-    "porttitor",
-    "posuere",
-    "praesent",
-    "pulvinar",
-    "purus",
-    "quam",
-    "quis",
-    "quisque",
-    "risus",
-    "rutrum",
-    "sagittis",
-    "sapien",
-    "sed",
-    "sem",
-    "semper",
-    "sit",
-    "sodales",
-    "sollicitudin",
-    "suscipit",
-    "suspendisse",
-    "tellus",
-    "tempor",
-    "tempus",
-    "tincidunt",
-    "tortor",
-    "tristique",
-    "turpis",
-    "ultrices",
-    "ultricies",
-    "urna",
-    "ut",
-    "vehicula",
-    "vel",
-    "velit",
-    "venenatis",
-    "vestibulum",
-    "vitae",
-    "vivamus",
-    "viverra",
-    "volutpat",
-    "vulputate"
-  ];
-  LoremIpsum2.generateSentence = (wordCount) => {
-    const resultArr = [];
-    let currentWordCound = wordCount;
-    for (let i = 0; i < currentWordCound; i++) {
-      const picked = Arrays.randomPick(LoremIpsum2.words);
-      if (typeof picked === "string") resultArr.push(picked);
-      else {
-        currentWordCound += 1;
-      }
-    }
-    const [firstWord, ...otherWords] = resultArr;
-    if (firstWord === void 0) return "";
-    const capFirstLetter = firstWord?.charAt(0).toUpperCase();
-    const restOfFirstWord = firstWord?.slice(1);
-    const sentence = [
-      `${capFirstLetter}${restOfFirstWord}`,
-      ...otherWords
-    ].join(" ");
-    return `${sentence}.`;
-  };
-  LoremIpsum2.generateSentences = (sentencesCount, maxSentenceLength = 12, minSentenceLength = 4) => {
-    const sentences = [];
-    for (let i = 0; i < sentencesCount; i++) {
-      const length = Random.randomInt(maxSentenceLength, minSentenceLength) ?? 8;
-      sentences.push((0, LoremIpsum2.generateSentence)(length));
-    }
-    return sentences;
-  };
-})(LoremIpsum || (LoremIpsum = {}));
-
-export {
-  LoremIpsum
-};