@design-edito/tools 0.1.73 → 0.2.1

package/chunks/chunk-FORJXSIW.js

@@ -0,0 +1,43 @@
+import {
+  isSharpColor
+} from "./chunk-4UV3XIGE.js";
+import {
+  zod_default
+} from "./chunk-OT4SVHDX.js";
+
+// src/node/images/transform/operations/resize/index.ts
+function isResizeOperationParams(obj) {
+  return zod_default.object({
+    width: zod_default.number().optional(),
+    height: zod_default.number().optional(),
+    fit: zod_default.enum([
+      "contain",
+      "cover",
+      "fill",
+      "inside",
+      "outside"
+    ]).optional(),
+    position: zod_default.union([
+      zod_default.number(),
+      zod_default.string()
+    ]).optional(),
+    background: zod_default.custom((val) => isSharpColor(val)).optional(),
+    kernel: zod_default.enum([
+      "nearest",
+      "cubic",
+      "mitchell",
+      "lanczos2",
+      "lanczos3",
+      "mks2013",
+      "mks2021"
+    ]).optional()
+  }).safeParse(obj).success;
+}
+async function resize(sharpInstance, params) {
+  return sharpInstance.resize(params);
+}
+
+export {
+  isResizeOperationParams,
+  resize
+};

package/chunks/chunk-FRJBHV4A.js

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

package/chunks/chunk-G4Y2EOVP.js

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

package/chunks/chunk-GGYWRA4A.js

@@ -0,0 +1,231 @@
+import {
+  Transitions
+} from "./chunk-ENMBK6H7.js";
+import {
+  shuffle
+} from "./chunk-VJJIYJMY.js";
+import {
+  randomInt
+} from "./chunk-D3ERTRDW.js";
+import {
+  clamp
+} from "./chunk-OSAXBA7G.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-GKCKBPY2.js

@@ -0,0 +1,16 @@
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+import {
+  zod_default
+} from "./chunk-FI675VZO.js";
+
+// src/node/images/transform/hue-rotate/index.ts
+var hueRotateSchema = zod_default.object({
+  name: zod_default.literal(OperationNames.HueRotate),
+  params: zod_default.number().min(0).max(360)
+});
+
+export {
+  hueRotateSchema
+};

package/chunks/{chunk-6PIGLFM3.js → chunk-GVGPJLS7.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-S32K7POB.js";
 import {
   Arrays
-} from "./chunk-LMPEBXSU.js";
+} from "./chunk-J7JWEDGE.js";
 
 // src/agnostic/misc/lorem-ipsum/index.ts
 var LoremIpsum;

package/chunks/chunk-GZIEUPBF.js

@@ -0,0 +1,18 @@
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+import {
+  zod_default
+} from "./chunk-FI675VZO.js";
+
+// src/node/images/transform/rotate/index.ts
+var rotateSchema = zod_default.object({
+  name: zod_default.literal(OperationNames.Rotate),
+  params: zod_default.object({
+    angle: zod_default.number()
+  })
+});
+
+export {
+  rotateSchema
+};

package/chunks/chunk-HRWQVASA.js

@@ -0,0 +1,40 @@
+import {
+  remove_exports
+} from "./chunk-KJAEVOIW.js";
+import {
+  move_exports
+} from "./chunk-HRNDUTZE.js";
+import {
+  copy_exports
+} from "./chunk-NMYVJJXV.js";
+import {
+  download_exports
+} from "./chunk-FF5NURFO.js";
+import {
+  exists_exports
+} from "./chunk-ZJTWDCNZ.js";
+import {
+  upload_exports
+} from "./chunk-CVDCTI7F.js";
+import {
+  stat_exports
+} from "./chunk-CNYSX2L2.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/ftps/file/index.ts
+var file_exports = {};
+__export(file_exports, {
+  Copy: () => copy_exports,
+  Download: () => download_exports,
+  Exists: () => exists_exports,
+  Move: () => move_exports,
+  Remove: () => remove_exports,
+  Stat: () => stat_exports,
+  Upload: () => upload_exports
+});
+
+export {
+  file_exports
+};

package/chunks/chunk-HX5PHI2P.js

@@ -0,0 +1,42 @@
+import {
+  moveDir as moveDir4
+} from "./chunk-BWYH445G.js";
+import {
+  moveDir as moveDir3
+} from "./chunk-ON6LC3HE.js";
+import {
+  moveDir
+} from "./chunk-BE7OXZRK.js";
+import {
+  moveDir as moveDir2
+} from "./chunk-RWO53U4X.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/move-dir/index.ts
+var move_dir_exports = {};
+__export(move_dir_exports, {
+  moveDir: () => moveDir5
+});
+async function moveDir5(client, sourcePath, targetPath, options) {
+  if (isGcsBucket(client)) return moveDir4(client, sourcePath, targetPath, options);
+  if (isS3ClientWithBucket(client)) return moveDir3(client.client, client.bucketName, sourcePath, targetPath, options);
+  if (isFtpClient(client)) return moveDir(client, sourcePath, targetPath, options);
+  if (isSftpClient(client)) return moveDir2(client, sourcePath, targetPath, options);
+  return Outcome.makeFailure("Invalid client type");
+}
+
+export {
+  moveDir5 as moveDir,
+  move_dir_exports
+};

package/chunks/chunk-HY4V3SPP.js

@@ -0,0 +1,56 @@
+import {
+  remove_dir_exports
+} from "./chunk-CA3UPHYO.js";
+import {
+  move_file_exports
+} from "./chunk-646R6BQZ.js";
+import {
+  remove_file_exports
+} from "./chunk-H4LW6FP3.js";
+import {
+  copy_dir_exports
+} from "./chunk-6NLNUGBI.js";
+import {
+  copy_file_exports
+} from "./chunk-OA7Y2A5T.js";
+import {
+  download_file_exports
+} from "./chunk-EOTOFHUR.js";
+import {
+  list_dir_exports
+} from "./chunk-DPQRXSZH.js";
+import {
+  exists_file_exports
+} from "./chunk-24ZUWYIR.js";
+import {
+  move_dir_exports
+} from "./chunk-FS6LRTDK.js";
+import {
+  upload_file_exports
+} from "./chunk-NOLQR5RW.js";
+import {
+  stat_file_exports
+} from "./chunk-UK4HNSEJ.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/cloud-storage/operations/index.ts
+var operations_exports = {};
+__export(operations_exports, {
+  CopyDir: () => copy_dir_exports,
+  CopyFile: () => copy_file_exports,
+  DownloadFile: () => download_file_exports,
+  ExistsFile: () => exists_file_exports,
+  ListDir: () => list_dir_exports,
+  MoveDir: () => move_dir_exports,
+  MoveFile: () => move_file_exports,
+  RemoveDir: () => remove_dir_exports,
+  RemoveFile: () => remove_file_exports,
+  StatFile: () => stat_file_exports,
+  UploadFile: () => upload_file_exports
+});
+
+export {
+  operations_exports
+};

package/chunks/chunk-IFZ4CMF4.js

@@ -0,0 +1,16 @@
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+import {
+  zod_default
+} from "./chunk-FI675VZO.js";
+
+// src/node/images/transform/saturate/index.ts
+var saturateSchema = zod_default.object({
+  name: zod_default.literal(OperationNames.Saturate),
+  params: zod_default.number().min(0)
+});
+
+export {
+  saturateSchema
+};

package/chunks/{chunk-IH25CV3F.js → chunk-J4C3U3MK.js}

@@ -1,9 +1,12 @@
 import {
   bucket_exports
-} from "./chunk-YMRAUWRW.js";
+} from "./chunk-UEAMPAHK.js";
+import {
+  directory_exports
+} from "./chunk-CKENYYWH.js";
 import {
   file_exports
-} from "./chunk-6V7VQ32U.js";
+} from "./chunk-IWDIKDYR.js";
 import {
   __export
 } from "./chunk-WSFCRVEQ.js";
@@ -12,6 +15,7 @@ import {
 var storage_exports = {};
 __export(storage_exports, {
   Bucket: () => bucket_exports,
+  Directory: () => directory_exports,
   File: () => file_exports
 });
 

package/chunks/chunk-JAENHN5Z.js

@@ -0,0 +1,42 @@
+import {
+  remove as remove4
+} from "./chunk-7J7CYOXU.js";
+import {
+  remove as remove3
+} from "./chunk-3TKBCG7Y.js";
+import {
+  remove
+} from "./chunk-KJAEVOIW.js";
+import {
+  remove as remove2
+} from "./chunk-ANPXBD2G.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/remove-file/index.ts
+var remove_file_exports = {};
+__export(remove_file_exports, {
+  removeFile: () => removeFile
+});
+async function removeFile(client, path, options) {
+  if (isGcsBucket(client)) return remove4(client, path, options);
+  if (isS3ClientWithBucket(client)) return remove3(client.client, path, client.bucketName, options);
+  if (isFtpClient(client)) return remove(client, path, options);
+  if (isSftpClient(client)) return remove2(client, path, options);
+  return Outcome.makeFailure("Invalid client type");
+}
+
+export {
+  removeFile,
+  remove_file_exports
+};

package/chunks/chunk-JNQPNZTB.js

@@ -0,0 +1,42 @@
+import {
+  removeDir as removeDir4
+} from "./chunk-QLDN574K.js";
+import {
+  removeDir as removeDir3
+} from "./chunk-4XSDRT23.js";
+import {
+  removeDir
+} from "./chunk-BSUQNHAM.js";
+import {
+  removeDir as removeDir2
+} from "./chunk-5ZJ3KJPK.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/remove-dir/index.ts
+var remove_dir_exports = {};
+__export(remove_dir_exports, {
+  removeDir: () => removeDir5
+});
+async function removeDir5(client, sourcePath, options) {
+  if (isGcsBucket(client)) return removeDir4(client, sourcePath, options);
+  if (isS3ClientWithBucket(client)) return removeDir3(client.client, client.bucketName, sourcePath, options);
+  if (isFtpClient(client)) return removeDir(client, sourcePath, options);
+  if (isSftpClient(client)) return removeDir2(client, sourcePath, options);
+  return Outcome.makeFailure("Invalid client type");
+}
+
+export {
+  removeDir5 as removeDir,
+  remove_dir_exports
+};

package/chunks/chunk-JQAOGZPV.js

@@ -0,0 +1,37 @@
+import {
+  Cast,
+  Tree,
+  Utils
+} from "./chunk-Z4B2Z7QO.js";
+import {
+  Serialize
+} from "./chunk-SXRWMH3U.js";
+import {
+  Types
+} from "./chunk-XEQ2PBT2.js";
+import {
+  SmartTags
+} from "./chunk-UT2J62LH.js";
+import {
+  Transformer
+} from "./chunk-BKO7GLC2.js";
+import {
+  Method
+} from "./chunk-RW7VAKJW.js";
+
+// src/agnostic/html/hyper-json/index.ts
+var HyperJson;
+((HyperJson2) => {
+  HyperJson2.Cast = Cast;
+  HyperJson2.Method = Method;
+  HyperJson2.Serialize = Serialize;
+  HyperJson2.SmartTags = SmartTags;
+  HyperJson2.Transformer = Transformer;
+  HyperJson2.Tree = Tree;
+  HyperJson2.Types = Types;
+  HyperJson2.Utils = Utils;
+})(HyperJson || (HyperJson = {}));
+
+export {
+  HyperJson
+};