@design-edito/tools 0.1.73 → 0.2.1

package/chunks/chunk-3CZNTEF7.js

@@ -1,151 +0,0 @@
-import {
-  formatImage
-} from "./chunk-SJFY537W.js";
-import {
-  transform
-} from "./chunk-VHPX7UA3.js";
-import {
-  __export
-} from "./chunk-NZLE2WMY.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-3KN4IIQU.js

@@ -1,23 +0,0 @@
-import {
-  __export
-} from "./chunk-NZLE2WMY.js";
-
-// src/node/encryption/key/index.ts
-var key_exports = {};
-__export(key_exports, {
-  generate: () => generate
-});
-import { pbkdf2Sync, randomBytes } from "node:crypto";
-function generate(passphrase, outputByteLength, options) {
-  const { saltLength = 16, iterations = 1e5 } = options ?? {};
-  const salt = randomBytes(saltLength);
-  const key = pbkdf2Sync(passphrase, salt, iterations, outputByteLength, "sha256");
-  const saltString = salt.toString("hex");
-  const keyString = key.toString("hex");
-  return `${saltString}:${keyString}`;
-}
-
-export {
-  generate,
-  key_exports
-};

package/chunks/chunk-3LPD7IXF.js

@@ -1,56 +0,0 @@
-import {
-  revoke_signed_urls_exports
-} from "./chunk-UUSZJMJB.js";
-import {
-  update_metadata_exports
-} from "./chunk-YW5ASSIQ.js";
-import {
-  erase_exports
-} from "./chunk-7BCQCDGQ.js";
-import {
-  exists_exports
-} from "./chunk-TXGV4KJD.js";
-import {
-  generate_signed_url_exports
-} from "./chunk-OPU4CANL.js";
-import {
-  get_metadata_exports
-} from "./chunk-KFMYB672.js";
-import {
-  get_permissions_exports
-} from "./chunk-GXICX4F6.js";
-import {
-  move_exports
-} from "./chunk-T55QIYYV.js";
-import {
-  copy_exports
-} from "./chunk-SZQHLC4K.js";
-import {
-  download_exports
-} from "./chunk-IARWH6LC.js";
-import {
-  upload_exports
-} from "./chunk-7FJKDVBE.js";
-import {
-  __export
-} from "./chunk-NZLE2WMY.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,
-  RevokeSignedUrls: () => revoke_signed_urls_exports,
-  UpdateMetadata: () => update_metadata_exports,
-  Upload: () => upload_exports
-});
-
-export {
-  file_exports
-};

package/chunks/chunk-3UM5CZA5.js

@@ -1,18 +0,0 @@
-import {
-  OperationNames
-} from "./chunk-MOVLLUDL.js";
-import {
-  esm_default
-} from "./chunk-YE67BQQN.js";
-
-// src/node/images/transform/blur/index.ts
-var blurSchema = esm_default.object({
-  name: esm_default.literal(OperationNames.Blur),
-  params: esm_default.object({
-    sigma: esm_default.number()
-  })
-});
-
-export {
-  blurSchema
-};

package/chunks/chunk-3XNFVOJF.js

@@ -1,20 +0,0 @@
-import {
-  bucket_exports
-} from "./chunk-XSVBWVVC.js";
-import {
-  file_exports
-} from "./chunk-334MFRHI.js";
-import {
-  __export
-} from "./chunk-NZLE2WMY.js";
-
-// src/node/@google-cloud/storage/index.ts
-var storage_exports = {};
-__export(storage_exports, {
-  Bucket: () => bucket_exports,
-  File: () => file_exports
-});
-
-export {
-  storage_exports
-};

package/chunks/chunk-422KBDRV.js

@@ -1,203 +0,0 @@
-import {
-  thumbnails_exports
-} from "./chunk-UVSTFYSD.js";
-
-// src/node/images/transform/area-composition/index.ts
-import sharp from "sharp";
-var DEFAULT_GENERATE_OPTIONS = {
-  formats: ["jpeg"],
-  nbOutputs: 1,
-  imagePosition: "center",
-  imageOccupation: 60,
-  dimensions: { w: 300, h: 500 },
-  palette: ["default"],
-  maxPaletteDensity: 100,
-  extractPaletteDensity: 8,
-  lightenIntensity: 20,
-  saturateIntensity: 20,
-  colorFilterApply: "all",
-  tileDensityA: { min: 1, max: 1 },
-  tileDensityB: { min: 1, max: 1 },
-  tileCoverage: 50,
-  tileFormat: "default",
-  tileXEasing: "none",
-  tileYEasing: "none"
-};
-async function areaCompose(inputSharp, customOptions) {
-  const options = getOptions(customOptions);
-  const inputMetadata = await inputSharp.metadata();
-  const initialDimensions = {
-    w: inputMetadata.width || 0,
-    h: inputMetadata.height || 0
-  };
-  const inputBufferData = await inputSharp.raw().toBuffer();
-  const imagePalette = thumbnails_exports.Colors.extractPaletteFromImage(inputBufferData, initialDimensions, options);
-  const composedPalette = composePalette(imagePalette, options.palette, options.maxPaletteDensity);
-  inputSharp.png({ quality: 100 });
-  const outputDimensions = {
-    w: options.dimensions.w,
-    h: options.dimensions.h
-  };
-  const resizeInputDimensions = getNewInputImageDimensions(outputDimensions, options.imageOccupation);
-  const resizedInput = inputSharp.resize({
-    width: resizeInputDimensions.w,
-    height: resizeInputDimensions.h,
-    fit: "contain",
-    background: { r: 255, g: 255, b: 255, alpha: 0 }
-    // Add a transparent background
-  }).toFormat("png");
-  const resizedInputPositions = getImagePositions(options.imagePosition, resizeInputDimensions, resizeInputDimensions, outputDimensions);
-  const shapesLayout = thumbnails_exports.Layout.packAreasAndTiles(
-    {
-      ...resizedInputPositions,
-      ...resizeInputDimensions
-    },
-    outputDimensions,
-    options.tileCoverage,
-    { A: options.tileDensityA, B: options.tileDensityB },
-    { X: options.tileXEasing, Y: options.tileYEasing }
-  );
-  const sharpShapes = getSharpTilesInputs(shapesLayout, composedPalette);
-  const sharpShapesForComposite = [];
-  for await (const sharpShape of sharpShapes) {
-    ;
-    sharpShapesForComposite.push({
-      input: await sharpShape.input.toFormat("png").toBuffer(),
-      left: sharpShape.left,
-      top: sharpShape.top
-    });
-  }
-  const background = composedPalette[0] || [255, 255, 255];
-  const outputSharp = await createSharpShape(outputDimensions, background).toFormat("webp");
-  const composedSharp = outputSharp.composite([
-    {
-      input: await resizedInput.toFormat("webp").toBuffer(),
-      /* Converting to png to handle alpha */
-      left: Math.round(resizedInputPositions.x),
-      top: Math.round(resizedInputPositions.y)
-    },
-    ...sharpShapesForComposite
-  ]);
-  return await composedSharp.flatten();
-}
-function getOptions(customOptions) {
-  if (!customOptions) {
-    return DEFAULT_GENERATE_OPTIONS;
-  }
-  ;
-  const options = {
-    ...DEFAULT_GENERATE_OPTIONS,
-    ...customOptions
-  };
-  return options;
-}
-function getNewInputImageDimensions(formatDimensions, imageOccupation) {
-  const placeRatio = imageOccupation / 100;
-  return {
-    w: Math.round(formatDimensions.w * placeRatio),
-    h: Math.round(formatDimensions.h * placeRatio)
-  };
-}
-function composePalette(palette, paletteOption, maxPaletteDensity) {
-  let composedPalette = [];
-  if (paletteOption.includes("default-lighten")) {
-    composedPalette = [...composedPalette, ...palette.default.lighten];
-  }
-  if (paletteOption.includes("default-saturate")) {
-    composedPalette = [...composedPalette, ...palette.default.saturate];
-  }
-  if (paletteOption.includes("complementary")) {
-    composedPalette = [...composedPalette, ...palette.complementary.default];
-  }
-  if (paletteOption.includes("complementary-lighten")) {
-    composedPalette = [...composedPalette, ...palette.complementary.lighten];
-  }
-  if (paletteOption.includes("complementary-saturate")) {
-    composedPalette = [...composedPalette, ...palette.complementary.saturate];
-  }
-  if (paletteOption.includes("default") || !composedPalette.length) {
-    composedPalette = [...composedPalette, ...palette.default.default];
-  }
-  const shuffledPalette = thumbnails_exports.Common.shuffleArray(composedPalette);
-  const outputPalette = composedPalette.length > maxPaletteDensity ? shuffledPalette.splice(0, maxPaletteDensity) : shuffledPalette;
-  return outputPalette;
-}
-function getImagePositions(position, resizedImageDimensions, containedImageDimensions, wrapperDimensions) {
-  switch (position) {
-    case "top-left":
-      return thumbnails_exports.Layout.alignTopLeft(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "top-center":
-      return thumbnails_exports.Layout.alignTopCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "top-right":
-      return thumbnails_exports.Layout.alignTopRight(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "left-center":
-      return thumbnails_exports.Layout.alignLeftCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "center":
-      return thumbnails_exports.Layout.alignCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "right-center":
-      return thumbnails_exports.Layout.alignRightCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "bottom-left":
-      return thumbnails_exports.Layout.alignBottomLeft(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "bottom-center":
-      return thumbnails_exports.Layout.alignBottomCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    case "bottom-right":
-      return thumbnails_exports.Layout.alignBottomRight(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
-    default:
-      return { x: 0, y: 0 };
-  }
-}
-function createSharpShape(dimensions, background) {
-  return sharp(
-    {
-      create: getCreateSharpShape(dimensions, background)
-    }
-  );
-}
-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);
-}
-
-export {
-  areaCompose,
-  getSharpTilesInputs
-};