@lerna-lite/core 1.2.0 → 1.5.0

package/README.md

@@ -1,13 +1,13 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![TypeScript](https://img.shields.io/badge/%3C%2F%3E-TypeScript-%230074c1.svg)](http://www.typescriptlang.org/)
-[![npm](https://img.shields.io/npm/v/@lerna-lite/core.svg?color=forest)](https://www.npmjs.com/package/@lerna-lite/core)
 [![npm](https://img.shields.io/npm/dy/@lerna-lite/core?color=forest)](https://www.npmjs.com/package/@lerna-lite/core)
-[![Actions Status](https://github.com/ghiscoding/lerna-lite/workflows/CI%20Build/badge.svg)](https://github.com/ghiscoding/lerna-lite/actions)
+[![npm](https://img.shields.io/npm/v/@lerna-lite/core.svg?logo=npm&logoColor=fff&label=npm)](https://www.npmjs.com/package/@lerna-lite/core)
 
 ## Lerna-Lite Core
+
 #### @lerna-lite/core
 
 The Lerna-Lite core & utils, basically the shared code used by all commands.
 
 ### Installation
+
 Follow the instruction provided in the main [README](https://github.com/ghiscoding/lerna-lite#installation) page.

package/dist/child-process.d.ts

@@ -1,62 +1,62 @@
-import execa from 'execa';
-import { Package } from './package';
-/**
- * Execute a command asynchronously, piping stdio by default.
- * @param {string} command
- * @param {string[]} args
- * @param {import("execa").Options} [opts]
- */
-export declare function exec(command: string, args: string[], opts?: execa.Options & {
-    pkg?: Package;
-}, cmdDryRun?: boolean): Promise<any>;
-/**
- * Execute a command synchronously.
- * @param {string} command
- * @param {string[]} args
- * @param {import("execa").SyncOptions} [opts]
- */
-export declare function execSync(command: string, args?: string[], opts?: execa.SyncOptions<string>, cmdDryRun?: boolean): string;
-/**
- * Spawn a command asynchronously, _always_ inheriting stdio.
- * @param {string} command
- * @param {string[]} args
- * @param {import("execa").Options} [opts]
- */
-export declare function spawn(command: string, args: string[], opts?: execa.Options & {
-    pkg?: Package;
-}, cmdDryRun?: boolean): Promise<any>;
-/**
- * Spawn a command asynchronously, streaming stdio with optional prefix.
- * @param {string} command
- * @param {string[]} args
- * @param {import("execa").Options} [opts]
- * @param {string} [prefix]
- */
-export declare function spawnStreaming(command: string, args: string[], opts?: execa.Options & {
-    pkg?: Package;
-}, prefix?: string | boolean, cmdDryRun?: boolean): Promise<any>;
-export declare function getChildProcessCount(): number;
-export declare function getExitCode(result: any): any;
-/**
- * @param {string} command
- * @param {string[]} args
- * @param {import("execa").Options} opts
- */
-export declare function spawnProcess(command: string, args: string[], opts: execa.Options & {
-    pkg?: Package;
-}, cmdDryRun?: boolean): any;
-/**
- * Spawn a command asynchronously, _always_ inheriting stdio.
- * @param {string} command
- * @param {string[]} args
- * @param {import("execa").Options} [opts]
- */
-export declare function wrapError(spawned: execa.ExecaChildProcess & {
-    pkg?: Package;
-}): Promise<execa.ExecaReturnValue<string>>;
-/**
- * Log the child-process command and its arguments as dry-run (without executing the process)
- * @param {string} command
- * @param {string[]} args
- */
-export declare function logExecCommand(command: string, args?: string[]): string;
+import execa from 'execa';
+import { Package } from './package';
+/**
+ * Execute a command asynchronously, piping stdio by default.
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import("execa").Options} [opts]
+ */
+export declare function exec(command: string, args: string[], opts?: execa.Options & {
+    pkg?: Package;
+}, cmdDryRun?: boolean): Promise<any>;
+/**
+ * Execute a command synchronously.
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import("execa").SyncOptions} [opts]
+ */
+export declare function execSync(command: string, args?: string[], opts?: execa.SyncOptions<string>, cmdDryRun?: boolean): string;
+/**
+ * Spawn a command asynchronously, _always_ inheriting stdio.
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import("execa").Options} [opts]
+ */
+export declare function spawn(command: string, args: string[], opts?: execa.Options & {
+    pkg?: Package;
+}, cmdDryRun?: boolean): Promise<any>;
+/**
+ * Spawn a command asynchronously, streaming stdio with optional prefix.
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import("execa").Options} [opts]
+ * @param {string} [prefix]
+ */
+export declare function spawnStreaming(command: string, args: string[], opts?: execa.Options & {
+    pkg?: Package;
+}, prefix?: string | boolean, cmdDryRun?: boolean): Promise<any>;
+export declare function getChildProcessCount(): number;
+export declare function getExitCode(result: any): any;
+/**
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import("execa").Options} opts
+ */
+export declare function spawnProcess(command: string, args: string[], opts: execa.Options & {
+    pkg?: Package;
+}, cmdDryRun?: boolean): any;
+/**
+ * Spawn a command asynchronously, _always_ inheriting stdio.
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import("execa").Options} [opts]
+ */
+export declare function wrapError(spawned: execa.ExecaChildProcess & {
+    pkg?: Package;
+}): Promise<execa.ExecaReturnValue<string>>;
+/**
+ * Log the child-process command and its arguments as dry-run (without executing the process)
+ * @param {string} command
+ * @param {string[]} args
+ */
+export declare function logExecCommand(command: string, args?: string[]): string;

package/dist/child-process.js

@@ -1,166 +1,166 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logExecCommand = exports.wrapError = exports.spawnProcess = exports.getExitCode = exports.getChildProcessCount = exports.spawnStreaming = exports.spawn = exports.execSync = exports.exec = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const execa_1 = __importDefault(require("execa"));
-const npmlog_1 = __importDefault(require("npmlog"));
-const os_1 = __importDefault(require("os"));
-const strong_log_transformer_1 = __importDefault(require("strong-log-transformer"));
-// bookkeeping for spawned processes
-const children = new Set();
-// when streaming processes are spawned, use this color for prefix
-const colorWheel = ['cyan', 'magenta', 'blue', 'yellow', 'green', 'red'];
-const NUM_COLORS = colorWheel.length;
-// ever-increasing index ensures colors are always sequential
-let currentColor = 0;
-/**
- * Execute a command asynchronously, piping stdio by default.
- * @param {string} command
- * @param {string[]} args
- * @param {import("execa").Options} [opts]
- */
-function exec(command, args, opts, cmdDryRun = false) {
-    const options = Object.assign({ stdio: 'pipe' }, opts);
-    const spawned = spawnProcess(command, args, options, cmdDryRun);
-    return cmdDryRun ? Promise.resolve() : wrapError(spawned);
-}
-exports.exec = exec;
-/**
- * Execute a command synchronously.
- * @param {string} command
- * @param {string[]} args
- * @param {import("execa").SyncOptions} [opts]
- */
-function execSync(command, args, opts, cmdDryRun = false) {
-    return cmdDryRun
-        ? logExecCommand(command, args)
-        : execa_1.default.sync(command, args, opts).stdout;
-}
-exports.execSync = execSync;
-/**
- * Spawn a command asynchronously, _always_ inheriting stdio.
- * @param {string} command
- * @param {string[]} args
- * @param {import("execa").Options} [opts]
- */
-function spawn(command, args, opts, cmdDryRun = false) {
-    const options = Object.assign({}, opts, { stdio: 'inherit' });
-    const spawned = spawnProcess(command, args, options, cmdDryRun);
-    return wrapError(spawned);
-}
-exports.spawn = spawn;
-/**
- * Spawn a command asynchronously, streaming stdio with optional prefix.
- * @param {string} command
- * @param {string[]} args
- * @param {import("execa").Options} [opts]
- * @param {string} [prefix]
- */
-// istanbul ignore next
-function spawnStreaming(command, args, opts, prefix, cmdDryRun = false) {
-    const options = Object.assign({}, opts);
-    options.stdio = ['ignore', 'pipe', 'pipe'];
-    const spawned = spawnProcess(command, args, options, cmdDryRun);
-    const stdoutOpts = {};
-    const stderrOpts = {}; // mergeMultiline causes escaped newlines :P
-    if (prefix) {
-        const colorName = colorWheel[currentColor % NUM_COLORS];
-        const color = chalk_1.default[colorName];
-        currentColor += 1;
-        stdoutOpts.tag = `${color.bold(prefix)}:`;
-        stderrOpts.tag = `${color(prefix)}:`;
-    }
-    // Avoid 'Possible EventEmitter memory leak detected' warning due to piped stdio
-    if (children.size > process.stdout.listenerCount('close')) {
-        process.stdout.setMaxListeners(children.size);
-        process.stderr.setMaxListeners(children.size);
-    }
-    spawned.stdout.pipe((0, strong_log_transformer_1.default)(stdoutOpts)).pipe(process.stdout);
-    spawned.stderr.pipe((0, strong_log_transformer_1.default)(stderrOpts)).pipe(process.stderr);
-    return wrapError(spawned);
-}
-exports.spawnStreaming = spawnStreaming;
-function getChildProcessCount() {
-    return children.size;
-}
-exports.getChildProcessCount = getChildProcessCount;
-function getExitCode(result) {
-    var _a, _b, _c;
-    // https://nodejs.org/docs/latest-v6.x/api/child_process.html#child_process_event_close
-    if (typeof result.code === 'number' || typeof result.exitCode === 'number') {
-        return (_a = result.code) !== null && _a !== void 0 ? _a : result.exitCode;
-    }
-    // https://nodejs.org/docs/latest-v6.x/api/errors.html#errors_error_code
-    // istanbul ignore else
-    if (typeof result.code === 'string' || typeof result.exitCode === 'string') {
-        return os_1.default.constants.errno[(_b = result.code) !== null && _b !== void 0 ? _b : result.exitCode];
-    }
-    // istanbul ignore next: extremely weird
-    throw new TypeError(`Received unexpected exit code value ${JSON.stringify((_c = result.code) !== null && _c !== void 0 ? _c : result.exitCode)}`);
-}
-exports.getExitCode = getExitCode;
-/**
- * @param {string} command
- * @param {string[]} args
- * @param {import("execa").Options} opts
- */
-function spawnProcess(command, args, opts, cmdDryRun = false) {
-    if (cmdDryRun) {
-        return logExecCommand(command, args);
-    }
-    const child = (0, execa_1.default)(command, args, opts);
-    const drain = (_code, signal) => {
-        children.delete(child);
-        // don't run repeatedly if this is the error event
-        if (signal === undefined) {
-            child.removeListener('exit', drain);
-        }
-    };
-    child.once('exit', drain);
-    child.once('error', drain);
-    if (opts.pkg) {
-        child.pkg = opts.pkg;
-    }
-    children.add(child);
-    return child;
-}
-exports.spawnProcess = spawnProcess;
-/**
- * Spawn a command asynchronously, _always_ inheriting stdio.
- * @param {string} command
- * @param {string[]} args
- * @param {import("execa").Options} [opts]
- */
-function wrapError(spawned) {
-    if (spawned.pkg) {
-        return spawned.catch((err) => {
-            // ensure exit code is always a number
-            err.exitCode = getExitCode(err);
-            // log non-lerna error cleanly
-            err.pkg = spawned.pkg;
-            throw err;
-        });
-    }
-    return spawned;
-}
-exports.wrapError = wrapError;
-/**
- * Log the child-process command and its arguments as dry-run (without executing the process)
- * @param {string} command
- * @param {string[]} args
- */
-function logExecCommand(command, args) {
-    var _a;
-    const argStr = (_a = (Array.isArray(args) ? args.join(' ') : args)) !== null && _a !== void 0 ? _a : '';
-    const cmdList = [];
-    for (const c of [command, argStr]) {
-        cmdList.push((Array.isArray(c) ? c.join(' ') : c));
-    }
-    npmlog_1.default.info('dry-run>', cmdList.join(' '));
-    return '';
-}
-exports.logExecCommand = logExecCommand;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logExecCommand = exports.wrapError = exports.spawnProcess = exports.getExitCode = exports.getChildProcessCount = exports.spawnStreaming = exports.spawn = exports.execSync = exports.exec = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const execa_1 = __importDefault(require("execa"));
+const npmlog_1 = __importDefault(require("npmlog"));
+const os_1 = __importDefault(require("os"));
+const strong_log_transformer_1 = __importDefault(require("strong-log-transformer"));
+// bookkeeping for spawned processes
+const children = new Set();
+// when streaming processes are spawned, use this color for prefix
+const colorWheel = ['cyan', 'magenta', 'blue', 'yellow', 'green', 'red'];
+const NUM_COLORS = colorWheel.length;
+// ever-increasing index ensures colors are always sequential
+let currentColor = 0;
+/**
+ * Execute a command asynchronously, piping stdio by default.
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import("execa").Options} [opts]
+ */
+function exec(command, args, opts, cmdDryRun = false) {
+    const options = Object.assign({ stdio: 'pipe' }, opts);
+    const spawned = spawnProcess(command, args, options, cmdDryRun);
+    return cmdDryRun ? Promise.resolve() : wrapError(spawned);
+}
+exports.exec = exec;
+/**
+ * Execute a command synchronously.
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import("execa").SyncOptions} [opts]
+ */
+function execSync(command, args, opts, cmdDryRun = false) {
+    return cmdDryRun
+        ? logExecCommand(command, args)
+        : execa_1.default.sync(command, args, opts).stdout;
+}
+exports.execSync = execSync;
+/**
+ * Spawn a command asynchronously, _always_ inheriting stdio.
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import("execa").Options} [opts]
+ */
+function spawn(command, args, opts, cmdDryRun = false) {
+    const options = Object.assign({}, opts, { stdio: 'inherit' });
+    const spawned = spawnProcess(command, args, options, cmdDryRun);
+    return wrapError(spawned);
+}
+exports.spawn = spawn;
+/**
+ * Spawn a command asynchronously, streaming stdio with optional prefix.
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import("execa").Options} [opts]
+ * @param {string} [prefix]
+ */
+// istanbul ignore next
+function spawnStreaming(command, args, opts, prefix, cmdDryRun = false) {
+    const options = Object.assign({}, opts);
+    options.stdio = ['ignore', 'pipe', 'pipe'];
+    const spawned = spawnProcess(command, args, options, cmdDryRun);
+    const stdoutOpts = {};
+    const stderrOpts = {}; // mergeMultiline causes escaped newlines :P
+    if (prefix) {
+        const colorName = colorWheel[currentColor % NUM_COLORS];
+        const color = chalk_1.default[colorName];
+        currentColor += 1;
+        stdoutOpts.tag = `${color.bold(prefix)}:`;
+        stderrOpts.tag = `${color(prefix)}:`;
+    }
+    // Avoid 'Possible EventEmitter memory leak detected' warning due to piped stdio
+    if (children.size > process.stdout.listenerCount('close')) {
+        process.stdout.setMaxListeners(children.size);
+        process.stderr.setMaxListeners(children.size);
+    }
+    spawned.stdout.pipe((0, strong_log_transformer_1.default)(stdoutOpts)).pipe(process.stdout);
+    spawned.stderr.pipe((0, strong_log_transformer_1.default)(stderrOpts)).pipe(process.stderr);
+    return wrapError(spawned);
+}
+exports.spawnStreaming = spawnStreaming;
+function getChildProcessCount() {
+    return children.size;
+}
+exports.getChildProcessCount = getChildProcessCount;
+function getExitCode(result) {
+    var _a, _b, _c;
+    // https://nodejs.org/docs/latest-v6.x/api/child_process.html#child_process_event_close
+    if (typeof result.code === 'number' || typeof result.exitCode === 'number') {
+        return (_a = result.code) !== null && _a !== void 0 ? _a : result.exitCode;
+    }
+    // https://nodejs.org/docs/latest-v6.x/api/errors.html#errors_error_code
+    // istanbul ignore else
+    if (typeof result.code === 'string' || typeof result.exitCode === 'string') {
+        return os_1.default.constants.errno[(_b = result.code) !== null && _b !== void 0 ? _b : result.exitCode];
+    }
+    // istanbul ignore next: extremely weird
+    throw new TypeError(`Received unexpected exit code value ${JSON.stringify((_c = result.code) !== null && _c !== void 0 ? _c : result.exitCode)}`);
+}
+exports.getExitCode = getExitCode;
+/**
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import("execa").Options} opts
+ */
+function spawnProcess(command, args, opts, cmdDryRun = false) {
+    if (cmdDryRun) {
+        return logExecCommand(command, args);
+    }
+    const child = (0, execa_1.default)(command, args, opts);
+    const drain = (_code, signal) => {
+        children.delete(child);
+        // don't run repeatedly if this is the error event
+        if (signal === undefined) {
+            child.removeListener('exit', drain);
+        }
+    };
+    child.once('exit', drain);
+    child.once('error', drain);
+    if (opts.pkg) {
+        child.pkg = opts.pkg;
+    }
+    children.add(child);
+    return child;
+}
+exports.spawnProcess = spawnProcess;
+/**
+ * Spawn a command asynchronously, _always_ inheriting stdio.
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import("execa").Options} [opts]
+ */
+function wrapError(spawned) {
+    if (spawned.pkg) {
+        return spawned.catch((err) => {
+            // ensure exit code is always a number
+            err.exitCode = getExitCode(err);
+            // log non-lerna error cleanly
+            err.pkg = spawned.pkg;
+            throw err;
+        });
+    }
+    return spawned;
+}
+exports.wrapError = wrapError;
+/**
+ * Log the child-process command and its arguments as dry-run (without executing the process)
+ * @param {string} command
+ * @param {string[]} args
+ */
+function logExecCommand(command, args) {
+    var _a;
+    const argStr = (_a = (Array.isArray(args) ? args.join(' ') : args)) !== null && _a !== void 0 ? _a : '';
+    const cmdList = [];
+    for (const c of [command, argStr]) {
+        cmdList.push((Array.isArray(c) ? c.join(' ') : c));
+    }
+    npmlog_1.default.info('dry-run>', cmdList.join(' '));
+    return '';
+}
+exports.logExecCommand = logExecCommand;
 //# sourceMappingURL=child-process.js.map

package/dist/command.d.ts

@@ -1,35 +1,37 @@
-import { Logger } from 'npmlog';
-import { Project } from './project/project';
-import { CommandType, ExecOpts } from './models';
-import { PackageGraph } from './package-graph/package-graph';
-export declare class Command {
-    argv: any;
-    concurrency: number;
-    envDefaults: any;
-    sort: any;
-    toposort?: number;
-    execOpts: ExecOpts;
-    commandName: CommandType;
-    composed: any;
-    logger: Logger;
-    options: any;
-    project: Project;
-    packageGraph: PackageGraph;
-    runner?: Promise<any>;
-    constructor(_argv: any);
-    then(onResolved: typeof Promise.resolve, onRejected: typeof Promise.reject): Promise<unknown> | undefined;
-    catch(onRejected: typeof Promise.reject): Promise<any> | undefined;
-    get requiresGit(): boolean;
-    get otherCommandConfigs(): string[];
-    configureEnvironment(): void;
-    configureOptions(): void;
-    configureProperties(): void;
-    configureLogging(): void;
-    enableProgressBar(): void;
-    gitInitialized(): boolean;
-    runValidations(): void;
-    runPreparations(): Promise<any>;
-    runCommand(): Promise<any>;
-    initialize(): any | Promise<any>;
-    execute(): any | Promise<any>;
-}
+import { Logger } from 'npmlog';
+import { Project } from './project/project';
+import { CommandType, ExecCommandOption, ExecOpts, InitCommandOption, ListCommandOption, ProjectConfig, PublishCommandOption, VersionCommandOption } from './models';
+import { PackageGraph } from './package-graph/package-graph';
+declare type AvailableCommandOption = ExecCommandOption | InitCommandOption | ListCommandOption | PublishCommandOption | VersionCommandOption;
+export declare class Command<T extends AvailableCommandOption> {
+    argv: any;
+    concurrency: number;
+    envDefaults: any;
+    sort: any;
+    toposort?: number;
+    execOpts: ExecOpts;
+    commandName: CommandType;
+    composed: any;
+    logger: Logger;
+    options: T & ExecOpts & ProjectConfig;
+    project: Project;
+    packageGraph: PackageGraph;
+    runner?: Promise<any>;
+    constructor(_argv: AvailableCommandOption);
+    then(onResolved: typeof Promise.resolve, onRejected: typeof Promise.reject): Promise<unknown> | undefined;
+    catch(onRejected: typeof Promise.reject): Promise<any> | undefined;
+    get requiresGit(): boolean;
+    get otherCommandConfigs(): string[];
+    configureEnvironment(): void;
+    configureOptions(): void;
+    configureProperties(): void;
+    configureLogging(): void;
+    enableProgressBar(): void;
+    gitInitialized(): boolean;
+    runValidations(): void;
+    runPreparations(): Promise<any> | void;
+    runCommand(): Promise<any>;
+    initialize(): any | Promise<any>;
+    execute(): any | Promise<any>;
+}
+export {};