@oclif/core 2.9.5 → 2.10.1

package/lib/interfaces/parser.d.ts

@@ -284,7 +284,7 @@ export type BooleanFlag<T> = FlagProps & BooleanFlagProps & {
      * specifying a default of false is the same as not specifying a default
      */
     default?: FlagDefault<boolean>;
-    parse: (input: boolean, context: Command, opts: FlagProps & BooleanFlagProps) => Promise<T>;
+    parse: (input: boolean, context: FlagParserContext, opts: FlagProps & BooleanFlagProps) => Promise<T>;
 };
 export type OptionFlagDefaults<T, P = CustomOptions, M = false> = FlagProps & OptionFlagProps & {
     parse: FlagParser<T, string, P>;
@@ -327,7 +327,7 @@ export type Input<TFlags extends FlagOutput, BFlags extends FlagOutput, AFlags e
     baseFlags?: FlagInput<BFlags>;
     args?: ArgInput<AFlags>;
     strict?: boolean;
-    context?: Command;
+    context?: ParserContext;
     '--'?: boolean;
 };
 export type ParserInput = {
@@ -335,9 +335,12 @@ export type ParserInput = {
     flags: FlagInput<any>;
     args: ArgInput<any>;
     strict: boolean;
-    context: Command | undefined;
+    context: ParserContext | undefined;
     '--'?: boolean;
 };
+export type ParserContext = Command & {
+    token?: FlagToken | ArgToken;
+};
 export type CompletionContext = {
     args?: {
         [name: string]: string;

package/lib/module-loader.js

@@ -100,10 +100,12 @@ class ModuleLoader {
         const extension = path.extname(filePath).toLowerCase();
         switch (extension) {
             case '.js':
-                return getPackageType.sync(filePath) === 'module';
+            case '.jsx':
             case '.ts':
+            case '.tsx':
                 return getPackageType.sync(filePath) === 'module';
             case '.mjs':
+            case '.mts':
                 return true;
             default:
                 return false;

package/lib/parser/parse.js

@@ -13,16 +13,41 @@ try {
 catch {
     debug = () => { };
 }
-const readStdin = async () => {
-    const { stdin, stdout } = process;
-    debug('stdin.isTTY', stdin.isTTY);
+/**
+ * Support reading from stdin in Node 14 and older.
+ *
+ * This generally works for Node 14 and older EXCEPT when it's being
+ * run from another process, in which case it will hang indefinitely. Because
+ * of that issue we updated this to use AbortController but since AbortController
+ * is only available in Node 16 and newer, we have to keep this legacy version.
+ *
+ * See these issues for more details on the hanging indefinitely bug:
+ * https://github.com/oclif/core/issues/330
+ * https://github.com/oclif/core/pull/363
+ *
+ * @returns Promise<string | null>
+ */
+const readStdinLegacy = async () => {
+    const { stdin } = process;
+    let result;
     if (stdin.isTTY)
         return null;
+    result = '';
+    stdin.setEncoding('utf8');
+    for await (const chunk of stdin) {
+        result += chunk;
+    }
+    return result;
+};
+const readStdinWithTimeout = async () => {
+    const { stdin, stdout } = process;
     // process.stdin.isTTY is true whenever it's running in a terminal.
     // process.stdin.isTTY is undefined when it's running in a pipe, e.g. echo 'foo' | my-cli command
     // process.stdin.isTTY is undefined when it's running in a spawned process, even if there's no pipe.
     // This means that reading from stdin could hang indefinitely while waiting for a non-existent pipe.
     // Because of this, we have to set a timeout to prevent the process from hanging.
+    if (stdin.isTTY)
+        return null;
     return new Promise(resolve => {
         let result = '';
         const ac = new AbortController();
@@ -49,6 +74,13 @@ const readStdin = async () => {
         }, { once: true });
     });
 };
+const readStdin = async () => {
+    const { stdin, version } = process;
+    debug('stdin.isTTY', stdin.isTTY);
+    const nodeMajorVersion = Number(version.split('.')[0].replace(/^v/, ''));
+    debug('node version', nodeMajorVersion);
+    return nodeMajorVersion >= 14 ? readStdinLegacy() : readStdinWithTimeout();
+};
 function isNegativeNumber(input) {
     return /^-\d/g.test(input);
 }
@@ -56,7 +88,7 @@ class Parser {
     constructor(input) {
         this.input = input;
         this.raw = [];
-        this.context = input.context || {};
+        this.context = input.context ?? {};
         this.argv = [...input.argv];
         this._setNames();
         this.booleanFlags = (0, util_1.pickBy)(input.flags, f => f.type === 'boolean');
@@ -180,14 +212,23 @@ class Parser {
                 throw new errors_1.FlagInvalidOptionError(flag, input);
             return input;
         };
-        const parseFlagOrThrowError = async (input, flag, token, context = {}) => {
+        const parseFlagOrThrowError = async (input, flag, context, token) => {
             if (!flag.parse)
                 return input;
+            const ctx = {
+                ...context,
+                token,
+                error: context?.error,
+                exit: context?.exit,
+                log: context?.log,
+                logToStderr: context?.logToStderr,
+                warn: context?.warn,
+            };
             try {
                 if (flag.type === 'boolean') {
-                    return await flag.parse(input, { ...context, token }, flag);
+                    return await flag.parse(input, ctx, flag);
                 }
-                return await flag.parse(input, { ...context, token }, flag);
+                return await flag.parse(input, ctx, flag);
             }
             catch (error) {
                 error.message = `Parsing --${flag.name} \n\t${error.message}\nSee more help with --help`;
@@ -202,8 +243,11 @@ class Parser {
             // user provided some input
             if (tokenLength) {
                 // boolean
-                if (fws.inputFlag.flag.type === 'boolean' && fws.tokens?.at(-1)?.input) {
-                    return { ...fws, valueFunction: async (i) => parseFlagOrThrowError(i.tokens?.at(-1)?.input !== `--no-${i.inputFlag.name}`, i.inputFlag.flag, i.tokens?.at(-1), this.context) };
+                if (fws.inputFlag.flag.type === 'boolean' && (0, util_1.last)(fws.tokens)?.input) {
+                    return {
+                        ...fws,
+                        valueFunction: async (i) => parseFlagOrThrowError((0, util_1.last)(i.tokens)?.input !== `--no-${i.inputFlag.name}`, i.inputFlag.flag, this.context, (0, util_1.last)(i.tokens)),
+                    };
                 }
                 // multiple with custom delimiter
                 if (fws.inputFlag.flag.type === 'option' && fws.inputFlag.flag.delimiter && fws.inputFlag.flag.multiple) {
@@ -211,26 +255,38 @@ class Parser {
                         ...fws, valueFunction: async (i) => (await Promise.all(((i.tokens ?? []).flatMap(token => token.input.split(i.inputFlag.flag.delimiter)))
                             // trim, and remove surrounding doubleQuotes (which would hav been needed if the elements contain spaces)
                             .map(v => v.trim().replace(/^"(.*)"$/, '$1').replace(/^'(.*)'$/, '$1'))
-                            .map(async (v) => parseFlagOrThrowError(v, i.inputFlag.flag, { ...i.tokens?.at(-1), input: v }, this.context)))).map(v => validateOptions(i.inputFlag.flag, v)),
+                            .map(async (v) => parseFlagOrThrowError(v, i.inputFlag.flag, this.context, { ...(0, util_1.last)(i.tokens), input: v })))).map(v => validateOptions(i.inputFlag.flag, v)),
                     };
                 }
                 // multiple in the oclif-core style
                 if (fws.inputFlag.flag.type === 'option' && fws.inputFlag.flag.multiple) {
-                    return { ...fws, valueFunction: async (i) => Promise.all((fws.tokens ?? []).map(token => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, token.input), i.inputFlag.flag, token, this.context))) };
+                    return {
+                        ...fws,
+                        valueFunction: async (i) => Promise.all((fws.tokens ?? []).map(token => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, token.input), i.inputFlag.flag, this.context, token))),
+                    };
                 }
                 // simple option flag
                 if (fws.inputFlag.flag.type === 'option') {
-                    return { ...fws, valueFunction: async (i) => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, fws.tokens?.at(-1)?.input), i.inputFlag.flag, fws.tokens?.at(-1), this.context) };
+                    return {
+                        ...fws,
+                        valueFunction: async (i) => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, (0, util_1.last)(fws.tokens)?.input), i.inputFlag.flag, this.context, (0, util_1.last)(fws.tokens)),
+                    };
                 }
             }
             // no input: env flags
             if (fws.inputFlag.flag.env && process.env[fws.inputFlag.flag.env]) {
                 const valueFromEnv = process.env[fws.inputFlag.flag.env];
                 if (fws.inputFlag.flag.type === 'option' && valueFromEnv) {
-                    return { ...fws, valueFunction: async (i) => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, valueFromEnv), i.inputFlag.flag, this.context) };
+                    return {
+                        ...fws,
+                        valueFunction: async (i) => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, valueFromEnv), i.inputFlag.flag, this.context),
+                    };
                 }
                 if (fws.inputFlag.flag.type === 'boolean') {
-                    return { ...fws, valueFunction: async (i) => Promise.resolve((0, util_1.isTruthy)(process.env[i.inputFlag.flag.env] ?? 'false')) };
+                    return {
+                        ...fws,
+                        valueFunction: async (i) => Promise.resolve((0, util_1.isTruthy)(process.env[i.inputFlag.flag.env] ?? 'false')),
+                    };
                 }
             }
             // no input, but flag has default value

package/lib/util.d.ts

@@ -5,6 +5,7 @@ export declare function pickBy<T extends {
 } | ArrayLike<T[keyof T]>>(obj: T, fn: (i: T[keyof T]) => boolean): Partial<T>;
 export declare function compact<T>(a: (T | undefined)[]): T[];
 export declare function uniqBy<T>(arr: T[], fn: (cur: T) => any): T[];
+export declare function last<T>(arr?: T[]): T | undefined;
 type SortTypes = string | number | undefined | boolean;
 export declare function sortBy<T>(arr: T[], fn: (i: T) => SortTypes | SortTypes[]): T[];
 export declare function castArray<T>(input?: T | T[]): T[];

package/lib/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureArgObject = exports.requireJson = exports.isNotFalsy = exports.isTruthy = exports.fileExists = exports.dirExists = exports.capitalize = exports.sumBy = exports.maxBy = exports.isProd = exports.castArray = exports.sortBy = exports.uniqBy = exports.compact = exports.pickBy = void 0;
+exports.ensureArgObject = exports.requireJson = exports.isNotFalsy = exports.isTruthy = exports.fileExists = exports.dirExists = exports.capitalize = exports.sumBy = exports.maxBy = exports.isProd = exports.castArray = exports.sortBy = exports.last = exports.uniqBy = exports.compact = exports.pickBy = void 0;
 const fs = require("fs");
 const path_1 = require("path");
 function pickBy(obj, fn) {
@@ -23,6 +23,12 @@ function uniqBy(arr, fn) {
     });
 }
 exports.uniqBy = uniqBy;
+function last(arr) {
+    if (!arr)
+        return;
+    return arr.slice(-1)[0];
+}
+exports.last = last;
 function sortBy(arr, fn) {
     function compare(a, b) {
         a = a === undefined ? 0 : a;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/core",
   "description": "base library for oclif CLIs",
-  "version": "2.9.5",
+  "version": "2.10.1",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/core/issues",
   "dependencies": {