@jujulego/jill 2.5.2 → 3.0.0-alpha.2

package/dist/core.plugin-Bxu0Sx70.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-CyjZrimj.js';
-import { f as Command, E as ExitException, I as InkCommand, y as printJson, a as List } from './ink-command-S3TpJLFi.js';
-import { T as TaskCommand } from './jill.application-CGujSe1_.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-Bxu0Sx70.js.map