pixeli 1.0.4 → 1.0.6-beta.3

package/dist/cli/commands/project/backend/index.js

@@ -0,0 +1,28 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Hono } from 'hono';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { serve } from '@hono/node-server';
+import * as routers from './routers/index.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const app = new Hono();
+export const serveApp = (projectDir, cb = null, port = null) => {
+    // Serve frontend build
+    app.use('/*', serveStatic({ root: path.join(__dirname, 'dist') }));
+    // Routes
+    const routes = app
+        .basePath('/api')
+        .route('/fs', routers.createFsRouter(projectDir))
+        .route('/merge', routers.createMergeRouter(projectDir));
+    app.get('*', serveStatic({ path: path.join(__dirname, 'dist/index.html') }));
+    // For specific ports (not required during build)
+    if (port) {
+        serve({
+            fetch: app.fetch,
+            port,
+        }, (info) => (cb ? cb(info) : console.log(`Project running at: http://localhost:${info.port}`)));
+        return routes;
+    }
+    serve(app, (info) => (cb ? cb(info) : console.log(`Project running at: http://localhost:${port}`)));
+    return routes;
+};

package/dist/cli/commands/project/backend/routers/fs.d.ts

@@ -0,0 +1,61 @@
+export declare const createFsRouter: (projectDir: string) => import("hono/hono-base").HonoBase<import("hono/types").BlankEnv, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    recursive: "true" | "false";
+                };
+            };
+            output: {
+                error: string;
+                at: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                query: {
+                    recursive: "true" | "false";
+                };
+            };
+            output: {
+                images: {
+                    size: number;
+                    path: string;
+                    width: number;
+                    height: number;
+                }[];
+                ignoredPaths: string[];
+            };
+            outputFormat: "json";
+            status: 200;
+        };
+    };
+} & {
+    "/preview": {
+        $get: {
+            input: {
+                query: {
+                    path: string | string[];
+                    size?: string | string[];
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        } | {
+            input: {
+                query: {
+                    path: string | string[];
+                    size?: string | string[];
+                };
+            };
+            output: {
+                error: string;
+                at: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+}, "/", "/preview">;

package/dist/cli/commands/project/backend/routers/fs.js

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import sharp from 'sharp';
+import { Hono } from 'hono';
+import { loadImages } from '../../../../modules/loadImages.js';
+import { zValidator } from '@hono/zod-validator';
+import { fsGetQuerySchema, fsPreviewGetQuerySchema } from '../validators/fs.js';
+export const createFsRouter = (projectDir) => {
+    const fsRouter = new Hono()
+        // Chaining methods for type inference
+        .get('/', zValidator('query', fsGetQuerySchema, (result, c) => {
+        if (!result.success) {
+            const currentIssue = result.error.issues[0];
+            return c.json({ error: currentIssue.message, at: currentIssue.path.join('.') }, 400);
+        }
+    }), async (c) => {
+        const params = c.req.valid('query');
+        const { images: buffers, imagePaths, ignoredPaths, } = await loadImages({
+            input: { dir: projectDir, files: undefined },
+            recursive: params.recursive === 'true',
+        });
+        const images = buffers.map(async (buff, index) => {
+            const { width, height } = await sharp(buff, { limitInputPixels: false }).metadata();
+            const relativePath = path.relative(projectDir, imagePaths[index]);
+            return { size: buff.length, path: relativePath, width, height };
+        });
+        return c.json({ images: await Promise.all(images), ignoredPaths }, 200);
+    })
+        .get('/preview', zValidator('query', fsPreviewGetQuerySchema, (result, c) => {
+        if (!result.success) {
+            const currentIssue = result.error.issues[0];
+            return c.json({ error: currentIssue.message, at: currentIssue.path.join('.') }, 400);
+        }
+    }), async (c) => {
+        const { path: filePath, size } = c.req.valid('query');
+        const absolutePath = path.resolve(projectDir, filePath);
+        const buffer = await sharp(absolutePath, { limitInputPixels: false }).resize(size).toBuffer();
+        return new Response(buffer, { headers: { 'Content-Type': 'image/jpeg' } });
+    });
+    return fsRouter;
+};

package/dist/cli/commands/project/backend/routers/index.d.ts

@@ -0,0 +1,2 @@
+export { createFsRouter } from './fs.js';
+export { createMergeRouter } from './merge.js';

package/dist/cli/commands/project/backend/routers/index.js

@@ -0,0 +1,3 @@
+// BARREL FILE
+export { createFsRouter } from './fs.js';
+export { createMergeRouter } from './merge.js';

package/dist/cli/commands/project/backend/routers/merge.d.ts

@@ -0,0 +1,109 @@
+export declare const createMergeRouter: (projectDir: string) => import("hono/hono-base").HonoBase<import("hono/types").BlankEnv, {
+    "/grid": {
+        $post: {
+            input: {
+                json: {
+                    imagePaths: string[];
+                    shuffle: boolean;
+                    gap: number;
+                    cornerRadius: number;
+                    canvasColor: {
+                        r: number;
+                        g: number;
+                        b: number;
+                        alpha: number;
+                    };
+                    borderWidth: number;
+                    borderColor: {
+                        r: number;
+                        g: number;
+                        b: number;
+                        alpha: number;
+                    };
+                    aspectRatio: string;
+                    imageWidth: number;
+                    columns: number;
+                    caption: boolean;
+                    captions: string[];
+                    captionColor: {
+                        r: number;
+                        g: number;
+                        b: number;
+                        alpha: number;
+                    };
+                    maxCaptionSize: number;
+                };
+            };
+            output: {};
+            outputFormat: string;
+            status: import("hono/utils/http-status").StatusCode;
+        } | {
+            input: {
+                json: {
+                    imagePaths: string[];
+                    shuffle: boolean;
+                    gap: number;
+                    cornerRadius: number;
+                    canvasColor: {
+                        r: number;
+                        g: number;
+                        b: number;
+                        alpha: number;
+                    };
+                    borderWidth: number;
+                    borderColor: {
+                        r: number;
+                        g: number;
+                        b: number;
+                        alpha: number;
+                    };
+                    aspectRatio: string;
+                    imageWidth: number;
+                    columns: number;
+                    caption: boolean;
+                    captions: string[];
+                    captionColor: {
+                        r: number;
+                        g: number;
+                        b: number;
+                        alpha: number;
+                    };
+                    maxCaptionSize: number;
+                };
+            };
+            output: {
+                error: string;
+                at: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        };
+    };
+} & {
+    "/masonry": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: import("hono/types").ResponseFormat;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+} & {
+    collage: {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: import("hono/types").ResponseFormat;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+} & {
+    template: {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: import("hono/types").ResponseFormat;
+            status: import("hono/utils/http-status").StatusCode;
+        };
+    };
+}, "/", "template">;

package/dist/cli/commands/project/backend/routers/merge.js

@@ -0,0 +1,26 @@
+import { Hono } from 'hono';
+import { mergePostGridSchema } from '../validators/merge.js';
+import { zValidator } from '@hono/zod-validator';
+import { gridMerge } from '../../../../../core/index.js';
+import path from 'node:path';
+export const createMergeRouter = (projectDir) => {
+    const mergeRouter = new Hono()
+        // Chaining methods for type inference
+        .post('/grid', zValidator('json', mergePostGridSchema, (result, c) => {
+        if (!result.success) {
+            const currentIssue = result.error.issues[0];
+            return c.json({ error: currentIssue.message, at: currentIssue.path.join('.') }, 400);
+        }
+    }), async (c) => {
+        const data = c.req.valid('json');
+        const { imagePaths, ...gridMergeOptions } = data;
+        const options = { ...gridMergeOptions, format: 'png' };
+        const absolutePaths = imagePaths.map((p) => path.resolve(projectDir, p));
+        const output = await gridMerge(absolutePaths, options);
+        return new Response(output, { headers: { 'Content-Type': 'image/png' } });
+    })
+        .post('/masonry')
+        .post('collage')
+        .post('template');
+    return mergeRouter;
+};

package/dist/cli/commands/project/backend/validators/fs.d.ts

@@ -0,0 +1,11 @@
+import z from 'zod';
+export declare const fsGetQuerySchema: z.ZodObject<{
+    recursive: z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>;
+}, z.z.core.$strip>;
+export declare const fsPreviewGetQuerySchema: z.ZodObject<{
+    path: z.ZodString;
+    size: z.ZodDefault<z.z.ZodCoercedNumber<unknown>>;
+}, z.z.core.$strip>;

package/dist/cli/commands/project/backend/validators/fs.js

@@ -0,0 +1,8 @@
+import z from 'zod';
+export const fsGetQuerySchema = z.object({
+    recursive: z.enum(['true', 'false']),
+});
+export const fsPreviewGetQuerySchema = z.object({
+    path: z.string(),
+    size: z.coerce.number().default(256),
+});

package/dist/cli/commands/project/backend/validators/merge.d.ts

@@ -0,0 +1,32 @@
+import z from 'zod';
+export declare const mergePostGridSchema: z.ZodObject<{
+    imagePaths: z.ZodArray<z.ZodString>;
+    shuffle: z.ZodBoolean;
+    gap: z.ZodNumber;
+    cornerRadius: z.ZodNumber;
+    canvasColor: z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+        alpha: z.ZodNumber;
+    }, z.z.core.$strip>;
+    borderWidth: z.ZodNumber;
+    borderColor: z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+        alpha: z.ZodNumber;
+    }, z.z.core.$strip>;
+    aspectRatio: z.ZodString;
+    imageWidth: z.ZodNumber;
+    columns: z.ZodNumber;
+    caption: z.ZodBoolean;
+    captions: z.ZodArray<z.ZodString>;
+    captionColor: z.ZodObject<{
+        r: z.ZodNumber;
+        g: z.ZodNumber;
+        b: z.ZodNumber;
+        alpha: z.ZodNumber;
+    }, z.z.core.$strip>;
+    maxCaptionSize: z.ZodNumber;
+}, z.z.core.$strip>;

package/dist/cli/commands/project/backend/validators/merge.js

@@ -0,0 +1,17 @@
+import z from 'zod';
+export const mergePostGridSchema = z.object({
+    imagePaths: z.array(z.string()),
+    shuffle: z.boolean(),
+    gap: z.number(),
+    cornerRadius: z.number(),
+    canvasColor: z.object({ r: z.number(), g: z.number(), b: z.number(), alpha: z.number() }),
+    borderWidth: z.number(),
+    borderColor: z.object({ r: z.number(), g: z.number(), b: z.number(), alpha: z.number() }),
+    aspectRatio: z.string(),
+    imageWidth: z.number(),
+    columns: z.number(),
+    caption: z.boolean(),
+    captions: z.array(z.string()),
+    captionColor: z.object({ r: z.number(), g: z.number(), b: z.number(), alpha: z.number() }),
+    maxCaptionSize: z.number(),
+});

package/dist/cli/commands/project/index.d.ts

@@ -0,0 +1,2 @@
+declare const projectCommand: import("commander").Command;
+export default projectCommand;

package/dist/cli/commands/project/index.js

@@ -0,0 +1,64 @@
+import { buildCommandFromSchema } from '../../utils/buildCommandFromSchema.js';
+import { cliProjectSchema } from '../../schemas/project.js';
+import { loadImages } from '../../modules/loadImages.js';
+import { MergeProgressBar } from '../../modules/progressBar.js';
+import { MessageRenderer, MESSAGES } from '../../../core/modules/messages.js';
+import { toErrorMessage } from '../../utils/toErrorMessage.js';
+import { serveApp } from './backend/index.js';
+const projectCommand = buildCommandFromSchema('project', 'Starts a new project in the directory specified', cliProjectSchema, {
+    dir: {
+        flags: '[directory-path]',
+        description: 'Directory to start a new project in, defaults to current working directory',
+    },
+}, {}).action(async (dir) => {
+    const input = { dir };
+    try {
+        const { dir: projectDir } = await cliProjectSchema.parseAsync(input);
+        serveApp(projectDir, (info) => {
+            console.log(`Server running at http://localhost:${info.port}`);
+        }, 3000);
+        // console.log('xxx');
+        // console.log('yyy');
+        // console.log(5 + 5);
+        // // Use load images module
+        // const { images, imagePaths, ignoredPaths } = await loadImages({
+        //   input: { files: validatedOptions.files, dir: validatedOptions.dir },
+        //   recursive: validatedOptions.recursive,
+        // });
+        // // Ensure user knows about ignored files
+        // if (ignoredPaths.length) {
+        //   const warning = new MessageRenderer(MESSAGES.WARNINGS.IGNORED_FILES, ignoredPaths.join('\n') + '\n');
+        //   const confirmation = await warning.confirm();
+        //   if (!confirmation) return;
+        // }
+        // // Collect merge options
+        // const { recursive, output, files, dir, ...cliOptions } = validatedOptions;
+        // const format = path.extname(output).replace('.', '');
+        // const captions = imagePaths.map((p) => path.basename(p));
+        // const mergeOptions = {
+        //   format,
+        //   captions,
+        //   ...cliOptions,
+        // };
+        // // Get grid buffer
+        // const buffer = await gridMerge(images, mergeOptions, (progressInfo) => {
+        //   if (!bar.progressBar.isActive) {
+        //     bar.startBar(progressInfo.phase);
+        //   } else {
+        //     bar.updateBar(progressInfo);
+        //   }
+        // });
+        // // Write file and display success message
+        // await fs.writeFile(output, buffer);
+        // bar.endBar();
+        // const success = new MessageRenderer(MESSAGES.SUCCESS.OUTPUT, output);
+        // success.render();
+    }
+    catch (err) {
+        // Create and render error
+        const errorMessage = toErrorMessage(err);
+        const error = new MessageRenderer(errorMessage);
+        error.render();
+    }
+});
+export default projectCommand;

package/dist/cli/index.js

@@ -5,6 +5,7 @@ import gridCommand from './commands/grid/index.js';
 import masonryCommand from './commands/masonry/index.js';
 import templateCommand from './commands/template/index.js';
 import collageCommand from './commands/collage/index.js';
+import projectCommand from './commands/project/index.js';
 import pkg from '../../package.json' with { type: 'json' };
 const program = new Command();
 program
@@ -15,6 +16,7 @@ program.addCommand(gridCommand);
 program.addCommand(masonryCommand);
 program.addCommand(templateCommand);
 program.addCommand(collageCommand);
+program.addCommand(projectCommand);
 configureCommandErrors(program);
 try {
     program.parse();

package/dist/cli/schemas/project.d.ts

@@ -0,0 +1,4 @@
+import z from 'zod';
+export declare const cliProjectSchema: z.ZodObject<{
+    dir: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.z.core.$strict>;

package/dist/cli/schemas/project.js

@@ -0,0 +1,5 @@
+import z from 'zod';
+import { VALIDATORS } from '../../validators/index.js';
+export const cliProjectSchema = z.strictObject({
+    dir: VALIDATORS.dir.optional().default('./'),
+});

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

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

package/dist/core/jobs/types.js

@@ -1 +1 @@
-export {};
+import {} from 'sharp';

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

@@ -1,5 +1,5 @@
 import { requireNonEmptyArray, requireState } from '../../../pipeline/guards.js';
-import sharp from 'sharp';
+import {} from 'sharp';
 import { createSvgTextBuffer } from '../../../utils/svg/createSvgTextBuffer.js';
 import { rgbaToHex } from '../../../utils/colors/rgbaToHex.js';
 export const createComposites = async (context, options, onProgress) => {

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

@@ -1,10 +1,10 @@
 import type { MasonryMerge } from '../types.js';
-import type sharp from 'sharp';
+import { type Sharp } from 'sharp';
 export interface MasonryState {
     rowHeight: number;
     columnWidth: number;
     canvasWidth: number;
     canvasHeight: number;
-    lanes: sharp.Sharp[][];
+    lanes: Sharp[][];
 }
 export declare const masonryMerge: MasonryMerge;

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

@@ -1,5 +1,6 @@
 import { MergePipeline } from '../../pipeline/mergePipeline.js';
 import { masonrySchema } from '../../schemas/masonry.js';
+import {} from 'sharp';
 import { loadImages } from '../shared-steps/loadImages.js';
 import { createCanvas } from '../shared-steps/createCanvas.js';
 import { applyComposites } from '../shared-steps/applyComposites.js';

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

@@ -1,4 +1,4 @@
-import sharp from 'sharp';
+import sharp, {} from 'sharp';
 import { requireState } from '../../../pipeline/guards.js';
 import { handleImageEdges } from '../../../utils/images/handleImageEdges.js';
 // |----------------------|

package/dist/core/merges/shared-steps/exportCanvas.js

@@ -5,7 +5,8 @@ export const exportCanvas = async (context, options, _onProgress) => {
     // Ensure canvas exists
     requireContextProp(context, 'canvas');
     try {
-        return await context.canvas.toFormat(options.format).toBuffer();
+        const format = options.format === 'jpg' ? 'jpeg' : options.format;
+        return await context.canvas.toFormat(format).toBuffer();
     }
     catch (err) {
         // Assuming ALL sharp errors are instances of the Error object

package/dist/core/merges/shared-steps/loadImages.js

@@ -1,4 +1,4 @@
-import sharp from 'sharp';
+import sharp, {} from 'sharp';
 import { isActualImage } from '../../utils/images/isActualImage.js';
 import { MergeError } from '../../mergeError.js';
 import { requireNonEmptyArray } from '../../pipeline/guards.js';

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

@@ -1,4 +1,4 @@
-import sharp from 'sharp';
+import type { SharpInput } from 'sharp';
 import type { Color } from '../utils/colors/types.js';
 import type { Template } from './template/types.js';
 export interface ProgressInfo {
@@ -20,7 +20,7 @@ export type OnProgress = (info: ProgressInfo) => void;
  * @returns A Promise resolving to the merged image buffer
  */
 interface MergeCommand<T> {
-    (imageInputs: sharp.SharpInput[], options: T, onProgress?: OnProgress): Promise<Buffer>;
+    (imageInputs: SharpInput[], options: T, onProgress?: OnProgress): Promise<Buffer>;
 }
 interface BaseMergeOptions {
     /** Whether to randomize image order before merging. */

package/dist/core/merges/types.js

@@ -1 +1 @@
-import sharp from 'sharp';
+export {};

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

@@ -1,12 +1,12 @@
-import sharp from 'sharp';
+import { type Sharp, type SharpInput, type OverlayOptions } from 'sharp';
 import type z from 'zod';
 import type { OnProgress, ProgressInfo } from '../merges/types.js';
 export interface MergeContext<TState> {
-    inputs: sharp.SharpInput[];
+    inputs: SharpInput[];
     progressInfo: ProgressInfo;
-    images: sharp.Sharp[];
-    canvas?: sharp.Sharp;
-    composites: sharp.OverlayOptions[];
+    images: Sharp[];
+    canvas?: Sharp;
+    composites: OverlayOptions[];
     captions: string[];
     state: TState;
 }

package/dist/core/pipeline/mergePipeline.js

@@ -1,4 +1,4 @@
-import sharp from 'sharp';
+import {} from 'sharp';
 import { MergeError } from '../mergeError.js';
 import { MESSAGES } from '../modules/messages.js';
 import chalk from 'chalk';

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

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

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

@@ -1,4 +1,4 @@
-import sharp from 'sharp';
+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)

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

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

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

@@ -1,4 +1,4 @@
-import sharp from 'sharp';
+import {} from 'sharp';
 export const getImageHeights = async (images) => {
     const heights = [];
     for (const image of images) {

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

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

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

@@ -1,4 +1,4 @@
-import sharp from 'sharp';
+import {} from 'sharp';
 export const getImageWidths = async (images) => {
     const widths = [];
     for (const image of images) {

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

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

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

@@ -1,4 +1,4 @@
-import sharp from 'sharp';
+import {} 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()));

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

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