pixeli 0.1.9 → 1.0.4

package/dist/core/utils/images/getImageWidths.js

@@ -0,0 +1,9 @@
+import sharp from 'sharp';
+export const getImageWidths = async (images) => {
+    const widths = [];
+    for (const image of images) {
+        const meta = await image.metadata();
+        widths.push(meta.width);
+    }
+    return widths;
+};

package/dist/core/utils/images/getSmallestImageDimensions.d.ts

@@ -0,0 +1,5 @@
+import sharp from 'sharp';
+export declare const getSmallestImageDimensions: (images: sharp.Sharp[]) => Promise<{
+    smallestWidth: number;
+    smallestHeight: number;
+}>;

package/dist/core/utils/images/getSmallestImageDimensions.js

@@ -0,0 +1,9 @@
+import sharp from 'sharp';
+// Width and height do not necessarily have to be from the same image
+export const getSmallestImageDimensions = async (images) => {
+    const metas = await Promise.all(images.map((img) => img.metadata()));
+    return metas.reduce((acc, meta) => ({
+        smallestWidth: Math.min(acc.smallestWidth, meta.width),
+        smallestHeight: Math.min(acc.smallestHeight, meta.height),
+    }), { smallestWidth: Infinity, smallestHeight: Infinity });
+};

package/dist/core/utils/images/handleImageEdges.d.ts

@@ -0,0 +1,13 @@
+import sharp from 'sharp';
+import type { RGBA } from '../colors/types.js';
+interface Options {
+    borderWidth: number;
+    borderHeight: number;
+    borderColor: RGBA;
+    cornerRadius: number;
+    imageWidth: number;
+    imageHeight: number;
+    finalizePipeline?: boolean;
+}
+export declare const handleImageEdges: (image: sharp.Sharp, { borderWidth, borderHeight, borderColor, imageWidth, imageHeight, cornerRadius, finalizePipeline }: Options) => Promise<sharp.Sharp>;
+export {};

package/dist/core/utils/images/handleImageEdges.js

@@ -0,0 +1,39 @@
+import sharp from 'sharp';
+import { rgbaToHex } from '../colors/rgbaToHex.js';
+export const handleImageEdges = async (image, { borderWidth, borderHeight, borderColor, imageWidth, imageHeight, cornerRadius = 0, finalizePipeline = false }) => {
+    // Only change the image's edges if needed
+    if (borderWidth <= 0 && borderHeight <= 0 && cornerRadius <= 0)
+        return image;
+    const maxBorderX = imageWidth / 2;
+    const maxBorderY = imageHeight / 2;
+    const effectiveBorderWidth = Math.min(borderWidth, maxBorderX);
+    const effectiveBorderHeight = Math.min(borderHeight, maxBorderY);
+    // Step 1 — Round corners mask
+    const mask = `
+    <svg width="${imageWidth}" height="${imageHeight}">
+      <rect x="0" y="0" width="${imageWidth}" height="${imageHeight}" rx="${cornerRadius}" ry="${cornerRadius}" fill="white"/>
+    </svg>
+  `;
+    // Step 2 — Optional border layer (draw inside the image)
+    const border = `
+    <svg width="${imageWidth}" height="${imageHeight}">
+      <rect x="${effectiveBorderWidth / 2}" y="${effectiveBorderHeight / 2}" width="${imageWidth - effectiveBorderWidth}" height="${imageHeight - effectiveBorderHeight}" rx="${cornerRadius}" ry="${cornerRadius}" 
+        fill="none" stroke="${rgbaToHex(borderColor)}" stroke-width="${Math.max(effectiveBorderWidth, effectiveBorderHeight)}"/>
+    </svg>
+  `;
+    // Only pick needed composites
+    const composites = [];
+    if (cornerRadius > 0) {
+        composites.push({ input: Buffer.from(mask), blend: 'dest-in', top: 0, left: 0 });
+    }
+    if (effectiveBorderWidth > 0 || effectiveBorderHeight > 0) {
+        composites.push({ input: Buffer.from(border), blend: 'over', top: 0, left: 0 });
+    }
+    // Step 3 — Composite mask and border
+    const processed = composites.length > 0 ? image.toFormat('png').composite(composites) : image;
+    // Finalize image if needed
+    if (finalizePipeline) {
+        return sharp(await processed.toBuffer());
+    }
+    return processed;
+};

package/dist/core/utils/images/isActualImage.d.ts

@@ -0,0 +1,5 @@
+import sharp from 'sharp';
+export declare const isActualImage: (input: sharp.SharpInput) => Promise<{
+    isImage: boolean;
+    reason: string;
+}>;

package/dist/core/utils/images/isActualImage.js

@@ -0,0 +1,26 @@
+import sharp from 'sharp';
+export const isActualImage = async (input) => {
+    try {
+        // Try to get metadata
+        const metadata = await sharp(input).metadata();
+        // Try to get width and height
+        /* v8 ignore start */
+        if (!metadata.width || !metadata.height) {
+            return {
+                isImage: false,
+                reason: 'Image metadata missing width or height',
+            };
+        }
+        /* v8 ignore stop */
+    }
+    catch (err) {
+        return {
+            isImage: false,
+            reason: err.message,
+        };
+    }
+    return {
+        isImage: true,
+        reason: '',
+    };
+};

package/dist/core/utils/images/parseAspectRatio.d.ts

@@ -0,0 +1 @@
+export declare const parseAspectRatio: (aspectRatio: string) => number | false;

package/dist/core/utils/images/parseAspectRatio.js

@@ -0,0 +1,22 @@
+export const parseAspectRatio = (aspectRatio) => {
+    // return ratio straight away if its just a number
+    const ratio = Number(aspectRatio);
+    if (ratio) {
+        return ratio;
+    }
+    const ratioRegex = /^\s*(\d+)\s*(\/|:|x)\s*(\d+)\s*$/i;
+    const match = aspectRatio.match(ratioRegex);
+    // Ensure match exists
+    if (!match)
+        return false;
+    // Ensures absolute type safety
+    const [, wStr, , hStr] = match;
+    if (!wStr || !hStr)
+        return false;
+    // Return aspect ratio
+    const width = parseInt(wStr, 10);
+    const height = parseInt(hStr, 10);
+    if (width === 0 || height === 0)
+        return false;
+    return width / height;
+};

package/dist/core/utils/images/roundImage.d.ts

@@ -0,0 +1,9 @@
+import sharp from 'sharp';
+interface RoundImageOptions {
+    width: number;
+    height: number;
+    cornerRadius: number;
+    finalizePipeline?: boolean;
+}
+export declare const roundImage: (image: sharp.Sharp, { width, height, cornerRadius, finalizePipeline }: RoundImageOptions) => Promise<sharp.Sharp>;
+export {};

package/dist/core/utils/images/roundImage.js

@@ -0,0 +1,27 @@
+import sharp from 'sharp';
+export const roundImage = async (image, { width, height, cornerRadius, finalizePipeline = false }) => {
+    // Skip if the cornerRadius = zero
+    if (!cornerRadius)
+        return image;
+    // Create rounded svg mask
+    const mask = Buffer.from(`
+        <svg width="${width}" height="${height}">
+          <rect x="0" y="0" width="${width}" height="${height}" rx="${cornerRadius}" ry="${cornerRadius}" />
+          </svg>
+      `);
+    // Apply mask
+    const roundedImage = image
+        .composite([
+        {
+            input: mask,
+            blend: 'dest-in',
+        },
+    ])
+        .toFormat('png');
+    // Finalize pipeline if needed
+    if (finalizePipeline) {
+        const buffer = await roundedImage.toBuffer();
+        return sharp(buffer);
+    }
+    return roundedImage;
+};

package/dist/core/utils/images/roundImages.d.ts

@@ -0,0 +1,8 @@
+import sharp from 'sharp';
+interface RoundImagesOptions {
+    width: number;
+    height: number;
+    cornerRadius: number;
+}
+export declare const roundImages: (images: sharp.Sharp[], { width, height, cornerRadius }: RoundImagesOptions) => Promise<sharp.Sharp[]>;
+export {};

package/dist/core/utils/images/roundImages.js

@@ -0,0 +1,19 @@
+import sharp from 'sharp';
+export const roundImages = async (images, { width, height, cornerRadius }) => {
+    // Skip if the cornerRadius = zero
+    if (!cornerRadius)
+        return images;
+    // Round images respectively
+    return await Promise.all(images.map(async (image) => {
+        const mask = Buffer.from(`
+        <svg width="${width}" height="${height}">
+          <rect x="0" y="0" width="${width}" height="${height}" rx="${cornerRadius}" ry="${cornerRadius}" />
+          </svg>
+      `);
+        const buff = await image
+            .composite([{ input: mask, blend: 'dest-in' }])
+            .png()
+            .toBuffer();
+        return sharp(buff);
+    }));
+};

package/dist/core/utils/images/scaleImage.d.ts

@@ -0,0 +1,8 @@
+import sharp from 'sharp';
+interface ScaleImageOptions {
+    width?: number;
+    height?: number;
+    finalizePipeline?: boolean;
+}
+export declare const scaleImage: (image: sharp.Sharp, { width, height, finalizePipeline }: ScaleImageOptions) => Promise<sharp.Sharp>;
+export {};

package/dist/core/utils/images/scaleImage.js

@@ -0,0 +1,36 @@
+import sharp from 'sharp';
+export const scaleImage = async (image, { width, height, finalizePipeline = false }) => {
+    // Ensure either width or height is provided
+    if (width == undefined && height === undefined) {
+        throw new Error('You must provide either width or height.');
+    }
+    let targetWidth, targetHeight;
+    const meta = await image.metadata();
+    // Set target width and height using size factor
+    if (width !== undefined && height !== undefined) {
+        targetWidth = width;
+        targetHeight = height;
+    }
+    else if (width !== undefined) {
+        const f = width / meta.width;
+        targetWidth = width;
+        targetHeight = Math.floor(meta.height * f);
+    }
+    else {
+        const f = height / meta.height;
+        targetHeight = height;
+        targetWidth = Math.floor(meta.width * f);
+    }
+    // Resize the image
+    const resizedImage = image.resize(targetWidth, targetHeight);
+    // Only finalize changes in the image pipeline if needed
+    if (finalizePipeline) {
+        // Use jpg format if possible for less memory usage
+        const formatPipe = meta.channels === 4 ? resizedImage.toFormat('png') : resizedImage.toFormat('jpg');
+        const buffer = await formatPipe.toBuffer();
+        return sharp(buffer);
+    }
+    else {
+        return resizedImage;
+    }
+};

package/dist/core/utils/images/scaleImages.d.ts

@@ -0,0 +1,8 @@
+import sharp from 'sharp';
+interface ScaleImagesOptions {
+    width?: number;
+    height?: number;
+    finalizePipeline?: boolean;
+}
+export declare const scaleImages: (images: sharp.Sharp[], { width, height, finalizePipeline }?: ScaleImagesOptions) => Promise<sharp.Sharp[]>;
+export {};

package/dist/core/utils/images/scaleImages.js

@@ -0,0 +1,38 @@
+import sharp from 'sharp';
+export const scaleImages = async (images, { width, height, finalizePipeline = false } = {}) => {
+    // Ensure either width or height is provided
+    if (width == undefined && height === undefined) {
+        throw new Error('You must provide either width or height.');
+    }
+    // Return scaled images
+    const scaledImages = await Promise.all(images.map(async (image) => {
+        const meta = await image.metadata();
+        let targetWidth, targetHeight;
+        if (width !== undefined && height !== undefined) {
+            targetWidth = width;
+            targetHeight = height;
+        }
+        else if (width !== undefined) {
+            const f = width / meta.width;
+            targetWidth = width;
+            targetHeight = Math.floor(meta.height * f);
+        }
+        else {
+            const f = height / meta.height;
+            targetHeight = height;
+            targetWidth = Math.floor(meta.width * f);
+        }
+        const newImage = image.resize(targetWidth, targetHeight);
+        // Only finalize changes in the image pipeline if needed
+        if (finalizePipeline) {
+            // Use jpg format if possible for less memory usage
+            const formatPipe = meta.channels === 4 ? newImage.toFormat('png') : newImage.toFormat('jpg');
+            const buffer = await formatPipe.toBuffer();
+            return sharp(buffer);
+        }
+        else {
+            return newImage;
+        }
+    }));
+    return scaledImages;
+};

package/dist/core/utils/math/median.d.ts

@@ -0,0 +1 @@
+export declare function median(values: readonly number[]): number | null;

package/dist/core/utils/math/median.js

@@ -0,0 +1,12 @@
+export function median(values) {
+    if (values.length === 0)
+        return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 1) {
+        return sorted[mid] ?? null;
+    }
+    const a = sorted[mid - 1];
+    const b = sorted[mid];
+    return a !== undefined && b !== undefined ? (a + b) / 2 : null;
+}

package/dist/core/utils/math/randint.d.ts

@@ -0,0 +1,6 @@
+interface Randint {
+    (low: number, high: number): number;
+    (value: number): number;
+}
+export declare const randint: Randint;
+export {};

package/dist/core/utils/math/randint.js

@@ -0,0 +1,11 @@
+export const randint = (lowOrValue, high) => {
+    if (high === undefined) {
+        return Math.round(Math.random() * lowOrValue);
+    }
+    let low = lowOrValue;
+    if (high > low) {
+        [low, high] = [high, low];
+    }
+    const range = high - low;
+    return Math.round(low + Math.random() * range);
+};

package/dist/core/utils/math/trimmedMedian.d.ts

@@ -0,0 +1 @@
+export declare const trimmedMedian: (values: number[], trimRatio?: number) => number | null;

package/dist/core/utils/math/trimmedMedian.js

@@ -0,0 +1,12 @@
+import { median } from './median.js';
+export const trimmedMedian = (values, trimRatio = 0.1) => {
+    if (values.length === 0)
+        return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    const trim = Math.floor(sorted.length * trimRatio);
+    // Prevent trimming everything
+    if (trim * 2 >= sorted.length) {
+        return median(sorted);
+    }
+    return median(sorted.slice(trim, sorted.length - trim));
+};

package/dist/core/utils/svg/createSvgTextBuffer.d.ts

@@ -0,0 +1,9 @@
+interface CreateSvgTextBufferOptions {
+    text: string;
+    maxWidth: number;
+    maxHeight: number;
+    fontSize: number;
+    fill?: string;
+}
+export declare const createSvgTextBuffer: ({ text, maxWidth, maxHeight, fontSize, fill }: CreateSvgTextBufferOptions) => Buffer<ArrayBuffer>;
+export {};

package/dist/core/utils/svg/createSvgTextBuffer.js

@@ -0,0 +1,21 @@
+import { escapeXML } from '../../helpers.js';
+export const createSvgTextBuffer = ({ text, maxWidth, maxHeight, fontSize, fill = '#000000' }) => {
+    // Width and viewport are assigned to this svg
+    const svg = `
+    <svg xmlns="http://www.w3.org/2000/svg"
+         width="${maxWidth}" height="${maxHeight}"
+         viewBox="0 0 ${maxWidth} ${maxHeight}">
+      <text
+        x="${maxWidth / 2}"
+        y="${maxHeight / 2}"
+        font-size="${fontSize}"
+        font-family="sans-serif"
+        fill="${fill}"
+        text-anchor="middle"
+        dominant-baseline="middle">
+        ${escapeXML(text)}
+      </text>
+    </svg>
+    `;
+    return Buffer.from(svg);
+};

package/dist/validators/aspectRatio.d.ts

@@ -0,0 +1,2 @@
+import z from 'zod';
+export declare const aspectRatioValidator: z.ZodPipe<z.z.ZodCoercedString<unknown>, z.ZodTransform<number, string>>;

package/dist/validators/aspectRatio.js

@@ -0,0 +1,15 @@
+import z from 'zod';
+import { parseAspectRatio } from '../core/utils/images/parseAspectRatio.js';
+export const aspectRatioValidator = z.coerce.string().transform((ratio, ctx) => {
+    const result = parseAspectRatio(ratio);
+    // Validate aspect ratio
+    if (!result) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Invalid aspect ratio: Examples of valid ratios include 16/9, 2:3, 1x2, 1.77.',
+            input: ratio,
+        });
+        return z.NEVER;
+    }
+    return result;
+});

package/dist/validators/coercion.d.ts

@@ -0,0 +1,2 @@
+import z from 'zod';
+export declare const useNumberCoercion: (schema: z.ZodNumber) => z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;

package/dist/validators/coercion.js

@@ -0,0 +1,12 @@
+import z from 'zod';
+export const useNumberCoercion = (schema) => {
+    return z.preprocess((val) => {
+        if (typeof val === 'number')
+            return val;
+        if (typeof val === 'string' && val.trim() !== '') {
+            const n = Number(val);
+            return Number.isNaN(n) ? val : n;
+        }
+        return val;
+    }, schema);
+};

package/dist/validators/format.d.ts

@@ -0,0 +1,2 @@
+import z from 'zod';
+export declare const formatValidator: z.ZodPipe<z.ZodString, z.ZodTransform<"webp" | "gif" | "jpeg" | "jpg" | "png" | "tiff" | "avif", string>>;

package/dist/validators/format.js

@@ -0,0 +1,15 @@
+import z from 'zod';
+import { isSupportedOutputImage, SUPPORTED_OUTPUT_FORMATS } from '../core/helpers.js';
+export const formatValidator = z.string().transform((extname, ctx) => {
+    if (isSupportedOutputImage(extname)) {
+        return extname;
+    }
+    else {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['format'],
+            message: `Invalid format type. Valid output formats include: ${SUPPORTED_OUTPUT_FORMATS.join(', ')}`,
+        });
+        return z.NEVER;
+    }
+});

package/dist/validators/hexColor.d.ts

@@ -0,0 +1,7 @@
+import z from 'zod';
+export declare const hexColorValidator: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/utils/colors/types.js").RGBA, string>>, z.ZodObject<{
+    r: z.ZodNumber;
+    g: z.ZodNumber;
+    b: z.ZodNumber;
+    alpha: z.ZodNumber;
+}, z.z.core.$strip>]>;

package/dist/validators/hexColor.js

@@ -0,0 +1,27 @@
+import z from 'zod';
+import { isValidHexColor } from '../core/helpers.js';
+import { hexToRgba } from '../core/utils/colors/hexToRgba.js';
+export const hexColorValidator = z.union([
+    z.string().transform((color, ctx) => {
+        // Handle transparency
+        if (color === 'transparent') {
+            return hexToRgba('#00000000');
+        }
+        // Handle hex values
+        if (!isValidHexColor(color)) {
+            ctx.addIssue({
+                code: 'custom',
+                message: "Invalid color: must be 'transparent', #rgb, #rrggbb, #rrggbbaa, or object of {r, g, b, a}.",
+                input: color,
+            });
+            return z.NEVER;
+        }
+        return hexToRgba(color);
+    }),
+    z.object({
+        r: z.number().int().min(0).max(255),
+        g: z.number().int().min(0).max(255),
+        b: z.number().int().min(0).max(255),
+        alpha: z.number().min(0).max(1),
+    }, "Invalid color: must be 'transparent', #rgb, #rrggbb, #rrggbbaa, or object of {r, g, b, a}."),
+], "Invalid color: must be 'transparent', #rgb, #rrggbb, #rrggbbaa, or object of {r, g, b, a}.");

package/dist/validators/index.d.ts

@@ -0,0 +1,95 @@
+import z from 'zod';
+export declare const VALIDATORS: {
+    files: z.ZodArray<z.ZodString>;
+    dir: z.ZodString;
+    output: z.ZodString;
+    format: z.ZodPipe<z.ZodString, z.ZodTransform<"webp" | "gif" | "jpeg" | "jpg" | "png" | "tiff" | "avif", string>>;
+    cliTemplate: z.ZodString;
+    imageInputs: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>;
+    captions: z.ZodArray<z.ZodString>;
+    caption: z.ZodBoolean;
+    recursive: z.ZodBoolean;
+    shuffle: z.ZodBoolean;
+    canvasColor: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/utils/colors/types.js").RGBA, string>>, z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+        alpha: z.ZodNumber;
+    }, z.z.core.$strip>]>;
+    captionColor: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/utils/colors/types.js").RGBA, string>>, z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+        alpha: z.ZodNumber;
+    }, z.z.core.$strip>]>;
+    borderColor: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/utils/colors/types.js").RGBA, string>>, z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+        alpha: z.ZodNumber;
+    }, z.z.core.$strip>]>;
+    cornerRadius: z.ZodNumber;
+    gap: z.ZodNumber;
+    imageWidth: z.ZodNumber;
+    columns: z.ZodNumber;
+    maxCaptionSize: z.ZodNumber;
+    rowHeight: z.ZodNumber;
+    columnWidth: z.ZodNumber;
+    canvasWidth: z.ZodNumber;
+    canvasHeight: z.ZodNumber;
+    overlapPercentage: z.ZodNumber;
+    rotationRange: z.ZodNumber;
+    imageWidthVariance: z.ZodNumber;
+    borderWidth: z.ZodNumber;
+    cliCornerRadius: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+    cliGap: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+    cliImageWidth: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+    cliColumns: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+    cliMaxCaptionSize: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+    cliRowHeight: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+    cliColumnWidth: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+    cliCanvasWidth: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+    cliCanvasHeight: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+    cliOverlapPercentage: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+    cliRotationRange: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+    cliImageWidthVariance: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+    cliBorderWidth: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+    flow: z.ZodEnum<{
+        horizontal: "horizontal";
+        vertical: "vertical";
+    }>;
+    hAlign: z.ZodEnum<{
+        left: "left";
+        center: "center";
+        right: "right";
+        justified: "justified";
+    }>;
+    vAlign: z.ZodEnum<{
+        justified: "justified";
+        top: "top";
+        middle: "middle";
+        bottom: "bottom";
+    }>;
+    preset: z.ZodEnum<{
+        "instagram-grid": "instagram-grid";
+        "dashboard-shot": "dashboard-shot";
+        "horizontal-book-spread": "horizontal-book-spread";
+        "vertical-book-spread": "vertical-book-spread";
+        "art-gallery": "art-gallery";
+    }>;
+    template: z.ZodObject<{
+        canvas: z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            columns: z.ZodNumber;
+            rows: z.ZodNumber;
+        }, z.z.core.$strip>;
+        slots: z.ZodArray<z.ZodObject<{
+            col: z.ZodNumber;
+            row: z.ZodNumber;
+            colSpan: z.ZodNumber;
+            rowSpan: z.ZodNumber;
+        }, z.z.core.$strip>>;
+    }, z.z.core.$strip>;
+    aspectRatio: z.ZodPipe<z.z.ZodCoercedString<unknown>, z.ZodTransform<number, string>>;
+};

package/dist/validators/index.js

@@ -0,0 +1,64 @@
+import z from 'zod';
+import { hexColorValidator } from './hexColor.js';
+import { aspectRatioValidator } from './aspectRatio.js';
+import { sharpImageValidation } from './sharpImageInput.js';
+import { dirPathValidator, filePathValidator } from './path.js';
+import { outputFileValidator } from './outputFile.js';
+import { useNumberCoercion } from './coercion.js';
+import { formatValidator } from './format.js';
+import { templateValidator } from './template.js';
+export const VALIDATORS = {
+    // Inputs and outputs
+    files: z.array(filePathValidator),
+    dir: dirPathValidator,
+    output: outputFileValidator,
+    format: formatValidator,
+    cliTemplate: filePathValidator,
+    imageInputs: z.array(sharpImageValidation),
+    // Strings
+    captions: z.array(z.string()),
+    // Flags
+    caption: z.boolean(),
+    recursive: z.boolean(),
+    shuffle: z.boolean(),
+    // Colors
+    canvasColor: hexColorValidator,
+    captionColor: hexColorValidator,
+    borderColor: hexColorValidator,
+    // Numbers
+    cornerRadius: z.number().int().gte(0),
+    gap: z.number().gte(0).int(),
+    imageWidth: z.number().gt(0).int(),
+    columns: z.number().gt(0).int(),
+    maxCaptionSize: z.number().gt(0).int(),
+    rowHeight: z.number().gt(0).int(),
+    columnWidth: z.number().gt(0).int(),
+    canvasWidth: z.number().gt(0).int(),
+    canvasHeight: z.number().gt(0).int(),
+    overlapPercentage: z.number().gte(0).lte(100).int(),
+    rotationRange: z.number().gte(0).lte(360).int(),
+    imageWidthVariance: z.number().gte(0).int(),
+    borderWidth: z.number().gte(0).int(),
+    // Coerced Numbers
+    cliCornerRadius: useNumberCoercion(z.number().int().gte(0)),
+    cliGap: useNumberCoercion(z.number().gte(0).int()),
+    cliImageWidth: useNumberCoercion(z.number().gt(0).int()),
+    cliColumns: useNumberCoercion(z.number().gt(0).int()),
+    cliMaxCaptionSize: useNumberCoercion(z.number().gt(0).int()),
+    cliRowHeight: useNumberCoercion(z.number().gt(0).int()),
+    cliColumnWidth: useNumberCoercion(z.number().gt(0).int()),
+    cliCanvasWidth: useNumberCoercion(z.number().gt(0).int()),
+    cliCanvasHeight: useNumberCoercion(z.number().gt(0).int()),
+    cliOverlapPercentage: useNumberCoercion(z.number().gte(0).lte(100).int()),
+    cliRotationRange: useNumberCoercion(z.number().gte(0).lte(360).int()),
+    cliImageWidthVariance: useNumberCoercion(z.number().gte(0).int()),
+    cliBorderWidth: useNumberCoercion(z.number().gte(0).int()),
+    // Enumerations
+    flow: z.enum(['horizontal', 'vertical']),
+    hAlign: z.enum(['left', 'center', 'right', 'justified']),
+    vAlign: z.enum(['top', 'middle', 'bottom', 'justified']),
+    preset: z.enum(['instagram-grid', 'dashboard-shot', 'horizontal-book-spread', 'vertical-book-spread', 'art-gallery']),
+    // Misc
+    template: templateValidator,
+    aspectRatio: aspectRatioValidator,
+};