@design-edito/tools 0.1.71 → 0.1.73

package/chunks/chunk-CVDCTI7F.js

@@ -0,0 +1,47 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/ftps/file/upload/index.ts
+var upload_exports = {};
+__export(upload_exports, {
+  upload: () => upload
+});
+async function upload(ftpClient, targetPath, fileStream, options) {
+  const {
+    ensureDir = true,
+    overwrite = false
+  } = options ?? {};
+  try {
+    if (ensureDir) {
+      const dirPath = targetPath.substring(0, targetPath.lastIndexOf("/"));
+      await ftpClient.ensureDir(dirPath);
+    }
+    let fileExists = false;
+    try {
+      await ftpClient.size(targetPath);
+      fileExists = true;
+    } catch {
+      fileExists = false;
+    }
+    if (fileExists && !overwrite) {
+      return Outcome.makeFailure(`File already exists at ${targetPath}.`);
+    }
+    await ftpClient.uploadFrom(fileStream, targetPath, options);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return Outcome.makeFailure(errStr);
+  }
+}
+
+export {
+  upload,
+  upload_exports
+};

package/chunks/chunk-CWZFRUBS.js

@@ -0,0 +1,41 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@google-cloud/storage/file/copy/index.ts
+var copy_exports = {};
+__export(copy_exports, {
+  copy: () => copy
+});
+async function copy(bucket, sourcePath, targetPath, options) {
+  const {
+    fileOptions,
+    copyOptions,
+    overwrite = false
+  } = options ?? {};
+  try {
+    const srcFile = bucket.file(sourcePath, fileOptions);
+    const destFile = bucket.file(targetPath, fileOptions);
+    if (!overwrite) {
+      const [destExists] = await destFile.exists();
+      if (destExists) {
+        return Outcome.makeFailure(`Object already exists at ${targetPath}.`);
+      }
+    }
+    await srcFile.copy(destFile, copyOptions);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  copy,
+  copy_exports
+};

package/chunks/chunk-DABLUUMY.js

@@ -0,0 +1,24 @@
+import {
+  bucket_exports
+} from "./chunk-BD56ZAYF.js";
+import {
+  directory_exports
+} from "./chunk-WJ3XV35I.js";
+import {
+  file_exports
+} from "./chunk-3G7KHSKB.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@google-cloud/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  Bucket: () => bucket_exports,
+  Directory: () => directory_exports,
+  File: () => file_exports
+});
+
+export {
+  storage_exports
+};

package/chunks/chunk-DAOJPBZ6.js

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

package/chunks/chunk-DHCDZVLA.js

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

package/chunks/chunk-DPQRXSZH.js

@@ -0,0 +1,42 @@
+import {
+  list as list4
+} from "./chunk-37TRFYZT.js";
+import {
+  list as list3
+} from "./chunk-ZSUG52DO.js";
+import {
+  list as list2
+} from "./chunk-UK2F7CWI.js";
+import {
+  list
+} from "./chunk-3CLGBOHN.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/list-dir/index.ts
+var list_dir_exports = {};
+__export(list_dir_exports, {
+  listDir: () => listDir
+});
+async function listDir(client, path, options) {
+  if (isGcsBucket(client)) return list4(client, path, options);
+  if (isS3ClientWithBucket(client)) return list3(client.client, client.bucketName, path, options);
+  if (isFtpClient(client)) return list(client, path);
+  if (isSftpClient(client)) return list2(client, path);
+  return Outcome.makeFailure("Invalid client type");
+}
+
+export {
+  listDir,
+  list_dir_exports
+};

package/chunks/chunk-DTETQT5O.js

@@ -0,0 +1,15 @@
+import {
+  esm_default
+} from "./chunk-QPHK5QI7.js";
+
+// src/node/images/transform/_utils/color-schema/index.ts
+var colorSchema = esm_default.object({
+  r: esm_default.number().min(0).max(255),
+  g: esm_default.number().min(0).max(255),
+  b: esm_default.number().min(0).max(255),
+  alpha: esm_default.number().min(0).max(1)
+}).or(esm_default.string().length(7));
+
+export {
+  colorSchema
+};

package/chunks/chunk-E3F7QTXR.js

@@ -0,0 +1,141 @@
+import {
+  esm_default
+} from "./chunk-QPHK5QI7.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  clamp
+} from "./chunk-OSAXBA7G.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/images/format/index.ts
+var format_exports = {};
+__export(format_exports, {
+  format: () => format,
+  formatImage: () => formatImage,
+  isFormatAvifOptions: () => isFormatAvifOptions,
+  isFormatCommonOptions: () => isFormatCommonOptions,
+  isFormatHeifOptions: () => isFormatHeifOptions,
+  isFormatJpgOptions: () => isFormatJpgOptions,
+  isFormatKeepOptions: () => isFormatKeepOptions,
+  isFormatOptions: () => isFormatOptions,
+  isFormatPngOptions: () => isFormatPngOptions,
+  isFormatTiffOptions: () => isFormatTiffOptions,
+  isFormatWebpOptions: () => isFormatWebpOptions,
+  toAvif: () => toAvif,
+  toHeif: () => toHeif,
+  toHeight: () => toHeight,
+  toJpg: () => toJpg,
+  toPng: () => toPng,
+  toTiff: () => toTiff,
+  toWebp: () => toWebp,
+  toWidth: () => toWidth
+});
+import sharp from "sharp";
+async function formatImage(imageBuffer, outputOptions) {
+  const { width, height, quality, format: format2 } = outputOptions;
+  const sharpInstance = sharp(imageBuffer).resize({
+    width,
+    height,
+    fit: sharp.fit.cover
+  });
+  let withQuality = sharpInstance;
+  if (format2 === "png") {
+    withQuality = withQuality.png({ quality });
+  } else if (format2 === "jpeg") {
+    withQuality = withQuality.jpeg({ quality });
+  } else if (format2 === "webp") {
+    withQuality = withQuality.webp({ quality });
+  } else if (format2 === "avif") {
+    withQuality = withQuality.avif({ quality });
+  }
+  let buffer = Buffer.from([]);
+  try {
+    buffer = await withQuality.toBuffer();
+  } catch (e) {
+    console.log("Images:Exports:Error", { e });
+  }
+  return buffer;
+}
+var formatCommonOptionsSchema = esm_default.object({
+  width: esm_default.number().optional(),
+  height: esm_default.number().optional(),
+  fit: esm_default.enum(["contain", "cover", "fill", "inside", "outside"]).optional()
+});
+var formatJpgOptionsSchema = formatCommonOptionsSchema.extend({ quality: esm_default.number().optional() });
+var formatPngOptionsSchema = formatCommonOptionsSchema.extend({
+  quality: esm_default.number().optional(),
+  compressionLevel: esm_default.number().optional()
+});
+var formatWebpOptionsSchema = formatCommonOptionsSchema.extend({ quality: esm_default.number().optional() });
+var formatAvifOptionsSchema = formatCommonOptionsSchema.extend({ quality: esm_default.number().optional() });
+var formatTiffOptionsSchema = formatCommonOptionsSchema.extend({
+  quality: esm_default.number().optional(),
+  compression: esm_default.enum(["none", "jpeg", "deflate", "packbits", "ccittfax4", "lzw", "webp", "zstd", "jp2k"]).optional()
+});
+var formatHeifOptionsSchema = formatCommonOptionsSchema.extend({ quality: esm_default.number().optional() });
+var formatKeepOptionsSchema = formatCommonOptionsSchema;
+var formatOptionsSchema = esm_default.union([
+  formatJpgOptionsSchema,
+  formatPngOptionsSchema,
+  formatWebpOptionsSchema,
+  formatAvifOptionsSchema,
+  formatTiffOptionsSchema,
+  formatHeifOptionsSchema,
+  formatKeepOptionsSchema
+]);
+var isFormatCommonOptions = (options) => formatCommonOptionsSchema.safeParse(options).success;
+var isFormatJpgOptions = (options) => formatJpgOptionsSchema.safeParse(options).success;
+var isFormatPngOptions = (options) => formatPngOptionsSchema.safeParse(options).success;
+var isFormatWebpOptions = (options) => formatWebpOptionsSchema.safeParse(options).success;
+var isFormatAvifOptions = (options) => formatAvifOptionsSchema.safeParse(options).success;
+var isFormatTiffOptions = (options) => formatTiffOptionsSchema.safeParse(options).success;
+var isFormatHeifOptions = (options) => formatHeifOptionsSchema.safeParse(options).success;
+var isFormatKeepOptions = (options) => formatKeepOptionsSchema.safeParse(options).success;
+var isFormatOptions = (options) => formatOptionsSchema.safeParse(options).success;
+async function format(input, typeOrOptions, options) {
+  const sharpInstance = sharp(input);
+  if (typeof typeOrOptions !== "string") return Outcome.makeSuccess(await sharpInstance.resize(typeOrOptions).toBuffer());
+  const type = typeOrOptions;
+  if (type === "jpg" || type === "jpeg") return Outcome.makeSuccess(await sharpInstance.jpeg(options).toBuffer());
+  if (type === "png") return Outcome.makeSuccess(await sharpInstance.png(options).toBuffer());
+  if (type === "webp") return Outcome.makeSuccess(await sharpInstance.webp(options).toBuffer());
+  if (type === "avif") return Outcome.makeSuccess(await sharpInstance.avif(options).toBuffer());
+  if (type === "tiff") return Outcome.makeSuccess(await sharpInstance.tiff(options).toBuffer());
+  if (type === "heif") return Outcome.makeSuccess(await sharpInstance.heif(options).toBuffer());
+  return Outcome.makeFailure(`Invalid image format: ${type}`);
+}
+var toWidth = async (input, width) => sharp(input).resize({ width }).toBuffer();
+var toHeight = async (input, height) => sharp(input).resize({ height }).toBuffer();
+var toJpg = async (input, quality) => sharp(input).jpeg({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+var toPng = async (input, quality, compressionLevel) => sharp(input).png({ quality: clamp(quality ?? 100, 1, 100), compressionLevel }).toBuffer();
+var toWebp = async (input, quality) => sharp(input).webp({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+var toAvif = async (input, quality) => sharp(input).avif({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+var toTiff = async (input, quality, compression) => sharp(input).tiff({ quality: clamp(quality ?? 100, 1, 100), compression }).toBuffer();
+var toHeif = async (input, quality) => sharp(input).heif({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+
+export {
+  formatImage,
+  isFormatCommonOptions,
+  isFormatJpgOptions,
+  isFormatPngOptions,
+  isFormatWebpOptions,
+  isFormatAvifOptions,
+  isFormatTiffOptions,
+  isFormatHeifOptions,
+  isFormatKeepOptions,
+  isFormatOptions,
+  format,
+  toWidth,
+  toHeight,
+  toJpg,
+  toPng,
+  toWebp,
+  toAvif,
+  toTiff,
+  toHeif,
+  format_exports
+};

package/chunks/chunk-EOTOFHUR.js

@@ -0,0 +1,42 @@
+import {
+  download as download4
+} from "./chunk-2JH4TCT2.js";
+import {
+  download as download3
+} from "./chunk-IV75M3KE.js";
+import {
+  download as download2
+} from "./chunk-HWEGQVBQ.js";
+import {
+  download
+} from "./chunk-FF5NURFO.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/download-file/index.ts
+var download_file_exports = {};
+__export(download_file_exports, {
+  downloadFile: () => downloadFile
+});
+async function downloadFile(client, path, options) {
+  if (isGcsBucket(client)) return download4(client, path, options);
+  if (isS3ClientWithBucket(client)) return download3(client.client, client.bucketName, path, options);
+  if (isFtpClient(client)) return download(client, path, options);
+  if (isSftpClient(client)) return download2(client, path, options);
+  return Outcome.makeFailure("Invalid client type");
+}
+
+export {
+  downloadFile,
+  download_file_exports
+};

package/chunks/chunk-F6CB5TEO.js

@@ -0,0 +1,151 @@
+import {
+  formatImage
+} from "./chunk-E3F7QTXR.js";
+import {
+  transform
+} from "./chunk-6SXCNPJ2.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-FB3GNE2B.js

@@ -0,0 +1,48 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@google-cloud/storage/file/upload/index.ts
+var upload_exports = {};
+__export(upload_exports, {
+  upload: () => upload
+});
+async function upload(bucket, targetPath, fileStream, options) {
+  const { fileOptions, saveOptions, overwrite = false } = options ?? {};
+  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-FD5WR2A5.js

@@ -0,0 +1,63 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@aws-s3/storage/file/upload/index.ts
+var upload_exports = {};
+__export(upload_exports, {
+  upload: () => upload
+});
+import {
+  HeadObjectCommand
+} from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+async function upload(s3, bucketName, targetPath, fileStream, options) {
+  const {
+    uploadSettings,
+    fileMetadata,
+    overwrite = false
+  } = options ?? {};
+  if (!overwrite) {
+    try {
+      const headCommand = new HeadObjectCommand({
+        Bucket: bucketName,
+        Key: targetPath
+      });
+      await s3.send(headCommand);
+      return Outcome.makeFailure(`File already exists at ${targetPath}.`);
+    } catch (err) {
+      const code = err?.name ?? err?.$metadata?.httpStatusCode;
+      if (code !== "NotFound" && code !== 404) {
+        return Outcome.makeFailure(unknownToString(err));
+      }
+    }
+  }
+  const params = {
+    ...fileMetadata,
+    Bucket: bucketName,
+    Key: targetPath,
+    Body: fileStream
+  };
+  try {
+    const upload2 = new Upload({
+      client: s3,
+      params,
+      ...uploadSettings
+    });
+    await upload2.done();
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  upload,
+  upload_exports
+};