pixeli 0.1.8 → 1.0.3

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,
+};

package/dist/validators/outputFile.d.ts

@@ -0,0 +1,2 @@
+import z from 'zod';
+export declare const outputFileValidator: z.ZodString;

package/dist/validators/outputFile.js

@@ -0,0 +1,7 @@
+import path from 'node:path';
+import z from 'zod';
+import { SUPPORTED_OUTPUT_FORMATS } from '../core/helpers.js';
+export const outputFileValidator = z.string().refine((outputPath) => {
+    const extension = path.extname(outputPath).replace('.', '');
+    return SUPPORTED_OUTPUT_FORMATS.includes(extension);
+}, '--output image format is invalid');

package/dist/validators/path.d.ts

@@ -0,0 +1,3 @@
+import z from 'zod';
+export declare const filePathValidator: z.ZodString;
+export declare const dirPathValidator: z.ZodString;

package/dist/validators/path.js

@@ -0,0 +1,18 @@
+import { stat } from 'node:fs/promises';
+import z from 'zod';
+export const filePathValidator = z.string().refine(async (path) => {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}, { error: 'File path does not exist or is invalid.' });
+export const dirPathValidator = z.string().refine(async (path) => {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}, { error: 'Directory path does not exist or is invalid.', abort: true });

package/dist/validators/sharpImageInput.d.ts

@@ -0,0 +1,3 @@
+import z from 'zod';
+export declare const sharpImageValidation: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>;
+export type SharpImageInput = z.infer<typeof sharpImageValidation>;

package/dist/validators/sharpImageInput.js

@@ -0,0 +1,6 @@
+import z from 'zod';
+export const sharpImageValidation = z.union([
+    z.string(),
+    z.instanceof(Buffer), // technically redundant, but verbose
+    z.instanceof(Uint8Array),
+]);

package/dist/validators/template.d.ts

@@ -0,0 +1,15 @@
+import z from 'zod';
+export declare const templateValidator: 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>;

package/dist/validators/template.js

@@ -0,0 +1,41 @@
+import z from 'zod';
+export const templateValidator = z
+    .object({
+    canvas: z.object({
+        width: z.number().int().positive(),
+        height: z.number().int().positive(),
+        columns: z.number().int().positive(),
+        rows: z.number().int().positive(),
+    }),
+    slots: z.array(z.object({
+        col: z.number().int().positive(),
+        row: z.number().int().positive(),
+        colSpan: z.number().int().positive(),
+        rowSpan: z.number().int().positive(),
+    })),
+})
+    .superRefine((opts, ctx) => {
+    // Ensure slots do not overlap
+    const result = validateSlotOverlaps(opts.slots);
+    if (!result.success) {
+        const [i, j] = result.overlaps;
+        ctx.addIssue({ code: 'custom', message: `slot ${i} overlaps with slot ${j}` });
+    }
+});
+const validateSlotOverlaps = (slots) => {
+    for (let i = 0; i < slots.length; i++) {
+        const A = slots[i];
+        const A_right = A.col + A.colSpan - 1;
+        const A_bottom = A.row + A.rowSpan - 1;
+        for (let j = i + 1; j < slots.length; j++) {
+            const B = slots[j];
+            const B_right = B.col + B.colSpan - 1;
+            const B_bottom = B.row + B.rowSpan - 1;
+            const overlap = A.col <= B_right && A_right >= B.col && A.row <= B_bottom && A_bottom >= B.row;
+            if (overlap) {
+                return { success: false, overlaps: [i, j] };
+            }
+        }
+    }
+    return { success: true };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pixeli",
-  "version": "0.1.8",
+  "version": "1.0.3",
   "description": "A lightweight command-line tool for merging multiple images into customizable grid layouts.",
   "homepage": "https://github.com/pakdad-mousavi/pixeli#readme",
   "bugs": {
@@ -11,16 +11,21 @@
     "url": "git+https://github.com/pakdad-mousavi/pixeli.git"
   },
   "bin": {
-    "pixeli": "bin/pixeli.js"
+    "pixeli": "./dist/cli/index.js"
   },
   "license": "MIT",
   "author": "Pakdad Mousavi",
   "type": "module",
-  "main": "index.js",
+  "main": "./dist/core/index.js",
+  "types": "./dist/core/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/core/index.js",
+      "types": "./dist/core/index.d.ts"
+    }
+  },
   "files": [
-    "/lib",
-    "/bin",
-    "/commands"
+    "dist"
   ],
   "keywords": [
     "cli",
@@ -30,14 +35,26 @@
     "image-merge"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "dev": "tsc --watch",
+    "build": "tsc",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "ajv": "^8.17.1",
     "chalk": "^5.6.2",
     "cli-progress": "^3.12.0",
     "commander": "^14.0.2",
     "sharp": "^0.34.5",
-    "table": "^6.9.0"
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@types/cli-progress": "^3.11.6",
+    "@types/node": "^25.0.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "prettier": "^3.8.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
   }
 }

package/bin/pixeli.js

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import mergeCommand from '../commands/merge/index.js';
-import { configureCommandErrors, handleError } from '../lib/helpers/utils.js';
-
-const program = new Command();
-
-// Define program
-program
-  .name('pixeli')
-  .description('A lightweight command-line tool for merging multiple images into customizable grid layouts.')
-  .version('1.0.0');
-
-// Add subcommands
-program.addCommand(mergeCommand);
-
-// Configure errors for all subcommands
-configureCommandErrors(program);
-
-// Parse arguments
-try {
-  program.parse();
-} catch (e) {
-  handleError(e);
-}