rman 0.38.0 → 1.0.2

package/commands/version-command.js

@@ -1,198 +0,0 @@
-import colors from 'ansi-colors';
-import logger from 'npmlog';
-import path from 'path';
-import { Task } from 'power-tasks';
-import semver from 'semver';
-import stripColor from 'strip-color';
-import * as yargs from 'yargs';
-import { Command } from '../core/command.js';
-import { Package } from '../core/package.js';
-import { Repository } from '../core/repository.js';
-import { GitHelper } from '../utils/git-utils.js';
-import { RunCommand } from './run-command.js';
-export class VersionCommand extends RunCommand {
-    repository;
-    bump;
-    static commandName = 'version';
-    _updatedPackages = new Set();
-    constructor(repository, bump, options) {
-        super(repository, 'version', options);
-        this.repository = repository;
-        this.bump = bump;
-    }
-    async _prepareTasks(packages) {
-        const { repository } = this;
-        const git = new GitHelper({ cwd: repository.dirname });
-        const dirtyFiles = await git.listDirtyFiles();
-        const committedFiles = await git.listCommittedFiles();
-        const newVersions = {};
-        let errorCount = 0;
-        const selectedPackages = [];
-        const dependentPackages = [];
-        for (const p of packages) {
-            const relDir = path.relative(repository.dirname, p.dirname);
-            let status = '';
-            let message = '';
-            let newVer = '';
-            const logPkgName = colors.yellow(p.name);
-            if (!this.options.noTag) {
-                const isDirty = dirtyFiles.find(f => !path.relative(relDir, f).startsWith('..'));
-                if (isDirty) {
-                    if (!this.options.ignoreDirty)
-                        errorCount++;
-                    status = this.options.ignoreDirty ? colors.cyan.bold('skip') : colors.redBright.bold('error');
-                    message = 'Git directory is not clean';
-                }
-            }
-            if (!status) {
-                const isChanged = committedFiles.find(f => !path.relative(relDir, f).startsWith('..'));
-                newVer =
-                    isChanged || this.options.all || this.options.unified
-                        ? semver.inc(p.version, this.bump)
-                        : undefined;
-                if (newVer)
-                    newVersions[p.name] = newVer;
-                else {
-                    status = colors.cyanBright.bold('no-change');
-                    message = 'No change detected';
-                }
-            }
-            if (status) {
-                if (this.options.json) {
-                    logger.info(this.commandName, '%j', {
-                        package: p.name,
-                        version: p.version,
-                        newVersion: newVer,
-                        status: stripColor(status),
-                        message: stripColor(message),
-                    });
-                }
-                else {
-                    logger.log(this.options.ignoreDirty ? 'info' : 'error', this.commandName, logPkgName, colors.whiteBright(p.version), status, logger.separator, message);
-                }
-                continue;
-            }
-            selectedPackages.push(p);
-            packages.forEach(p2 => {
-                if (p2.dependencies.includes(p.name) && !dependentPackages.includes(p2))
-                    dependentPackages.push(p2);
-            });
-        }
-        if (errorCount)
-            throw new Error('Unable to bump version due to error(s)');
-        const maxVer = Object.values(newVersions).reduce((m, v) => (semver.gt(m, v) ? m : v), '0.0.0');
-        if (this.options.unified) {
-            Object.keys(newVersions).forEach(k => (newVersions[k] = maxVer));
-        }
-        dependentPackages.forEach(p2 => {
-            if (!selectedPackages.includes(p2))
-                selectedPackages.push(p2);
-        });
-        const tasks = await super._prepareTasks(selectedPackages, { newVersions });
-        tasks.forEach(t => (t.options.exclusive = true));
-        if (!this.options.noTag) {
-            tasks.push(new Task(async () => {
-                while (this._updatedPackages.size) {
-                    const filenames = [];
-                    const [first] = this._updatedPackages;
-                    for (const pkg of this._updatedPackages) {
-                        if (pkg.version === first.version) {
-                            filenames.push(path.relative(this.repository.rootPackage.dirname, pkg.jsonFileName));
-                            this._updatedPackages.delete(pkg);
-                        }
-                    }
-                    await super._exec(this.repository.rootPackage, 'git commit -m "' + first.version + '" ' + filenames.map(s => '"' + s + '"').join(' '), {
-                        stdio: logger.levelIndex < 1000 ? 'inherit' : 'pipe',
-                        logLevel: 'silly',
-                    });
-                }
-                if (this.options.unified) {
-                    try {
-                        await super._exec(this.repository.rootPackage, 'git tag -a "v' + maxVer + '" -m "version ' + maxVer + '"', {
-                            cwd: this.repository.dirname,
-                            stdio: logger.levelIndex < 1000 ? 'inherit' : 'pipe',
-                            logLevel: 'silly',
-                        });
-                    }
-                    catch {
-                        //
-                    }
-                }
-            }, { exclusive: true }));
-        }
-        return tasks;
-    }
-    async _exec(pkg, command, args, options) {
-        if (pkg === this.repository.rootPackage)
-            return { code: 0 };
-        if (command === '#') {
-            const { newVersions } = options;
-            pkg.reloadJson();
-            const oldVer = pkg.json.version;
-            const newVer = newVersions[pkg.name];
-            pkg.json.version = newVer;
-            delete pkg.json.scripts.version;
-            pkg.writeJson();
-            if (!this._updatedPackages.has(pkg))
-                this._updatedPackages.add(pkg);
-            const packages = this.repository.getPackages();
-            for (const p of packages) {
-                if (p.dependencies.includes(pkg.name)) {
-                    p.reloadJson();
-                    for (const k of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
-                        if (p.json[k]?.[pkg.name]) {
-                            p.json[k][pkg.name] = '^' + newVer;
-                        }
-                    }
-                    p.writeJson();
-                    if (!this._updatedPackages.has(p))
-                        this._updatedPackages.add(p);
-                }
-            }
-            logger.info(this.commandName, pkg.name, logger.separator, 'Version changed from ' + colors.cyan(oldVer) + ' to ' + colors.cyan(newVer));
-            return { code: 0 };
-        }
-        return super._exec(pkg, command, args, options);
-    }
-}
-(function (VersionCommand) {
-    VersionCommand.cliCommandOptions = {
-        unified: {
-            alias: 'u',
-            describe: '# Keep all package versions same',
-            type: 'boolean',
-        },
-        all: {
-            alias: 'a',
-            describe: '# Bump version for all packages even no commits',
-            type: 'boolean',
-        },
-        'ignore-dirty': {
-            alias: 'i',
-            describe: '# Do not bump version for dirty packages',
-            type: 'boolean',
-        },
-        'no-tag': {
-            alias: 'n',
-            describe: '# Do not crate git version tag. (Ignores dirty check)',
-            type: 'boolean',
-        },
-    };
-    function initCli(repository, program) {
-        program.command({
-            command: 'version [bump] [...options]',
-            describe: 'Bump version of packages',
-            builder: cmd => cmd
-                .example('$0 version patch', '# semver keyword')
-                .example('$0 version 1.0.1', '# explicit')
-                .conflicts('ignore-dirty', ['force-dirty', 'unified'])
-                .option(VersionCommand.cliCommandOptions),
-            handler: async (args) => {
-                const bump = args.bump;
-                const options = Command.composeOptions(VersionCommand.commandName, args, repository.config);
-                await new VersionCommand(repository, bump, options).execute();
-            },
-        });
-    }
-    VersionCommand.initCli = initCli;
-})(VersionCommand || (VersionCommand = {}));

package/core/command.d.ts

@@ -1,35 +0,0 @@
-import './logger.js';
-import npmlog from 'npmlog';
-import * as yargs from 'yargs';
-export interface CommandEvents {
-    start: () => void | Promise<void>;
-    finish: (error?: any, result?: any) => void | Promise<void>;
-    error: (e: unknown) => void | Promise<void>;
-}
-declare const Command_base: import("strict-typed-events").Type<import("strict-typed-events").TypedEventEmitter<any, CommandEvents, CommandEvents>>;
-export declare abstract class Command<TOptions extends Command.GlobalOptions = Command.GlobalOptions> extends Command_base {
-    protected _started: boolean;
-    protected _finished: boolean;
-    protected _options: TOptions;
-    logger: npmlog.Logger;
-    static commandName: string;
-    constructor(options?: TOptions);
-    get options(): TOptions;
-    get commandName(): string;
-    execute(): Promise<any>;
-    protected enableProgress(): Promise<void>;
-    protected disableProgress(): void;
-    protected abstract _execute(): Promise<any>;
-    protected _preExecute(): Promise<void>;
-    protected _postExecute?(): Promise<void>;
-}
-export declare namespace Command {
-    interface GlobalOptions {
-        logLevel?: string;
-        json?: boolean;
-        ci?: boolean;
-    }
-    const globalOptions: Record<string, yargs.Options>;
-    function composeOptions<TOptions extends GlobalOptions = GlobalOptions>(commandName: string, yargArgs: any, config: any): Partial<TOptions>;
-}
-export {};

package/core/command.js

@@ -1,117 +0,0 @@
-import './logger.js';
-import colors from 'ansi-colors';
-import isCi from 'is-ci';
-import npmlog from 'npmlog';
-import merge from 'putil-merge';
-import { AsyncEventEmitter, TypedEventEmitterClass } from 'strict-typed-events';
-import * as yargs from 'yargs';
-import { isTTY } from './constants.js';
-const noOp = () => undefined;
-const lineVerticalDashed0 = '┆';
-export class Command extends TypedEventEmitterClass(AsyncEventEmitter) {
-    _started = false;
-    _finished = false;
-    _options;
-    logger = npmlog;
-    static commandName;
-    constructor(options) {
-        super();
-        this._options = options || {};
-        if (isCi)
-            this.options.ci = true;
-        this.logger.separator = colors.gray(lineVerticalDashed0);
-        Object.defineProperty(this.logger, 'levelIndex', {
-            get() {
-                return npmlog.levels[npmlog.level] || 0;
-            },
-        });
-    }
-    get options() {
-        return this._options;
-    }
-    get commandName() {
-        return Object.getPrototypeOf(this).constructor.commandName;
-    }
-    async execute() {
-        if (this._finished) {
-            this._finished = false;
-            this._started = false;
-        }
-        if (!this._started) {
-            this._started = true;
-            await this.emitAsync('start');
-        }
-        this._started = true;
-        try {
-            this.logger.level = this.options.logLevel || (this.options.ci ? 'error' : 'info');
-            if (this.options.ci || !isTTY) {
-                this.logger.disableColor();
-                this.logger.disableUnicode();
-            }
-            else {
-                this.logger.enableColor();
-                this.logger.enableUnicode();
-            }
-            if (this._preExecute)
-                await this._preExecute();
-            const v = await this._execute();
-            if (this._postExecute)
-                await this._postExecute();
-            await this.emitAsync('finish', undefined, v).catch(noOp);
-            this.disableProgress();
-            this.logger.resume();
-            this.logger.info('', 'Command completed');
-            return v;
-        }
-        catch (e) {
-            this.disableProgress();
-            await this.emitAsync('finish', e).catch(noOp);
-            if (this.listenerCount('error'))
-                await this.emitAsync('error', e).catch(noOp);
-            this.logger.resume();
-            this.logger.error(this.commandName, this.logger.separator, e.message.trim());
-            e.logged = true;
-            throw e;
-        }
-        finally {
-            this._finished = true;
-        }
-    }
-    async enableProgress() {
-        // if (this.options.ci || !isTTY || (this._screen && this._screen.visible)) return;
-    }
-    disableProgress() {
-        //
-    }
-    async _preExecute() {
-        npmlog.info('rman', `Executing "${this.commandName}" command`);
-    }
-}
-(function (Command) {
-    Command.globalOptions = {
-        'log-level': {
-            defaultDescription: 'info',
-            describe: 'Set log level',
-            choices: ['silly', 'verbose', 'info', 'output', 'notice', 'success', 'warn', 'error', 'silent'],
-            requiresArg: true,
-        },
-        json: {
-            alias: 'j',
-            describe: '# Stream log as json',
-            type: 'boolean',
-        },
-        ci: {
-            hidden: true,
-            type: 'boolean',
-        },
-    };
-    function composeOptions(commandName, yargArgs, config) {
-        const result = merge({}, config, { filter: (_, key) => key !== 'command' });
-        merge(result, yargArgs);
-        const cfgCmd = config.command && typeof config.command === 'object' ? config.command[commandName] : undefined;
-        if (cfgCmd && typeof cfgCmd === 'object')
-            merge(result, cfgCmd);
-        return result;
-    }
-    Command.composeOptions = composeOptions;
-})(Command || (Command = {}));

package/core/constants.d.ts

@@ -1 +0,0 @@
-export declare const isTTY: boolean;

package/core/constants.js

@@ -1,2 +0,0 @@
-// export const DOTS = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-export const isTTY = process.stdout.isTTY && process.env.TERM !== 'dumb';

package/core/logger.d.ts

@@ -1,12 +0,0 @@
-declare module 'npmlog' {
-    interface Logger {
-        output(prefix: string, message: string, ...args: any[]): void;
-        success(prefix: string, message: string, ...args: any[]): void;
-        disp: Record<string, string>;
-        showProgress(): any;
-        hideProgress(): any;
-        separator: string;
-        levelIndex: number;
-    }
-}
-export {};

package/core/logger.js

@@ -1,2 +0,0 @@
-import logger from 'npmlog';
-logger.addLevel('output', 3300, {}, '');

package/utils/file-utils.d.ts

@@ -1,4 +0,0 @@
-import { Stats } from 'node:fs';
-export declare function fsExists(s: string): Promise<boolean>;
-export declare function tryStat(s: any): Promise<Stats | undefined>;
-export declare function fsDelete(fileOrDir: string): Promise<boolean>;

package/utils/file-utils.js

@@ -1,29 +0,0 @@
-import { Stats } from 'node:fs';
-import fsa from 'fs/promises';
-import path from 'path';
-export async function fsExists(s) {
-    return fsa
-        .lstat(s)
-        .then(() => true)
-        .catch(() => false);
-}
-export async function tryStat(s) {
-    return fsa.lstat(s).catch(() => undefined);
-}
-export async function fsDelete(fileOrDir) {
-    const stat = await tryStat(fileOrDir);
-    if (stat) {
-        if (stat.isFile() || stat.isSymbolicLink()) {
-            await fsa.unlink(fileOrDir);
-            return true;
-        }
-        if (stat.isDirectory()) {
-            const list = await fsa.readdir(fileOrDir);
-            for (const file of list)
-                await fsDelete(path.join(fileOrDir, file));
-            await fsa.rmdir(fileOrDir);
-            return true;
-        }
-    }
-    return false;
-}

package/utils/git-utils.d.ts

@@ -1,25 +0,0 @@
-export declare namespace GitHelper {
-    interface FileStatus {
-        filename: string;
-        status: string;
-    }
-}
-export interface GitOptions {
-    cwd?: string;
-}
-export declare class GitHelper {
-    cwd: string;
-    constructor(options?: GitOptions);
-    listDirtyFileStatus(options?: {
-        absolute?: boolean;
-    }): Promise<GitHelper.FileStatus[]>;
-    listDirtyFiles(options?: {
-        absolute?: boolean;
-    }): Promise<string[]>;
-    listCommitSha(): Promise<string[]>;
-    listCommittedFiles(options?: {
-        absolute?: boolean;
-        commits?: string | string[];
-    }): Promise<string[]>;
-    readFileLastPublished(filePath: string, commitSha?: string): Promise<string>;
-}

package/utils/git-utils.js

@@ -1,66 +0,0 @@
-import path from 'path';
-import { exec } from './exec.js';
-export class GitHelper {
-    cwd;
-    constructor(options) {
-        this.cwd = options?.cwd || process.cwd();
-    }
-    async listDirtyFileStatus(options) {
-        const x = await exec('git', {
-            cwd: this.cwd,
-            argv: ['status', '--porcelain'],
-        });
-        const result = [];
-        const files = x.stdout ? x.stdout.trim().split(/\s*\n\s*/) : [];
-        for (const f of files) {
-            const m = f.match(/^(\w+) (.+)$/);
-            if (m) {
-                result.push({
-                    filename: options?.absolute ? path.join(this.cwd, m[2]) : m[2],
-                    status: m[1],
-                });
-            }
-        }
-        return result;
-    }
-    async listDirtyFiles(options) {
-        return (await this.listDirtyFileStatus(options)).map(x => x.filename);
-    }
-    async listCommitSha() {
-        const x = await exec('git', {
-            cwd: this.cwd,
-            argv: ['cherry'],
-        });
-        const matches = x.stdout ? x.stdout.matchAll(/([a-f0-9]+)/gi) : [];
-        const result = [];
-        for (const m of matches) {
-            result.push(m[1]);
-        }
-        return result;
-    }
-    async listCommittedFiles(options) {
-        const shaArr = options?.commits
-            ? Array.isArray(options?.commits)
-                ? options?.commits
-                : [options?.commits]
-            : await this.listCommitSha();
-        let result = [];
-        for (const s of shaArr) {
-            const x = await exec('git', {
-                cwd: this.cwd,
-                argv: ['show', s, '--name-only', '--pretty="format:"'],
-            });
-            result.push(...(x.stdout ? x.stdout.trim().split(/\s*\n\s*/) : []));
-        }
-        if (options?.absolute)
-            result = result.map(f => path.join(this.cwd, f));
-        return result;
-    }
-    async readFileLastPublished(filePath, commitSha) {
-        const x = await exec('git', {
-            cwd: this.cwd,
-            argv: ['show', (commitSha || 'HEAD') + ':"' + filePath + '"'],
-        });
-        return x.stdout || '';
-    }
-}

package/utils/npm-utils.d.ts

@@ -1,11 +0,0 @@
-export declare namespace NpmHelper { }
-export interface NpmOptions {
-    cwd?: string;
-    userconfig?: string;
-}
-export declare class NpmHelper {
-    cwd: string;
-    userconfig?: string;
-    constructor(options?: NpmOptions);
-    getPackageInfo(packageName: string): Promise<any>;
-}

package/utils/npm-utils.js

@@ -1,33 +0,0 @@
-import path from 'path';
-import { exec } from './exec.js';
-import { PackageNotFoundError } from './package-not-found-error.js';
-export class NpmHelper {
-    cwd;
-    userconfig;
-    constructor(options) {
-        this.cwd = options?.cwd || process.cwd();
-        this.userconfig = options?.userconfig ? path.resolve(this.cwd, options.userconfig) : undefined;
-    }
-    async getPackageInfo(packageName) {
-        const argv = ['view', packageName, '--json'];
-        if (this.userconfig)
-            argv.push('--userconfig', this.userconfig);
-        const x = await exec('npm', { cwd: this.cwd, argv });
-        if (x && x.stdout) {
-            if (x.code && x.stdout.includes('404')) {
-                throw new PackageNotFoundError('Package ' + packageName + ' not found in repository');
-            }
-            const b = x.stdout.indexOf('{');
-            const e = x.stdout.lastIndexOf('}');
-            const s = x.stdout.substring(b, e + 1);
-            try {
-                if (s)
-                    return JSON.parse(s);
-            }
-            catch {
-                //
-            }
-        }
-        throw new Error('Unable to fetch version info');
-    }
-}

package/utils/package-not-found-error.d.ts

@@ -1,2 +0,0 @@
-export declare class PackageNotFoundError extends Error {
-}

package/utils/package-not-found-error.js

@@ -1,2 +0,0 @@
-export class PackageNotFoundError extends Error {
-}