pixeli 0.1.8 → 1.0.3

package/dist/core/merges/template/steps/calculateSlotDimensions.d.ts

@@ -0,0 +1,9 @@
+import type { MergeStep } from '../../../pipeline/mergePipeline.js';
+import type { Template } from '../types.js';
+import type { TemplateState } from '../index.js';
+interface Options {
+    gap: number;
+    template: Template;
+}
+export declare const calculateCanvasDimensions: MergeStep<Options, TemplateState>;
+export {};

package/dist/core/merges/template/steps/calculateSlotDimensions.js

@@ -0,0 +1,12 @@
+export const calculateCanvasDimensions = async (context, options, _onProgress) => {
+    // Calculate each column's width and height
+    const workableCanvasWidth = options.template.canvas.width - options.gap * (options.template.canvas.columns + 1);
+    const workableCanvasHeight = options.template.canvas.height - options.gap * (options.template.canvas.rows + 1);
+    const slotWidth = workableCanvasWidth / options.template.canvas.columns;
+    const slotHeight = workableCanvasHeight / options.template.canvas.rows;
+    // Assign to state
+    context.state.canvasWidth = options.template.canvas.width;
+    context.state.canvasHeight = options.template.canvas.height;
+    context.state.slotWidth = slotWidth;
+    context.state.slotHeight = slotHeight;
+};

package/dist/core/merges/template/steps/createComposites.d.ts

@@ -0,0 +1,10 @@
+import type { MergeStep } from '../../../pipeline/mergePipeline.js';
+import type { Template } from '../types.js';
+import type { TemplateState } from '../index.js';
+interface Options {
+    template: Template;
+    gap: number;
+    cornerRadius: number;
+}
+export declare const createComposites: MergeStep<Options, TemplateState>;
+export {};

package/dist/core/merges/template/steps/createComposites.js

@@ -0,0 +1,25 @@
+import { requireState } from '../../../pipeline/guards.js';
+export const createComposites = async (context, options, onProgress) => {
+    // Require needed states
+    requireState(context, 'blocks');
+    requireState(context, 'slotWidth');
+    requireState(context, 'slotHeight');
+    // Collect composites
+    const composites = [];
+    for (const block of context.state.blocks) {
+        const x = (block.col - 1) * context.state.slotWidth + block.col * options.gap;
+        const y = (block.row - 1) * context.state.slotHeight + block.row * options.gap;
+        composites.push({
+            input: block.imageBuffer,
+            left: Math.floor(x),
+            top: Math.floor(y),
+        });
+        // Update progress
+        if (onProgress) {
+            context.progressInfo.phase = 'Merging images';
+            context.progressInfo.completed += 1;
+            onProgress({ ...context.progressInfo });
+        }
+    }
+    context.composites = composites;
+};

package/dist/core/merges/template/steps/getBlocks.d.ts

@@ -0,0 +1,13 @@
+import type { MergeStep } from '../../../pipeline/mergePipeline.js';
+import type { Template } from '../types.js';
+import type { TemplateState } from '../index.js';
+import type { RGBA } from '../../../utils/colors/types.js';
+interface Options {
+    template: Template;
+    gap: number;
+    borderWidth: number;
+    borderColor: RGBA;
+    cornerRadius: number;
+}
+export declare const getBlocks: MergeStep<Options, TemplateState>;
+export {};

package/dist/core/merges/template/steps/getBlocks.js

@@ -0,0 +1,28 @@
+import { requireNonEmptyArray, requireState } from '../../../pipeline/guards.js';
+import { handleImageEdges } from '../../../utils/images/handleImageEdges.js';
+export const getBlocks = async (context, options, _onProgress) => {
+    // Require needed states
+    requireState(context, 'slotWidth');
+    requireState(context, 'slotHeight');
+    requireNonEmptyArray(context.images, 'images');
+    const blocks = [];
+    for (let i = 0; i < options.template.slots.length && i < context.images.length; i++) {
+        const slot = options.template.slots[i];
+        const image = context.images[i];
+        // Calculate image width and height
+        const width = Math.floor(slot.colSpan * context.state.slotWidth + (slot.colSpan - 1) * options.gap);
+        const height = Math.floor(slot.rowSpan * context.state.slotHeight + (slot.rowSpan - 1) * options.gap);
+        // Resize image
+        const resizedImage = image.resize({ width, height });
+        const borderedImage = await handleImageEdges(resizedImage, {
+            borderWidth: options.borderWidth,
+            borderHeight: options.borderWidth,
+            borderColor: options.borderColor,
+            cornerRadius: options.cornerRadius,
+            imageWidth: width,
+            imageHeight: height,
+        });
+        blocks.push({ imageBuffer: await borderedImage.toBuffer(), col: slot.col, row: slot.row });
+    }
+    context.state.blocks = blocks;
+};

package/dist/core/merges/template/types.d.ts

@@ -0,0 +1,21 @@
+export interface Canvas {
+    width: number;
+    height: number;
+    columns: number;
+    rows: number;
+}
+export interface Slot {
+    col: number;
+    row: number;
+    colSpan: number;
+    rowSpan: number;
+}
+export interface Template {
+    canvas: Canvas;
+    slots: Slot[];
+}
+export interface Block {
+    imageBuffer: Buffer;
+    col: number;
+    row: number;
+}

package/dist/core/merges/template/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/merges/types.d.ts

@@ -0,0 +1,102 @@
+import sharp from 'sharp';
+import type { Color } from '../utils/colors/types.js';
+import type { Template } from './template/types.js';
+export interface ProgressInfo {
+    /** How many images have been processed so far */
+    completed: number;
+    /** The total number of images to be processed */
+    total: number;
+    /** The current phase of the merge */
+    phase: string;
+}
+export type OnProgress = (info: ProgressInfo) => void;
+/**
+ * Generic image merge command.
+ *
+ * @template T - Merge-specific configuration options
+ * @param imageInputs - Input images to merge
+ * @param options - Merge options
+ * @param onProgress - Optional progress callback
+ * @returns A Promise resolving to the merged image buffer
+ */
+interface MergeCommand<T> {
+    (imageInputs: sharp.SharpInput[], options: T, onProgress?: OnProgress): Promise<Buffer>;
+}
+interface BaseMergeOptions {
+    /** Whether to randomize image order before merging. */
+    shuffle?: boolean;
+    /** Rounded corner radius in pixels. */
+    cornerRadius?: number;
+    /** Gap between images in pixels. */
+    gap?: number;
+    /** Background canvas color. */
+    canvasColor?: Color;
+    /** Width of the border around each image. Borders are placed internally in each image. */
+    borderWidth?: number;
+    /** Color of the border around each image. */
+    borderColor?: Color;
+    /** Output image format (png, jpeg, webp). */
+    format?: string;
+}
+export interface GridMergeOptions extends BaseMergeOptions {
+    /** The aspect ratio of each image. Used to calculate image height based on given width.
+     *
+     * Examples include `16:9`, `3x2` or `1.777`. */
+    aspectRatio?: string | number;
+    /** Width of each image cell in pixels, uses the median image width if undefined. */
+    imageWidth?: number | undefined;
+    /** Number of columns in the grid. */
+    columns?: number;
+    /** Enable captions under images. */
+    caption?: boolean;
+    /** Captions text (one per image, in order). */
+    captions?: string[];
+    /** Caption text color. */
+    captionColor?: Color;
+    /** Maximum caption font size in pixels. */
+    maxCaptionSize?: number;
+}
+export interface MasonryMergeOptions extends BaseMergeOptions {
+    /** The height of each row, defaults to the trimmed median image height if undefined. Only applied in horizontal flows. */
+    rowHeight?: number | undefined;
+    /** The width of each column, defaults to the trimmed median image width if undefined. Only applied in vertical flows. */
+    columnWidth?: number | undefined;
+    /** The width of the entire canvas. Only required in horizontal flows. */
+    canvasWidth?: number | undefined;
+    /** The width of the entire canvas. Only required in vertical flows. */
+    canvasHeight?: number | undefined;
+    /** The orientation of the masonry layout. */
+    flow: 'horizontal' | 'vertical';
+    /** The horizontal alignment of each row. Only applied in horizontal layouts. */
+    hAlign?: 'left' | 'center' | 'right' | 'justified';
+    /** The vertical alignment of each column. Only applied in vertical layouts. */
+    vAlign?: 'top' | 'middle' | 'bottom' | 'justified';
+}
+interface TemplateMergeOptions extends BaseMergeOptions {
+    template: Template;
+}
+interface CollageMergeOptions extends Omit<BaseMergeOptions, 'gap'> {
+    /** Width of each image cell in pixels, uses the median image width if undefined. */
+    imageWidth?: number | undefined;
+    /** The aspect ratio of each image. Used to calculate image height based on given width.
+     *
+     * Examples include `16:9`, `3x2` or `1.777`. */
+    aspectRatio?: string | number;
+    /** Number of columns in the collage grid. */
+    columns?: number;
+    /** The number of pixels to potentially variate `imageWidth` by. Used to create random-sized images in the collage.
+     *
+     *  For example, a value of `50` results in images being up to `50` pixels wider or narrower than the given `imageWidth`. */
+    imageWidthVariance?: number;
+    /** The estimated percentage of overlap for every image pair. A higher percentage creates a tighter collage. */
+    overlapPercentage?: number;
+    /** The maximum and minimum degree to rotate each image.
+     *
+     * For example, a value of `10` will result in a random degree being picked from `-10` to `+10` degrees. */
+    rotationRange?: number;
+}
+export type GridMerge = MergeCommand<GridMergeOptions>;
+export type MasonryMerge = MergeCommand<MasonryMergeOptions>;
+export type TemplateMerge = MergeCommand<TemplateMergeOptions>;
+export type CollageMerge = MergeCommand<CollageMergeOptions>;
+export {};

package/dist/core/merges/types.js

@@ -0,0 +1 @@
+import sharp from 'sharp';

package/dist/core/modules/messages.d.ts

@@ -0,0 +1,32 @@
+interface Message {
+    message: string;
+    chalk?: (text: string) => string;
+}
+export declare const MESSAGES: {
+    WARNINGS: {
+        IGNORED_FILES: {
+            message: string;
+            chalk: import("chalk").ChalkInstance;
+        };
+    };
+    SUCCESS: {
+        OUTPUT: {
+            message: string;
+            chalk: import("chalk").ChalkInstance;
+        };
+    };
+    ERROR: {
+        INTERNAL: {
+            message: string;
+            chalk: import("chalk").ChalkInstance;
+        };
+    };
+};
+export declare class MessageRenderer {
+    #private;
+    message: Message;
+    constructor(message: Message, ...inputs: (string | number)[]);
+    render(): void;
+    confirm(defaultAnswer?: boolean): Promise<boolean>;
+}
+export {};

package/dist/core/modules/messages.js

@@ -0,0 +1,54 @@
+import readline from 'node:readline';
+import chalk from 'chalk';
+import { formatString } from '../../cli/utils/stringFormatter.js';
+export const MESSAGES = {
+    WARNINGS: {
+        IGNORED_FILES: {
+            message: '{0}\nThe following files will be ignored. Proceed?',
+            chalk: chalk.yellow,
+        },
+    },
+    SUCCESS: {
+        OUTPUT: {
+            message: 'Image created at {0}.',
+            chalk: chalk.blue,
+        },
+    },
+    ERROR: {
+        INTERNAL: {
+            message: 'An internal error has occurred.',
+            chalk: chalk.red,
+        },
+    },
+};
+export class MessageRenderer {
+    message;
+    #formattedMessage;
+    #message;
+    constructor(message, ...inputs) {
+        this.message = message;
+        this.#message = message;
+        const base = formatString(message.message, ...inputs);
+        this.#formattedMessage = message.chalk ? message.chalk(base) : base;
+    }
+    render() {
+        console.log(this.#formattedMessage);
+    }
+    confirm(defaultAnswer = true) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const options = defaultAnswer ? '(Y/n)' : '(y/N)';
+        const question = this.#message.chalk
+            ? `${this.#formattedMessage} ${this.#message.chalk(options)} `
+            : `${this.#formattedMessage} ${options} `;
+        return new Promise((resolve) => {
+            rl.question(question, (value) => {
+                const cleanedValue = value.toLowerCase().trim();
+                resolve((!cleanedValue.length && !!defaultAnswer) || cleanedValue === 'y');
+                rl.close();
+            });
+        });
+    }
+}

package/dist/core/pipeline/guards.d.ts

@@ -0,0 +1,4 @@
+import type { MergeContext } from './mergePipeline.js';
+export declare function requireState<TState, K extends keyof TState>(context: MergeContext<TState>, key: K): asserts context is MergeContext<TState & Required<Pick<TState, K>>>;
+export declare function requireContextProp<TState, K extends keyof MergeContext<TState>>(context: MergeContext<TState>, key: K): asserts context is MergeContext<TState> & Required<Pick<MergeContext<TState>, K>>;
+export declare function requireNonEmptyArray<T>(arr: readonly T[], name?: string): asserts arr is readonly [T, ...T[]];

package/dist/core/pipeline/guards.js

@@ -0,0 +1,23 @@
+import { MergeError } from '../mergeError.js';
+// |-------------------|
+// | Structural Guards |
+// |-------------------|
+export function requireState(context, key) {
+    if (context.state[key] === undefined) {
+        throw new MergeError(`State "${String(key)}" was not initialized`, { type: 'internal' });
+    }
+}
+export function requireContextProp(context, key) {
+    const value = context[key];
+    if (value === undefined) {
+        throw new MergeError(`Context "${String(key)}" was not initialized`, { type: 'internal' });
+    }
+}
+// |------------------|
+// | Invariant Guards |
+// |------------------|
+export function requireNonEmptyArray(arr, name = 'Array') {
+    if (arr.length === 0) {
+        throw new MergeError(`"${name}" must not be empty`, { type: 'internal' });
+    }
+}

package/dist/core/pipeline/mergePipeline.d.ts

@@ -0,0 +1,60 @@
+import sharp from 'sharp';
+import type z from 'zod';
+import type { OnProgress, ProgressInfo } from '../merges/types.js';
+export interface MergeContext<TState> {
+    inputs: sharp.SharpInput[];
+    progressInfo: ProgressInfo;
+    images: sharp.Sharp[];
+    canvas?: sharp.Sharp;
+    composites: sharp.OverlayOptions[];
+    captions: string[];
+    state: TState;
+}
+export type MergeStep<TOptions, TState> = (context: MergeContext<TState>, options: TOptions, onProgress?: OnProgress) => Promise<Buffer | void>;
+/**
+ * Pipeline orchestrator for running a sequence of merge steps that
+ * progressively build or modify a final merged image.
+ *
+ * Generic type parameters:
+ * - TOptions: the shape of the validated options object passed to each step.
+ * - TState: the shape of the pipeline's runtime state held in MergeContext.
+ *
+ * The pipeline:
+ * - Validates incoming options via a Zod schema (see createPipeline).
+ * - Maintains an ordered list of MergeStep functions to execute.
+ * - Provides optional progress reporting via an OnProgress callback.
+ *
+ * Usage:
+ * - Create an instance via createPipeline to ensure options are validated and
+ *   progressInfo is initialized on the supplied MergeContext.
+ * - Register steps with use(...).
+ * - Execute with run() — in normal usage this returns a Buffer containing the
+ *   final image. When run in "test" mode (testOptions supplied) the pipeline
+ *   may perform a dry-run and return void.
+ *
+ * Errors:
+ * - Validation-related errors thrown from createPipeline are surfaced as
+ *   MergeError instances with type 'validation' or 'internal'.
+ * - During execution, any thrown non-MergeError is converted into a runtime
+ *   Error indicating the offending step name.
+ *
+ * @template TOptions - Validated options shape used by registered steps.
+ * @template TState - Context/state shape managed by the pipeline.
+ */
+export declare class MergePipeline<TOptions, TState> {
+    private options;
+    private context;
+    private onProgress?;
+    private steps;
+    private optionsCounter;
+    private stateCounter;
+    constructor(options: TOptions, context: MergeContext<TState>, onProgress?: OnProgress | undefined);
+    static createPipeline<TZodSchema extends z.ZodType, TOptions, TState>(schema: TZodSchema, options: TOptions, context: Omit<MergeContext<TState>, 'progressInfo'>, onProgress?: OnProgress): Promise<MergePipeline<z.z.core.output<TZodSchema>, TState>>;
+    use(step: MergeStep<TOptions, TState>): this;
+    run(): Promise<Buffer>;
+    run(testOptions: {
+        logOptions?: boolean;
+        logContext?: boolean;
+    }): Promise<Buffer | void>;
+    private logForDebugging;
+}

package/dist/core/pipeline/mergePipeline.js

@@ -0,0 +1,122 @@
+import sharp from 'sharp';
+import { MergeError } from '../mergeError.js';
+import { MESSAGES } from '../modules/messages.js';
+import chalk from 'chalk';
+/**
+ * Pipeline orchestrator for running a sequence of merge steps that
+ * progressively build or modify a final merged image.
+ *
+ * Generic type parameters:
+ * - TOptions: the shape of the validated options object passed to each step.
+ * - TState: the shape of the pipeline's runtime state held in MergeContext.
+ *
+ * The pipeline:
+ * - Validates incoming options via a Zod schema (see createPipeline).
+ * - Maintains an ordered list of MergeStep functions to execute.
+ * - Provides optional progress reporting via an OnProgress callback.
+ *
+ * Usage:
+ * - Create an instance via createPipeline to ensure options are validated and
+ *   progressInfo is initialized on the supplied MergeContext.
+ * - Register steps with use(...).
+ * - Execute with run() — in normal usage this returns a Buffer containing the
+ *   final image. When run in "test" mode (testOptions supplied) the pipeline
+ *   may perform a dry-run and return void.
+ *
+ * Errors:
+ * - Validation-related errors thrown from createPipeline are surfaced as
+ *   MergeError instances with type 'validation' or 'internal'.
+ * - During execution, any thrown non-MergeError is converted into a runtime
+ *   Error indicating the offending step name.
+ *
+ * @template TOptions - Validated options shape used by registered steps.
+ * @template TState - Context/state shape managed by the pipeline.
+ */
+export class MergePipeline {
+    options;
+    context;
+    onProgress;
+    steps = [];
+    optionsCounter = 0;
+    stateCounter = 0;
+    constructor(options, context, onProgress) {
+        this.options = options;
+        this.context = context;
+        this.onProgress = onProgress;
+    }
+    static async createPipeline(schema, options, context, onProgress) {
+        const { success, data, error } = await schema.safeParseAsync(options);
+        if (success) {
+            // Initialize progressInfo
+            const progressInfo = {
+                completed: 0,
+                total: context.inputs.length,
+                phase: 'Initializing',
+            };
+            // Initialize mergeContext
+            const mergeContext = {
+                ...context,
+                progressInfo,
+            };
+            // Return the pipeline
+            return new MergePipeline(data, mergeContext, onProgress);
+        }
+        else {
+            const path = error.issues[0]?.path;
+            const err = error.issues[0]?.message;
+            if (!path || !err) {
+                throw new MergeError(MESSAGES.ERROR.INTERNAL.message, { type: 'internal', cause: error });
+            }
+            const errorText = path.length > 0 ? `Invalid value at ${path.join('/')}: ${err}` : `Error: ${err}`;
+            throw new MergeError(errorText, { type: 'validation' });
+        }
+    }
+    use(step) {
+        this.steps.push(step);
+        return this;
+    }
+    async run(testOptions) {
+        let finalImage;
+        if (testOptions)
+            this.logForDebugging(testOptions);
+        for (const step of this.steps) {
+            // Use a copy of this.options to ensure that merge steps cannot mutate the original
+            const result = await step(this.context, { ...this.options }, this.onProgress);
+            if (testOptions)
+                this.logForDebugging(testOptions);
+            // If the result is a sharp instance, update finalImage
+            if (result instanceof Buffer) {
+                finalImage = result;
+            }
+        }
+        // If finalImage has a value, return it
+        if (finalImage) {
+            return finalImage;
+        }
+        // During a dry run, void returns are allowed (for debugging)
+        if (testOptions) {
+            return;
+        }
+        // Normal runs must have a final sharp image produced.
+        throw new Error('No merge step produced a final Sharp image.');
+    }
+    logForDebugging(testOptions) {
+        if (testOptions.logOptions) {
+            // Log
+            console.log(chalk.bgBlueBright(` OPTIONS ${this.optionsCounter++}: `));
+            console.log(this.options);
+        }
+        // Whitespace
+        if (testOptions.logOptions && testOptions.logContext)
+            console.log();
+        if (testOptions.logContext) {
+            // Replace images and inputs with their lengths to make context readable
+            const { images, inputs, ...trimmedContext } = this.context;
+            const modifiedContext = { totalImages: images.length, totalInputs: inputs.length, ...trimmedContext };
+            // Log
+            console.log(chalk.bgGreen(` CONTEXT ${this.stateCounter++}: `));
+            console.log(modifiedContext);
+        }
+        console.log();
+    }
+}

package/dist/core/schemas/collage.d.ts

@@ -0,0 +1,26 @@
+import z from 'zod';
+export declare const collageSchema: z.ZodObject<{
+    shuffle: z.ZodDefault<z.ZodBoolean>;
+    cornerRadius: z.ZodDefault<z.ZodNumber>;
+    gap: z.ZodDefault<z.ZodNumber>;
+    canvasColor: z.ZodPrefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../utils/colors/types.js").RGBA, string>>, z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+        alpha: z.ZodNumber;
+    }, z.z.core.$strip>]>>;
+    borderWidth: z.ZodDefault<z.ZodNumber>;
+    borderColor: z.ZodPrefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../utils/colors/types.js").RGBA, string>>, z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+        alpha: z.ZodNumber;
+    }, z.z.core.$strip>]>>;
+    format: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"webp" | "gif" | "jpeg" | "jpg" | "png" | "tiff" | "avif", string>>>;
+    aspectRatio: z.ZodPrefault<z.ZodPipe<z.z.ZodCoercedString<unknown>, z.ZodTransform<number, string>>>;
+    imageWidth: z.ZodOptional<z.ZodNumber>;
+    columns: z.ZodDefault<z.ZodNumber>;
+    overlapPercentage: z.ZodDefault<z.ZodNumber>;
+    rotationRange: z.ZodDefault<z.ZodNumber>;
+    imageWidthVariance: z.ZodDefault<z.ZodNumber>;
+}, z.z.core.$strict>;

package/dist/core/schemas/collage.js

@@ -0,0 +1,17 @@
+import z from 'zod';
+import { VALIDATORS } from '../../validators/index.js';
+export const collageSchema = z.strictObject({
+    shuffle: VALIDATORS.shuffle.default(false),
+    cornerRadius: VALIDATORS.cornerRadius.default(0),
+    gap: VALIDATORS.gap.default(50),
+    canvasColor: VALIDATORS.canvasColor.prefault('#fff'),
+    borderWidth: VALIDATORS.imageWidthVariance.default(20),
+    borderColor: VALIDATORS.borderColor.prefault('#000'),
+    format: VALIDATORS.format.default('png'),
+    aspectRatio: VALIDATORS.aspectRatio.prefault('1:1'),
+    imageWidth: VALIDATORS.imageWidth.optional(),
+    columns: VALIDATORS.columns.default(4),
+    overlapPercentage: VALIDATORS.overlapPercentage.default(25),
+    rotationRange: VALIDATORS.rotationRange.default(7),
+    imageWidthVariance: VALIDATORS.imageWidthVariance.default(10),
+});

package/dist/core/schemas/grid.d.ts

@@ -0,0 +1,32 @@
+import z from 'zod';
+export declare const gridSchema: z.ZodObject<{
+    shuffle: z.ZodDefault<z.ZodBoolean>;
+    cornerRadius: z.ZodDefault<z.ZodNumber>;
+    gap: z.ZodDefault<z.ZodNumber>;
+    canvasColor: z.ZodPrefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../utils/colors/types.js").RGBA, string>>, z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+        alpha: z.ZodNumber;
+    }, z.z.core.$strip>]>>;
+    borderWidth: z.ZodDefault<z.ZodNumber>;
+    borderColor: z.ZodPrefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../utils/colors/types.js").RGBA, string>>, z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+        alpha: z.ZodNumber;
+    }, z.z.core.$strip>]>>;
+    format: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"webp" | "gif" | "jpeg" | "jpg" | "png" | "tiff" | "avif", string>>>;
+    aspectRatio: z.ZodPrefault<z.ZodPipe<z.z.ZodCoercedString<unknown>, z.ZodTransform<number, string>>>;
+    imageWidth: z.ZodOptional<z.ZodNumber>;
+    columns: z.ZodDefault<z.ZodNumber>;
+    caption: z.ZodDefault<z.ZodBoolean>;
+    captions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    captionColor: z.ZodPrefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../utils/colors/types.js").RGBA, string>>, z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+        alpha: z.ZodNumber;
+    }, z.z.core.$strip>]>>;
+    maxCaptionSize: z.ZodDefault<z.ZodNumber>;
+}, z.z.core.$strict>;

package/dist/core/schemas/grid.js

@@ -0,0 +1,29 @@
+import z from 'zod';
+import { VALIDATORS } from '../../validators/index.js';
+export const gridSchema = z
+    .strictObject({
+    shuffle: VALIDATORS.shuffle.default(false),
+    cornerRadius: VALIDATORS.cornerRadius.default(0),
+    gap: VALIDATORS.gap.default(50),
+    canvasColor: VALIDATORS.canvasColor.prefault('#fff'),
+    borderWidth: VALIDATORS.borderWidth.default(0),
+    borderColor: VALIDATORS.borderColor.prefault('#000'),
+    format: VALIDATORS.format.default('png'),
+    aspectRatio: VALIDATORS.aspectRatio.prefault('1:1'),
+    imageWidth: VALIDATORS.imageWidth.optional(),
+    columns: VALIDATORS.columns.default(4),
+    caption: VALIDATORS.caption.default(false),
+    captions: VALIDATORS.captions.nonempty().optional(),
+    captionColor: VALIDATORS.captionColor.prefault('#000'),
+    maxCaptionSize: VALIDATORS.maxCaptionSize.default(100),
+})
+    .superRefine((opts, ctx) => {
+    // Ensure captions are given if caption is set to true
+    if (opts.caption && (!opts.captions || opts.captions.length === 0)) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'Caption texts must be provided.',
+            path: ['captions'],
+        });
+    }
+});