@pi-r/jimp 0.3.0 → 0.3.2

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2023 An Pham
+Copyright 2023 Studio Trigger
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -1,5 +1,7 @@
-### @pi-r/jimp
+# @pi-r/jimp
 
-### LICENSE
+PEP 402 - Forever Aina
+
+## LICENSE
 
 MIT

package/index.js

@@ -8,7 +8,14 @@ const gifwrap = require("gifwrap");
 const bmp = require("bmp-js");
 const types_1 = require("@e-mc/types");
 const Image = require('@e-mc/image');
-const util_1 = require("./util");
+let WEBPMUX = null, WEBPMUX_INIT = false;
+try {
+    WEBPMUX = require('node-webpmux');
+    new WEBPMUX.Image().initLib().then(() => WEBPMUX_INIT = true);
+}
+catch {
+}
+const util_1 = require("@pi-r/jimp/util");
 const CACHE_TRANSFORM = {};
 let CACHE_INIT = false;
 let TEMP_DIR = '';
@@ -24,13 +31,16 @@ const METHOD_ALIAS = {
     composite: 'cp',
     mask: 'ma',
     convolute: 'cl',
+    convolution: 'cl',
     flip: 'fl',
     mirror: 'mi',
     rotate: 'ro',
     brightness: 'br',
     contrast: 'cn',
     dither565: 'dt',
+    dither16: 'dt',
     greyscale: 'gr',
+    grayscale: 'gr',
     invert: 'in',
     normalize: 'no',
     fade: 'fa',
@@ -43,7 +53,19 @@ const METHOD_ALIAS = {
     sepia: 'se',
     pixelate: 'px',
     displace: 'dp',
-    color: 'co'
+    color: 'co',
+    colour: 'co',
+    backgroundQuiet: 'bq',
+    circle: 'ci',
+    colorType: 'ce',
+    cropQuiet: 'cq',
+    deflateLevel: 'dl',
+    deflateStrategy: 'ds',
+    fishEye: 'fe',
+    filterType: 'ft',
+    rgba: 'rg',
+    shadow: 'sh',
+    threshold: 'th'
 };
 function getMethodName(value) {
     const name = value.toLowerCase();
@@ -98,9 +120,9 @@ async function transformCommand(localFile, handler, command, outputType, outputA
             return handler.rotate();
         default:
             return handler.rotate(localFile, (err, result) => {
-                if (!err) {
+                if (!err && handler.host?.moduleName === 'filemanager') {
                     try {
-                        handler.host?.add(result, parent);
+                        handler.host.add(result, parent);
                     }
                     catch {
                     }
@@ -200,10 +222,10 @@ function getCacheData() {
 }
 function formatMessage(value, startTime, failed, cTimeMs) {
     if (cTimeMs) {
-        this.formatMessage(2048 /* LOG_TYPE.IMAGE */, "jimp" /* STRINGS.MODULE_NAME */, [value, 'cache'], new Date(cTimeMs).toLocaleString(), { ...Image.LOG_STYLE_NOTICE, hintBold: true });
+        this.formatMessage(2048, "jimp", [value, 'cache'], new Date(cTimeMs).toLocaleString(), { ...Image.LOG_STYLE_NOTICE, hintBold: true });
     }
     else if (startTime) {
-        this.writeTimeProcess("jimp" /* STRINGS.MODULE_NAME */, value, startTime, { type: 2048 /* LOG_TYPE.IMAGE */, failed });
+        this.writeTimeProcess("jimp", value, startTime, { type: 2048, failed });
     }
 }
 function getTempPath(ext) {
@@ -243,7 +265,7 @@ class JimpHandler {
                     const output = leading + value + ext;
                     tasks.push(img.writeAsync(output)
                         .then(() => this.finalize(output, callback))
-                        .catch(err => this.instance.writeFail(["Unable to rotate image" /* ERR_IMAGE.ROTATE */, "jimp" /* STRINGS.MODULE_NAME */], err, 2048 /* LOG_TYPE.IMAGE */)));
+                        .catch(err => this.instance.writeFail(["Unable to rotate image", "jimp"], err, 2048)));
                 }
             }
             if (deg) {
@@ -268,7 +290,7 @@ class JimpHandler {
             try {
                 const alias = getMethodName(name);
                 if (!alias) {
-                    throw (0, types_1.errorValue)("Invalid method name" /* ERR_IMAGE.METHOD_NAME */, name);
+                    throw (0, types_1.errorValue)("Invalid method name", name);
                 }
                 if (alias === 'composite') {
                     const [src, x, y, opts] = args;
@@ -276,7 +298,7 @@ class JimpHandler {
                         handler.composite(await jimp.read(src), x, y, opts);
                     }
                     else {
-                        throw (0, types_1.errorValue)("Invalid parameters" /* ERR_MESSAGE.PARAMETERS */, alias);
+                        throw (0, types_1.errorValue)("Invalid parameters", alias);
                     }
                 }
                 else {
@@ -284,7 +306,7 @@ class JimpHandler {
                 }
             }
             catch (err) {
-                this.instance.writeFail(["Unknown" /* ERR_MESSAGE.UNKNOWN */, "jimp" /* STRINGS.MODULE_NAME */ + ': ' + name], err, 2048 /* LOG_TYPE.IMAGE */);
+                this.instance.writeFail(["Unknown", "jimp" + ': ' + name], err, 2048);
             }
         }
     }
@@ -415,7 +437,7 @@ class JimpHandler {
             try {
                 child_process.execFile((0, util_1.getWebP_bin)('cwebp', webp.path), args, { shell: true, signal: this.instance.signal, ...execOptions(settings) }, err => {
                     if (err) {
-                        this.instance.writeFail(["Unable to convert file" /* ERR_MESSAGE.CONVERT_FILE */, path.basename(filename)], err, 2048 /* LOG_TYPE.IMAGE */);
+                        this.instance.writeFail(["Unable to convert file", path.basename(filename)], err, 2048);
                     }
                     else if (webp !== output) {
                         const tempFile = output;
@@ -430,7 +452,7 @@ class JimpHandler {
                 });
             }
             catch (err) {
-                this.instance.checkPackage(err, 'cwebp-bin@6.1.2', "Unknown" /* ERR_MESSAGE.UNKNOWN */, { type: 2048 /* LOG_TYPE.IMAGE */, passThrough: !!callback });
+                this.instance.checkPackage(err, 'cwebp-bin@6.1.2', "Unknown", { type: 2048, passThrough: !!callback });
                 if (callback) {
                     callback(err, '');
                 }
@@ -461,7 +483,7 @@ class JimpHandler {
                             resolve(fs.readFileSync(result));
                         }
                         catch (err) {
-                            this.instance.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(result)], err, 32 /* LOG_TYPE.FILE */);
+                            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)));
@@ -527,7 +549,7 @@ class JimpHandler {
                 callback(err, '');
             }
             else {
-                this.instance.writeFail(["Unable to write file" /* ERR_MESSAGE.WRITE_FILE */, path.basename(output)], err, 2048 /* LOG_TYPE.IMAGE */);
+                this.instance.writeFail(["Unable to write file", path.basename(output)], err, 2048);
             }
         });
     }
@@ -541,11 +563,10 @@ class JimpHandler {
         return this.instance.rotateData?.values.length || 0;
     }
 }
-// @ts-ignore
 class Jimp extends Image {
     constructor() {
         super(...arguments);
-        this._moduleName = "jimp" /* STRINGS.MODULE_NAME */;
+        this._moduleName = "jimp";
         this._threadable = true;
     }
     static async transform(file, command, options = {}) {
@@ -598,7 +619,7 @@ class Jimp extends Image {
                 return Promise.resolve(buffer);
             }
         }
-        instance.formatMessage(Image.LOG_TYPE.IMAGE, "jimp" /* STRINGS.MODULE_NAME */, ["Transforming image..." /* STRINGS.TRANSFORM */, filename], command);
+        instance.formatMessage(Image.LOG_TYPE.IMAGE, "jimp", ["Transforming image...", filename], command);
         Image.initCpuUsage(instance);
         return performCommand(null, instance, file, command, outputType, finalAs)
             .then(async (handler) => {
@@ -632,26 +653,26 @@ class Jimp extends Image {
             const localUri = host.getLocalUri(data);
             const mimeType = host.getMimeType(data);
             if (!localUri || !util_1.MIME_INPUT.has(mimeType)) {
-                reject((0, types_1.errorValue)("Unknown" /* ERR_MESSAGE.UNKNOWN */, !localUri ? 'URI' : 'MIME'));
+                reject((0, types_1.errorValue)("Unknown", !localUri ? 'URI' : 'MIME'));
                 return;
             }
             if (!this.canRead(localUri, { ownPermissionOnly: true })) {
-                reject((0, types_1.errorValue)("Not permitted to read file" /* ERR_MESSAGE.UNSUPPORTED_READ */, localUri));
+                reject((0, types_1.errorValue)("Not permitted to read file", localUri));
                 return;
             }
             const [outputType, saveAs, finalAs] = (0, util_1.parseFormat)(command = command.trim(), mimeType, true);
             if (!outputType) {
-                reject((0, types_1.errorValue)("Invalid format" /* ERR_MESSAGE.FORMAT */, /^\w+/.exec(command)?.[0] || "Unknown" /* ERR_MESSAGE.UNKNOWN */));
+                reject((0, types_1.errorValue)("Invalid format", /^\w+/.exec(command)?.[0] || "Unknown"));
                 return;
             }
             const replace = command.indexOf('@') !== -1;
             const output = host.addCopy(data.getObject({ command, outputType }), saveAs, replace);
             if (!output) {
-                reject((0, types_1.errorValue)("Not able to copy file" /* ERR_MESSAGE.NOT_COPYABLE */, outputType));
+                reject((0, types_1.errorValue)("Not able to copy file", outputType));
                 return;
             }
             if (!this.canWrite(output, { ownPermissionOnly: true })) {
-                reject((0, types_1.errorValue)("Not permitted to write file" /* ERR_MESSAGE.UNSUPPORTED_WRITE */, output));
+                reject((0, types_1.errorValue)("Not permitted to write file", output));
                 return;
             }
             const startTime = process.hrtime();
@@ -712,7 +733,7 @@ class Jimp extends Image {
                         removeFile(bmpFile);
                     }
                     const errorResponse = (err) => {
-                        this.writeFail(["Unable to finalize image" /* ERR_IMAGE.FINALIZE */, "jimp" /* STRINGS.MODULE_NAME */], err, { type: 2048 /* LOG_TYPE.IMAGE */, startTime });
+                        this.writeFail(["Unable to finalize image", "jimp"], err, { type: 2048, startTime });
                         resolve();
                     };
                     if (outputType === jimp.MIME_GIF) {
@@ -734,18 +755,18 @@ class Jimp extends Image {
                                 finalize(result);
                             }
                             else {
-                                errorResponse(err || new Error("Unknown" /* ERR_MESSAGE.UNKNOWN */));
+                                errorResponse(err || new Error("Unknown"));
                             }
                         });
                     }
                 })
                     .catch(err => {
-                    this.writeFail(["Unable to read buffer" /* ERR_MESSAGE.READ_BUFFER */, path.basename(localUri)], err, { type: 2048 /* LOG_TYPE.IMAGE */, startTime });
+                    this.writeFail(["Unable to read buffer", path.basename(localUri)], err, { type: 2048, startTime });
                     resolve();
                 });
             };
             const errorResponse = (err) => {
-                this.writeFail(["Unable to convert file" /* ERR_MESSAGE.CONVERT_FILE */, path.basename(localUri)], err, { type: 2048 /* LOG_TYPE.IMAGE */, startTime });
+                this.writeFail(["Unable to convert file", path.basename(localUri)], err, { type: 2048, startTime });
                 resolve();
             };
             const rotateAnim = (cmd) => {
@@ -755,9 +776,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 /* LOG_TYPE.IMAGE */, "jimp" /* STRINGS.MODULE_NAME */, ["Transforming image..." /* STRINGS.TRANSFORM */, 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" /* STRINGS.MIME_WEBP */) {
+                if (outputType === jimp.MIME_GIF || outputType === "image/webp") {
                     const cmd = this.parseCommand(command);
                     const transformWebP = (target, modified) => {
                         var _a;
@@ -815,7 +836,7 @@ class Jimp extends Image {
                                 });
                             }
                             catch (err) {
-                                if (this.checkPackage(err, 'gif2webp-bin@3', 2048 /* LOG_TYPE.IMAGE */)) {
+                                if (this.checkPackage(err, 'gif2webp-bin@3', 2048)) {
                                     resolve();
                                 }
                                 else {
@@ -868,18 +889,16 @@ class Jimp extends Image {
                     transformBuffer();
                 }
             }
-            else if (mimeType === "image/webp" /* STRINGS.MIME_WEBP */) {
+            else if (mimeType === "image/webp") {
                 const tryWebpMux = async () => {
-                    let loaded;
                     try {
-                        const webp = new (require('node-webpmux').Image)();
-                        loaded = true;
-                        if (Image.supported(18, 1)) {
-                            this.formatMessage(2048 /* LOG_TYPE.IMAGE */, 'WARN', 'node-webpmux is not compatible with global fetch', 'NodeJS: --no-experimental-fetch', { ...Image.LOG_STYLE_WARN });
+                        const webp = new (WEBPMUX || (WEBPMUX = require('node-webpmux'))).Image();
+                        if (!WEBPMUX_INIT) {
+                            await webp.initLib();
+                            WEBPMUX_INIT = true;
                         }
-                        await webp.initLib();
                         await webp.load(host.getBuffer(file));
-                        if (!(webp.hasAnim && (outputType === "image/webp" /* STRINGS.MIME_WEBP */ || outputType === jimp.MIME_GIF))) {
+                        if (!(webp.hasAnim && (outputType === "image/webp" || outputType === jimp.MIME_GIF))) {
                             transformBuffer(bmp.encode({ width: webp.width, height: webp.height, data: Image.toABGR(await (!webp.hasAnim ? webp.getImageData() : webp.getFrameData(0))) }).data);
                             return true;
                         }
@@ -941,10 +960,10 @@ class Jimp extends Image {
                         return true;
                     }
                     catch (err) {
-                        if (loaded) {
-                            this.writeFail(["Unknown" /* ERR_MESSAGE.UNKNOWN */, 'node-webpmux'], err, { type: 2048 /* LOG_TYPE.IMAGE */, startTime });
+                        if (WEBPMUX_INIT) {
+                            this.writeFail(["Unknown", 'node-webpmux'], err, { type: 2048, startTime });
                         }
-                        else if (this.checkPackage(err, 'node-webpmux@3', 2048 /* LOG_TYPE.IMAGE */)) {
+                        else if (this.checkPackage(err, 'node-webpmux@3', 2048)) {
                             resolve();
                             return true;
                         }
@@ -967,7 +986,7 @@ class Jimp extends Image {
                 }
                 catch (err) {
                     if (!await tryWebpMux()) {
-                        if (this.checkPackage(err, 'dwebp-bin@1', 2048 /* LOG_TYPE.IMAGE */)) {
+                        if (this.checkPackage(err, 'dwebp-bin@1', 2048)) {
                             resolve();
                         }
                         else {
@@ -986,5 +1005,9 @@ class Jimp extends Image {
         return (_a = this.module).settings || (_a.settings = {});
     }
 }
+exports.default = Jimp;
 
-module.exports = Jimp;
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/jimp",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Jimp image constructor for E-mc.",
   "main": "index.js",
   "publishConfig": {
@@ -8,7 +8,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/anpham6/pi-r.git",
+    "url": "git+https://github.com/anpham6/pi-r.git",
     "directory": "src/module/jimp"
   },
   "keywords": [
@@ -20,10 +20,10 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/image": "^0.6.0",
-    "@e-mc/types": "^0.6.0",
+    "@e-mc/image": "^0.6.1",
+    "@e-mc/types": "^0.6.1",
     "bmp-js": "^0.1.0",
     "gifwrap": "^0.10.1",
-    "jimp": "^0.22.10"
+    "jimp": "^0.22.12"
   }
 }

package/util.js

@@ -6,8 +6,8 @@ const fs = require("fs");
 const jimp = require("jimp");
 const types_1 = 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" /* STRINGS.MIME_WEBP */]);
-exports.MIME_OUTPUT = new Set([jimp.MIME_PNG, jimp.MIME_JPEG, jimp.MIME_BMP, jimp.MIME_GIF, "image/webp" /* STRINGS.MIME_WEBP */]);
+exports.MIME_INPUT = new Set([jimp.MIME_PNG, jimp.MIME_JPEG, jimp.MIME_BMP, jimp.MIME_GIF, jimp.MIME_TIFF, "image/webp"]);
+exports.MIME_OUTPUT = new Set([jimp.MIME_PNG, jimp.MIME_JPEG, jimp.MIME_BMP, jimp.MIME_GIF, "image/webp"]);
 function parseFormat(command, mimeType, gif) {
     command = command.toLowerCase();
     for (let mime of exports.MIME_OUTPUT) {
@@ -20,10 +20,10 @@ function parseFormat(command, mimeType, gif) {
                         saveAs = 'jpg';
                         break;
                     case 'webp':
-                        if (mimeType === "image/webp" /* STRINGS.MIME_WEBP */) {
+                        if (mimeType === "image/webp") {
                             try {
                                 require('node-webpmux');
-                                mime = "image/webp" /* STRINGS.MIME_WEBP */;
+                                mime = "image/webp";
                                 break;
                             }
                             catch {