@jujulego/jill 2.4.0-alpha.3 → 2.4.0-alpha.4

package/bin/jill.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../dist/main.js';

package/dist/commands/each.d.ts

@@ -7,6 +7,7 @@ export interface IEachCommandArgs {
     script: string;
     'build-script': string;
     'deps-mode': WorkspaceDepsMode;
+    'allow-no-workspaces'?: boolean;
     private?: boolean;
     affected: string;
     'affected-rev-fallback': string;

package/dist/commands/list.d.ts

@@ -1,21 +1,30 @@
+import { Logger } from '@jujulego/logger';
 import { type ArgumentsCamelCase, type Argv } from 'yargs';
 import { InkCommand } from '@/src/modules/ink-command.tsx';
 import { type Project } from '@/src/project/project.ts';
 export type Attribute = 'name' | 'version' | 'root' | 'slug';
 export type Data = Partial<Record<Attribute, string>>;
-export interface IListCommandArgs {
+export type Order = 'asc' | 'desc';
+export interface ListCommandArgs {
     private?: boolean;
     'with-script'?: string[];
     affected: string;
     'affected-rev-fallback': string;
     'affected-rev-sort'?: string;
-    attrs: Attribute[];
+    attrs?: Attribute[];
     headers?: boolean;
     long?: boolean;
     json?: boolean;
+    'sort-by'?: Attribute[];
+    order: Order;
 }
-export declare class ListCommand extends InkCommand<IListCommandArgs> {
+export declare class ListCommand extends InkCommand<ListCommandArgs> {
+    private readonly logger;
     readonly project: Project;
-    builder(parser: Argv): Argv<IListCommandArgs>;
-    render(args: ArgumentsCamelCase<IListCommandArgs>): AsyncGenerator<import("react/jsx-runtime").JSX.Element, void, unknown>;
+    constructor(logger: Logger);
+    builder(parser: Argv): Argv<ListCommandArgs>;
+    render(args: ArgumentsCamelCase<ListCommandArgs>): AsyncGenerator<import("react/jsx-runtime").JSX.Element, void, unknown>;
+    private _applyDefaults;
+    private _preparePipeline;
+    private _dataComparator;
 }

package/dist/core.plugin-CZ8_7QfH.js

@@ -0,0 +1,630 @@
+import { Logger } from '@jujulego/logger';
+import { inject } from 'inversify';
+import symbols from 'log-symbols';
+import { b as LazyCurrentProject, L as LoadProject, S as ScriptsFilter, a as PrivateFilter, A as AffectedFilter, P as Pipeline, d as LazyCurrentWorkspace, c as LoadWorkspace, T as TaskExprService, W as WorkspaceTree, f as Plugin } from './workspace-tree-9cXaezk-.js';
+import { h as Command, E as ExitException, I as InkCommand, z as printJson, a as List } from './ink-command-SIxVoU_e.js';
+import { T as TaskCommand } from './jill.application-NaKSF97o.js';
+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 'reflect-metadata';
+import '@jujulego/aegis';
+import '@jujulego/quick-tag';
+import 'chalk-template';
+
+function _ts_decorate$6(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_param$3(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let EachCommand = class EachCommand extends TaskCommand {
+    // Constructor
+    constructor(logger){
+        super();
+        this.logger = logger;
+    }
+    // Methods
+    builder(parser) {
+        return this.addTaskOptions(parser)// Run options
+        .positional("script", {
+            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"
+        }).option("allow-no-workspaces", {
+            type: "boolean",
+            default: false,
+            desc: "Allow no matching workspaces. By default, jill will throw when no affected workspaces are found"
+        })// 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(args) {
+        // Setup pipeline
+        const pipeline = new Pipeline();
+        pipeline.add(new ScriptsFilter([
+            args.script
+        ]));
+        if (args.private !== undefined) {
+            pipeline.add(new PrivateFilter(args.private));
+        }
+        if (args.affected !== undefined) {
+            pipeline.add(new AffectedFilter(args.affected, args.affectedRevFallback, args.affectedRevSort));
+        }
+        // Extract arguments
+        const rest = args._.map((arg)=>arg.toString());
+        if (rest[0] === "each") {
+            rest.splice(0, 1);
+        }
+        // Create script tasks
+        let empty = true;
+        for await (const wks of pipeline.filter(this.project.workspaces())){
+            const task = await wks.run(args.script, rest, {
+                buildScript: args.buildScript,
+                buildDeps: args.depsMode
+            });
+            if (task) {
+                yield task;
+                empty = false;
+            }
+        }
+        if (empty) {
+            this.logger.error(`${symbols.error} No matching workspace found !`);
+            if (args.allowNoWorkspaces === false) {
+                throw new ExitException(1);
+            }
+        }
+    }
+};
+_ts_decorate$6([
+    LazyCurrentProject()
+], EachCommand.prototype, "project", void 0);
+EachCommand = _ts_decorate$6([
+    Command({
+        command: "each <script>",
+        describe: "Run script on many workspaces",
+        middlewares: [
+            LoadProject
+        ]
+    }),
+    _ts_param$3(0, inject(Logger))
+], EachCommand);
+
+function _ts_decorate$5(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+let ExecCommand = class ExecCommand extends TaskCommand {
+    // 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
+        });
+        yield task;
+    }
+};
+_ts_decorate$5([
+    LazyCurrentWorkspace()
+], ExecCommand.prototype, "workspace", void 0);
+ExecCommand = _ts_decorate$5([
+    Command({
+        command: "exec <command>",
+        aliases: [
+            "$0"
+        ],
+        describe: "Run command inside workspace, after all its dependencies has been built.",
+        middlewares: [
+            LoadProject,
+            LoadWorkspace
+        ]
+    })
+], ExecCommand);
+
+function _ts_decorate$4(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_param$2(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let GroupCommand = 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;
+    }
+};
+_ts_decorate$4([
+    LazyCurrentWorkspace()
+], GroupCommand.prototype, "workspace", void 0);
+GroupCommand = _ts_decorate$4([
+    Command({
+        command: "group <script..>",
+        describe: "Run many scripts inside a workspace (experimental)",
+        middlewares: [
+            LoadProject,
+            LoadWorkspace
+        ]
+    }),
+    _ts_param$2(0, inject(TaskExprService))
+], GroupCommand);
+
+function _ts_decorate$3(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_param$1(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+// 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;
+    };
+}
+let ListCommand = 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;
+        };
+    }
+};
+_ts_decorate$3([
+    LazyCurrentProject()
+], ListCommand.prototype, "project", void 0);
+ListCommand = _ts_decorate$3([
+    Command({
+        command: "list",
+        aliases: [
+            "ls"
+        ],
+        describe: "List workspace",
+        middlewares: [
+            LoadProject
+        ]
+    }),
+    _ts_param$1(0, inject(Logger))
+], ListCommand);
+
+function _ts_decorate$2(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let RunCommand = class RunCommand extends TaskCommand {
+    // Constructor
+    constructor(logger){
+        super();
+        this.logger = logger;
+    }
+    // Methods
+    builder(parser) {
+        return this.addTaskOptions(parser).positional("script", {
+            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"
+        })// Config
+        .strict(false).parserConfiguration({
+            "unknown-options-as-args": true
+        });
+    }
+    async *prepare(args) {
+        // Extract arguments
+        const rest = args._.map((arg)=>arg.toString());
+        if (rest[0] === "run") {
+            rest.splice(0, 1);
+        }
+        // Run script in workspace
+        const task = await this.workspace.run(args.script, rest, {
+            buildScript: args.buildScript,
+            buildDeps: args.depsMode
+        });
+        if (task) {
+            yield task;
+        } else {
+            this.logger.error(`Workspace ${this.workspace.name} have no ${args.script} script`);
+            throw new ExitException(1);
+        }
+    }
+};
+_ts_decorate$2([
+    LazyCurrentWorkspace()
+], RunCommand.prototype, "workspace", void 0);
+RunCommand = _ts_decorate$2([
+    Command({
+        command: "run <script>",
+        describe: "Run script inside workspace",
+        middlewares: [
+            LoadProject,
+            LoadWorkspace
+        ]
+    }),
+    _ts_param(0, inject(Logger))
+], RunCommand);
+
+function _ts_decorate$1(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+let TreeCommand = class TreeCommand extends InkCommand {
+    // Methods
+    *render() {
+        yield /*#__PURE__*/ jsx(WorkspaceTree, {
+            workspace: this.workspace
+        });
+    }
+};
+_ts_decorate$1([
+    LazyCurrentWorkspace()
+], TreeCommand.prototype, "workspace", void 0);
+TreeCommand = _ts_decorate$1([
+    Command({
+        command: "tree",
+        describe: "Print workspace dependency tree",
+        middlewares: [
+            LoadProject,
+            LoadWorkspace
+        ]
+    })
+], TreeCommand);
+
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+let CorePlugin = class CorePlugin {
+};
+CorePlugin = _ts_decorate([
+    Plugin({
+        name: "core",
+        commands: [
+            EachCommand,
+            ExecCommand,
+            GroupCommand,
+            ListCommand,
+            RunCommand,
+            TreeCommand
+        ]
+    })
+], CorePlugin);
+
+export { CorePlugin };
+//# sourceMappingURL=core.plugin-CZ8_7QfH.js.map