@design-edito/tools 0.1.52 → 0.1.54

package/chunks/chunk-TSQVG7GA.js

@@ -0,0 +1,31 @@
+import {
+  isArrayOf
+} from "./chunk-6RGDWX4A.js";
+import {
+  findDuplicates
+} from "./chunk-YS6WMSWC.js";
+import {
+  make
+} from "./chunk-RLAZR3NL.js";
+import {
+  randomPick,
+  randomPickMany
+} from "./chunk-WJMBLQRX.js";
+import {
+  shuffle
+} from "./chunk-VJJIYJMY.js";
+
+// src/agnostic/arrays/index.tsx
+var Arrays;
+((Arrays2) => {
+  Arrays2.findDuplicates = findDuplicates;
+  Arrays2.isArrayOf = isArrayOf;
+  Arrays2.make = make;
+  Arrays2.randomPick = randomPick;
+  Arrays2.randomPickMany = randomPickMany;
+  Arrays2.shuffle = shuffle;
+})(Arrays || (Arrays = {}));
+
+export {
+  Arrays
+};

package/chunks/chunk-TXOUGP37.js

@@ -0,0 +1,62 @@
+import {
+  areaCompose
+} from "./chunk-4LCL2RIC.js";
+import {
+  require_lib
+} from "./chunk-53MBV4TG.js";
+import {
+  __export,
+  __toESM
+} from "./chunk-XCBH6NLF.js";
+
+// src/node/images/transform/index.ts
+var transform_exports = {};
+__export(transform_exports, {
+  isOperation: () => isOperation,
+  transformImage: () => transformImage
+});
+var import_sharp = __toESM(require_lib(), 1);
+async function transformImage(imageBuffer, operations, maxDimensions) {
+  const imageSharp = (0, import_sharp.default)(imageBuffer);
+  let imageSharped = imageSharp;
+  for await (const operation of operations) {
+    if (isOperation(operation)) {
+      imageSharped = await applyOperation(imageSharped, operation, maxDimensions);
+    }
+  }
+  return await imageSharped.toBuffer();
+}
+function isOperation(operation) {
+  return true;
+}
+async function applyOperation(imageSharp, operation, maxDimensions) {
+  switch (operation.name) {
+    case "rotate":
+      return imageSharp.rotate(operation.params.angle);
+    case "resize":
+      return imageSharp.resize({
+        width: operation.params.width,
+        height: operation.params.height,
+        fit: operation.params.fit || "cover",
+        background: { r: 255, g: 255, b: 255, alpha: 0 }
+      });
+    /* Adds a transparent background (necessary for png) */
+    case "area-composition":
+      const composedImage = await areaCompose(imageSharp, {
+        ...operation.params,
+        dimensions: {
+          w: maxDimensions.width,
+          h: maxDimensions.height
+        }
+      });
+      return composedImage;
+    default:
+      return imageSharp;
+  }
+}
+
+export {
+  transformImage,
+  isOperation,
+  transform_exports
+};

package/chunks/chunk-UG36UPJK.js

@@ -0,0 +1,31 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-XCBH6NLF.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-UVSTFYSD.js

@@ -0,0 +1,28 @@
+import {
+  colors_exports
+} from "./chunk-X5FAZBWL.js";
+import {
+  layout_exports
+} from "./chunk-BONBND7I.js";
+import {
+  common_exports
+} from "./chunk-7DDXALPH.js";
+import {
+  easings_exports
+} from "./chunk-JJWKHBXD.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@design-edito/thumbnails/index.ts
+var thumbnails_exports = {};
+__export(thumbnails_exports, {
+  Colors: () => colors_exports,
+  Common: () => common_exports,
+  Easings: () => easings_exports,
+  Layout: () => layout_exports
+});
+
+export {
+  thumbnails_exports
+};

package/chunks/chunk-UXM54YBI.js

@@ -0,0 +1,68 @@
+import {
+  __export
+} from "./chunk-XCBH6NLF.js";
+
+// src/node/@design-edito/thumbnails/easings/index.ts
+var easings_exports = {};
+__export(easings_exports, {
+  ease: () => ease,
+  easeInOutQuad: () => easeInOutQuad,
+  easeInOutSine: () => easeInOutSine,
+  easeInQuad: () => easeInQuad,
+  easeInSine: () => easeInSine,
+  easeOutQuad: () => easeOutQuad,
+  easeOutSine: () => easeOutSine,
+  linear: () => linear
+});
+function ease(t, name) {
+  switch (name) {
+    case "in-sine":
+      return easeInSine(t);
+    case "out-sine":
+      return easeOutSine(t);
+    case "in-out-sine":
+      return easeInOutSine(t);
+    case "in-quad":
+      return easeInQuad(t);
+    case "out-quad":
+      return easeOutQuad(t);
+    case "in-out-quad":
+      return easeInOutQuad(t);
+    case "linear":
+    default:
+      return linear(t);
+  }
+}
+function linear(t) {
+  return t;
+}
+function easeOutSine(t) {
+  return Math.sin(t * (Math.PI / 2));
+}
+function easeInSine(t) {
+  return -1 * Math.cos(t * (Math.PI / 2)) + 1;
+}
+function easeInOutSine(t) {
+  return -0.5 * (Math.cos(Math.PI * t) - 1);
+}
+function easeInQuad(t) {
+  return t * t;
+}
+function easeOutQuad(t) {
+  return t * (2 - t);
+}
+function easeInOutQuad(t) {
+  return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+}
+
+export {
+  ease,
+  linear,
+  easeOutSine,
+  easeInSine,
+  easeInOutSine,
+  easeInQuad,
+  easeOutQuad,
+  easeInOutQuad,
+  easings_exports
+};

package/chunks/chunk-VHFMQI7Z.js

@@ -0,0 +1,20 @@
+import {
+  get_metadata_exports
+} from "./chunk-AF2MI5O5.js";
+import {
+  list_exports
+} from "./chunk-KYMCGWPM.js";
+import {
+  __export
+} from "./chunk-XCBH6NLF.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
+};

package/chunks/chunk-VP3Y6EMX.js

@@ -0,0 +1,190 @@
+import {
+  __commonJS,
+  __require
+} from "./chunk-XCBH6NLF.js";
+
+// node_modules/inherits/inherits_browser.js
+var require_inherits_browser = __commonJS({
+  "node_modules/inherits/inherits_browser.js"(exports, module) {
+    if (typeof Object.create === "function") {
+      module.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          ctor.prototype = Object.create(superCtor.prototype, {
+            constructor: {
+              value: ctor,
+              enumerable: false,
+              writable: true,
+              configurable: true
+            }
+          });
+        }
+      };
+    } else {
+      module.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          var TempCtor = function() {
+          };
+          TempCtor.prototype = superCtor.prototype;
+          ctor.prototype = new TempCtor();
+          ctor.prototype.constructor = ctor;
+        }
+      };
+    }
+  }
+});
+
+// node_modules/inherits/inherits.js
+var require_inherits = __commonJS({
+  "node_modules/inherits/inherits.js"(exports, module) {
+    try {
+      util = __require("util");
+      if (typeof util.inherits !== "function") throw "";
+      module.exports = util.inherits;
+    } catch (e) {
+      module.exports = require_inherits_browser();
+    }
+    var util;
+  }
+});
+
+// node_modules/process-nextick-args/index.js
+var require_process_nextick_args = __commonJS({
+  "node_modules/process-nextick-args/index.js"(exports, module) {
+    "use strict";
+    if (typeof process === "undefined" || !process.version || process.version.indexOf("v0.") === 0 || process.version.indexOf("v1.") === 0 && process.version.indexOf("v1.8.") !== 0) {
+      module.exports = { nextTick };
+    } else {
+      module.exports = process;
+    }
+    function nextTick(fn, arg1, arg2, arg3) {
+      if (typeof fn !== "function") {
+        throw new TypeError('"callback" argument must be a function');
+      }
+      var len = arguments.length;
+      var args, i;
+      switch (len) {
+        case 0:
+        case 1:
+          return process.nextTick(fn);
+        case 2:
+          return process.nextTick(function afterTickOne() {
+            fn.call(null, arg1);
+          });
+        case 3:
+          return process.nextTick(function afterTickTwo() {
+            fn.call(null, arg1, arg2);
+          });
+        case 4:
+          return process.nextTick(function afterTickThree() {
+            fn.call(null, arg1, arg2, arg3);
+          });
+        default:
+          args = new Array(len - 1);
+          i = 0;
+          while (i < args.length) {
+            args[i++] = arguments[i];
+          }
+          return process.nextTick(function afterTick() {
+            fn.apply(null, args);
+          });
+      }
+    }
+  }
+});
+
+// node_modules/isarray/index.js
+var require_isarray = __commonJS({
+  "node_modules/isarray/index.js"(exports, module) {
+    var toString = {}.toString;
+    module.exports = Array.isArray || function(arr) {
+      return toString.call(arr) == "[object Array]";
+    };
+  }
+});
+
+// node_modules/core-util-is/lib/util.js
+var require_util = __commonJS({
+  "node_modules/core-util-is/lib/util.js"(exports) {
+    function isArray(arg) {
+      if (Array.isArray) {
+        return Array.isArray(arg);
+      }
+      return objectToString(arg) === "[object Array]";
+    }
+    exports.isArray = isArray;
+    function isBoolean(arg) {
+      return typeof arg === "boolean";
+    }
+    exports.isBoolean = isBoolean;
+    function isNull(arg) {
+      return arg === null;
+    }
+    exports.isNull = isNull;
+    function isNullOrUndefined(arg) {
+      return arg == null;
+    }
+    exports.isNullOrUndefined = isNullOrUndefined;
+    function isNumber(arg) {
+      return typeof arg === "number";
+    }
+    exports.isNumber = isNumber;
+    function isString(arg) {
+      return typeof arg === "string";
+    }
+    exports.isString = isString;
+    function isSymbol(arg) {
+      return typeof arg === "symbol";
+    }
+    exports.isSymbol = isSymbol;
+    function isUndefined(arg) {
+      return arg === void 0;
+    }
+    exports.isUndefined = isUndefined;
+    function isRegExp(re) {
+      return objectToString(re) === "[object RegExp]";
+    }
+    exports.isRegExp = isRegExp;
+    function isObject(arg) {
+      return typeof arg === "object" && arg !== null;
+    }
+    exports.isObject = isObject;
+    function isDate(d) {
+      return objectToString(d) === "[object Date]";
+    }
+    exports.isDate = isDate;
+    function isError(e) {
+      return objectToString(e) === "[object Error]" || e instanceof Error;
+    }
+    exports.isError = isError;
+    function isFunction(arg) {
+      return typeof arg === "function";
+    }
+    exports.isFunction = isFunction;
+    function isPrimitive(arg) {
+      return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
+      typeof arg === "undefined";
+    }
+    exports.isPrimitive = isPrimitive;
+    exports.isBuffer = __require("buffer").Buffer.isBuffer;
+    function objectToString(o) {
+      return Object.prototype.toString.call(o);
+    }
+  }
+});
+
+// node_modules/util-deprecate/node.js
+var require_node = __commonJS({
+  "node_modules/util-deprecate/node.js"(exports, module) {
+    module.exports = __require("util").deprecate;
+  }
+});
+
+export {
+  require_process_nextick_args,
+  require_isarray,
+  require_util,
+  require_inherits,
+  require_node
+};

package/chunks/chunk-VQEP2EQF.js

@@ -0,0 +1,100 @@
+import {
+  transformImage
+} from "./chunk-VV72XGJJ.js";
+import {
+  thumbnails_exports
+} from "./chunk-UVSTFYSD.js";
+import {
+  exportZipBuffer,
+  prepareExport
+} from "./chunk-5RGHYFQH.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,
+  prepareImage: () => prepareImage
+});
+import sharp from "sharp";
+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");
+  }
+  const transformedBuffer = await transformImage(imageBuffer, options.inputOperations, {
+    width: thumbnails_exports.Common.getArrayMax(options.widths) || 0,
+    height: thumbnails_exports.Common.getArrayMax(options.heights) || 0
+  });
+  const exportsBuffers = [{
+    buffer: imageBuffer,
+    name: generateFileName({
+      ...imageBufferMetadata,
+      quality: 100,
+      suffix: "original",
+      preffix: options.name
+    })
+  }];
+  for await (const width of options.widths) {
+    for await (const height of options.heights) {
+      for await (const quality of options.qualities) {
+        for await (const format of options.formats) {
+          const exportBuffer = await prepareExport(transformedBuffer, {
+            format,
+            quality,
+            width,
+            height
+          });
+          exportsBuffers.push({
+            buffer: exportBuffer,
+            name: generateFileName({ width, height, quality, format, preffix: options.name })
+          });
+        }
+      }
+    }
+  }
+  const zipBuffer = exportZipBuffer(exportsBuffers, generateZipName());
+  return zipBuffer;
+}
+function getOptions(imageBufferMetadata, options) {
+  return {
+    center: [0.5, 0.5],
+    qualities: [100],
+    inputOperations: [],
+    ...options,
+    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() {
+  const date = /* @__PURE__ */ new Date();
+  return `image-exports_${date.toLocaleDateString()}_${date.toLocaleTimeString()}_${date.getTime()}`.replace(/\/|:/g, "-").replace(/ /g, "").trim();
+}
+function generateFileName({ width, height, quality, format, suffix, preffix }) {
+  const _preffix = preffix ? `${preffix}_` : "image-formats_";
+  const _suffix = `${suffix ? `_${suffix}` : ""}.${format}`;
+  return `${_preffix}${width}${height}_Q${quality}${_suffix}`;
+}
+
+export {
+  MAX_NB_OUTPUTS,
+  OUTPUT_ZIP_FOLDER,
+  prepareImage,
+  prepare_exports
+};

package/chunks/chunk-VV72XGJJ.js

@@ -0,0 +1,58 @@
+import {
+  areaCompose
+} from "./chunk-422KBDRV.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/images/transform/index.ts
+var transform_exports = {};
+__export(transform_exports, {
+  isOperation: () => isOperation,
+  transformImage: () => transformImage
+});
+import sharp from "sharp";
+async function transformImage(imageBuffer, operations, maxDimensions) {
+  const imageSharp = sharp(imageBuffer);
+  let imageSharped = imageSharp;
+  for await (const operation of operations) {
+    if (isOperation(operation)) {
+      imageSharped = await applyOperation(imageSharped, operation, maxDimensions);
+    }
+  }
+  return await imageSharped.toBuffer();
+}
+function isOperation(operation) {
+  return true;
+}
+async function applyOperation(imageSharp, operation, maxDimensions) {
+  switch (operation.name) {
+    case "rotate":
+      return imageSharp.rotate(operation.params.angle);
+    case "resize":
+      return imageSharp.resize({
+        width: operation.params.width,
+        height: operation.params.height,
+        fit: operation.params.fit || "cover",
+        background: { r: 255, g: 255, b: 255, alpha: 0 }
+      });
+    /* Adds a transparent background (necessary for png) */
+    case "area-composition":
+      const composedImage = await areaCompose(imageSharp, {
+        ...operation.params,
+        dimensions: {
+          w: maxDimensions.width,
+          h: maxDimensions.height
+        }
+      });
+      return composedImage;
+    default:
+      return imageSharp;
+  }
+}
+
+export {
+  transformImage,
+  isOperation,
+  transform_exports
+};

package/chunks/chunk-VXSOUAUT.js

@@ -0,0 +1,100 @@
+import {
+  exportZipBuffer,
+  prepareExport
+} from "./chunk-5RGHYFQH.js";
+import {
+  transformImage
+} from "./chunk-A4FSJC46.js";
+import {
+  thumbnails_exports
+} from "./chunk-HTNLTDQT.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,
+  prepareImage: () => prepareImage
+});
+import sharp from "sharp";
+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");
+  }
+  const transformedBuffer = await transformImage(imageBuffer, options.inputOperations, {
+    width: thumbnails_exports.Common.getArrayMax(options.widths) || 0,
+    height: thumbnails_exports.Common.getArrayMax(options.heights) || 0
+  });
+  const exportsBuffers = [{
+    buffer: imageBuffer,
+    name: generateFileName({
+      ...imageBufferMetadata,
+      quality: 100,
+      suffix: "original",
+      preffix: options.name
+    })
+  }];
+  for await (const width of options.widths) {
+    for await (const height of options.heights) {
+      for await (const quality of options.qualities) {
+        for await (const format of options.formats) {
+          const exportBuffer = await prepareExport(transformedBuffer, {
+            format,
+            quality,
+            width,
+            height
+          });
+          exportsBuffers.push({
+            buffer: exportBuffer,
+            name: generateFileName({ width, height, quality, format, preffix: options.name })
+          });
+        }
+      }
+    }
+  }
+  const zipBuffer = exportZipBuffer(exportsBuffers, generateZipName());
+  return zipBuffer;
+}
+function getOptions(imageBufferMetadata, options) {
+  return {
+    center: [0.5, 0.5],
+    qualities: [100],
+    inputOperations: [],
+    ...options,
+    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() {
+  const date = /* @__PURE__ */ new Date();
+  return `image-exports_${date.toLocaleDateString()}_${date.toLocaleTimeString()}_${date.getTime()}`.replace(/\/|:/g, "-").replace(/ /g, "").trim();
+}
+function generateFileName({ width, height, quality, format, suffix, preffix }) {
+  const _preffix = preffix ? `${preffix}_` : "image-formats_";
+  const _suffix = `${suffix ? `_${suffix}` : ""}.${format}`;
+  return `${_preffix}${width}${height}_Q${quality}${_suffix}`;
+}
+
+export {
+  MAX_NB_OUTPUTS,
+  OUTPUT_ZIP_FOLDER,
+  prepareImage,
+  prepare_exports
+};