@uploadista/flow-images-nodes 0.0.3

package/dist/optimize-node.js

@@ -0,0 +1,41 @@
+import { createTransformNode, ImagePlugin, } from "@uploadista/core/flow";
+import { Effect } from "effect";
+// Map image format to MIME type
+const formatToMimeType = {
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    png: "image/png",
+    avif: "image/avif",
+};
+// Map image format to file extension
+const formatToExtension = {
+    jpeg: "jpg",
+    webp: "webp",
+    png: "png",
+    avif: "avif",
+};
+export function createOptimizeNode(id, { quality, format }) {
+    return Effect.gen(function* () {
+        const imageService = yield* ImagePlugin;
+        return yield* createTransformNode({
+            id,
+            name: "Optimize",
+            description: "Optimizes an image for web delivery",
+            transform: (inputBytes, file) => Effect.map(imageService.optimize(inputBytes, { quality, format }), (optimizedBytes) => {
+                // Return bytes with updated metadata if format changes
+                const newType = formatToMimeType[format];
+                const newExtension = formatToExtension[format];
+                // Update file extension if format changed
+                const fileName = file.metadata?.fileName;
+                const newFileName = fileName && typeof fileName === "string"
+                    ? fileName.replace(/\.[^.]+$/, `.${newExtension}`)
+                    : undefined;
+                return {
+                    bytes: optimizedBytes,
+                    type: newType,
+                    fileName: newFileName,
+                };
+            }),
+        });
+    });
+}

package/dist/remove-background-node.d.ts

@@ -0,0 +1,28 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { ImageAiPlugin } from "@uploadista/core/flow";
+import { UploadServer } from "@uploadista/core/upload";
+import { Effect } from "effect";
+export declare function createRemoveBackgroundNode(id: string, { credentialId }?: {
+    credentialId?: string;
+}): Effect.Effect<import("@uploadista/core").FlowNode<{
+    id: string;
+    offset: number;
+    storage: {
+        id: string;
+        type: string;
+        path?: string | undefined;
+        uploadId?: string | undefined;
+        bucket?: string | undefined;
+    };
+    size?: number | undefined;
+    metadata?: Record<string, string | number | boolean> | undefined;
+    creationDate?: string | undefined;
+    url?: string | undefined;
+    sizeIsDeferred?: boolean | undefined;
+    flow?: {
+        flowId: string;
+        nodeId: string;
+        jobId: string;
+    } | undefined;
+}, import("@uploadista/core").UploadFile, UploadistaError>, never, ImageAiPlugin | UploadServer>;
+//# sourceMappingURL=remove-background-node.d.ts.map

package/dist/remove-background-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-background-node.d.ts","sourceRoot":"","sources":["../src/remove-background-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAGL,aAAa,EAGd,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,MAAM,EACV,EAAE,YAAY,EAAE,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO;;;;;;;;;;;;;;;;;;;;iGAkHjD"}

package/dist/remove-background-node.js

@@ -0,0 +1,84 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { completeNodeExecution, createFlowNode, ImageAiPlugin, NodeType, resolveUploadMetadata, } from "@uploadista/core/flow";
+import { uploadFileSchema } from "@uploadista/core/types";
+import { UploadServer } from "@uploadista/core/upload";
+import { Effect } from "effect";
+import { waitForUrlAvailability } from "./wait-for-url";
+export function createRemoveBackgroundNode(id, { credentialId } = {}) {
+    return Effect.gen(function* () {
+        const imageAiService = yield* ImageAiPlugin;
+        const uploadServer = yield* UploadServer;
+        return yield* createFlowNode({
+            id,
+            name: "Remove Background",
+            description: "Removes the background from an image",
+            type: NodeType.process,
+            inputSchema: uploadFileSchema,
+            outputSchema: uploadFileSchema,
+            run: ({ data: file, flowId, jobId, storageId, clientId }) => {
+                return Effect.gen(function* () {
+                    const flow = {
+                        flowId,
+                        nodeId: id,
+                        jobId,
+                    };
+                    const fileUrl = file.url;
+                    // Validate input
+                    if (!fileUrl) {
+                        return yield* UploadistaError.fromCode("FLOW_NODE_ERROR", {
+                            cause: "URL is required for remove background operation",
+                        }).toEffect();
+                    }
+                    yield* Effect.logInfo(`Removing background for file ${file.id} at URL: ${file.url}`);
+                    // Wait for URL to be available with retry mechanism
+                    yield* waitForUrlAvailability(fileUrl);
+                    // Build context for ImageAI plugin
+                    const context = {
+                        clientId,
+                        credentialId,
+                    };
+                    // Remove background with error handling
+                    const backgroundRemovalResult = yield* imageAiService
+                        .removeBackground(fileUrl, context)
+                        .pipe(Effect.catchAll((error) => Effect.gen(function* () {
+                        yield* Effect.logError("Failed to remove background", error);
+                        return yield* UploadistaError.fromCode("FLOW_NODE_ERROR", {
+                            cause: error instanceof Error
+                                ? error.message
+                                : "Failed to remove background from image",
+                        }).toEffect();
+                    })));
+                    const { outputUrl } = backgroundRemovalResult;
+                    const { type, fileName, metadata, metadataJson } = resolveUploadMetadata(file.metadata);
+                    yield* Effect.logInfo(`Uploading processed file to storage`);
+                    // Upload the transformed bytes back to the upload server with error handling
+                    const result = yield* uploadServer
+                        .uploadFromUrl({
+                        storageId,
+                        size: 0,
+                        type,
+                        fileName,
+                        lastModified: 0,
+                        metadata: metadataJson,
+                        flow,
+                    }, clientId, outputUrl)
+                        .pipe(Effect.catchAll((error) => Effect.gen(function* () {
+                        yield* Effect.logError("Failed to upload processed file", error);
+                        return yield* UploadistaError.fromCode("FLOW_NODE_ERROR", {
+                            cause: error instanceof Error
+                                ? error.message
+                                : "Failed to upload processed file",
+                        }).toEffect();
+                    })));
+                    yield* Effect.logInfo(`Successfully removed background for file ${file.id}`);
+                    return completeNodeExecution(metadata
+                        ? {
+                            ...result,
+                            metadata,
+                        }
+                        : result);
+                });
+            },
+        });
+    });
+}

package/dist/resize-node.d.ts

@@ -0,0 +1,24 @@
+import { ImagePlugin, type ResizeParams } from "@uploadista/core/flow";
+import { Effect } from "effect";
+export declare function createResizeNode(id: string, { width, height, fit }: ResizeParams): Effect.Effect<import("@uploadista/core").FlowNode<{
+    id: string;
+    offset: number;
+    storage: {
+        id: string;
+        type: string;
+        path?: string | undefined;
+        uploadId?: string | undefined;
+        bucket?: string | undefined;
+    };
+    size?: number | undefined;
+    metadata?: Record<string, string | number | boolean> | undefined;
+    creationDate?: string | undefined;
+    url?: string | undefined;
+    sizeIsDeferred?: boolean | undefined;
+    flow?: {
+        flowId: string;
+        nodeId: string;
+        jobId: string;
+    } | undefined;
+}, import("@uploadista/core").UploadFile, import("@uploadista/core").UploadistaError>, never, ImagePlugin | import("@uploadista/core").UploadServer>;
+//# sourceMappingURL=resize-node.d.ts.map

package/dist/resize-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-node.d.ts","sourceRoot":"","sources":["../src/resize-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,EACX,KAAK,YAAY,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,MAAM,EACV,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,YAAY;;;;;;YAc8W,CAAC;gBAAsC,CAAC;cAAoC,CAAC;;;;;;;;;;;;qJADhe"}

package/dist/resize-node.js

@@ -0,0 +1,13 @@
+import { createTransformNode, ImagePlugin, } from "@uploadista/core/flow";
+import { Effect } from "effect";
+export function createResizeNode(id, { width, height, fit }) {
+    return Effect.gen(function* () {
+        const imageService = yield* ImagePlugin;
+        return yield* createTransformNode({
+            id,
+            name: "Resize",
+            description: "Resizes an image to the specified dimensions",
+            transform: (inputBytes) => imageService.resize(inputBytes, { height, width, fit }),
+        });
+    });
+}

package/dist/services/idnex.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=idnex.d.ts.map

package/dist/services/idnex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idnex.d.ts","sourceRoot":"","sources":["../../src/services/idnex.ts"],"names":[],"mappings":""}

package/dist/services/idnex.js

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

package/dist/services/image-service-common.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=image-service-common.d.ts.map

package/dist/services/image-service-common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-service-common.d.ts","sourceRoot":"","sources":["../../src/services/image-service-common.ts"],"names":[],"mappings":""}

package/dist/services/image-service-common.js

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

package/dist/services/image-service-node.d.ts

@@ -0,0 +1,18 @@
+import { PhotonImage, Rgba } from "@cf-wasm/photon/node";
+import { ImagePlugin } from "@uploadista/core/flow";
+import { Layer } from "effect";
+import type tinycolor from "tinycolor2";
+export declare const calculateImageSize: (objectFit: "contain" | "cover" | "fill" | "none" | "scale-down", currentWidth: number, currentHeight: number, containerWidth: number, containerHeight: number) => {
+    width: number;
+    height: number;
+};
+export declare const tinyColorToPhotonRGBA: (color: tinycolor.Instance) => Rgba;
+export declare const autoResize: (image: PhotonImage, newWidth?: number, newHeight?: number, options?: {
+    fit?: "contain" | "cover" | "fill";
+    fit_cover_letterbox_color?: tinycolor.Instance;
+}) => PhotonImage;
+export declare const imageToFormat: (image: PhotonImage, format: "webp" | "jpeg" | "png", options?: {
+    jpeg_quality?: number;
+}) => Uint8Array<ArrayBufferLike>;
+export declare const imageNode: Layer.Layer<ImagePlugin, never, never>;
+//# sourceMappingURL=image-service-node.d.ts.map

package/dist/services/image-service-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-service-node.d.ts","sourceRoot":"","sources":["../../src/services/image-service-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,EAKX,IAAI,EAEL,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,SAAS,MAAM,YAAY,CAAC;AAKxC,eAAO,MAAM,kBAAkB,GAC7B,WAAW,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,YAAY,EAC/D,cAAc,MAAM,EACpB,eAAe,MAAM,EACrB,gBAAgB,MAAM,EACtB,iBAAiB,MAAM;;;CAsFxB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,OAAO,SAAS,CAAC,QAAQ,SAG9D,CAAC;AAEF,eAAO,MAAM,UAAU,GACrB,OAAO,WAAW,EAClB,WAAW,MAAM,EACjB,YAAY,MAAM,EAClB,UAAU;IACR,GAAG,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;IACnC,yBAAyB,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC;CAChD,gBA4EF,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,OAAO,WAAW,EAClB,QAAQ,MAAM,GAAG,MAAM,GAAG,KAAK,EAC/B,UAAU;IACR,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,gCAmBF,CAAC;AAEF,eAAO,MAAM,SAAS,wCA4CrB,CAAC"}

package/dist/services/image-service-node.js

@@ -0,0 +1,170 @@
+import { crop, PhotonImage, padding_bottom, padding_left, padding_right, padding_top, Rgba, resize, } from "@cf-wasm/photon/node";
+import { ImagePlugin } from "@uploadista/core/flow";
+import { Effect, Layer } from "effect";
+const round2dp = (num) => Math.round((num + Number.EPSILON) * 100) / 100;
+export const calculateImageSize = (objectFit, currentWidth, currentHeight, containerWidth, containerHeight) => {
+    let newSize = {};
+    switch (objectFit) {
+        case "contain": {
+            // Calculate dimensions while maintaining aspect ratio
+            const widthRatioContain = containerWidth / currentWidth;
+            const heightRatioContain = containerHeight / currentHeight;
+            const scaleContain = Math.min(widthRatioContain, heightRatioContain);
+            newSize = {
+                width: currentWidth * scaleContain,
+                height: currentHeight * scaleContain,
+            };
+            break;
+        }
+        case "cover": {
+            // Calculate dimensions while maintaining aspect ratio
+            const widthRatioCover = containerWidth / currentWidth;
+            const heightRatioCover = containerHeight / currentHeight;
+            const scaleCover = Math.max(widthRatioCover, heightRatioCover);
+            const newWidthCover = currentWidth * scaleCover;
+            const newHeightCover = currentHeight * scaleCover;
+            // Adjust dimensions if it doesn't cover the container completely
+            if (newWidthCover < containerWidth || newHeightCover < containerHeight) {
+                const scaleCoverAdjusted = Math.max(containerWidth / currentWidth, containerHeight / currentHeight);
+                newSize = {
+                    width: currentWidth * scaleCoverAdjusted,
+                    height: currentHeight * scaleCoverAdjusted,
+                };
+                break;
+            }
+            newSize = {
+                width: newWidthCover,
+                height: newHeightCover,
+            };
+            break;
+        }
+        case "fill":
+            // Stretch image to fill container
+            newSize = {
+                width: containerWidth,
+                height: containerHeight,
+            };
+            break;
+        case "none":
+            // Keep original image size
+            newSize = {
+                width: currentWidth,
+                height: currentHeight,
+            };
+            break;
+        case "scale-down": {
+            // Calculate dimensions based on contain and none values
+            const widthRatioScaleDown = containerWidth / currentWidth;
+            const heightRatioScaleDown = containerHeight / currentHeight;
+            const scaleScaleDown = Math.min(1, Math.min(widthRatioScaleDown, heightRatioScaleDown));
+            newSize = {
+                width: currentWidth * scaleScaleDown,
+                height: currentHeight * scaleScaleDown,
+            };
+            break;
+        }
+        default:
+            throw new Error("Invalid object fit value");
+    }
+    if (!newSize?.width || !newSize?.height) {
+        throw new Error("Invalid dimensions");
+    }
+    return {
+        width: round2dp(newSize.width),
+        height: round2dp(newSize.height),
+    };
+    // return newSize;
+};
+export const tinyColorToPhotonRGBA = (color) => {
+    const rgba = color.toRgb();
+    return new Rgba(rgba.r, rgba.g, rgba.b, rgba.a);
+};
+export const autoResize = (image, newWidth, newHeight, options) => {
+    const currentWidth = image.get_width();
+    const currentHeight = image.get_height();
+    if (!newWidth && !newHeight) {
+        throw new Error("At least one of width or height is required");
+    }
+    if (newWidth && !newHeight) {
+        newHeight = Math.floor((newWidth / currentWidth) * currentHeight);
+    }
+    else if (newHeight && !newWidth) {
+        newWidth = Math.floor((newHeight / currentHeight) * currentWidth);
+    }
+    if (!newWidth || !newHeight) {
+        throw new Error("Invalid width or height");
+    }
+    if (newWidth === currentWidth && newHeight === currentHeight) {
+        return image;
+    }
+    const fit = options?.fit || "cover";
+    const dem = calculateImageSize(fit, currentWidth, currentHeight, newWidth, newHeight);
+    image = resize(image, dem.width, dem.height, 1);
+    const [updatedWidth, updatedHeight] = [image.get_width(), image.get_height()];
+    if (fit === "contain" && options?.fit_cover_letterbox_color) {
+        const paddingX = Math.floor((newWidth - updatedWidth) / 2);
+        const paddingY = Math.floor((newHeight - updatedHeight) / 2);
+        if (paddingY > 0) {
+            image = padding_top(image, paddingY, tinyColorToPhotonRGBA(options.fit_cover_letterbox_color));
+            image = padding_bottom(image, paddingY, tinyColorToPhotonRGBA(options.fit_cover_letterbox_color));
+        }
+        if (paddingX > 0) {
+            image = padding_left(image, paddingX, tinyColorToPhotonRGBA(options.fit_cover_letterbox_color));
+            image = padding_right(image, paddingX, tinyColorToPhotonRGBA(options.fit_cover_letterbox_color));
+        }
+    }
+    else if (fit === "cover") {
+        //crop to center
+        const cropX = Math.floor(updatedWidth - newWidth) / 2;
+        const cropY = Math.floor(updatedHeight - newHeight) / 2;
+        //top left to down right
+        image = crop(image, cropX, cropY, newWidth + cropX, newHeight + cropY);
+    }
+    return image;
+};
+export const imageToFormat = (image, format, options) => {
+    let outputBytes;
+    switch (format) {
+        case "webp":
+            outputBytes = image.get_bytes_webp();
+            break;
+        case "jpeg":
+            outputBytes = image.get_bytes_jpeg(options?.jpeg_quality || 100);
+            break;
+        case "png":
+            outputBytes = image.get_bytes();
+            break;
+        default:
+            outputBytes = image.get_bytes_jpeg(options?.jpeg_quality || 100);
+    }
+    return outputBytes;
+};
+export const imageNode = Layer.succeed(ImagePlugin, ImagePlugin.of({
+    optimize: (inputBytes, { quality }) => {
+        // create a PhotonImage instance
+        const inputImage = PhotonImage.new_from_byteslice(inputBytes);
+        // get jpeg bytes
+        const outputBytes = inputImage.get_bytes_jpeg(quality);
+        // call free() method to free memory
+        inputImage.free();
+        return Effect.succeed(outputBytes);
+    },
+    resize: (inputBytes, { width, height, fit }) => {
+        if (!width && !height) {
+            throw new Error("Either width or height must be specified for resize");
+        }
+        // create a PhotonImage instance
+        const inputImage = PhotonImage.new_from_byteslice(inputBytes);
+        // resize image using photon
+        const outputImage = autoResize(inputImage, width ?? inputImage.get_width(), height ?? inputImage.get_height(), { fit });
+        // get webp bytes
+        const outputBytes = outputImage.get_bytes_webp();
+        // for other formats
+        // png  : outputImage.get_bytes();
+        // jpeg : outputImage.get_bytes_jpeg(quality);
+        // call free() method to free memory
+        inputImage.free();
+        outputImage.free();
+        return Effect.succeed(outputBytes);
+    },
+}));

package/dist/services/image-service-serverless.d.ts

@@ -0,0 +1,4 @@
+import { ImagePlugin } from "@uploadista/core/flow";
+import { Layer } from "effect";
+export declare const imageServerless: Layer.Layer<ImagePlugin, never, never>;
+//# sourceMappingURL=image-service-serverless.d.ts.map

package/dist/services/image-service-serverless.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-service-serverless.d.ts","sourceRoot":"","sources":["../../src/services/image-service-serverless.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAC;AA6LvC,eAAO,MAAM,eAAe,wCA4C3B,CAAC"}

package/dist/services/image-service-serverless.js

@@ -0,0 +1,153 @@
+import { crop, PhotonImage, padding_bottom, padding_left, padding_right, padding_top, Rgba, resize, } from "@cf-wasm/photon";
+import { ImagePlugin } from "@uploadista/core/flow";
+import { Effect, Layer } from "effect";
+const round2dp = (num) => Math.round((num + Number.EPSILON) * 100) / 100;
+const calculateImageSize = (objectFit, currentWidth, currentHeight, containerWidth, containerHeight) => {
+    let newSize = {};
+    switch (objectFit) {
+        case "contain": {
+            // Calculate dimensions while maintaining aspect ratio
+            const widthRatioContain = containerWidth / currentWidth;
+            const heightRatioContain = containerHeight / currentHeight;
+            const scaleContain = Math.min(widthRatioContain, heightRatioContain);
+            newSize = {
+                width: currentWidth * scaleContain,
+                height: currentHeight * scaleContain,
+            };
+            break;
+        }
+        case "cover": {
+            // Calculate dimensions while maintaining aspect ratio
+            const widthRatioCover = containerWidth / currentWidth;
+            const heightRatioCover = containerHeight / currentHeight;
+            const scaleCover = Math.max(widthRatioCover, heightRatioCover);
+            const newWidthCover = currentWidth * scaleCover;
+            const newHeightCover = currentHeight * scaleCover;
+            // Adjust dimensions if it doesn't cover the container completely
+            if (newWidthCover < containerWidth || newHeightCover < containerHeight) {
+                const scaleCoverAdjusted = Math.max(containerWidth / currentWidth, containerHeight / currentHeight);
+                newSize = {
+                    width: currentWidth * scaleCoverAdjusted,
+                    height: currentHeight * scaleCoverAdjusted,
+                };
+                break;
+            }
+            newSize = {
+                width: newWidthCover,
+                height: newHeightCover,
+            };
+            break;
+        }
+        case "fill":
+            // Stretch image to fill container
+            newSize = {
+                width: containerWidth,
+                height: containerHeight,
+            };
+            break;
+        case "none":
+            // Keep original image size
+            newSize = {
+                width: currentWidth,
+                height: currentHeight,
+            };
+            break;
+        case "scale-down": {
+            // Calculate dimensions based on contain and none values
+            const widthRatioScaleDown = containerWidth / currentWidth;
+            const heightRatioScaleDown = containerHeight / currentHeight;
+            const scaleScaleDown = Math.min(1, Math.min(widthRatioScaleDown, heightRatioScaleDown));
+            newSize = {
+                width: currentWidth * scaleScaleDown,
+                height: currentHeight * scaleScaleDown,
+            };
+            break;
+        }
+        default:
+            throw new Error("Invalid object fit value");
+    }
+    if (!newSize?.width || !newSize?.height) {
+        throw new Error("Invalid dimensions");
+    }
+    return {
+        width: round2dp(newSize.width),
+        height: round2dp(newSize.height),
+    };
+    // return newSize;
+};
+const tinyColorToPhotonRGBA = (color) => {
+    const rgba = color.toRgb();
+    return new Rgba(rgba.r, rgba.g, rgba.b, rgba.a);
+};
+const autoResize = (image, newWidth, newHeight, options) => {
+    const currentWidth = image.get_width();
+    const currentHeight = image.get_height();
+    if (!newWidth && !newHeight) {
+        throw new Error("At least one of width or height is required");
+    }
+    if (newWidth && !newHeight) {
+        newHeight = Math.floor((newWidth / currentWidth) * currentHeight);
+    }
+    else if (newHeight && !newWidth) {
+        newWidth = Math.floor((newHeight / currentHeight) * currentWidth);
+    }
+    if (!newWidth || !newHeight) {
+        throw new Error("Invalid width or height");
+    }
+    if (newWidth === currentWidth && newHeight === currentHeight) {
+        return image;
+    }
+    const fit = options?.fit || "cover";
+    const dem = calculateImageSize(fit, currentWidth, currentHeight, newWidth, newHeight);
+    image = resize(image, dem.width, dem.height, 1);
+    const [updatedWidth, updatedHeight] = [image.get_width(), image.get_height()];
+    if (fit === "contain" && options?.fit_cover_letterbox_color) {
+        const paddingX = Math.floor((newWidth - updatedWidth) / 2);
+        const paddingY = Math.floor((newHeight - updatedHeight) / 2);
+        if (paddingY > 0) {
+            image = padding_top(image, paddingY, tinyColorToPhotonRGBA(options.fit_cover_letterbox_color));
+            image = padding_bottom(image, paddingY, tinyColorToPhotonRGBA(options.fit_cover_letterbox_color));
+        }
+        if (paddingX > 0) {
+            image = padding_left(image, paddingX, tinyColorToPhotonRGBA(options.fit_cover_letterbox_color));
+            image = padding_right(image, paddingX, tinyColorToPhotonRGBA(options.fit_cover_letterbox_color));
+        }
+    }
+    else if (fit === "cover") {
+        //crop to center
+        const cropX = Math.floor(updatedWidth - newWidth) / 2;
+        const cropY = Math.floor(updatedHeight - newHeight) / 2;
+        //top left to down right
+        image = crop(image, cropX, cropY, newWidth + cropX, newHeight + cropY);
+    }
+    return image;
+};
+export const imageServerless = Layer.succeed(ImagePlugin, ImagePlugin.of({
+    optimize: (inputBytes, { quality }) => {
+        // create a PhotonImage instance
+        const inputImage = PhotonImage.new_from_byteslice(inputBytes);
+        // get jpeg bytes
+        const outputBytes = inputImage.get_bytes_jpeg(quality);
+        // call free() method to free memory
+        inputImage.free();
+        return Effect.succeed(outputBytes);
+    },
+    resize: (inputBytes, { width, height, fit }) => {
+        if (!width && !height) {
+            throw new Error("Either width or height must be specified for resize");
+        }
+        // create a PhotonImage instance
+        const inputImage = PhotonImage.new_from_byteslice(inputBytes);
+        // resize image using photon
+        const outputImage = autoResize(inputImage, width ?? inputImage.get_width(), height ?? inputImage.get_height(), { fit });
+        // get webp bytes
+        const outputBytes = outputImage.get_bytes_webp();
+        // for other formats
+        // png  : outputImage.get_bytes();
+        // jpeg : outputImage.get_bytes_jpeg(quality);
+        // call free() method to free memory
+        inputImage.free();
+        outputImage.free();
+        return Effect.succeed(outputBytes);
+    },
+}));

package/dist/services/image-service.d.ts

@@ -0,0 +1,13 @@
+import type { UploadistaError } from "@uploadista/core/errors";
+import { Context, type Effect } from "effect";
+import type { OptimizeParams } from "../types/optimize-node";
+import type { ResizeParams } from "../types/resize-node";
+export type ImageServiceShape = {
+    optimize: (input: Uint8Array, options: OptimizeParams) => Effect.Effect<Uint8Array, UploadistaError>;
+    resize: (input: Uint8Array, options: ResizeParams) => Effect.Effect<Uint8Array, UploadistaError>;
+};
+declare const ImageService_base: Context.TagClass<ImageService, "ImageService", ImageServiceShape>;
+export declare class ImageService extends ImageService_base {
+}
+export {};
+//# sourceMappingURL=image-service.d.ts.map

package/dist/services/image-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-service.d.ts","sourceRoot":"","sources":["../../src/services/image-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,CACR,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,cAAc,KACpB,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;IAChD,MAAM,EAAE,CACN,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,YAAY,KAClB,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;CACjD,CAAC;;AAEF,qBAAa,YAAa,SAAQ,iBAG/B;CAAG"}

package/dist/services/image-service.js

@@ -0,0 +1,3 @@
+import { Context } from "effect";
+export class ImageService extends Context.Tag("ImageService")() {
+}

package/dist/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./image-service";
+export * from "./image-service-node";
+//# sourceMappingURL=index.d.ts.map

package/dist/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC"}

package/dist/services/index.js

@@ -0,0 +1,3 @@
+export * from "./image-service";
+export * from "./image-service-node";
+// export * from "./image-service-serverless";

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./optimize-node";
+export * from "./resize-node";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC"}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export * from "./optimize-node";
+export * from "./resize-node";

package/dist/types/optimize-node.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const optimizeParamsSchema: z.ZodObject<{
+    quality: z.ZodNumber;
+    format: z.ZodEnum<{
+        jpeg: "jpeg";
+    }>;
+}, z.core.$strip>;
+export type OptimizeParams = z.infer<typeof optimizeParamsSchema>;
+//# sourceMappingURL=optimize-node.d.ts.map

package/dist/types/optimize-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimize-node.d.ts","sourceRoot":"","sources":["../../src/types/optimize-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,oBAAoB;;;;;iBAG/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/types/optimize-node.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export const optimizeParamsSchema = z.object({
+    quality: z.number().min(0).max(100),
+    format: z.enum(["jpeg"]),
+});