@pi-r/jimp 0.2.2 → 0.3.1

package/index.js

@@ -24,13 +24,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 +46,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();
@@ -64,6 +79,20 @@ function performCommand(host, instance, localUri, command, outputType, finalAs,
         return transformCommand(localUri, new JimpHandler(img, instance, host), command, outputType, finalAs, parent);
     });
 }
+function execOptions(settings) {
+    const exec = settings.jimp?.exec;
+    let uid, gid;
+    if ((0, types_1.isPlainObject)(exec)) {
+        let { uid: u, gid: g } = exec;
+        if ((u = parseInt(u)) >= 0) {
+            uid = u;
+        }
+        if ((g = parseInt(g)) >= 0) {
+            gid = g;
+        }
+    }
+    return { uid, gid };
+}
 async function transformCommand(localFile, handler, command, outputType, outputAs, parent) {
     if (command) {
         handler.instance.setCommand(command, outputAs);
@@ -71,14 +100,12 @@ async function transformCommand(localFile, handler, command, outputType, outputA
     await handler.method();
     handler.resize();
     handler.crop();
-    if (outputType === jimp.MIME_JPEG) {
-        if (!outputAs) {
-            handler.quality();
-        }
-    }
-    else {
+    if (outputType !== jimp.MIME_JPEG) {
         handler.opacity();
     }
+    else if (!outputAs) {
+        handler.quality();
+    }
     switch (handler.rotateCount) {
         case 0:
             return handler;
@@ -86,9 +113,9 @@ async function transformCommand(localFile, handler, command, outputType, outputA
             return handler.rotate();
         default:
             return handler.rotate(localFile, (err, result) => {
-                if (!err && handler.host) {
+                if (!err) {
                     try {
-                        handler.host.add(result, parent);
+                        handler.host?.add(result, parent);
                     }
                     catch {
                     }
@@ -248,31 +275,32 @@ class JimpHandler {
             return;
         }
         const data = this.instance.methodData;
-        if (data) {
-            const handler = this.handler;
-            for (const [name, args = []] of data) {
-                try {
-                    const alias = getMethodName(name);
-                    if (!alias) {
-                        throw (0, types_1.errorValue)("Invalid method name" /* ERR_IMAGE.METHOD_NAME */, name);
-                    }
-                    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);
-                        }
-                        else {
-                            throw (0, types_1.errorValue)("Invalid parameters" /* ERR_MESSAGE.PARAMETERS */, alias);
-                        }
+        if (!data) {
+            return;
+        }
+        const handler = this.handler;
+        for (const [name, args = []] of data) {
+            try {
+                const alias = getMethodName(name);
+                if (!alias) {
+                    throw (0, types_1.errorValue)("Invalid method name" /* ERR_IMAGE.METHOD_NAME */, name);
+                }
+                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);
                     }
                     else {
-                        handler[alias](...args);
+                        throw (0, types_1.errorValue)("Invalid parameters" /* ERR_MESSAGE.PARAMETERS */, alias);
                     }
                 }
-                catch (err) {
-                    this.instance.writeFail(["Unknown" /* ERR_MESSAGE.UNKNOWN */, "jimp" /* STRINGS.MODULE_NAME */ + ': ' + name], err, 2048 /* LOG_TYPE.IMAGE */);
+                else {
+                    handler[alias](...args);
                 }
             }
+            catch (err) {
+                this.instance.writeFail(["Unknown" /* ERR_MESSAGE.UNKNOWN */, "jimp" /* STRINGS.MODULE_NAME */ + ': ' + name], err, 2048 /* LOG_TYPE.IMAGE */);
+            }
         }
     }
     resize() {
@@ -280,63 +308,64 @@ class JimpHandler {
             return;
         }
         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;
-            }
-            switch (align[0]) {
-                case 'left':
-                    flags |= jimp.HORIZONTAL_ALIGN_LEFT;
-                    break;
-                case 'center':
-                    flags |= jimp.HORIZONTAL_ALIGN_CENTER;
-                    break;
-                case 'right':
-                    flags |= jimp.HORIZONTAL_ALIGN_RIGHT;
-                    break;
-            }
-            switch (align[1]) {
-                case 'top':
-                    flags |= jimp.VERTICAL_ALIGN_TOP;
-                    break;
-                case 'middle':
-                    flags |= jimp.VERTICAL_ALIGN_MIDDLE;
-                    break;
-                case 'bottom':
-                    flags |= jimp.VERTICAL_ALIGN_BOTTOM;
-                    break;
-            }
-            switch (mode) {
-                case 'contain':
-                    handler.contain(width, height, flags);
-                    break;
-                case 'cover':
-                    handler.cover(width, height, flags);
-                    break;
-                case 'scale':
-                    handler.scaleToFit(width, height);
-                    break;
-                default:
-                    handler.resize(width === Infinity ? jimp.AUTO : width, height === Infinity ? jimp.AUTO : height, resizeMode);
-                    break;
-            }
+        if (!data) {
+            return;
+        }
+        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;
+        }
+        switch (align[0]) {
+            case 'left':
+                flags |= jimp.HORIZONTAL_ALIGN_LEFT;
+                break;
+            case 'center':
+                flags |= jimp.HORIZONTAL_ALIGN_CENTER;
+                break;
+            case 'right':
+                flags |= jimp.HORIZONTAL_ALIGN_RIGHT;
+                break;
+        }
+        switch (align[1]) {
+            case 'top':
+                flags |= jimp.VERTICAL_ALIGN_TOP;
+                break;
+            case 'middle':
+                flags |= jimp.VERTICAL_ALIGN_MIDDLE;
+                break;
+            case 'bottom':
+                flags |= jimp.VERTICAL_ALIGN_BOTTOM;
+                break;
+        }
+        switch (mode) {
+            case 'contain':
+                handler.contain(width, height, flags);
+                break;
+            case 'cover':
+                handler.cover(width, height, flags);
+                break;
+            case 'scale':
+                handler.scaleToFit(width, height);
+                break;
+            default:
+                handler.resize(width === Infinity ? jimp.AUTO : width, height === Infinity ? jimp.AUTO : height, resizeMode);
+                break;
         }
     }
     background(value) {
@@ -346,13 +375,13 @@ class JimpHandler {
         this.handler.background(value);
     }
     finalize(output, callback) {
-        var _a;
         if (this.aborted) {
             return;
         }
         const instance = this.instance;
         if (instance.outputAs === 'webp' && path.extname(output).toLowerCase() !== '.webp') {
-            const webp = (_a = instance.settings).webp || (_a.webp = {});
+            const settings = instance.settings;
+            const webp = settings.webp || (settings.webp = {});
             const data = instance.qualityData;
             const replace = instance.getCommand().indexOf('@') !== -1;
             const filename = (0, util_1.renameExt)(output, 'webp', replace);
@@ -399,7 +428,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 }, err => {
+                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 */);
                     }
@@ -537,67 +566,67 @@ 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) {
-            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();
-                }
-                try {
-                    const { ext } = await this.resolveMime(file) || { ext: 'unknown' };
-                    buffer = file;
-                    fs.writeFileSync(file = path.join(tempDir, (0, types_1.generateUUID)() + '.' + ext), buffer);
-                }
-                catch {
-                    return empty();
-                }
-                options.cache = false;
-            }
-            const filename = path.basename(file);
-            const broadcastId = options.broadcastId;
-            if (broadcastId) {
-                if ((0, types_1.isPlainObject)(broadcastId)) {
-                    instance.broadcastId = broadcastId.value;
-                    if (broadcastId.stripAnsi === false) {
-                        instance.supports('stripAnsi', false);
-                    }
-                }
-                else {
-                    instance.broadcastId = broadcastId;
-                }
+        if (!outputType) {
+            return empty();
+        }
+        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();
             }
-            const writeMessage = (failed, cTimeMs) => {
-                if (cTimeMs || options.startTime) {
-                    formatMessage.call(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 || ''));
-                if (buffer) {
-                    writeMessage(false, ctimeMs);
-                    return Promise.resolve(buffer);
-                }
+            try {
+                const { ext } = await this.resolveMime(file) || { ext: 'unknown' };
+                buffer = file;
+                fs.writeFileSync(file = path.join(tempDir, (0, types_1.generateUUID)() + '.' + ext), buffer);
             }
-            instance.formatMessage(Image.LOG_TYPE.IMAGE, "jimp" /* STRINGS.MODULE_NAME */, ["Transforming image..." /* STRINGS.TRANSFORM */, filename], command);
-            Image.initCpuUsage(instance);
-            return performCommand(null, instance, file, command, outputType, finalAs)
-                .then(async (handler) => {
-                const result = await handler.getBuffer(options.tempFile, saveAs);
-                instance.flushLog();
-                writeMessage(!result || instance.errors.length > 0);
-                if (result && tempKey && tempFile) {
-                    setImageCache.call(instance, tempKey, tempFile, result, file);
-                }
-                return result;
-            })
-                .catch(() => empty())
-                .finally(() => buffer && !options.cache && removeFile(file));
+            catch {
+                return empty();
+            }
+            options.cache = false;
         }
-        return empty();
+        const filename = path.basename(file);
+        const broadcastId = options.broadcastId;
+        if (broadcastId) {
+            if ((0, types_1.isPlainObject)(broadcastId)) {
+                instance.broadcastId = broadcastId.value;
+                if (broadcastId.stripAnsi === false) {
+                    instance.supports('stripAnsi', false);
+                }
+            }
+            else {
+                instance.broadcastId = broadcastId;
+            }
+        }
+        const writeMessage = (failed, cTimeMs) => {
+            if (cTimeMs || options.startTime) {
+                formatMessage.call(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 || ''));
+            if (buffer) {
+                writeMessage(false, ctimeMs);
+                return Promise.resolve(buffer);
+            }
+        }
+        instance.formatMessage(Image.LOG_TYPE.IMAGE, "jimp" /* STRINGS.MODULE_NAME */, ["Transforming image..." /* STRINGS.TRANSFORM */, filename], command);
+        Image.initCpuUsage(instance);
+        return performCommand(null, instance, file, command, outputType, finalAs)
+            .then(async (handler) => {
+            const result = await handler.getBuffer(options.tempFile, saveAs);
+            instance.flushLog();
+            writeMessage(!result || instance.errors.length > 0);
+            if (result && tempKey && tempFile) {
+                setImageCache.call(instance, tempKey, tempFile, result, file);
+            }
+            return result;
+        })
+            .catch(() => empty())
+            .finally(() => buffer && !options.cache && removeFile(file));
     }
     parseRotate(value) {
         const data = super.parseRotate(value);
@@ -614,7 +643,6 @@ class Jimp extends Image {
             return Promise.reject((0, types_1.createAbortError)());
         }
         return new Promise(async (resolve, reject) => {
-            var _a;
             const { host, file } = data;
             const localUri = host.getLocalUri(data);
             const mimeType = host.getMimeType(data);
@@ -644,8 +672,9 @@ class Jimp extends Image {
             const startTime = process.hrtime();
             const success = (result, ctimeMs) => {
                 const filename = path.basename(result);
-                if (file.document) {
-                    host.writeImage(file.document, data.getObject({ command, output: result }));
+                const document = file.document;
+                if (document) {
+                    host.writeImage(document, data.getObject({ command, output: result }));
                 }
                 if (host.getLocalUri(data) !== result) {
                     if (command.indexOf('%') !== -1) {
@@ -756,11 +785,12 @@ class Jimp extends Image {
                             const args = [(0, util_1.normalizePath)(target)];
                             const quality = cmd.quality;
                             if (quality) {
-                                if (!isNaN(quality.value)) {
-                                    args.push('-q', quality.value.toString());
+                                const { value, method } = quality;
+                                if (!isNaN(value)) {
+                                    args.push('-q', value.toString());
                                 }
-                                if (!isNaN(quality.method)) {
-                                    args.push('-m', quality.method.toString());
+                                if (!isNaN(method)) {
+                                    args.push('-m', method.toString());
                                 }
                             }
                             if (Array.isArray(gif2webp)) {
@@ -789,7 +819,7 @@ 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 }, (err, stdout) => {
+                                child_process.execFile((0, util_1.getWebP_bin)('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);
@@ -936,10 +966,11 @@ class Jimp extends Image {
                     }
                     return false;
                 };
-                const { path: webp_path } = (_a = this.settings).webp || (_a.webp = {});
+                const settings = this.settings;
+                const { path: webp_path } = settings.webp || (settings.webp = {});
                 const bmpFile = getTempPath.call(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 }, err => {
+                    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) {
                             transformBuffer(bmpFile);
                         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/jimp",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "Jimp image constructor for E-mc.",
   "main": "index.js",
   "publishConfig": {
@@ -20,10 +20,10 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/image": "^0.5.3",
-    "@e-mc/types": "^0.5.3",
+    "@e-mc/image": "^0.6.0",
+    "@e-mc/types": "^0.6.0",
     "bmp-js": "^0.1.0",
-    "gifwrap": "^0.9.4",
-    "jimp": "^0.22.8"
+    "gifwrap": "^0.10.1",
+    "jimp": "^0.22.10"
   }
 }