@design-edito/tools 0.1.64 → 0.1.65

package/chunks/chunk-CP454IJD.js

@@ -0,0 +1,231 @@
+import {
+  Transitions
+} from "./chunk-ENMBK6H7.js";
+import {
+  clamp
+} from "./chunk-OSAXBA7G.js";
+import {
+  randomInt
+} from "./chunk-D3ERTRDW.js";
+import {
+  shuffle
+} from "./chunk-VJJIYJMY.js";
+
+// src/node/images/transform/operations/_utils/frame/backgrounds/create-tile-background/index.ts
+var DEFAULT_CREATE_BACKGROUND_TILE_PARAMS = {
+  coverageRatio: 0.5,
+  densityA: { min: 0, max: 0 },
+  densityB: { min: 0, max: 0 },
+  format: "random",
+  xEasing: "linear",
+  yEasing: "linear"
+};
+async function createTileBackground(background, dimensions, imageCoordinates, colorPalette) {
+  background = {
+    ...background,
+    params: {
+      ...DEFAULT_CREATE_BACKGROUND_TILE_PARAMS,
+      ...background.params
+    }
+  };
+  const tileCoordinatesList = getPackedTilesCoordinatesList(
+    {
+      x: imageCoordinates.x,
+      y: imageCoordinates.y,
+      w: imageCoordinates.w,
+      h: imageCoordinates.h
+    },
+    dimensions,
+    background.params.coverageRatio,
+    {
+      A: background.params.densityA,
+      B: background.params.densityB
+    },
+    {
+      X: background.params.xEasing,
+      Y: background.params.yEasing
+    },
+    background.params.format
+  );
+  return createSharpOverlaysFromCoordinatesList(
+    tileCoordinatesList,
+    colorPalette
+  );
+}
+function getPackedTilesCoordinatesList(coordinatesToAvoid, dimensions, tileCoverageRatio, tileDensity, tileEasing, tileFormat) {
+  const areaCoordinatesList = [];
+  const baseFormat = {
+    nbCells: 9,
+    cellAvoidIndex: 4,
+    nbRows: 3,
+    nbColumns: 3
+  };
+  const positionsToAvoid = {
+    top: Math.ceil(coordinatesToAvoid.y),
+    bottom: Math.ceil(coordinatesToAvoid.y + coordinatesToAvoid.h),
+    left: Math.ceil(coordinatesToAvoid.x),
+    right: Math.ceil(coordinatesToAvoid.x + coordinatesToAvoid.w)
+  };
+  for (let i = 0; i < baseFormat.nbCells; i++) {
+    if (i === baseFormat.cellAvoidIndex) {
+      continue;
+    }
+    const middleColumn = i % baseFormat.nbColumns === 1;
+    const rightColumn = i % baseFormat.nbColumns === 2;
+    const topRow = i < baseFormat.nbRows;
+    const middleRow = !topRow && i < baseFormat.nbRows * 2;
+    const bottomRow = !topRow && !middleRow;
+    areaCoordinatesList[i] = { x: 0, y: 0, w: positionsToAvoid.left, h: positionsToAvoid.top };
+    if (middleColumn) {
+      areaCoordinatesList[i].x = positionsToAvoid.left;
+      areaCoordinatesList[i].w = coordinatesToAvoid.w;
+    }
+    if (rightColumn) {
+      areaCoordinatesList[i].x = positionsToAvoid.right;
+    }
+    if (middleRow) {
+      areaCoordinatesList[i].y = positionsToAvoid.top;
+      areaCoordinatesList[i].h = coordinatesToAvoid.h;
+    }
+    if (bottomRow) {
+      areaCoordinatesList[i].y = positionsToAvoid.bottom;
+      areaCoordinatesList[i].h = dimensions.heightPx - positionsToAvoid.bottom;
+    }
+  }
+  const filteredAreaCoordinatesList = shuffle(areaCoordinatesList.filter((areaCoordinate) => areaCoordinate.w !== 0 && areaCoordinate.h !== 0));
+  const subTiles = [];
+  const nbAreas = filteredAreaCoordinatesList.length;
+  const nbAreasToCover = Math.round(nbAreas * tileCoverageRatio);
+  if (tileDensity.A.min > 1 || tileDensity.A.max > 1 || tileDensity.B.min > 1 || tileDensity.B.max > 1) {
+    filteredAreaCoordinatesList.forEach((areaCoordinates, index) => {
+      if (index > nbAreasToCover) {
+        subTiles.push(areaCoordinates);
+        return;
+      }
+      const { nbRows, nbColumns } = getNbRowsAndColumnsForFormat(
+        randomInt(tileDensity.A.min, tileDensity.A.max) || 0,
+        randomInt(tileDensity.B.min, tileDensity.B.max) || 0,
+        { widthPx: areaCoordinates.w, heightPx: areaCoordinates.h },
+        tileFormat
+      );
+      const XEasingFunc = (tileEasing.X && tileEasing.X in Transitions.easings ? Transitions.easings[tileEasing.X] : Transitions.easings.linear) || function(x) {
+        return x;
+      };
+      const YEasingFunc = (tileEasing.Y in Transitions.easings ? Transitions.easings[tileEasing.Y] : Transitions.easings.linear) || function(x) {
+        return x;
+      };
+      const tiles = [];
+      for (let i = 0; i < nbRows; i++) {
+        for (let j = 0; j < nbColumns; j++) {
+          const columnI = j;
+          const rowI = i;
+          const x = Math.ceil(areaCoordinates.w * XEasingFunc(columnI / nbColumns));
+          const y = Math.ceil(areaCoordinates.h * YEasingFunc(rowI / nbRows));
+          tiles.push({
+            x: areaCoordinates.x + x,
+            y: areaCoordinates.y + y
+          });
+        }
+      }
+      const nbTiles = tiles.length;
+      tiles.forEach((subTileCoord, i) => {
+        const tileNum = i + 1;
+        const nextTileX = tileNum % nbColumns > 0 ? tiles[i + 1] : null;
+        const nextTileY = i + nbColumns < nbTiles ? tiles[i + nbColumns] : null;
+        const subTileBounds = {
+          x: nextTileX ? nextTileX.x : areaCoordinates.x + areaCoordinates.w,
+          y: nextTileY ? nextTileY.y : areaCoordinates.y + areaCoordinates.h
+        };
+        subTiles.push({
+          x: subTileCoord.x,
+          y: subTileCoord.y,
+          w: subTileBounds.x - subTileCoord.x,
+          h: subTileBounds.y - subTileCoord.y
+        });
+      });
+    });
+  }
+  return (subTiles.length ? subTiles : filteredAreaCoordinatesList).map((tile) => ({
+    w: clamp(tile.w, 0, dimensions.widthPx),
+    h: clamp(tile.h, 0, dimensions.heightPx),
+    x: clamp(tile.x, 0, dimensions.widthPx),
+    y: clamp(tile.y, 0, dimensions.heightPx)
+  })).filter((tile) => tile.w > 0 && tile.h > 0);
+}
+function getNbRowsAndColumnsForFormat(tileDensityA, tileDensityB, tileDimensions, tileFormat) {
+  switch (tileFormat) {
+    case "random":
+      const random = Math.random() > Math.random();
+      return {
+        nbRows: random ? tileDensityA : tileDensityB,
+        nbColumns: random ? tileDensityB : tileDensityA
+      };
+    case "portrait":
+      return {
+        nbRows: tileDensityA,
+        nbColumns: tileDensityB
+      };
+    case "landscape":
+      return {
+        nbRows: tileDensityB,
+        nbColumns: tileDensityA
+      };
+    default:
+      return {
+        nbRows: tileDimensions.widthPx > tileDimensions.heightPx ? tileDensityA : tileDensityB,
+        nbColumns: tileDimensions.widthPx > tileDimensions.heightPx ? tileDensityB : tileDensityA
+      };
+  }
+}
+function createSharpOverlaysFromCoordinatesList(tileCoordinatesList, colorPalette) {
+  let usedColorsIndexes = [];
+  const colorPaletteLength = colorPalette.length;
+  const getRGBColor = () => {
+    const getUnusedColorIndex = () => {
+      const paletteIndex = randomInt(0, colorPaletteLength) || 0;
+      resetUnusedColorIndexesIfNeeded();
+      if (usedColorsIndexes.includes(paletteIndex)) {
+        return getUnusedColorIndex();
+      }
+      usedColorsIndexes.push(paletteIndex);
+      return paletteIndex;
+    };
+    const resetUnusedColorIndexesIfNeeded = () => {
+      if (usedColorsIndexes.length !== colorPaletteLength) {
+        return;
+      }
+      usedColorsIndexes = [];
+    };
+    const colorPaletteIndex = getUnusedColorIndex();
+    const RGBColor = colorPalette[colorPaletteIndex];
+    if (!RGBColor) {
+      return [0, 0, 0];
+    }
+    return RGBColor;
+  };
+  return tileCoordinatesList.map((tileCoordinates) => {
+    const RGBColor = getRGBColor();
+    return {
+      top: Math.floor(tileCoordinates.y),
+      left: Math.floor(tileCoordinates.x),
+      input: {
+        create: {
+          width: Math.round(tileCoordinates.w),
+          height: Math.round(tileCoordinates.h),
+          channels: 4,
+          background: {
+            r: RGBColor[0],
+            g: RGBColor[1],
+            b: RGBColor[2],
+            alpha: 1
+          }
+        }
+      }
+    };
+  });
+}
+
+export {
+  DEFAULT_CREATE_BACKGROUND_TILE_PARAMS,
+  createTileBackground
+};

package/chunks/chunk-CSZFW4R5.js

@@ -0,0 +1,69 @@
+import {
+  createLineBackgroundSchema
+} from "./chunk-YLKBLE6G.js";
+import {
+  createTileBackgroundSchema
+} from "./chunk-YXJXNTCV.js";
+import {
+  positionsSchema
+} from "./chunk-7KCMLH6B.js";
+import {
+  colorSchema
+} from "./chunk-JBZR6R5B.js";
+import {
+  z
+} from "./chunk-XEAHMN2T.js";
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+
+// src/node/images/transform/frame/index.tsx
+var createBackgroundOptionsSchema = {
+  colorPalette: z.optional(z.object({
+    extract: z.optional(z.object({
+      nbColor: z.number()
+    })),
+    use: z.optional(z.object({
+      RGBColors: z.array(z.tuple([z.number(), z.number(), z.number()]))
+    })),
+    densify: z.optional(z.object({
+      types: z.array(z.enum([
+        "default",
+        "default-lighten",
+        "default-saturate",
+        "complementary",
+        "complementary-lighten",
+        "complementary-saturate"
+      ])),
+      ligthenIntensity: z.optional(z.number()),
+      saturateIntensity: z.optional(z.number())
+    })),
+    compose: z.optional(z.object({
+      nbColor: z.optional(z.number()),
+      mix: z.optional(z.boolean())
+    }))
+  }))
+};
+var frameSchema = z.object({
+  name: z.literal(OperationNames.Frame),
+  params: z.object({
+    dimensions: z.object({
+      widthPx: z.number().min(0),
+      heightPx: z.number().min(0)
+    }),
+    imageScale: z.object({
+      xRatio: z.optional(z.number().min(0).max(1)),
+      yRatio: z.optional(z.number().min(0).max(1))
+    }).optional(),
+    positions: positionsSchema,
+    background: z.union([
+      colorSchema,
+      createLineBackgroundSchema.extend(createBackgroundOptionsSchema),
+      createTileBackgroundSchema.extend(createBackgroundOptionsSchema)
+    ])
+  })
+});
+
+export {
+  frameSchema
+};

package/chunks/chunk-CYIUZX2T.js

@@ -0,0 +1,31 @@
+import {
+  colorSchema
+} from "./chunk-JBZR6R5B.js";
+import {
+  z
+} from "./chunk-XEAHMN2T.js";
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+
+// src/node/images/transform/extend/index.ts
+var extendSchema = z.object({
+  name: z.literal(OperationNames.Extend),
+  params: z.object({
+    top: z.number(),
+    left: z.number(),
+    right: z.number(),
+    bottom: z.number(),
+    background: colorSchema,
+    extendWith: z.optional(z.enum([
+      "background",
+      "copy",
+      "repeat",
+      "mirror"
+    ]))
+  })
+});
+
+export {
+  extendSchema
+};

package/chunks/chunk-DEQ5N53D.js

@@ -0,0 +1,21 @@
+import {
+  z
+} from "./chunk-XEAHMN2T.js";
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+
+// src/node/images/transform/extract/index.ts
+var extractSchema = z.object({
+  name: z.literal(OperationNames.Extract),
+  params: z.object({
+    width: z.number(),
+    height: z.number(),
+    left: z.number(),
+    top: z.number()
+  })
+});
+
+export {
+  extractSchema
+};

package/chunks/chunk-E7J4E6OB.js

@@ -0,0 +1,65 @@
+import {
+  isNonNullObject
+} from "./chunk-HQLRJ7XW.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/node/cloud-storage/credentials/index.ts
+var credentials_exports = {};
+__export(credentials_exports, {
+  isCredentials: () => isCredentials,
+  isFtpCredentials: () => isFtpCredentials,
+  isFtpsCredentials: () => isFtpsCredentials,
+  isGcsBucketCredentials: () => isGcsBucketCredentials,
+  isS3BucketCredentials: () => isS3BucketCredentials,
+  isSftpCredentials: () => isSftpCredentials
+});
+function isGcsBucketCredentials(unknownObject) {
+  if (!isNonNullObject(unknownObject)) return false;
+  if ("client_email" in unknownObject && typeof unknownObject.client_email === "string" && "private_key" in unknownObject && typeof unknownObject.private_key === "string" && "project_id" in unknownObject && typeof unknownObject.project_id === "string") return true;
+  return false;
+}
+function isS3BucketCredentials(unknownObject) {
+  if (!isNonNullObject(unknownObject)) return false;
+  if ("accessKeyId" in unknownObject && typeof unknownObject.accessKeyId === "string" && "secretAccessKey" in unknownObject && typeof unknownObject.secretAccessKey === "string") {
+    if ("region" in unknownObject && typeof unknownObject.region === "string") return true;
+    if (!("region" in unknownObject)) return true;
+    return false;
+  }
+  return false;
+}
+function isFtpCredentials(unknownObject) {
+  if (!isNonNullObject(unknownObject)) return false;
+  if ("host" in unknownObject && typeof unknownObject.host === "string" && "port" in unknownObject && typeof unknownObject.port === "number" && "username" in unknownObject && typeof unknownObject.username === "string" && "password" in unknownObject && typeof unknownObject.password === "string") return true;
+  return false;
+}
+function isFtpsCredentials(unknownObject) {
+  if (!isNonNullObject(unknownObject)) return false;
+  if ("host" in unknownObject && typeof unknownObject.host === "string" && "port" in unknownObject && typeof unknownObject.port === "number" && "username" in unknownObject && typeof unknownObject.username === "string" && "password" in unknownObject && typeof unknownObject.password === "string") return true;
+  return false;
+}
+function isSftpCredentials(unknownObject) {
+  if (!isNonNullObject(unknownObject)) return false;
+  if ("host" in unknownObject && typeof unknownObject.host === "string" && "port" in unknownObject && typeof unknownObject.port === "number" && "username" in unknownObject && typeof unknownObject.username === "string") {
+    const { password, privateKey, passphrase } = unknownObject;
+    if (typeof password !== "string" && password !== void 0) return false;
+    if (typeof privateKey !== "string" && privateKey !== void 0) return false;
+    if (typeof passphrase !== "string" && passphrase !== void 0) return false;
+    return true;
+  }
+  return false;
+}
+function isCredentials(unknownObject) {
+  return isGcsBucketCredentials(unknownObject) || isS3BucketCredentials(unknownObject) || isFtpCredentials(unknownObject) || isFtpsCredentials(unknownObject) || isSftpCredentials(unknownObject);
+}
+
+export {
+  isGcsBucketCredentials,
+  isS3BucketCredentials,
+  isFtpCredentials,
+  isFtpsCredentials,
+  isSftpCredentials,
+  isCredentials,
+  credentials_exports
+};

package/chunks/chunk-EA4L7AGZ.js

@@ -0,0 +1,48 @@
+import {
+  upload as upload2
+} from "./chunk-7FJKDVBE.js";
+import {
+  upload as upload3
+} from "./chunk-O7UEQQ6H.js";
+import {
+  s3IdentifierData
+} from "./chunk-MOBGB2PH.js";
+import {
+  upload as upload4
+} from "./chunk-45WKBXSF.js";
+import {
+  upload
+} from "./chunk-ADTQQNIQ.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.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 upload2(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 upload3(fileReadable, targetPath, bucketName, client);
+  }
+  if (endpointType === "ftp" /* FTP */ && client instanceof FtpClient) return await upload(fileReadable, targetPath, client);
+  if (endpointType === "ftps" /* FTPS */ && client instanceof FtpClient) return await upload(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-FAXNZG5C.js

@@ -0,0 +1,10 @@
+// src/agnostic/colors/hex-to-rgb/index.ts
+function HEXToRGB(hexColor) {
+  hexColor = hexColor.replace("#", "");
+  const r = Math.max(0, Math.min(255, parseInt(hexColor.substring(0, 2), 16))), g = Math.max(0, Math.min(255, parseInt(hexColor.substring(2, 4), 16))), b = Math.max(0, Math.min(255, parseInt(hexColor.substring(4, 6), 16)));
+  return [r, g, b];
+}
+
+export {
+  HEXToRGB
+};

package/chunks/chunk-FMRPJBUC.js

@@ -0,0 +1,20 @@
+import {
+  download_exports
+} from "./chunk-MFWKY3DT.js";
+import {
+  upload_exports
+} from "./chunk-ADTQQNIQ.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/node/ftps/file/index.ts
+var file_exports = {};
+__export(file_exports, {
+  Download: () => download_exports,
+  Upload: () => upload_exports
+});
+
+export {
+  file_exports
+};

package/chunks/chunk-FTT6ZCCS.js

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

package/chunks/chunk-GCHQD7MH.js

@@ -0,0 +1,63 @@
+import {
+  saturateColor,
+  setColorSaturation
+} from "./chunk-MB7HWF22.js";
+import {
+  complementColor
+} from "./chunk-2POD3TAX.js";
+import {
+  lightenColor,
+  setColorLuminance
+} from "./chunk-U57Q62IN.js";
+
+// src/node/images/transform/operations/_utils/frame/backgrounds/create-line-background/index.ts
+async function createLineBackground(background, dimensions, palette) {
+  const lineDimensions = {
+    widthPx: dimensions.widthPx,
+    heightPx: Math.round(dimensions.heightPx / background.params.nbLines)
+  };
+  const sharpOverlays = [];
+  const maxPaletteLength = palette.length;
+  const selectedColorIndex = background.params.colors.selectColorPaletteIndex === "first" ? 0 : background.params.colors.selectColorPaletteIndex === "last" ? palette.length - 1 : background.params.colors.selectColorPaletteIndex;
+  for (let i = 0; i < background.params.nbLines; i++) {
+    const indexPalette = Math.min(Math.max(0, selectedColorIndex), maxPaletteLength);
+    const RGBColor = palette[indexPalette] || [0, 0, 0];
+    const primaryRGBColor = applyColorTransformations(RGBColor, background.params.colors.primaryTransformations);
+    const secondaryRGBColor = applyColorTransformations(RGBColor, background.params.colors.secondaryTransformations);
+    const outputRGBColor = i % 2 === 0 ? primaryRGBColor : secondaryRGBColor;
+    const topPx = Math.min(lineDimensions.heightPx * i, dimensions.heightPx);
+    sharpOverlays.push({
+      input: {
+        create: {
+          width: lineDimensions.widthPx,
+          height: i === background.params.nbLines - 1 ? dimensions.heightPx - topPx : lineDimensions.heightPx,
+          channels: 4,
+          background: { r: outputRGBColor[0], g: outputRGBColor[1], b: outputRGBColor[2], alpha: 1 }
+        }
+      },
+      left: 0,
+      top: topPx
+    });
+  }
+  return sharpOverlays;
+}
+function applyColorTransformations(RGBColor, transformations) {
+  transformations.forEach((transformation) => {
+    RGBColor = transformColor(RGBColor, transformation);
+  });
+  return RGBColor;
+}
+function transformColor(RGBColor, transformation) {
+  switch (transformation.type) {
+    case "saturate":
+      return transformation.intensityMode === "add" ? saturateColor(RGBColor, transformation.intensity) : setColorSaturation(RGBColor, transformation.intensity);
+    case "lighten":
+      return transformation.intensityMode === "add" ? lightenColor(RGBColor, transformation.intensity) : setColorLuminance(RGBColor, transformation.intensity);
+    case "complement":
+      return complementColor(RGBColor);
+  }
+}
+
+export {
+  createLineBackground
+};

package/chunks/chunk-GXICX4F6.js

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

package/chunks/chunk-H73SGDQI.js

@@ -0,0 +1,20 @@
+import {
+  list_exports
+} from "./chunk-XZ7II65Z.js";
+import {
+  get_metadata_exports
+} from "./chunk-FTT6ZCCS.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/node/@google-cloud/storage/bucket/index.ts
+var bucket_exports = {};
+__export(bucket_exports, {
+  GetMetadata: () => get_metadata_exports,
+  List: () => list_exports
+});
+
+export {
+  bucket_exports
+};