rman 0.37.4 → 1.0.1

package/commands/list-command.js

@@ -1,134 +0,0 @@
-import colors from 'ansi-colors';
-import EasyTable from 'easy-table';
-import logger from 'npmlog';
-import path from 'path';
-import { Command } from '../core/command.js';
-import { GitHelper } from '../utils/git-utils.js';
-export class ListCommand extends Command {
-    repository;
-    static commandName = 'list';
-    constructor(repository, options) {
-        super(options);
-        this.repository = repository;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    _filter(pkg, inf) {
-        return true;
-    }
-    async _execute() {
-        const { repository } = this;
-        const packages = repository.getPackages({ toposort: this.options.toposort });
-        const git = new GitHelper({ cwd: repository.dirname });
-        const dirtyFiles = await git.listDirtyFiles({ absolute: true });
-        const committedFiles = await git.listCommittedFiles({ absolute: true });
-        const table = new EasyTable();
-        const arr = [];
-        const obj = {};
-        let count = 0;
-        for (const p of packages) {
-            const isDirty = !!dirtyFiles.find(f => !path.relative(p.dirname, f).startsWith('..'));
-            const isCommitted = !!committedFiles.find(f => !path.relative(p.dirname, f).startsWith('..'));
-            if (!this._filter(p, { isDirty, isCommitted }))
-                continue;
-            if (this.options.graph) {
-                count++;
-                obj[p.name] = [...p.dependencies];
-                continue;
-            }
-            const location = path.relative(repository.dirname, p.dirname);
-            let o = {
-                name: p.name,
-                version: p.version,
-                location,
-                private: p.isPrivate,
-                isDirty,
-                isCommitted,
-            };
-            o = this.onPrepare ? this.onPrepare(p, o) : o;
-            if (!o)
-                continue;
-            arr.push(o);
-            count++;
-            if (!this.options.json) {
-                if (this.options.parseable) {
-                    const a = [
-                        location,
-                        p.name,
-                        p.version,
-                        p.isPrivate ? 'PRIVATE' : '',
-                        isDirty ? 'DIRTY' : isCommitted ? ':COMMITTED' : '',
-                    ];
-                    logger.output('', a.join('::'));
-                }
-                else if (this.options.short) {
-                    logger.output('', p.name);
-                }
-                else {
-                    if (this.onPrintTable)
-                        this.onPrintTable(p, o, table);
-                    else {
-                        table.cell('Package', colors.yellowBright(p.name));
-                        table.cell('Version', colors.yellow(p.version));
-                        table.cell('Private', p.isPrivate ? colors.magentaBright('yes') : '');
-                        table.cell('Changed', isDirty ? colors.magenta('dirty') : isCommitted ? colors.yellow('committed') : '');
-                        table.cell('Path', path.relative(repository.dirname, p.dirname));
-                        table.newRow();
-                    }
-                }
-            }
-        }
-        if (this.options.graph) {
-            logger.output('', '%j', obj);
-            return obj;
-        }
-        if (this.options.json) {
-            logger.output('', '%j', arr);
-            return arr;
-        }
-        if (table.rows.length) {
-            logger.output('', '%s', table.toString().trim());
-            console.log('');
-            logger.info('list', '%i Package(s) found', count);
-            return arr;
-        }
-        return arr;
-    }
-}
-(function (ListCommand) {
-    ListCommand.cliCommandOptions = {
-        short: {
-            alias: 's',
-            describe: '# Do not show extended information',
-        },
-        parseable: {
-            alias: 'p',
-            describe: '# Show parseable output',
-        },
-        toposort: {
-            alias: 't',
-            describe: '# Sort packages in topological order (dependencies before dependents) instead of lexical by directory',
-        },
-        graph: {
-            alias: 'g',
-            describe: '# Show dependency graph as a JSON-formatted adjacency list',
-        },
-    };
-    function initCli(repository, program) {
-        program.command({
-            command: 'list [options...]',
-            describe: 'Lists packages in repository',
-            aliases: ['ls'],
-            builder: cmd => cmd
-                .example('$0 list', '# List all packages')
-                .example('$0 list --json', '# List all packages in JSON format')
-                .conflicts('graph', ['parseable', 'json'])
-                .conflicts('short', ['parseable', 'json'])
-                .option(ListCommand.cliCommandOptions),
-            handler: async (args) => {
-                const options = Command.composeOptions(ListCommand.commandName, args, repository.config);
-                await new ListCommand(repository, options).execute();
-            },
-        });
-    }
-    ListCommand.initCli = initCli;
-})(ListCommand || (ListCommand = {}));

package/commands/multi-task-command.d.ts

@@ -1,22 +0,0 @@
-import { Task } from 'power-tasks';
-import * as yargs from 'yargs';
-import { Command } from '../core/command.js';
-import { Package } from '../core/package.js';
-import { Repository } from '../core/repository.js';
-export declare abstract class MultiTaskCommand<TOptions extends MultiTaskCommand.Options = MultiTaskCommand.Options> extends Command<TOptions> {
-    readonly repository: Repository;
-    protected _task?: Task;
-    protected constructor(repository: Repository, options?: TOptions);
-    protected _execute(): Promise<any>;
-    protected _getPackages(): Promise<Package[]>;
-    protected abstract _prepareTasks(packages: Package[]): Task[] | Promise<Task[]> | void;
-}
-export declare namespace MultiTaskCommand {
-    interface Options extends Command.GlobalOptions {
-        concurrency?: number;
-        parallel?: boolean;
-        bail?: boolean;
-        progress?: boolean;
-    }
-    const cliCommandOptions: Record<string, yargs.Options>;
-}

package/commands/multi-task-command.js

@@ -1,65 +0,0 @@
-import os from 'os';
-import { Task } from 'power-tasks';
-import { toNumber } from 'putil-varhelpers';
-import { Command } from '../core/command.js';
-import { isTTY } from '../core/constants.js';
-export class MultiTaskCommand extends Command {
-    repository;
-    _task;
-    constructor(repository, options) {
-        super(options);
-        this.repository = repository;
-        if (this.options.ci || !isTTY)
-            this.options.progress = false;
-        // noinspection SuspiciousTypeOfGuard
-        this.options.concurrency = toNumber(options?.concurrency);
-        if (this.options.bail == null)
-            this.options.bail = true;
-    }
-    async _execute() {
-        const packages = await this._getPackages();
-        const childTasks = await this._prepareTasks(packages);
-        if (!(childTasks && childTasks.length)) {
-            return;
-        }
-        // this.enableProgress();
-        this._task = new Task(childTasks, {
-            name: '$project-root',
-            concurrency: this.options.concurrency || os.cpus().length,
-            bail: this.options.bail,
-        });
-        await this._task.toPromise();
-    }
-    async _getPackages() {
-        return this.repository.getPackages({ toposort: !this.options.parallel });
-    }
-}
-(function (MultiTaskCommand) {
-    MultiTaskCommand.cliCommandOptions = {
-        concurrency: {
-            describe: '# Set processes count to parallelize tasks. (CPU count if not defined)',
-            type: 'number',
-        },
-        parallel: {
-            describe: '# Disregards dependency checking and runs the command for every package at same time.',
-            type: 'boolean',
-        },
-        'no-bail': {
-            describe: '# Continue execution even one fails.',
-            type: 'boolean',
-        },
-        bail: {
-            hidden: true,
-            type: 'boolean',
-        },
-        'no-progress': {
-            describe: 'Disable progress bars',
-            type: 'boolean',
-        },
-        progress: {
-            hidden: true,
-            type: 'boolean',
-            default: true,
-        },
-    };
-})(MultiTaskCommand || (MultiTaskCommand = {}));

package/commands/publish-command.d.ts

@@ -1,24 +0,0 @@
-import { Task } from 'power-tasks';
-import * as yargs from 'yargs';
-import { Package } from '../core/package.js';
-import { Repository } from '../core/repository.js';
-import { ExecuteCommandResult } from '../utils/exec.js';
-import { RunCommand } from './run-command.js';
-export declare class PublishCommand extends RunCommand<PublishCommand.Options> {
-    readonly repository: Repository;
-    static commandName: string;
-    constructor(repository: Repository, options?: PublishCommand.Options);
-    protected _prepareTasks(packages: Package[]): Promise<Task[]>;
-    protected _exec(pkg: Package, command: string, args: {}, options?: any): Promise<ExecuteCommandResult>;
-}
-export declare namespace PublishCommand {
-    interface Options extends RunCommand.Options {
-        contents?: string;
-        access?: string;
-        tag?: string;
-        checkOnly?: boolean;
-        userconfig?: string;
-    }
-    const cliCommandOptions: Record<string, yargs.Options>;
-    function initCli(repository: Repository, program: yargs.Argv): void;
-}

package/commands/publish-command.js

@@ -1,131 +0,0 @@
-import colors from 'ansi-colors';
-import logger from 'npmlog';
-import path from 'path';
-import { Command } from '../core/command.js';
-import { NpmHelper } from '../utils/npm-utils.js';
-import { PackageNotFoundError } from '../utils/package-not-found-error.js';
-import { RunCommand } from './run-command.js';
-export class PublishCommand extends RunCommand {
-    repository;
-    static commandName = 'publish';
-    constructor(repository, options) {
-        super(repository, 'publish', {
-            ...options,
-            bail: false,
-            parallel: true,
-        });
-        this.repository = repository;
-    }
-    async _prepareTasks(packages) {
-        const newVersions = {};
-        const selectedPackages = [];
-        const promises = [];
-        for (const p of packages) {
-            const logPkgName = colors.yellow(p.name);
-            if (p.json.private) {
-                logger.info(this.commandName, logPkgName, logger.separator, `Ignored. Package is set to "private"`);
-                continue;
-            }
-            logger.info(this.commandName, logPkgName, logger.separator, `Fetching package information from repository`);
-            const npmHelper = new NpmHelper({ cwd: p.dirname, userconfig: this.options.userconfig });
-            promises.push(npmHelper
-                .getPackageInfo(p.json.name)
-                .then(r => {
-                const fetchedVersion = r.version;
-                const sameVersion = fetchedVersion === p.version;
-                logger.info(this.commandName, logPkgName, logger.separator, sameVersion
-                    ? `No publish needed. Version (${colors.magenta(p.version)}) same in repository`
-                    : `Publishing is possible.` +
-                        ` Version "${colors.magenta(p.version)}" differs from version in repository (${colors.magenta(fetchedVersion)})`);
-                if (!sameVersion) {
-                    selectedPackages.push(p);
-                }
-            })
-                .catch(e => {
-                if (e instanceof PackageNotFoundError) {
-                    logger.info(this.commandName, logPkgName, logger.separator, 'Publishing is possible. No package information found in repository');
-                    selectedPackages.push(p);
-                }
-                else
-                    throw e;
-            }));
-        }
-        await Promise.all(promises);
-        if (this.options.checkOnly)
-            logger.verbose(this.commandName, '', logger.separator, `${selectedPackages.length} packages can be be published`);
-        else
-            logger.verbose(this.commandName, '', logger.separator, `${selectedPackages.length} packages will be published`);
-        selectedPackages.forEach(p => {
-            p.json.scripts = p.json.scripts || {};
-            p.json.scripts.publish = '#';
-        });
-        return super._prepareTasks(selectedPackages, { newVersions });
-    }
-    async _exec(pkg, command, args, options) {
-        if (command === '#') {
-            if (pkg === this.repository.rootPackage)
-                return { code: 0 };
-            let cwd = pkg.dirname;
-            if (this.options.contents) {
-                const contents = this.options.contents.replaceAll('${package.basename}', pkg.basename);
-                if (contents.startsWith('/'))
-                    cwd = path.join(this.repository.dirname, contents);
-                else
-                    cwd = path.join(pkg.dirname, contents);
-            }
-            const npmHelper = new NpmHelper({ cwd: pkg.dirname, userconfig: this.options.userconfig });
-            return super._exec(pkg, 'npm publish' +
-                (this.options.access ? ' --access=' + this.options.access : '') +
-                (this.options.tag ? ' --tag=' + this.options.tag : '') +
-                (npmHelper.userconfig ? ` --userconfig="${npmHelper.userconfig}"` : ''), {
-                ...args,
-                cwd,
-                stdio: logger.levelIndex < 1000 ? 'inherit' : 'pipe',
-            }, options);
-        }
-        return super._exec(pkg, command, args, options);
-    }
-}
-(function (PublishCommand) {
-    PublishCommand.cliCommandOptions = {
-        ...RunCommand.cliCommandOptions,
-        contents: {
-            describe: '# Subdirectory to publish',
-            type: 'string',
-        },
-        access: {
-            describe: '#  Tells the registry whether this package should be published as public or restricted. ' +
-                "Only applies to scoped packages, which default to restricted. If you don't have a paid account, " +
-                'you must publish with --access public to publish scoped packages.',
-            type: 'string',
-            choices: ['public', 'restricted'],
-        },
-        tag: {
-            describe: '',
-            type: 'string',
-        },
-        userconfig: {
-            describe: '# Path of .npmrc file to use for authentication',
-            type: 'string',
-        },
-        'check-only': {
-            describe: '#  Only performs version checking and do not apply "publish" to the registry.',
-            type: 'boolean',
-        },
-    };
-    function initCli(repository, program) {
-        program.command({
-            command: 'publish [...options]',
-            describe: 'Publish packages in the current project',
-            builder: cmd => cmd
-                .example('$0 publish', '')
-                .example('$0 publish --contents dist', '# publish package from built directory')
-                .option(PublishCommand.cliCommandOptions),
-            handler: async (args) => {
-                const options = Command.composeOptions(PublishCommand.commandName, args, repository.config);
-                await new PublishCommand(repository, options).execute();
-            },
-        });
-    }
-    PublishCommand.initCli = initCli;
-})(PublishCommand || (PublishCommand = {}));

package/commands/run-command.d.ts

@@ -1,28 +0,0 @@
-import { Task } from 'power-tasks';
-import * as yargs from 'yargs';
-import { Package } from '../core/package.js';
-import { Repository } from '../core/repository.js';
-import { ExecuteCommandResult } from '../utils/exec.js';
-import { MultiTaskCommand } from './multi-task-command.js';
-export declare class RunCommand<TOptions extends RunCommand.Options> extends MultiTaskCommand<TOptions> {
-    readonly repository: Repository;
-    script: string;
-    static commandName: string;
-    constructor(repository: Repository, script: string, options?: TOptions);
-    protected _prepareTasks(packages: Package[], options?: any): Task[] | Promise<Task[]>;
-    protected _prepareScriptTask(pkg: Package, options?: any): Task | undefined;
-    protected _exec(pkg: Package, command: string, args: {
-        stdio?: 'inherit' | 'pipe';
-        cwd?: string;
-        json?: any;
-        logLevel?: string;
-        noThrow?: boolean;
-        script?: string;
-    }, options?: any): Promise<ExecuteCommandResult>;
-}
-export declare namespace RunCommand {
-    interface Options extends MultiTaskCommand.Options {
-    }
-    const cliCommandOptions: Record<string, yargs.Options>;
-    function initCli(repository: Repository, program: yargs.Argv): void;
-}

package/commands/run-command.js

@@ -1,131 +0,0 @@
-import parseNpmScript from '@netlify/parse-npm-script';
-import colors from 'ansi-colors';
-import logger from 'npmlog';
-import { Task } from 'power-tasks';
-import { Command } from '../core/command.js';
-import { exec } from '../utils/exec.js';
-import { MultiTaskCommand } from './multi-task-command.js';
-export class RunCommand extends MultiTaskCommand {
-    repository;
-    script;
-    static commandName = 'run';
-    constructor(repository, script, options) {
-        super(repository, options);
-        this.repository = repository;
-        this.script = script;
-    }
-    _prepareTasks(packages, options) {
-        const packageTasks = [];
-        for (const p of packages) {
-            if (p.json.scripts) {
-                const childTask = this._prepareScriptTask(p, options);
-                if (childTask) {
-                    packageTasks.push(childTask);
-                }
-            }
-        }
-        const rootTask = this._prepareScriptTask(this.repository.rootPackage);
-        const children = rootTask?.options.children;
-        if (!children)
-            return packageTasks;
-        const tasks = [];
-        const pre = children.filter(t => t.name?.endsWith(':pre' + this.script));
-        const post = children.filter(t => t.name?.endsWith(':post' + this.script));
-        pre.forEach(t => (t.options.exclusive = true));
-        post.forEach(t => (t.options.exclusive = true));
-        tasks.push(...pre);
-        tasks.push(...packageTasks);
-        tasks.push(...post);
-        return tasks;
-    }
-    _prepareScriptTask(pkg, options) {
-        const json = { ...pkg.json };
-        json.scripts = json.scripts || {};
-        json.scripts[this.script] = json.scripts[this.script] || '#';
-        const scriptInfo = parseNpmScript(json, 'npm run ' + this.script);
-        if (!(scriptInfo && scriptInfo.raw))
-            return;
-        const children = [];
-        for (const s of scriptInfo.steps) {
-            const parsed = Array.isArray(s.parsed) ? s.parsed : [s.parsed];
-            for (const cmd of parsed) {
-                const task = new Task(async () => await this._exec(pkg, cmd, {
-                    script: s.name,
-                    stdio: logger.levelIndex < 1000 ? 'inherit' : 'pipe',
-                }, options), {
-                    name: pkg.name + ':' + s.name,
-                    dependencies: this.options.parallel || s.name.startsWith('pre') || s.name.startsWith('post')
-                        ? undefined
-                        : pkg.dependencies,
-                });
-                children.push(task);
-            }
-        }
-        if (children.length) {
-            return new Task(children, {
-                name: pkg.name,
-                bail: true,
-                serial: true,
-            });
-        }
-    }
-    async _exec(pkg, command, args, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    options) {
-        const name = pkg === this.repository.rootPackage ? 'root' : pkg.name;
-        const logLevel = args.logLevel == null ? 'info' : args.logLevel;
-        if (logLevel) {
-            logger.verbose(this.commandName, colors.cyan(name), logger.separator, colors.cyanBright.bold(args.script || ''), colors.cyanBright.bold('executing'), logger.separator, command);
-        }
-        const t = Date.now();
-        const cwd = args.cwd || pkg.dirname;
-        const r = await exec(command, {
-            cwd,
-            stdio: args.stdio,
-            throwOnError: false,
-        });
-        if (logLevel) {
-            if (r.error) {
-                logger.error(this.commandName, colors.cyan(name), logger.separator, colors.cyanBright.bold(args.script || ''), colors.red.bold('failed'), logger.separator, command, logger.separator, r.error.message.trim() + ('\n' + r.stdout).trim());
-            }
-            else {
-                logger.log(logLevel, this.commandName, colors.cyan(name), logger.separator, colors.cyanBright.bold(args.script || ''), colors.green.bold('success'), logger.separator, command, colors.yellow(' (' + (Date.now() - t) + ' ms)'));
-            }
-        }
-        if (r.error && !args.noThrow)
-            throw r.error;
-        return r;
-    }
-}
-(function (RunCommand) {
-    RunCommand.cliCommandOptions = {
-        ...MultiTaskCommand.cliCommandOptions,
-    };
-    function initCli(repository, program) {
-        program.command({
-            command: 'run <script>',
-            describe: 'Execute an arbitrary script in each package',
-            builder: cmd => cmd
-                .example('$0 run build', '')
-                .positional('script', {
-                describe: '# The script to execute. Any command flags must be passed after --',
-                type: 'string',
-            })
-                .option(RunCommand.cliCommandOptions),
-            handler: async (args) => {
-                const runCfg = repository.config?.command?.run;
-                if (args.script && runCfg && typeof runCfg === 'object') {
-                    ['parallel', 'bail', 'progress'].forEach(n => {
-                        if (typeof runCfg[n] === 'string') {
-                            runCfg[n] = runCfg[n].split(/\s*,\s*/).includes(String(args.script));
-                        }
-                    });
-                }
-                const options = Command.composeOptions(RunCommand.commandName, args, repository.config);
-                const script = '' + args.script;
-                await new RunCommand(repository, script, options).execute();
-            },
-        });
-    }
-    RunCommand.initCli = initCli;
-})(RunCommand || (RunCommand = {}));

package/commands/version-command.d.ts

@@ -1,25 +0,0 @@
-import { Task } from 'power-tasks';
-import * as yargs from 'yargs';
-import { Package } from '../core/package.js';
-import { Repository } from '../core/repository.js';
-import { ExecuteCommandResult } from '../utils/exec.js';
-import { RunCommand } from './run-command.js';
-export declare class VersionCommand extends RunCommand<VersionCommand.Options> {
-    readonly repository: Repository;
-    bump: string;
-    static commandName: string;
-    private _updatedPackages;
-    constructor(repository: Repository, bump: string, options?: VersionCommand.Options);
-    protected _prepareTasks(packages: Package[]): Promise<Task[]>;
-    protected _exec(pkg: Package, command: string, args: {}, options?: any): Promise<ExecuteCommandResult>;
-}
-export declare namespace VersionCommand {
-    interface Options extends RunCommand.Options {
-        unified?: boolean;
-        all?: boolean;
-        ignoreDirty?: boolean;
-        noTag?: boolean;
-    }
-    const cliCommandOptions: Record<string, yargs.Options>;
-    function initCli(repository: Repository, program: yargs.Argv): void;
-}