@design-edito/tools 0.1.71 → 0.1.72

package/chunks/chunk-YVEMIEOT.js

@@ -1,203 +0,0 @@
-import {
-  thumbnails_exports
-} from "./chunk-DW4ILX77.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
-};

package/chunks/chunk-YVLZX2JQ.js

@@ -1,164 +0,0 @@
-import {
-  createColorPalette
-} from "./chunk-XTOAQTLP.js";
-import {
-  createLineBackground
-} from "./chunk-GE7DNPF6.js";
-import {
-  createTileBackground
-} from "./chunk-CP454IJD.js";
-import {
-  getRelativePxPositionsInWrapperFor
-} from "./chunk-OCM3RLO6.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-YW5ASSIQ.js

@@ -1,31 +0,0 @@
-import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
-import {
-  unknownToString
-} from "./chunk-FENXVJYO.js";
-import {
-  __export
-} from "./chunk-NZLE2WMY.js";
-
-// src/node/@google-cloud/storage/file/update-metadata/index.ts
-var update_metadata_exports = {};
-__export(update_metadata_exports, {
-  updateFileMetadata: () => updateFileMetadata
-});
-async function updateFileMetadata(sourcePath, bucket, metadata, options) {
-  const { fileOptions, metadataOptions } = options ?? {};
-  try {
-    const file = bucket.file(sourcePath, fileOptions);
-    await file.setMetadata(metadata, metadataOptions);
-    return Outcome.makeSuccess(true);
-  } catch (err) {
-    const errStr = unknownToString(err);
-    return Outcome.makeFailure(errStr);
-  }
-}
-
-export {
-  updateFileMetadata,
-  update_metadata_exports
-};

package/chunks/chunk-YXJXNTCV.js

@@ -1,65 +0,0 @@
-import {
-  z
-} from "./chunk-XEAHMN2T.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 = z.object({
-  type: z.literal("tile"),
-  params: z.object({
-    coverageRatio: z.number(),
-    densityA: z.object({
-      min: z.number(),
-      max: z.number()
-    }),
-    densityB: z.object({
-      min: z.number(),
-      max: z.number()
-    }),
-    format: z.enum([
-      "random",
-      "default",
-      "portrait",
-      "landscape"
-    ]),
-    xEasing: z.enum(TransitionNames),
-    yEasing: z.enum(TransitionNames)
-  })
-});
-
-export {
-  TransitionNames,
-  createTileBackgroundSchema
-};

package/chunks/chunk-YYA5VRE4.js

@@ -1,177 +0,0 @@
-import {
-  frame
-} from "./chunk-WU3JQC7W.js";
-import {
-  frameSchema
-} from "./chunk-CSZFW4R5.js";
-import {
-  compose
-} from "./chunk-AWVQJNGX.js";
-import {
-  scale
-} from "./chunk-JRYI4VBX.js";
-import {
-  lineateLevelsSchema
-} from "./chunk-U7CF7IDN.js";
-import {
-  normalizeSchema
-} from "./chunk-76QORXDC.js";
-import {
-  resizeSchema
-} from "./chunk-OSZ4BWDE.js";
-import {
-  rotateSchema
-} from "./chunk-4TGRV2AB.js";
-import {
-  saturateSchema
-} from "./chunk-IJAFLBHD.js";
-import {
-  scaleSchema
-} from "./chunk-RLTBF5FT.js";
-import {
-  extractSchema
-} from "./chunk-DEQ5N53D.js";
-import {
-  flattenSchema
-} from "./chunk-MZZOFFFT.js";
-import {
-  extendSchema
-} from "./chunk-CYIUZX2T.js";
-import {
-  hueRotateSchema
-} from "./chunk-OWCPJD6O.js";
-import {
-  flipSchema
-} from "./chunk-RPWYARS3.js";
-import {
-  flopSchema
-} from "./chunk-33YK4WOA.js";
-import {
-  lightenSchema
-} from "./chunk-AMXIZUFB.js";
-import {
-  modulateSchema
-} from "./chunk-XN44EWRS.js";
-import {
-  brightenSchema
-} from "./chunk-OUJTDMHK.js";
-import {
-  blurSchema
-} from "./chunk-QUDIXNB2.js";
-import {
-  composeSchema
-} from "./chunk-QAE3OWOI.js";
-import {
-  z
-} from "./chunk-XEAHMN2T.js";
-import {
-  OperationNames
-} from "./chunk-MOVLLUDL.js";
-import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
-import {
-  unknownToString
-} from "./chunk-FENXVJYO.js";
-import {
-  __export
-} from "./chunk-NZLE2WMY.js";
-
-// src/node/images/transform/index.ts
-var transform_exports = {};
-__export(transform_exports, {
-  apply: () => apply,
-  isOperation: () => isOperation,
-  transform: () => transform
-});
-import sharp from "sharp";
-var operationSchema = z.union([
-  // areaComposeSchema,
-  blurSchema,
-  brightenSchema,
-  composeSchema,
-  extendSchema,
-  extractSchema,
-  flattenSchema,
-  flipSchema,
-  flopSchema,
-  frameSchema,
-  hueRotateSchema,
-  lightenSchema,
-  lineateLevelsSchema,
-  modulateSchema,
-  normalizeSchema,
-  resizeSchema,
-  rotateSchema,
-  saturateSchema,
-  scaleSchema
-]);
-function isOperation(operation) {
-  try {
-    return Outcome.makeSuccess(operationSchema.parse(operation));
-  } catch (err) {
-    return Outcome.makeFailure(unknownToString(err));
-  }
-}
-async function transform(imageBuffer, operations, checkValidOperations) {
-  let sharpInstance = sharp(imageBuffer);
-  const needsValidation = checkValidOperations ?? false;
-  for (const operation of operations) {
-    const _isOperation = isOperation(operation);
-    if (!needsValidation || _isOperation.success) {
-      console.log("Images:Transform:Operation:Start", operation.name);
-      sharpInstance = await apply(sharpInstance, operation);
-      console.log("Images:Transform:Operation:Done", operation.name);
-    }
-  }
-  return sharpInstance.toBuffer();
-}
-async function apply(sharpInstance, operation) {
-  switch (operation.name) {
-    case OperationNames.Blur:
-      return sharpInstance.blur(operation.params.sigma);
-    case OperationNames.Brighten:
-      return sharpInstance.blur(operation.params);
-    case OperationNames.Compose:
-      return compose(sharpInstance, operation.params);
-    case OperationNames.Extend:
-      return sharpInstance.extend(operation.params);
-    case OperationNames.Extract:
-      return sharpInstance.extract(operation.params);
-    case OperationNames.Flip:
-      return sharpInstance.flip(operation.params.flip);
-    case OperationNames.Flop:
-      return sharpInstance.flop(operation.params.flop);
-    case OperationNames.Frame:
-      return frame(sharpInstance, operation.params);
-    case OperationNames.Flatten:
-      return sharpInstance.flatten(operation.params);
-    case OperationNames.HueRotate:
-      return sharpInstance.modulate({ hue: operation.params });
-    case OperationNames.Lighten:
-      return sharpInstance.modulate({ lightness: operation.params });
-    case OperationNames.LineateLevels:
-      return sharpInstance.linear(operation.params.multiplier, operation.params.offset);
-    case OperationNames.Modulate:
-      return sharpInstance.modulate(operation.params);
-    case OperationNames.Normalize:
-      return sharpInstance.normalize(operation.params);
-    case OperationNames.Resize:
-      return sharpInstance.resize(operation.params);
-    case OperationNames.Rotate:
-      return sharpInstance.rotate(operation.params.angle);
-    case OperationNames.Saturate:
-      return sharpInstance.modulate({ saturation: operation.params });
-    case OperationNames.Scale:
-      return scale(sharpInstance, operation.params);
-    default:
-      return sharpInstance;
-  }
-}
-
-export {
-  isOperation,
-  transform,
-  apply,
-  transform_exports
-};

package/chunks/chunk-YZYA7LFK.js

@@ -1,20 +0,0 @@
-import {
-  file_exports
-} from "./chunk-46HTGOCE.js";
-import {
-  bucket_exports
-} from "./chunk-YMRAUWRW.js";
-import {
-  __export
-} from "./chunk-WSFCRVEQ.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-Z2CU55CF.js

@@ -1,20 +0,0 @@
-import {
-  bucket_exports
-} from "./chunk-XSVBWVVC.js";
-import {
-  file_exports
-} from "./chunk-YLJBKSLO.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-Z4PVE6SR.js

@@ -1,21 +0,0 @@
-import {
-  colorSchema
-} from "./chunk-U7R6TPHR.js";
-import {
-  OperationNames
-} from "./chunk-MOVLLUDL.js";
-import {
-  esm_default
-} from "./chunk-YE67BQQN.js";
-
-// src/node/images/transform/flatten/index.ts
-var flattenSchema = esm_default.object({
-  name: esm_default.literal(OperationNames.Flatten),
-  params: esm_default.object({
-    background: colorSchema
-  })
-});
-
-export {
-  flattenSchema
-};