@jujulego/jill 1.1.14 → 1.1.18

package/dist/base.command.d.ts

@@ -0,0 +1,8 @@
+import { Arguments, Awaitable, Builder, Command } from './command';
+export interface BaseArgs {
+    verbose: number;
+}
+export declare abstract class BaseCommand<A extends BaseArgs> extends Command<BaseArgs> {
+    protected define<T, U>(builder: Builder<T, U>): Builder<T, U & BaseArgs>;
+    protected run(args: Arguments<A>): Awaitable<number | void>;
+}

package/dist/base.command.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseCommand = void 0;
+
+var _command = require("./command");
+
+// Command
+class BaseCommand extends _command.Command {
+  // Methods
+  define(builder) {
+    return y => builder(y).option('verbose', {
+      alias: 'v',
+      type: 'count',
+      description: 'Set verbosity level (1 for verbose, 2 for debug)'
+    });
+  }
+
+  run(args) {
+    // Setup logger verbosity
+    if (args.verbose === 1) {
+      this.logger.level = 'verbose';
+    } else if (args.verbose >= 2) {
+      this.logger.level = 'debug';
+    }
+  }
+
+}
+
+exports.BaseCommand = BaseCommand;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/dist/command.d.ts

@@ -0,0 +1,21 @@
+import yargs from 'yargs';
+export declare type Awaitable<T> = T | PromiseLike<T>;
+export declare type Arguments<A> = yargs.Arguments<A> & {
+    '--': readonly (string | number)[];
+};
+export declare type Builder<T, A = T> = (yargs: yargs.Argv<T>) => yargs.Argv<A>;
+export declare class Exit extends Error {
+    readonly code: number;
+    constructor(code?: number);
+}
+export declare abstract class Command<A = unknown> {
+    readonly logger: import("winston").Logger;
+    readonly spinner: import("ora").Ora;
+    protected abstract define<T, U>(builder: Builder<T, U>): Builder<T, U & A>;
+    protected abstract run(args: Arguments<A>): Awaitable<number | void>;
+    setup<T>(yargs: yargs.Argv<T>): yargs.Argv<T>;
+    private _wrapper;
+    log(msg: string): void;
+    abstract get name(): string | readonly string[];
+    abstract get description(): string;
+}

package/dist/command.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Exit = exports.Command = void 0;
+
+var _jillCore = require("@jujulego/jill-core");
+
+var _yargs = _interopRequireDefault(require("yargs"));
+
+var _logger = require("./logger");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+// Exceptions
+class Exit extends Error {
+  // Constructor
+  constructor(code = 1) {
+    super();
+    this.code = code;
+  }
+
+} // Command
+
+
+exports.Exit = Exit;
+
+class Command {
+  constructor() {
+    _defineProperty(this, "logger", _jillCore.logger);
+
+    _defineProperty(this, "spinner", _logger.transport.spinner);
+  }
+
+  setup(yargs) {
+    yargs.command(this.name, this.description, y => this.define(_ => _)(y), a => this._wrapper(a));
+    return yargs;
+  }
+
+  async _wrapper(args) {
+    try {
+      const exit = await this.run(args);
+      process.exit(exit ?? 0);
+    } catch (err) {
+      if (err instanceof Exit) {
+        process.exit(err.code);
+      }
+
+      this.spinner.fail(err.message);
+      process.exit(1);
+    }
+  }
+
+  log(msg) {
+    if (this.spinner.isSpinning) {
+      this.spinner.clear();
+    }
+
+    process.stdout.write(msg + '\n');
+  } // Properties
+
+
+}
+
+exports.Command = Command;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/dist/commands/each.command.d.ts

@@ -0,0 +1,17 @@
+import { WorkspaceDepsMode } from '@jujulego/jill-core';
+import { Arguments, Builder } from '../command';
+import { ProjectArgs, ProjectCommand } from '../project.command';
+export interface EachArgs extends ProjectArgs {
+    script: string;
+    'deps-mode': WorkspaceDepsMode;
+    private: boolean | undefined;
+    affected: string | undefined;
+    'affected-rev-sort': string | undefined;
+    'affected-rev-fallback': string;
+}
+export declare class EachCommand extends ProjectCommand<EachArgs> {
+    readonly name = "each <script>";
+    readonly description = "Run script on selected workspaces";
+    protected define<T, U>(builder: Builder<T, U>): Builder<T, U & EachArgs>;
+    protected run(args: Arguments<EachArgs>): Promise<number>;
+}

package/dist/commands/each.command.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EachCommand = void 0;
+
+var _jillCore = require("@jujulego/jill-core");
+
+var _filters = require("../filters");
+
+var _pipeline = require("../pipeline");
+
+var _taskLogger = require("../task-logger");
+
+var _project = require("../project.command");
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+// Command
+class EachCommand extends _project.ProjectCommand {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "name", 'each <script>');
+
+    _defineProperty(this, "description", 'Run script on selected workspaces');
+  }
+
+  // Methods
+  define(builder) {
+    return super.define(y => builder(y).positional('script', {
+      type: 'string',
+      demandOption: true
+    }).option('deps-mode', {
+      choice: ['all', 'prod', 'none'],
+      default: 'all',
+      desc: 'Dependency selection mode:\n' + ' - all = dependencies AND devDependencies\n' + ' - prod = dependencies\n' + ' - none = nothing'
+    }).option('private', {
+      type: 'boolean',
+      group: 'Filters:',
+      desc: 'Print only private workspaces'
+    }).option('affected', {
+      alias: 'a',
+      type: 'string',
+      coerce: rev => rev === '' ? 'master' : rev,
+      group: 'Affected:',
+      desc: 'Print only affected workspaces towards given git revision. If no revision is given, it will check towards master.\n' + 'Replaces %name by workspace name.'
+    }).option('affected-rev-sort', {
+      type: 'string',
+      group: 'Affected:',
+      desc: 'Sort applied to git tag / git branch command'
+    }).option('affected-rev-fallback', {
+      type: 'string',
+      default: 'master',
+      group: 'Affected:',
+      desc: 'Fallback revision, used if no revision matching the given format is found'
+    }));
+  }
+
+  async run(args) {
+    await super.run(args); // Setup pipeline
+
+    const pipeline = new _pipeline.Pipeline();
+    pipeline.add(_filters.Filter.scripts([args.script]));
+
+    if (args.private !== undefined) {
+      pipeline.add(_filters.Filter.privateWorkspace(args.private));
+    }
+
+    if (args.affected !== undefined) {
+      pipeline.add(new _filters.AffectedFilter(args.affected, args['affected-rev-fallback'], args['affected-rev-sort']));
+    } // Filter
+
+
+    const workspaces = [];
+
+    for await (const wks of pipeline.filter(this.project.workspaces())) {
+      workspaces.push(wks);
+    }
+
+    if (workspaces.length === 0) {
+      this.spinner.fail('No workspace found !');
+      return 1;
+    }
+
+    this.spinner.stop();
+    this.logger.verbose(`Will run ${args.script} in ${workspaces.map(wks => wks.name).join(', ')}`); // Run tasks
+
+    const set = new _jillCore.TaskSet();
+    const tasks = [];
+
+    for (const wks of workspaces) {
+      const task = await wks.run(args.script, args['--']?.map(arg => arg.toString()), {
+        buildDeps: args['deps-mode']
+      });
+      tasks.push(task);
+      set.add(task);
+    }
+
+    const tlogger = new _taskLogger.TaskLogger();
+    tlogger.on('spin-multiple', count => `Working in ${count} packages ...`);
+    tlogger.on('spin-simple', tsk => tasks.includes(tsk) ? `Running ${args.script} in ${tsk.context.workspace?.name} ...` : `Building ${tsk.context.workspace?.name} ...`);
+    tlogger.on('fail', tsk => tasks.includes(tsk) ? `${tsk.context.workspace?.name} ${args.script} failed` : `Failed to build ${tsk.context.workspace?.name}`);
+    tlogger.on('succeed', tsk => tasks.includes(tsk) ? `${tsk.context.workspace?.name} ${args.script} done` : `${tsk.context.workspace?.name} built`);
+    tlogger.connect(set);
+    set.start();
+    const [result] = await set.waitFor('finished');
+    return result.failed === 0 ? 0 : 1;
+  }
+
+}
+
+exports.EachCommand = EachCommand;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["commands/each.command.ts"],"names":["EachCommand","ProjectCommand","define","builder","y","positional","type","demandOption","option","choice","default","desc","group","alias","coerce","rev","run","args","pipeline","Pipeline","add","Filter","scripts","script","private","undefined","privateWorkspace","affected","AffectedFilter","workspaces","wks","filter","project","push","length","spinner","fail","stop","logger","verbose","map","name","join","set","TaskSet","tasks","task","arg","toString","buildDeps","tlogger","TaskLogger","on","count","tsk","includes","context","workspace","connect","start","result","waitFor","failed"],"mappings":"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","sourcesContent":["import { Task, TaskSet, Workspace, WorkspaceDepsMode } from '@jujulego/jill-core';\n\nimport { Arguments, Builder } from '../command';\nimport { AffectedFilter, Filter } from '../filters';\nimport { Pipeline } from '../pipeline';\nimport { TaskLogger } from '../task-logger';\nimport { ProjectArgs, ProjectCommand } from '../project.command';\n\n// Types\nexport interface EachArgs extends ProjectArgs {\n  script: string;\n  'deps-mode': WorkspaceDepsMode;\n\n  private: boolean | undefined;\n  affected: string | undefined;\n  'affected-rev-sort': string | undefined;\n  'affected-rev-fallback': string;\n}\n\n// Command\nexport class EachCommand extends ProjectCommand<EachArgs> {\n  // Attributes\n  readonly name = 'each <script>';\n  readonly description = 'Run script on selected workspaces';\n\n  // Methods\n  protected define<T, U>(builder: Builder<T, U>): Builder<T, U & EachArgs> {\n    return super.define(y => builder(y)\n      .positional('script', { type: 'string', demandOption: true })\n      .option('deps-mode', {\n        choice: ['all', 'prod', 'none'],\n        default: 'all' as WorkspaceDepsMode,\n        desc: 'Dependency selection mode:\\n' +\n          ' - all = dependencies AND devDependencies\\n' +\n          ' - prod = dependencies\\n' +\n          ' - none = nothing'\n      })\n      .option('private', {\n        type: 'boolean',\n        group: 'Filters:',\n        desc: 'Print only private workspaces',\n      })\n      .option('affected', {\n        alias: 'a',\n        type: 'string',\n        coerce: (rev: string) => rev === '' ? 'master' : rev,\n        group: 'Affected:',\n        desc: 'Print only affected workspaces towards given git revision. If no revision is given, it will check towards master.\\n' +\n          'Replaces %name by workspace name.',\n      })\n      .option('affected-rev-sort', {\n        type: 'string',\n        group: 'Affected:',\n        desc: 'Sort applied to git tag / git branch command',\n      })\n      .option('affected-rev-fallback', {\n        type: 'string',\n        default: 'master',\n        group: 'Affected:',\n        desc: 'Fallback revision, used if no revision matching the given format is found',\n      })\n    );\n  }\n\n  protected async run(args: Arguments<EachArgs>): Promise<number> {\n    await super.run(args);\n\n    // Setup pipeline\n    const pipeline = new Pipeline();\n    pipeline.add(Filter.scripts([args.script]));\n\n    if (args.private !== undefined) {\n      pipeline.add(Filter.privateWorkspace(args.private));\n    }\n\n    if (args.affected !== undefined) {\n      pipeline.add(new AffectedFilter(\n        args.affected,\n        args['affected-rev-fallback'],\n        args['affected-rev-sort']\n      ));\n    }\n\n    // Filter\n    const workspaces: Workspace[] = [];\n\n    for await (const wks of pipeline.filter(this.project.workspaces())) {\n      workspaces.push(wks);\n    }\n\n    if (workspaces.length === 0) {\n      this.spinner.fail('No workspace found !');\n      return 1;\n    }\n\n    this.spinner.stop();\n    this.logger.verbose(`Will run ${args.script} in ${workspaces.map(wks => wks.name).join(', ')}`);\n\n    // Run tasks\n    const set = new TaskSet();\n    const tasks: Task[] = [];\n\n    for (const wks of workspaces) {\n      const task = await wks.run(args.script, args['--']?.map(arg => arg.toString()), {\n        buildDeps: args['deps-mode']\n      });\n\n      tasks.push(task);\n      set.add(task);\n    }\n\n    const tlogger = new TaskLogger();\n    tlogger.on('spin-multiple', (count) => `Working in ${count} packages ...`);\n    tlogger.on('spin-simple', (tsk) => tasks.includes(tsk) ? `Running ${args.script} in ${tsk.context.workspace?.name} ...` : `Building ${tsk.context.workspace?.name} ...`);\n    tlogger.on('fail', (tsk) => tasks.includes(tsk) ? `${tsk.context.workspace?.name} ${args.script} failed` : `Failed to build ${tsk.context.workspace?.name}`);\n    tlogger.on('succeed', (tsk) => tasks.includes(tsk) ? `${tsk.context.workspace?.name} ${args.script} done` : `${tsk.context.workspace?.name} built`);\n    tlogger.connect(set);\n\n    set.start();\n    const [result] = await set.waitFor('finished');\n    return result.failed === 0 ? 0 : 1;\n  }\n}"],"file":"commands/each.command.js"}

package/dist/commands/info.command.d.ts

@@ -0,0 +1,9 @@
+import { Arguments } from '../command';
+import { WorkspaceArgs, WorkspaceCommand } from '../workspace.command';
+export declare class InfoCommand extends WorkspaceCommand {
+    readonly name = "info";
+    readonly description = "Print workspace data";
+    protected run(args: Arguments<WorkspaceArgs>): Promise<number | void>;
+    private printDepsTree;
+    private printTree;
+}

package/dist/commands/info.command.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InfoCommand = void 0;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _workspace = require("../workspace.command");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+// Command
+class InfoCommand extends _workspace.WorkspaceCommand {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "name", 'info');
+
+    _defineProperty(this, "description", 'Print workspace data');
+  }
+
+  // Methods
+  async run(args) {
+    await super.run(args);
+    this.spinner.stop(); // Print data
+
+    this.log((0, _chalk.default)`Workspace {bold ${this.workspace.name}}:`);
+    this.log((0, _chalk.default)`{bold Version:}   ${this.workspace.manifest.version || _chalk.default.grey('unset')}`);
+    this.log((0, _chalk.default)`{bold Directory:} ${_path.default.relative(process.cwd(), this.workspace.cwd) || '.'}`);
+    this.log('');
+    await this.printDepsTree();
+  }
+
+  async printDepsTree() {
+    this.log((0, _chalk.default)`{bold Dependencies:}`);
+    const printed = new Set([this.workspace.name]);
+    await this.printTree(this.workspace, '', false, printed);
+
+    if (printed.size === 1) {
+      this.log(_chalk.default.grey(`   No dependencies for ${this.workspace.name}`));
+    }
+  }
+
+  async printTree(wks, level, dev, printed) {
+    const workspaces = [];
+
+    for await (const dep of wks.dependencies()) {
+      workspaces.push([dep, dev]);
+    }
+
+    for await (const dep of wks.devDependencies()) {
+      workspaces.push([dep, true]);
+    }
+
+    for (let i = 0; i < workspaces.length; ++i) {
+      const [dep, isDev] = workspaces[i];
+      const isPrinted = printed.has(dep.cwd);
+      const isLast = i === workspaces.length - 1; // Format
+
+      let name = dep.name;
+      if (dep.version) name = (0, _chalk.default)`${name}{grey @${dep.version}}`;
+      if (isDev) name = _chalk.default.blue(`${name} (dev)`);
+      if (isPrinted) name = _chalk.default.italic(name);
+      const branchFmt = dev ? _chalk.default.blue : s => s;
+      this.log(`${level}${branchFmt(`${isLast ? '└' : '├'}─ `)}${name}`); // Print deps of dep
+
+      if (!isPrinted) {
+        printed.add(dep.cwd);
+        await this.printTree(dep, level + (isLast ? '   ' : branchFmt('│  ')), isDev, printed);
+      }
+    }
+  }
+
+}
+
+exports.InfoCommand = InfoCommand;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/dist/commands/list.command.d.ts

@@ -0,0 +1,22 @@
+import { ProjectArgs, ProjectCommand } from '../project.command';
+import { Arguments, Builder } from '../command';
+export declare type Attribute = 'name' | 'version' | 'root' | 'slug';
+export declare type Data = Partial<Record<Attribute, string>>;
+export interface ListArgs extends ProjectArgs {
+    private: boolean | undefined;
+    'with-script': string[] | undefined;
+    affected: string | undefined;
+    'affected-rev-sort': string | undefined;
+    'affected-rev-fallback': string;
+    attrs: Attribute[];
+    headers: boolean | undefined;
+    long: boolean | undefined;
+    json: boolean | undefined;
+}
+export declare class ListCommand extends ProjectCommand<ListArgs> {
+    readonly name: string[];
+    readonly description = "List workspaces";
+    private buildExtractor;
+    protected define<T, U>(builder: Builder<T, U>): Builder<T, U & ListArgs>;
+    protected run(args: Arguments<ListArgs>): Promise<number | void>;
+}

package/dist/commands/list.command.js

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ListCommand = void 0;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _slugify = _interopRequireDefault(require("slugify"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _project = require("../project.command");
+
+var _pipeline = require("../pipeline");
+
+var _filters = require("../filters");
+
+var _cliList = require("../utils/cli-list");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+// 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.default.grey('unset')),
+  root: wks => wks.cwd,
+  slug: wks => (0, _slugify.default)(wks.name)
+}; // Command
+
+class ListCommand extends _project.ProjectCommand {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "name", ['list', 'ls']);
+
+    _defineProperty(this, "description", 'List workspaces');
+  }
+
+  // Methods
+  buildExtractor(attrs) {
+    return (wks, json) => {
+      const data = {};
+
+      for (const attr of attrs) {
+        data[attr] = EXTRACTORS[attr](wks, json);
+      }
+
+      return data;
+    };
+  }
+
+  define(builder) {
+    return super.define(y => builder(y).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: 'Affected:',
+      desc: 'Print only affected workspaces towards given git revision. If no revision is given, it will check towards master.\n' + 'Replaces %name by workspace name.'
+    }).option('affected-rev-sort', {
+      type: 'string',
+      group: 'Affected:',
+      desc: 'Sort applied to git tag / git branch command'
+    }).option('affected-rev-fallback', {
+      type: 'string',
+      default: 'master',
+      group: 'Affected:',
+      desc: 'Fallback revision, used if no revision matching the given format is found'
+    }).option('attrs', {
+      type: 'array',
+      choices: ['name', 'version', 'root', 'slug'],
+      default: [],
+      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'
+    }));
+  }
+
+  async run(args) {
+    await super.run(args); // Setup pipeline
+
+    const pipeline = new _pipeline.Pipeline();
+
+    if (args.private !== undefined) {
+      pipeline.add(_filters.Filter.privateWorkspace(args.private));
+    }
+
+    if (args['with-script'] !== undefined) {
+      pipeline.add(_filters.Filter.scripts(args['with-script']));
+    }
+
+    if (args.affected !== undefined) {
+      pipeline.add(new _filters.AffectedFilter(args.affected, args['affected-rev-fallback'], args['affected-rev-sort']));
+    } // Filter
+
+
+    const workspaces = [];
+
+    for await (const wks of pipeline.filter(this.project.workspaces())) {
+      workspaces.push(wks);
+    }
+
+    this.spinner.stop(); // Build data
+
+    let attrs = args.attrs;
+
+    if (args.attrs.length === 0) {
+      if (args.long) {
+        attrs = LONG_ATTRIBUTES;
+      } else if (args.json) {
+        attrs = JSON_ATTRIBUTES;
+      } else {
+        attrs = DEFAULT_ATTRIBUTES;
+      }
+    }
+
+    const data = workspaces.map(wks => this.buildExtractor(attrs)(wks, args.json || false)); // Print data
+
+    if (args.json) {
+      if (process.stdout.isTTY) {
+        // Pretty print for ttys
+        this.log(JSON.stringify(data, null, 2));
+      } else {
+        this.log(JSON.stringify(data));
+      }
+    } else {
+      const list = new _cliList.CliList();
+
+      if (args.headers ?? attrs.length > 1) {
+        list.setHeaders(attrs);
+      }
+
+      for (const d of data) {
+        if (d.root) {
+          d.root = _path.default.relative(process.cwd(), d.root) || '.';
+        }
+
+        list.add(attrs.map(attr => d[attr] || ''));
+      }
+
+      for (const d of list.lines()) {
+        this.log(d);
+      }
+    }
+  }
+
+}
+
+exports.ListCommand = ListCommand;
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["commands/list.command.ts"],"names":["LONG_ATTRIBUTES","JSON_ATTRIBUTES","DEFAULT_ATTRIBUTES","EXTRACTORS","name","wks","version","json","manifest","undefined","chalk","grey","root","cwd","slug","ListCommand","ProjectCommand","buildExtractor","attrs","data","attr","define","builder","y","option","type","group","desc","string","alias","coerce","rev","default","choices","run","args","pipeline","Pipeline","private","add","Filter","privateWorkspace","scripts","affected","AffectedFilter","workspaces","filter","project","push","spinner","stop","length","long","map","process","stdout","isTTY","log","JSON","stringify","list","CliList","headers","setHeaders","d","path","relative","lines"],"mappings":"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","sourcesContent":["import { Workspace } from '@jujulego/jill-core';\nimport chalk from 'chalk';\nimport slugify from 'slugify';\nimport path from 'path';\n\nimport { ProjectArgs, ProjectCommand } from '../project.command';\nimport { Pipeline } from '../pipeline';\nimport { AffectedFilter, Filter } from '../filters';\nimport { CliList } from '../utils/cli-list';\nimport { Arguments, Builder } from '../command';\n\n// Types\nexport type Attribute = 'name' | 'version' | 'root' | 'slug';\nexport type Data = Partial<Record<Attribute, string>>;\n\ntype Extractor<T> = (wks: Workspace, json: boolean) => T;\n\nexport interface ListArgs extends ProjectArgs {\n  private: boolean | undefined;\n  'with-script': string[] | undefined;\n\n  affected: string | undefined;\n  'affected-rev-sort': string | undefined;\n  'affected-rev-fallback': string;\n\n  attrs: Attribute[];\n  headers: boolean | undefined;\n  long: boolean | undefined;\n  json: boolean | undefined;\n}\n\n// Constants\nconst LONG_ATTRIBUTES: Attribute[] = ['name', 'version', 'root'];\nconst JSON_ATTRIBUTES: Attribute[] = ['name', 'version', 'slug', 'root'];\nconst DEFAULT_ATTRIBUTES: Attribute[] = ['name'];\n\nconst EXTRACTORS: Record<Attribute, Extractor<string | undefined>> = {\n  name: wks => wks.name,\n  version: (wks, json) => wks.manifest.version || (json ? undefined : chalk.grey('unset')),\n  root: wks => wks.cwd,\n  slug: wks => slugify(wks.name)\n};\n\n// Command\nexport class ListCommand extends ProjectCommand<ListArgs> {\n  // Attributes\n  readonly name = ['list', 'ls'];\n  readonly description = 'List workspaces';\n\n  // Methods\n  private buildExtractor(attrs: Attribute[]): Extractor<Data> {\n    return (wks, json: boolean) => {\n      const data: Data = {};\n\n      for (const attr of attrs) {\n        data[attr] = EXTRACTORS[attr](wks, json);\n      }\n\n      return data;\n    };\n  }\n\n  protected define<T, U>(builder: Builder<T, U>): Builder<T, U & ListArgs> {\n    return super.define(y => builder(y)\n      .option('private', {\n        type: 'boolean',\n        group: 'Filters:',\n        desc: 'Print only private workspaces',\n      })\n      .option('with-script', {\n        type: 'array',\n        string: true,\n        group: 'Filters:',\n        desc: 'Print only workspaces having the given script',\n      })\n      .option('affected', {\n        alias: 'a',\n        type: 'string',\n        coerce: (rev: string) => rev === '' ? 'master' : rev,\n        group: 'Affected:',\n        desc: 'Print only affected workspaces towards given git revision. If no revision is given, it will check towards master.\\n' +\n          'Replaces %name by workspace name.',\n      })\n      .option('affected-rev-sort', {\n        type: 'string',\n        group: 'Affected:',\n        desc: 'Sort applied to git tag / git branch command',\n      })\n      .option('affected-rev-fallback', {\n        type: 'string',\n        default: 'master',\n        group: 'Affected:',\n        desc: 'Fallback revision, used if no revision matching the given format is found',\n      })\n      .option('attrs', {\n        type: 'array',\n        choices: ['name', 'version', 'root', 'slug'],\n        default: [] as Attribute[],\n        group: 'Format:',\n        desc: 'Select printed attributes'\n      })\n      .option('headers', {\n        type: 'boolean',\n        group: 'Format:',\n        desc: 'Prints columns headers'\n      })\n      .option('long', {\n        alias: 'l',\n        type: 'boolean',\n        group: 'Format:',\n        desc: 'Prints name, version and root of all workspaces',\n      })\n      .option('json', {\n        type: 'boolean',\n        group: 'Format:',\n        desc: 'Prints data as a JSON array',\n      })\n    );\n  }\n\n  protected async run(args: Arguments<ListArgs>): Promise<number | void> {\n    await super.run(args);\n\n    // Setup pipeline\n    const pipeline = new Pipeline();\n\n    if (args.private !== undefined) {\n      pipeline.add(Filter.privateWorkspace(args.private));\n    }\n\n    if (args['with-script'] !== undefined) {\n      pipeline.add(Filter.scripts(args['with-script']));\n    }\n\n    if (args.affected !== undefined) {\n      pipeline.add(new AffectedFilter(\n        args.affected,\n        args['affected-rev-fallback'],\n        args['affected-rev-sort']\n      ));\n    }\n\n    // Filter\n    const workspaces: Workspace[] = [];\n\n    for await (const wks of pipeline.filter(this.project.workspaces())) {\n      workspaces.push(wks);\n    }\n\n    this.spinner.stop();\n\n    // Build data\n    let attrs = args.attrs;\n\n    if (args.attrs.length === 0) {\n      if (args.long) {\n        attrs = LONG_ATTRIBUTES;\n      } else if (args.json) {\n        attrs = JSON_ATTRIBUTES;\n      } else {\n        attrs = DEFAULT_ATTRIBUTES;\n      }\n    }\n\n    const data = workspaces.map(wks => this.buildExtractor(attrs)(wks, args.json || false));\n\n    // Print data\n    if (args.json) {\n      if (process.stdout.isTTY) { // Pretty print for ttys\n        this.log(JSON.stringify(data, null, 2));\n      } else {\n        this.log(JSON.stringify(data));\n      }\n    } else {\n      const list = new CliList();\n\n      if (args.headers ?? (attrs.length > 1)) {\n        list.setHeaders(attrs);\n      }\n\n      for (const d of data) {\n        if (d.root) {\n          d.root = path.relative(process.cwd(), d.root) || '.';\n        }\n\n        list.add(attrs.map(attr => d[attr] || ''));\n      }\n\n      for (const d of list.lines()) {\n        this.log(d);\n      }\n    }\n  }\n}"],"file":"commands/list.command.js"}

package/dist/commands/run.command.d.ts

@@ -0,0 +1,13 @@
+import { WorkspaceDepsMode } from '@jujulego/jill-core';
+import { Arguments, Builder } from '../command';
+import { WorkspaceArgs, WorkspaceCommand } from '../workspace.command';
+export interface RunArgs extends WorkspaceArgs {
+    script: string;
+    'deps-mode': WorkspaceDepsMode;
+}
+export declare class RunCommand extends WorkspaceCommand<RunArgs> {
+    readonly name = "run <script>";
+    readonly description = "Run script inside workspace";
+    protected define<T, U>(builder: Builder<T, U>): Builder<T, U & RunArgs>;
+    protected run(args: Arguments<RunArgs>): Promise<number>;
+}