@jujulego/jill 2.4.0-alpha.5 → 2.4.0

package/README.md

@@ -11,9 +11,9 @@ Zero-config monorepo cli
 Jill uses the `workspaces` attribute of your root package.json manifest to build your workspaces dependency tree.
 That done it can offer you various utilities:
 - `jill list` prints a list of all your workspaces, with many useful filters
-- `jill run` build all workspace's local dependencies before run a given script
-- `jill each` do the same as `run` but for a list of workspaces, optimizing builds.<br />
-  Supports the same filters as `list`.
+- `jill run` Run a task expression in a workspace, after having built all its dependencies.
+- `jill group` Deprecated in favor of run
+- `jill each` Run a task expression in many workspace, after having built all theirs dependencies.
 - `jill tree` prints current workspace's local dependency tree
 
 It supports both `npm` and `yarn`.
@@ -24,10 +24,7 @@ Jill will run hook script like npm do, for both npm and yarn. As npm, when you t
 
 This feature can be disabled using the `--no-hooks` option: `jill run --no-hooks test`.
 
-### Experimental features
-- `jill group` same as `run` but allows to run multiple scripts in sequence or in parallel using the task syntax
-
-#### Task syntax _(only supported by `jill group` command yet)_
+#### Task expression syntax
 Allows to instruct multiple tasks with the given orchestration. The orchestration is given by the following operators:
 - `&&` in sequence
 - `||` fallbacks
@@ -36,22 +33,22 @@ Allows to instruct multiple tasks with the given orchestration. The orchestratio
 ##### Examples:
 - This will run scripts **taskA**, **taskB** and **taskC** in order, one after another.
   ```shell
-  jill group 'taskA && taskB && taskC'
+  jill run 'taskA && taskB && taskC'
   ```
 
 - This will run first **taskA**, if it fails it will run **taskB**, then **taskC** in order, until one succeed.
   ```shell
-  jill group 'taskA || taskB || taskC'
+  jill run 'taskA || taskB || taskC'
   ```
 
 - This will run scripts **taskA**, **taskB** and **taskC** in parallel.
   ```shell
-  jill group 'taskA // taskB // taskC'
+  jill run 'taskA // taskB // taskC'
   ```
 
 - And you can create more complex flows: this will run **taskA** and **taskB** in parallel, and then **taskC** when both tasks are ended
   ```shell
-  jill group '(taskA // taskB) && taskC'
+  jill run '(taskA // taskB) && taskC'
   ```
 
 ## Installation

package/dist/commands/each.d.ts

@@ -3,8 +3,9 @@ import { type ArgumentsCamelCase, type Argv } from 'yargs';
 import { TaskCommand } from '@/src/modules/task-command.tsx';
 import { type Project } from '@/src/project/project.ts';
 import { type WorkspaceDepsMode } from '@/src/project/workspace.ts';
-export interface IEachCommandArgs {
-    script: string;
+import { TaskExpressionService } from '@/src/tasks/task-expression.service.ts';
+export interface EachCommandArgs {
+    expr: string;
     'build-script': string;
     'deps-mode': WorkspaceDepsMode;
     'allow-no-workspaces'?: boolean;
@@ -13,10 +14,12 @@ export interface IEachCommandArgs {
     'affected-rev-fallback': string;
     'affected-rev-sort'?: string;
 }
-export declare class EachCommand extends TaskCommand<IEachCommandArgs> {
+export declare class EachCommand extends TaskCommand<EachCommandArgs> {
     private readonly logger;
+    private readonly taskExpression;
     readonly project: Project;
-    constructor(logger: Logger);
-    builder(parser: Argv): Argv<IEachCommandArgs>;
-    prepare(args: ArgumentsCamelCase<IEachCommandArgs>): AsyncGenerator<import("../index.ts").ScriptTask, void, unknown>;
+    constructor(logger: Logger, taskExpression: TaskExpressionService);
+    builder(parser: Argv): Argv<EachCommandArgs>;
+    prepare(argv: ArgumentsCamelCase<EachCommandArgs>): AsyncGenerator<import("@jujulego/tasks").Task<import("@jujulego/tasks").TaskContext>, void, unknown>;
+    private _preparePipeline;
 }

package/dist/commands/group.d.ts

@@ -1,7 +1,7 @@
 import { type ArgumentsCamelCase, type Argv } from 'yargs';
 import { TaskCommand } from '@/src/modules/task-command.tsx';
 import { type Workspace, type WorkspaceDepsMode } from '@/src/project/workspace.ts';
-import { TaskExprService, type TaskTree } from '@/src/tasks/task-expr.service.ts';
+import { TaskExpressionService, type TaskTree } from '@/src/tasks/task-expression.service.ts';
 export interface IGroupCommandArgs {
     script: TaskTree;
     'build-script': string;
@@ -10,7 +10,7 @@ export interface IGroupCommandArgs {
 export declare class GroupCommand extends TaskCommand<IGroupCommandArgs> {
     private readonly taskExpr;
     readonly workspace: Workspace;
-    constructor(taskExpr: TaskExprService);
+    constructor(taskExpr: TaskExpressionService);
     builder(parser: Argv): Argv<IGroupCommandArgs>;
     prepare(args: ArgumentsCamelCase<IGroupCommandArgs>): AsyncGenerator<import("@jujulego/tasks").Task<import("@jujulego/tasks").TaskContext>, void, unknown>;
 }

package/dist/commands/run.d.ts

@@ -2,21 +2,23 @@ import { Logger } from '@jujulego/logger';
 import { type ArgumentsCamelCase, type Argv } from 'yargs';
 import { TaskCommand } from '@/src/modules/task-command.tsx';
 import { type Workspace, type WorkspaceDepsMode } from '@/src/project/workspace.ts';
+import { TaskExpressionService } from '@/src/tasks/task-expression.service.ts';
 export interface IRunCommandArgs {
-    script: string;
+    expr: string;
     'build-script': string;
     'deps-mode': WorkspaceDepsMode;
 }
 export declare class RunCommand extends TaskCommand<IRunCommandArgs> {
     private readonly logger;
+    private readonly taskExpression;
     readonly workspace: Workspace;
-    constructor(logger: Logger);
+    constructor(logger: Logger, taskExpression: TaskExpressionService);
     builder(parser: Argv): Argv<import("@/src/modules/task-command.tsx").ITaskCommandArgs & {
-        script: string;
+        expr: string;
     } & {
         "build-script": string;
     } & {
         "deps-mode": "all";
     }>;
-    prepare(args: ArgumentsCamelCase<IRunCommandArgs>): AsyncGenerator<import("../index.ts").ScriptTask, void, unknown>;
+    prepare(args: ArgumentsCamelCase<IRunCommandArgs>): AsyncGenerator<import("@jujulego/tasks").Task<import("@jujulego/tasks").TaskContext>, void, unknown>;
 }

package/dist/{core.plugin-ED-2XO_T.js → core.plugin-eIXhcLId.js}

@@ -1,9 +1,11 @@
+import { _ } from '@swc/helpers/_/_ts_decorate';
+import { _ as _$1 } from '@swc/helpers/_/_ts_param';
 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-DEg4wm69.js';
-import { h as Command, E as ExitException, I as InkCommand, z as printJson, a as List } from './ink-command-HSaTNbaX.js';
-import { T as TaskCommand } from './jill.application-nR6EmV7y.js';
+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-1zFRh2Fq.js';
+import { f as Command, E as ExitException, I as InkCommand, y as printJson, a as List } from './ink-command-8BDSCbqp.js';
+import { T as TaskCommand } from './jill.application-8LJ2a7MD.js';
 import { jsx } from 'react/jsx-runtime';
 import chalk from 'chalk';
 import path from 'node:path';
@@ -35,29 +37,20 @@ 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 {
+class EachCommand extends TaskCommand {
     // Constructor
-    constructor(logger){
+    constructor(logger, taskExpression){
         super();
         this.logger = logger;
+        this.taskExpression = taskExpression;
     }
     // Methods
     builder(parser) {
         return this.addTaskOptions(parser)// Run options
-        .positional("script", {
+        .positional("expr", {
             type: "string",
-            demandOption: true
+            demandOption: true,
+            desc: "Script or task expression"
         }).option("build-script", {
             default: "build",
             desc: "Script to use to build dependencies"
@@ -73,7 +66,7 @@ let EachCommand = class EachCommand extends TaskCommand {
         }).option("allow-no-workspaces", {
             type: "boolean",
             default: false,
-            desc: "Allow no matching workspaces. By default, jill will throw when no affected workspaces are found"
+            desc: "Allow no matching workspaces. Without it jill will exit with code 1 if no workspace matches"
         })// Filters
         .option("private", {
             type: "boolean",
@@ -99,64 +92,75 @@ let EachCommand = class EachCommand extends TaskCommand {
             "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
+    async *prepare(argv) {
         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;
+        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 (args.allowNoWorkspaces === false) {
+            if (argv.allowNoWorkspaces === false) {
                 throw new ExitException(1);
             }
         }
     }
-};
-_ts_decorate$6([
+    _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 = _ts_decorate$6([
+EachCommand = _([
     Command({
-        command: "each <script>",
-        describe: "Run script on many workspaces",
+        command: "each <expr>",
+        describe: "Run a task expression in many workspace, after having built all theirs dependencies.",
         middlewares: [
             LoadProject
         ]
     }),
-    _ts_param$3(0, inject(Logger))
+    _$1(0, inject(Logger)),
+    _$1(1, inject(TaskExpressionService))
 ], 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 {
+class ExecCommand extends TaskCommand {
     // Methods
     builder(parser) {
         return this.addTaskOptions(parser).positional("command", {
@@ -193,11 +197,11 @@ let ExecCommand = class ExecCommand extends TaskCommand {
         });
         yield task;
     }
-};
-_ts_decorate$5([
+}
+_([
     LazyCurrentWorkspace()
 ], ExecCommand.prototype, "workspace", void 0);
-ExecCommand = _ts_decorate$5([
+ExecCommand = _([
     Command({
         command: "exec <command>",
         aliases: [
@@ -211,18 +215,7 @@ ExecCommand = _ts_decorate$5([
     })
 ], 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 {
+class GroupCommand extends TaskCommand {
     // Constructor
     constructor(taskExpr){
         super();
@@ -256,33 +249,23 @@ let GroupCommand = class GroupCommand extends TaskCommand {
         });
         yield group;
     }
-};
-_ts_decorate$4([
+}
+_([
     LazyCurrentWorkspace()
 ], GroupCommand.prototype, "workspace", void 0);
-GroupCommand = _ts_decorate$4([
+GroupCommand = _([
     Command({
         command: "group <script..>",
         describe: "Run many scripts inside a workspace (experimental)",
+        deprecated: true,
         middlewares: [
             LoadProject,
             LoadWorkspace
         ]
     }),
-    _ts_param$2(0, inject(TaskExprService))
+    _$1(0, inject(TaskExpressionService))
 ], 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",
@@ -320,7 +303,7 @@ function buildExtractor(attrs) {
         return data;
     };
 }
-let ListCommand = class ListCommand extends InkCommand {
+class ListCommand extends InkCommand {
     // Constructor
     constructor(logger){
         super();
@@ -485,11 +468,11 @@ let ListCommand = class ListCommand extends InkCommand {
             return 0;
         };
     }
-};
-_ts_decorate$3([
+}
+_([
     LazyCurrentProject()
 ], ListCommand.prototype, "project", void 0);
-ListCommand = _ts_decorate$3([
+ListCommand = _([
     Command({
         command: "list",
         aliases: [
@@ -500,31 +483,22 @@ ListCommand = _ts_decorate$3([
             LoadProject
         ]
     }),
-    _ts_param$1(0, inject(Logger))
+    _$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 {
+class RunCommand extends TaskCommand {
     // Constructor
-    constructor(logger){
+    constructor(logger, taskExpression){
         super();
         this.logger = logger;
+        this.taskExpression = taskExpression;
     }
     // Methods
     builder(parser) {
-        return this.addTaskOptions(parser).positional("script", {
+        return this.addTaskOptions(parser).positional("expr", {
             type: "string",
-            demandOption: true
+            demandOption: true,
+            desc: "Script or task expression"
         }).option("build-script", {
             default: "build",
             desc: "Script to use to build dependencies"
@@ -543,57 +517,60 @@ let RunCommand = class RunCommand extends TaskCommand {
         });
     }
     async *prepare(args) {
-        // Extract arguments
-        const rest = args._.map((arg)=>arg.toString());
-        if (rest[0] === "run") {
-            rest.splice(0, 1);
+        // Extract expression
+        const expr = args._.map((arg)=>arg.toString());
+        if (expr[0] === "run") {
+            expr.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);
+        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;
         }
     }
-};
-_ts_decorate$2([
+}
+_([
     LazyCurrentWorkspace()
 ], RunCommand.prototype, "workspace", void 0);
-RunCommand = _ts_decorate$2([
+RunCommand = _([
     Command({
-        command: "run <script>",
-        describe: "Run script inside workspace",
+        command: "run <expr>",
+        describe: "Run a task expression in a workspace, after having built all its dependencies.",
         middlewares: [
             LoadProject,
             LoadWorkspace
         ]
     }),
-    _ts_param(0, inject(Logger))
+    _$1(0, inject(Logger)),
+    _$1(1, inject(TaskExpressionService))
 ], 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 {
+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([
+TreeCommand = _([
     Command({
         command: "tree",
         describe: "Print workspace dependency tree",
@@ -604,15 +581,9 @@ TreeCommand = _ts_decorate$1([
     })
 ], 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;
+class CorePlugin {
 }
-let CorePlugin = class CorePlugin {
-};
-CorePlugin = _ts_decorate([
+CorePlugin = _([
     Plugin({
         name: "core",
         commands: [
@@ -627,4 +598,4 @@ CorePlugin = _ts_decorate([
 ], CorePlugin);
 
 export { CorePlugin };
-//# sourceMappingURL=core.plugin-ED-2XO_T.js.map
+//# sourceMappingURL=core.plugin-eIXhcLId.js.map