@design-edito/tools 0.1.71 → 0.1.73

package/chunks/chunk-2VJ4QISD.js

@@ -0,0 +1,28 @@
+import {
+  move_dir_exports
+} from "./chunk-BE7OXZRK.js";
+import {
+  remove_dir_exports
+} from "./chunk-BSUQNHAM.js";
+import {
+  copy_dir_exports
+} from "./chunk-N2T672IG.js";
+import {
+  list_exports
+} from "./chunk-3CLGBOHN.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/ftps/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-2VXYXVV2.js

@@ -0,0 +1,164 @@
+import {
+  getRelativePxPositionsInWrapperFor
+} from "./chunk-OCM3RLO6.js";
+import {
+  createColorPalette
+} from "./chunk-GD6Y5QJV.js";
+import {
+  createLineBackground
+} from "./chunk-C4Q4PC53.js";
+import {
+  createTileBackground
+} from "./chunk-CP454IJD.js";
+import {
+  clamp
+} from "./chunk-OSAXBA7G.js";
+
+// src/node/images/transform/operations/_utils/frame/index.ts
+import sharp from "sharp";
+async function frame(imageSharp, params) {
+  const imageMetadata = await imageSharp.metadata();
+  const imageDimensions = {
+    widthPx: imageMetadata.width ?? 0,
+    heightPx: imageMetadata.height ?? 0
+  };
+  const scaledImage = scaleImageToFrame(
+    imageSharp,
+    imageDimensions,
+    params.dimensions,
+    params.imageScale
+  );
+  imageSharp = scaledImage.sharpInstance;
+  imageDimensions.widthPx = scaledImage.widthPx;
+  imageDimensions.heightPx = scaledImage.heightPx;
+  const defaultBackgroundColorCreate = getDefaultBackgroundColor(params.background);
+  const imagePositions = getRelativePxPositionsInWrapperFor(imageDimensions, params.dimensions, params.positions);
+  const backgroundOverlays = await getBackgroundOverlays(
+    {
+      sharp: imageSharp,
+      dimensions: imageDimensions
+    },
+    params.background,
+    params.dimensions,
+    {
+      x: imagePositions.x,
+      y: imagePositions.y,
+      w: imageDimensions.widthPx,
+      h: imageDimensions.heightPx
+    }
+  );
+  const composition = [
+    ...backgroundOverlays,
+    {
+      input: await imageSharp.toFormat("png").png({ quality: 100 }).toBuffer(),
+      /* Make sure we work with the best quality of our file */
+      left: imagePositions.x,
+      top: imagePositions.y
+    }
+  ];
+  const frameSharpInstance = sharp({
+    create: {
+      background: defaultBackgroundColorCreate,
+      width: params.dimensions.widthPx,
+      height: params.dimensions.heightPx,
+      channels: 4
+    }
+  }).ensureAlpha(0).composite(composition).png({ quality: 100 });
+  return frameSharpInstance;
+}
+var scaleImageToFrame = (imageSharp, imageDimensions, frameDimensions, imageScale) => {
+  const scale = {
+    xRatio: 1,
+    yRatio: 1
+  };
+  const frameZoneDimensions = {
+    widthPx: frameDimensions.widthPx,
+    heightPx: frameDimensions.heightPx
+  };
+  if (imageScale) {
+    frameZoneDimensions.widthPx = frameDimensions.widthPx * (imageScale.xRatio || 1);
+    frameZoneDimensions.heightPx = frameDimensions.heightPx * (imageScale.yRatio || 1);
+  }
+  const containedRatiosPercents = getContainedRatios(
+    imageDimensions.widthPx,
+    imageDimensions.heightPx,
+    frameZoneDimensions.widthPx,
+    frameZoneDimensions.heightPx
+  );
+  if (imageScale || !imageScale && imageDimensions.widthPx < frameDimensions.widthPx && imageDimensions.heightPx < frameDimensions.heightPx) {
+    scale.xRatio = containedRatiosPercents.xPercent;
+    scale.yRatio = containedRatiosPercents.yPercent;
+  }
+  if (scale.xRatio !== 1 || scale.yRatio !== 1) {
+    imageDimensions.widthPx = clamp(Math.round(imageDimensions.widthPx * scale.xRatio), 0, frameDimensions.widthPx);
+    imageDimensions.heightPx = clamp(Math.round(imageDimensions.heightPx * scale.yRatio), 0, frameDimensions.heightPx);
+    imageSharp = imageSharp.resize({
+      width: imageDimensions.widthPx,
+      height: imageDimensions.heightPx,
+      fit: sharp.fit.inside,
+      position: "center",
+      fastShrinkOnLoad: false
+    });
+  }
+  return {
+    sharpInstance: imageSharp,
+    widthPx: imageDimensions.widthPx,
+    heightPx: imageDimensions.heightPx
+  };
+};
+var getDefaultBackgroundColor = (background) => {
+  if (background && (typeof background === "object" && "r" in background)) {
+    return {
+      r: background.r || 255,
+      g: background.g || 255,
+      b: background.b || 255,
+      alpha: background.alpha || 0
+    };
+  }
+  return { r: 255, g: 255, b: 255, alpha: 0 };
+};
+var getBackgroundOverlays = (imageInput, background, dimensions, imageCoordinates) => {
+  const backgroundOverlays = [];
+  return new Promise(async (resolve, reject) => {
+    if (!background || typeof background !== "object" || typeof background === "object" && !("type" in background)) {
+      resolve(backgroundOverlays);
+      return;
+    }
+    const imageBuffer = await imageInput.sharp.raw().toBuffer();
+    const nbImageChannels = (await imageInput.sharp.metadata()).channels || 3;
+    const colorPalette = createColorPalette(
+      {
+        buffer: imageBuffer,
+        nbChannels: nbImageChannels,
+        dimensions: imageInput.dimensions
+      },
+      background.colorPalette
+    );
+    switch (background.type) {
+      case "line":
+        return resolve(createLineBackground(background, dimensions, colorPalette));
+      case "tile":
+        return resolve(createTileBackground(background, dimensions, imageCoordinates, colorPalette));
+      default:
+        resolve(backgroundOverlays);
+    }
+    reject(new Error("Unknown background type"));
+  });
+};
+function getContainedRatios(widthPx, heightPx, wrapperWidthPx, wrapperHeightPx, withoutReduction) {
+  if (withoutReduction && widthPx <= wrapperWidthPx && heightPx <= wrapperHeightPx) {
+    return { xPercent: 100, yPercent: 100 };
+  }
+  const wrapperRatio = wrapperWidthPx / wrapperHeightPx;
+  const imgRatio = widthPx / heightPx;
+  const containRatio = clamp(imgRatio > wrapperRatio ? wrapperWidthPx / widthPx : wrapperHeightPx / heightPx, 0, 100);
+  return {
+    xPercent: containRatio,
+    yPercent: containRatio
+  };
+}
+
+export {
+  frame,
+  getContainedRatios
+};

package/chunks/chunk-32FNUJVW.js

@@ -0,0 +1,31 @@
+import {
+  make
+} from "./chunk-RLAZR3NL.js";
+import {
+  randomPick,
+  randomPickMany
+} from "./chunk-B446JIN3.js";
+import {
+  shuffle
+} from "./chunk-VJJIYJMY.js";
+import {
+  findDuplicates
+} from "./chunk-YS6WMSWC.js";
+import {
+  isArrayOf
+} from "./chunk-6RGDWX4A.js";
+
+// src/agnostic/arrays/index.tsx
+var Arrays;
+((Arrays2) => {
+  Arrays2.findDuplicates = findDuplicates;
+  Arrays2.isArrayOf = isArrayOf;
+  Arrays2.make = make;
+  Arrays2.randomPick = randomPick;
+  Arrays2.randomPickMany = randomPickMany;
+  Arrays2.shuffle = shuffle;
+})(Arrays || (Arrays = {}));
+
+export {
+  Arrays
+};

package/chunks/chunk-36CTYZYA.js

@@ -0,0 +1,28 @@
+import {
+  Sanitize
+} from "./chunk-JWF5EKM2.js";
+import {
+  register
+} from "./chunk-CHUOCTRP.js";
+
+// src/agnostic/html/string-to-nodes/index.ts
+function stringToNodes(dirtyStr, options) {
+  const actualDocument = options?.documentObj ?? window.document;
+  if (actualDocument === null) throw register.getError("no-window-document-on-runtime-please-provide" /* NO_DOCUMENT_PLEASE_PROVIDE */, "See documentObj in the options object");
+  const sanitizeOptions = {
+    ...options?.sanitize,
+    documentObj: options?.sanitize?.documentObj ?? options?.documentObj
+  };
+  const str = options?.sanitize !== void 0 ? Sanitize.sanitize(dirtyStr, sanitizeOptions) : dirtyStr;
+  const wrapperDiv = actualDocument.createElement("div");
+  wrapperDiv.innerHTML = str;
+  const nodes = Array.from(wrapperDiv.childNodes).filter((node) => {
+    const allowedNodeTypes = [Node.ELEMENT_NODE, Node.TEXT_NODE];
+    return allowedNodeTypes.includes(node.nodeType);
+  });
+  return nodes;
+}
+
+export {
+  stringToNodes
+};

package/chunks/chunk-37TRFYZT.js

@@ -0,0 +1,35 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@google-cloud/storage/directory/list/index.ts
+var list_exports = {};
+__export(list_exports, {
+  list: () => list
+});
+async function list(bucket, directoryPath, options) {
+  const { fileOptions } = options ?? {};
+  try {
+    const prefix = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+    const [files] = await bucket.getFiles({
+      prefix,
+      delimiter: "/",
+      ...fileOptions
+    });
+    const paths = files.map((file) => file.name);
+    return Outcome.makeSuccess(paths);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  list,
+  list_exports
+};

package/chunks/chunk-3CGRUS5C.js

@@ -0,0 +1,37 @@
+import {
+  Cast,
+  Tree,
+  Utils
+} from "./chunk-766BSKLU.js";
+import {
+  Serialize
+} from "./chunk-SXRWMH3U.js";
+import {
+  Types
+} from "./chunk-XEQ2PBT2.js";
+import {
+  SmartTags
+} from "./chunk-UT2J62LH.js";
+import {
+  Transformer
+} from "./chunk-BKO7GLC2.js";
+import {
+  Method
+} from "./chunk-RW7VAKJW.js";
+
+// src/agnostic/html/hyper-json/index.ts
+var HyperJson;
+((HyperJson2) => {
+  HyperJson2.Cast = Cast;
+  HyperJson2.Method = Method;
+  HyperJson2.Serialize = Serialize;
+  HyperJson2.SmartTags = SmartTags;
+  HyperJson2.Transformer = Transformer;
+  HyperJson2.Tree = Tree;
+  HyperJson2.Types = Types;
+  HyperJson2.Utils = Utils;
+})(HyperJson || (HyperJson = {}));
+
+export {
+  HyperJson
+};

package/chunks/chunk-3CLGBOHN.js

@@ -0,0 +1,29 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/ftps/directory/list/index.ts
+var list_exports = {};
+__export(list_exports, {
+  list: () => list
+});
+async function list(ftpClient, directoryPath) {
+  try {
+    const list2 = await ftpClient.list(directoryPath);
+    const files = list2.filter((entry) => entry.isFile).map((entry) => directoryPath.endsWith("/") ? `${directoryPath}${entry.name}` : `${directoryPath}/${entry.name}`);
+    return Outcome.makeSuccess(files);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  list,
+  list_exports
+};

package/chunks/chunk-3DL3U7UR.js

@@ -0,0 +1,40 @@
+import {
+  remove_exports
+} from "./chunk-ANPXBD2G.js";
+import {
+  move_exports
+} from "./chunk-FE4DECBU.js";
+import {
+  upload_exports
+} from "./chunk-QDVDHFMZ.js";
+import {
+  stat_exports
+} from "./chunk-TGVYEQIA.js";
+import {
+  copy_exports
+} from "./chunk-QH64MYGA.js";
+import {
+  download_exports
+} from "./chunk-HWEGQVBQ.js";
+import {
+  exists_exports
+} from "./chunk-QVPS2BCJ.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/sftp/file/index.ts
+var file_exports = {};
+__export(file_exports, {
+  Copy: () => copy_exports,
+  Download: () => download_exports,
+  Exists: () => exists_exports,
+  Move: () => move_exports,
+  Remove: () => remove_exports,
+  Stat: () => stat_exports,
+  Upload: () => upload_exports
+});
+
+export {
+  file_exports
+};

package/chunks/chunk-3G7KHSKB.js

@@ -0,0 +1,60 @@
+import {
+  update_metadata_exports
+} from "./chunk-HWVEI3RH.js";
+import {
+  generate_signed_url_exports
+} from "./chunk-PAIUCLVK.js";
+import {
+  get_metadata_exports
+} from "./chunk-42K3MQQ5.js";
+import {
+  get_permissions_exports
+} from "./chunk-YKPA3MQL.js";
+import {
+  revoke_signed_urls_exports
+} from "./chunk-G5RRNREY.js";
+import {
+  move_exports
+} from "./chunk-6IYUA43Q.js";
+import {
+  remove_exports
+} from "./chunk-7J7CYOXU.js";
+import {
+  stat_exports
+} from "./chunk-W3RXHN5I.js";
+import {
+  upload_exports
+} from "./chunk-FB3GNE2B.js";
+import {
+  copy_exports
+} from "./chunk-CWZFRUBS.js";
+import {
+  download_exports
+} from "./chunk-2JH4TCT2.js";
+import {
+  exists_exports
+} from "./chunk-5VHFXWFM.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@google-cloud/storage/file/index.ts
+var file_exports = {};
+__export(file_exports, {
+  Copy: () => copy_exports,
+  Download: () => download_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
+});
+
+export {
+  file_exports
+};

package/chunks/chunk-3TKBCG7Y.js

@@ -0,0 +1,40 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@aws-s3/storage/file/remove/index.ts
+var remove_exports = {};
+__export(remove_exports, {
+  remove: () => remove
+});
+import { HeadObjectCommand, DeleteObjectCommand } from "@aws-sdk/client-s3";
+async function remove(s3, bucketName, targetPath, options) {
+  const { ignoreMissing = true } = options ?? {};
+  try {
+    try {
+      await s3.send(new HeadObjectCommand({ Bucket: bucketName, Key: targetPath }));
+    } catch (err) {
+      const code = err?.name ?? err?.Code ?? err?.code;
+      if (code === "NotFound" || code === "NoSuchKey" || code === "NotFoundException") {
+        if (ignoreMissing) return Outcome.makeSuccess(true);
+        return Outcome.makeFailure(`File not found at ${targetPath}.`);
+      }
+      return Outcome.makeFailure(unknownToString(err));
+    }
+    await s3.send(new DeleteObjectCommand({ Bucket: bucketName, Key: targetPath }));
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  remove,
+  remove_exports
+};

package/chunks/chunk-42K3MQQ5.js

@@ -0,0 +1,31 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@google-cloud/storage/file/get-metadata/index.ts
+var get_metadata_exports = {};
+__export(get_metadata_exports, {
+  getMetadata: () => getMetadata
+});
+async function getMetadata(bucket, sourcePath, options) {
+  const { fileOptions, getFileMetadataOptions } = options ?? {};
+  try {
+    const file = bucket.file(sourcePath, fileOptions);
+    const [metadata] = await file.getMetadata(getFileMetadataOptions);
+    return Outcome.makeSuccess(metadata);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return Outcome.makeFailure(errStr);
+  }
+}
+
+export {
+  getMetadata,
+  get_metadata_exports
+};

package/chunks/chunk-4A2IILES.js

@@ -0,0 +1,16 @@
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+import {
+  esm_default
+} from "./chunk-QPHK5QI7.js";
+
+// src/node/images/transform/brighten/index.ts
+var brightenSchema = esm_default.object({
+  name: esm_default.literal(OperationNames.Brighten),
+  params: esm_default.number().min(0)
+});
+
+export {
+  brightenSchema
+};

package/chunks/chunk-4WM6K5IZ.js

@@ -0,0 +1,30 @@
+import {
+  esm_default
+} from "./chunk-QPHK5QI7.js";
+
+// src/node/images/transform/frame/backgrounds/create-line-background/index.ts
+var colorTransformationsSchema = esm_default.array(esm_default.object({
+  type: esm_default.enum(["saturate", "lighten", "complement"]),
+  intensity: esm_default.number().min(0).max(100),
+  intensityMode: esm_default.enum(["add", "set"])
+}));
+var createLineBackgroundSchema = esm_default.object({
+  type: esm_default.literal("line"),
+  params: esm_default.object({
+    nbLines: esm_default.number().min(1),
+    colors: esm_default.object({
+      selectColorPaletteIndex: esm_default.union([
+        esm_default.literal("first"),
+        esm_default.literal("last"),
+        esm_default.number().min(0)
+      ]),
+      primaryTransformations: colorTransformationsSchema,
+      secondaryTransformations: colorTransformationsSchema
+    })
+  })
+});
+
+export {
+  colorTransformationsSchema,
+  createLineBackgroundSchema
+};

package/chunks/chunk-4XBUJAQU.js

@@ -0,0 +1,71 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@aws-s3/storage/directory/copy-dir/index.ts
+var copy_dir_exports = {};
+__export(copy_dir_exports, {
+  copyDir: () => copyDir
+});
+import {
+  ListObjectsV2Command,
+  CopyObjectCommand,
+  HeadObjectCommand
+} from "@aws-sdk/client-s3";
+async function copyDir(client, bucketName, sourceDir, targetDir, options) {
+  const { listObjectsOptions, copyOptions, overwrite = false } = options ?? {};
+  const from = sourceDir.endsWith("/") ? sourceDir : `${sourceDir}/`;
+  const to = targetDir.endsWith("/") ? targetDir : `${targetDir}/`;
+  try {
+    let token;
+    do {
+      const listResp = await client.send(
+        new ListObjectsV2Command({
+          Bucket: bucketName,
+          Prefix: from,
+          ContinuationToken: token,
+          ...listObjectsOptions
+        })
+      );
+      for (const obj of listResp.Contents ?? []) {
+        if (!obj.Key) continue;
+        const rel = obj.Key.substring(from.length);
+        const dest = `${to}${rel}`;
+        if (!overwrite) {
+          try {
+            await client.send(new HeadObjectCommand({ Bucket: bucketName, Key: dest }));
+            continue;
+          } catch (err) {
+            const code = err?.name ?? err?.$metadata?.httpStatusCode;
+            if (code !== "NotFound" && code !== 404) {
+              return Outcome.makeFailure(unknownToString(err));
+            }
+          }
+        }
+        await client.send(
+          new CopyObjectCommand({
+            Bucket: bucketName,
+            Key: dest,
+            CopySource: `${bucketName}/${obj.Key}`,
+            ...copyOptions
+          })
+        );
+      }
+      token = listResp.IsTruncated ? listResp.NextContinuationToken : void 0;
+    } while (token);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  copyDir,
+  copy_dir_exports
+};