@design-edito/tools 0.1.72 → 0.2.0

package/chunks/chunk-YB2KZLMN.js

@@ -0,0 +1,65 @@
+import {
+  zod_default
+} from "./chunk-FI675VZO.js";
+
+// src/node/images/transform/frame/backgrounds/create-tile-background/index.ts
+var TransitionNames = [
+  "linear",
+  "ease-in-quad",
+  "ease-out-quad",
+  "ease-in-out-quad",
+  "ease-in-cubic",
+  "ease-out-cubic",
+  "ease-in-out-cubic",
+  "ease-in-quart",
+  "ease-out-quart",
+  "ease-in-out-quart",
+  "ease-in-quint",
+  "ease-out-quint",
+  "ease-in-out-quint",
+  "ease-in-sine",
+  "ease-out-sine",
+  "ease-in-out-sine",
+  "ease-in-expo",
+  "ease-out-expo",
+  "ease-in-out-expo",
+  "ease-in-circ",
+  "ease-out-circ",
+  "ease-in-out-circ",
+  "ease-in-back",
+  "ease-out-back",
+  "ease-in-out-back",
+  "ease-in-elastic",
+  "ease-out-elastic",
+  "ease-in-out-elastic",
+  "ease-in-bounce",
+  "ease-out-bounce",
+  "ease-in-out-bounce"
+];
+var createTileBackgroundSchema = zod_default.object({
+  type: zod_default.literal("tile"),
+  params: zod_default.object({
+    coverageRatio: zod_default.number(),
+    densityA: zod_default.object({
+      min: zod_default.number(),
+      max: zod_default.number()
+    }),
+    densityB: zod_default.object({
+      min: zod_default.number(),
+      max: zod_default.number()
+    }),
+    format: zod_default.enum([
+      "random",
+      "default",
+      "portrait",
+      "landscape"
+    ]),
+    xEasing: zod_default.enum(TransitionNames),
+    yEasing: zod_default.enum(TransitionNames)
+  })
+});
+
+export {
+  TransitionNames,
+  createTileBackgroundSchema
+};

package/chunks/chunk-YDIFL3IZ.js

@@ -0,0 +1,151 @@
+import {
+  formatImage
+} from "./chunk-C2MFLI7A.js";
+import {
+  transform
+} from "./chunk-7CHYRYXJ.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/images/prepare/index.ts
+var prepare_exports = {};
+__export(prepare_exports, {
+  MAX_NB_OUTPUTS: () => MAX_NB_OUTPUTS,
+  OUTPUT_ZIP_FOLDER: () => OUTPUT_ZIP_FOLDER,
+  exportZipBuffer: () => exportZipBuffer,
+  prepareImage: () => prepareImage
+});
+import sharp from "sharp";
+import { Writable } from "node:stream";
+import archiver from "archiver";
+var MAX_NB_OUTPUTS = 50;
+var OUTPUT_ZIP_FOLDER = "./output-zips";
+async function prepareImage(imageBuffer, customOptions) {
+  const sharpImage = sharp(imageBuffer);
+  const sharpImageMetadata = await sharpImage.metadata();
+  const imageBufferMetadata = {
+    width: sharpImageMetadata.width ?? 0,
+    height: sharpImageMetadata.height ?? 0,
+    format: sharpImageMetadata.format || "png"
+  };
+  const options = getOptions(imageBufferMetadata, customOptions);
+  const nbOutputs = options.qualities.length * (options.ratios.length + 1) * (options.widths.length + 1) * (options.heights.length + 1);
+  if (nbOutputs > MAX_NB_OUTPUTS) throw Error("Nb output exceeds supported max nb output");
+  let transformedBuffer = imageBuffer;
+  try {
+    transformedBuffer = await transform(imageBuffer, options.inputOperations, options.checkValidOperations);
+  } catch (e) {
+    console.log("Images:Prepare:Transform:Buffer:Error", { e });
+  }
+  const transformedBufferMetadata = await sharp(transformedBuffer).metadata();
+  const exportsBuffers = [
+    {
+      buffer: imageBuffer,
+      name: generateFileName({
+        ...imageBufferMetadata,
+        quality: 100,
+        suffix: "original",
+        prefix: options.name
+      })
+    },
+    {
+      buffer: transformedBuffer,
+      name: generateFileName({
+        width: transformedBufferMetadata.width || 0,
+        height: transformedBufferMetadata.height || 0,
+        format: transformedBufferMetadata.format || "png",
+        quality: 100,
+        suffix: "transformed-unresized",
+        prefix: options.name
+      })
+    }
+  ];
+  for (const width of options.widths) {
+    for (const height of options.heights) {
+      for (const quality of options.qualities) {
+        for (const format of options.formats) {
+          const exportBuffer = await formatImage(transformedBuffer, {
+            format,
+            quality,
+            width,
+            height
+          });
+          exportsBuffers.push({
+            buffer: exportBuffer,
+            name: generateFileName({
+              width,
+              height,
+              quality,
+              format,
+              prefix: options.name
+            })
+          });
+        }
+      }
+    }
+  }
+  console.log("Images:Transform:Export:ZIP", generateZipName(options.name));
+  const zipBuffer = exportZipBuffer(exportsBuffers, generateZipName(options.name));
+  return zipBuffer;
+}
+function exportZipBuffer(zipSources, zipDirectoryName) {
+  return new Promise(async (resolve) => {
+    const archive = archiver("zip", { zlib: { level: 9 } });
+    if (zipDirectoryName) {
+      archive.directory(zipDirectoryName + "/", false);
+    }
+    zipSources.forEach((zipSource) => {
+      const fileName = zipDirectoryName ? `${zipDirectoryName}/${zipSource.name}` : zipSource.name;
+      archive.append(zipSource.buffer, { name: fileName });
+    });
+    const chunks = [];
+    const writable = new Writable();
+    writable._write = (chunk, _enc, callback) => {
+      chunks.push(chunk);
+      callback();
+    };
+    archive.pipe(writable);
+    await archive.finalize();
+    const bufferZip = Buffer.concat(chunks);
+    resolve(bufferZip);
+  });
+}
+function getOptions(imageBufferMetadata, options) {
+  return {
+    center: [0.5, 0.5],
+    qualities: [100],
+    inputOperations: [],
+    ...options,
+    checkValidOperations: options?.checkValidOperations ?? false,
+    name: options?.name ?? "",
+    formats: [imageBufferMetadata.format, ...options?.formats ? options.formats : []],
+    ratios: [...options?.ratios ? options.ratios : []],
+    widths: [imageBufferMetadata.width, ...options?.widths ? options.widths : []],
+    heights: [imageBufferMetadata.height, ...options?.heights ? options.heights : []]
+  };
+}
+function generateZipName(name = "") {
+  const date = /* @__PURE__ */ new Date();
+  return `${name}_image-exports_${date.toLocaleDateString()}_${date.toLocaleTimeString()}_${date.getTime()}`.replace(/\/|:/g, "-").replace(/ /g, "").trim();
+}
+function generateFileName({
+  width,
+  height,
+  quality,
+  format,
+  suffix,
+  prefix
+}) {
+  prefix = prefix ? `${prefix}_` : "image-formats_";
+  suffix = `${suffix ? `_${suffix}` : ""}.${format}`;
+  return `${prefix}${width}x${height}_Q${quality}${suffix}`;
+}
+
+export {
+  MAX_NB_OUTPUTS,
+  OUTPUT_ZIP_FOLDER,
+  prepareImage,
+  exportZipBuffer,
+  prepare_exports
+};

package/chunks/chunk-YJE3G6BE.js

@@ -0,0 +1,16 @@
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+import {
+  zod_default
+} from "./chunk-OT4SVHDX.js";
+
+// src/node/images/transform/saturate/index.ts
+var saturateSchema = zod_default.object({
+  name: zod_default.literal(OperationNames.Saturate),
+  params: zod_default.number().min(0)
+});
+
+export {
+  saturateSchema
+};

package/chunks/{chunk-NXV33ZSC.js → chunk-YKPA3MQL.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/get-permissions/index.ts
 var get_permissions_exports = {};

package/chunks/chunk-YVWQXQTE.js

@@ -0,0 +1,42 @@
+import {
+  stat as stat4
+} from "./chunk-W3RXHN5I.js";
+import {
+  stat as stat3
+} from "./chunk-VROZGPC5.js";
+import {
+  stat
+} from "./chunk-CNYSX2L2.js";
+import {
+  stat as stat2
+} from "./chunk-TGVYEQIA.js";
+import {
+  isFtpClient,
+  isGcsBucket,
+  isS3ClientWithBucket,
+  isSftpClient
+} from "./chunk-V3GX7SIJ.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/cloud-storage/operations/stat-file/index.ts
+var stat_file_exports = {};
+__export(stat_file_exports, {
+  statFile: () => statFile
+});
+async function statFile(client, path, options) {
+  if (isGcsBucket(client)) return stat4(client, path, options);
+  if (isS3ClientWithBucket(client)) return stat3(client.client, path, client.bucketName, options);
+  if (isFtpClient(client)) return stat(client, path);
+  if (isSftpClient(client)) return stat2(client, path);
+  return Outcome.makeFailure("Invalid client type");
+}
+
+export {
+  statFile,
+  stat_file_exports
+};

package/chunks/{chunk-S3GEV44K.js → chunk-Z4B2Z7QO.js}

@@ -1,18 +1,18 @@
 import {
   nullFunc
 } from "./chunk-QAVYONH6.js";
-import {
-  any
-} from "./chunk-FHLCPVND.js";
-import {
-  array
-} from "./chunk-QAQZEKIF.js";
 import {
   Serialize
 } from "./chunk-SXRWMH3U.js";
 import {
   Types
 } from "./chunk-XEQ2PBT2.js";
+import {
+  any
+} from "./chunk-FHLCPVND.js";
+import {
+  array
+} from "./chunk-QAQZEKIF.js";
 import {
   SmartTags
 } from "./chunk-UT2J62LH.js";
@@ -35,15 +35,15 @@ import {
   isRecord
 } from "./chunk-YDIBNEGA.js";
 import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
+  replaceAll
+} from "./chunk-ZTDVUXPR.js";
 import {
   trimEnd,
   trimStart
 } from "./chunk-6XL25OZX.js";
 import {
-  replaceAll
-} from "./chunk-ZTDVUXPR.js";
+  Outcome
+} from "./chunk-JMU5PDBD.js";
 import {
   Window
 } from "./chunk-RLJOYG64.js";
@@ -92,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;
@@ -377,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);
   }
 });
 
@@ -991,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;
@@ -1004,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]);
+    }
   }
 });
 
@@ -1019,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);
   }
 });
 
@@ -1164,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;
@@ -1177,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]);
+    }
   }
 });
 
@@ -1374,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
@@ -1383,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);
   }
 });
 
@@ -2255,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-NHMEZ6ZP.js → chunk-ZEZCYPLQ.js}

@@ -1,6 +1,3 @@
-import {
-  require_dist_cjs4 as require_dist_cjs
-} from "./chunk-IZP4VIFZ.js";
 import {
   Outcome
 } from "./chunk-JMU5PDBD.js";
@@ -8,21 +5,22 @@ import {
   unknownToString
 } from "./chunk-FENXVJYO.js";
 import {
-  __export,
-  __toESM
-} from "./chunk-KH45J4DC.js";
+  __export
+} from "./chunk-WSFCRVEQ.js";
 
 // src/node/@aws-s3/storage/file/exists/index.ts
 var exists_exports = {};
 __export(exists_exports, {
   exists: () => exists
 });
-var import_client_s3 = __toESM(require_dist_cjs(), 1);
+import {
+  HeadObjectCommand
+} from "@aws-sdk/client-s3";
 async function exists(client, bucketName, sourcePath, options) {
   const { headObjectOptions } = options ?? {};
   try {
     await client.send(
-      new import_client_s3.HeadObjectCommand({
+      new HeadObjectCommand({
         Bucket: bucketName,
         Key: sourcePath,
         ...headObjectOptions

package/chunks/chunk-ZH3QMMVD.js

@@ -0,0 +1,28 @@
+import {
+  copy_dir_exports
+} from "./chunk-4XBUJAQU.js";
+import {
+  list_exports
+} from "./chunk-ZSUG52DO.js";
+import {
+  move_dir_exports
+} from "./chunk-ON6LC3HE.js";
+import {
+  remove_dir_exports
+} from "./chunk-4XSDRT23.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.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
+};

package/chunks/{chunk-B7E3DQ4Z.js → chunk-ZJTWDCNZ.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-FENXVJYO.js";
 import {
   __export
-} from "./chunk-KH45J4DC.js";
+} from "./chunk-WSFCRVEQ.js";
 
 // src/node/ftps/file/exists/index.ts
 var exists_exports = {};