@jujulego/jill 2.4.0-alpha.5 → 2.4.0

package/dist/ui/hooks/useFlatTaskTree.d.ts

@@ -0,0 +1,14 @@
+import { Task, TaskManager } from '@jujulego/tasks';
+export interface FlatTask {
+    task: Task;
+    level: number;
+}
+/**
+ * Sorts tasks according to workspace and script, keeping command at the end
+ */
+export declare function taskComparator(a: Task, b: Task): number;
+/**
+ * Extract tasks to be printed, with their level in the tree
+ */
+export declare function flatTasks(tasks: readonly Task[], isVerbose: boolean, groupId?: string, level?: number): Generator<FlatTask>;
+export declare function useFlatTaskTree(manager: TaskManager): FlatTask[];

package/dist/ui/hooks/useIsVerbose.d.ts

@@ -0,0 +1 @@
+export declare function useIsVerbose(): boolean;

package/dist/ui/hooks/useStdoutDimensions.d.ts

@@ -0,0 +1,4 @@
+export declare function useStdoutDimensions(): {
+    columns: number;
+    rows: number;
+};

package/dist/ui/task-tree-completed.d.ts

@@ -0,0 +1,5 @@
+import { TaskManager } from '@jujulego/tasks';
+export interface TaskTreeCompletedProps {
+    readonly manager: TaskManager;
+}
+export default function TaskTreeCompleted({ manager }: TaskTreeCompletedProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/task-tree-full-spinner.d.ts

@@ -0,0 +1,5 @@
+import { TaskManager } from '@jujulego/tasks';
+export interface TaskTreeFullSpinnerProps {
+    readonly manager: TaskManager;
+}
+export default function TaskTreeFullSpinner({ manager }: TaskTreeFullSpinnerProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/task-tree-scrollable-spinner.d.ts

@@ -0,0 +1,5 @@
+import { TaskManager } from '@jujulego/tasks';
+export interface TaskTreeScrollableSpinnerProps {
+    readonly manager: TaskManager;
+}
+export default function TaskTreeScrollableSpinner({ manager }: TaskTreeScrollableSpinnerProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/task-tree-spinner.d.ts

@@ -0,0 +1,5 @@
+import { TaskManager } from '@jujulego/tasks';
+export interface TaskTreeSpinnerProps {
+    readonly manager: TaskManager;
+}
+export default function TaskTreeSpinner({ manager }: TaskTreeSpinnerProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/task-tree-stats.d.ts

@@ -0,0 +1,5 @@
+import { TaskManager } from '@jujulego/tasks';
+export interface TaskTreeStatsProps {
+    readonly manager: TaskManager;
+}
+export default function TaskTreeStats({ manager }: TaskTreeStatsProps): import("react/jsx-runtime").JSX.Element;

package/dist/{workspace-tree-DEg4wm69.js → workspace-tree-1zFRh2Fq.js}

@@ -1,5 +1,7 @@
+import { _ } from '@swc/helpers/_/_ts_decorate';
 import { Logger, withLabel } from '@jujulego/logger';
-import { S as Service, v as TASK_MANAGER, o as lazyInject, C as CONFIG, n as container, r as CommandTask, u as ScriptTask, M as Middleware, F as ContextService, m as CURRENT, p as lazyInjectNamed, E as ExitException, j as getRegistry, l as setModule } from './ink-command-HSaTNbaX.js';
+import { S as Service, u as TASK_MANAGER, n as lazyInject, C as CONFIG, m as container, q as CommandTask, t as ScriptTask, M as Middleware, D as ContextService, l as CURRENT, o as lazyInjectNamed, E as ExitException, i as getRegistry, k as setModule } from './ink-command-8BDSCbqp.js';
+import { _ as _$1 } from '@swc/helpers/_/_ts_param';
 import { inject, injectable, ContainerModule, id } from 'inversify';
 import symbols from 'log-symbols';
 import path from 'node:path';
@@ -50,18 +52,7 @@ async function* streamLines(task, stream) {
     }
 }
 
-function _ts_decorate$7(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$4(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-let GitService = class GitService {
+class GitService {
     // Constructor
     constructor(manager, logger){
         this.manager = manager;
@@ -171,19 +162,13 @@ let GitService = class GitService {
         }
         return result;
     }
-};
-GitService = _ts_decorate$7([
+}
+GitService = _([
     Service(),
-    _ts_param$4(0, inject(TASK_MANAGER)),
-    _ts_param$4(1, inject(Logger))
+    _$1(0, inject(TASK_MANAGER)),
+    _$1(1, inject(Logger))
 ], GitService);
 
-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;
-}
 // Class
 class AffectedFilter {
     // Constructor
@@ -244,10 +229,10 @@ class AffectedFilter {
         return await workspace.isAffected(rev);
     }
 }
-_ts_decorate$6([
+_([
     lazyInject(Logger)
 ], AffectedFilter.prototype, "_logger", void 0);
-_ts_decorate$6([
+_([
     lazyInject(GitService)
 ], AffectedFilter.prototype, "_git", void 0);
 
@@ -294,23 +279,22 @@ class PrivateFilter {
 // Filter
 class ScriptsFilter {
     // Constructor
-    constructor(scripts){
+    constructor(scripts, all = false){
         this.scripts = scripts;
+        this.all = all;
     }
     // Methods
     test(workspace) {
         const scripts = Object.keys(workspace.manifest.scripts || {});
-        return this.scripts.some((scr)=>scripts.includes(scr));
+        if (this.all) {
+            return this.scripts.every((scr)=>scripts.includes(scr));
+        } else {
+            return this.scripts.some((scr)=>scripts.includes(scr));
+        }
     }
 }
 
-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 Workspace = class Workspace {
+class Workspace {
     // Constructor
     constructor(_cwd, manifest, project){
         this._cwd = _cwd;
@@ -462,24 +446,18 @@ let Workspace = class Workspace {
     get cwd() {
         return path.resolve(this.project.root, this._cwd);
     }
-};
-_ts_decorate$5([
+}
+_([
     lazyInject(GitService)
 ], Workspace.prototype, "_git", void 0);
-_ts_decorate$5([
+_([
     lazyInject(CONFIG)
 ], Workspace.prototype, "_config", void 0);
-Workspace = _ts_decorate$5([
+Workspace = _([
     injectable()
 ], Workspace);
 
-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;
-}
-let Project = class Project {
+class Project {
     // Constructor
     constructor(_root, _logger, opts = {}){
         this._root = _root;
@@ -612,29 +590,18 @@ let Project = class Project {
     get root() {
         return path.resolve(this._root);
     }
-};
-Project = _ts_decorate$4([
+}
+Project = _([
     injectable()
 ], Project);
 
-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$3(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
 // Constants
 const MANIFEST = "package.json";
 const LOCK_FILES = [
     "package-lock.json",
     "yarn.lock"
 ];
-let ProjectRepository = class ProjectRepository {
+class ProjectRepository {
     // Constructor
     constructor(logger){
         this._cache = new Map();
@@ -700,24 +667,13 @@ let ProjectRepository = class ProjectRepository {
         }
         return project;
     }
-};
-ProjectRepository = _ts_decorate$3([
+}
+ProjectRepository = _([
     Service(),
-    _ts_param$3(0, inject(Logger))
+    _$1(0, inject(Logger))
 ], ProjectRepository);
 
-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$2(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-let LoadProject = class LoadProject {
+class LoadProject {
     // Constructor
     constructor(projects, context){
         this.projects = projects;
@@ -748,11 +704,11 @@ let LoadProject = class LoadProject {
             args.project = this.context.project.root;
         }
     }
-};
-LoadProject = _ts_decorate$2([
+}
+LoadProject = _([
     Middleware(),
-    _ts_param$2(0, inject(ProjectRepository)),
-    _ts_param$2(1, inject(ContextService))
+    _$1(0, inject(ProjectRepository)),
+    _$1(1, inject(ContextService))
 ], LoadProject);
 // Lazy injection
 function LazyCurrentProject() {
@@ -767,18 +723,7 @@ container.bind(Project).toDynamicValue(({ container })=>{
     return prj;
 }).whenTargetNamed(CURRENT);
 
-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;
-}
-function _ts_param$1(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-let LoadWorkspace = class LoadWorkspace {
+class LoadWorkspace {
     // Constructor
     constructor(context, logger){
         this.context = context;
@@ -810,14 +755,14 @@ let LoadWorkspace = class LoadWorkspace {
             this.context.workspace = workspace;
         }
     }
-};
-_ts_decorate$1([
+}
+_([
     LazyCurrentProject()
 ], LoadWorkspace.prototype, "project", void 0);
-LoadWorkspace = _ts_decorate$1([
+LoadWorkspace = _([
     Middleware(),
-    _ts_param$1(0, inject(ContextService)),
-    _ts_param$1(1, inject(Logger))
+    _$1(0, inject(ContextService)),
+    _$1(1, inject(Logger))
 ], LoadWorkspace);
 // Decorators
 function LazyCurrentWorkspace() {
@@ -855,18 +800,12 @@ function Plugin(opts) {
     };
 }
 
-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 TaskExpressionError extends Error {
 }
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
+class TaskSyntaxError extends Error {
 }
-let TaskExprService = class TaskExprService1 {
+
+class TaskExpressionService {
     // Statics
     static isTaskNode(node) {
         return "script" in node;
@@ -956,13 +895,13 @@ let TaskExprService = class TaskExprService1 {
             // Handle argument
             if (token.type === "argument") {
                 if (!node) {
-                    throw new Error(lexer.formatError(token, "Unexpected argument"));
-                } else if (TaskExprService.isTaskNode(node)) {
+                    throw new TaskSyntaxError(lexer.formatError(token, "Unexpected argument"));
+                } else if (TaskExpressionService.isTaskNode(node)) {
                     node.args.push(token.value);
                 } else {
                     const lastTask = node.tasks[node.tasks.length - 1];
-                    if (!lastTask || !TaskExprService.isTaskNode(lastTask)) {
-                        throw new Error(lexer.formatError(token, "Unexpected argument"));
+                    if (!lastTask || !TaskExpressionService.isTaskNode(lastTask)) {
+                        throw new TaskSyntaxError(lexer.formatError(token, "Unexpected argument"));
                     } else {
                         lastTask.args.push(token.value);
                     }
@@ -973,8 +912,8 @@ let TaskExprService = class TaskExprService1 {
             if (token.type === "operator") {
                 const operator = token.value;
                 if (!node) {
-                    throw new Error(lexer.formatError(token, "Unexpected operator"));
-                } else if (TaskExprService.isTaskNode(node)) {
+                    throw new TaskSyntaxError(lexer.formatError(token, "Unexpected operator"));
+                } else if (TaskExpressionService.isTaskNode(node)) {
                     node = {
                         operator,
                         tasks: [
@@ -1010,16 +949,16 @@ let TaskExprService = class TaskExprService1 {
             } else if (token.type === "lparen") {
                 const res = this._nextNode(lexer, i + 1);
                 if (!res) {
-                    throw new Error(lexer.formatError(token, "Empty group found"));
+                    throw new TaskSyntaxError(lexer.formatError(token, "Empty group found"));
                 }
                 child = res;
             } else {
-                throw new Error(lexer.formatError(token, "Unexpected token"));
+                throw new TaskSyntaxError(lexer.formatError(token, "Unexpected token"));
             }
             if (!node) {
                 node = child;
-            } else if (TaskExprService.isTaskNode(node)) {
-                throw new Error(lexer.formatError(token, "Unexpected token, expected an operator"));
+            } else if (TaskExpressionService.isTaskNode(node)) {
+                throw new TaskSyntaxError(lexer.formatError(token, "Unexpected token, expected an operator"));
             } else {
                 node.tasks.push(child);
             }
@@ -1042,29 +981,48 @@ let TaskExprService = class TaskExprService1 {
         }
         return tree;
     }
+    *extractScripts(node) {
+        if ("roots" in node) {
+            for (const child of node.roots){
+                yield* this.extractScripts(child);
+            }
+        } else if (TaskExpressionService.isTaskNode(node)) {
+            yield node.script;
+        } else {
+            for (const child of node.tasks){
+                yield* this.extractScripts(child);
+            }
+        }
+    }
     async buildTask(node, workspace, opts) {
-        if (TaskExprService.isTaskNode(node)) {
+        if (TaskExpressionService.isTaskNode(node)) {
             const task = await workspace.run(node.script, node.args, opts);
             if (!task) {
-                throw new Error(`Workspace ${workspace.name} have no ${node.script} script`);
+                throw new TaskExpressionError(`Workspace ${workspace.name} have no ${node.script} script`);
             }
             return task;
         } else {
             let group;
             if (node.operator === "//") {
-                group = new ParallelGroup("In parallel", {}, {
+                group = new ParallelGroup("In parallel", {
+                    workspace
+                }, {
                     logger: this._logger
                 });
             } else if (node.operator === "||") {
-                group = new FallbackGroup("Fallbacks", {}, {
+                group = new FallbackGroup("Fallbacks", {
+                    workspace
+                }, {
                     logger: this._logger
                 });
             } else {
-                if (node.operator === "->" && TaskExprService._sequenceOperatorWarn) {
+                if (node.operator === "->" && TaskExpressionService._sequenceOperatorWarn) {
                     this._logger.warn("Sequence operator -> is deprecated in favor of &&. It will be removed in a next major release.");
-                    TaskExprService._sequenceOperatorWarn = true;
+                    TaskExpressionService._sequenceOperatorWarn = true;
                 }
-                group = new SequenceGroup("In sequence", {}, {
+                group = new SequenceGroup("In sequence", {
+                    workspace
+                }, {
                     logger: this._logger
                 });
             }
@@ -1074,11 +1032,11 @@ let TaskExprService = class TaskExprService1 {
             return group;
         }
     }
-};
-TaskExprService = _ts_decorate([
+}
+TaskExpressionService = _([
     Service(),
-    _ts_param(0, inject(Logger))
-], TaskExprService);
+    _$1(0, inject(Logger))
+], TaskExpressionService);
 
 // Utils
 const style = (dev)=>({
@@ -1157,5 +1115,5 @@ function WorkspaceTree(props) {
     });
 }
 
-export { AffectedFilter as A, GitService as G, LoadProject as L, Pipeline as P, ScriptsFilter as S, TaskExprService as T, WorkspaceTree as W, PrivateFilter as a, LazyCurrentProject as b, LoadWorkspace as c, LazyCurrentWorkspace as d, PluginModule as e, Plugin as f, Project as g, ProjectRepository as h, Workspace as i, combine as j, streamLines as s };
-//# sourceMappingURL=workspace-tree-DEg4wm69.js.map
+export { AffectedFilter as A, GitService as G, LoadProject as L, Pipeline as P, ScriptsFilter as S, TaskExpressionService as T, WorkspaceTree as W, PrivateFilter as a, LazyCurrentProject as b, LoadWorkspace as c, LazyCurrentWorkspace as d, PluginModule as e, Plugin as f, Project as g, ProjectRepository as h, Workspace as i, combine as j, TaskExpressionError as k, TaskSyntaxError as l, streamLines as s };
+//# sourceMappingURL=workspace-tree-1zFRh2Fq.js.map