@e-mc/task 0.1.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/task",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Task constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,9 +20,7 @@
   "license": "BSD 3-Clause",
   "homepage": "https://github.com/anpham6/e-mc#readme",
   "dependencies": {
-    "@e-mc/core": "0.1.0",
-    "@e-mc/types": "0.1.0",
-    "strip-ansi": "6.0.1",
-    "which": "^2.0.2"
+    "@e-mc/core": "0.3.0",
+    "@e-mc/types": "0.3.0"
   }
 }

package/gulp/index.d.ts

@@ -1,5 +0,0 @@
-import type { TaskConstructor } from '../../types/lib';
-
-declare const Gulp: TaskConstructor;
-
-export = Gulp;

package/gulp/index.js

@@ -1,333 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const fs = require("fs");
-const child_process = require("child_process");
-const stripansi = require("strip-ansi");
-const which = require("which");
-const types_1 = require("../../types");
-const index_1 = require("../index");
-const BIN_NPX = index_1.default.sanitizeCmd(which.sync('npx', { nothrow: true }) || 'npx');
-const BIN_GULP = index_1.default.sanitizeCmd(which.sync("gulp" /* STRINGS.MODULE_NAME */, { nothrow: true }) || '');
-const REGEXP_TIMESTAMP = /^\[\d+:\d+:\d+\]$/;
-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 => {
-        if (host) {
-            for (const output of result) {
-                if (output.status === 'fulfilled') {
-                    const { added, deleted } = output.value;
-                    if (deleted) {
-                        deleted.forEach(file => host.deleteFile(file));
-                    }
-                    if (added) {
-                        added.forEach(file => host.add(file));
-                    }
-                }
-            }
-        }
-    });
-}
-const normalizePath = (value) => process.platform === 'win32' ? '"' + value.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"' : index_1.default.sanitizeArgs(value);
-class Gulp extends index_1.default {
-    constructor() {
-        super(...arguments);
-        this._moduleName = "gulp" /* STRINGS.MODULE_NAME */;
-    }
-    static finalize(instance, assets) {
-        return executeTasks.call(instance, assets, false, this);
-    }
-    using(data) {
-        return executeTasks.call(this, [data.file], true, data.host);
-    }
-    collate(assets, isPreceding = false) {
-        const settings = this.settings;
-        const taskMap = new Map();
-        const origMap = new Map();
-        const username = this.host?.username || '';
-        for (const item of assets) {
-            const localUri = item.localUri;
-            if (!localUri || !item.tasks || (0, types_1.ignoreFlag)(item.flags) || !this.canWrite(localUri, { ownPermissionOnly: true })) {
-                continue;
-            }
-            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) {
-                    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) && index_1.default.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))) {
-                            let dirMap = taskMap.get(task);
-                            if (!dirMap) {
-                                taskMap.set(task, dirMap = new Map());
-                            }
-                            let sourceDir = dirMap.get(origDir);
-                            if (!sourceDir) {
-                                dirMap.set(origDir, sourceDir = { path: gulpfile, tasks, opts, items: [] });
-                            }
-                            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 */);
-                    }
-                }
-            }
-            if (scheduled.size) {
-                const stored = origMap.get(origDir);
-                const items = Array.from(scheduled);
-                if (!stored) {
-                    origMap.set(origDir, items);
-                    continue;
-                }
-                let previous = -1;
-                for (const task of items.reverse()) {
-                    const index = stored.indexOf(task);
-                    if (index !== -1) {
-                        if (index <= previous) {
-                            previous = index;
-                            continue;
-                        }
-                        stored.splice(index, 1);
-                    }
-                    if (previous !== -1) {
-                        stored.splice(previous--, 0, task);
-                    }
-                    else {
-                        stored.push(task);
-                        previous = stored.length - 1;
-                    }
-                }
-            }
-        }
-        const series = [];
-        const parallel = [];
-        for (const [task, dirMap] of taskMap) {
-            for (const [origDir, data] of dirMap) {
-                const item = origMap.get(origDir);
-                (item && item.length > 1 ? series : parallel).push({ task, origDir, data });
-            }
-        }
-        series.sort((a, b) => {
-            if (a.origDir === b.origDir && a.task !== b.task) {
-                const taskData = origMap.get(a.origDir);
-                const indexA = taskData.indexOf(a.task);
-                const indexB = taskData.indexOf(b.task);
-                if (indexA !== -1 && indexB !== -1) {
-                    if (indexA < indexB) {
-                        return -1;
-                    }
-                    if (indexB < indexA) {
-                        return 1;
-                    }
-                }
-            }
-            return 0;
-        });
-        const result = [];
-        if (series.length) {
-            result.push(this.series(series));
-        }
-        if (parallel.length) {
-            result.push(this.parallel(parallel));
-        }
-        return result;
-    }
-    queue(tasks) {
-        return tasks.map(item => new Promise(resolve => { this.spawn(item, (result) => { resolve(result); }); }));
-    }
-    async series(tasks) {
-        let added, deleted;
-        for await (const output of this.queue(tasks)) {
-            if (output) {
-                if (output.added) {
-                    (added || (added = [])).push(...output.added);
-                }
-                if (output.deleted) {
-                    (deleted || (deleted = [])).push(...output.deleted);
-                }
-            }
-        }
-        return { added, deleted };
-    }
-    parallel(tasks) {
-        return Promise.allSettled(this.queue(tasks)).then(result => {
-            let added, deleted, value;
-            for (const item of result) {
-                if (item.status === 'fulfilled' && (value = item.value)) {
-                    if (value.added) {
-                        (added || (added = [])).push(...value.added);
-                    }
-                    if (value.deleted) {
-                        (deleted || (deleted = [])).push(...value.deleted);
-                    }
-                }
-            }
-            return { added, deleted };
-        });
-    }
-    spawn(gulp, callback) {
-        const { task, origDir, data } = gulp;
-        const tempDir = this.getTempDir({ uuidDir: true });
-        const writeError = (value, err, hint, type = 32 /* LOG_TYPE.FILE */) => {
-            if (err) {
-                this.writeFail([value, hint || (this.moduleName + ': ' + task)], err, { type, startTime });
-            }
-            if (hint !== false) {
-                queueMicrotask(() => index_1.default.removeDir(tempDir));
-                callback();
-            }
-        };
-        if (!tempDir) {
-            writeError("Unable to create temp directory" /* ERR_MESSAGE.TEMP_DIRECTORY */, null, this.getTempDir());
-            return;
-        }
-        let { path: gulpfile, tasks, opts, items } = data;
-        if (!Array.isArray(tasks)) {
-            tasks = (0, types_1.isString)(tasks) ? [tasks] : [task];
-        }
-        if (!Array.isArray(opts)) {
-            opts = (0, types_1.isString)(opts) ? [opts] : [];
-        }
-        for (let i = 0; i < opts.length; ++i) {
-            switch (opts[i]) {
-                case '--verify':
-                case '--compact-tasks':
-                case '--sort-tasks':
-                case '--color':
-                case '--no-color':
-                case '--silent':
-                case '--continue':
-                case '--series':
-                case '--log-level':
-                case '-S':
-                case '-L':
-                case '-LL':
-                case '-LLL':
-                case '-LLLL':
-                    continue;
-                case '--require':
-                    if (i < opts.length - 1) {
-                        ++i;
-                        continue;
-                    }
-                    break;
-                case '--tasks-depth':
-                case '--depth':
-                    if (!isNaN(+opts[i + 1])) {
-                        ++i;
-                        continue;
-                    }
-                    break;
-            }
-            opts.splice(i--, 1);
-        }
-        const startTime = process.hrtime();
-        const broadcastId = this.broadcastId;
-        this.formatMessage(4 /* LOG_TYPE.PROCESS */, "gulp" /* STRINGS.MODULE_NAME */, ['Executing task...', task], gulpfile);
-        Promise.all(items.map(src => fs.promises.copyFile(src, path.join(tempDir, path.basename(src)))))
-            .then(() => {
-            try {
-                const args = [...index_1.default.sanitizeArgs(tasks), ...opts, '--gulpfile', `${normalizePath(gulpfile)}`, '--cwd', `${normalizePath(tempDir)}`];
-                if (!BIN_GULP) {
-                    args.unshift('gulp');
-                }
-                let out = '', timeStamp = '', message = '';
-                const setMessage = (type, value) => {
-                    if (REGEXP_TIMESTAMP.test(stripansi(value = value.trim()))) {
-                        timeStamp = value + ' ';
-                    }
-                    else {
-                        this.formatMessage(type, '', timeStamp + value, null, { sessionId: '' });
-                        timeStamp = '';
-                    }
-                };
-                const { stdout, stderr } = child_process.spawn(BIN_GULP || BIN_NPX, args, { cwd: process.cwd(), shell: true, stdio: index_1.default.hasLogType(32768 /* LOG_TYPE.STDOUT */) && !broadcastId ? 'inherit' : undefined, signal: this.signal })
-                    .on('exit', code => {
-                    if (!code) {
-                        this.addLog(types_1.STATUS_TYPE.INFO, out);
-                        const result = new Set();
-                        let added, deleted;
-                        try {
-                            const files = fs.readdirSync(tempDir);
-                            for (let i = 0, copy; i < files.length; ++i) {
-                                const filename = files[i];
-                                try {
-                                    const dest = path.join(origDir, filename);
-                                    if (!result.has(dest)) {
-                                        const src = path.join(tempDir, filename);
-                                        if (copy) {
-                                            fs.copyFileSync(src, dest);
-                                        }
-                                        else {
-                                            fs.renameSync(src, dest);
-                                        }
-                                        result.add(dest);
-                                    }
-                                }
-                                catch (err) {
-                                    if (!copy && index_1.default.isErrorCode(err, 'EXDEV')) {
-                                        copy = true;
-                                        --i;
-                                    }
-                                    else {
-                                        this.writeFail(["Unable to rename file" /* ERR_MESSAGE.RENAME_FILE */, filename], err, 32 /* LOG_TYPE.FILE */);
-                                    }
-                                }
-                            }
-                            this.writeTimeProcess("gulp" /* STRINGS.MODULE_NAME */, task + ' -> ' + path.basename(items[0]), startTime);
-                        }
-                        catch (err) {
-                            writeError("Unable to read directory" /* ERR_MESSAGE.READ_DIRECTORY */, err, false);
-                        }
-                        items.forEach(value => !result.has(value) && (deleted || (deleted = [])).push(value));
-                        result.forEach(value => !items.includes(value) && (added || (added = [])).push(value));
-                        queueMicrotask(() => index_1.default.removeDir(tempDir));
-                        callback({ added, deleted });
-                    }
-                    else {
-                        writeError("Unable to execute file" /* ERR_MESSAGE.EXECUTE_FILE */, new Error(message || "Unknown" /* ERR_MESSAGE.UNKNOWN */), '', 4 /* LOG_TYPE.PROCESS */);
-                    }
-                })
-                    .on('error', err => writeError("Unknown" /* ERR_MESSAGE.UNKNOWN */, err, false, 4 /* LOG_TYPE.PROCESS */));
-                if (stdout) {
-                    stdout.setEncoding('utf-8').on('data', (value) => {
-                        if (broadcastId) {
-                            setMessage(types_1.STATUS_TYPE.INFO, value);
-                        }
-                        out += value;
-                    });
-                }
-                if (stderr) {
-                    stderr.setEncoding('utf-8').on('data', (value) => {
-                        if (broadcastId) {
-                            setMessage(types_1.STATUS_TYPE.ERROR, value);
-                        }
-                        message += value;
-                    });
-                }
-            }
-            catch (err) {
-                writeError("Unable to execute file" /* ERR_MESSAGE.EXECUTE_FILE */, err);
-            }
-        })
-            .catch(err => writeError("Unable to copy file" /* ERR_MESSAGE.COPY_FILE */, err, tempDir));
-    }
-}
-exports.default = Gulp;
-
-if (exports.default) {
-    module.exports = exports.default;
-    module.exports.default = exports.default;
-}