@design-edito/tools 0.2.15 → 0.2.17

package/chunks/chunk-IDXUS2IO.js

@@ -0,0 +1,296 @@
+import {
+  zod_default
+} from "./chunk-DZ2T5DTY.js";
+import {
+  toSharpColor,
+  toSharpInstance
+} from "./chunk-BKIF2ELV.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  clamp
+} from "./chunk-OSAXBA7G.js";
+import {
+  isColor
+} from "./chunk-UG5EMKGN.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/images/format/index.ts
+var format_exports = {};
+__export(format_exports, {
+  format: () => format,
+  isFormatAvifOptions: () => isFormatAvifOptions,
+  isFormatCommonOptions: () => isFormatCommonOptions,
+  isFormatHeifOptions: () => isFormatHeifOptions,
+  isFormatJpgOptions: () => isFormatJpgOptions,
+  isFormatOptions: () => isFormatOptions,
+  isFormatPngOptions: () => isFormatPngOptions,
+  isFormatTiffOptions: () => isFormatTiffOptions,
+  isFormatWebpOptions: () => isFormatWebpOptions,
+  toAvif: () => toAvif,
+  toHeif: () => toHeif,
+  toHeight: () => toHeight,
+  toJpg: () => toJpg,
+  toPng: () => toPng,
+  toSharpAvifOptions: () => toSharpAvifOptions,
+  toSharpHeifOptions: () => toSharpHeifOptions,
+  toSharpJpegOptions: () => toSharpJpegOptions,
+  toSharpPngOptions: () => toSharpPngOptions,
+  toSharpResizeOptions: () => toSharpResizeOptions,
+  toSharpTiffOptions: () => toSharpTiffOptions,
+  toSharpWebpOptions: () => toSharpWebpOptions,
+  toTiff: () => toTiff,
+  toWebp: () => toWebp,
+  toWidth: () => toWidth
+});
+var formatCommonOptionsSchema = 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(isColor).optional(),
+  kernel: zod_default.enum(["nearest", "cubic", "mitchell", "lanczos2", "lanczos3", "mks2013", "mks2021"]).optional(),
+  withoutEnlargement: zod_default.boolean().optional(),
+  withoutReduction: zod_default.boolean().optional(),
+  fastShrinkOnLoad: zod_default.boolean().optional()
+});
+var formatJpgOptionsSchema = formatCommonOptionsSchema.extend({
+  type: zod_default.union([zod_default.literal("jpg"), zod_default.literal("jpeg")]),
+  quality: zod_default.number().optional(),
+  force: zod_default.boolean().optional(),
+  progressive: zod_default.boolean().optional(),
+  chromaSubsampling: zod_default.string().optional(),
+  trellisQuantisation: zod_default.boolean().optional(),
+  overshootDeringing: zod_default.boolean().optional(),
+  optimizeScans: zod_default.boolean().optional(),
+  optimizeCoding: zod_default.boolean().optional(),
+  quantizationTable: zod_default.number().optional(),
+  mozjpeg: zod_default.boolean().optional()
+});
+var formatPngOptionsSchema = formatCommonOptionsSchema.extend({
+  type: zod_default.literal("png"),
+  quality: zod_default.number().optional(),
+  force: zod_default.boolean().optional(),
+  progressive: zod_default.boolean().optional(),
+  compressionLevel: zod_default.number().min(0).max(9).optional(),
+  adaptiveFiltering: zod_default.boolean().optional(),
+  effort: zod_default.number().min(1).max(10).optional(),
+  palette: zod_default.boolean().optional(),
+  colors: zod_default.number().min(1).max(256).optional(),
+  dither: zod_default.number().min(0).max(1).optional()
+});
+var formatWebpOptionsSchema = formatCommonOptionsSchema.extend({
+  type: zod_default.literal("webp"),
+  quality: zod_default.number().optional(),
+  force: zod_default.boolean().optional(),
+  alphaQuality: zod_default.number().optional(),
+  lossless: zod_default.boolean().optional(),
+  nearLossless: zod_default.boolean().optional(),
+  smartSubsample: zod_default.boolean().optional(),
+  smartDeblock: zod_default.boolean().optional(),
+  effort: zod_default.number().optional(),
+  minSize: zod_default.boolean().optional(),
+  mixed: zod_default.boolean().optional(),
+  preset: zod_default.enum(["default", "picture", "photo", "drawing", "icon", "text"]).optional(),
+  loop: zod_default.number().optional(),
+  delay: zod_default.union([zod_default.number(), zod_default.array(zod_default.number())]).optional()
+});
+var formatAvifOptionsSchema = formatCommonOptionsSchema.extend({
+  type: zod_default.literal("avif"),
+  quality: zod_default.number().optional(),
+  force: zod_default.boolean().optional(),
+  lossless: zod_default.boolean().optional(),
+  effort: zod_default.number().optional(),
+  chromaSubsampling: zod_default.string().optional(),
+  bitdepth: zod_default.union([zod_default.literal(8), zod_default.literal(10), zod_default.literal(12)]).optional()
+});
+var formatTiffOptionsSchema = formatCommonOptionsSchema.extend({
+  type: zod_default.literal("tiff"),
+  quality: zod_default.number().optional(),
+  compression: zod_default.enum(["none", "jpeg", "deflate", "packbits", "ccittfax4", "lzw", "webp", "zstd", "jp2k"]).optional(),
+  force: zod_default.boolean().optional(),
+  predictor: zod_default.enum(["none", "horizontal", "float"]).optional(),
+  pyramid: zod_default.boolean().optional(),
+  tile: zod_default.boolean().optional(),
+  tileWidth: zod_default.number().optional(),
+  tileHeight: zod_default.number().optional(),
+  xres: zod_default.number().optional(),
+  yres: zod_default.number().optional(),
+  bitdepth: zod_default.union([zod_default.literal(1), zod_default.literal(2), zod_default.literal(4), zod_default.literal(8)]).optional(),
+  miniswhite: zod_default.boolean().optional(),
+  resolutionUnit: zod_default.enum(["inch", "cm"]).optional()
+});
+var formatHeifOptionsSchema = formatCommonOptionsSchema.extend({
+  type: zod_default.literal("heif"),
+  quality: zod_default.number().optional(),
+  force: zod_default.boolean().optional(),
+  compression: zod_default.enum(["av1", "hevc"]).optional(),
+  lossless: zod_default.boolean().optional(),
+  effort: zod_default.number().optional(),
+  chromaSubsampling: zod_default.string().optional(),
+  bitdepth: zod_default.union([zod_default.literal(8), zod_default.literal(10), zod_default.literal(12)]).optional()
+});
+var formatKeepOptionsSchema = formatCommonOptionsSchema;
+var formatOptionsSchema = zod_default.union([
+  formatJpgOptionsSchema,
+  formatPngOptionsSchema,
+  formatWebpOptionsSchema,
+  formatAvifOptionsSchema,
+  formatTiffOptionsSchema,
+  formatHeifOptionsSchema,
+  formatKeepOptionsSchema
+]);
+var isFormatCommonOptions = (options) => formatCommonOptionsSchema.safeParse(options).success;
+var isFormatJpgOptions = (options) => formatJpgOptionsSchema.safeParse(options).success;
+var isFormatPngOptions = (options) => formatPngOptionsSchema.safeParse(options).success;
+var isFormatWebpOptions = (options) => formatWebpOptionsSchema.safeParse(options).success;
+var isFormatAvifOptions = (options) => formatAvifOptionsSchema.safeParse(options).success;
+var isFormatTiffOptions = (options) => formatTiffOptionsSchema.safeParse(options).success;
+var isFormatHeifOptions = (options) => formatHeifOptionsSchema.safeParse(options).success;
+var isFormatOptions = (options) => formatOptionsSchema.safeParse(options).success;
+var toSharpResizeOptions = (options) => {
+  return {
+    width: options.width,
+    height: options.height,
+    fit: options.fit,
+    position: options.position,
+    background: options.background ? toSharpColor(options.background) : void 0,
+    kernel: options.kernel,
+    withoutEnlargement: options.withoutEnlargement,
+    withoutReduction: options.withoutReduction,
+    fastShrinkOnLoad: options.fastShrinkOnLoad
+  };
+};
+var toSharpJpegOptions = (options) => {
+  return {
+    quality: options.quality,
+    force: options.force,
+    progressive: options.progressive,
+    chromaSubsampling: options.chromaSubsampling,
+    trellisQuantisation: options.trellisQuantisation,
+    overshootDeringing: options.overshootDeringing,
+    optimizeScans: options.optimizeScans,
+    optimizeCoding: options.optimizeCoding,
+    quantizationTable: options.quantizationTable,
+    mozjpeg: options.mozjpeg
+  };
+};
+var toSharpPngOptions = (options) => {
+  return {
+    quality: options.quality,
+    force: options.force,
+    progressive: options.progressive,
+    compressionLevel: options.compressionLevel,
+    adaptiveFiltering: options.adaptiveFiltering,
+    effort: options.effort,
+    palette: options.palette,
+    colors: options.colors,
+    dither: options.dither
+  };
+};
+var toSharpWebpOptions = (options) => {
+  return {
+    quality: options.quality,
+    loop: options.loop,
+    delay: options.delay,
+    force: options.force,
+    alphaQuality: options.alphaQuality,
+    lossless: options.lossless,
+    nearLossless: options.nearLossless,
+    smartSubsample: options.smartSubsample,
+    smartDeblock: options.smartDeblock,
+    effort: options.effort,
+    minSize: options.minSize,
+    mixed: options.mixed,
+    preset: options.preset
+  };
+};
+var toSharpAvifOptions = (options) => {
+  return {
+    force: options.force,
+    quality: options.quality,
+    lossless: options.lossless,
+    effort: options.effort,
+    chromaSubsampling: options.chromaSubsampling,
+    bitdepth: options.bitdepth
+  };
+};
+var toSharpTiffOptions = (options) => {
+  return {
+    force: options.force,
+    quality: options.quality,
+    compression: options.compression,
+    predictor: options.predictor,
+    pyramid: options.pyramid,
+    tile: options.tile,
+    tileWidth: options.tileWidth,
+    tileHeight: options.tileHeight,
+    xres: options.xres,
+    yres: options.yres,
+    bitdepth: options.bitdepth,
+    miniswhite: options.miniswhite,
+    resolutionUnit: options.resolutionUnit
+  };
+};
+var toSharpHeifOptions = (options) => {
+  return {
+    force: options.force,
+    quality: options.quality,
+    compression: options.compression,
+    lossless: options.lossless,
+    effort: options.effort,
+    chromaSubsampling: options.chromaSubsampling,
+    bitdepth: options.bitdepth
+  };
+};
+async function format(input, options) {
+  const sharpInstance = await toSharpInstance(input);
+  const resizeOptions = toSharpResizeOptions(options);
+  const resizedInstance = sharpInstance.resize(resizeOptions);
+  if (isFormatJpgOptions(options)) return Outcome.makeSuccess(await resizedInstance.jpeg(toSharpJpegOptions(options)).toBuffer());
+  if (isFormatPngOptions(options)) return Outcome.makeSuccess(await resizedInstance.png(toSharpPngOptions(options)).toBuffer());
+  if (isFormatWebpOptions(options)) return Outcome.makeSuccess(await resizedInstance.webp(toSharpWebpOptions(options)).toBuffer());
+  if (isFormatAvifOptions(options)) return Outcome.makeSuccess(await resizedInstance.avif(toSharpAvifOptions(options)).toBuffer());
+  if (isFormatTiffOptions(options)) return Outcome.makeSuccess(await resizedInstance.tiff(toSharpTiffOptions(options)).toBuffer());
+  if (isFormatHeifOptions(options)) return Outcome.makeSuccess(await resizedInstance.heif(toSharpHeifOptions(options)).toBuffer());
+  return Outcome.makeSuccess(await resizedInstance.toBuffer());
+}
+var toWidth = async (input, width) => (await toSharpInstance(input)).resize({ width }).toBuffer();
+var toHeight = async (input, height) => (await toSharpInstance(input)).resize({ height }).toBuffer();
+var toJpg = async (input, quality) => (await toSharpInstance(input)).jpeg({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+var toPng = async (input, quality, compressionLevel) => (await toSharpInstance(input)).png({ quality: clamp(quality ?? 100, 1, 100), compressionLevel }).toBuffer();
+var toWebp = async (input, quality) => (await toSharpInstance(input)).webp({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+var toAvif = async (input, quality) => (await toSharpInstance(input)).avif({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+var toTiff = async (input, quality, compression) => (await toSharpInstance(input)).tiff({ quality: clamp(quality ?? 100, 1, 100), compression }).toBuffer();
+var toHeif = async (input, quality) => (await toSharpInstance(input)).heif({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+
+export {
+  isFormatCommonOptions,
+  isFormatJpgOptions,
+  isFormatPngOptions,
+  isFormatWebpOptions,
+  isFormatAvifOptions,
+  isFormatTiffOptions,
+  isFormatHeifOptions,
+  isFormatOptions,
+  toSharpResizeOptions,
+  toSharpJpegOptions,
+  toSharpPngOptions,
+  toSharpWebpOptions,
+  toSharpAvifOptions,
+  toSharpTiffOptions,
+  toSharpHeifOptions,
+  format,
+  toWidth,
+  toHeight,
+  toJpg,
+  toPng,
+  toWebp,
+  toAvif,
+  toTiff,
+  toHeif,
+  format_exports
+};

package/chunks/chunk-ISUDTAMN.js

@@ -0,0 +1,101 @@
+import {
+  zod_default
+} from "./chunk-DZ2T5DTY.js";
+import {
+  isDuckTypedSharpInstance,
+  toSharpInstance
+} from "./chunk-BKIF2ELV.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  isColor
+} from "./chunk-UG5EMKGN.js";
+
+// src/node/images/transform/operations/overlay/index.ts
+function isOverlayOperationParams(obj) {
+  const schema = zod_default.object({
+    input: zod_default.union([
+      zod_default.custom(isDuckTypedSharpInstance),
+      zod_default.custom(Buffer.isBuffer),
+      zod_default.string(),
+      zod_default.object({
+        width: zod_default.number().optional(),
+        height: zod_default.number().optional(),
+        channels: zod_default.union([zod_default.literal(3), zod_default.literal(4)]).optional(),
+        background: zod_default.custom(isColor).optional(),
+        noise: zod_default.object({
+          mean: zod_default.number().optional(),
+          sigma: zod_default.number().optional()
+        }).optional(),
+        pageHeight: zod_default.number().optional()
+      })
+    ]),
+    top: zod_default.number().optional(),
+    left: zod_default.number().optional(),
+    tile: zod_default.boolean().optional(),
+    premultiplied: zod_default.boolean().optional(),
+    density: zod_default.number().optional(),
+    animated: zod_default.boolean().optional(),
+    autoOrient: zod_default.boolean().optional(),
+    ignoreIcc: zod_default.boolean().optional(),
+    pages: zod_default.number().optional(),
+    page: zod_default.number().optional(),
+    blend: zod_default.enum([
+      "clear",
+      "source",
+      "over",
+      "in",
+      "out",
+      "atop",
+      "dest",
+      "dest-over",
+      "dest-in",
+      "dest-out",
+      "dest-atop",
+      "xor",
+      "add",
+      "saturate",
+      "multiply",
+      "screen",
+      "overlay",
+      "darken",
+      "lighten",
+      "color-dodge",
+      "colour-dodge",
+      "color-burn",
+      "colour-burn",
+      "hard-light",
+      "soft-light",
+      "difference",
+      "exclusion"
+    ]).optional(),
+    gravity: zod_default.enum([
+      "north",
+      "northeast",
+      "southeast",
+      "south",
+      "southwest",
+      "west",
+      "northwest",
+      "east",
+      "center",
+      "centre"
+    ]).optional()
+  });
+  const result = schema.safeParse(obj);
+  if (!result.success) return Outcome.makeFailure(result.error.message);
+  return Outcome.makeSuccess(result.data);
+}
+async function overlay(sharpInstance, params) {
+  const inputBuffer = params.input instanceof Buffer ? params.input : await (await toSharpInstance(params.input)).toBuffer();
+  return sharpInstance.composite([{
+    ...params,
+    input: inputBuffer
+  }]);
+}
+
+export {
+  isOverlayOperationParams,
+  overlay
+};

package/chunks/{chunk-GVQVGFAA.js → chunk-J4WGYUFY.js}

@@ -2,16 +2,16 @@ import {
   Cast,
   Tree,
   Utils
-} from "./chunk-QCMBG5LN.js";
-import {
-  Serialize
-} from "./chunk-SXRWMH3U.js";
+} from "./chunk-7SZXDQVJ.js";
 import {
   Types
 } from "./chunk-XEQ2PBT2.js";
 import {
   SmartTags
 } from "./chunk-UT2J62LH.js";
+import {
+  Serialize
+} from "./chunk-SXRWMH3U.js";
 import {
   Transformer
 } from "./chunk-BKO7GLC2.js";

package/chunks/{chunk-Q6DUKZU6.js → chunk-JJ7DN7NN.js}

@@ -1,16 +1,16 @@
-import {
-  isArrayOf
-} from "./chunk-6RGDWX4A.js";
-import {
-  randomPick,
-  randomPickMany
-} from "./chunk-B446JIN3.js";
 import {
   shuffle
 } from "./chunk-VJJIYJMY.js";
 import {
   findDuplicates
 } from "./chunk-YS6WMSWC.js";
+import {
+  randomPick,
+  randomPickMany
+} from "./chunk-AQBJ6HNB.js";
+import {
+  isArrayOf
+} from "./chunk-6RGDWX4A.js";
 import {
   make
 } from "./chunk-RLAZR3NL.js";

package/chunks/{chunk-EDJ3TVNV.js → chunk-KDOMQ4LM.js}

@@ -1,12 +1,15 @@
-import {
-  isSharpColor
-} from "./chunk-MFYNJMVM.js";
 import {
   zod_default
 } from "./chunk-DZ2T5DTY.js";
+import {
+  toSharpColor
+} from "./chunk-BKIF2ELV.js";
 import {
   Outcome
 } from "./chunk-JMU5PDBD.js";
+import {
+  isColor
+} from "./chunk-UG5EMKGN.js";
 
 // src/node/images/transform/operations/resize/index.ts
 function isResizeOperationParams(obj) {
@@ -24,13 +27,16 @@ function isResizeOperationParams(obj) {
       zod_default.number(),
       zod_default.string()
     ]).optional(),
-    background: zod_default.custom((val) => isSharpColor(val)).optional(),
+    background: zod_default.custom(isColor).optional(),
     kernel: zod_default.enum([
       "nearest",
       "cubic",
+      "linear",
       "mitchell",
       "lanczos2",
-      "lanczos3"
+      "lanczos3",
+      "mks2013",
+      "mks2021"
     ]).optional(),
     withoutEnlargement: zod_default.boolean().optional(),
     withoutReduction: zod_default.boolean().optional(),
@@ -41,7 +47,10 @@ function isResizeOperationParams(obj) {
   return Outcome.makeSuccess(result.data);
 }
 async function resize(sharpInstance, params) {
-  return sharpInstance.resize(params);
+  return sharpInstance.resize({
+    ...params,
+    background: params.background !== void 0 ? toSharpColor(params.background) : void 0
+  });
 }
 
 export {