turbo-gulp/targets/node.mjs

Gulp tasks to boost high-quality projects.

import { spawn } from "child_process";
import { posix as posixPath } from "path";
import { nameTask, registerBaseTasks, resolveTargetBase, } from "./_base";
/**
 * Resolve absolute paths and dependencies for the provided target.
 *
 * @param target Non-resolved target.
 * @return Resolved target.
 */
function resolveLibTarget(target) {
    const base = 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.
 */
export function generateNodeTasks(gulp, targetOptions) {
    const target = resolveLibTarget(targetOptions);
    const result = registerBaseTasks(gulp, targetOptions);
    const absMain = posixPath.join(target.buildDir, `${target.mainModule}.js`);
    // run
    result.run = nameTask(`${target.name}:run`, () => {
        return 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 = nameTask(target.name, gulp.series(startTasks));
    return result;
}
/**
 * Generates and registers gulp tasks for the provided node target.
 *
 * @param gulp Gulp instance where the tasks will be registered.
 * @param targetOptions Target configuration.
 */
export 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;
}

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