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

package/dist/workspace-tree-9cXaezk-.js

@@ -0,0 +1,1152 @@
+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-SIxVoU_e.js';
+import { inject, injectable, ContainerModule, id } from 'inversify';
+import symbols from 'log-symbols';
+import path from 'node:path';
+import { satisfies } from 'semver';
+import { off$, once$, iterate$ } from '@jujulego/event-tree';
+import { SpawnTask, ParallelGroup, FallbackGroup, SequenceGroup } from '@jujulego/tasks';
+import { Lock } from '@jujulego/utils';
+import { Glob } from 'glob';
+import fs from 'node:fs';
+import normalize from 'normalize-package-data';
+import { PathScurry } from 'path-scurry';
+import fs$1 from 'node:fs/promises';
+import moo from 'moo';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { Text, Newline } from 'ink';
+import { useState, useEffect } from 'react';
+
+// Utils
+async function* combine(...generators) {
+    for (const gen of generators){
+        yield* gen;
+    }
+}
+async function* streamLines(task, stream) {
+    // Abort
+    const off = off$();
+    once$(task, "completed", off);
+    // Stream
+    let current = "";
+    try {
+        for await (const chunk of iterate$(task, `stream.${stream}`, {
+            off
+        })){
+            const data = current + chunk.data.toString("utf-8");
+            const lines = data.split(/\r?\n/);
+            current = lines.pop() ?? "";
+            for (const line of lines){
+                yield line;
+            }
+        }
+    } catch (err) {
+        if (err.message !== "Unsubscribed !") {
+            throw err;
+        }
+        if (current) {
+            yield current;
+        }
+    }
+}
+
+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 {
+    // Constructor
+    constructor(manager, logger){
+        this.manager = manager;
+        this.logger = logger;
+    }
+    // Methods
+    /**
+   * Runs a git command inside a SpawnTask
+   *
+   * @param cmd
+   * @param args
+   * @param options
+   */ command(cmd, args, options = {}) {
+        const opts = {
+            logger: this.logger,
+            ...options
+        };
+        // Create task
+        const task = new SpawnTask("git", [
+            cmd,
+            ...args
+        ], {
+            command: cmd,
+            hidden: true
+        }, opts);
+        task.on("stream", ({ data })=>opts.logger.debug(data.toString("utf-8")));
+        this.manager.add(task);
+        return task;
+    }
+    /**
+   * Runs git branch
+   *
+   * @param args
+   * @param options
+   */ branch(args, options) {
+        return this.command("branch", args, options);
+    }
+    /**
+   * Runs git diff
+   *
+   * @param args
+   * @param options
+   */ diff(args, options) {
+        return this.command("diff", args, options);
+    }
+    /**
+   * Runs git tag
+   *
+   * @param args
+   * @param options
+   */ tag(args, options) {
+        return this.command("tag", args, options);
+    }
+    /**
+   * Uses git diff to detect if given files have been affected since given reference
+   *
+   * @param reference
+   * @param files
+   * @param opts
+   */ isAffected(reference, files = [], opts) {
+        return new Promise((resolve, reject)=>{
+            const task = this.diff([
+                "--quiet",
+                reference,
+                "--",
+                ...files
+            ], opts);
+            once$(task, "status.done", ()=>resolve(false));
+            once$(task, "status.failed", ()=>{
+                if (task.exitCode) {
+                    resolve(true);
+                } else {
+                    reject(new Error(`Task ${task.name} failed`));
+                }
+            });
+        });
+    }
+    /**
+   * List git branches
+   *
+   * @param args
+   * @param opts
+   */ async listBranches(args = [], opts) {
+        const task = this.branch([
+            "-l",
+            ...args
+        ], opts);
+        const result = [];
+        for await (const line of streamLines(task, "stdout")){
+            result.push(line.replace(/^[ *] /, ""));
+        }
+        return result;
+    }
+    /**
+   * List git tags
+   *
+   * @param args
+   * @param opts
+   */ async listTags(args = [], opts) {
+        const task = this.tag([
+            "-l",
+            ...args
+        ], opts);
+        const result = [];
+        for await (const line of streamLines(task, "stdout")){
+            result.push(line);
+        }
+        return result;
+    }
+};
+GitService = _ts_decorate$7([
+    Service(),
+    _ts_param$4(0, inject(TASK_MANAGER)),
+    _ts_param$4(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
+    constructor(format, fallback, sort){
+        this.format = format;
+        this.fallback = fallback;
+        this.sort = sort;
+    }
+    // Methods
+    async _formatRevision(wks) {
+        const logger = this._logger.child(withLabel(wks.name));
+        // Format revision
+        let result = this.format;
+        result = result.replace(/(?<!\\)((?:\\\\)*)%name/g, `$1${wks.name}`);
+        result = result.replace(/\\(.)/g, "$1");
+        // Ask git to complete it
+        const sortArgs = this.sort ? [
+            "--sort",
+            this.sort
+        ] : [];
+        // - search in branches
+        if (result.includes("*")) {
+            const branches = await this._git.listBranches([
+                ...sortArgs,
+                result
+            ], {
+                cwd: wks.cwd,
+                logger: logger
+            });
+            if (branches.length > 0) {
+                result = branches[branches.length - 1];
+            }
+        }
+        // - search in tags
+        if (result.includes("*")) {
+            const tags = await this._git.listTags([
+                ...sortArgs,
+                result
+            ], {
+                cwd: wks.cwd,
+                logger: logger
+            });
+            if (tags.length > 0) {
+                result = tags[tags.length - 1];
+            }
+        }
+        if (result !== this.format) {
+            logger.verbose`Resolved ${this.format} into ${result}`;
+        }
+        if (result.includes("*")) {
+            logger.warning(`No revision found matching ${result}, using fallback ${this.fallback}`);
+            return this.fallback;
+        }
+        return result;
+    }
+    async test(workspace) {
+        const rev = await this._formatRevision(workspace);
+        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);
+
+// Class
+class Pipeline {
+    // Methods
+    add(filter) {
+        this._filters.push(filter);
+    }
+    async _test(workspace) {
+        for (const filter of this._filters){
+            const res = await filter.test(workspace);
+            if (!res) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async *filter(workspaces) {
+        for await (const wks of workspaces){
+            if (await this._test(wks)) {
+                yield wks;
+            }
+        }
+    }
+    constructor(){
+        // Attributes
+        this._filters = [];
+    }
+}
+
+// Filter
+class PrivateFilter {
+    // Constructor
+    constructor(value){
+        this.value = value;
+    }
+    // Methods
+    test(workspace) {
+        return (workspace.manifest.private ?? false) === this.value;
+    }
+}
+
+// Filter
+class ScriptsFilter {
+    // Constructor
+    constructor(scripts){
+        this.scripts = scripts;
+    }
+    // Methods
+    test(workspace) {
+        const scripts = Object.keys(workspace.manifest.scripts || {});
+        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 {
+    // Constructor
+    constructor(_cwd, manifest, project){
+        this._cwd = _cwd;
+        this.manifest = manifest;
+        this.project = project;
+        this._affectedCache = new Map();
+        this._tasks = new Map();
+        const logger = container.get(Logger);
+        this._logger = logger.child(withLabel(this.manifest.name));
+    }
+    // Methods
+    _satisfies(from, range) {
+        if (range.startsWith("file:")) {
+            return path.resolve(from.cwd, range.substring(5)) === this.cwd;
+        }
+        if (range.startsWith("workspace:")) {
+            range = range.substring(10);
+        }
+        return !this.version || satisfies(this.version, range);
+    }
+    async _buildDependencies(task, opts) {
+        // Generators
+        const generators = [];
+        switch(opts.buildDeps ?? "all"){
+            case "all":
+                generators.unshift(this.devDependencies());
+            // eslint-disable-next no-fallthrough
+            case "prod":
+                generators.unshift(this.dependencies());
+        }
+        // Build deps
+        for await (const dep of combine(...generators)){
+            const build = await dep.build(opts);
+            if (build) {
+                task.dependsOn(build);
+            }
+        }
+    }
+    async _isAffected(reference) {
+        const isAffected = await this._git.isAffected(reference, [
+            this.cwd
+        ], {
+            cwd: this.project.root,
+            logger: this._logger
+        });
+        if (isAffected) {
+            return true;
+        }
+        // Test dependencies
+        const proms = [];
+        for await (const dep of combine(this.dependencies(), this.devDependencies())){
+            proms.push(dep.isAffected(reference));
+        }
+        const results = await Promise.all(proms);
+        return results.some((r)=>r);
+    }
+    async isAffected(reference) {
+        let isAffected = this._affectedCache.get(reference);
+        if (!isAffected) {
+            isAffected = this._isAffected(reference);
+            this._affectedCache.set(reference, isAffected);
+        }
+        return await isAffected;
+    }
+    async *_loadDependencies(dependencies, kind) {
+        for (const [dep, range] of Object.entries(dependencies)){
+            const ws = await this.project.workspace(dep);
+            if (ws) {
+                if (ws._satisfies(this, range)) {
+                    yield ws;
+                } else {
+                    this._logger.warning(`Ignoring ${kind} ${ws.reference} as it does not match requirement ${range}`);
+                }
+            }
+        }
+    }
+    async *dependencies() {
+        if (!this.manifest.dependencies) return;
+        for await (const ws of this._loadDependencies(this.manifest.dependencies, "dependency")){
+            yield ws;
+        }
+    }
+    async *devDependencies() {
+        if (!this.manifest.devDependencies) return;
+        for await (const ws of this._loadDependencies(this.manifest.devDependencies, "devDependency")){
+            yield ws;
+        }
+    }
+    async exec(command, args = [], opts = {}) {
+        const pm = await this.project.packageManager();
+        const task = new CommandTask(this, command, args, {
+            ...opts,
+            logger: this._logger.child(withLabel(`${this.name}$${command}`)),
+            superCommand: pm === "yarn" ? [
+                "yarn",
+                "exec"
+            ] : undefined
+        });
+        await this._buildDependencies(task, opts);
+        return task;
+    }
+    async run(script, args = [], opts = {}) {
+        // Script not found
+        if (!this.getScript(script)) {
+            return null;
+        }
+        // Create task if it doesn't exist yet
+        let task = this._tasks.get(script);
+        if (!task) {
+            task = new ScriptTask(this, script, args, {
+                ...opts,
+                logger: this._logger.child(withLabel(`${this.name}#${script}`)),
+                runHooks: this._config.hooks
+            });
+            await task.prepare();
+            await this._buildDependencies(task, opts);
+            this._tasks.set(script, task);
+        }
+        return task;
+    }
+    async build(opts = {}) {
+        const task = await this.run(opts?.buildScript ?? "build", [], opts);
+        if (!task) {
+            this._logger.warning("Will not be built (no build script)");
+        }
+        return task;
+    }
+    getScript(script) {
+        const { scripts = {} } = this.manifest;
+        return scripts[script] || null;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            version: this.version,
+            cwd: this.cwd
+        };
+    }
+    // Properties
+    get name() {
+        return this.manifest.name;
+    }
+    get version() {
+        return this.manifest.version;
+    }
+    get reference() {
+        return this.version ? `${this.name}@${this.version}` : this.name;
+    }
+    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([
+    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 {
+    // Constructor
+    constructor(_root, _logger, opts = {}){
+        this._root = _root;
+        this._logger = _logger;
+        this._names = new Map();
+        this._workspaces = new Map();
+        this._isFullyLoaded = false;
+        this._lock = new Lock();
+        this._scurry = new PathScurry(this.root, {
+            fs
+        });
+        if (opts.packageManager) {
+            this._logger.debug`Forced use of ${opts.packageManager} in #!cwd:${this.root}`;
+            this._packageManager = opts.packageManager;
+        }
+    }
+    // Methods
+    async _loadManifest(dir) {
+        const file = path.resolve(this.root, dir, "package.json");
+        const relative = path.relative(this.root, path.dirname(file));
+        const logger = this._logger.child(withLabel(relative ? `project@${relative}` : "project"));
+        logger.debug("Loading package.json ...");
+        const data = await fs.promises.readFile(file, "utf-8");
+        const mnf = JSON.parse(data);
+        normalize(mnf, (msg)=>logger.verbose(msg));
+        return mnf;
+    }
+    async _loadWorkspace(dir) {
+        return await this._lock.with(async ()=>{
+            let wks = this._workspaces.get(dir);
+            if (!wks) {
+                const manifest = await this._loadManifest(dir);
+                wks = new Workspace(dir, manifest, this);
+                this._workspaces.set(dir, wks);
+                this._names.set(wks.name, wks);
+            }
+            return wks;
+        });
+    }
+    async packageManager() {
+        if (!this._packageManager) {
+            const files = await this._scurry.readdir(this.root, {
+                withFileTypes: false
+            });
+            if (files.includes("yarn.lock")) {
+                this._logger.debug`Detected yarn in #!cwd:${this.root}`;
+                this._packageManager = "yarn";
+            } else if (files.includes("package-lock.json")) {
+                this._logger.debug`Detected npm in #!cwd:${this.root}`;
+                this._packageManager = "npm";
+            } else {
+                this._logger.debug`No package manager recognized in #!cwd:${this.root}, defaults to npm`;
+                this._packageManager = "npm";
+            }
+        }
+        return this._packageManager;
+    }
+    async mainWorkspace() {
+        if (!this._mainWorkspace) {
+            const manifest = await this._loadManifest(".");
+            this._mainWorkspace = new Workspace(".", manifest, this);
+            this._names.set(this._mainWorkspace.name, this._mainWorkspace);
+        }
+        return this._mainWorkspace;
+    }
+    async currentWorkspace(cwd = process.cwd()) {
+        let workspace = null;
+        cwd = path.resolve(cwd);
+        for await (const wks of this.workspaces()){
+            if (cwd.startsWith(wks.cwd)) {
+                workspace = wks;
+                if (wks.cwd !== this.root) return wks;
+            }
+        }
+        return workspace;
+    }
+    async *workspaces() {
+        const main = await this.mainWorkspace();
+        yield main;
+        if (this._isFullyLoaded) {
+            for (const wks of this._names.values()){
+                if (wks.name !== main.name) yield wks;
+            }
+        } else {
+            // Load child workspaces
+            const { workspaces = [] } = main.manifest;
+            this._workspaceGlob ??= new Glob(workspaces, {
+                scurry: this._scurry,
+                withFileTypes: true
+            });
+            for await (const dir of this._workspaceGlob){
+                try {
+                    // Check if dir is a directory
+                    if (dir.isDirectory()) {
+                        yield await this._loadWorkspace(dir.fullpath());
+                    }
+                } catch (error) {
+                    if (error.code === "ENOENT") {
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+            this._isFullyLoaded = true;
+        }
+    }
+    async workspace(name) {
+        // With current directory
+        if (!name) {
+            const dir = path.relative(this.root, process.cwd());
+            return this._loadWorkspace(dir);
+        }
+        // Try name index
+        const wks = this._names.get(name);
+        if (wks) {
+            return wks;
+        }
+        // Load workspaces
+        if (!this._isFullyLoaded) {
+            for await (const ws of this.workspaces()){
+                if (ws.name === name) {
+                    return ws;
+                }
+            }
+            this._isFullyLoaded = true;
+        }
+        return null;
+    }
+    // Properties
+    get root() {
+        return path.resolve(this._root);
+    }
+};
+Project = _ts_decorate$4([
+    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 {
+    // Constructor
+    constructor(logger){
+        this._cache = new Map();
+        this._roots = new Map();
+        this._logger = logger.child(withLabel("projects"));
+    }
+    // Methods
+    async isProjectRoot(dir) {
+        const files = await fs$1.readdir(dir);
+        return {
+            hasManifest: files.includes(MANIFEST),
+            hasLockFile: LOCK_FILES.some((lock)=>files.includes(lock))
+        };
+    }
+    async searchProjectRoot(directory) {
+        directory = path.resolve(directory);
+        // Test all ancestors
+        const steps = [];
+        let foundManifest = false;
+        let projectRoot = directory;
+        let dir = directory;
+        let prev = dir;
+        do {
+            // Check cache
+            const root = this._roots.get(dir);
+            if (root) {
+                projectRoot = root;
+                foundManifest = true;
+                break;
+            }
+            // Look for files
+            const { hasManifest, hasLockFile } = await this.isProjectRoot(dir);
+            steps.push(dir);
+            if (hasManifest) {
+                projectRoot = dir;
+                foundManifest = true;
+            }
+            if (hasLockFile) {
+                break;
+            }
+            prev = dir;
+            dir = path.dirname(dir);
+        }while (prev !== dir);
+        // Cache result
+        for (const dir of steps){
+            if (dir.startsWith(projectRoot)) {
+                this._roots.set(dir, projectRoot);
+            }
+        }
+        // Log it
+        if (foundManifest) {
+            this._logger.debug`Project root found at #!cwd:${projectRoot}`;
+        } else {
+            this._logger.debug`Project root not found, keeping #!cwd:${projectRoot}`;
+        }
+        return projectRoot;
+    }
+    getProject(root, opts) {
+        let project = this._cache.get(root);
+        if (!project) {
+            project = new Project(root, this._logger, opts);
+            this._cache.set(root, project);
+        }
+        return project;
+    }
+};
+ProjectRepository = _ts_decorate$3([
+    Service(),
+    _ts_param$3(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 {
+    // Constructor
+    constructor(projects, context){
+        this.projects = projects;
+        this.context = context;
+    }
+    // Methods
+    builder(parser) {
+        return parser.option("project", {
+            alias: "p",
+            type: "string",
+            description: "Project root directory"
+        }).option("package-manager", {
+            choices: [
+                "yarn",
+                "npm"
+            ],
+            type: "string",
+            description: "Force package manager"
+        });
+    }
+    async handler(args) {
+        if (!this.context.project || args.project) {
+            args.project = await this.projects.searchProjectRoot(args.project ?? process.cwd());
+            this.context.project = this.projects.getProject(args.project, {
+                packageManager: args.packageManager
+            });
+        } else {
+            args.project = this.context.project.root;
+        }
+    }
+};
+LoadProject = _ts_decorate$2([
+    Middleware(),
+    _ts_param$2(0, inject(ProjectRepository)),
+    _ts_param$2(1, inject(ContextService))
+], LoadProject);
+// Lazy injection
+function LazyCurrentProject() {
+    return lazyInjectNamed(Project, CURRENT);
+}
+container.bind(Project).toDynamicValue(({ container })=>{
+    const ctx = container.get(ContextService);
+    const prj = ctx.project;
+    if (!prj) {
+        throw new Error("Cannot inject current project, it not yet defined");
+    }
+    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 {
+    // Constructor
+    constructor(context, logger){
+        this.context = context;
+        this.logger = logger;
+    }
+    // Methods
+    builder(parser) {
+        return parser.option("workspace", {
+            alias: "w",
+            type: "string",
+            desc: "Workspace to use"
+        });
+    }
+    async handler(args) {
+        let workspace = this.context.workspace ?? null;
+        if (!workspace || args.workspace) {
+            if (args.workspace) {
+                workspace = await this.project.workspace(args.workspace);
+            } else if (process.cwd().startsWith(this.project.root)) {
+                workspace = await this.project.currentWorkspace();
+            } else {
+                workspace = await this.project.mainWorkspace();
+            }
+        }
+        if (!workspace) {
+            this.logger.error(`${symbols.error} Workspace "${args.workspace || "."}" not found`);
+            throw new ExitException(1, "Workspace not found");
+        } else {
+            this.context.workspace = workspace;
+        }
+    }
+};
+_ts_decorate$1([
+    LazyCurrentProject()
+], LoadWorkspace.prototype, "project", void 0);
+LoadWorkspace = _ts_decorate$1([
+    Middleware(),
+    _ts_param$1(0, inject(ContextService)),
+    _ts_param$1(1, inject(Logger))
+], LoadWorkspace);
+// Decorators
+function LazyCurrentWorkspace() {
+    return lazyInjectNamed(Workspace, CURRENT);
+}
+container.bind(Workspace).toDynamicValue(({ container })=>{
+    const ctx = container.get(ContextService);
+    const wks = ctx.workspace;
+    if (!wks) {
+        throw new Error("Cannot inject current workspace, it not yet defined");
+    }
+    return wks;
+}).whenTargetNamed(CURRENT);
+
+class PluginModule extends ContainerModule {
+    // Constructor
+    constructor(name, commands){
+        super((...args)=>{
+            for (const command of this.commands){
+                const registry = getRegistry(command);
+                registry(...args);
+            }
+        });
+        this.name = name;
+        this.commands = commands;
+        this.id = id();
+    }
+}
+// Decorator
+function Plugin(opts) {
+    return (target)=>{
+        const name = opts.name ?? target.name;
+        const module = new PluginModule(name, opts.commands);
+        setModule(target, module);
+    };
+}
+
+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;
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+let TaskExprService = class TaskExprService1 {
+    // Statics
+    static isTaskNode(node) {
+        return "script" in node;
+    }
+    // Constructor
+    constructor(_logger){
+        this._logger = _logger;
+    }
+    // Methods
+    _lexer() {
+        return moo.states({
+            task: {
+                lparen: "(",
+                whitespace: /[ \t]+/,
+                script: {
+                    match: /[-_:a-zA-Z0-9]+/,
+                    push: "operatorOrArgument"
+                },
+                string: [
+                    {
+                        match: /'(?:\\['\\]|[^\r\n'\\])+'/,
+                        push: "operator",
+                        value: (x)=>x.slice(1, -1).replace(/\\(['\\])/g, "$1")
+                    },
+                    {
+                        match: /"(?:\\["\\]|[^\r\n"\\])+"/,
+                        push: "operator",
+                        value: (x)=>x.slice(1, -1).replace(/\\(["\\])/g, "$1")
+                    }
+                ]
+            },
+            operator: {
+                rparen: ")",
+                whitespace: /[ \t]+/,
+                operator: {
+                    match: [
+                        "->",
+                        "//",
+                        "||"
+                    ],
+                    pop: 1
+                }
+            },
+            operatorOrArgument: {
+                rparen: ")",
+                whitespace: /[ \t]+/,
+                operator: {
+                    match: [
+                        "->",
+                        "//",
+                        "||"
+                    ],
+                    pop: 1
+                },
+                argument: [
+                    {
+                        match: /[-_:a-zA-Z0-9]+/
+                    },
+                    {
+                        match: /'(?:\\['\\]|[^\r\n'\\])+'/,
+                        value: (x)=>x.slice(1, -1).replace(/\\(['\\])/g, "$1")
+                    },
+                    {
+                        match: /"(?:\\["\\]|[^\r\n"\\])+"/,
+                        value: (x)=>x.slice(1, -1).replace(/\\(["\\])/g, "$1")
+                    }
+                ]
+            }
+        });
+    }
+    _nextNode(lexer, i = 0) {
+        let node = null;
+        for (const token of lexer){
+            // Ignore whitespaces
+            if (token.type === "whitespace") {
+                continue;
+            }
+            // rparen = end of group
+            if (token.type === "rparen") {
+                break;
+            }
+            // Handle argument
+            if (token.type === "argument") {
+                if (!node) {
+                    throw new Error(lexer.formatError(token, "Unexpected argument"));
+                } else if (TaskExprService.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"));
+                    } else {
+                        lastTask.args.push(token.value);
+                    }
+                }
+                continue;
+            }
+            // Handle operator
+            if (token.type === "operator") {
+                const operator = token.value;
+                if (!node) {
+                    throw new Error(lexer.formatError(token, "Unexpected operator"));
+                } else if (TaskExprService.isTaskNode(node)) {
+                    node = {
+                        operator,
+                        tasks: [
+                            node
+                        ]
+                    };
+                    continue;
+                } else {
+                    if (node.operator !== operator) {
+                        node = {
+                            operator,
+                            tasks: [
+                                node
+                            ]
+                        };
+                    }
+                    continue;
+                }
+            }
+            // Build "child"
+            let child;
+            if (token.type === "script") {
+                child = {
+                    script: token.value,
+                    args: []
+                };
+            } else if (token.type === "string") {
+                const [script, ...args] = token.value.split(/ +/);
+                child = {
+                    script,
+                    args
+                };
+            } else if (token.type === "lparen") {
+                const res = this._nextNode(lexer, i + 1);
+                if (!res) {
+                    throw new Error(lexer.formatError(token, "Empty group found"));
+                }
+                child = res;
+            } else {
+                throw new Error(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 {
+                node.tasks.push(child);
+            }
+        }
+        return node;
+    }
+    parse(expr) {
+        const lexer = this._lexer().reset(expr);
+        const tree = {
+            roots: []
+        };
+        // eslint-disable-next-line no-constant-condition
+        while(true){
+            const node = this._nextNode(lexer);
+            if (node) {
+                tree.roots.push(node);
+            } else {
+                break;
+            }
+        }
+        return tree;
+    }
+    async buildTask(node, workspace, opts) {
+        if (TaskExprService.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`);
+            }
+            return task;
+        } else {
+            let group;
+            if (node.operator === "//") {
+                group = new ParallelGroup("In parallel", {}, {
+                    logger: this._logger
+                });
+            } else if (node.operator === "||") {
+                group = new FallbackGroup("Fallbacks", {}, {
+                    logger: this._logger
+                });
+            } else {
+                group = new SequenceGroup("In sequence", {}, {
+                    logger: this._logger
+                });
+            }
+            for (const child of node.tasks){
+                group.add(await this.buildTask(child, workspace, opts));
+            }
+            return group;
+        }
+    }
+};
+TaskExprService = _ts_decorate([
+    Service(),
+    _ts_param(0, inject(Logger))
+], TaskExprService);
+
+// Utils
+const style = (dev)=>({
+        color: dev ? "blue" : ""
+    });
+// Component
+function WorkspaceTree(props) {
+    const { workspace: wks, dev = false, level = "" } = props;
+    // State
+    const [deps, setDeps] = useState([]);
+    // Effects
+    useEffect(()=>void (async ()=>{
+            const deps = [];
+            for await (const dep of wks.dependencies()){
+                deps.push([
+                    dep,
+                    null
+                ]);
+            }
+            for await (const dep of wks.devDependencies()){
+                deps.push([
+                    dep,
+                    true
+                ]);
+            }
+            setDeps(deps);
+        })(), [
+        wks
+    ]);
+    // Render
+    return /*#__PURE__*/ jsxs(Text, {
+        children: [
+            /*#__PURE__*/ jsx(Text, {
+                ...style(dev),
+                children: wks.name
+            }),
+            wks.version && /*#__PURE__*/ jsxs(Text, {
+                color: "grey",
+                children: [
+                    "@",
+                    wks.version
+                ]
+            }),
+            deps.length > 0 && /*#__PURE__*/ jsx(Newline, {}),
+            deps.map(([dep, isDev], idx)=>/*#__PURE__*/ jsxs(Text, {
+                    children: [
+                        level,
+                        /*#__PURE__*/ jsxs(Text, {
+                            ...style(dev),
+                            children: [
+                                idx === deps.length - 1 ? "└" : "├",
+                                "─",
+                                " "
+                            ]
+                        }),
+                        /*#__PURE__*/ jsx(WorkspaceTree, {
+                            workspace: dep,
+                            dev: isDev ?? dev,
+                            level: /*#__PURE__*/ jsxs(Fragment, {
+                                children: [
+                                    level,
+                                    /*#__PURE__*/ jsxs(Text, {
+                                        ...style(dev),
+                                        children: [
+                                            idx === deps.length - 1 ? " " : "│",
+                                            "  "
+                                        ]
+                                    })
+                                ]
+                            })
+                        }),
+                        idx < deps.length - 1 && /*#__PURE__*/ jsx(Newline, {})
+                    ]
+                }, dep.name))
+        ]
+    });
+}
+
+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-9cXaezk-.js.map