@pi-r/gulp 0.6.2 → 0.6.5

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2023 An Pham
+Copyright 2024 An Pham
 
 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,7 +1,10 @@
-### @pi-r/gulp
+# @pi-r/gulp
 
-https://e-mc.readthedocs.io/en/latest/task/index.html
+## Documentation
 
-### LICENSE
+- [E-mc](https://e-mc.readthedocs.io/en/latest/task/index.html)
+- [squared](https://squared.readthedocs.io)
+
+## LICENSE
 
 MIT

package/index.js

@@ -1,5 +1,4 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 const path = require("path");
 const fs = require("fs");
 const child_process = require("child_process");
@@ -8,13 +7,13 @@ const which = require("which");
 const types_1 = require("@e-mc/types");
 const Task = require('@e-mc/task');
 const BIN_NPX = Task.sanitizeCmd(which.sync('npx', { nothrow: true }) || 'npx');
-const BIN_GULP = Task.sanitizeCmd(which.sync("gulp" /* STRINGS.MODULE_NAME */, { nothrow: true }) || '');
+const BIN_GULP = Task.sanitizeCmd(which.sync("gulp", { nothrow: true }) || '');
 const REGEXP_TIMESTAMP = /^\[\d+:\d+:\d+\]$/;
 async function executeTasks(assets, preceding, host) {
     if (this.aborted) {
         return Promise.reject((0, types_1.createAbortError)());
     }
-    return this.allSettled(this.collate(assets, preceding), ['Execute tasks', "gulp" /* STRINGS.MODULE_NAME */]).then(result => {
+    return this.allSettled(this.collate(assets, preceding), ['Execute tasks', "gulp"]).then(result => {
         if (host) {
             for (const output of result) {
                 if (output.status === 'fulfilled') {
@@ -31,11 +30,10 @@ async function executeTasks(assets, preceding, host) {
     });
 }
 const normalizePath = (value) => process.platform === 'win32' ? '"' + value.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"' : Task.sanitizeArgs(value);
-// @ts-ignore
 class Gulp extends Task {
     constructor() {
         super(...arguments);
-        this._moduleName = "gulp" /* STRINGS.MODULE_NAME */;
+        this._moduleName = "gulp";
     }
     static async finalize(instance, assets) {
         return executeTasks.call(instance, assets, false, this);
@@ -56,13 +54,25 @@ class Gulp extends Task {
             const origDir = path.dirname(localUri);
             const scheduled = new Set();
             for (let { task, handler, preceding } of item.tasks) {
-                if (task && handler === "gulp" /* STRINGS.MODULE_NAME */ && !!preceding === isPreceding) {
+                if (task && handler === "gulp" && !!preceding === isPreceding) {
                     let gulpfile = (0, types_1.isString)(task) ? username && (0, types_1.isObject)(settings.users) && settings.users[username]?.[task] || settings[task] : task, tasks, opts;
                     if ((0, types_1.isObject)(gulpfile)) {
                         ({ path: gulpfile, tasks, opts } = gulpfile);
                     }
-                    if ((0, types_1.isString)(gulpfile) && Task.isPath(gulpfile = path.resolve(gulpfile), true) && ((0, types_1.isString)(task) || !this.canRead(gulpfile, { ownPermissionOnly: true }))) {
+                    if ((0, types_1.isString)(gulpfile) && Task.isPath(gulpfile = path.resolve(gulpfile), true) && ((0, types_1.isString)(task) || this.canRead(gulpfile, { ownPermissionOnly: true }))) {
                         if (!scheduled.has((0, types_1.isString)(task) ? task : task = JSON.stringify(task))) {
+                            try {
+                                const buffer = item.sourceUTF8 || item.buffer;
+                                if (buffer) {
+                                    fs.writeFileSync(localUri, buffer);
+                                    delete item.sourceUTF8;
+                                    delete item.buffer;
+                                }
+                            }
+                            catch (err) {
+                                this.writeFail(["Unable to write file", path.basename(localUri)], err, 32);
+                                continue;
+                            }
                             let dirMap = taskMap.get(task);
                             if (!dirMap) {
                                 taskMap.set(task, dirMap = new Map());
@@ -73,15 +83,13 @@ class Gulp extends Task {
                             }
                             sourceDir.items.push(localUri);
                             scheduled.add(task);
-                            delete item.sourceUTF8;
-                            delete item.buffer;
                         }
                     }
                     else {
                         if (!(0, types_1.isString)(task)) {
                             task = gulpfile && path.basename(gulpfile);
                         }
-                        this.writeFail(["Unable to perform task" /* ERR_MESSAGE.PERFORM_TASK */, task ? "gulp" /* STRINGS.MODULE_NAME */ + ': ' + task : ''], (0, types_1.errorMessage)(task || "gulp" /* STRINGS.MODULE_NAME */, "Unknown" /* ERR_MESSAGE.UNKNOWN */, username), 4 /* LOG_TYPE.PROCESS */);
+                        this.writeFail(["Unable to perform task", task ? "gulp" + ': ' + task : ''], (0, types_1.errorMessage)(task || "gulp", "Unknown", username), 4);
                     }
                 }
             }
@@ -181,7 +189,7 @@ class Gulp extends Task {
     spawn(gulp, callback) {
         const { task, origDir, data } = gulp;
         const tempDir = this.getTempDir({ uuidDir: true });
-        const writeError = (value, err, hint, type = 32 /* LOG_TYPE.FILE */) => {
+        const writeError = (value, err, hint, type = 32) => {
             if (err) {
                 this.writeFail([value, hint || (this.moduleName + ': ' + task)], err, { type, startTime });
             }
@@ -191,7 +199,7 @@ class Gulp extends Task {
             }
         };
         if (!tempDir) {
-            writeError("Unable to create temp directory" /* ERR_MESSAGE.TEMP_DIRECTORY */, null, this.getTempDir());
+            writeError("Unable to create temp directory", null, this.getTempDir());
             return;
         }
         const exec = this.settings.exec;
@@ -246,7 +254,7 @@ class Gulp extends Task {
         }
         const startTime = process.hrtime();
         const broadcastId = this.broadcastId;
-        this.formatMessage(4 /* LOG_TYPE.PROCESS */, "gulp" /* STRINGS.MODULE_NAME */, ['Executing task...', task], gulpfile);
+        this.formatMessage(4, "gulp", ['Executing task...', task], gulpfile);
         Promise.all(items.map(async (src) => fs.promises.copyFile(src, path.join(tempDir, path.basename(src)))))
             .then(() => {
             try {
@@ -264,7 +272,7 @@ class Gulp extends Task {
                         timeStamp = '';
                     }
                 };
-                const { stdout, stderr } = child_process.spawn(BIN_GULP || BIN_NPX, args, { cwd: process.cwd(), shell: true, stdio: Task.hasLogType(32768 /* LOG_TYPE.STDOUT */) && !broadcastId ? 'inherit' : undefined, signal: this.signal, uid, gid })
+                const { stdout, stderr } = child_process.spawn(BIN_GULP || BIN_NPX, args, { cwd: process.cwd(), shell: true, stdio: Task.hasLogType(32768) && !broadcastId ? 'inherit' : undefined, signal: this.signal, uid, gid })
                     .on('exit', code => {
                     if (!code) {
                         this.addLog(types_1.STATUS_TYPE.INFO, out);
@@ -293,14 +301,14 @@ class Gulp extends Task {
                                         --i;
                                     }
                                     else {
-                                        this.writeFail(["Unable to rename file" /* ERR_MESSAGE.RENAME_FILE */, filename], err, 32 /* LOG_TYPE.FILE */);
+                                        this.writeFail(["Unable to rename file", filename], err, 32);
                                     }
                                 }
                             }
-                            this.writeTimeProcess("gulp" /* STRINGS.MODULE_NAME */, task + ' -> ' + path.basename(items[0]), startTime);
+                            this.writeTimeProcess("gulp", task + ' -> ' + path.basename(items[0]), startTime);
                         }
                         catch (err) {
-                            writeError("Unable to read directory" /* ERR_MESSAGE.READ_DIRECTORY */, err, false);
+                            writeError("Unable to read directory", err, false);
                         }
                         items.forEach(value => !result.has(value) && (deleted || (deleted = [])).push(value));
                         result.forEach(value => !items.includes(value) && (added || (added = [])).push(value));
@@ -308,10 +316,10 @@ class Gulp extends Task {
                         callback({ added, deleted });
                     }
                     else {
-                        writeError("Unable to execute file" /* ERR_MESSAGE.EXECUTE_FILE */, new Error(message || "Unknown" /* ERR_MESSAGE.UNKNOWN */), '', 4 /* LOG_TYPE.PROCESS */);
+                        writeError("Unable to execute file", new Error(message || "Unknown"), '', 4);
                     }
                 })
-                    .on('error', err => writeError("Unknown" /* ERR_MESSAGE.UNKNOWN */, err, false, 4 /* LOG_TYPE.PROCESS */));
+                    .on('error', err => writeError("Unknown", err, false, 4));
                 if (stdout) {
                     stdout.setEncoding('utf-8').on('data', (value) => {
                         if (broadcastId) {
@@ -330,10 +338,10 @@ class Gulp extends Task {
                 }
             }
             catch (err) {
-                writeError("Unable to execute file" /* ERR_MESSAGE.EXECUTE_FILE */, err);
+                writeError("Unable to execute file", err);
             }
         })
-            .catch(err => writeError("Unable to copy file" /* ERR_MESSAGE.COPY_FILE */, err, tempDir));
+            .catch(err => writeError("Unable to copy file", err, tempDir));
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/gulp",
-  "version": "0.6.2",
+  "version": "0.6.5",
   "description": "Gulp task 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/gulp"
   },
   "keywords": [
@@ -20,8 +20,8 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/task": "^0.8.2",
-    "@e-mc/types": "^0.8.2",
+    "@e-mc/task": "^0.8.6",
+    "@e-mc/types": "^0.8.6",
     "gulp": "^4.0.2",
     "gulp-cli": "^2.3.0",
     "strip-ansi": "6.0.1",

package/types/index.d.ts

@@ -10,7 +10,7 @@ export interface GulpData extends GulpCommand {
     items: string[];
 }
 
-export interface GulpSettings extends ObjectMap<GulpTask>, PlainObject {
+export interface GulpSettings extends PlainObject {
     exec?: ExecAction;
     users?: GulpUsers;
 }