gulp-add-tasks2/src/index.js

A tool to add tasks to a passed-in gulp instance, as a task list, or as a map of functions

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const run_sequence_1 = require("gulp-run-seq-unique/run-sequence");
exports.runSequence = run_sequence_1.default;
//import * as runSequence from 'run-sequence';
const gulpHelp = require("gulp-help");
exports.gulpHelp = gulpHelp;
const SEP = ':';
exports.SEP = SEP;
function looksLikeGulp(gulp) {
    return !!(gulp.task && gulp.watch && gulp.src && gulp.dest);
}
exports.looksLikeGulp = looksLikeGulp;
function looksLikeGulpHelp(gulp) {
    return !!(gulp.tasks.help);
}
exports.looksLikeGulpHelp = looksLikeGulpHelp;
function getOptions(impl) {
    const options = (impl.options || {});
    if (options.options || options.aliases) {
        return options;
    }
    return {
        options: impl.options || {},
        aliases: impl.aliases || []
    };
}
exports.getOptions = getOptions;
function isTaskListObject(impl = {}) {
    return Object.keys(impl).indexOf('tasks') > -1;
}
exports.isTaskListObject = isTaskListObject;
function getTasks(tasks, parentTask = '', cache = exports.defaultGulpAddTasksOptions) {
    if (typeof tasks === 'function') {
        tasks = tasks();
    }
    for (let i in tasks) {
        if (Array.isArray(tasks[i])) {
            tasks[i] = prefixTasks(tasks[i], parentTask, cache);
        }
        else if (typeof tasks[i] == 'string') {
            tasks[i] = prefixTasks([tasks[i]], parentTask, cache)[0];
        }
    }
    return tasks || [];
}
exports.getTasks = getTasks;
function prefixTasks(tasks = [], parentTask = '', cache = exports.defaultGulpAddTasksOptions) {
    if (tasks && !Array.isArray(tasks)) {
        tasks = [tasks];
    }
    return (tasks || []).map(function (v) {
        if (typeof v !== 'string')
            return v;
        if (!cache.sep) {
            return v;
        }
        if (cache.root !== '' && v.indexOf(`~${cache.sep}`) === 0) {
            return v.replace(`~${cache.sep}`, `${cache.root}${cache.sep}`);
        }
        if (v.indexOf(cache.sep) === 0) {
            if (parentTask === '') {
                return v.substr(cache.sep.length);
            }
            return parentTask + v;
        }
        return v;
    });
}
exports.prefixTasks = prefixTasks;
function validTaskObject(taskObject) {
    let type = typeof taskObject;
    if (type === 'function') {
        return taskObject;
    }
    if (type === 'object') {
        for (let k of Object.keys(taskObject)) {
            if (['function', 'object', 'string'].includes(typeof taskObject[k])) {
                return taskObject;
            }
        }
    }
    return false;
}
exports.validTaskObject = validTaskObject;
function addTasksToGulp(gulp, rs, taskObject, parentTask = '', cache = exports.defaultGulpAddTasksOptions) {
    for (let taskName in taskObject) {
        const taskImpl = taskObject[taskName];
        if (parentTask) {
            taskName = `${parentTask}:${taskName}`;
        }
        if (Object.keys(taskImpl).indexOf('callback') > -1) {
            let taskFn;
            if (isTaskListObject(taskImpl)) {
                taskFn = async function (...argv) {
                    await new Promise(function (resolve, reject) {
                        rs.use(gulp)(...(getTasks(taskImpl.tasks, parentTask, cache).concat(resolve)));
                    });
                    await taskImpl.callback.call(this, ...argv);
                };
            }
            else {
                taskFn = taskImpl.callback;
            }
            gulp.task(taskName, taskImpl.description, prefixTasks(taskImpl.deps, parentTask, cache), taskFn, getOptions(taskImpl));
        }
        else if (typeof taskImpl === 'function' || isTaskListObject(taskImpl)) {
            const taskFn = typeof taskImpl === 'function' ? taskImpl : function (done) {
                return rs.use(gulp)(...(getTasks(taskImpl.tasks, parentTask, cache)).concat(done));
            };
            gulp.task(taskName, taskImpl.description, prefixTasks(taskImpl.deps, parentTask, cache), taskFn, getOptions(taskImpl));
        }
        else if (Object.keys(taskImpl).indexOf('deps') > -1) {
            gulp.task(taskName, taskImpl.description, prefixTasks(taskImpl.deps, parentTask, cache), () => { }, getOptions(taskImpl));
        }
        else if (!validTaskObject(taskImpl)) {
            let { inspect } = require('util');
            throw new TypeError(`argument:taskObject ${inspect(taskImpl)} not a valid ITaskObject`);
        }
        else {
            addTasksToGulp(gulp, rs, taskImpl, taskName, cache);
        }
    }
}
exports.addTasksToGulp = addTasksToGulp;
exports.defaultGulpAddTasksOptions = {
    sep: SEP,
    runSequence: run_sequence_1.default,
    gulpHelp: gulpHelp,
};
function gulpAddTasks(gulpInstance, parentTaskName = '', options = exports.defaultGulpAddTasksOptions) {
    if (!looksLikeGulp(gulpInstance)) {
        throw new Error('An instance of gulp is required as the first argument');
    }
    if (Array.isArray(parentTaskName)) {
        parentTaskName = parentTaskName.join(options.sep ? options.sep : SEP);
    }
    const cache = Object.assign({
        root: parentTaskName,
    }, exports.defaultGulpAddTasksOptions, options);
    return function (...taskObjects) {
        const runSequence = cache.runSequence;
        const gulpHelp = cache.gulpHelp;
        const gulp = looksLikeGulpHelp(gulpInstance) ? gulpInstance : gulpHelp(gulpInstance);
        gulp.options = gulp.options || {};
        gulp.options.gulpAddTasks = cache;
        taskObjects
            .forEach((taskObject) => {
            addTasksToGulp(gulp, runSequence, taskObject, parentTaskName, cache);
        });
        return gulp;
    };
}
exports.gulpAddTasks = gulpAddTasks;
exports.init = gulpAddTasks;
exports.default = gulpAddTasks;