pixeli 0.1.9 → 1.0.4

package/dist/cli/utils/buildCommandFromSchema.js

@@ -0,0 +1,55 @@
+import z from 'zod';
+import { Argument, Command, Option } from 'commander';
+const getDefault = (schema) => {
+    try {
+        return schema.parse(undefined);
+    }
+    catch {
+        return undefined;
+    }
+};
+export const buildCommandFromSchema = (name, description, schema, args, options) => {
+    // Initialize command
+    const command = new Command(name).description(description);
+    // Initialize the shape
+    let shape = {};
+    if (schema instanceof z.ZodUnion) {
+        for (const option of schema.options) {
+            if (option instanceof z.ZodObject) {
+                shape = { ...shape, ...option.shape };
+            }
+        }
+    }
+    else {
+        shape = schema.shape;
+    }
+    // Go through schema
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+        const argConfig = args?.[key];
+        const optionConfig = options?.[key];
+        let optionOrArgument;
+        if (optionConfig !== undefined) {
+            optionOrArgument = new Option(optionConfig.flags, optionConfig.description);
+        }
+        else if (argConfig !== undefined) {
+            optionOrArgument = new Argument(argConfig.flags, argConfig.description);
+        }
+        else
+            continue;
+        // 1. Try to get enum choices as a set of strings
+        const choices = fieldSchema?.options;
+        if (choices) {
+            optionOrArgument.choices(choices);
+        }
+        // 2. Try to get any default value set
+        const def = getDefault(fieldSchema);
+        if (def !== undefined) {
+            optionOrArgument.default(def);
+        }
+        // 3. Add option/argument to command
+        optionConfig !== undefined
+            ? command.addOption(optionOrArgument)
+            : command.addArgument(optionOrArgument);
+    }
+    return command;
+};

package/dist/cli/utils/configureCommandErrors.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare const configureCommandErrors: (cmd: Command) => void;

package/dist/cli/utils/configureCommandErrors.js

@@ -0,0 +1,22 @@
+import { MessageRenderer } from '../../core/modules/messages.js';
+import chalk from 'chalk';
+export const configureCommandErrors = (cmd) => {
+    // Configure error message for the current command
+    cmd.configureOutput({
+        writeErr: (str) => {
+            if (str.includes('error:')) {
+                const errorMessage = {
+                    message: str.trim().replace('error', 'Error'),
+                    chalk: chalk.red,
+                };
+                const error = new MessageRenderer(errorMessage);
+                return error.render();
+            }
+            process.stderr.write(str);
+        },
+    });
+    // Recursively configure error messages for all subcommands
+    for (const subCmd of cmd.commands) {
+        configureCommandErrors(subCmd);
+    }
+};

package/dist/cli/utils/stringFormatter.d.ts

@@ -0,0 +1 @@
+export declare const formatString: (str: string, ...args: (string | number)[]) => string;

package/dist/cli/utils/stringFormatter.js

@@ -0,0 +1,3 @@
+export const formatString = (str, ...args) => {
+    return str.replace(/{(\d+)}/g, (m, i) => (args[Number(i)] !== undefined ? String(args[Number(i)]) : m));
+};

package/dist/cli/utils/toErrorMessage.d.ts

@@ -0,0 +1,4 @@
+export declare const toErrorMessage: (err: unknown) => {
+    message: string;
+    chalk: import("chalk").ChalkInstance;
+};

package/dist/cli/utils/toErrorMessage.js

@@ -0,0 +1,22 @@
+import z from 'zod';
+import chalk from 'chalk';
+import { MESSAGES } from '../../core/modules/messages.js';
+import { MergeError } from '../../core/mergeError.js';
+export const toErrorMessage = (err) => {
+    let errorMessage = MESSAGES.ERROR.INTERNAL;
+    // Schema errors
+    if (err instanceof z.ZodError) {
+        errorMessage = {
+            message: z.prettifyError(err),
+            chalk: chalk.red,
+        };
+    }
+    // Merge errors
+    if (err instanceof MergeError) {
+        errorMessage = {
+            message: err.message,
+            chalk: chalk.red,
+        };
+    }
+    return errorMessage;
+};

package/dist/core/helpers.d.ts

@@ -0,0 +1,10 @@
+export declare const SUPPORTED_INPUT_FORMATS: readonly ["webp", "gif", "jpeg", "jpg", "png", "tiff", "avif", "svg"];
+export type SupportedInputFormat = (typeof SUPPORTED_INPUT_FORMATS)[number];
+export declare const SUPPORTED_OUTPUT_FORMATS: readonly ["webp", "gif", "jpeg", "jpg", "png", "tiff", "avif"];
+export type SupportedOutputFormat = (typeof SUPPORTED_OUTPUT_FORMATS)[number];
+export declare const escapeXML: (str: string) => string;
+export declare const shuffleTogether: <T, U>(a: T[], b: U[]) => [T[], U[]];
+export declare const shuffleArray: <T>(array: T[]) => T[];
+export declare const isSupportedInputImage: (extname: string) => extname is SupportedInputFormat;
+export declare const isSupportedOutputImage: (extname: string) => extname is SupportedOutputFormat;
+export declare const isValidHexColor: (hex: string) => boolean;

package/dist/core/helpers.js

@@ -0,0 +1,42 @@
+export const SUPPORTED_INPUT_FORMATS = ['webp', 'gif', 'jpeg', 'jpg', 'png', 'tiff', 'avif', 'svg'];
+export const SUPPORTED_OUTPUT_FORMATS = ['webp', 'gif', 'jpeg', 'jpg', 'png', 'tiff', 'avif'];
+export const escapeXML = (str) => {
+    return str.replace(/[<>&'"]/g, (c) => ({
+        '<': '&lt;',
+        '>': '&gt;',
+        '&': '&amp;',
+        '"': '&quot;',
+        "'": '&apos;',
+    }[c]));
+};
+export const shuffleTogether = (a, b) => {
+    if (a.length !== b.length) {
+        throw new Error('Arrays must have the same length');
+    }
+    const indices = [...a.keys()];
+    shuffleArray(indices);
+    return [indices.map((i) => a[i]), indices.map((i) => b[i])];
+};
+export const shuffleArray = (array) => {
+    let currentIndex = array.length;
+    let randomIndex;
+    // While there remain elements to shuffle.
+    while (currentIndex !== 0) {
+        // Pick a remaining element.
+        randomIndex = Math.floor(Math.random() * currentIndex);
+        currentIndex--;
+        // And swap it with the current element.
+        [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
+    }
+    return array;
+};
+export const isSupportedInputImage = (extname) => {
+    return SUPPORTED_INPUT_FORMATS.includes(extname);
+};
+export const isSupportedOutputImage = (extname) => {
+    return SUPPORTED_OUTPUT_FORMATS.includes(extname);
+};
+export const isValidHexColor = (hex) => {
+    const hexRegex = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+    return hexRegex.test(hex);
+};

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from './merges/index.js';
+export { BatchRunner } from './jobs/batchRunner.js';

package/dist/core/index.js

@@ -0,0 +1,2 @@
+export * from './merges/index.js';
+export { BatchRunner } from './jobs/batchRunner.js';

package/dist/core/jobs/batchRunner.d.ts

@@ -0,0 +1,44 @@
+import { MergeError } from '../mergeError.js';
+import { TypedEventEmitter } from '../modules/typedEventEmitter.js';
+import type { BatchOptions, MergeJob } from './types.js';
+type MergeResult = {
+    index: number;
+    success: true;
+    buffer: Buffer;
+} | {
+    index: number;
+    success: false;
+    error: MergeError;
+};
+export interface BatchEvents {
+    start: {
+        totalJobs: number;
+    };
+    'job:start': {
+        job: MergeJob;
+        index: number;
+    };
+    'job:complete': {
+        job: MergeJob;
+        index: number;
+        buffer: Buffer;
+    };
+    'job:error': {
+        job: MergeJob;
+        index: number;
+        error: MergeError;
+    };
+    complete: {
+        results: MergeResult[];
+    };
+}
+export declare class BatchRunner extends TypedEventEmitter<BatchEvents> {
+    private jobs;
+    private results;
+    private validatedJobs;
+    constructor(jobs: MergeJob[]);
+    run(options?: BatchOptions): Promise<MergeResult[]>;
+    private runJob;
+    private validateJob;
+}
+export {};

package/dist/core/jobs/batchRunner.js

@@ -0,0 +1,90 @@
+// Merges
+import * as mergeFunctions from '../merges/index.js';
+// Errors
+import { MergeError } from '../mergeError.js';
+import { MESSAGES } from '../modules/messages.js';
+// Other
+import { TypedEventEmitter } from '../modules/typedEventEmitter.js';
+import { mergeJobSchema } from '../schemas/mergeJob.js';
+export class BatchRunner extends TypedEventEmitter {
+    jobs;
+    results = [];
+    validatedJobs = [];
+    constructor(jobs) {
+        super();
+        this.jobs = jobs;
+        // Ensure all jobs are valid
+        for (const job of jobs) {
+            const validatedJob = this.validateJob(job);
+            this.validatedJobs.push(validatedJob);
+        }
+    }
+    async run(options = {}) {
+        const { stopOnError = false } = options;
+        // Run jobs
+        for (let i = 0; i < this.validatedJobs.length; i++) {
+            const job = this.validatedJobs[i];
+            try {
+                // Emit job start event
+                this.emit('job:start', {
+                    index: i,
+                    job: this.jobs[i],
+                });
+                // Run job
+                const buffer = await this.runJob(job);
+                // Emit job completion event
+                this.emit('job:complete', {
+                    index: i,
+                    job: this.jobs[i],
+                    buffer,
+                });
+                this.results.push({ index: i, success: true, buffer: buffer });
+            }
+            catch (error) {
+                // Emit job error event
+                this.emit('job:error', {
+                    index: i,
+                    job: this.jobs[i],
+                    error: error,
+                });
+                // Throw error if needed
+                if (stopOnError)
+                    throw error;
+                // Store error for later
+                this.results.push({ index: i, success: false, error: error });
+            }
+        }
+        // Emit batch job completion event
+        this.emit('complete', {
+            results: this.results,
+        });
+        return this.results;
+    }
+    async runJob(job) {
+        // Run job and return resulting buffer
+        switch (job.type) {
+            case 'grid':
+                return mergeFunctions.gridMerge(job.inputs, job.options);
+            case 'masonry':
+                return mergeFunctions.masonryMerge(job.inputs, job.options);
+            case 'collage':
+                return mergeFunctions.collageMerge(job.inputs, job.options);
+            case 'template':
+                return mergeFunctions.templateMerge(job.inputs, job.options);
+        }
+    }
+    validateJob(job) {
+        // Validate job format
+        const { success, data, error } = mergeJobSchema.safeParse(job);
+        if (!success) {
+            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' });
+        }
+        return data;
+    }
+}

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

@@ -0,0 +1,10 @@
+import type sharp from 'sharp';
+import type { MergeTypeOptions } from '../merges/types.js';
+export type MergeJob = {
+    /** File paths to all of the images to load. */
+    inputs: sharp.SharpInput[];
+} & MergeTypeOptions;
+export interface BatchOptions {
+    /** Throws a `MergeError` instantly and stops the process if true. */
+    stopOnError?: boolean;
+}

package/dist/core/jobs/types.js

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

package/dist/core/mergeError.d.ts

@@ -0,0 +1,9 @@
+interface Context {
+    type: 'validation' | 'image' | 'internal';
+    cause?: any;
+}
+export declare class MergeError extends Error {
+    readonly context: Context;
+    constructor(message: string, context: Context);
+}
+export {};

package/dist/core/mergeError.js

@@ -0,0 +1,10 @@
+export class MergeError extends Error {
+    context;
+    constructor(message, context) {
+        super(message);
+        this.name = 'MergeError';
+        this.context = context;
+        // Fix prototype chain
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}

package/dist/core/merges/collage/index.d.ts

@@ -0,0 +1,9 @@
+import type { CollageMerge } from '../types.js';
+export interface CollageState {
+    imageWidth: number;
+    imageHeight: number;
+    canvasWidth: number;
+    canvasHeight: number;
+    rows: number;
+}
+export declare const collageMerge: CollageMerge;

package/dist/core/merges/collage/index.js

@@ -0,0 +1,32 @@
+import { collageSchema } from '../../schemas/collage.js';
+import { MergePipeline } from '../../pipeline/mergePipeline.js';
+import { loadImages } from '../shared-steps/loadImages.js';
+import { applyComposites } from '../shared-steps/applyComposites.js';
+import { createCanvas } from '../shared-steps/createCanvas.js';
+import { exportCanvas } from '../shared-steps/exportCanvas.js';
+import { finalizeImagePipelines } from '../shared-steps/finalizeImagePipelines.js';
+import { calculateImageDimensions } from './steps/calculateImageDimensions.js';
+import { resizeAndBorderImages } from './steps/resizeAndBorderImages.js';
+import { rotateImages } from './steps/rotateImages.js';
+import { createComposites } from './steps/createComposites.js';
+export const collageMerge = async (imageInputs, options, onProgress) => {
+    const context = {
+        inputs: imageInputs,
+        captions: [],
+        composites: [],
+        images: [],
+        state: {},
+    };
+    const collageMergePipeline = await MergePipeline.createPipeline(collageSchema, options, context, onProgress);
+    collageMergePipeline
+        .use(loadImages)
+        .use(calculateImageDimensions)
+        .use(resizeAndBorderImages)
+        .use(rotateImages)
+        .use(finalizeImagePipelines)
+        .use(createComposites)
+        .use(createCanvas)
+        .use(applyComposites)
+        .use(exportCanvas);
+    return await collageMergePipeline.run();
+};

package/dist/core/merges/collage/steps/calculateImageDimensions.d.ts

@@ -0,0 +1,12 @@
+import type { MergeStep } from '../../../pipeline/mergePipeline.js';
+import type { CollageState } from '../index.js';
+interface Options {
+    imageWidth?: number | undefined;
+    aspectRatio: number;
+    imageWidthVariance: number;
+    gap: number;
+    columns: number;
+    overlapPercentage: number;
+}
+export declare const calculateImageDimensions: MergeStep<Options, CollageState>;
+export {};

package/dist/core/merges/collage/steps/calculateImageDimensions.js

@@ -0,0 +1,18 @@
+import { requireNonEmptyArray } from '../../../pipeline/guards.js';
+import { MESSAGES } from '../../../modules/messages.js';
+import { MergeError } from '../../../mergeError.js';
+import { getImageWidths } from '../../../utils/images/getImageWidths.js';
+import { trimmedMedian } from '../../../utils/math/trimmedMedian.js';
+export const calculateImageDimensions = async (context, options, _onProgress) => {
+    requireNonEmptyArray(context.images, 'images');
+    // Calculate image width
+    const width = options.imageWidth || trimmedMedian(await getImageWidths(context.images));
+    if (width === null) {
+        throw new MergeError(MESSAGES.ERROR.INTERNAL.message, { type: 'internal', cause: 'trimmedMedian failed' });
+    }
+    const height = Math.floor(width / options.aspectRatio);
+    const rows = Math.ceil(context.images.length / options.columns);
+    context.state.imageWidth = width;
+    context.state.imageHeight = height;
+    context.state.rows = rows;
+};

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

@@ -0,0 +1,8 @@
+import type { MergeStep } from '../../../pipeline/mergePipeline.js';
+import type { CollageState } from '../index.js';
+interface Options {
+    overlapPercentage: number;
+    columns: number;
+}
+export declare const createComposites: MergeStep<Options, CollageState>;
+export {};

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

@@ -0,0 +1,58 @@
+import { requireNonEmptyArray, requireState } from '../../../pipeline/guards.js';
+import { shuffleArray } from '../../../helpers.js';
+export const createComposites = async (context, options, onProgress) => {
+    requireState(context, 'rows');
+    requireNonEmptyArray(context.images, 'images');
+    // Used to track canvas bounds
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (let i = 0; i < context.state.rows; i++) {
+        for (let j = 0; j < options.columns; j++) {
+            const index = i * options.columns + j;
+            if (index >= context.images.length) {
+                break;
+            }
+            const image = context.images[index];
+            const meta = await image.metadata();
+            // Calculate overlap
+            const widthOverlap = context.state.imageWidth * (options.overlapPercentage / 100);
+            const heightOverlap = context.state.imageHeight * (options.overlapPercentage / 100);
+            // Calculate image center
+            const cx = context.state.imageWidth * i - widthOverlap * i + context.state.imageWidth / 2;
+            const cy = context.state.imageHeight * j - heightOverlap * j + context.state.imageHeight / 2;
+            // Re-center rotated bitmap on original image center
+            const top = Math.round(cx - meta.width / 2);
+            const left = Math.round(cy - meta.height / 2);
+            // Add to composites
+            context.composites.push({
+                input: await image.toBuffer(),
+                left,
+                top,
+            });
+            // Update bounds
+            minX = Math.min(minX, left);
+            minY = Math.min(minY, top);
+            maxX = Math.max(maxX, left + meta.width);
+            maxY = Math.max(maxY, top + meta.height);
+            if (onProgress) {
+                context.progressInfo.completed += 1;
+                context.progressInfo.phase = 'Merging images';
+                onProgress({ ...context.progressInfo });
+            }
+        }
+    }
+    // Offset all coords to avoid negatives
+    const offsetX = -minX;
+    const offsetY = -minY;
+    for (const c of context.composites) {
+        c.left += offsetX;
+        c.top += offsetY;
+    }
+    // Update composites
+    context.composites = shuffleArray(context.composites);
+    // Update canvas width and height
+    context.state.canvasWidth = Math.ceil(maxX - minX);
+    context.state.canvasHeight = Math.ceil(maxY - minY);
+};

package/dist/core/merges/collage/steps/resizeAndBorderImages.d.ts

@@ -0,0 +1,12 @@
+import type { MergeStep } from '../../../pipeline/mergePipeline.js';
+import type { CollageState } from '../index.js';
+import type { RGBA } from '../../../utils/colors/types.js';
+interface Options {
+    imageWidthVariance: number;
+    aspectRatio: number;
+    borderWidth: number;
+    cornerRadius: number;
+    borderColor: RGBA;
+}
+export declare const resizeAndBorderImages: MergeStep<Options, CollageState>;
+export {};

package/dist/core/merges/collage/steps/resizeAndBorderImages.js

@@ -0,0 +1,26 @@
+import { requireNonEmptyArray, requireState } from '../../../pipeline/guards.js';
+import { randint } from '../../../utils/math/randint.js';
+import { scaleImage } from '../../../utils/images/scaleImage.js';
+import { handleImageEdges } from '../../../utils/images/handleImageEdges.js';
+export const resizeAndBorderImages = async (context, options, _onProgress) => {
+    requireState(context, 'imageWidth');
+    requireState(context, 'imageHeight');
+    requireNonEmptyArray(context.images, 'images');
+    for (let i = 0; i < context.images.length; i++) {
+        const varianceWidth = randint(-options.imageWidthVariance, options.imageWidthVariance);
+        const width = context.state.imageWidth + varianceWidth;
+        const varianceHeight = Math.floor(varianceWidth / options.aspectRatio);
+        const height = context.state.imageHeight + varianceHeight;
+        const resizedImage = await scaleImage(context.images[i], { width, height });
+        const borderedImage = await handleImageEdges(resizedImage, {
+            imageWidth: width,
+            imageHeight: height,
+            borderWidth: options.borderWidth,
+            borderHeight: options.borderWidth,
+            borderColor: options.borderColor,
+            cornerRadius: options.cornerRadius,
+            finalizePipeline: true,
+        });
+        context.images[i] = borderedImage;
+    }
+};

package/dist/core/merges/collage/steps/rotateImages.d.ts

@@ -0,0 +1,7 @@
+import type { MergeStep } from '../../../pipeline/mergePipeline.js';
+import type { CollageState } from '../index.js';
+interface Options {
+    rotationRange: number;
+}
+export declare const rotateImages: MergeStep<Options, CollageState>;
+export {};

package/dist/core/merges/collage/steps/rotateImages.js

@@ -0,0 +1,9 @@
+import { requireNonEmptyArray } from '../../../pipeline/guards.js';
+import { randint } from '../../../utils/math/randint.js';
+export const rotateImages = async (context, options, _onProgress) => {
+    requireNonEmptyArray(context.images, 'images');
+    for (let i = 0; i < context.images.length; i++) {
+        const angle = randint(-options.rotationRange, options.rotationRange);
+        context.images[i] = context.images[i].toFormat('png').rotate(angle, { background: { r: 0, g: 0, b: 0, alpha: 0 } });
+    }
+};

package/dist/core/merges/grid/index.d.ts

@@ -0,0 +1,12 @@
+import type { GridMerge } from '../types.js';
+export interface GridState {
+    areCaptionsProvided: boolean;
+    imageWidth: number;
+    imageHeight: number;
+    canvasWidth: number;
+    canvasHeight: number;
+    captionHeight: number;
+    fontSize: number;
+    rows: number;
+}
+export declare const gridMerge: GridMerge;

package/dist/core/merges/grid/index.js

@@ -0,0 +1,36 @@
+import { gridSchema } from '../../schemas/grid.js';
+import { MergePipeline } from '../../pipeline/mergePipeline.js';
+import { loadImages } from '../shared-steps/loadImages.js';
+import { validateCaptions } from '../shared-steps/validateCaptions.js';
+import { applyComposites } from '../shared-steps/applyComposites.js';
+import { createCanvas } from '../shared-steps/createCanvas.js';
+import { exportCanvas } from '../shared-steps/exportCanvas.js';
+import { shuffleImagesAndCaptions } from './steps/shuffleImagesAndCaptions.js';
+import { calculateImageDimensions } from './steps/calculateImageDimensions.js';
+import { prepareImages } from './steps/prepareImages.js';
+import { calculateCanvasDimensions } from './steps/calculateCanvasDimensions.js';
+import { calculateFontSize } from './steps/calculateFontSize.js';
+import { createComposites } from './steps/createComposites.js';
+export const gridMerge = async (imageInputs, options, onProgress) => {
+    const context = {
+        inputs: imageInputs,
+        captions: [],
+        composites: [],
+        images: [],
+        state: {},
+    };
+    const gridMergePipeline = await MergePipeline.createPipeline(gridSchema, options, context, onProgress);
+    gridMergePipeline
+        .use(loadImages)
+        .use(validateCaptions)
+        .use(shuffleImagesAndCaptions)
+        .use(calculateImageDimensions)
+        .use(prepareImages)
+        .use(calculateCanvasDimensions)
+        .use(calculateFontSize)
+        .use(createCanvas)
+        .use(createComposites)
+        .use(applyComposites)
+        .use(exportCanvas);
+    return await gridMergePipeline.run();
+};

package/dist/core/merges/grid/steps/calculateCanvasDimensions.d.ts

@@ -0,0 +1,8 @@
+import type { MergeStep } from '../../../pipeline/mergePipeline.js';
+import type { GridState } from '../index.js';
+interface Options {
+    columns: number;
+    gap: number;
+}
+export declare const calculateCanvasDimensions: MergeStep<Options, GridState>;
+export {};

package/dist/core/merges/grid/steps/calculateCanvasDimensions.js

@@ -0,0 +1,18 @@
+import { requireNonEmptyArray, requireState } from '../../../pipeline/guards.js';
+export const calculateCanvasDimensions = async (context, options, _onProgress) => {
+    requireState(context, 'imageWidth');
+    requireState(context, 'imageHeight');
+    requireState(context, 'areCaptionsProvided');
+    requireNonEmptyArray(context.images, 'images');
+    const CAPTION_HEIGHT_TO_CANVAS_WIDTH_RATIO = 0.04;
+    const rows = Math.ceil(context.images.length / options.columns);
+    const canvasWidth = context.state.imageWidth * options.columns + (options.columns + 1) * options.gap;
+    const captionHeight = Math.floor(canvasWidth * CAPTION_HEIGHT_TO_CANVAS_WIDTH_RATIO);
+    const minimumCanvasHeight = context.state.imageHeight * rows + (rows + 1) * options.gap;
+    const canvasHeight = context.state.areCaptionsProvided ? minimumCanvasHeight + rows * captionHeight : minimumCanvasHeight;
+    // Assign values to state
+    context.state.rows = rows;
+    context.state.canvasWidth = canvasWidth;
+    context.state.canvasHeight = canvasHeight;
+    context.state.captionHeight = captionHeight;
+};

package/dist/core/merges/grid/steps/calculateFontSize.d.ts

@@ -0,0 +1,7 @@
+import type { MergeStep } from '../../../pipeline/mergePipeline.js';
+import type { GridState } from '../index.js';
+interface Options {
+    maxCaptionSize: number;
+}
+export declare const calculateFontSize: MergeStep<Options, GridState>;
+export {};