@design-edito/tools 0.1.63 → 0.1.64

package/chunks/chunk-55MT7BMY.js

@@ -0,0 +1,16 @@
+import {
+  file_exports
+} from "./chunk-D5E2CIDK.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@aws-s3/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  File: () => file_exports
+});
+
+export {
+  storage_exports
+};

package/chunks/chunk-5J7H5WYC.js

@@ -0,0 +1,82 @@
+import {
+  thumbnails_exports
+} from "./chunk-OSCBZIZF.js";
+
+// src/node/images/transform/operations/inner-resize/index.ts
+import sharp from "sharp";
+async function innerResize(imageSharp, params) {
+  const imageMetadata = await imageSharp.metadata();
+  const inputDimensions = {
+    width: imageMetadata.width || 0,
+    height: imageMetadata.height || 0
+  };
+  const outputDimensions = params.outputDimensions ? params.outputDimensions : {
+    width: inputDimensions.width,
+    height: inputDimensions.height
+  };
+  const ratio = (params.innerRatio || 100) / 100;
+  const innerDimensions = {
+    width: Math.floor(outputDimensions.width * ratio),
+    height: Math.floor(outputDimensions.height * ratio)
+  };
+  const innerContainedDimensions = thumbnails_exports.Layout.getContainedDimensions(innerDimensions.width, innerDimensions.height, outputDimensions.width, outputDimensions.height, true);
+  const innerPositions = getInnerPositions(params.innerGravity || "center", { w: innerDimensions.width, h: innerDimensions.height }, innerContainedDimensions, { w: outputDimensions.width, h: outputDimensions.height });
+  const background = { r: 255, g: 255, b: 255, alpha: 0 };
+  const resizedSharp = imageSharp.toFormat("png").resize({
+    width: innerDimensions.width,
+    height: innerDimensions.height,
+    fit: sharp.fit.contain,
+    background
+  });
+  const composedSharp = sharp({
+    create: {
+      background,
+      width: outputDimensions.width,
+      height: outputDimensions.height,
+      channels: 4
+    }
+  }).ensureAlpha(0).composite([
+    {
+      input: await resizedSharp.toFormat("png").toBuffer(),
+      left: Math.floor(innerPositions.x),
+      top: Math.floor(innerPositions.y)
+    }
+  ]).toFormat("png");
+  return {
+    sharp: composedSharp,
+    transformation: {
+      width: innerContainedDimensions.w,
+      height: innerContainedDimensions.h,
+      x: Math.ceil(innerPositions.x),
+      y: Math.ceil(innerPositions.y)
+    }
+  };
+}
+function getInnerPositions(innerGravity, innerDimensions, innerContainedDimensions, outerDimension) {
+  switch (innerGravity) {
+    case "top-left":
+      return thumbnails_exports.Layout.alignTopLeft(innerDimensions, innerContainedDimensions, outerDimension);
+    case "top-center":
+      return thumbnails_exports.Layout.alignTopCenter(innerDimensions, innerContainedDimensions, outerDimension);
+    case "top-right":
+      return thumbnails_exports.Layout.alignTopRight(innerDimensions, innerContainedDimensions, outerDimension);
+    case "left-center":
+      return thumbnails_exports.Layout.alignLeftCenter(innerDimensions, innerContainedDimensions, outerDimension);
+    case "center":
+      return thumbnails_exports.Layout.alignCenter(innerDimensions, innerContainedDimensions, outerDimension);
+    case "right-center":
+      return thumbnails_exports.Layout.alignRightCenter(innerDimensions, innerContainedDimensions, outerDimension);
+    case "bottom-left":
+      return thumbnails_exports.Layout.alignBottomLeft(innerDimensions, innerContainedDimensions, outerDimension);
+    case "bottom-center":
+      return thumbnails_exports.Layout.alignBottomCenter(innerDimensions, innerContainedDimensions, outerDimension);
+    case "bottom-right":
+      return thumbnails_exports.Layout.alignBottomRight(innerDimensions, innerDimensions, outerDimension);
+    default:
+      return { x: 0, y: 0 };
+  }
+}
+
+export {
+  innerResize
+};

package/chunks/chunk-5JAITHS2.js

@@ -0,0 +1,48 @@
+import {
+  upload
+} from "./chunk-KH5JTC2N.js";
+import {
+  upload as upload4
+} from "./chunk-AZLVQV5A.js";
+import {
+  upload as upload2
+} from "./chunk-N5QAGJXV.js";
+import {
+  upload as upload3
+} from "./chunk-AIESW26U.js";
+import {
+  s3IdentifierData
+} from "./chunk-CMWR77VW.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/cloud-storage/operations/upload/index.ts
+var upload_exports = {};
+__export(upload_exports, {
+  upload: () => upload5
+});
+import { Bucket } from "@google-cloud/storage";
+import { S3 } from "aws-sdk";
+import { Client as FtpClient } from "basic-ftp";
+import SftpClient from "ssh2-sftp-client";
+async function upload5(fileReadable, targetPath, endpointType, endpointIdentifier, client) {
+  if (endpointType === "gcs-bucket" /* GCS */ && client instanceof Bucket) return await upload(fileReadable, targetPath, client);
+  if (endpointType === "s3-bucket" /* S3 */ && client instanceof S3) {
+    const { bucketName } = s3IdentifierData(endpointIdentifier);
+    if (bucketName === null) return Outcome.makeFailure("Invalid S3 bucket name");
+    return await upload2(fileReadable, targetPath, bucketName, client);
+  }
+  if (endpointType === "ftp" /* FTP */ && client instanceof FtpClient) return await upload3(fileReadable, targetPath, client);
+  if (endpointType === "ftps" /* FTPS */ && client instanceof FtpClient) return await upload3(fileReadable, targetPath, client);
+  if (endpointType === "sftp" /* SFTP */ && client instanceof SftpClient) return await upload4(fileReadable, targetPath, client);
+  return Outcome.makeFailure("Invalid endpoint or client type");
+}
+
+export {
+  upload5 as upload,
+  upload_exports
+};

package/chunks/chunk-7SS2R4B6.js

@@ -0,0 +1,82 @@
+import {
+  thumbnails_exports
+} from "./chunk-OSCBZIZF.js";
+
+// src/node/images/transform/operations/area-composition/area-tile-composition/index.ts
+import sharp from "sharp";
+function getCreateSharpShape(dimensions, background) {
+  return {
+    width: Math.round(dimensions.w),
+    height: Math.round(dimensions.h),
+    channels: 4,
+    background: { r: background[0], g: background[1], b: background[2], alpha: 1 }
+  };
+}
+function getSharpTilesInputs(tiles, palette) {
+  let usedColorsIndexes = [];
+  const paletteLength = palette.length;
+  const getUnusedColorIndex = () => {
+    const paletteIndex = thumbnails_exports.Common.randomInt(paletteLength);
+    resetUnusedColorIndexesIfNeeded();
+    if (usedColorsIndexes.includes(paletteIndex)) {
+      return getUnusedColorIndex();
+    }
+    usedColorsIndexes.push(paletteIndex);
+    return paletteIndex;
+  };
+  const resetUnusedColorIndexesIfNeeded = () => {
+    if (usedColorsIndexes.length !== paletteLength) {
+      return;
+    }
+    usedColorsIndexes = [];
+  };
+  return tiles.map((tile) => {
+    const paletteIndex = getUnusedColorIndex();
+    const color = palette[paletteIndex];
+    if (!color) {
+      return;
+    }
+    return {
+      top: Math.round(tile.y),
+      left: Math.round(tile.x),
+      input: sharp(
+        {
+          create: getCreateSharpShape(tile, color)
+        }
+      )
+    };
+  }).filter((sharpShape) => sharpShape !== void 0);
+}
+async function areaTileCompose(inputSharp, composition, options) {
+  const shapesLayout = thumbnails_exports.Layout.packAreasAndTiles(
+    options.innerTransformation,
+    options.outputDimensions,
+    composition.params.coverage,
+    { A: composition.params.densityA, B: composition.params.densityB },
+    { X: composition.params.xEasing, Y: composition.params.yEasing }
+  );
+  const sharpShapes = getSharpTilesInputs(shapesLayout, options.palette);
+  const sharpShapesForComposite = [];
+  for await (const sharpShape of sharpShapes) {
+    ;
+    sharpShapesForComposite.push({
+      input: await sharpShape.input.toFormat("png").toBuffer(),
+      left: sharpShape.left,
+      top: sharpShape.top
+    });
+  }
+  return [
+    {
+      input: await inputSharp.png({ quality: 100 }).toBuffer(),
+      /* Converting to png to handle alpha */
+      left: 0,
+      top: 0
+    },
+    ...sharpShapesForComposite
+  ];
+}
+
+export {
+  getSharpTilesInputs,
+  areaTileCompose
+};

package/chunks/chunk-D5E2CIDK.js

@@ -0,0 +1,20 @@
+import {
+  upload_exports
+} from "./chunk-N5QAGJXV.js";
+import {
+  download_exports
+} from "./chunk-7N7BJA6C.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@aws-s3/storage/file/index.ts
+var file_exports = {};
+__export(file_exports, {
+  Download: () => download_exports,
+  Upload: () => upload_exports
+});
+
+export {
+  file_exports
+};

package/chunks/chunk-ECWDSMDZ.js

@@ -0,0 +1,20 @@
+import {
+  upload_exports
+} from "./chunk-5JAITHS2.js";
+import {
+  download_exports
+} from "./chunk-JLXITDAV.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/cloud-storage/operations/index.ts
+var operations_exports = {};
+__export(operations_exports, {
+  Download: () => download_exports,
+  Upload: () => upload_exports
+});
+
+export {
+  operations_exports
+};

package/chunks/chunk-JLXITDAV.js

@@ -0,0 +1,48 @@
+import {
+  download
+} from "./chunk-6WVNJVBE.js";
+import {
+  download as download4
+} from "./chunk-OD33BN4K.js";
+import {
+  download as download2
+} from "./chunk-7N7BJA6C.js";
+import {
+  download as download3
+} from "./chunk-UJN2WZGO.js";
+import {
+  s3IdentifierData
+} from "./chunk-CMWR77VW.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/cloud-storage/operations/download/index.ts
+var download_exports = {};
+__export(download_exports, {
+  download: () => download5
+});
+import { Bucket } from "@google-cloud/storage";
+import { S3 } from "aws-sdk";
+import { Client as FtpClient } from "basic-ftp";
+import SftpClient from "ssh2-sftp-client";
+async function download5(targetPath, endpointType, endpointIdentifier, client) {
+  if (endpointType === "gcs-bucket" /* GCS */ && client instanceof Bucket) return await download(targetPath, client);
+  if (endpointType === "s3-bucket" /* S3 */ && client instanceof S3) {
+    const { bucketName } = s3IdentifierData(endpointIdentifier);
+    if (bucketName === null) return Outcome.makeFailure("Invalid S3 bucket name");
+    return await download2(targetPath, bucketName, client);
+  }
+  if (endpointType === "ftp" /* FTP */ && client instanceof FtpClient) return await download3(targetPath, client);
+  if (endpointType === "ftps" /* FTPS */ && client instanceof FtpClient) return await download3(targetPath, client);
+  if (endpointType === "sftp" /* SFTP */ && client instanceof SftpClient) return await download4(targetPath, client);
+  return Outcome.makeFailure("Invalid endpoint or client type");
+}
+
+export {
+  download5 as download,
+  download_exports
+};

package/chunks/chunk-JYYW4KOZ.js

@@ -0,0 +1,72 @@
+import {
+  colors_exports
+} from "./chunk-YUJJEKYY.js";
+
+// src/node/images/transform/operations/area-composition/area-line-composition/index.ts
+var DEFAULT_COMPOSITION_LINE_PARAMS = {
+  nbLines: 3,
+  colors: {
+    base: "first",
+    primary: [],
+    secondary: []
+  }
+};
+async function areaLineCompose(inputSharp, composition, options) {
+  const lineDimensions = {
+    w: options.outputDimensions.w,
+    h: Math.round(options.outputDimensions.h / composition.params.nbLines)
+  };
+  const sharpShapes = [];
+  const maxPaletteLength = options.palette.length;
+  const baseColorIndex = composition.params.colors.base === "first" ? 0 : composition.params.colors.base === "last" ? options.palette.length - 1 : composition.params.colors.base;
+  for (let i = 0; i < composition.params.nbLines; i++) {
+    const indexPalette = Math.min(Math.max(0, baseColorIndex), maxPaletteLength);
+    const primaryColor = getTransformedColor(options.palette[indexPalette], composition.params.colors.primary);
+    const secondaryColor = getTransformedColor(options.palette[indexPalette], composition.params.colors.secondary);
+    const outputColor = i % 2 === 0 ? primaryColor : secondaryColor;
+    const top = Math.min(lineDimensions.h * i, options.outputDimensions.h);
+    sharpShapes.push({
+      input: {
+        create: {
+          width: lineDimensions.w,
+          height: i === composition.params.nbLines - 1 ? options.outputDimensions.h - top : lineDimensions.h,
+          channels: 4,
+          background: { r: outputColor[0], g: outputColor[1], b: outputColor[2], alpha: 1 }
+        }
+      },
+      left: 0,
+      top
+    });
+  }
+  return [
+    ...sharpShapes,
+    {
+      input: await inputSharp.png({ quality: 100 }).toBuffer(),
+      /* Converting to png to handle alpha */
+      left: 0,
+      top: 0
+    }
+  ];
+}
+function getTransformedColor(color, transformation) {
+  let transformedColor = color;
+  transformation.forEach((transformation2) => {
+    transformedColor = transformColor(transformedColor, transformation2);
+  });
+  return transformedColor;
+}
+function transformColor(color, transformation) {
+  switch (transformation.type) {
+    case "saturate":
+      return transformation.intensityMode === "add" ? colors_exports.saturateColor(color, transformation.intensity) : colors_exports.setColorSaturation(color, transformation.intensity);
+    case "lighten":
+      return transformation.intensityMode === "add" ? colors_exports.lightenColor(color, transformation.intensity) : colors_exports.setColorLuminance(color, transformation.intensity);
+    case "complement":
+      return colors_exports.complementColor(color);
+  }
+}
+
+export {
+  DEFAULT_COMPOSITION_LINE_PARAMS,
+  areaLineCompose
+};

package/chunks/chunk-LVBXPZUO.js

@@ -0,0 +1,104 @@
+import {
+  exportZipBuffer,
+  prepareExport
+} from "./chunk-5RGHYFQH.js";
+import {
+  transformImage
+} from "./chunk-TC7A4P5S.js";
+import {
+  thumbnails_exports
+} from "./chunk-OSCBZIZF.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,
+  prepareImage: () => prepareImage
+});
+import sharp from "sharp";
+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 outputDimensions = {
+    widths: customOptions?.widths && customOptions?.widths.length ? customOptions?.widths : [imageBufferMetadata.width],
+    heights: customOptions?.heights && customOptions?.heights.length ? customOptions?.heights : [imageBufferMetadata.height]
+  };
+  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");
+  }
+  const transformedBuffer = await transformImage(imageBuffer, options.inputOperations, {
+    width: thumbnails_exports.Common.getArrayMax(outputDimensions.widths) || 0,
+    height: thumbnails_exports.Common.getArrayMax(outputDimensions.heights) || 0
+  });
+  const exportsBuffers = [{
+    buffer: imageBuffer,
+    name: generateFileName({
+      ...imageBufferMetadata,
+      quality: 100,
+      suffix: "original",
+      preffix: options.name
+    })
+  }];
+  for await (const width of options.widths) {
+    for await (const height of options.heights) {
+      for await (const quality of options.qualities) {
+        for await (const format of options.formats) {
+          const exportBuffer = await prepareExport(transformedBuffer, {
+            format,
+            quality,
+            width,
+            height
+          });
+          exportsBuffers.push({
+            buffer: exportBuffer,
+            name: generateFileName({ width, height, quality, format, preffix: options.name })
+          });
+        }
+      }
+    }
+  }
+  const zipBuffer = exportZipBuffer(exportsBuffers, generateZipName(options.name));
+  return zipBuffer;
+}
+function getOptions(imageBufferMetadata, options) {
+  return {
+    center: [0.5, 0.5],
+    qualities: [100],
+    inputOperations: [],
+    ...options,
+    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, preffix }) {
+  const _preffix = preffix ? `${preffix}_` : "image-formats_";
+  const _suffix = `${suffix ? `_${suffix}` : ""}.${format}`;
+  return `${_preffix}${width}x${height}_Q${quality}${_suffix}`;
+}
+
+export {
+  MAX_NB_OUTPUTS,
+  OUTPUT_ZIP_FOLDER,
+  prepareImage,
+  prepare_exports
+};