@design-edito/tools 0.1.32 → 0.1.34

package/chunks/chunk-QFEF4EET.js

@@ -1,211 +0,0 @@
-import {
-  isArrayOf
-} from "./chunk-6RGDWX4A.js";
-import {
-  make
-} from "./chunk-RLAZR3NL.js";
-import {
-  findDuplicates
-} from "./chunk-YS6WMSWC.js";
-import {
-  RANDOM_PICK_ERR_SYMBOL,
-  randomPick
-} from "./chunk-FCU6IHKD.js";
-import {
-  Random
-} from "./chunk-R6KCN6CK.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
-};

package/chunks/chunk-QHSVCGLD.js

@@ -1,280 +0,0 @@
-import {
-  isRecord
-} from "./chunk-YDIBNEGA.js";
-import {
-  isInEnum
-} from "./chunk-E6MSDKON.js";
-import {
-  isFalsy
-} from "./chunk-QXAJXTXV.js";
-
-// src/agnostic/html/hyper-json/index.ts
-var HyperJson;
-((HyperJson2) => {
-  const crossenvWindow = window;
-  const document = crossenvWindow.document;
-  const Element = crossenvWindow.Element;
-  const Text = crossenvWindow.Text;
-  const Node = crossenvWindow.Node;
-  const isElement = (node) => node.nodeType === Node.ELEMENT_NODE;
-  const isText = (node) => node.nodeType === Node.TEXT_NODE;
-  let TyperTagName;
-  ((TyperTagName2) => {
-    TyperTagName2["NULL"] = "null";
-    TyperTagName2["BOOLEAN"] = "boolean";
-    TyperTagName2["NUMBER"] = "number";
-    TyperTagName2["STRING"] = "string";
-    TyperTagName2["TEXT"] = "text";
-    TyperTagName2["NODELIST"] = "nodelist";
-    TyperTagName2["ARRAY"] = "array";
-    TyperTagName2["RECORD"] = "record";
-  })(TyperTagName = HyperJson2.TyperTagName || (HyperJson2.TyperTagName = {}));
-  let TransformerTagName;
-  ((TransformerTagName2) => {
-    TransformerTagName2["MAP"] = "map";
-    TransformerTagName2["REF"] = "ref";
-    TransformerTagName2["ADD"] = "add";
-    TransformerTagName2["MULT"] = "mult";
-    TransformerTagName2["APPEND"] = "append";
-  })(TransformerTagName = HyperJson2.TransformerTagName || (HyperJson2.TransformerTagName = {}));
-  class Tree {
-    node;
-    name;
-    parent;
-    root;
-    path;
-    pathString;
-    tagName;
-    attributes;
-    subtrees = /* @__PURE__ */ new Map();
-    children;
-    type;
-    constructor(node, parent, pathFromParent) {
-      this.initValue = this.initValue.bind(this);
-      this.getInnerValue = this.getInnerValue.bind(this);
-      this.wrapInnerValue = this.wrapInnerValue.bind(this);
-      this.evaluate = this.evaluate.bind(this);
-      this.node = node;
-      this.name = this.node instanceof 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 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) => {
-        if (isElement(node2)) return true;
-        if (isText(node2)) return true;
-        return false;
-      }).forEach((childNode) => {
-        if (childNode instanceof 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 === "null" /* NULL */) {
-        this.type = "null";
-      } else if (this.tagName === "boolean" /* BOOLEAN */) {
-        this.type = "boolean";
-      } else if (this.tagName === "number" /* NUMBER */) {
-        this.type = "number";
-      } else if (this.tagName === "string" /* STRING */) {
-        this.type = "string";
-      } else if (this.tagName === "text" /* TEXT */) {
-        this.type = "text";
-      } else if (this.tagName === "nodelist" /* NODELIST */) {
-        this.type = "nodelist";
-      } else if (this.tagName === "array" /* ARRAY */) {
-        this.type = "array";
-      } else if (this.tagName === "record" /* RECORD */) {
-        this.type = "record";
-      } else if (isInEnum(TransformerTagName, this.tagName)) {
-        this.type = "transformer";
-      } else {
-        this.type = "element";
-      }
-      console.log(this);
-    }
-    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 = document.createDocumentFragment().childNodes;
-      } else if (type === "nodelist") {
-        currentValue = 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;
-      console.log("---", this, subtrees);
-      const innerValue = Array.from(subtrees.entries()).reduce((currentValue, [subpath, subTree]) => {
-        if (subTree.type === "transformer") {
-          const evaluated = subTree.evaluate();
-          return evaluated(currentValue);
-        }
-        if (currentValue === null || typeof currentValue === "boolean" || typeof currentValue === "number" || typeof currentValue === "string" || currentValue instanceof Text || currentValue instanceof Element) {
-          const evaluated = subTree.evaluate();
-          if (evaluated === null || typeof evaluated === "boolean" || typeof evaluated === "number" || typeof evaluated === "string" || Array.isArray(evaluated) || isRecord(evaluated)) {
-            return evaluated;
-          }
-          const frag = document.createDocumentFragment();
-          frag.append(`${currentValue}`);
-          if (evaluated instanceof Element || evaluated instanceof Text) {
-            frag.append(evaluated);
-            return frag.childNodes;
-          }
-          frag.append(...Array.from(evaluated));
-          return frag.childNodes;
-        }
-        if (Array.isArray(currentValue)) {
-          if (typeof subpath === "string") return currentValue;
-          return [...currentValue, subTree.evaluate()];
-        }
-        if (currentValue instanceof NodeList) {
-          const evaluated = subTree.evaluate();
-          if (evaluated instanceof Element || evaluated instanceof Text) {
-            const frag = document.createDocumentFragment();
-            frag.append(...Array.from(currentValue), evaluated);
-            return frag.childNodes;
-          }
-          if (evaluated instanceof NodeList) {
-            const frag = document.createDocumentFragment();
-            frag.append(
-              ...Array.from(currentValue),
-              ...Array.from(evaluated)
-            );
-            return frag.childNodes;
-          }
-          if (evaluated === null || typeof evaluated === "string" || typeof evaluated === "number" || typeof evaluated === "boolean") {
-            const frag = document.createDocumentFragment();
-            frag.append(...Array.from(currentValue), `${evaluated}`);
-            return frag.childNodes;
-          }
-          if (Array.isArray(evaluated)) return [...Array.from(currentValue), ...evaluated];
-          return { ...evaluated };
-        }
-        if (typeof subpath === "number") return currentValue;
-        return {
-          ...currentValue,
-          [subpath]: subTree.evaluate()
-        };
-      }, initialValue);
-      return innerValue;
-    }
-    wrapInnerValue(innerValue) {
-      const { type, node } = this;
-      if (type === "transformer") return (contextValue) => {
-        console.log(`I am a transformer. My name is ${this.tagName}.`);
-        console.log("I have this innerValue (these are my params):");
-        console.log(innerValue);
-        console.log("And this context value:");
-        console.log(contextValue);
-        return contextValue;
-      };
-      if (type === "null") return null;
-      if (type === "boolean") return !isFalsy(innerValue);
-      if (type === "number") return parseFloat(`${innerValue}`);
-      if (type === "string") return `${innerValue}`;
-      if (type === "array") {
-        if (Array.isArray(innerValue)) return innerValue;
-        if (innerValue instanceof NodeList) {
-          return [...Array.from(innerValue)];
-        }
-        return [innerValue];
-      }
-      if (type === "record") {
-        if (isRecord(innerValue)) return innerValue;
-        return {};
-      }
-      if (type === "text") return document.createTextNode(`${innerValue}`);
-      if (type === "element") {
-        const wrapper = node.cloneNode();
-        if (innerValue instanceof NodeList) {
-          wrapper.append(...Array.from(innerValue));
-          return wrapper;
-        }
-        if (innerValue instanceof Element || innerValue instanceof Text || typeof innerValue === "string") {
-          wrapper.append(innerValue);
-          return wrapper;
-        }
-        if (innerValue === null || typeof innerValue === "number" || typeof innerValue === "boolean") {
-          wrapper.append(`${innerValue}`);
-          return wrapper;
-        }
-        return wrapper;
-      }
-      if (innerValue instanceof NodeList) return innerValue;
-      if (innerValue instanceof Element || innerValue instanceof Text || typeof innerValue === "string") {
-        const frag2 = document.createDocumentFragment();
-        frag2.append(innerValue);
-        return frag2.childNodes;
-      }
-      if (innerValue === null || typeof innerValue === "string" || typeof innerValue === "number" || typeof innerValue === "boolean") {
-        const frag2 = document.createDocumentFragment();
-        frag2.append(`${innerValue}`);
-        return frag2.childNodes;
-      }
-      const frag = document.createDocumentFragment();
-      return frag.childNodes;
-    }
-    evaluate() {
-      const init = this.initValue();
-      const inner = this.getInnerValue(init);
-      const wrapped = this.wrapInnerValue(inner);
-      return wrapped;
-    }
-  }
-  HyperJson2.Tree = Tree;
-})(HyperJson || (HyperJson = {}));
-
-export {
-  HyperJson
-};

package/chunks/chunk-QO64L4KB.js

@@ -1,97 +0,0 @@
-import {
-  Crossenv
-} from "./chunk-3LVR6KZH.js";
-import {
-  Utils
-} from "./chunk-YEBOL67V.js";
-import {
-  isRecord
-} from "./chunk-YDIBNEGA.js";
-import {
-  isFalsy
-} from "./chunk-QXAJXTXV.js";
-
-// src/agnostic/html/hyper-json/cast/index.ts
-var getWindow = Crossenv.getWindow;
-var Cast;
-((Cast2) => {
-  Cast2.toNull = () => null;
-  Cast2.toBoolean = (input) => !isFalsy(input);
-  Cast2.toNumber = (input) => {
-    const { Text } = getWindow();
-    if (typeof input === "number") return input;
-    if (typeof input === "string") return parseFloat(`${input}`);
-    if (input instanceof Text) return parseFloat(`${input.textContent}`);
-    return 0;
-  };
-  Cast2.toString = (input) => {
-    if (typeof input === "string") return input;
-    if (typeof input === "number" || typeof input === "boolean" || input === null) return `${input}`;
-    const { Element, Text, NodeList } = getWindow();
-    if (input instanceof Element) return input.outerHTML;
-    if (input instanceof Text) return input.textContent ?? "";
-    if (input instanceof NodeList) return Array.from(input).map((e) => {
-      if (e instanceof Element) return e.outerHTML;
-      return e.textContent;
-    }).join("");
-    return input.toString();
-  };
-  Cast2.toText = (input) => {
-    const { Text, document } = getWindow();
-    if (input instanceof Text) return input.cloneNode(true);
-    return document.createTextNode((0, Cast2.toString)(input));
-  };
-  Cast2.toElement = (input) => {
-    const { Element, Text, NodeList, document } = getWindow();
-    if (input instanceof Element) return input.cloneNode(true);
-    const elt = document.createElement("div");
-    if (input instanceof Text) {
-      elt.append(input.cloneNode(true));
-      return elt;
-    }
-    if (input instanceof NodeList) {
-      elt.append(...Array.from(input).map((e) => e.cloneNode(true)));
-      return elt;
-    }
-    if (Array.isArray(input)) return elt;
-    if (isRecord(input)) return elt;
-    elt.append(`${input}`);
-    return elt;
-  };
-  Cast2.toNodeList = (input) => {
-    const { Element, Text, NodeList, document } = getWindow();
-    const elt = document.createElement("div");
-    if (input instanceof NodeList) {
-      elt.append(...Array.from(input).map((i) => i.cloneNode(true)));
-      return elt.childNodes;
-    }
-    if (input instanceof Element || input instanceof Text) {
-      elt.append(input.cloneNode(true));
-      return elt.childNodes;
-    }
-    if (Array.isArray(input)) return elt.childNodes;
-    if (isRecord(input)) return elt.childNodes;
-    elt.innerHTML = `${input}`;
-    return elt.childNodes;
-  };
-  Cast2.toArray = (input) => {
-    const { NodeList } = getWindow();
-    if (Array.isArray(input)) return [...input];
-    if (input instanceof NodeList) return Array.from(input);
-    return [input];
-  };
-  Cast2.toRecord = (input) => {
-    if (isRecord(input)) return { ...input };
-    return {};
-  };
-  Cast2.toTransformer = (input) => {
-    return Utils.toNamedTransformer("utils/Cast.toTransformer", () => ({
-      action: "REPLACE",
-      value: input
-    }));
-  };
-})(Cast || (Cast = {}));
-
-export {
-  Cast
-};

package/chunks/chunk-R6KCN6CK.js

@@ -1,40 +0,0 @@
-// src/agnostic/random/index.ts
-var Random;
-((Random2) => {
-  function random(bound1 = 1, bound2) {
-    const min = bound2 === void 0 ? 0 : bound1;
-    const max = bound2 === void 0 ? bound1 : bound2;
-    if (min === max || min > max) return void 0;
-    const range = max - min;
-    return Math.random() * range + min;
-  }
-  Random2.random = random;
-  function randomInt(...args) {
-    const rand = random(...args);
-    return rand !== void 0 ? Math.floor(rand) : void 0;
-  }
-  Random2.randomInt = randomInt;
-  Random2.hexChars = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
-  function randomHexChar() {
-    const nbr = Math.floor(Math.random() * 16);
-    const char = Random2.hexChars[nbr];
-    return char;
-  }
-  Random2.randomHexChar = randomHexChar;
-  function randomHash(length = 4) {
-    return new Array(length).fill(null).map(randomHexChar).join("");
-  }
-  Random2.randomHash = randomHash;
-  function randomHashPattern(pattern, joiner = "-") {
-    return pattern.map(randomHash).join(joiner);
-  }
-  Random2.randomHashPattern = randomHashPattern;
-  function randomUUID() {
-    return randomHashPattern([8, 4, 4, 4, 12]);
-  }
-  Random2.randomUUID = randomUUID;
-})(Random || (Random = {}));
-
-export {
-  Random
-};