@pi-r/jimp 0.7.2 → 0.8.0

package/index.js

@@ -5,12 +5,13 @@ const child_process = require("child_process");
 const jimp = require("jimp");
 const gifwrap = require("gifwrap");
 const bmp = require("bmp-js");
+const crypto_1 = require("crypto");
 const types_1 = require("@e-mc/types");
 const Image = require('@e-mc/image');
 let WEBPMUX = null, WEBPMUX_INIT = false;
 try {
     WEBPMUX = require('node-webpmux');
-    new WEBPMUX.Image().initLib().then(() => WEBPMUX_INIT = true);
+    void new WEBPMUX.Image().initLib().then(() => WEBPMUX_INIT = true);
 }
 catch {
 }
@@ -80,9 +81,9 @@ function getMethodName(value) {
     }
 }
 async function performCommand(host, instance, localUri, command, outputType, finalAs, buffer, parent) {
-    return jimp.read((buffer || localUri))
+    return await jimp.read((buffer || localUri))
         .then(async (img) => {
-        return transformCommand(localUri, new JimpHandler(img, instance, host), command, outputType, finalAs, parent);
+        return await transformCommand(localUri, new JimpHandler(img, instance, host), command, outputType, finalAs, parent);
     });
 }
 function execOptions(settings) {
@@ -129,7 +130,7 @@ async function transformCommand(localFile, handler, command, outputType, outputA
             });
     }
 }
-function setImageCache(tempKey, tempFile, output, localFile) {
+function setImageCache(instance, tempKey, tempFile, output, localFile) {
     try {
         if (typeof output === 'string') {
             fs.copyFileSync(output, tempFile);
@@ -137,7 +138,7 @@ function setImageCache(tempKey, tempFile, output, localFile) {
         else {
             fs.writeFileSync(tempFile, output);
         }
-        const stored = getCacheData.call(this);
+        const stored = getCacheData(instance);
         if (localFile) {
             const { ctimeMs, mtimeMs, size } = fs.statSync(localFile);
             stored[tempKey] = { tempKey, tempFile, ctimeMs, localFile, mtimeMs, size };
@@ -145,7 +146,7 @@ function setImageCache(tempKey, tempFile, output, localFile) {
         else {
             stored[tempKey] = { tempKey, tempFile, ctimeMs: Date.now() };
         }
-        if (this.settings.jimp.cache_expires) {
+        if (instance.settings.jimp.cache_expires) {
             fs.writeFile(tempFile + '.json', JSON.stringify(stored[tempKey]), 'utf-8', () => { });
         }
     }
@@ -153,8 +154,8 @@ function setImageCache(tempKey, tempFile, output, localFile) {
         TEMP_DIR = '';
     }
 }
-function getImageCache(tempKey) {
-    const stored = getCacheData.call(this);
+function getImageCache(instance, tempKey) {
+    const stored = getCacheData(instance);
     const data = stored[tempKey];
     if (data) {
         const { tempFile, localFile, ctimeMs, mtimeMs, size } = data;
@@ -173,13 +174,13 @@ function getImageCache(tempKey) {
         removeFile(tempFile);
         delete stored[tempKey];
     }
-    TEMP_DIR ||= this.getTempDir({ moduleDir: true, increment: 5 });
-    return [null, TEMP_DIR ? path.join(TEMP_DIR, (0, types_1.generateUUID)()) : ''];
+    TEMP_DIR ||= instance.getTempDir({ moduleDir: true, increment: 5 });
+    return [null, TEMP_DIR ? path.join(TEMP_DIR, (0, crypto_1.randomUUID)()) : ''];
 }
-function getCacheData() {
+function getCacheData(instance) {
     if (!CACHE_INIT) {
-        TEMP_DIR = this.getTempDir({ moduleDir: true, increment: 5 });
-        const settings = this.settings.jimp ||= {};
+        TEMP_DIR = instance.getTempDir({ moduleDir: true, increment: 5 });
+        const settings = instance.settings.jimp ||= {};
         const expires = (0, types_1.parseExpires)(settings.cache_expires || 0);
         if (expires === 0) {
             settings.cache_expires = 0;
@@ -218,19 +219,22 @@ function getCacheData() {
     }
     return CACHE_TRANSFORM;
 }
-function formatMessage(value, startTime, failed, cTimeMs) {
+function formatMessage(instance, value, startTime, failed, cTimeMs) {
     if (cTimeMs) {
-        this.formatMessage(2048, "jimp", [value, 'cache'], new Date(cTimeMs).toLocaleString(), { ...Image.LOG_STYLE_NOTICE, hintBold: true });
+        instance.formatMessage(2048, "jimp", [value, 'cache'], new Date(cTimeMs).toLocaleString(), { ...Image.LOG_STYLE_NOTICE, hintBold: true });
     }
     else if (startTime) {
-        this.writeTimeProcess("jimp", value, startTime, { type: 2048, failed });
+        instance.writeTimeProcess("jimp", value, startTime, { type: 2048, failed });
     }
 }
-function getTempPath(ext) {
-    const tempDir = TEMP_DIR || this.getTempDir({ moduleDir: true, createDir: true }) || this.getTempDir();
-    return path.join(tempDir, (0, types_1.generateUUID)() + '.' + ext);
+function getTempPath(instance, ext) {
+    const tempDir = TEMP_DIR || instance.getTempDir({ moduleDir: true, createDir: true }) || instance.getTempDir();
+    return path.join(tempDir, (0, crypto_1.randomUUID)() + '.' + ext);
 }
-const removeFile = (pathname) => fs.unlink(pathname, () => { });
+function removeFile(pathname) {
+    fs.unlink(pathname, () => { });
+}
+const emptyResult = (options) => (options.tempFile ? '' : null);
 class JimpHandler {
     handler;
     instance;
@@ -264,14 +268,18 @@ class JimpHandler {
                     const img = handler.clone().rotate(value);
                     const output = leading + value + ext;
                     tasks.push(img.writeAsync(output)
-                        .then(() => this.finalize(output, callback))
-                        .catch((err) => this.instance.writeFail(["Unable to rotate image", "jimp"], err, 2048)));
+                        .then(() => {
+                        this.finalize(output, callback);
+                    })
+                        .catch((err) => {
+                        this.instance.writeFail(["Unable to rotate image", "jimp"], err, 2048);
+                    }));
                 }
             }
             if (deg) {
                 handler.rotate(deg);
             }
-            if (tasks.length) {
+            if (tasks.length > 0) {
                 return Promise.all(tasks).then(() => this);
             }
         }
@@ -440,7 +448,11 @@ class JimpHandler {
                     else if (webp !== output) {
                         const tempFile = output;
                         queueMicrotask(() => {
-                            fs.unlink(tempFile, error => !error && fs.rmdir(path.dirname(tempFile), () => { }));
+                            fs.unlink(tempFile, error => {
+                                if (!error) {
+                                    fs.rmdir(path.dirname(tempFile), () => { });
+                                }
+                            });
                         });
                         output = filename;
                     }
@@ -462,7 +474,7 @@ class JimpHandler {
     }
     async getBuffer(tempFile, saveAs) {
         const empty = () => tempFile ? '' : null;
-        const output = getTempPath.call(this.instance, this.instance.outputAs || (saveAs && util_1.MIME_OUTPUT.has('image/' + (saveAs === 'jpg' ? 'jpeg' : saveAs)) ? saveAs : this.handler.getMIME().split('/').pop()));
+        const output = getTempPath(this.instance, this.instance.outputAs || (saveAs && util_1.MIME_OUTPUT.has('image/' + (saveAs === 'jpg' ? 'jpeg' : saveAs)) ? saveAs : this.handler.getMIME().split('/').pop()));
         return !output ? empty() : new Promise(resolve => {
             this.handler.write(output, error => {
                 if (error) {
@@ -484,7 +496,13 @@ class JimpHandler {
                             this.instance.writeFail(["Unable to read file", path.basename(result)], err, 32);
                             resolve(null);
                         }
-                        queueMicrotask(() => fs.unlink(result, err => !err && this.instance.emit('file:delete', result)));
+                        finally {
+                            fs.unlink(result, err => {
+                                if (!err) {
+                                    this.instance.emit('file:delete', result);
+                                }
+                            });
+                        }
                     }
                 });
             });
@@ -541,7 +559,9 @@ class JimpHandler {
             return;
         }
         return this.handler.writeAsync(output)
-            .then(() => this.finalize(output, callback))
+            .then(() => {
+            this.finalize(output, callback);
+        })
             .catch((err) => {
             if (callback) {
                 callback(err, '');
@@ -564,24 +584,23 @@ class JimpHandler {
 class Jimp extends Image {
     static async transform(file, command, options = {}) {
         const [outputType, saveAs, finalAs] = (0, util_1.parseFormat)(command = command.trim(), options.mimeType);
-        const empty = () => options.tempFile ? '' : null;
         if (!outputType) {
-            return empty();
+            return emptyResult(options);
         }
         const instance = new Jimp(options.module);
         let buffer = null;
         if (Buffer.isBuffer(file)) {
             const tempDir = TEMP_DIR || instance.getTempDir();
             if (!this.createDir(tempDir)) {
-                return empty();
+                return emptyResult(options);
             }
             try {
                 const { ext } = await this.resolveMime(file) || { ext: 'unknown' };
                 buffer = file;
-                fs.writeFileSync(file = path.join(tempDir, (0, types_1.generateUUID)() + '.' + ext), buffer);
+                fs.writeFileSync(file = path.join(tempDir, (0, crypto_1.randomUUID)() + '.' + ext), buffer);
             }
             catch {
-                return empty();
+                return emptyResult(options);
             }
             options.cache = false;
         }
@@ -600,13 +619,13 @@ class Jimp extends Image {
         }
         const writeMessage = (failed, cTimeMs) => {
             if (cTimeMs || options.startTime) {
-                formatMessage.call(instance, filename + (0, util_1.showOutputType)(options.mimeType, outputType, finalAs), options.startTime, failed, cTimeMs);
+                formatMessage(instance, filename + (0, util_1.showOutputType)(options.mimeType, outputType, finalAs), options.startTime, failed, cTimeMs);
             }
         };
         let tempKey, tempFile;
         if (options.cache) {
             let ctimeMs;
-            [buffer, tempFile, ctimeMs] = getImageCache.call(instance, tempKey = file + command + (options.mimeType || ''));
+            [buffer, tempFile, ctimeMs] = getImageCache(instance, tempKey = file + command + (options.mimeType || ''));
             if (buffer) {
                 writeMessage(false, ctimeMs);
                 return buffer;
@@ -620,12 +639,18 @@ class Jimp extends Image {
             instance.flushLog();
             writeMessage(!result || instance.errors.length > 0);
             if (result && tempKey && tempFile) {
-                setImageCache.call(instance, tempKey, tempFile, result, file);
+                setImageCache(instance, tempKey, tempFile, result, file);
             }
             return result;
         })
-            .catch(() => empty())
-            .finally(() => buffer && !options.cache && removeFile(file));
+            .catch(() => {
+            return emptyResult(options);
+        })
+            .finally(() => {
+            if (buffer && !options.cache) {
+                removeFile(file);
+            }
+        });
     }
     _moduleName = "jimp";
     _threadable = true;
@@ -697,13 +722,13 @@ class Jimp extends Image {
                 if (replace && file.localUri !== output && !host.assets.find(item => item.localUri === output && !item.invalid)) {
                     host.filesToRemove.add(output);
                 }
-                formatMessage.call(this, (0, util_1.showInputType)(mimeType, outputType, finalAs) + filename, startTime, false, ctimeMs);
+                formatMessage(this, (0, util_1.showInputType)(mimeType, outputType, finalAs) + filename, startTime, false, ctimeMs);
                 resolve();
             };
             let tempKey, tempFile;
             if (this.settings.cache && (file.etag || file.buffer)) {
                 let buffer, ctimeMs;
-                [buffer, tempFile] = getImageCache.call(this, tempKey = (file.etag || Image.asHash(file.buffer)) + command + mimeType);
+                [buffer, tempFile] = getImageCache(this, tempKey = (file.etag || Image.asHash(file.buffer)) + command + mimeType);
                 if (buffer) {
                     const result = finalAs === 'webp' ? (0, util_1.renameExt)(output, 'webp', replace) : output;
                     fs.writeFileSync(result, file.buffer = buffer);
@@ -713,7 +738,7 @@ class Jimp extends Image {
             }
             const finalize = (value) => {
                 if (tempFile && tempKey) {
-                    setImageCache.call(this, tempKey, tempFile, value);
+                    setImageCache(this, tempKey, tempFile, value);
                 }
                 if (replace) {
                     delete file.buffer;
@@ -737,8 +762,12 @@ class Jimp extends Image {
                             const frame = new GifFrame(img.handler.bitmap);
                             GifUtil.quantizeSorokin(frame, 256);
                             GifUtil.write(output, [frame])
-                                .then(() => finalize(output))
-                                .catch((err) => errorResponse(err));
+                                .then(() => {
+                                finalize(output);
+                            })
+                                .catch((err) => {
+                                errorResponse(err);
+                            });
                         }
                         catch (err) {
                             errorResponse(err);
@@ -771,7 +800,9 @@ class Jimp extends Image {
                 }
             };
             const hasTransform = (cmd) => !!(cmd.rotate || cmd.opacity >= 0 && cmd.opacity < 1 || cmd.resize || cmd.crop || cmd.method);
-            const startMessage = () => host.formatMessage(2048, "jimp", ["Transforming image...", path.basename(localUri)], command);
+            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);
@@ -864,12 +895,20 @@ class Jimp extends Image {
                                         frames[i].bitmap = img.bitmap;
                                     }
                                     GifUtil.write(output, frames, gif)
-                                        .then(() => transformWebP(output, true))
-                                        .catch((err) => errorResponse(err));
+                                        .then(() => {
+                                        transformWebP(output, true);
+                                    })
+                                        .catch((err) => {
+                                        errorResponse(err);
+                                    });
                                 })
-                                    .catch((err) => errorResponse(err));
+                                    .catch((err) => {
+                                    errorResponse(err);
+                                });
                             })
-                                .catch((err) => errorResponse(err));
+                                .catch((err) => {
+                                errorResponse(err);
+                            });
                         }
                         catch (err) {
                             errorResponse(err);
@@ -917,8 +956,12 @@ class Jimp extends Image {
                                             frames[i] = new GifFrame(new BitmapImage(img), { xOffset: x, yOffset: y, delayCentisecs: delay / 10 });
                                         }
                                         GifUtil.write(output, frames, { loops: webp.anim.loops })
-                                            .then(() => finalize(output))
-                                            .catch((err) => errorResponse(err));
+                                            .then(() => {
+                                            finalize(output);
+                                        })
+                                            .catch((err) => {
+                                            errorResponse(err);
+                                        });
                                     }
                                     catch (err) {
                                         errorResponse(err);
@@ -940,13 +983,21 @@ class Jimp extends Image {
                                     Promise.all(frames)
                                         .then(() => {
                                         webp.save(output, { width: w, height: h, bgColor: cmd.rotate ? [0, 0, 0, 0] : undefined })
-                                            .then(() => finalize(output))
-                                            .catch((err) => errorResponse(err));
+                                            .then(() => {
+                                            finalize(output);
+                                        })
+                                            .catch((err) => {
+                                            errorResponse(err);
+                                        });
                                     })
-                                        .catch((err) => errorResponse(err));
+                                        .catch((err) => {
+                                        errorResponse(err);
+                                    });
                                 }
                             })
-                                .catch((err) => errorResponse(err));
+                                .catch((err) => {
+                                errorResponse(err);
+                            });
                         }
                         else {
                             resolve();
@@ -966,7 +1017,7 @@ class Jimp extends Image {
                 };
                 const settings = this.settings;
                 const { path: webp_path } = settings.webp ||= {};
-                const bmpFile = getTempPath.call(this, 'bmp');
+                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 => {
                         if (!err) {
@@ -974,7 +1025,11 @@ class Jimp extends Image {
                         }
                         else {
                             removeFile(bmpFile);
-                            tryWebpMux().then(valid => !valid && errorResponse(err));
+                            void tryWebpMux().then(valid => {
+                                if (!valid) {
+                                    errorResponse(err);
+                                }
+                            });
                         }
                     });
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/jimp",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Jimp image constructor for E-mc.",
   "main": "index.js",
   "publishConfig": {
@@ -20,8 +20,8 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/image": "^0.9.4",
-    "@e-mc/types": "^0.9.4",
+    "@e-mc/image": "^0.10.0",
+    "@e-mc/types": "^0.10.0",
     "bmp-js": "^0.1.0",
     "gifwrap": "^0.10.1",
     "jimp": "^0.22.12"

package/types/index.d.ts

@@ -1,10 +1,23 @@
-import type { IHost, IImage, ImageConstructor } from '@e-mc/types/lib';
-import type { ImageModule } from '@e-mc/types/lib/settings';
+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 { 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';
 
+export interface JimpSettings extends ImageSettings {
+    jimp?: {
+        exec?: ExecAction;
+        cache_expires?: number | string;
+        rotate_clockwise?: boolean;
+    };
+}
+
+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>;
     rotate(localFile?: string, callback?: ResultCallback<string>): Promise<this>;
@@ -12,8 +25,8 @@ export interface IJimpHandler<T extends IHost = IHost, U extends ImageModule = I
     writeAsync(output: string, callback?: ResultCallback): Promise<void>;
 }
 
-export interface JimpImageConstructor extends ImageConstructor {
-    new(handler: jimp, instance: IImage, host?: Null<IHost>): IJimpHandler;
-}
-
-export type ResultCallback<T = unknown, U = void, V = unknown> = (err: V, result: T) => U;
+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 : Null<Buffer>>;
+    readonly prototype: IImage<T, V>;
+    new(module?: V, ...args: unknown[]): IImage<T, V>;
+}

package/util.js

@@ -1,5 +1,11 @@
 "use strict";
-exports.showOutputType = exports.showInputType = exports.getWebP_bin = exports.normalizePath = exports.renameExt = exports.parseFormat = exports.MIME_OUTPUT = exports.MIME_INPUT = void 0;
+exports.MIME_OUTPUT = exports.MIME_INPUT = void 0;
+exports.parseFormat = parseFormat;
+exports.renameExt = renameExt;
+exports.normalizePath = normalizePath;
+exports.getWebP_bin = getWebP_bin;
+exports.showInputType = showInputType;
+exports.showOutputType = showOutputType;
 const path = require("path");
 const fs = require("fs");
 const jimp = require("jimp");
@@ -52,7 +58,6 @@ function parseFormat(command, mimeType, gif) {
     }
     return ['', '', ''];
 }
-exports.parseFormat = parseFormat;
 function renameExt(output, ext, replace) {
     let result = (0, types_1.renameExt)(output.replace('.__copy__.', '.'), ext);
     if (!replace) {
@@ -64,31 +69,26 @@ function renameExt(output, ext, replace) {
     }
     return result;
 }
-exports.renameExt = renameExt;
 function normalizePath(value) {
     return '"' + value.replace(/"/g, '\\"') + '"';
 }
-exports.normalizePath = normalizePath;
 function getWebP_bin(name, pathname) {
     if (pathname && fs.existsSync(pathname)) {
-        name += process.platform === 'win32' ? '.exe' : '';
+        name += Image.PLATFORM_WIN32 ? '.exe' : '';
         const bin = path.join(pathname, name);
         return Image.sanitizeCmd(fs.existsSync(bin) ? bin : path.join(pathname, 'bin', name));
     }
     return require(name + '-bin');
 }
-exports.getWebP_bin = getWebP_bin;
 function showInputType(value, outputType, finalAs) {
     if (finalAs) {
         outputType = 'image/' + finalAs;
     }
     return value && outputType !== value ? value.split('/').pop() + ' -> ' : '';
 }
-exports.showInputType = showInputType;
 function showOutputType(value, outputType, finalAs) {
     if (finalAs) {
         outputType = 'image/' + finalAs;
     }
     return value !== outputType ? ' -> ' + outputType.split('/').pop() : '';
 }
-exports.showOutputType = showOutputType;