@factorialco/shadowdog/dist/src/generate.js

<img src="https://raw.githubusercontent.com/factorialco/shadowdog/refs/heads/main/logo.png" alt="drawing" width="100"/>

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.generate = void 0;
const path_1 = __importDefault(require("path"));
const plugins_1 = require("./plugins");
const task_runner_1 = require("./task-runner");
const tasks_1 = require("./tasks");
const processTask = async (task, pluginsConfig, eventEmitter, options) => {
    switch (task.type) {
        case 'parallel': {
            return Promise.all(task.tasks.map((subTask) => processTask(subTask, pluginsConfig, eventEmitter, options)));
        }
        case 'serial': {
            for (const subTask of task.tasks) {
                await processTask(subTask, pluginsConfig, eventEmitter, options);
            }
            return;
        }
        case 'command': {
            eventEmitter.emit('begin', {
                artifacts: task.config.artifacts,
            });
            const taskRunner = new task_runner_1.TaskRunner({
                files: task.files,
                invalidators: task.invalidators,
                config: task.config,
                eventEmitter,
            });
            (0, plugins_1.filterMiddlewarePlugins)(pluginsConfig).forEach(({ fn, options: pluginOptions }) => {
                taskRunner.use(fn.middleware, pluginOptions);
            });
            taskRunner.use(() => {
                return (0, tasks_1.runTask)({
                    command: task.config.command,
                    workingDirectory: path_1.default.join(process.cwd(), task.config.workingDirectory),
                    onSpawn: () => { },
                    onExit: () => { },
                });
            });
            try {
                await taskRunner.execute();
                eventEmitter.emit('end', {
                    artifacts: task.config.artifacts,
                });
            }
            catch (error) {
                eventEmitter.emit('error', {
                    artifacts: task.config.artifacts,
                    errorMessage: error.message,
                });
                if (!options.continueOnError) {
                    throw error;
                }
            }
            break;
        }
        case 'empty': {
            // noop
        }
    }
};
const generate = async (config, eventEmitter, options) => {
    const plugins = (0, plugins_1.filterCommandPlugins)(config.plugins);
    const task = {
        type: 'parallel',
        tasks: config.watchers.flatMap((watcherConfig) => watcherConfig.commands.map((commandConfig) => ({
            type: 'command',
            config: commandConfig,
            files: watcherConfig.files,
            invalidators: watcherConfig.invalidators,
        }))),
    };
    const finalTask = plugins.reduce((subTask, { fn }) => fn.command(subTask), task);
    return processTask(finalTask, config.plugins, eventEmitter, options);
};
exports.generate = generate;