pixeli 0.1.8 → 1.0.3

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

@@ -0,0 +1,56 @@
+import z from 'zod';
+export declare const masonrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    flow: z.ZodLiteral<"horizontal">;
+    rowHeight: z.ZodOptional<z.ZodNumber>;
+    canvasWidth: z.ZodNumber;
+    hAlign: z.ZodDefault<z.ZodEnum<{
+        left: "left";
+        center: "center";
+        right: "right";
+        justified: "justified";
+    }>>;
+    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>]>>;
+    format: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"webp" | "gif" | "jpeg" | "jpg" | "png" | "tiff" | "avif", string>>>;
+    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>]>>;
+}, z.z.core.$strip>, z.ZodObject<{
+    flow: z.ZodLiteral<"vertical">;
+    columnWidth: z.ZodOptional<z.ZodNumber>;
+    canvasHeight: z.ZodNumber;
+    vAlign: z.ZodDefault<z.ZodEnum<{
+        justified: "justified";
+        top: "top";
+        middle: "middle";
+        bottom: "bottom";
+    }>>;
+    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>]>>;
+    format: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"webp" | "gif" | "jpeg" | "jpg" | "png" | "tiff" | "avif", string>>>;
+    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>]>>;
+}, z.z.core.$strip>], "flow">;

package/dist/core/schemas/masonry.js

@@ -0,0 +1,43 @@
+import z from 'zod';
+import { VALIDATORS } from '../../validators/index.js';
+const baseMasonrySchema = z.object({
+    shuffle: VALIDATORS.shuffle.default(false),
+    cornerRadius: VALIDATORS.cornerRadius.default(0),
+    gap: VALIDATORS.gap.default(50),
+    canvasColor: VALIDATORS.canvasColor.prefault('#fff'),
+    format: VALIDATORS.format.default('png'),
+    borderWidth: VALIDATORS.borderWidth.default(0),
+    borderColor: VALIDATORS.borderColor.prefault('#000'),
+});
+const horizontalMasonrySchema = z.object({
+    ...baseMasonrySchema.shape,
+    flow: z.literal('horizontal'),
+    rowHeight: VALIDATORS.rowHeight.optional(),
+    canvasWidth: VALIDATORS.canvasWidth,
+    hAlign: VALIDATORS.hAlign.default('justified'),
+});
+const verticalMasonrySchema = z.object({
+    ...baseMasonrySchema.shape,
+    flow: z.literal('vertical'),
+    columnWidth: VALIDATORS.rowHeight.optional(),
+    canvasHeight: VALIDATORS.canvasHeight,
+    vAlign: VALIDATORS.vAlign.default('justified'),
+});
+export const masonrySchema = z
+    .discriminatedUnion('flow', [horizontalMasonrySchema, verticalMasonrySchema])
+    .superRefine((opts, ctx) => {
+    if (opts.flow === 'horizontal' && opts.canvasWidth <= opts.gap * 2) {
+        ctx.addIssue({
+            code: 'custom',
+            message: "Canvas is too small to place images in. Increase 'canvasWidth'.",
+            path: ['canvasWidth'],
+        });
+    }
+    if (opts.flow === 'vertical' && opts.canvasHeight <= opts.gap * 2) {
+        ctx.addIssue({
+            code: 'custom',
+            message: "Canvas is too small to place images in. Increase 'canvasHeight'.",
+            path: ['canvasHeight'],
+        });
+    }
+});

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

@@ -0,0 +1,34 @@
+import z from 'zod';
+export declare const templateSchema: 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>]>>;
+    format: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<"webp" | "gif" | "jpeg" | "jpg" | "png" | "tiff" | "avif", string>>>;
+    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>;
+    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>]>>;
+}, z.z.core.$strict>;

package/dist/core/schemas/template.js

@@ -0,0 +1,88 @@
+import z from 'zod';
+import { VALIDATORS } from '../../validators/index.js';
+export const templateSchema = z
+    .strictObject({
+    shuffle: VALIDATORS.shuffle.default(false),
+    cornerRadius: VALIDATORS.cornerRadius.default(0),
+    gap: VALIDATORS.gap.default(50),
+    canvasColor: VALIDATORS.canvasColor.prefault('#fff'),
+    format: VALIDATORS.format.default('png'),
+    template: VALIDATORS.template,
+    borderWidth: VALIDATORS.borderWidth.default(0),
+    borderColor: VALIDATORS.borderColor.prefault('#000'),
+})
+    .superRefine((opts, ctx) => {
+    // Ensure canvas is wide enough for at least a single 1px column
+    if (opts.template.canvas.width <= opts.gap * 2) {
+        ctx.addIssue({
+            code: 'custom',
+            message: `Canvas width must be greater than ${opts.gap * 2}.`,
+            path: ['template', 'canvas', 'width'],
+        });
+    }
+    // Ensure canvas is long enough for at least a single 1px row
+    if (opts.template.canvas.height <= opts.gap * 2) {
+        ctx.addIssue({
+            code: 'custom',
+            message: `Canvas height must be greater than ${opts.gap * 2}.`,
+            path: ['template', 'canvas', 'height'],
+        });
+    }
+    // Calculate column width and row height
+    const workableCanvasWidth = opts.template.canvas.width - opts.gap * (opts.template.canvas.columns + 1);
+    const workableCanvasHeight = opts.template.canvas.height - opts.gap * (opts.template.canvas.rows + 1);
+    const columnWidth = Math.floor(workableCanvasWidth / opts.template.canvas.columns);
+    const rowHeight = Math.floor(workableCanvasHeight / opts.template.canvas.rows);
+    // Ensure columns are thick enough
+    if (columnWidth <= 0) {
+        ctx.addIssue({
+            code: 'custom',
+            message: `Columns are too thin. Increase canvas width, reduce gap, or reduce number of columns.`,
+            path: ['template', 'canvas', 'columns'],
+        });
+    }
+    // Ensure rows are thick enough
+    if (rowHeight <= 0) {
+        ctx.addIssue({
+            code: 'custom',
+            message: `Rows are too thin. Increase canvas height or reduce number of rows.`,
+            path: ['template', 'canvas', 'rows'],
+        });
+    }
+    // For each slot...
+    for (let i = 0; i < opts.template.slots.length; i++) {
+        const slot = opts.template.slots[i];
+        // Ensure slot is placed inside given canvas columns
+        if (slot.col > opts.template.canvas.columns) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `"col" must be between 1 and ${opts.template.canvas.columns}.`,
+                path: ['template', 'slots', i, 'col'],
+            });
+        }
+        // Ensure slot is placed inside given canvas rows
+        if (slot.row > opts.template.canvas.rows) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `"row" must be between 1 and ${opts.template.canvas.rows}.`,
+                path: ['template', 'slots', i, 'row'],
+            });
+        }
+        // Ensure slot spans within given canvas columns
+        if (slot.col + slot.colSpan - 1 > opts.template.canvas.columns) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `slot spans past the right edge of the grid (col + colSpan exceeds columns).`,
+                path: ['template', 'slots', i],
+            });
+        }
+        // Ensure slot spans within given canvas rows
+        if (slot.row + slot.rowSpan - 1 > opts.template.canvas.rows) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `slot spans past the bottom edge of the grid (row + rowSpan exceeds rows).`,
+                path: ['template', 'slots', i],
+            });
+        }
+    }
+});

package/dist/core/utils/colors/hexToRgba.d.ts

@@ -0,0 +1,2 @@
+import type { RGBA } from './types.js';
+export declare const hexToRgba: (color: string) => RGBA;

package/dist/core/utils/colors/hexToRgba.js

@@ -0,0 +1,25 @@
+export const hexToRgba = (color) => {
+    // 3. Normalize hex → RGBA
+    let r, g, b, alpha;
+    const hexValue = color.slice(1);
+    // #rgb
+    if (hexValue.length === 3) {
+        r = parseInt(hexValue.charAt(0) + hexValue.charAt(0), 16);
+        g = parseInt(hexValue.charAt(1) + hexValue.charAt(1), 16);
+        b = parseInt(hexValue.charAt(2) + hexValue.charAt(2), 16);
+        alpha = 1;
+    } // #rrggbb
+    else if (hexValue.length === 6) {
+        r = parseInt(hexValue.slice(0, 2), 16);
+        g = parseInt(hexValue.slice(2, 4), 16);
+        b = parseInt(hexValue.slice(4, 6), 16);
+        alpha = 1;
+    } // #rrggbbaa
+    else {
+        r = parseInt(hexValue.slice(0, 2), 16);
+        g = parseInt(hexValue.slice(2, 4), 16);
+        b = parseInt(hexValue.slice(4, 6), 16);
+        alpha = Number((parseInt(hexValue.slice(6, 8), 16) / 255).toFixed(2));
+    }
+    return { r, g, b, alpha };
+};

package/dist/core/utils/colors/rgbaToHex.d.ts

@@ -0,0 +1,2 @@
+import type { RGBA } from './types.js';
+export declare const rgbaToHex: (rgba: RGBA) => string;

package/dist/core/utils/colors/rgbaToHex.js

@@ -0,0 +1,15 @@
+export const rgbaToHex = (rgba) => {
+    // Function to convert a number to a 2-digit hex string
+    const componentToHex = (c) => {
+        const hex = c.toString(16);
+        return hex.length === 1 ? '0' + hex : hex;
+    };
+    // Convert r, g, b (0-255)
+    const rHex = componentToHex(rgba.r);
+    const gHex = componentToHex(rgba.g);
+    const bHex = componentToHex(rgba.b);
+    // Convert alpha (0-1) to 0-255 range, then to 2-digit hex
+    const aVal = Math.round(rgba.alpha * 255);
+    const aHex = componentToHex(aVal);
+    return `#${rHex}${gHex}${bHex}${aHex}`;
+};

package/dist/core/utils/colors/types.d.ts

@@ -0,0 +1,7 @@
+export type RGBA = {
+    r: number;
+    g: number;
+    b: number;
+    alpha: number;
+};
+export type Color = string | RGBA;

package/dist/core/utils/colors/types.js

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

package/dist/core/utils/fonts/getFontSize.d.ts

@@ -0,0 +1,9 @@
+interface GetFontSizeOptions {
+    text: string;
+    maxWidth: number;
+    maxHeight: number;
+    initialFontSize?: number;
+    minFontSize?: number;
+}
+export declare const getFontSize: ({ text, maxWidth, maxHeight, initialFontSize, minFontSize }: GetFontSizeOptions) => Promise<number>;
+export {};

package/dist/core/utils/fonts/getFontSize.js

@@ -0,0 +1,40 @@
+import sharp from 'sharp';
+import { escapeXML } from '../../helpers.js';
+export const getFontSize = async ({ text, maxWidth, maxHeight, initialFontSize = 100, minFontSize = 2 }) => {
+    const FONT_FAMILY = 'sans-serif';
+    const THRESHOLD = 200;
+    const SMALL_CHANGE = 2;
+    const LARGE_CHANGE = 5;
+    let fontSize = initialFontSize;
+    while (fontSize >= minFontSize) {
+        // No width or viewport given so that the actual size can be determined after rasterization
+        const svg = `
+    <svg xmlns="http://www.w3.org/2000/svg">
+      <text
+        x="${maxWidth / 2}"
+        y="10"
+        font-size="${fontSize}"
+        font-family="${FONT_FAMILY}"
+        fill="#000000"
+        text-anchor="middle"
+        dominant-baseline="middle">
+        ${escapeXML(text)}
+      </text>
+    </svg>
+    `;
+        // Rasterize SVG: measure actual rendered size
+        const raster = await sharp(Buffer.from(svg)).png().toBuffer();
+        const meta = await sharp(raster).metadata();
+        if (meta.width <= maxWidth && meta.height <= maxHeight) {
+            return fontSize;
+        }
+        // If the difference is greater than the threshold, use large change
+        if (meta.width - maxWidth > THRESHOLD || meta.height - maxHeight > THRESHOLD) {
+            fontSize -= LARGE_CHANGE;
+        }
+        else {
+            fontSize -= SMALL_CHANGE;
+        }
+    }
+    return minFontSize;
+};

package/dist/core/utils/images/addImageBorder.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 addImageBorder: (image: sharp.Sharp, { borderWidth, borderHeight, borderColor, imageWidth, imageHeight, cornerRadius, finalizePipeline }: Options) => Promise<sharp.Sharp>;
+export {};

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

@@ -0,0 +1,33 @@
+import sharp from 'sharp';
+export const addImageBorder = async (image, { borderWidth, borderHeight, borderColor, imageWidth, imageHeight, cornerRadius = 0, finalizePipeline = false }) => {
+    // Only add borders to an image if needed
+    if (borderWidth <= 0)
+        return image;
+    // Create background to act as border
+    const background = sharp({
+        create: {
+            width: imageWidth,
+            height: imageHeight,
+            channels: 4,
+            background: borderColor,
+        },
+    }).toFormat('png');
+    // Crop image
+    const croppedImage = image.resize({
+        width: imageWidth - borderWidth * 2,
+        height: imageHeight - borderHeight * 2,
+    });
+    // Put cropped image on the background
+    background.composite([
+        {
+            input: await croppedImage.toBuffer(),
+            top: borderWidth,
+            left: borderHeight,
+        },
+    ]);
+    // Finalize image if needed
+    if (finalizePipeline) {
+        return sharp(await background.toBuffer());
+    }
+    return background;
+};

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

@@ -0,0 +1,2 @@
+import sharp from 'sharp';
+export declare const getImageHeights: (images: sharp.Sharp[]) => Promise<number[]>;

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

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

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

@@ -0,0 +1,2 @@
+import sharp from 'sharp';
+export declare const getImageWidths: (images: sharp.Sharp[]) => Promise<number[]>;

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 {};