@pi-r/jimp 0.11.3 → 0.12.1

package/index.js

@@ -1,18 +1,17 @@
-'use strict';
+"use strict";
 
-var core = require('@e-mc/core');
-var types = require('@e-mc/types');
-
-const path = require("node:path");
-const fs = require("node:fs");
-const crypto = require("node:crypto");
-const child_process = require("node:child_process");
-const jimp = require("jimp");
-const jimp_utils = require("@jimp/utils");
-const gifwrap = require("gifwrap");
-const bmp = require("bmp-js");
+const path = require('node:path');
+const fs = require('node:fs');
+const child_process = require('node:child_process');
+const gifwrap = require('gifwrap');
+const { randomUUID } = require('node:crypto');
+const jimp = require('jimp');
+const { encode } = require('bmp-js');
+const { rgbaToInt } = require('@jimp/utils');
+const { WorkerChannel, WorkerGroup } = require('@e-mc/core');
 const Image = require('@e-mc/image');
-const util = require("@pi-r/jimp/util");
+const { ERR_CODE, createAbortError, errorMessage, errorValue, getTempDir, isErrorCode, isPlainObject, isString, parseExpires, sanitizeCmd } = require('@e-mc/types');
+const util = require('@pi-r/jimp/util');
 const kJimp = Symbol.for('jimp:constructor');
 let WEBPMUX = null, WEBPMUX_INIT = false;
 try {
@@ -23,7 +22,7 @@ catch {
 }
 const CACHE_TRANSFORM = {};
 const FONT_DATA = {};
-const WORKER_JIMP = core.WorkerChannel.create(path.join(__dirname, 'worker', 'jimp.js'), 'PIR_JIMP');
+const WORKER_JIMP = WorkerChannel.create(path.join(__dirname, 'worker', 'jimp.js'), 'PIR_JIMP');
 let CACHE_INIT = false;
 let TEMP_DIR = '';
 const METHOD_ALIAS = {
@@ -87,7 +86,7 @@ const METHOD_ALIAS = {
     });
 }
 function getMethodName(value) {
-    if (types.isString(value)) {
+    if (isString(value)) {
         if (value.length === 2) {
             value = value.toLowerCase();
             for (const alias in METHOD_ALIAS) {
@@ -110,7 +109,7 @@ async function performCommand(instance, buffer, command, outputType, outputAs, o
 function execOptions(settings) {
     const exec = settings.jimp?.exec;
     let uid, gid;
-    if (types.isPlainObject(exec)) {
+    if (isPlainObject(exec)) {
         let { uid: u, gid: g } = exec;
         if ((u = parseInt(u)) >= 0) {
             uid = u;
@@ -197,13 +196,13 @@ function getImageCache(instance, tempKey) {
         delete stored[tempKey];
     }
     setTempDir(instance);
-    return [null, path.join(TEMP_DIR, crypto.randomUUID())];
+    return [null, path.join(TEMP_DIR, randomUUID())];
 }
 function getCacheData(instance) {
     if (!CACHE_INIT) {
         setTempDir(instance);
         const settings = instance.settings.jimp ||= {};
-        const expires = types.parseExpires(settings.cache_expires || 0);
+        const expires = parseExpires(settings.cache_expires || 0);
         if (settings.worker) {
             let { min = -1, max = -1, expires: idleTimeout = 0 } = settings.worker;
             if ((min = Math.trunc(+min)) >= 0) {
@@ -212,7 +211,7 @@ function getCacheData(instance) {
             if ((max = Math.trunc(+max)) >= 0) {
                 WORKER_JIMP.max = max;
             }
-            if ((idleTimeout = types.parseExpires(idleTimeout)) > 0) {
+            if ((idleTimeout = parseExpires(idleTimeout)) > 0) {
                 WORKER_JIMP.idleTimeout = idleTimeout;
             }
         }
@@ -231,7 +230,7 @@ function getCacheData(instance) {
                             const pathname = path.join(TEMP_DIR, item.name);
                             try {
                                 const data = JSON.parse(fs.readFileSync(pathname, 'utf8'));
-                                if (types.isPlainObject(data) && fs.existsSync(data.tempFile)) {
+                                if (isPlainObject(data) && fs.existsSync(data.tempFile)) {
                                     if (data.ctimeMs + expires > current) {
                                         CACHE_TRANSFORM[data.tempKey] = data;
                                         return;
@@ -266,7 +265,7 @@ function formatMessage(instance, value, startTime, failed, worker = false, cTime
 }
 function getTempPath(instance, ext) {
     setTempDir(instance);
-    return path.join(TEMP_DIR, crypto.randomUUID() + '.' + ext);
+    return path.join(TEMP_DIR, randomUUID() + '.' + ext);
 }
 function rotateAnim(cmd) {
     const rotate = cmd.rotate;
@@ -275,16 +274,16 @@ function rotateAnim(cmd) {
     }
 }
 function setBackground(instance, args) {
-    instance.background = jimp_utils.rgbaToInt(...args);
+    instance.background = rgbaToInt(...args);
 }
 function removeFile(pathname) {
     fs.unlink(pathname, () => { });
 }
 function errorParameters(alias, value) {
-    throw types.errorMessage(alias, "Invalid parameters", JSON.stringify(value));
+    throw errorMessage(alias, "Invalid parameters", JSON.stringify(value));
 }
 function setTempDir(instance) {
-    TEMP_DIR ||= instance.getTempDir({ moduleDir: true, createDir: true }) || types.getTempDir(true, "jimp");
+    TEMP_DIR ||= instance.getTempDir({ moduleDir: true, createDir: true }) || getTempDir(true, "jimp");
 }
 const hasTransform = (cmd) => !!(cmd.rotate || cmd.resize || cmd.crop || cmd.method || typeof cmd.opacity === 'number' && cmd.opacity >= 0 && cmd.opacity < 1);
 const isUnsupported = (value) => value === Image.MIME_GIF || value === Image.MIME_WEBP;
@@ -309,7 +308,7 @@ class JimpHandler {
                 return;
             }
             Jimp.applyBackground(this.handler, data);
-            const leading = output.substring(0, output.lastIndexOf('.') + 1);
+            const leading = output.slice(0, output.lastIndexOf('.') + 1);
             const ext = path.extname(output);
             const tasks = [];
             for (let i = 0; i < data.values.length; i++) {
@@ -342,7 +341,7 @@ class JimpHandler {
                     const alias = getMethodName(name);
                     if (alias === 'composite') {
                         const [src, x, y, opts] = args;
-                        if (types.isString(src) && typeof x === 'number' && typeof y === 'number') {
+                        if (isString(src) && typeof x === 'number' && typeof y === 'number') {
                             this.handler.composite(await jimp.Jimp.read(src), x, y, opts);
                         }
                         else {
@@ -356,7 +355,7 @@ class JimpHandler {
                         }
                     }
                     else {
-                        throw types.errorValue("Invalid method name", name);
+                        throw errorValue("Invalid method name", name);
                     }
                 }
                 catch (err) {
@@ -375,7 +374,7 @@ class JimpHandler {
         }
     }
     background(value) {
-        this.handler.background = Array.isArray(value) ? jimp_utils.rgbaToInt(...value) : value;
+        this.handler.background = Array.isArray(value) ? rgbaToInt(...value) : value;
     }
     async finalize(output, callback, replace) {
         if (this.aborted) {
@@ -430,7 +429,7 @@ class JimpHandler {
             }
             args.push('-o', util.normalizePath(outFile));
             try {
-                child_process.execFile(types.sanitizeCmd(await util.importBinary('cwebp', webp.path), args), { shell: true, signal: this.instance.signal, ...execOptions(settings) }, err => {
+                child_process.execFile(sanitizeCmd(await util.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(outFile)], err, 2048);
                     }
@@ -518,7 +517,7 @@ class JimpHandler {
     async write(output, callback) {
         if (this.aborted) {
             if (callback) {
-                callback(types.createAbortError(), '');
+                callback(createAbortError(), '');
             }
             return;
         }
@@ -555,7 +554,7 @@ class Jimp extends Image {
                 setTempDir(instance);
                 const { mime, ext } = await this.resolveMime(file) || { ext: 'unknown' };
                 buffer = file;
-                fs.writeFileSync(file = path.join(TEMP_DIR, crypto.randomUUID() + '.' + ext), buffer);
+                fs.writeFileSync(file = path.join(TEMP_DIR, randomUUID() + '.' + ext), buffer);
                 if (mime) {
                     options.mimeType = mime;
                 }
@@ -575,7 +574,7 @@ class Jimp extends Image {
         const filename = path.basename(file);
         const broadcastId = options.broadcastId;
         if (broadcastId) {
-            if (types.isPlainObject(broadcastId)) {
+            if (isPlainObject(broadcastId)) {
                 instance.broadcastId = broadcastId.value;
                 if (broadcastId.stripAnsi === false) {
                     instance.supports('stripAnsi', false);
@@ -701,7 +700,7 @@ class Jimp extends Image {
     static applyMethod(instance, name, ...args) {
         const alias = getMethodName(name);
         if (!alias) {
-            throw types.errorValue("Invalid method name", name);
+            throw errorValue("Invalid method name", name);
         }
         switch (alias) {
             case 'background':
@@ -738,7 +737,7 @@ class Jimp extends Image {
                     case 'posterize':
                     case 'opacity':
                     case 'fade':
-                        if (types.isPlainObject(arg)) {
+                        if (isPlainObject(arg)) {
                             errorParameters(alias, args);
                         }
                         instance[alias](+arg);
@@ -748,8 +747,8 @@ class Jimp extends Image {
                         instance[alias](arg);
                         break;
                     case 'print':
-                        if (types.isPlainObject(arg)) {
-                            if (types.isString(arg.font)) {
+                        if (isPlainObject(arg)) {
+                            if (isString(arg.font)) {
                                 arg.font = FONT_DATA[arg.font];
                             }
                             instance.print(arg);
@@ -759,7 +758,7 @@ class Jimp extends Image {
                         }
                         break;
                     default:
-                        if (!types.isPlainObject(arg)) {
+                        if (!isPlainObject(arg)) {
                             errorParameters(alias, arg);
                         }
                         instance[alias](arg);
@@ -810,33 +809,33 @@ class Jimp extends Image {
     }
     async using(data, command) {
         if (this.aborted) {
-            return types.createAbortError(true);
+            return createAbortError(true);
         }
         return new Promise(async (resolve, reject) => {
             const { host, file } = data;
             const localUri = host.getLocalUri(data);
             const mimeType = host.getMimeType(data);
             if (!localUri || !util.MIME_INPUT.has(mimeType)) {
-                reject(types.errorValue("Unknown", !localUri ? 'URI' : 'MIME'));
+                reject(errorValue("Unknown", !localUri ? 'URI' : 'MIME'));
                 return;
             }
             if (!this.canRead(localUri, { ownPermissionOnly: true })) {
-                reject(types.errorValue("Not permitted to read file", localUri));
+                reject(errorValue("Not permitted to read file", localUri));
                 return;
             }
             const [outputType, saveAs, outputAs] = util.parseFormat(command = command.trim(), mimeType);
             if (!outputType) {
-                reject(types.errorValue("Invalid format", /^\w+/.exec(command)?.[0] || "Unknown"));
+                reject(errorValue("Invalid format", /^\w+/.exec(command)?.[0] || "Unknown"));
                 return;
             }
             const replace = command.includes('@');
             const output = host.addCopy(data.getObject({ command, outputType }), saveAs, replace);
             if (!output) {
-                reject(types.errorValue("Not able to copy file", outputType));
+                reject(errorValue("Not able to copy file", outputType));
                 return;
             }
             if (!this.canWrite(output, { ownPermissionOnly: true })) {
-                reject(types.errorValue("Not permitted to write file", output));
+                reject(errorValue("Not permitted to write file", output));
                 return;
             }
             const startTime = process.hrtime();
@@ -871,7 +870,7 @@ class Jimp extends Image {
             let tempKey, tempFile;
             if (this.settings.cache && (file.etag || file.buffer)) {
                 let buffer, ctimeMs;
-                [buffer, tempFile] = getImageCache(this, tempKey = (file.etag || Image.asHash(file.buffer)) + command + mimeType);
+                [buffer, tempFile, ctimeMs] = getImageCache(this, tempKey = (file.etag || Image.asHash(file.buffer)) + command + mimeType);
                 if (buffer) {
                     const result = outputAs === 'webp' ? util.renameExt(output, 'webp', replace) : output;
                     fs.writeFileSync(result, file.buffer = buffer);
@@ -916,7 +915,7 @@ class Jimp extends Image {
                             if (!err && result) {
                                 finalize(result);
                             }
-                            else if (types.isErrorCode(err, types.ERR_CODE.MODULE_NOT_FOUND)) {
+                            else if (isErrorCode(err, ERR_CODE.MODULE_NOT_FOUND)) {
                                 resolve();
                             }
                             else {
@@ -974,7 +973,7 @@ class Jimp extends Image {
                         }
                         args.push('-o', util.normalizePath(webp));
                         try {
-                            child_process.execFile(types.sanitizeCmd(await util.importBinary('gif2webp', webp_path), args), { shell: true, signal: this.signal, ...execOptions(this.settings) }, (err, stdout) => {
+                            child_process.execFile(sanitizeCmd(await util.importBinary('gif2webp', webp_path), args), { shell: true, signal: this.signal, ...execOptions(this.settings) }, (err, stdout) => {
                                 if (!err) {
                                     this.addLog(4, stdout);
                                     finalize(webp);
@@ -1008,7 +1007,7 @@ class Jimp extends Image {
                             .then(src => {
                             rotateAnim(outputData);
                             Promise.all(src.frames.map(async (frame) => {
-                                const bitmap = bmp.encode(frame.bitmap).data;
+                                const bitmap = encode(frame.bitmap).data;
                                 const instance = await jimp.Jimp.read(bitmap);
                                 const handler = new JimpHandler(instance, this);
                                 return transformCommand(output, handler, outputData, Image.MIME_GIF);
@@ -1062,7 +1061,7 @@ class Jimp extends Image {
                         await webp.load(host.getBuffer(file));
                         if (!(webp.hasAnim && (outputType === Image.MIME_WEBP || outputType === Image.MIME_GIF))) {
                             const buffer = Image.toABGR(await (!webp.hasAnim ? webp.getImageData() : webp.getFrameData(0)));
-                            const bitmap = bmp.encode({ width: webp.width, height: webp.height, data: buffer }).data;
+                            const bitmap = encode({ width: webp.width, height: webp.height, data: buffer }).data;
                             transformBuffer(bitmap);
                             return true;
                         }
@@ -1070,7 +1069,7 @@ class Jimp extends Image {
                             startMessage();
                             Promise.all(webp.frames.map(async (frame, index) => {
                                 const buffer = Image.toABGR(await webp.getFrameData(index));
-                                const bitmap = bmp.encode({ width: frame.width, height: frame.height, data: buffer }).data;
+                                const bitmap = encode({ width: frame.width, height: frame.height, data: buffer }).data;
                                 const instance = await jimp.Jimp.read(bitmap);
                                 const handler = new JimpHandler(instance, this);
                                 handler.background(webp.anim.bgColor);
@@ -1155,7 +1154,7 @@ class Jimp extends Image {
                 };
                 const bmpFile = getTempPath(this, 'bmp');
                 try {
-                    child_process.execFile(types.sanitizeCmd(await util.importBinary('dwebp', this.settings.webp?.path), [util.normalizePath(localUri), '-bmp', '-o', util.normalizePath(bmpFile)]), { shell: true, signal: this.signal, ...execOptions(this.settings) }, err => {
+                    child_process.execFile(sanitizeCmd(await util.importBinary('dwebp', this.settings.webp?.path), [util.normalizePath(localUri), '-bmp', '-o', util.normalizePath(bmpFile)]), { shell: true, signal: this.signal, ...execOptions(this.settings) }, err => {
                         if (!err) {
                             transformBuffer(bmpFile);
                         }
@@ -1181,11 +1180,11 @@ class Jimp extends Image {
                 }
             }
             else {
-                if (core.WorkerChannel.hasPermission(file) && this.parseWorker(outputData, outputType)) {
+                if (WorkerChannel.hasPermission(file) && this.parseWorker(outputData, outputType)) {
                     try {
                         let timer = null;
                         const failed = (message) => {
-                            reject(types.errorMessage("jimp", message, localUri));
+                            reject(errorMessage("jimp", message, localUri));
                         };
                         const worker = WORKER_JIMP.sendObject({ data: file.buffer || localUri, commandData: outputData, outputType, output, options: this.getEncodeOptions() }, [], (value) => {
                             if (timer) {
@@ -1203,7 +1202,7 @@ class Jimp extends Image {
                                 timer = setTimeout(() => {
                                     void worker.terminate();
                                     failed("Worker timeout was exceeded");
-                                }, core.WorkerGroup.checkTimeout(file.worker, true));
+                                }, WorkerGroup.checkTimeout(file.worker, true));
                             }
                             return;
                         }
@@ -1226,4 +1225,5 @@ class Jimp extends Image {
         return this.module.settings ||= {};
     }
 }
+
 module.exports = Jimp;

package/package.json

@@ -1,12 +1,9 @@
 {
   "name": "@pi-r/jimp",
-  "version": "0.11.3",
+  "version": "0.12.1",
   "description": "Jimp V1 image constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
-  "publishConfig": {
-    "access": "public"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anpham6/pi-r2.git",
@@ -20,9 +17,9 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r2#readme",
   "dependencies": {
-    "@e-mc/core": "^0.13.10",
-    "@e-mc/image": "^0.13.10",
-    "@e-mc/types": "^0.13.10",
+    "@e-mc/core": "^0.14.1",
+    "@e-mc/image": "^0.14.1",
+    "@e-mc/types": "^0.14.1",
     "@jimp/utils": "1.6.0",
     "bmp-js": "^0.1.0",
     "gifwrap": "^0.10.1",

package/util.js

@@ -1,9 +1,9 @@
-'use strict';
+"use strict";
 
-const path = require("node:path");
-const fs = require("node:fs");
-const types = require("@e-mc/types");
-const Image = require("@e-mc/image");
+const path = require('node:path');
+const fs = require('node:fs');
+const { importESM, renameExt: renameExt_ } = require('@e-mc/types');
+const Image = require('@e-mc/image');
 const MIME_INPUT = new Set([
     Image.MIME_PNG,
     Image.MIME_JPEG,
@@ -64,12 +64,12 @@ function detectExt(mimeType, webp) {
     }
 }
 function renameExt(output, ext, replace) {
-    let result = types.renameExt(output.replace('.__copy__.', '.'), ext);
+    let result = renameExt_(output.replace('.__copy__.', '.'), ext);
     if (!replace) {
         const pathname = result;
         let i = 0;
         while (Image.isPath(result)) {
-            result = pathname.substring(0, pathname.lastIndexOf('.') + 1) + `(${++i}).` + ext;
+            result = pathname.slice(0, pathname.lastIndexOf('.') + 1) + `(${++i}).` + ext;
         }
     }
     return result;
@@ -83,7 +83,7 @@ async function importBinary(name, pathname) {
         const bin = path.join(pathname, name);
         return fs.existsSync(bin) ? bin : path.join(pathname, 'bin', name);
     }
-    return types.importESM(name + '-bin', true);
+    return importESM(name + '-bin', true);
 }
 function showInputType(value, outputType, finalAs) {
     if (finalAs) {

package/worker/jimp.js

@@ -1,41 +1,40 @@
-'use strict';
+"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 { parentPort, workerData } = require('node:worker_threads');
+const { Jimp } = require('jimp');
+const Image = require('@e-mc/image');
+const { errorMessage, isString } = require('@e-mc/types');
+const Main = require('@pi-r/jimp');
+const PORT = workerData[0];
+parentPort.on('message', (value) => {
     const { data, commandData, output, options } = value;
-    jimp.Jimp.read(typeof data === 'string' ? data : Image.asBuffer(data))
+    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);
+                    if (isString(src) && typeof x === 'number' && typeof y === 'number') {
+                        img.composite(await Jimp.read(src), x, y, opts);
                     }
                     else {
-                        throw types.errorMessage(name, "Invalid parameters", JSON.stringify(value));
+                        throw errorMessage(name, "Invalid parameters", JSON.stringify(value));
                     }
                 }
                 else {
-                    JimpApp.applyMethod(img, name, ...args);
+                    Main.applyMethod(img, name, ...args);
                 }
             }
         }
         if (resize) {
-            JimpApp.applyResize(img, resize);
+            Main.applyResize(img, resize);
         }
         if (crop) {
-            JimpApp.applyCrop(img, crop);
+            Main.applyCrop(img, crop);
         }
         if (rotate) {
-            JimpApp.applyRotate(img, rotate);
+            Main.applyRotate(img, rotate);
         }
         if (opacity >= 0) {
             img.opacity(opacity);