@design-edito/tools 0.1.70 → 0.1.72

package/chunks/{chunk-E3GK7YZ7.js → chunk-FTGHUU73.js}

@@ -1,6 +1,6 @@
 import {
   esm_default
-} from "./chunk-YE67BQQN.js";
+} from "./chunk-T4KFB6QN.js";
 
 // src/node/images/transform/frame/backgrounds/create-tile-background/index.ts
 var TransitionNames = [

package/chunks/{chunk-ADTQQNIQ.js → chunk-FTOEQNF6.js}

@@ -6,16 +6,16 @@ import {
 } from "./chunk-FENXVJYO.js";
 import {
   __export
-} from "./chunk-NZLE2WMY.js";
+} from "./chunk-KH45J4DC.js";
 
 // src/node/ftps/file/upload/index.ts
 var upload_exports = {};
 __export(upload_exports, {
   upload: () => upload
 });
-async function upload(fileStream, targetPath, ftpClient, options) {
+async function upload(ftpClient, targetPath, fileStream, options) {
   const {
-    ensureDir = false,
+    ensureDir = true,
     overwrite = false
   } = options ?? {};
   try {

package/chunks/{chunk-DPBYDWV3.js → chunk-FVPFKY5G.js}

@@ -1,3 +1,6 @@
+import {
+  array
+} from "./chunk-VDNIN3V5.js";
 import {
   nullFunc
 } from "./chunk-QAVYONH6.js";
@@ -7,9 +10,6 @@ import {
 import {
   any
 } from "./chunk-FHLCPVND.js";
-import {
-  array
-} from "./chunk-QAQZEKIF.js";
 import {
   SmartTags
 } from "./chunk-UT2J62LH.js";
@@ -34,16 +34,12 @@ import {
 import {
   recordMap
 } from "./chunk-XNF5MLCQ.js";
-import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
 import {
   replaceAll
 } from "./chunk-ZTDVUXPR.js";
 import {
-  trimEnd,
-  trimStart
-} from "./chunk-6XL25OZX.js";
+  Outcome
+} from "./chunk-JMU5PDBD.js";
 import {
   Window
 } from "./chunk-RLJOYG64.js";
@@ -1587,7 +1583,7 @@ var Tree;
       return new Tree2(merged, null, null, options);
     }
     constructor(node, parent, pathFromParent, options) {
-      const { Element: Element2, Text: Text2, document: document2 } = Window.get();
+      const { Element: Element2, Text: Text2 } = Window.get();
       this.resolve = this.resolve.bind(this);
       this.setVariable = this.setVariable.bind(this);
       this.getVariable = this.getVariable.bind(this);
@@ -1596,6 +1592,7 @@ 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;
@@ -1732,32 +1729,20 @@ var Tree;
       const mutableSubtrees = /* @__PURE__ */ new Map();
       Array.from(childNodes).filter((child, _, childNodes2) => {
         if (child instanceof Element2) 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() !== "";
+        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;
       }).forEach((childNode) => {
         if (childNode instanceof Text2) {
-          const rawTextContent = childNode.textContent ?? "";
-          const textContent = rawTextContent.replace(/^\s*\n+\s*/, "").replace(/\s*\n+\s*$/, "");
-          const returnedChildNode = document2.createTextNode(textContent);
+          const hasContent = (childNode.textContent ?? "").trim() !== "";
+          if (hasContent) {
+            childNode.textContent = childNode.textContent?.trim() ?? "";
+          }
           mutableSubtrees.set(
             positionnedChildrenCount,
-            new Tree2(returnedChildNode, this, positionnedChildrenCount, this.options)
+            new Tree2(childNode, this, positionnedChildrenCount, this.options)
           );
           positionnedChildrenCount += 1;
         } else {
@@ -1876,20 +1861,57 @@ 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
+        enforceEvaluation,
+        perfCounters
       } = this;
       const cached = getCachedValue();
-      if (cached !== void 0) return cached;
+      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;
+      }
       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`);
+      perfCounters.evaluations++;
+      perfCounters.computeTime += time;
+      perfCounters.computeTimeAvg = perfCounters.computeTime / perfCounters.evaluations;
+      perfCounters.totalTime = perfCounters.computeTime + perfCounters.cacheTime;
       return evaluated;
     }
   }

package/chunks/chunk-FWR7ZA4M.js

@@ -0,0 +1,44 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/sftp/directory/remove-dir/index.ts
+var remove_dir_exports = {};
+__export(remove_dir_exports, {
+  removeDir: () => removeDir
+});
+async function removeDir(sftp, directoryPath, options) {
+  const { ignoreMissing = true } = options ?? {};
+  async function recurse(dir) {
+    const list = await sftp.list(dir);
+    for (const entry of list) {
+      const full = dir.endsWith("/") ? dir + entry.name : `${dir}/${entry.name}`;
+      if (entry.type === "d") {
+        await recurse(full);
+      } else if (entry.type === "-") {
+        await sftp.delete(full);
+      }
+    }
+    await sftp.rmdir(dir);
+  }
+  try {
+    await recurse(directoryPath);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    if (ignoreMissing && (err.code === 2 || err.code === "ENOENT")) {
+      return Outcome.makeSuccess(true);
+    }
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  removeDir,
+  remove_dir_exports
+};

package/chunks/{chunk-JBDWHJ4Q.js → chunk-G2XDDBWE.js}

@@ -6,17 +6,17 @@ import {
 } from "./chunk-FENXVJYO.js";
 import {
   __export
-} from "./chunk-WSFCRVEQ.js";
+} from "./chunk-KH45J4DC.js";
 
 // src/node/@google-cloud/storage/file/update-metadata/index.ts
 var update_metadata_exports = {};
 __export(update_metadata_exports, {
   updateFileMetadata: () => updateFileMetadata
 });
-async function updateFileMetadata(sourcePath, bucket, metadata, options) {
+async function updateFileMetadata(bucket, targetPath, metadata, options) {
   const { fileOptions, metadataOptions } = options ?? {};
   try {
-    const file = bucket.file(sourcePath, fileOptions);
+    const file = bucket.file(targetPath, fileOptions);
     await file.setMetadata(metadata, metadataOptions);
     return Outcome.makeSuccess(true);
   } catch (err) {

package/chunks/chunk-GDYVCEWA.js

@@ -0,0 +1,38 @@
+import {
+  getDocument
+} from "./chunk-73V5RDSG.js";
+import {
+  getWindow
+} from "./chunk-4GUDL44X.js";
+
+// src/agnostic/misc/crossenv/index.ts
+var Crossenv;
+((Crossenv2) => {
+  let RuntimeName;
+  ((RuntimeName2) => {
+    RuntimeName2["NODE"] = "Node.js";
+    RuntimeName2["BROWSER"] = "Browser";
+    RuntimeName2["DENO"] = "Deno";
+    RuntimeName2["REACT_NATIVE"] = "React Native";
+    RuntimeName2["ELECTRON"] = "Electron";
+    RuntimeName2["CLOUDFLARE"] = "Cloudflare Workers";
+    RuntimeName2["AWS_LAMBDA"] = "AWS Lambda";
+  })(RuntimeName = Crossenv2.RuntimeName || (Crossenv2.RuntimeName = {}));
+  function detectRuntime() {
+    if (typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined") return "Node.js" /* NODE */;
+    if (typeof window !== "undefined" && typeof window.document !== "undefined") return "Browser" /* BROWSER */;
+    if (typeof Deno !== "undefined") return "Deno" /* DENO */;
+    if (typeof process !== "undefined" && typeof navigator.userAgent === "string" && /ReactNative/.test(navigator.userAgent)) return "React Native" /* REACT_NATIVE */;
+    if (typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.version.electron !== "undefined") return "Electron" /* ELECTRON */;
+    if (typeof self !== "undefined" && typeof self.addEventListener === "function" && typeof Headers !== "undefined") return "Cloudflare Workers" /* CLOUDFLARE */;
+    if (typeof AWS !== "undefined" && typeof AWS.Lambda !== "undefined") return "AWS Lambda" /* AWS_LAMBDA */;
+    return null;
+  }
+  Crossenv2.detectRuntime = detectRuntime;
+  Crossenv2.getWindow = getWindow;
+  Crossenv2.getDocument = getDocument;
+})(Crossenv || (Crossenv = {}));
+
+export {
+  Crossenv
+};

package/chunks/chunk-GKTDEHC6.js

@@ -0,0 +1,39 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/sftp/directory/move-dir/index.ts
+var move_dir_exports = {};
+__export(move_dir_exports, {
+  moveDir: () => moveDir
+});
+async function moveDir(sftp, sourceDir, targetDir, options) {
+  const { overwrite = false, ensureDir = true } = options ?? {};
+  try {
+    if (ensureDir) {
+      const parentDir = targetDir.substring(0, targetDir.lastIndexOf("/"));
+      if (parentDir) {
+        await sftp.mkdir(parentDir, true);
+      }
+    }
+    if (!overwrite) {
+      const exists = await sftp.exists(targetDir);
+      if (exists) return Outcome.makeFailure(`Target ${targetDir} already exists.`);
+    }
+    await sftp.rename(sourceDir, targetDir);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  moveDir,
+  move_dir_exports
+};

package/chunks/{chunk-3LPD7IXF.js → chunk-GZWZ5SSG.js}

@@ -1,52 +1,56 @@
 import {
   revoke_signed_urls_exports
-} from "./chunk-UUSZJMJB.js";
+} from "./chunk-UBJACMOZ.js";
 import {
   update_metadata_exports
-} from "./chunk-YW5ASSIQ.js";
-import {
-  erase_exports
-} from "./chunk-7BCQCDGQ.js";
-import {
-  exists_exports
-} from "./chunk-TXGV4KJD.js";
+} from "./chunk-G2XDDBWE.js";
 import {
   generate_signed_url_exports
-} from "./chunk-OPU4CANL.js";
+} from "./chunk-6NZOSESD.js";
+import {
+  get_permissions_exports
+} from "./chunk-NXV33ZSC.js";
 import {
   get_metadata_exports
-} from "./chunk-KFMYB672.js";
+} from "./chunk-6STIUASQ.js";
 import {
-  get_permissions_exports
-} from "./chunk-GXICX4F6.js";
+  remove_exports
+} from "./chunk-2RFYHF6F.js";
 import {
-  move_exports
-} from "./chunk-T55QIYYV.js";
+  stat_exports
+} from "./chunk-JKAHSFJD.js";
+import {
+  upload_exports
+} from "./chunk-MP6CL7F7.js";
 import {
   copy_exports
-} from "./chunk-SZQHLC4K.js";
+} from "./chunk-4XS5UIQF.js";
 import {
   download_exports
-} from "./chunk-IARWH6LC.js";
+} from "./chunk-MPYCQ5IF.js";
 import {
-  upload_exports
-} from "./chunk-7FJKDVBE.js";
+  move_exports
+} from "./chunk-XIMUZN5X.js";
+import {
+  exists_exports
+} from "./chunk-BTJ2JXDV.js";
 import {
   __export
-} from "./chunk-NZLE2WMY.js";
+} from "./chunk-KH45J4DC.js";
 
 // src/node/@google-cloud/storage/file/index.ts
 var file_exports = {};
 __export(file_exports, {
   Copy: () => copy_exports,
   Download: () => download_exports,
-  Erase: () => erase_exports,
   Exists: () => exists_exports,
   GenerateSignedUrl: () => generate_signed_url_exports,
   GetMetaData: () => get_metadata_exports,
   GetPermissions: () => get_permissions_exports,
   Move: () => move_exports,
+  Remove: () => remove_exports,
   RevokeSignedUrls: () => revoke_signed_urls_exports,
+  Stat: () => stat_exports,
   UpdateMetadata: () => update_metadata_exports,
   Upload: () => upload_exports
 });

package/chunks/chunk-H4NHF72W.js

@@ -0,0 +1,40 @@
+import {
+  require_dist_cjs4 as require_dist_cjs
+} from "./chunk-IZP4VIFZ.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export,
+  __toESM
+} from "./chunk-KH45J4DC.js";
+
+// src/node/@aws-s3/storage/file/download/index.ts
+var download_exports = {};
+__export(download_exports, {
+  download: () => download
+});
+var import_client_s3 = __toESM(require_dist_cjs(), 1);
+async function download(client, bucketName, sourcePath, options) {
+  try {
+    const response = await client.send(
+      new import_client_s3.GetObjectCommand({
+        Bucket: bucketName,
+        Key: sourcePath,
+        ...options
+      })
+    );
+    const stream = response.Body;
+    return Outcome.makeSuccess(stream);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  download,
+  download_exports
+};

package/chunks/{chunk-FVFYLT5T.js → chunk-H5HM5EBO.js}

@@ -1,19 +1,19 @@
+import {
+  randomPick,
+  randomPickMany
+} from "./chunk-72NLUT3X.js";
 import {
   findDuplicates
 } from "./chunk-YS6WMSWC.js";
+import {
+  shuffle
+} from "./chunk-VJJIYJMY.js";
 import {
   make
 } from "./chunk-RLAZR3NL.js";
 import {
   isArrayOf
 } from "./chunk-6RGDWX4A.js";
-import {
-  shuffle
-} from "./chunk-VJJIYJMY.js";
-import {
-  randomPick,
-  randomPickMany
-} from "./chunk-AQBJ6HNB.js";
 
 // src/agnostic/arrays/index.tsx
 var Arrays;

package/chunks/chunk-HCNRPWKW.js

@@ -0,0 +1,63 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  Errors
+} from "./chunk-WH6BPDAC.js";
+
+// src/agnostic/misc/assert/index.ts
+var Assert;
+((Assert2) => {
+  function makeSuccess(label) {
+    console.info(`\u2705 SUCCESS: "${label}"`);
+  }
+  function makeFailure(label) {
+    throw new Error(`\u{1F6AB} FAILURE: "${label}""`);
+  }
+  async function assert(label, assertion) {
+    if (typeof assertion === "boolean") return assertion ? Outcome.makeSuccess(label) : Outcome.makeFailure(label);
+    else if (typeof assertion === "function") {
+      try {
+        const result = await assertion();
+        if (result === false) return Outcome.makeFailure(label);
+        else return Outcome.makeSuccess(label);
+      } catch (err) {
+        const errStr = Errors.unknownToString(err);
+        return Outcome.makeFailure(`${label} / ${errStr}`);
+      }
+    } else {
+      let assertions;
+      if (Array.isArray(assertion)) {
+        assertions = [...assertion].map((a, p) => [`${p}`, a]);
+      } else if (assertion instanceof Map) {
+        assertions = Array.from(assertion);
+      } else {
+        assertions = Object.entries(assertion);
+      }
+      const allAsserted = await Promise.all(assertions.map(([innerLabel, innerAssertion]) => {
+        const fullLabel = `${label} / ${innerLabel}`;
+        const asserted = assert(fullLabel, innerAssertion);
+        return asserted;
+      }));
+      const allSuccess = allAsserted.every((asserted) => asserted.success);
+      if (allSuccess) return Outcome.makeSuccess(allAsserted.map((e) => e.payload).join("\n"));
+      const failures = allAsserted.filter((asserted) => asserted.success === false);
+      const failuresStr = failures.map((failure) => failure.error).join("\n  ");
+      return Outcome.makeFailure(failuresStr);
+    }
+  }
+  Assert2.assert = assert;
+  async function assertVerbose(label, assertion) {
+    const asserted = await assert(label, assertion);
+    if (asserted?.success) {
+      makeSuccess(asserted.payload);
+      return asserted;
+    }
+    return makeFailure(asserted.error);
+  }
+  Assert2.assertVerbose = assertVerbose;
+})(Assert || (Assert = {}));
+
+export {
+  Assert
+};

package/chunks/chunk-HDGHODNO.js

@@ -0,0 +1,28 @@
+import {
+  list_exports
+} from "./chunk-ZAIWJI6A.js";
+import {
+  move_dir_exports
+} from "./chunk-2UPQ73EE.js";
+import {
+  remove_dir_exports
+} from "./chunk-LF4VYSOT.js";
+import {
+  copy_dir_exports
+} from "./chunk-5WARYKLO.js";
+import {
+  __export
+} from "./chunk-KH45J4DC.js";
+
+// src/node/@aws-s3/storage/directory/index.ts
+var directory_exports = {};
+__export(directory_exports, {
+  CopyDir: () => copy_dir_exports,
+  List: () => list_exports,
+  MoveDir: () => move_dir_exports,
+  RemoveDir: () => remove_dir_exports
+});
+
+export {
+  directory_exports
+};