turbo-gulp/targets/node.js

Gulp tasks to boost high-quality projects.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const child_process_1 = require("child_process");
const path_1 = require("path");
const _base_1 = require("./_base");
/**
 * Resolve absolute paths and dependencies for the provided target.
 *
 * @param target Non-resolved target.
 * @return Resolved target.
 */
function resolveLibTarget(target) {
    const base = _base_1.resolveTargetBase(target);
    return Object.assign({}, base, { mainModule: target.mainModule });
}
/**
 * Generates and registers gulp tasks for the provided node target.
 *
 * @param gulp Gulp instance used to generate tasks manipulating files.
 * @param targetOptions Target configuration.
 */
function generateNodeTasks(gulp, targetOptions) {
    const target = resolveLibTarget(targetOptions);
    const result = _base_1.registerBaseTasks(gulp, targetOptions);
    const absMain = path_1.posix.join(target.buildDir, `${target.mainModule}.js`);
    // run
    result.run = _base_1.nameTask(`${target.name}:run`, () => {
        return child_process_1.spawn("node", [absMain, ...process.argv.splice(1)], { stdio: "inherit" });
    });
    // start
    const startTasks = [];
    if (result.clean !== undefined) {
        startTasks.push(result.clean);
    }
    startTasks.push(result.build);
    startTasks.push(result.run);
    result.start = _base_1.nameTask(target.name, gulp.series(startTasks));
    return result;
}
exports.generateNodeTasks = generateNodeTasks;
/**
 * Generates and registers gulp tasks for the provided node target.
 *
 * @param gulp Gulp instance where the tasks will be registered.
 * @param targetOptions Target configuration.
 */
function registerNodeTasks(gulp, targetOptions) {
    const tasks = generateNodeTasks(gulp, targetOptions);
    for (const key in tasks) {
        const task = tasks[key];
        if (task !== undefined) {
            gulp.task(task);
        }
    }
    return tasks;
}
exports.registerNodeTasks = registerNodeTasks;

//# sourceMappingURL=data:application/json;charset=utf8;base64,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