@pi-r/jimp 0.9.3 → 0.10.0

package/index.d.ts

@@ -0,0 +1,7 @@
+import type { IFileManager } from '@e-mc/types/lib';
+
+import type { JimpImageConstructor } from './types';
+
+declare const Jimp: JimpImageConstructor<IFileManager>;
+
+export = Jimp;

package/index.js

@@ -9,6 +9,7 @@ const node_crypto_1 = require("node:crypto");
 const types_1 = require("@e-mc/types");
 const util_1 = require("@pi-r/jimp/util");
 const Image = require('@e-mc/image');
+const kJimp = Symbol.for('jimp:constructor');
 let WEBPMUX = null, WEBPMUX_INIT = false;
 try {
     WEBPMUX = require('node-webpmux');
@@ -80,7 +81,7 @@ function getMethodName(value) {
         return value;
     }
 }
-async function performCommand(host, instance, localUri, command, outputType, outputAs, buffer, parent) {
+async function performCommand(host, instance, localUri, command, outputType, outputAs, { buffer, parent } = {}) {
     return await jimp.read((buffer || localUri))
         .then(async (img) => {
         return await transformCommand(localUri, new JimpHandler(img, instance, host), command, outputType, outputAs, parent);
@@ -145,8 +146,8 @@ async function setImageCache(instance, tempKey, tempFile, output, localFile) {
         else {
             stored[tempKey] = { tempKey, tempFile, ctimeMs: Date.now() };
         }
-        if (instance.settings.jimp.cache_expires) {
-            fs.writeFile(tempFile + '.json', JSON.stringify(stored[tempKey]), 'utf-8', () => { });
+        if (instance.settings.jimp?.cache_expires) {
+            fs.writeFile(tempFile + '.json', JSON.stringify(stored[tempKey]), 'utf8', () => { });
         }
     }
     catch {
@@ -195,7 +196,7 @@ function getCacheData(instance) {
                         if (item.isFile() && path.extname(item.name) === '.json') {
                             const pathname = path.join(TEMP_DIR, item.name);
                             try {
-                                const data = JSON.parse(fs.readFileSync(pathname, 'utf-8'));
+                                const data = JSON.parse(fs.readFileSync(pathname, 'utf8'));
                                 if ((0, types_1.isPlainObject)(data) && fs.existsSync(data.tempFile)) {
                                     if (data.ctimeMs + expires > current) {
                                         CACHE_TRANSFORM[data.tempKey] = data;
@@ -257,9 +258,8 @@ class JimpHandler {
         const data = this.instance.rotateData;
         if (data) {
             const { values, color } = data;
-            const handler = this.handler;
             if (!isNaN(color)) {
-                handler.background(color);
+                this.handler.background(color);
             }
             const tasks = [];
             const length = values.length;
@@ -269,11 +269,11 @@ class JimpHandler {
                 const ext = path.extname(localFile);
                 for (let i = 1; i < length; ++i) {
                     const value = values[i];
-                    const img = handler.clone().rotate(value);
+                    const img = this.handler.clone().rotate(value);
                     const output = leading + value + ext;
                     tasks.push(img.writeAsync(output)
                         .then(() => {
-                        this.finalize(output, callback);
+                        void this.finalize(output, callback, false);
                     })
                         .catch((err) => {
                         this.instance.writeFail(["Unable to rotate image", "jimp"], err, 2048);
@@ -281,7 +281,7 @@ class JimpHandler {
                 }
             }
             if (deg) {
-                handler.rotate(deg);
+                this.handler.rotate(deg);
             }
             if (tasks.length > 0) {
                 return Promise.all(tasks).then(() => this);
@@ -295,7 +295,6 @@ class JimpHandler {
         }
         const data = this.instance.methodData;
         if (data) {
-            const handler = this.handler;
             for (const [name, args = []] of data) {
                 try {
                     const alias = getMethodName(name);
@@ -305,14 +304,14 @@ class JimpHandler {
                     if (alias === 'composite') {
                         const [src, x, y, opts] = args;
                         if ((0, types_1.isString)(src) && typeof x === 'number' && typeof y === 'number') {
-                            handler.composite(await jimp.read(src), x, y, opts);
+                            this.handler.composite(await jimp.read(src), x, y, opts);
                         }
                         else {
                             throw (0, types_1.errorValue)("Invalid parameters", alias);
                         }
                     }
                     else {
-                        handler[alias](...args);
+                        this.handler[alias](...args);
                     }
                 }
                 catch (err) {
@@ -328,25 +327,10 @@ class JimpHandler {
         const data = this.instance.resizeData;
         if (data) {
             const { width, height, color, algorithm, align, mode } = data;
-            const handler = this.handler;
             if (!isNaN(color)) {
-                handler.background(color);
-            }
-            let resizeMode = jimp.RESIZE_NEAREST_NEIGHBOR, flags = 0;
-            switch (algorithm) {
-                case 'bilinear':
-                    resizeMode = jimp.RESIZE_BILINEAR;
-                    break;
-                case 'bicubic':
-                    resizeMode = jimp.RESIZE_BICUBIC;
-                    break;
-                case 'hermite':
-                    resizeMode = jimp.RESIZE_HERMITE;
-                    break;
-                case 'bezier':
-                    resizeMode = jimp.RESIZE_BEZIER;
-                    break;
+                this.handler.background(color);
             }
+            let flags = 0;
             switch (align[0]) {
                 case 'left':
                     flags |= jimp.HORIZONTAL_ALIGN_LEFT;
@@ -371,17 +355,36 @@ class JimpHandler {
             }
             switch (mode) {
                 case 'contain':
-                    handler.contain(width, height, flags);
+                    this.handler.contain(width, height, flags);
                     break;
                 case 'cover':
-                    handler.cover(width, height, flags);
+                    this.handler.cover(width, height, flags);
                     break;
                 case 'scale':
-                    handler.scaleToFit(width, height);
+                    this.handler.scaleToFit(width, height);
                     break;
-                default:
-                    handler.resize(width === Infinity ? jimp.AUTO : width, height === Infinity ? jimp.AUTO : height, resizeMode);
+                default: {
+                    let resizeMode = jimp.RESIZE_NEAREST_NEIGHBOR;
+                    switch (algorithm) {
+                        case 'bilinear':
+                            resizeMode = jimp.RESIZE_BILINEAR;
+                            break;
+                        case 'bicubic':
+                            resizeMode = jimp.RESIZE_BICUBIC;
+                            break;
+                        case 'hermite':
+                            resizeMode = jimp.RESIZE_HERMITE;
+                            break;
+                        case 'bezier':
+                            resizeMode = jimp.RESIZE_BEZIER;
+                            break;
+                        case 'none':
+                            resizeMode = undefined;
+                            break;
+                    }
+                    this.handler.resize(width === Infinity ? jimp.AUTO : width, height === Infinity ? jimp.AUTO : height, resizeMode);
                     break;
+                }
             }
         }
     }
@@ -391,7 +394,7 @@ class JimpHandler {
         }
         this.handler.background(value);
     }
-    finalize(output, callback) {
+    async finalize(output, callback, replace) {
         if (this.aborted) {
             return;
         }
@@ -400,7 +403,7 @@ class JimpHandler {
             const settings = instance.settings;
             const webp = settings.webp ||= {};
             const data = instance.qualityData;
-            const replace = instance.getCommand().includes('@');
+            replace ??= instance.getCommand().includes('@');
             const filename = (0, util_1.renameExt)(output, 'webp', replace);
             const args = [(0, util_1.normalizePath)(output)];
             if (data) {
@@ -445,7 +448,7 @@ class JimpHandler {
             }
             args.push('-o', (0, util_1.normalizePath)(filename));
             try {
-                child_process.execFile((0, util_1.getWebP_bin)('cwebp', webp.path), args, { shell: true, signal: this.instance.signal, ...execOptions(settings) }, err => {
+                child_process.execFile(await (0, util_1.importBinary)('cwebp', webp.path), args, { shell: true, signal: this.instance.signal, ...execOptions(settings) }, err => {
                     if (err) {
                         this.instance.writeFail(["Unable to convert file", path.basename(filename)], err, 2048);
                     }
@@ -466,7 +469,7 @@ class JimpHandler {
                 });
             }
             catch (err) {
-                this.instance.checkPackage(err, 'cwebp-bin@6.1.2', "Unknown", { type: 2048, passThrough: !!callback });
+                this.instance.checkPackage(err, 'cwebp-bin', "Unknown", { type: 2048, passThrough: !!callback });
                 if (callback) {
                     callback(err, '');
                 }
@@ -488,7 +491,7 @@ class JimpHandler {
                     resolve(emptyData());
                     return;
                 }
-                this.finalize(output, (error, result) => {
+                void this.finalize(output, (error, result) => {
                     if (error) {
                         resolve(emptyData());
                     }
@@ -521,7 +524,7 @@ class JimpHandler {
         }
         const data = this.instance.cropData;
         if (data) {
-            this.handler = this.handler.crop(data.x, data.y, data.width, data.height);
+            this.handler.crop(data.x, data.y, data.width, data.height);
         }
     }
     opacity() {
@@ -530,7 +533,7 @@ class JimpHandler {
         }
         const value = this.instance.opacityValue ?? NaN;
         if (value >= 0) {
-            this.handler = this.handler.opacity(value);
+            this.handler.opacity(value);
         }
     }
     quality() {
@@ -539,7 +542,7 @@ class JimpHandler {
         }
         const data = this.instance.qualityData;
         if (data && !isNaN(data.value)) {
-            this.handler = this.handler.quality(data.value);
+            this.handler.quality(data.value);
         }
     }
     write(output, callback) {
@@ -551,7 +554,7 @@ class JimpHandler {
         }
         this.handler.write(output, err => {
             if (!err) {
-                this.finalize(output, callback);
+                void this.finalize(output, callback);
             }
             else if (callback) {
                 callback(err, '');
@@ -567,7 +570,7 @@ class JimpHandler {
         }
         return this.handler.writeAsync(output)
             .then(() => {
-            this.finalize(output, callback);
+            void this.finalize(output, callback);
         })
             .catch((err) => {
             if (callback) {
@@ -589,6 +592,7 @@ class JimpHandler {
     }
 }
 class Jimp extends Image {
+    static [kJimp] = true;
     static async transform(file, command, options = {}) {
         const [outputType, saveAs, outputAs] = (0, util_1.parseFormat)(command = command.trim(), options.mimeType);
         if (!outputType) {
@@ -760,8 +764,8 @@ class Jimp extends Image {
             };
             const transformBuffer = (bmpFile) => {
                 startMessage();
-                performCommand(host, this, localUri, command, bmpFile ? jimp.MIME_BMP : outputType, outputAs, bmpFile || file.buffer, file)
-                    .then((img) => {
+                performCommand(host, this, localUri, command, outputType, outputAs, { buffer: bmpFile || file.buffer, parent: file })
+                    .then(img => {
                     if (typeof bmpFile === 'string') {
                         removeFile(bmpFile);
                     }
@@ -789,6 +793,9 @@ class Jimp extends Image {
                             if (!err && result) {
                                 finalize(result);
                             }
+                            else if (Image.isErrorCode(err, types_1.ERR_CODE.MODULE_NOT_FOUND)) {
+                                resolve();
+                            }
                             else {
                                 errorResponse(err || new Error("Unknown"));
                             }
@@ -800,17 +807,13 @@ class Jimp extends Image {
                     resolve();
                 });
             };
-            const errorResponse = (err) => {
-                this.writeFail(["Unable to convert file", path.basename(localUri)], err, { type: 2048, startTime });
-                resolve();
-            };
             const startMessage = () => {
                 host.formatMessage(2048, "jimp", ["Transforming image...", path.basename(localUri)], command);
             };
             if (mimeType === jimp.MIME_GIF) {
                 if (outputType === jimp.MIME_GIF || outputType === "image/webp") {
                     const cmd = this.parseCommand(command);
-                    const transformWebP = (target, modified) => {
+                    const transformWebP = async (target, modified) => {
                         if (outputAs === 'webp') {
                             if (!modified) {
                                 startMessage();
@@ -832,11 +835,10 @@ class Jimp extends Image {
                                 for (let i = 0, length = gif2webp.length; i < length; ++i) {
                                     const arg = gif2webp[i];
                                     switch (arg) {
-                                        case '-h':
-                                        case '-version':
-                                            continue;
                                         case '-o':
                                             ++i;
+                                        case '-h':
+                                        case '-version':
                                             continue;
                                         case '-q':
                                         case '-m':
@@ -854,22 +856,22 @@ class Jimp extends Image {
                             }
                             args.push('-o', (0, util_1.normalizePath)(webp));
                             try {
-                                child_process.execFile((0, util_1.getWebP_bin)('gif2webp', webp_path), args, { shell: true, signal: this.signal, ...execOptions(this.settings) }, (err, stdout) => {
+                                child_process.execFile(await (0, util_1.importBinary)('gif2webp', webp_path), args, { shell: true, signal: this.signal, ...execOptions(this.settings) }, (err, stdout) => {
                                     if (!err) {
                                         this.addLog(types_1.STATUS_TYPE.INFO, stdout);
                                         finalize(webp);
                                     }
                                     else {
-                                        errorResponse(err);
+                                        reject(err);
                                     }
                                 });
                             }
                             catch (err) {
-                                if (this.checkPackage(err, 'gif2webp-bin@3', 2048)) {
+                                if (this.checkPackage(err, 'gif2webp-bin', 2048)) {
                                     resolve();
                                 }
                                 else {
-                                    errorResponse(err);
+                                    reject(err);
                                 }
                             }
                         }
@@ -913,20 +915,20 @@ class Jimp extends Image {
                                     }
                                     GifUtil.write(output, frames, gif)
                                         .then(() => {
-                                        transformWebP(output, true);
+                                        void transformWebP(output, true);
                                     })
-                                        .catch(errorResponse);
+                                        .catch(reject);
                                 })
-                                    .catch(errorResponse);
+                                    .catch(reject);
                             })
-                                .catch(errorResponse);
+                                .catch(reject);
                         }
                         catch (err) {
-                            errorResponse(err);
+                            reject(err);
                         }
                     }
                     else {
-                        transformWebP(localUri, false);
+                        void transformWebP(localUri, false);
                     }
                 }
                 else {
@@ -983,10 +985,10 @@ class Jimp extends Image {
                                             .then(() => {
                                             finalize(output);
                                         })
-                                            .catch(errorResponse);
+                                            .catch(reject);
                                     }
                                     catch (err) {
-                                        errorResponse(err);
+                                        reject(err);
                                     }
                                 }
                                 else {
@@ -1008,12 +1010,12 @@ class Jimp extends Image {
                                             .then(() => {
                                             finalize(output);
                                         })
-                                            .catch(errorResponse);
+                                            .catch(reject);
                                     })
-                                        .catch(errorResponse);
+                                        .catch(reject);
                                 }
                             })
-                                .catch(errorResponse);
+                                .catch(reject);
                         }
                         else {
                             resolve();
@@ -1024,7 +1026,7 @@ class Jimp extends Image {
                         if (WEBPMUX_INIT) {
                             this.writeFail(["Unknown", 'node-webpmux'], err, { type: 2048, startTime });
                         }
-                        else if (this.checkPackage(err, 'node-webpmux@3', 2048)) {
+                        else if (this.checkPackage(err, 'node-webpmux', 2048)) {
                             resolve();
                             return true;
                         }
@@ -1035,7 +1037,7 @@ class Jimp extends Image {
                 const { path: webp_path } = settings.webp ||= {};
                 const bmpFile = getTempPath(this, 'bmp');
                 try {
-                    child_process.execFile((0, util_1.getWebP_bin)('dwebp', webp_path), [(0, util_1.normalizePath)(localUri), '-bmp', '-o', (0, util_1.normalizePath)(bmpFile)], { shell: true, signal: this.signal, ...execOptions(settings) }, err => {
+                    child_process.execFile(await (0, util_1.importBinary)('dwebp', webp_path), [(0, util_1.normalizePath)(localUri), '-bmp', '-o', (0, util_1.normalizePath)(bmpFile)], { shell: true, signal: this.signal, ...execOptions(settings) }, err => {
                         if (!err) {
                             transformBuffer(bmpFile);
                         }
@@ -1043,7 +1045,7 @@ class Jimp extends Image {
                             removeFile(bmpFile);
                             void tryWebpMux().then(valid => {
                                 if (!valid) {
-                                    errorResponse(err);
+                                    reject(err);
                                 }
                             });
                         }
@@ -1051,11 +1053,11 @@ class Jimp extends Image {
                 }
                 catch (err) {
                     if (!await tryWebpMux()) {
-                        if (this.checkPackage(err, 'dwebp-bin@1', 2048)) {
+                        if (this.checkPackage(err, 'dwebp-bin', 2048)) {
                             resolve();
                         }
                         else {
-                            errorResponse(err);
+                            reject(err);
                         }
                     }
                 }

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@pi-r/jimp",
-  "version": "0.9.3",
+  "version": "0.10.0",
   "description": "Jimp V0 image constructor for E-mc.",
   "main": "index.js",
+  "types": "index.d.ts",
   "publishConfig": {
     "access": "public"
   },
@@ -19,8 +20,8 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/image": "^0.11.4",
-    "@e-mc/types": "^0.11.4",
+    "@e-mc/image": "^0.12.0",
+    "@e-mc/types": "^0.12.0",
     "bmp-js": "^0.1.0",
     "gifwrap": "^0.10.1",
     "jimp": "^0.22.12"

package/types/index.d.ts

@@ -19,8 +19,7 @@ export interface JimpSettings extends ImageSettings {
 
 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>> {
-    method(): Promise<void>;
+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>;
     background(value: number | [number, number, number, number]): void;

package/util.d.ts

@@ -2,7 +2,9 @@ declare namespace util {
     function parseFormat(command: string, mimeType?: string, gif?: boolean): [string, string, string];
     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

@@ -4,27 +4,27 @@ exports.parseFormat = parseFormat;
 exports.renameExt = renameExt;
 exports.normalizePath = normalizePath;
 exports.getWebP_bin = getWebP_bin;
+exports.importBinary = importBinary;
 exports.showInputType = showInputType;
 exports.showOutputType = showOutputType;
 const path = require("node:path");
 const fs = require("node:fs");
-const jimp = require("jimp");
 const types = require("@e-mc/types");
 const Image = require("@e-mc/image");
 exports.MIME_INPUT = new Set([
-    jimp.MIME_PNG,
-    jimp.MIME_JPEG,
-    jimp.MIME_BMP,
-    jimp.MIME_GIF,
-    jimp.MIME_TIFF,
-    "image/webp"
+    Image.MIME_PNG,
+    Image.MIME_JPEG,
+    Image.MIME_BMP,
+    Image.MIME_GIF,
+    Image.MIME_TIFF,
+    Image.MIME_WEBP
 ]);
 exports.MIME_OUTPUT = new Set([
-    jimp.MIME_PNG,
-    jimp.MIME_JPEG,
-    jimp.MIME_BMP,
-    jimp.MIME_GIF,
-    "image/webp"
+    Image.MIME_PNG,
+    Image.MIME_JPEG,
+    Image.MIME_BMP,
+    Image.MIME_GIF,
+    Image.MIME_WEBP
 ]);
 function parseFormat(command, mimeType, gif) {
     command = command.toLowerCase();
@@ -38,21 +38,17 @@ function parseFormat(command, mimeType, gif) {
                         saveAs = 'jpg';
                         break;
                     case 'webp':
-                        if (mimeType === jimp.MIME_JPEG) {
-                            mime = jimp.MIME_JPEG;
+                        if (mimeType === Image.MIME_JPEG) {
+                            mime = Image.MIME_JPEG;
                             saveAs = 'jpg';
                         }
-                        else if (gif && mimeType === jimp.MIME_GIF) {
-                            mime = jimp.MIME_GIF;
+                        else if (gif && mimeType === Image.MIME_GIF) {
+                            mime = Image.MIME_GIF;
                             saveAs = 'gif';
                         }
-                        else if (mimeType === jimp.MIME_PNG) {
-                            mime = jimp.MIME_PNG;
-                            saveAs = 'png';
-                        }
                         else {
-                            mime = jimp.MIME_BMP;
-                            saveAs = 'bmp';
+                            mime = Image.MIME_PNG;
+                            saveAs = 'png';
                         }
                         outputAs = 'webp';
                         break;
@@ -84,10 +80,18 @@ function getWebP_bin(name, pathname) {
     if (pathname && fs.existsSync(pathname)) {
         name += Image.PLATFORM_WIN32 ? '.exe' : '';
         const bin = path.join(pathname, name);
-        return Image.sanitizeCmd(fs.existsSync(bin) ? bin : path.join(pathname, 'bin', name));
+        return types.sanitizeCmd(fs.existsSync(bin) ? bin : path.join(pathname, 'bin', name));
     }
     return require(name + '-bin');
 }
+async function importBinary(name, pathname) {
+    if (pathname && fs.existsSync(pathname)) {
+        name += Image.PLATFORM_WIN32 ? '.exe' : '';
+        const bin = path.join(pathname, name);
+        return Image.sanitizeCmd(fs.existsSync(bin) ? bin : path.join(pathname, 'bin', name));
+    }
+    return types.importESM(name + '-bin', true);
+}
 function showInputType(value, outputType, outputAs) {
     if (outputAs) {
         outputType = 'image/' + outputAs;