@design-edito/tools 0.1.72 → 0.1.73

package/chunks/{chunk-FVPFKY5G.js → chunk-766BSKLU.js}

@@ -1,21 +1,21 @@
 import {
-  array
-} from "./chunk-VDNIN3V5.js";
+  any
+} from "./chunk-FHLCPVND.js";
 import {
   nullFunc
 } from "./chunk-QAVYONH6.js";
+import {
+  Serialize
+} from "./chunk-SXRWMH3U.js";
 import {
   Types
 } from "./chunk-XEQ2PBT2.js";
 import {
-  any
-} from "./chunk-FHLCPVND.js";
+  array
+} from "./chunk-QAQZEKIF.js";
 import {
   SmartTags
 } from "./chunk-UT2J62LH.js";
-import {
-  Serialize
-} from "./chunk-SXRWMH3U.js";
 import {
   Transformer
 } from "./chunk-BKO7GLC2.js";
@@ -26,8 +26,15 @@ import {
   insertNode
 } from "./chunk-XA4HVHJ4.js";
 import {
-  isInEnum
-} from "./chunk-E6MSDKON.js";
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  replaceAll
+} from "./chunk-ZTDVUXPR.js";
+import {
+  trimEnd,
+  trimStart
+} from "./chunk-6XL25OZX.js";
 import {
   isRecord
 } from "./chunk-YDIBNEGA.js";
@@ -35,11 +42,8 @@ import {
   recordMap
 } from "./chunk-XNF5MLCQ.js";
 import {
-  replaceAll
-} from "./chunk-ZTDVUXPR.js";
-import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
+  isInEnum
+} from "./chunk-E6MSDKON.js";
 import {
   Window
 } from "./chunk-RLJOYG64.js";
@@ -88,10 +92,10 @@ var Cast;
     if (input instanceof Text2) return input.cloneNode(true);
     return document2.createTextNode((0, Cast2.toString)(input));
   };
-  Cast2.toElement = (input) => {
+  Cast2.toElement = (input, tagName) => {
     const { Element: Element2, Text: Text2, NodeList, document: document2 } = Window.get();
     if (input instanceof Element2) return input.cloneNode(true);
-    const returned = document2.createElement("div");
+    const returned = document2.createElement(tagName ?? "div");
     if (input instanceof Text2) {
       returned.append(input.cloneNode(true));
       return returned;
@@ -373,11 +377,25 @@ var addclass = SmartTags.makeSmartTag({
   name: "addclass",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element"),
+  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element", "nodelist"),
   argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
   func: (main, args) => {
-    main.classList.add(...args.map((arg) => Cast.toString(arg)));
-    return Outcome.makeSuccess(main);
+    const { Element: Element2 } = Window.get();
+    if (main instanceof Element2) {
+      main.classList.add(...args.map((arg) => Cast.toString(arg)));
+      return Outcome.makeSuccess(main);
+    }
+    const children = Array.from(main).map((child) => {
+      if (child instanceof Element2) {
+        child.classList.add(...args.map((arg) => Cast.toString(arg)));
+        return child;
+      }
+      return child;
+    });
+    const frag = document.createDocumentFragment();
+    frag.append(...children);
+    const nodelist2 = frag.childNodes;
+    return Outcome.makeSuccess(nodelist2);
   }
 });
 
@@ -987,7 +1005,7 @@ var removeattribute = SmartTags.makeSmartTag({
   mainValueCheck: (m) => {
     const { typeCheck, typeCheckMany } = Utils.Tree.TypeChecks;
     if (Array.isArray(m)) return typeCheckMany(m, "element");
-    return typeCheck(m, "element");
+    return typeCheck(m, "element", "nodelist");
   },
   argsValueCheck: (a) => {
     const { makeFailure, makeSuccess } = Outcome;
@@ -1000,13 +1018,26 @@ var removeattribute = SmartTags.makeSmartTag({
     return checked;
   },
   func: (main, args) => {
-    const { makeSuccess } = Outcome;
-    const mainArr = Array.isArray(main) ? main : [main];
-    const mainArrCloned = mainArr.map((e) => Utils.clone(e));
-    const name = Cast.toString(args[0]);
-    mainArrCloned.forEach((e) => e.removeAttribute(name));
-    if (Array.isArray(main)) return makeSuccess(mainArrCloned);
-    return makeSuccess(mainArrCloned[0]);
+    const argsStr = args.map((e) => Cast.toString(e));
+    const [name] = argsStr;
+    const { NodeList } = Window.get();
+    if (main instanceof NodeList) {
+      const children = Array.from(main).map((child) => {
+        const cloned = Utils.clone(child);
+        if (cloned instanceof Element) cloned.removeAttribute(name);
+        return cloned;
+      });
+      const frag = document.createDocumentFragment();
+      frag.append(...children);
+      const nodelist2 = frag.childNodes;
+      return Outcome.makeSuccess(nodelist2);
+    } else {
+      const mainArr = Array.isArray(main) ? main : [main];
+      const mainArrCloned = mainArr.map((e) => Utils.clone(e));
+      mainArrCloned.forEach((e) => e.removeAttribute(name));
+      if (Array.isArray(main)) return Outcome.makeSuccess(mainArrCloned);
+      return Outcome.makeSuccess(mainArrCloned[0]);
+    }
   }
 });
 
@@ -1015,11 +1046,25 @@ var removeclass = SmartTags.makeSmartTag({
   name: "removeclass",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element"),
+  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element", "nodelist"),
   argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
   func: (main, args) => {
-    main.classList.remove(...args.map((arg) => Cast.toString(arg)));
-    return Outcome.makeSuccess(main);
+    const { Element: Element2 } = Window.get();
+    if (main instanceof Element2) {
+      main.classList.remove(...args.map((arg) => Cast.toString(arg)));
+      return Outcome.makeSuccess(main);
+    }
+    const children = Array.from(main).map((child) => {
+      if (child instanceof Element2) {
+        child.classList.remove(...args.map((arg) => Cast.toString(arg)));
+        return child;
+      }
+      return child;
+    });
+    const frag = document.createDocumentFragment();
+    frag.append(...children);
+    const nodelist2 = frag.childNodes;
+    return Outcome.makeSuccess(nodelist2);
   }
 });
 
@@ -1160,7 +1205,7 @@ var setattribute = SmartTags.makeSmartTag({
   mainValueCheck: (m) => {
     const { typeCheck, typeCheckMany } = Utils.Tree.TypeChecks;
     if (Array.isArray(m)) return typeCheckMany(m, "element");
-    return typeCheck(m, "element");
+    return typeCheck(m, "element", "nodelist");
   },
   argsValueCheck: (a) => {
     const { makeFailure, makeSuccess } = Outcome;
@@ -1173,13 +1218,26 @@ var setattribute = SmartTags.makeSmartTag({
     return checked;
   },
   func: (main, args) => {
-    const mainArr = Array.isArray(main) ? main : [main];
-    const mainArrCloned = mainArr.map((e) => Utils.clone(e));
     const argsStr = args.map((e) => Cast.toString(e));
     const [name, value = ""] = argsStr;
-    mainArrCloned.forEach((e) => e.setAttribute(name, value));
-    if (Array.isArray(main)) return Outcome.makeSuccess(mainArrCloned);
-    return Outcome.makeSuccess(mainArrCloned[0]);
+    const { NodeList } = Window.get();
+    if (main instanceof NodeList) {
+      const children = Array.from(main).map((child) => {
+        const cloned = Utils.clone(child);
+        if (cloned instanceof Element) cloned.setAttribute(name, value);
+        return cloned;
+      });
+      const frag = document.createDocumentFragment();
+      frag.append(...children);
+      const nodelist2 = frag.childNodes;
+      return Outcome.makeSuccess(nodelist2);
+    } else {
+      const mainArr = Array.isArray(main) ? main : [main];
+      const mainArrCloned = mainArr.map((e) => Utils.clone(e));
+      mainArrCloned.forEach((e) => e.setAttribute(name, value));
+      if (Array.isArray(main)) return Outcome.makeSuccess(mainArrCloned);
+      return Outcome.makeSuccess(mainArrCloned[0]);
+    }
   }
 });
 
@@ -1370,8 +1428,13 @@ var toelement = SmartTags.makeSmartTag({
   defaultMode: "coalescion",
   isolationInitType: "array",
   mainValueCheck: (m) => Outcome.makeSuccess(m),
-  argsValueCheck: (a) => Utils.SmartTags.expectEmptyArgs(a),
-  func: (m) => Outcome.makeSuccess(Cast.toElement(m))
+  argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckManyWithLength(a, 0, 1, "string", "text"),
+  func: (m, a) => {
+    const [rawTagName] = a;
+    const castedTagName = rawTagName !== void 0 ? Cast.toString(rawTagName) : void 0;
+    const tagName = castedTagName !== "" ? castedTagName : void 0;
+    return Outcome.makeSuccess(Cast.toElement(m, tagName?.trim().toLowerCase()));
+  }
 });
 
 // src/agnostic/html/hyper-json/smart-tags/coalesced/toggleclass/index.ts
@@ -1379,11 +1442,25 @@ var toggleclass = SmartTags.makeSmartTag({
   name: "toggleclass",
   defaultMode: "coalescion",
   isolationInitType: "array",
-  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element"),
+  mainValueCheck: (m) => Utils.Tree.TypeChecks.typeCheck(m, "element", "nodelist"),
   argsValueCheck: (a) => Utils.Tree.TypeChecks.typeCheckMany(a, "string", "text"),
   func: (main, args) => {
-    for (const arg of args) main.classList.toggle(Cast.toString(arg));
-    return Outcome.makeSuccess(main);
+    const { Element: Element2 } = Window.get();
+    if (main instanceof Element2) {
+      args.forEach((arg) => main.classList.toggle(Cast.toString(arg)));
+      return Outcome.makeSuccess(main);
+    }
+    const children = Array.from(main).map((child) => {
+      if (child instanceof Element2) {
+        args.forEach((arg) => child.classList.toggle(Cast.toString(arg)));
+        return child;
+      }
+      return child;
+    });
+    const frag = document.createDocumentFragment();
+    frag.append(...children);
+    const nodelist2 = frag.childNodes;
+    return Outcome.makeSuccess(nodelist2);
   }
 });
 
@@ -1583,7 +1660,7 @@ var Tree;
       return new Tree2(merged, null, null, options);
     }
     constructor(node, parent, pathFromParent, options) {
-      const { Element: Element2, Text: Text2 } = Window.get();
+      const { Element: Element2, Text: Text2, document: document2 } = Window.get();
       this.resolve = this.resolve.bind(this);
       this.setVariable = this.setVariable.bind(this);
       this.getVariable = this.getVariable.bind(this);
@@ -1592,7 +1669,6 @@ var Tree;
       this.enforceEvaluation = this.enforceEvaluation.bind(this);
       this.getCachedValue = this.getCachedValue.bind(this);
       this.setCachedValue = this.setCachedValue.bind(this);
-      this.getPerformanceData = this.getPerformanceData.bind(this);
       this.evaluate = this.evaluate.bind(this);
       this.node = node;
       this.options = options ?? Tree2.defaultOptions;
@@ -1729,20 +1805,32 @@ var Tree;
       const mutableSubtrees = /* @__PURE__ */ new Map();
       Array.from(childNodes).filter((child, _, childNodes2) => {
         if (child instanceof Element2) return true;
-        if (!(child instanceof Text2)) return false;
-        const hasContent = (child.textContent ?? "").trim() !== "";
-        if (hasContent) return true;
-        if (childNodes2.some((n) => n instanceof Element2)) return false;
-        return true;
+        if (child instanceof Text2) return true;
+        return false;
+      }).reduce((reduced, child) => {
+        if (reduced.length === 0) return [child];
+        if (child instanceof Element2) return [...reduced, child];
+        const lastReducedItem = reduced[reduced.length - 1];
+        if (lastReducedItem instanceof Element2) return [...reduced, child];
+        const lastReducedTrimmed = trimEnd(lastReducedItem.textContent ?? "");
+        const childTrimmed = trimStart(child.textContent ?? "");
+        const merged = document2.createTextNode(`${lastReducedTrimmed}${childTrimmed}`);
+        const returned = [...reduced];
+        returned.pop();
+        returned.push(merged);
+        return returned;
+      }, []).filter((child) => {
+        if (child instanceof Element2) return true;
+        const textContent = child.textContent ?? "";
+        return textContent.trim() !== "";
       }).forEach((childNode) => {
         if (childNode instanceof Text2) {
-          const hasContent = (childNode.textContent ?? "").trim() !== "";
-          if (hasContent) {
-            childNode.textContent = childNode.textContent?.trim() ?? "";
-          }
+          const rawTextContent = childNode.textContent ?? "";
+          const textContent = rawTextContent.replace(/^\s*\n+\s*/, "").replace(/\s*\n+\s*$/, "");
+          const returnedChildNode = document2.createTextNode(textContent);
           mutableSubtrees.set(
             positionnedChildrenCount,
-            new Tree2(childNode, this, positionnedChildrenCount, this.options)
+            new Tree2(returnedChildNode, this, positionnedChildrenCount, this.options)
           );
           positionnedChildrenCount += 1;
         } else {
@@ -1861,57 +1949,20 @@ var Tree;
     setCachedValue(evaluated) {
       this.cachedValue = Serialize.serialize(evaluated);
     }
-    perfCounters = {
-      evaluations: 0,
-      computeTime: 0,
-      computeTimeAvg: 0,
-      cached: 0,
-      cacheTime: 0,
-      cacheTimeAvg: 0,
-      totalTime: 0
-    };
-    // [WIP] bind this
-    getPerformanceData() {
-      const { subtrees, cachedValue, tagName, perfCounters } = this;
-      const subCounters = [];
-      subCounters.push([this.pathString, {
-        ...perfCounters,
-        tagName: tagName ?? "#text",
-        evaluated: cachedValue
-      }]);
-      subtrees.forEach((subtree) => subCounters.push(...subtree.getPerformanceData()));
-      return subCounters.sort((a, b) => {
-        const aCalls = a[1].evaluations + a[1].cached;
-        const bCalls = b[1].evaluations + b[1].cached;
-        return bCalls - aCalls;
-      });
-    }
     evaluate() {
       const start = Date.now();
       const {
         getCachedValue,
         setCachedValue,
-        enforceEvaluation,
-        perfCounters
+        enforceEvaluation
       } = this;
       const cached = getCachedValue();
-      if (cached !== void 0) {
-        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 cached;
-      }
+      if (cached !== void 0) return cached;
       const evaluated = enforceEvaluation();
       setCachedValue(evaluated);
       const end = Date.now();
       const time = end - start;
-      perfCounters.evaluations++;
-      perfCounters.computeTime += time;
-      perfCounters.computeTimeAvg = perfCounters.computeTime / perfCounters.evaluations;
-      perfCounters.totalTime = perfCounters.computeTime + perfCounters.cacheTime;
+      if (time > 20) console.warn(`${this.pathString} took ${time}ms to evaluate, maybe there's something wrong here`);
       return evaluated;
     }
   }
@@ -2277,6 +2328,20 @@ var Utils;
         return Outcome.makeSuccess(values);
       }
       TypeChecks2.typeCheckMany = typeCheckMany;
+      function typeCheckManyWithLength(values, minLength, maxLength, ...types) {
+        if (minLength !== void 0 && values.length < minLength) return Outcome.makeFailure({
+          position: values.length + 1,
+          expected: `min length: ${minLength}`,
+          found: `length: ${values.length}`
+        });
+        if (maxLength !== void 0 && values.length > maxLength) return Outcome.makeFailure({
+          position: maxLength + 1,
+          expected: `max length: ${maxLength}`,
+          found: `length: ${values.length}`
+        });
+        return typeCheckMany(values, ...types);
+      }
+      TypeChecks2.typeCheckManyWithLength = typeCheckManyWithLength;
       TypeChecks2.isTreeMode = (name) => name === "isolation" || name === "coalescion";
       TypeChecks2.isValueTypeName = (name) => {
         const list = [

package/chunks/chunk-76QORXDC.js

@@ -0,0 +1,19 @@
+import {
+  z
+} from "./chunk-XEAHMN2T.js";
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+
+// src/node/images/transform/normalize/index.ts
+var normalizeSchema = z.object({
+  name: z.literal(OperationNames.Normalize),
+  params: z.object({
+    lower: z.number(),
+    upper: z.number()
+  })
+});
+
+export {
+  normalizeSchema
+};

package/chunks/chunk-7BCQCDGQ.js

@@ -0,0 +1,31 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/node/@google-cloud/storage/file/erase/index.ts
+var erase_exports = {};
+__export(erase_exports, {
+  erase: () => erase
+});
+async function erase(sourcePath, bucket, options) {
+  const { fileOptions, deleteOptions } = options ?? {};
+  try {
+    const file = bucket.file(sourcePath, fileOptions);
+    await file.delete(deleteOptions);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return Outcome.makeFailure(errStr);
+  }
+}
+
+export {
+  erase,
+  erase_exports
+};

package/chunks/chunk-7DDXALPH.js

@@ -0,0 +1,49 @@
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@design-edito/thumbnails/common/index.ts
+var common_exports = {};
+__export(common_exports, {
+  clampNumber: () => clampNumber,
+  getArrayMax: () => getArrayMax,
+  randomInt: () => randomInt,
+  randomIntRange: () => randomIntRange,
+  shuffleArray: () => shuffleArray
+});
+function randomInt(max) {
+  return Math.floor(Math.random() * max);
+}
+function randomIntRange(min, max) {
+  const minCeiled = Math.ceil(min);
+  const maxFloored = Math.floor(max);
+  return Math.floor(Math.random() * (maxFloored - minCeiled) + minCeiled);
+}
+function shuffleArray(array) {
+  return [...array].sort((a, b) => 0.5 - Math.random());
+}
+function clampNumber(val, min, max) {
+  return Math.max(min, Math.min(val, max));
+}
+function getArrayMax(array) {
+  if (!array.length || !array[0]) {
+    return;
+  }
+  let max = array[0];
+  for (let i = 0; i < array.length; i++) {
+    const current = array[i];
+    if (current !== void 0 && current > max) {
+      max = current;
+    }
+  }
+  return max;
+}
+
+export {
+  randomInt,
+  randomIntRange,
+  shuffleArray,
+  clampNumber,
+  getArrayMax,
+  common_exports
+};

package/chunks/{chunk-VSYAOEKE.js → chunk-7DV4CM2Z.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-KH45J4DC.js";
+} from "./chunk-WSFCRVEQ.js";
 
 // src/agnostic/misc/data-size/index.ts
 var data_size_exports = {};

package/chunks/chunk-7FJKDVBE.js

@@ -0,0 +1,49 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/node/@google-cloud/storage/file/upload/index.ts
+var upload_exports = {};
+__export(upload_exports, {
+  upload: () => upload
+});
+async function upload(fileStream, targetPath, bucket, options) {
+  const { fileOptions, saveOptions } = options ?? {};
+  const { overwrite = false } = saveOptions ?? {};
+  const file = bucket.file(targetPath, fileOptions);
+  if (!overwrite) {
+    try {
+      const [exists] = await file.exists();
+      if (exists) {
+        return Outcome.makeFailure(`File already exists at ${targetPath}.`);
+      }
+    } catch (err) {
+      const errStr = unknownToString(err);
+      return Outcome.makeFailure(errStr);
+    }
+  }
+  try {
+    await new Promise((resolve, reject) => {
+      const writeStream = file.createWriteStream(saveOptions);
+      fileStream.pipe(writeStream);
+      fileStream.on("error", reject);
+      writeStream.on("finish", resolve);
+      writeStream.on("error", reject);
+    });
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return Outcome.makeFailure(errStr);
+  }
+}
+
+export {
+  upload,
+  upload_exports
+};

package/chunks/{chunk-2RFYHF6F.js → chunk-7J7CYOXU.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-FENXVJYO.js";
 import {
   __export
-} from "./chunk-KH45J4DC.js";
+} from "./chunk-WSFCRVEQ.js";
 
 // src/node/@google-cloud/storage/file/remove/index.ts
 var remove_exports = {};

package/chunks/{chunk-BOJEVEPB.js → chunk-7JUKBN7P.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-FENXVJYO.js";
 import {
   __export
-} from "./chunk-KH45J4DC.js";
+} from "./chunk-NZLE2WMY.js";
 
 // src/node/@express/@multer/index.ts
 var multer_exports = {};

package/chunks/chunk-7KCMLH6B.js

@@ -0,0 +1,22 @@
+import {
+  z
+} from "./chunk-XEAHMN2T.js";
+
+// src/node/images/transform/_utils/positions/index.ts
+var positionSchema = z.union([
+  z.number().min(0),
+  z.string()
+]).optional();
+var positionsSchema = z.object({
+  top: positionSchema,
+  left: positionSchema,
+  bottom: positionSchema,
+  right: positionSchema,
+  translateX: positionSchema,
+  translateY: positionSchema
+});
+
+export {
+  positionSchema,
+  positionsSchema
+};

package/chunks/chunk-7N7BJA6C.js

@@ -0,0 +1,36 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@aws-s3/storage/file/download/index.ts
+var download_exports = {};
+__export(download_exports, {
+  download: () => download
+});
+async function download(sourcePath, bucketName, s3, options) {
+  const { downloadSettings } = options ?? {};
+  const params = {
+    ...downloadSettings,
+    Bucket: bucketName,
+    Key: sourcePath
+  };
+  try {
+    const data = await s3.getObject(params).promise();
+    const stream = data.Body;
+    return Outcome.makeSuccess(stream);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return Outcome.makeFailure(errStr);
+  }
+}
+
+export {
+  download,
+  download_exports
+};

package/chunks/chunk-7OK5NZTY.js

@@ -0,0 +1,18 @@
+import {
+  esm_default
+} from "./chunk-YE67BQQN.js";
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+
+// src/node/images/transform/flip/index.ts
+var flipSchema = esm_default.object({
+  name: esm_default.literal(OperationNames.Flip),
+  params: esm_default.object({
+    flip: esm_default.boolean().optional()
+  })
+});
+
+export {
+  flipSchema
+};