@jujulego/jill 3.0.0-alpha.1 → 3.0.0-alpha.3

package/dist/core.plugin-CxgfxFUI.js

@@ -1,642 +0,0 @@
-import { _ } from '@swc/helpers/_/_ts_decorate';
-import { _ as _$1 } from '@swc/helpers/_/_ts_param';
-import { Logger, withLabel } from '@jujulego/logger';
-import { inject } from 'inversify';
-import symbols from 'log-symbols';
-import { b as LazyCurrentProject, L as LoadProject, T as TaskExpressionService, k as TaskExpressionError, l as TaskSyntaxError, S as ScriptsFilter, a as PrivateFilter, A as AffectedFilter, P as Pipeline, d as LazyCurrentWorkspace, c as LoadWorkspace, W as WorkspaceTree, f as Plugin } from './workspace-tree-VWKE0B6b.js';
-import { f as Command, E as ExitException, I as InkCommand, y as printJson, a as List } from './ink-command-CsbkuRbm.js';
-import { T as TaskCommand } from './jill.application-DNJpmnCF.js';
-import cp from 'node:child_process';
-import process$1 from 'node:process';
-import { jsx } from 'react/jsx-runtime';
-import chalk from 'chalk';
-import path from 'node:path';
-import { compare, parse } from 'semver';
-import slugify from 'slugify';
-import '@jujulego/event-tree';
-import '@jujulego/tasks';
-import '@jujulego/utils';
-import 'glob';
-import 'node:fs';
-import 'normalize-package-data';
-import 'path-scurry';
-import 'node:fs/promises';
-import 'moo';
-import 'ink';
-import 'react';
-import 'node:async_hooks';
-import 'node:os';
-import 'ajv';
-import 'node:worker_threads';
-import 'yargs';
-import 'yargs/helpers';
-import 'cosmiconfig';
-import 'ink-spinner';
-import 'pretty-ms';
-import 'inversify-inject-decorators';
-import '@jujulego/aegis';
-import '@jujulego/quick-tag';
-import 'chalk-template';
-
-class EachCommand extends TaskCommand {
-    // Constructor
-    constructor(logger, taskExpression){
-        super();
-        this.logger = logger;
-        this.taskExpression = taskExpression;
-    }
-    // Methods
-    builder(parser) {
-        return this.addTaskOptions(parser)// Run options
-        .positional('expr', {
-            type: 'string',
-            demandOption: true,
-            desc: 'Script or task expression'
-        }).option('build-script', {
-            default: 'build',
-            desc: 'Script to use to build dependencies'
-        }).option('deps-mode', {
-            alias: 'd',
-            choice: [
-                'all',
-                'prod',
-                'none'
-            ],
-            default: 'all',
-            desc: 'Dependency selection mode:\n' + ' - all = dependencies AND devDependencies\n' + ' - prod = dependencies\n' + ' - none = nothing'
-        }).option('allow-no-workspaces', {
-            type: 'boolean',
-            default: false,
-            desc: 'Allow no matching workspaces. Without it jill will exit with code 1 if no workspace matches'
-        })// Filters
-        .option('private', {
-            type: 'boolean',
-            group: 'Filters:',
-            desc: 'Print only private workspaces'
-        }).option('affected', {
-            alias: 'a',
-            type: 'string',
-            coerce: (rev)=>rev === '' ? 'master' : rev,
-            group: 'Filters:',
-            desc: 'Print only affected workspaces towards given git revision. If no revision is given, it will check towards master. Replaces %name by workspace name.'
-        }).option('affected-rev-sort', {
-            type: 'string',
-            group: 'Filters:',
-            desc: 'Sort applied to git tag / git branch command'
-        }).option('affected-rev-fallback', {
-            type: 'string',
-            default: 'master',
-            group: 'Filters:',
-            desc: 'Fallback revision, used if no revision matching the given format is found'
-        })// Config
-        .strict(false).parserConfiguration({
-            'unknown-options-as-args': true
-        });
-    }
-    async *prepare(argv) {
-        let empty = true;
-        try {
-            // Extract expression
-            const expr = argv._.map((arg)=>arg.toString());
-            if (expr[0] === 'each') {
-                expr.splice(0, 1);
-            }
-            expr.unshift(argv.expr);
-            const tree = this.taskExpression.parse(expr.join(' '));
-            const scripts = Array.from(this.taskExpression.extractScripts(tree));
-            // Create script tasks
-            const pipeline = this._preparePipeline(argv, scripts);
-            for await (const wks of pipeline.filter(this.project.workspaces())){
-                const task = await this.taskExpression.buildTask(tree.roots[0], wks, {
-                    buildScript: argv.buildScript,
-                    buildDeps: argv.depsMode
-                });
-                if (task) {
-                    yield task;
-                    empty = false;
-                }
-            }
-        } catch (err) {
-            if (err instanceof TaskExpressionError) {
-                this.logger.error(err.message);
-                throw new ExitException(1);
-            }
-            if (err instanceof TaskSyntaxError) {
-                this.logger.error(`Syntax error in task expression: ${err.message}`);
-                throw new ExitException(1);
-            }
-            throw err;
-        }
-        if (empty) {
-            this.logger.error(`${symbols.error} No matching workspace found !`);
-            if (argv.allowNoWorkspaces === false) {
-                throw new ExitException(1);
-            }
-        }
-    }
-    _preparePipeline(argv, scripts) {
-        const pipeline = new Pipeline();
-        pipeline.add(new ScriptsFilter(scripts, true));
-        if (argv.private !== undefined) {
-            pipeline.add(new PrivateFilter(argv.private));
-        }
-        if (argv.affected !== undefined) {
-            pipeline.add(new AffectedFilter(argv.affected, argv.affectedRevFallback, argv.affectedRevSort));
-        }
-        return pipeline;
-    }
-}
-_([
-    LazyCurrentProject()
-], EachCommand.prototype, "project", void 0);
-EachCommand = _([
-    Command({
-        command: 'each <expr>',
-        describe: 'Run a task expression in many workspace, after having built all theirs dependencies.',
-        middlewares: [
-            LoadProject
-        ]
-    }),
-    _$1(0, inject(Logger)),
-    _$1(1, inject(TaskExpressionService))
-], EachCommand);
-
-class ExecCommand extends TaskCommand {
-    // Constructor
-    constructor(logger){
-        super();
-        this._logger = logger.child(withLabel('exec'));
-    }
-    // Methods
-    builder(parser) {
-        return this.addTaskOptions(parser).positional('command', {
-            type: 'string',
-            demandOption: true
-        }).option('build-script', {
-            default: 'build',
-            desc: 'Script to use to build dependencies'
-        }).option('deps-mode', {
-            alias: 'd',
-            choice: [
-                'all',
-                'prod',
-                'none'
-            ],
-            default: 'all',
-            desc: 'Dependency selection mode:\n' + ' - all = dependencies AND devDependencies\n' + ' - prod = dependencies\n' + ' - none = nothing'
-        })// Documentation
-        .example('jill eslint', '').example('jill eslint --env-info', 'Unknown arguments are passed down to command. Here it would run eslint --env-info').example('jill eslint -- -v', 'You can use -- to stop argument parsing. Here it would run eslint -v')// Config
-        .strict(false).parserConfiguration({
-            'unknown-options-as-args': true
-        });
-    }
-    async *prepare(args) {
-        // Extract arguments
-        const rest = args._.map((arg)=>arg.toString());
-        if (rest[0] === 'exec') {
-            rest.splice(0, 1);
-        }
-        // Run script in workspace
-        const task = await this.workspace.exec(args.command, rest, {
-            buildScript: args.buildScript,
-            buildDeps: args.depsMode
-        });
-        if (args.plan) {
-            yield task;
-        } else {
-            this._finalTask = task;
-            yield* task.dependencies;
-        }
-    }
-    async handler(args) {
-        await super.handler(args);
-        if (!args.plan) {
-            this.app.unmount();
-            // Execute command
-            this._logger.debug`${this._finalTask.cmd} ${this._finalTask.args.join(' ')}`;
-            const child = cp.spawn(this._finalTask.cmd, this._finalTask.args, {
-                stdio: 'inherit',
-                cwd: this._finalTask.cwd,
-                env: {
-                    ...process$1.env,
-                    ...this._finalTask.env
-                },
-                shell: true,
-                windowsHide: true
-            });
-            const code = await new Promise((resolve)=>{
-                child.on('close', (code)=>{
-                    resolve(code ?? 0);
-                });
-            });
-            if (code) {
-                throw new ExitException(code);
-            }
-        }
-    }
-}
-_([
-    LazyCurrentProject()
-], ExecCommand.prototype, "project", void 0);
-_([
-    LazyCurrentWorkspace()
-], ExecCommand.prototype, "workspace", void 0);
-ExecCommand = _([
-    Command({
-        command: 'exec <command>',
-        aliases: [
-            '$0'
-        ],
-        describe: 'Run command inside workspace, after all its dependencies has been built.',
-        middlewares: [
-            LoadProject,
-            LoadWorkspace
-        ]
-    }),
-    _$1(0, inject(Logger))
-], ExecCommand);
-
-class GroupCommand extends TaskCommand {
-    // Constructor
-    constructor(taskExpr){
-        super();
-        this.taskExpr = taskExpr;
-    }
-    // Methods
-    builder(parser) {
-        return this.addTaskOptions(parser).positional('script', {
-            demandOption: true,
-            desc: 'Task expression',
-            coerce: (expr)=>this.taskExpr.parse(expr.join(' '))
-        }).option('build-script', {
-            default: 'build',
-            desc: 'Script to use to build dependencies'
-        }).option('deps-mode', {
-            alias: 'd',
-            choice: [
-                'all',
-                'prod',
-                'none'
-            ],
-            default: 'all',
-            desc: 'Dependency selection mode:\n' + ' - all = dependencies AND devDependencies\n' + ' - prod = dependencies\n' + ' - none = nothing'
-        });
-    }
-    async *prepare(args) {
-        // Run script in workspace
-        const group = await this.taskExpr.buildTask(args.script.roots[0], this.workspace, {
-            buildScript: args.buildScript,
-            buildDeps: args.depsMode
-        });
-        yield group;
-    }
-}
-_([
-    LazyCurrentWorkspace()
-], GroupCommand.prototype, "workspace", void 0);
-GroupCommand = _([
-    Command({
-        command: 'group <script..>',
-        describe: 'Run many scripts inside a workspace (experimental)',
-        deprecated: true,
-        middlewares: [
-            LoadProject,
-            LoadWorkspace
-        ]
-    }),
-    _$1(0, inject(TaskExpressionService))
-], GroupCommand);
-
-// Constants
-const LONG_ATTRIBUTES = [
-    'name',
-    'version',
-    'root'
-];
-const JSON_ATTRIBUTES = [
-    'name',
-    'version',
-    'slug',
-    'root'
-];
-const DEFAULT_ATTRIBUTES = [
-    'name'
-];
-const EXTRACTORS = {
-    name: (wks)=>wks.name,
-    version: (wks, json)=>wks.manifest.version || (json ? undefined : chalk.grey('unset')),
-    root: (wks)=>wks.cwd,
-    slug: (wks)=>slugify.default(wks.name)
-};
-const COMPARATORS = {
-    name: (a = '', b = '')=>a.localeCompare(b),
-    version: (a, b)=>compare(parse(a) ?? '0.0.0', parse(b) ?? '0.0.0'),
-    root: (a = '', b = '')=>a.localeCompare(b),
-    slug: (a = '', b = '')=>a.localeCompare(b)
-};
-// Utils
-function buildExtractor(attrs) {
-    return (wks, json)=>{
-        const data = {};
-        for (const attr of attrs){
-            data[attr] = EXTRACTORS[attr](wks, json);
-        }
-        return data;
-    };
-}
-class ListCommand extends InkCommand {
-    // Constructor
-    constructor(logger){
-        super();
-        this.logger = logger;
-    }
-    // Methods
-    builder(parser) {
-        return parser// Filters
-        .option('private', {
-            type: 'boolean',
-            group: 'Filters:',
-            desc: 'Print only private workspaces'
-        }).option('with-script', {
-            type: 'array',
-            string: true,
-            group: 'Filters:',
-            desc: 'Print only workspaces having the given script'
-        }).option('affected', {
-            alias: 'a',
-            type: 'string',
-            coerce: (rev)=>rev === '' ? 'master' : rev,
-            group: 'Filters:',
-            desc: 'Print only affected workspaces towards given git revision. If no revision is given, it will check towards master. Replaces %name by workspace name.'
-        }).option('affected-rev-sort', {
-            type: 'string',
-            group: 'Filters:',
-            desc: 'Sort applied to git tag / git branch command'
-        }).option('affected-rev-fallback', {
-            type: 'string',
-            default: 'master',
-            group: 'Filters:',
-            desc: 'Fallback revision, used if no revision matching the given format is found'
-        })// Format
-        .option('attrs', {
-            type: 'array',
-            choices: [
-                'name',
-                'version',
-                'root',
-                'slug'
-            ],
-            group: 'Format:',
-            desc: 'Select printed attributes'
-        }).option('headers', {
-            type: 'boolean',
-            group: 'Format:',
-            desc: 'Prints columns headers'
-        }).option('long', {
-            alias: 'l',
-            type: 'boolean',
-            group: 'Format:',
-            desc: 'Prints name, version and root of all workspaces'
-        }).option('json', {
-            type: 'boolean',
-            group: 'Format:',
-            desc: 'Prints data as a JSON array'
-        })// Sort
-        .option('sort-by', {
-            alias: 's',
-            type: 'array',
-            choices: [
-                'name',
-                'version',
-                'root',
-                'slug'
-            ],
-            group: 'Sort:',
-            desc: 'Sort output by given attribute. By default sorts by name if printed'
-        }).option('order', {
-            alias: 'o',
-            type: 'string',
-            choices: [
-                'asc',
-                'desc'
-            ],
-            default: 'asc',
-            group: 'Sort:',
-            desc: 'Sort order'
-        });
-    }
-    async *render(args) {
-        const { attrs, sortBy } = this._applyDefaults(args);
-        // Load workspaces
-        const pipeline = this._preparePipeline(args);
-        const workspaces = [];
-        for await (const wks of pipeline.filter(this.project.workspaces())){
-            workspaces.push(wks);
-        }
-        // Build data
-        const data = workspaces.map((wks)=>buildExtractor(attrs)(wks, args.json || false));
-        if (sortBy.length > 0) {
-            data.sort(this._dataComparator(sortBy, args.order));
-        }
-        // Print list
-        if (args.json) {
-            printJson(data);
-        } else {
-            for (const d of data){
-                if (d.root) {
-                    d.root = path.relative(process.cwd(), d.root) || '.';
-                }
-            }
-            yield /*#__PURE__*/ jsx(List, {
-                items: data,
-                headers: args.headers ?? attrs.length > 1
-            });
-        }
-    }
-    _applyDefaults(argv) {
-        // Compute attributes
-        let attrs = argv.attrs ?? [];
-        if (attrs.length === 0) {
-            if (argv.long) {
-                attrs = LONG_ATTRIBUTES;
-            } else if (argv.json) {
-                attrs = JSON_ATTRIBUTES;
-            } else {
-                attrs = argv.sortBy ?? DEFAULT_ATTRIBUTES;
-            }
-        }
-        // Check sorted attributes
-        let sortBy = argv.sortBy ?? [];
-        if (attrs.length > 0 && sortBy.length > 0) {
-            const miss = sortBy.filter((attr)=>!attrs.includes(attr));
-            if (miss.length > 0) {
-                this.logger.error(`Cannot sort by non printed attributes. Missing ${miss.join(', ')}.`);
-                throw new ExitException(1);
-            }
-        }
-        if (sortBy.length === 0 && attrs.includes('name')) {
-            sortBy = [
-                'name'
-            ];
-        }
-        return {
-            attrs,
-            sortBy
-        };
-    }
-    _preparePipeline(argv) {
-        const pipeline = new Pipeline();
-        if (argv.private !== undefined) {
-            pipeline.add(new PrivateFilter(argv.private));
-        }
-        if (argv.withScript) {
-            pipeline.add(new ScriptsFilter(argv.withScript));
-        }
-        if (argv.affected !== undefined) {
-            pipeline.add(new AffectedFilter(argv.affected, argv.affectedRevFallback, argv.affectedRevSort));
-        }
-        return pipeline;
-    }
-    _dataComparator(sortBy, order) {
-        const factor = order === 'asc' ? 1 : -1;
-        return (a, b)=>{
-            for (const attr of sortBy){
-                const diff = COMPARATORS[attr](a[attr], b[attr]);
-                if (diff !== 0) {
-                    return factor * diff;
-                }
-            }
-            return 0;
-        };
-    }
-}
-_([
-    LazyCurrentProject()
-], ListCommand.prototype, "project", void 0);
-ListCommand = _([
-    Command({
-        command: 'list',
-        aliases: [
-            'ls'
-        ],
-        describe: 'List workspace',
-        middlewares: [
-            LoadProject
-        ]
-    }),
-    _$1(0, inject(Logger))
-], ListCommand);
-
-class RunCommand extends TaskCommand {
-    // Constructor
-    constructor(logger, taskExpression){
-        super();
-        this.logger = logger;
-        this.taskExpression = taskExpression;
-    }
-    // Methods
-    builder(parser) {
-        return this.addTaskOptions(parser).positional('expr', {
-            type: 'string',
-            demandOption: true,
-            desc: 'Script or task expression'
-        }).option('build-script', {
-            default: 'build',
-            desc: 'Script to use to build dependencies'
-        }).option('deps-mode', {
-            alias: 'd',
-            choice: [
-                'all',
-                'prod',
-                'none'
-            ],
-            default: 'all',
-            desc: 'Dependency selection mode:\n' + ' - all = dependencies AND devDependencies\n' + ' - prod = dependencies\n' + ' - none = nothing'
-        })// Config
-        .strict(false).parserConfiguration({
-            'unknown-options-as-args': true
-        });
-    }
-    async *prepare(args) {
-        // Extract expression
-        const expr = args._.map((arg)=>arg.toString());
-        if (expr[0] === 'run') {
-            expr.splice(0, 1);
-        }
-        expr.unshift(args.expr);
-        // Parse task expression
-        try {
-            const tree = this.taskExpression.parse(expr.join(' '));
-            yield await this.taskExpression.buildTask(tree.roots[0], this.workspace, {
-                buildScript: args.buildScript,
-                buildDeps: args.depsMode
-            });
-        } catch (err) {
-            if (err instanceof TaskExpressionError) {
-                this.logger.error(err.message);
-                throw new ExitException(1);
-            }
-            if (err instanceof TaskSyntaxError) {
-                this.logger.error(`Syntax error in task expression: ${err.message}`);
-                throw new ExitException(1);
-            }
-            throw err;
-        }
-    }
-}
-_([
-    LazyCurrentWorkspace()
-], RunCommand.prototype, "workspace", void 0);
-RunCommand = _([
-    Command({
-        command: 'run <expr>',
-        describe: 'Run a task expression in a workspace, after having built all its dependencies.',
-        middlewares: [
-            LoadProject,
-            LoadWorkspace
-        ]
-    }),
-    _$1(0, inject(Logger)),
-    _$1(1, inject(TaskExpressionService))
-], RunCommand);
-
-class TreeCommand extends InkCommand {
-    // Methods
-    *render() {
-        yield /*#__PURE__*/ jsx(WorkspaceTree, {
-            workspace: this.workspace
-        });
-    }
-}
-_([
-    LazyCurrentWorkspace()
-], TreeCommand.prototype, "workspace", void 0);
-TreeCommand = _([
-    Command({
-        command: 'tree',
-        describe: 'Print workspace dependency tree',
-        middlewares: [
-            LoadProject,
-            LoadWorkspace
-        ]
-    })
-], TreeCommand);
-
-class CorePlugin {
-}
-CorePlugin = _([
-    Plugin({
-        name: 'core',
-        commands: [
-            EachCommand,
-            ExecCommand,
-            GroupCommand,
-            ListCommand,
-            RunCommand,
-            TreeCommand
-        ]
-    })
-], CorePlugin);
-
-export { CorePlugin };
-//# sourceMappingURL=core.plugin-CxgfxFUI.js.map