@pi-r/jimp 0.10.3 → 0.11.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pi-r/jimp",
-  "version": "0.10.3",
-  "description": "Jimp V0 image constructor for E-mc.",
+  "version": "0.11.1",
+  "description": "Jimp V1 image constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
   "publishConfig": {
@@ -9,7 +9,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/anpham6/pi-r.git",
+    "url": "git+https://github.com/anpham6/pi-r2.git",
     "directory": "src/module/jimp"
   },
   "keywords": [
@@ -18,12 +18,14 @@
   ],
   "author": "An Pham <anpham6@gmail.com>",
   "license": "MIT",
-  "homepage": "https://github.com/anpham6/pi-r#readme",
+  "homepage": "https://github.com/anpham6/pi-r2#readme",
   "dependencies": {
-    "@e-mc/image": "^0.12.7",
-    "@e-mc/types": "^0.12.7",
+    "@e-mc/core": "^0.13.5",
+    "@e-mc/image": "^0.13.5",
+    "@e-mc/types": "^0.13.5",
+    "@jimp/utils": "^1.6.0",
     "bmp-js": "^0.1.0",
     "gifwrap": "^0.10.1",
-    "jimp": "^0.22.12"
+    "jimp": "^1.6.0"
   }
 }

package/types/index.d.ts

@@ -1,12 +1,12 @@
 import type { IFileManager, IHost, IImage, ImageConstructor } from '@e-mc/types/lib';
 import type { ExternalAsset } from '@e-mc/types/lib/asset';
-import type { TransformOptions } from '@e-mc/types/lib/image';
+import type { WorkerMessage } from '@e-mc/types/lib/core';
+import type { CommandData, CropData, Dimension, Point, ResizeData, RotateData, TransformOptions } from '@e-mc/types/lib/image';
 import type { ImageModule, ImageSettings } from '@e-mc/types/lib/settings';
 import type { ExecAction } from '@e-mc/types/lib/module';
-
 import type { ImageHandler } from '@e-mc/image/types';
 
-import type * as jimp from 'jimp';
+import type { JPEGOptions, JimpInstance } from 'jimp';
 
 export interface JimpSettings extends ImageSettings {
     jimp?: {
@@ -14,20 +14,64 @@ export interface JimpSettings extends ImageSettings {
         cache_expires?: number | string;
         rotate_clockwise?: boolean;
         gifwrap_quantize?: "dekker" | "sorokin" | "wu" | "none";
+        worker?: {
+            min?: number | string;
+            max?: number | string;
+            expires?: number | string;
+        };
+        options?: {
+            decode?: Record<string, AnyObject>;
+            encode?: Record<string, AnyObject>;
+        };
     };
 }
 
+export interface JimpMessage<T = PlainObject> extends WorkerMessage<T, Buffer | string> {
+    commandData: CommandData;
+    outputType: string;
+    output?: string;
+}
+
 export type ResultCallback<T = unknown, U = void, V = unknown> = (err: V, result: T) => U;
 
-export interface IJimpHandler<T extends IHost = IHost, U extends ImageModule = ImageModule> extends ImageHandler<jimp, T, IImage<T, U>, void, Promise<void>> {
-    quality(): void;
-    rotate(localFile?: string, callback?: ResultCallback<string>): Promise<this>;
+export interface IJimpHandler<T extends IHost = IHost, U extends ImageModule = ImageModule<JimpSettings>, V = JimpInstance> extends ImageHandler<V, T, IImage<T, U>, Promise<void>, Promise<void>> {
+    rotate(localFile?: string, callback?: ResultCallback<string>): Promise<void>;
     background(value: number | [number, number, number, number]): void;
-    writeAsync(output: string, callback?: ResultCallback): Promise<void>;
+    finalize(output: string, callback?: (err: unknown, result: string) => void, replace?: boolean): Promise<void>;
+}
+
+export interface IJimpImage<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ImageModule = ImageModule<JimpSettings>> extends IImage<T, V> {
+    getEncodeOptions(): JPEGOptions | undefined;
 }
 
 export interface JimpImageConstructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ImageModule = ImageModule<JimpSettings>> extends ConstructorDerived<ImageConstructor<T, V>> {
     transform<W extends TransformOptions>(file: string, command: string, options?: W): Promise<W extends { tempFile: true } ? string : Buffer | null>;
-    readonly prototype: IImage<T, V>;
-    new(module?: V, ...args: unknown[]): IImage<T, V>;
+    applyBackground(instance: JimpInstance, data: { color: number }): void;
+    applyResize(instance: JimpInstance, data: ResizeData): void;
+    applyCrop(instance: JimpInstance, data: CropData): void;
+    applyRotate(instance: JimpInstance, data: RotateData): void;
+    applyMethod(instance: JimpInstance, name: string, ...args: unknown[]): unknown[];
+    readonly prototype: IJimpImage<T, U, V>;
+    new(module?: V, ...args: unknown[]): IJimpImage<T, U, V>;
+}
+
+export interface WebpMuxFrame extends Dimension, Point {
+    delay: number;
+}
+
+export interface WebpMuxImage extends Readonly<Dimension> {
+    readonly anim: { loops: number; bgColor: [number, number, number, number] };
+    initLib(): Promise<void>;
+    load(value: Bufferable): Promise<void>;
+    demux(options: { path?: string; prefix?: string; buffers?: boolean }): Promise<void>;
+    getImageData(): Promise<Uint8Array>;
+    getFrameData(frame: number): Promise<Uint8Array>;
+    setFrameData(frame: number, source: Buffer, options: Dimension & { preset?: string; quality?: number; exact?: boolean; lossless?: number; method?: number }): Promise<void>;
+    save(path: string, options: Dimension & { bgColor?: number[] }): Promise<void>;
+    get hasAnim(): boolean;
+    get frames(): WebpMuxFrame[];
+}
+
+export interface WebpMux {
+    Image: new() => WebpMuxImage;
 }

package/util.d.ts

@@ -1,9 +1,8 @@
 declare namespace util {
-    function parseFormat(command: string, mimeType?: string, gif?: boolean): [string, string, string];
+    function parseFormat(command: string, mimeType?: string): [string, string, string];
+    function detectExt(mimeType: string | undefined, webp?: boolean): string | undefined;
     function renameExt(output: string, ext: string, replace?: boolean): string;
     function normalizePath(value: string): string;
-    /** @deprecated */
-    function getWebP_bin(name: string, pathname: string | undefined): string;
     function importBinary(name: string, pathname: string | undefined): Promise<string>;
     function showInputType(value: string | undefined, outputType: string, finalAs: string): string;
     function showOutputType(value: string | undefined, outputType: string, finalAs: string): string;

package/util.js

@@ -1,17 +1,10 @@
-"use strict";
-exports.MIME_OUTPUT = exports.MIME_INPUT = void 0;
-exports.parseFormat = parseFormat;
-exports.renameExt = renameExt;
-exports.normalizePath = normalizePath;
-exports.getWebP_bin = getWebP_bin;
-exports.importBinary = importBinary;
-exports.showInputType = showInputType;
-exports.showOutputType = showOutputType;
+'use strict';
+
 const path = require("node:path");
 const fs = require("node:fs");
 const types = require("@e-mc/types");
 const Image = require("@e-mc/image");
-exports.MIME_INPUT = new Set([
+const MIME_INPUT = new Set([
     Image.MIME_PNG,
     Image.MIME_JPEG,
     Image.MIME_BMP,
@@ -19,49 +12,57 @@ exports.MIME_INPUT = new Set([
     Image.MIME_TIFF,
     Image.MIME_WEBP
 ]);
-exports.MIME_OUTPUT = new Set([
+const MIME_OUTPUT = new Set([
     Image.MIME_PNG,
     Image.MIME_JPEG,
     Image.MIME_BMP,
     Image.MIME_GIF,
+    Image.MIME_TIFF,
     Image.MIME_WEBP
 ]);
-function parseFormat(command, mimeType, gif) {
+function parseFormat(command, mimeType) {
     command = command.toLowerCase();
-    for (let mime of exports.MIME_OUTPUT) {
+    for (let mime of MIME_OUTPUT) {
         let saveAs = mime.split('/')[1];
         if (command.startsWith(saveAs)) {
             let outputAs = '';
-            if (saveAs !== 'gif') {
-                switch (saveAs) {
-                    case 'jpeg':
-                        saveAs = 'jpg';
-                        break;
-                    case 'webp':
-                        if (mimeType === Image.MIME_JPEG) {
-                            mime = Image.MIME_JPEG;
-                            saveAs = 'jpg';
-                        }
-                        else if (gif && mimeType === Image.MIME_GIF) {
-                            mime = Image.MIME_GIF;
-                            saveAs = 'gif';
-                        }
-                        else {
-                            mime = Image.MIME_PNG;
-                            saveAs = 'png';
-                        }
-                        outputAs = 'webp';
-                        break;
-                }
-            }
-            else if (!gif) {
-                break;
+            switch (saveAs) {
+                case 'jpeg':
+                    saveAs = 'jpg';
+                    break;
+                case 'webp':
+                    if (saveAs = detectExt(mimeType)) {
+                        mime = mimeType;
+                    }
+                    else {
+                        mime = Image.MIME_PNG;
+                        saveAs = 'png';
+                    }
+                    outputAs = 'webp';
+                    break;
             }
             return [mime, saveAs, outputAs];
         }
     }
     return ['', '', ''];
 }
+function detectExt(mimeType, webp) {
+    switch (mimeType) {
+        case Image.MIME_JPEG:
+            return 'jpg';
+        case Image.MIME_GIF:
+            return 'gif';
+        case Image.MIME_TIFF:
+            return 'tiff';
+        case Image.MIME_BMP:
+            if (!webp) {
+                return 'bmp';
+            }
+            break;
+        case Image.MIME_PNG:
+            return 'png';
+    }
+}
 function renameExt(output, ext, replace) {
     let result = types.renameExt(output.replace('.__copy__.', '.'), ext);
     if (!replace) {
@@ -74,15 +75,7 @@ function renameExt(output, ext, replace) {
     return result;
 }
 function normalizePath(value) {
-    return '"' + value.replace(/"/g, '\\"') + '"';
-}
-function getWebP_bin(name, pathname) {
-    if (pathname && fs.existsSync(pathname)) {
-        name += Image.PLATFORM_WIN32 ? '.exe' : '';
-        const bin = path.join(pathname, name);
-        return types.sanitizeCmd(fs.existsSync(bin) ? bin : path.join(pathname, 'bin', name));
-    }
-    return require(name + '-bin');
+    return `"${value.replace(/"/g, '\\"')}"`;
 }
 async function importBinary(name, pathname) {
     if (pathname && fs.existsSync(pathname)) {
@@ -92,15 +85,25 @@ async function importBinary(name, pathname) {
     }
     return types.importESM(name + '-bin', true);
 }
-function showInputType(value, outputType, outputAs) {
-    if (outputAs) {
-        outputType = 'image/' + outputAs;
+function showInputType(value, outputType, finalAs) {
+    if (finalAs) {
+        outputType = 'image/' + finalAs;
     }
     return value && outputType !== value ? value.split('/').pop() + ' -> ' : '';
 }
-function showOutputType(value, outputType, outputAs) {
-    if (outputAs) {
-        outputType = 'image/' + outputAs;
+function showOutputType(value, outputType, finalAs) {
+    if (finalAs) {
+        outputType = 'image/' + finalAs;
     }
     return value !== outputType ? ' -> ' + outputType.split('/').pop() : '';
 }
+
+exports.MIME_INPUT = MIME_INPUT;
+exports.MIME_OUTPUT = MIME_OUTPUT;
+exports.detectExt = detectExt;
+exports.importBinary = importBinary;
+exports.normalizePath = normalizePath;
+exports.parseFormat = parseFormat;
+exports.renameExt = renameExt;
+exports.showInputType = showInputType;
+exports.showOutputType = showOutputType;

package/worker/jimp.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var node_worker_threads = require('node:worker_threads');
+var jimp = require('jimp');
+var types = require('@e-mc/types');
+
+const Image = require("@e-mc/image");
+const JimpApp = require("@pi-r/jimp");
+const PORT = node_worker_threads.workerData[0];
+node_worker_threads.parentPort.on('message', (value) => {
+    const { data, commandData, output, options } = value;
+    jimp.Jimp.read(typeof data === 'string' ? data : Image.asBuffer(data))
+        .then(async (img) => {
+        const { method, resize, crop, rotate, opacity = -1 } = commandData;
+        if (method) {
+            for (const [name, args = []] of method) {
+                if (name === 'composite') {
+                    const [src, x, y, opts] = args;
+                    if (types.isString(src) && typeof x === 'number' && typeof y === 'number') {
+                        img.composite(await jimp.Jimp.read(src), x, y, opts);
+                    }
+                    else {
+                        throw types.errorMessage(name, "Invalid parameters", JSON.stringify(value));
+                    }
+                }
+                else {
+                    JimpApp.applyMethod(img, name, ...args);
+                }
+            }
+        }
+        if (resize) {
+            JimpApp.applyResize(img, resize);
+        }
+        if (crop) {
+            JimpApp.applyCrop(img, crop);
+        }
+        if (rotate) {
+            JimpApp.applyRotate(img, rotate);
+        }
+        if (opacity >= 0) {
+            img.opacity(opacity);
+        }
+        if (output) {
+            img.write(output, options)
+                .then(() => {
+                PORT.postMessage(output);
+            })
+                .catch((err) => {
+                console.error(err);
+                PORT.postMessage(null);
+            });
+        }
+        else {
+            void img.getBuffer(value.outputType, options)
+                .then(result => {
+                PORT.postMessage(result, [result.buffer]);
+            });
+        }
+    })
+        .catch((err) => {
+        console.error(err);
+        PORT.postMessage(null);
+    });
+});