@jojoxd/barrels-nx/src/executors/generate/executor.js

Barrels NX Plugin

"use strict";
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: all[name]
    });
}
_export(exports, {
    generateBarrelsExecutor: function() {
        return generateBarrelsExecutor;
    },
    default: function() {
        return _default;
    }
});
const _barrels = require("@jojoxd/barrels");
const _asynciterable = require("@nx/devkit/src/utils/async-iterable");
const _devkit = require("@nx/devkit");
const _client = require("nx/src/daemon/client/client");
// @TODO: Can this be rxjs-native?
function debounce(fn, wait) {
    let timeoutId;
    return ()=>{
        clearTimeout(timeoutId);
        timeoutId = setTimeout(fn, wait);
    };
}
async function* generateBarrelsExecutor(schema, context) {
    const barrels = new _barrels.Barrels();
    const tasks = [];
    let currentTask = null;
    yield* (0, _asynciterable.createAsyncIterable)(async ({ done , next , error  })=>{
        const processQueue = async ()=>{
            if (tasks.length === 0) return;
            const previousTask = currentTask;
            const task = tasks.shift();
            currentTask = task;
            await previousTask.stop();
            await task.start();
        };
        var _schema_debounce;
        const debouncedProcessQueue = debounce(processQueue, (_schema_debounce = schema.debounce) != null ? _schema_debounce : 1000);
        const addToQueue = async ()=>{
            const task = {
                promise: null,
                abortController: new AbortController(),
                start: async ()=>{
                    if (task.abortController.signal.aborted) return;
                    // @TODO: Load from somewhere else
                    const barrelsConfig = [];
                    task.promise = new Promise((resolve, reject)=>{
                        // Run job
                        barrels.generate({
                            barrels: barrelsConfig,
                            abortSignal: task.abortController.signal
                        }).then(()=>{
                            if (schema.watch && !task.abortController.signal.aborted) {
                                // @TODO: Better error, is this even needed?
                                _devkit.logger.info(`NX Process exited, waiting for changes to restart...`);
                            }
                            if (!schema.watch) {
                                done();
                            }
                            resolve();
                        }).catch((e)=>{
                            error(e);
                            // @TODO: Do we need to reject here?
                            reject(e);
                        });
                        next({
                            success: true
                        });
                    });
                    await task.promise;
                    next({
                        success: true
                    });
                },
                stop: async ()=>{
                    task.abortController.abort();
                    await task.promise;
                }
            };
            tasks.push(task);
        };
        const stopWatch = await _client.daemonClient.registerFileWatcher({
            watchProjects: [
                context.projectName
            ],
            includeDependentProjects: true
        }, async (err)=>{
            if (err === 'closed') {
                _devkit.logger.error(`Watch error: Daemon closed the connection`);
                process.exit(1); // @TODO: Is this really the way to do it?
            } else if (err) {
                var _err_message;
                _devkit.logger.error(`Watch error: ${(_err_message = err == null ? void 0 : err.message) != null ? _err_message : 'Unknown'}`);
            } else {
                _devkit.logger.info(`NX File change detected. Rebuilding barrels...`);
                await addToQueue();
                await debouncedProcessQueue();
            }
        });
        const stopAllTasks = ()=>{
            for (const task of tasks){
                task.stop();
            }
        };
        process.on('SIGTERM', async ()=>{
            stopWatch();
            stopAllTasks();
            process.exit(128 + 15);
        });
        process.on('SIGINT', async ()=>{
            stopWatch();
            stopAllTasks();
            process.exit(128 + 2);
        });
        process.on('SIGHUP', async ()=>{
            stopWatch();
            stopAllTasks();
            process.exit(128 + 1);
        });
        await addToQueue();
        await processQueue();
    });
    return {
        success: true
    };
}
const _default = generateBarrelsExecutor;

//# sourceMappingURL=executor.js.map