@oclif/core 5.0.1 → 5.1.1

package/lib/parser/parse.js

@@ -33,7 +33,7 @@ const readStdin = async () => {
     // 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 undefined;
     if (globalThis.oclif?.stdinCache) {
         debug('resolved stdin from global cache', globalThis.oclif.stdinCache);
         return globalThis.oclif.stdinCache;
@@ -42,7 +42,7 @@ const readStdin = async () => {
         const lines = [];
         const ac = new AbortController();
         const { signal } = ac;
-        const timeout = setTimeout(() => ac.abort(), 10);
+        const timeout = setTimeout(() => { ac.abort(); }, Number(process.env.OCLIF_STDIN_TIMEOUT_MS) || 10);
         const rl = (0, node_readline_1.createInterface)({
             input: stdin,
             output: stdout,
@@ -62,7 +62,7 @@ const readStdin = async () => {
             debug('stdin aborted');
             clearTimeout(timeout);
             rl.close();
-            resolve(null);
+            resolve(undefined);
         }, { once: true });
     });
 };
@@ -105,11 +105,11 @@ class Parser {
                 if (i !== -1) {
                     const sliced = arg.slice(i + 1);
                     this.argv.unshift(sliced);
-                    const equalsParsed = await parseFlag(arg.slice(0, i));
-                    if (!equalsParsed) {
+                    const isEqualsParsed = await parseFlag(arg.slice(0, i));
+                    if (!isEqualsParsed) {
                         this.argv.shift();
                     }
-                    return equalsParsed;
+                    return isEqualsParsed;
                 }
                 return false;
             }
@@ -147,23 +147,23 @@ class Parser {
             }
             return true;
         };
-        let parsingFlags = true;
+        let isParsingFlags = true;
         const nonExistentFlags = [];
-        let dashdash = false;
+        let isDashdash = false;
         const originalArgv = [...this.argv];
         while (this.argv.length > 0) {
             const input = this.argv.shift();
-            if (parsingFlags && input.startsWith('-') && input !== '-') {
+            if (isParsingFlags && input.startsWith('-') && input !== '-') {
                 // attempt to parse as arg
                 if (this.input['--'] !== false && input === '--') {
-                    parsingFlags = false;
+                    isParsingFlags = false;
                     continue;
                 }
                 if (await parseFlag(input)) {
                     continue;
                 }
                 if (input === '--') {
-                    dashdash = true;
+                    isDashdash = true;
                     continue;
                 }
                 if (this.input['--'] !== false && !isNegativeNumber(input)) {
@@ -175,7 +175,7 @@ class Parser {
                     continue;
                 }
             }
-            if (parsingFlags && this.currentFlag && this.currentFlag.multiple && !this.currentFlag.multipleNonGreedy) {
+            if (isParsingFlags && this.currentFlag && this.currentFlag.multiple && !this.currentFlag.multipleNonGreedy) {
                 this.raw.push({ flag: this.currentFlag.name, input, type: 'flag' });
                 continue;
             }
@@ -185,7 +185,7 @@ class Parser {
         }
         const [{ args, argv }, { flags, metadata }] = await Promise.all([this._args(), this._flags()]);
         this._debugOutput(argv, args, flags);
-        const unsortedArgv = (dashdash ? [...argv, ...nonExistentFlags, '--'] : [...argv, ...nonExistentFlags]);
+        const unsortedArgv = (isDashdash ? [...argv, ...nonExistentFlags, '--'] : [...argv, ...nonExistentFlags]);
         return {
             args: args,
             argv: unsortedArgv.sort((a, b) => originalArgv.indexOf(a) - originalArgv.indexOf(b)),
@@ -199,7 +199,7 @@ class Parser {
         const argv = [];
         const args = {};
         const tokens = this._argTokens;
-        let stdinRead = false;
+        let isStdinRead = false;
         const ctx = this.context;
         const parseArgInput = async (name, arg, input) => {
             if (arg.options && !arg.options.includes(input)) {
@@ -226,10 +226,10 @@ class Parser {
             args[name] = value;
         };
         const tryStdin = async (name, arg) => {
-            if (arg.ignoreStdin || stdinRead)
+            if (arg.ignoreStdin || isStdinRead)
                 return;
             let stdin = await (0, exports.readStdin)();
-            stdinRead = true;
+            isStdinRead = true;
             if (!stdin)
                 return;
             stdin = stdin.trim();
@@ -365,7 +365,7 @@ class Parser {
                 // multiple with custom delimiter
                 if (fws.inputFlag.flag.type === 'option' && fws.inputFlag.flag.delimiter && fws.inputFlag.flag.multiple) {
                     // regex that will identify unescaped delimiters
-                    const makeDelimiter = (delimiter) => new RegExp(`(?<!\\\\)${delimiter}`);
+                    const makeDelimiter = (delimiter) => new RegExp(String.raw `(?<!\\)${delimiter}`);
                     return {
                         ...fws,
                         valueFunction: async (i) => (await Promise.all((i.tokens ?? [])
@@ -388,7 +388,7 @@ class Parser {
                 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, this.context, token))),
+                        valueFunction: async (i) => Promise.all((fws.tokens ?? []).map(async (token) => parseFlagOrThrowError(validateOptions(i.inputFlag.flag, token.input), i.inputFlag.flag, this.context, token))),
                     };
                 }
                 // simple option flag
@@ -492,17 +492,17 @@ class Parser {
         };
     }
     _setNames() {
-        for (const k of Object.keys(this.input.flags)) {
-            this.input.flags[k].name = k;
+        for (const [k, value] of Object.entries(this.input.flags)) {
+            value.name = k;
         }
-        for (const k of Object.keys(this.input.args)) {
-            this.input.args[k].name = k;
+        for (const [k, value] of Object.entries(this.input.args)) {
+            value.name = k;
         }
     }
     findFlag(arg) {
         const isLong = arg.startsWith('--');
-        const short = isLong ? false : arg.startsWith('-');
-        const name = isLong ? this.findLongFlag(arg) : short ? this.findShortFlag(arg) : undefined;
+        const isShort = isLong ? false : arg.startsWith('-');
+        const name = isLong ? this.findLongFlag(arg) : isShort ? this.findShortFlag(arg) : undefined;
         return { isLong, name };
     }
     findLongFlag(arg) {

package/lib/parser/validate.d.ts

@@ -1,4 +1,4 @@
-import { ParserInput, ParserOutput } from '../interfaces/parser';
+import { type ParserInput, type ParserOutput } from '../interfaces/parser';
 export declare function validate(parse: {
     input: ParserInput;
     output: ParserOutput;

package/lib/parser/validate.js

@@ -40,7 +40,7 @@ async function validate(parse) {
                 }
             }
         }
-        const variadicArgFound = variadicIndex !== -1;
+        const isVariadicArgFound = variadicIndex !== -1;
         if (parse.output.nonExistentFlags?.length > 0) {
             throw new errors_1.NonExistentFlagsError({
                 flags: parse.output.nonExistentFlags,
@@ -62,7 +62,7 @@ async function validate(parse) {
             if (!arg.required) {
                 hasOptional = true;
             }
-            else if (hasOptional && !variadicArgFound) {
+            else if (hasOptional && !isVariadicArgFound) {
                 // (required arg) check whether an optional has occurred before
                 // optionals should follow required, not before
                 // Skip this check when a variadic arg is present, since the variadic
@@ -119,15 +119,16 @@ async function validate(parse) {
             });
     }
     function validateConstraints() {
-        if (parse.input.constraints) {
-            const validations = parse.input.constraints.map((c) => c._evaluateAgainstFlags(parse.output.flags));
-            const failed = validations.filter((v) => v.status === 'failed');
-            if (failed.length > 0) {
-                throw new errors_1.ViolatedFlagConstraintError({
-                    failed,
-                    parse,
-                });
-            }
+        if (!parse.input.constraints) {
+            return;
+        }
+        const validations = parse.input.constraints.map((c) => c._evaluateAgainstFlags(parse.output.flags));
+        const failed = validations.filter((v) => v.status === 'failed');
+        if (failed.length > 0) {
+            throw new errors_1.ViolatedFlagConstraintError({
+                failed,
+                parse,
+            });
         }
     }
     async function resolveFlags(flags) {
@@ -137,8 +138,8 @@ async function validate(parse) {
             if (typeof flag === 'string') {
                 return [flag, parse.output.flags[flag]];
             }
-            const result = await flag.when(parse.output.flags);
-            return result ? [flag.name, parse.output.flags[flag.name]] : null;
+            const isResult = await flag.when(parse.output.flags);
+            return isResult ? [flag.name, parse.output.flags[flag.name]] : null;
         });
         const resolved = await Promise.all(promises);
         cachedResolvedFlags = Object.fromEntries(resolved.filter((r) => r !== null));
@@ -150,7 +151,7 @@ async function validate(parse) {
         const intersection = Object.entries(parse.input.flags)
             .map((entry) => entry[0]) // array of flag names
             .filter((flagName) => parse.output.flags[flagName] !== undefined) // with values
-            .filter((flagName) => flag.exactlyOne && flag.exactlyOne.includes(flagName)); // and in the exactlyOne list
+            .filter((flagName) => flag.exactlyOne?.includes(flagName)); // and in the exactlyOne list
         if (intersection.length === 0) {
             // the command's exactlyOne may or may not include itself, so we'll use Set to add + de-dupe
             const deduped = (0, util_1.uniq)(flag.exactlyOne?.map((flag) => `--${flag}`) ?? []).join(', ');
@@ -164,7 +165,7 @@ async function validate(parse) {
         const intersection = Object.entries(parse.input.flags)
             .map((entry) => entry[0]) // array of flag names
             .filter((flagName) => parse.output.flags[flagName] !== undefined) // with values
-            .filter((flagName) => flag.atLeastOne && flag.atLeastOne.includes(flagName)); // and in the atLeastOne list
+            .filter((flagName) => flag.atLeastOne?.includes(flagName)); // and in the atLeastOne list
         if (intersection.length === 0) {
             // the command's atLeastOne may or may not include itself, so we'll use Set to add + de-dupe
             const deduped = (0, util_1.uniq)(flag.atLeastOne?.map((flag) => `--${flag}`) ?? []).join(', ');
@@ -179,9 +180,9 @@ async function validate(parse) {
         const keys = getPresentFlags(resolved);
         for (const flag of keys) {
             // do not enforce exclusivity for flags that were defaulted
-            if (parse.output.metadata.flags && parse.output.metadata.flags[flag]?.setFromDefault)
+            if (parse.output.metadata.flags?.[flag]?.setFromDefault)
                 continue;
-            if (parse.output.metadata.flags && parse.output.metadata.flags[name]?.setFromDefault)
+            if (parse.output.metadata.flags?.[name]?.setFromDefault)
                 continue;
             if (parse.output.flags[flag] !== undefined) {
                 const flagValue = parse.output.metadata.flags?.[flag]?.defaultHelp ?? parse.output.flags[flag];
@@ -200,9 +201,9 @@ async function validate(parse) {
         const resolved = await resolveFlags(flags);
         for (const flag of Object.keys(parse.output.flags)) {
             // do not enforce exclusivity for flags that were defaulted
-            if (parse.output.metadata.flags && parse.output.metadata.flags[flag]?.setFromDefault)
+            if (parse.output.metadata.flags?.[flag]?.setFromDefault)
                 continue;
-            if (parse.output.metadata.flags && parse.output.metadata.flags[name]?.setFromDefault)
+            if (parse.output.metadata.flags?.[name]?.setFromDefault)
                 continue;
             if (flag !== name && parse.output.flags[flag] !== undefined && !combinableFlags.has(flag)) {
                 const formattedFlags = Object.keys(resolved)
@@ -231,8 +232,8 @@ async function validate(parse) {
     async function validateDependsOn(name, flags) {
         const base = { name, validationFn: 'validateDependsOn' };
         const resolved = await resolveFlags(flags);
-        const foundAll = Object.values(resolved).every((val) => val !== undefined);
-        if (!foundAll) {
+        const isFoundAll = Object.values(resolved).every((val) => val !== undefined);
+        if (!isFoundAll) {
             const formattedFlags = Object.keys(resolved)
                 .map((f) => `--${f}`)
                 .join(', ');
@@ -247,8 +248,8 @@ async function validate(parse) {
     async function validateSome(name, flags) {
         const base = { name, validationFn: 'validateSome' };
         const resolved = await resolveFlags(flags);
-        const foundAtLeastOne = Object.values(resolved).some(Boolean);
-        if (!foundAtLeastOne) {
+        const isFoundAtLeastOne = Object.values(resolved).some(Boolean);
+        if (!isFoundAtLeastOne) {
             const formattedFlags = Object.keys(resolved)
                 .map((f) => `--${f}`)
                 .join(', ');
@@ -261,7 +262,7 @@ async function validate(parse) {
         return { ...base, status: 'success' };
     }
     function validateRelationships(name, flag) {
-        return (flag.relationships ?? []).map((relationship) => {
+        return (flag.relationships ?? []).map(async (relationship) => {
             switch (relationship.type) {
                 case 'all': {
                     return validateDependsOn(name, relationship.flags);

package/lib/performance.d.ts

@@ -34,8 +34,8 @@ declare class Marker {
     module: string;
     scope: string;
     stopped: boolean;
-    private startMarker;
-    private stopMarker;
+    private readonly startMarker;
+    private readonly stopMarker;
     constructor(owner: string, name: string, details?: Details);
     addDetails(details: Details): void;
     measure(): void;
@@ -43,8 +43,8 @@ declare class Marker {
 }
 export declare class Performance {
     private static _oclifPerf;
-    private static _results;
-    private static markers;
+    private static readonly _results;
+    private static readonly markers;
     /**
      * Collect performance results into static Performance.results
      *

package/lib/performance.js

@@ -21,8 +21,8 @@ class Marker {
         this.details = details;
         this.startMarker = `${this.name}-start`;
         this.stopMarker = `${this.name}-stop`;
-        const [caller, scope] = name.split('#');
-        const [module, method] = caller.split('.');
+        const [caller, scope] = name.split('#', 2);
+        const [module, method] = caller.split('.', 2);
         this.module = module;
         this.method = method;
         this.scope = scope;
@@ -221,7 +221,7 @@ class Performance {
     static get results() {
         if (!Performance.enabled)
             return new Map();
-        return new Map([...Performance._results.entries()].filter(([owner]) => owner !== exports.OCLIF_MARKER_OWNER));
+        return new Map([...Performance._results].filter(([owner]) => owner !== exports.OCLIF_MARKER_OWNER));
     }
 }
 exports.Performance = Performance;

package/lib/util/aggregate-flags.d.ts

@@ -1,2 +1,2 @@
-import { FlagInput, FlagOutput } from '../interfaces/parser';
+import { type FlagInput, type FlagOutput } from '../interfaces/parser';
 export declare function aggregateFlags<F extends FlagOutput, B extends FlagOutput>(flags: FlagInput<F> | undefined, baseFlags: FlagInput<B> | undefined, enableJsonFlag: boolean | undefined): FlagInput<F>;

package/lib/util/cache-command.d.ts

@@ -1,3 +1,3 @@
-import { Command } from '../command';
-import { Plugin as IPlugin } from '../interfaces/plugin';
+import { type Command } from '../command';
+import { type Plugin as IPlugin } from '../interfaces/plugin';
 export declare function cacheCommand(uncachedCmd: Command.Class, plugin?: IPlugin, respectNoCacheDefault?: boolean): Promise<Command.Cached>;

package/lib/util/cache-command.js

@@ -93,9 +93,9 @@ async function cacheCommand(uncachedCmd, plugin, respectNoCacheDefault = false)
         hidden: cmd.hidden,
         hiddenAliases: cmd.hiddenAliases ?? [],
         id: cmd.id,
-        pluginAlias: plugin && plugin.alias,
-        pluginName: plugin && plugin.name,
-        pluginType: plugin && plugin.type,
+        pluginAlias: plugin?.alias,
+        pluginName: plugin?.name,
+        pluginType: plugin?.type,
         state: cmd.state,
         strict: cmd.strict,
         summary: cmd.summary,

package/lib/util/cache-default-value.d.ts

@@ -1,2 +1,2 @@
-import { Arg, OptionFlag } from '../interfaces/parser';
+import { type Arg, type OptionFlag } from '../interfaces/parser';
 export declare const cacheDefaultValue: (flagOrArg: Arg<any> | OptionFlag<any>, respectNoCacheDefault: boolean) => Promise<any>;

package/lib/util/determine-priority.d.ts

@@ -1,4 +1,4 @@
-import { Command } from '../command';
+import { type Command } from '../command';
 /**
  * This function is responsible for locating the correct plugin to use for a named command id
  * It searches the {Config} registered commands to match either the raw command id or the command alias

package/lib/util/ensure-arg-object.d.ts

@@ -1,5 +1,5 @@
-import { Command } from '../command';
-import { ArgInput } from '../interfaces/parser';
+import { type Command } from '../command';
+import { type ArgInput } from '../interfaces/parser';
 /**
  * Ensure that the provided args are an object. This is for backwards compatibility with v1 commands which
  * defined args as an array.
@@ -7,6 +7,4 @@ import { ArgInput } from '../interfaces/parser';
  * @param args Either an array of args or an object of args
  * @returns ArgInput
  */
-export declare function ensureArgObject(args?: {
-    [name: string]: Command.Arg.Cached;
-} | ArgInput | any[]): ArgInput;
+export declare function ensureArgObject(args?: Record<string, Command.Arg.Cached> | ArgInput | any[]): ArgInput;

package/lib/util/ensure-arg-object.js

@@ -9,5 +9,5 @@ exports.ensureArgObject = ensureArgObject;
  * @returns ArgInput
  */
 function ensureArgObject(args) {
-    return (Array.isArray(args) ? (args ?? []).reduce((x, y) => ({ ...x, [y.name]: y }), {}) : args ?? {});
+    return (Array.isArray(args) ? (args ?? []).reduce((x, y) => ({ ...x, [y.name]: y }), {}) : (args ?? {}));
 }

package/lib/util/find-root.js

@@ -6,7 +6,9 @@ const node_path_1 = require("node:path");
 const logger_1 = require("../logger");
 const fs_1 = require("./fs");
 function debug(...scope) {
-    return (formatter, ...args) => (0, logger_1.getLogger)(['find-root', ...scope].join(':')).debug(formatter, ...args);
+    return (formatter, ...args) => {
+        (0, logger_1.getLogger)(['find-root', ...scope].join(':')).debug(formatter, ...args);
+    };
 }
 // essentially just "cd .."
 function* up(from) {

package/lib/util/read-pjson.d.ts

@@ -1,4 +1,4 @@
-import { PJSON } from '../interfaces';
+import { type PJSON } from '../interfaces';
 /**
  * Read the package.json file from a given path and add the oclif config (found by lilconfig) if it exists.
  *

package/lib/util/read-tsconfig.d.ts

@@ -1,2 +1,2 @@
-import { TSConfig } from '../interfaces';
+import { type TSConfig } from '../interfaces';
 export declare function readTSConfig(root: string, tsconfigName?: string): Promise<TSConfig | undefined>;

package/lib/util/util.d.ts

@@ -1,7 +1,5 @@
-export declare function pickBy<T extends {
-    [s: string]: T[keyof T];
-} | 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 pickBy<T extends Record<string, T[keyof T]> | ArrayLike<T[keyof T]>>(obj: T, fn: (i: T[keyof T]) => boolean): Partial<T>;
+export declare function compact<T>(a: Array<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 = boolean | number | string | undefined;
@@ -19,5 +17,5 @@ export declare function mapValues<T extends Record<string, any>, TResult>(obj: {
 }, fn: (i: T[keyof T], k: keyof T) => TResult): {
     [P in keyof T]: TResult;
 };
-export declare function mergeNestedObjects(objs: Record<string, any>[], path: string): Record<string, any>;
+export declare function mergeNestedObjects(objs: Array<Record<string, any>>, path: string): Record<string, any>;
 export {};

package/lib/util/util.js

@@ -28,7 +28,7 @@ function compact(a) {
 function uniqBy(arr, fn) {
     return arr.filter((a, i) => {
         const aVal = fn(a);
-        return !arr.some((b, j) => j > i && fn(b) === aVal);
+        return arr.every((b, j) => !(j > i && fn(b) === aVal));
     });
 }
 function last(arr) {

package/lib/ux/action/base.d.ts

@@ -1,4 +1,4 @@
-import { Options } from './types';
+import { type Options } from './types';
 type Task = {
     action: string;
     active: boolean;
@@ -7,7 +7,7 @@ type Task = {
 export type ActionType = 'debug' | 'simple' | 'spinner';
 export declare class ActionBase {
     std: 'stderr' | 'stdout';
-    protected stdmocks?: ['stderr' | 'stdout', string[]][];
+    protected stdmocks?: Array<['stderr' | 'stdout', string[]]>;
     type: ActionType;
     private stdmockOrigs;
     private get globals();

package/lib/ux/action/base.js

@@ -133,9 +133,9 @@ class ActionBase {
             }
         }
     }
-    pause(fn, icon) {
+    async pause(fn, icon) {
         const { task } = this;
-        const active = task && task.active;
+        const active = task?.active;
         if (task && active) {
             this._pause(icon);
             this._stdout(false);
@@ -149,7 +149,7 @@ class ActionBase {
     }
     async pauseAsync(fn, icon) {
         const { task } = this;
-        const active = task && task.active;
+        const active = task?.active;
         if (task && active) {
             this._pause(icon);
             this._stdout(false);
@@ -163,7 +163,7 @@ class ActionBase {
     }
     start(action, status, opts = {}) {
         this.std = opts.stdout ? 'stdout' : 'stderr';
-        const task = { action, active: Boolean(this.task && this.task.active), status };
+        const task = { action, active: Boolean(this.task?.active), status };
         this.task = task;
         this._start(opts);
         task.active = true;

package/lib/ux/action/simple.d.ts

@@ -1,4 +1,4 @@
-import { ActionBase, ActionType } from './base';
+import { ActionBase, type ActionType } from './base';
 export default class SimpleAction extends ActionBase {
     type: ActionType;
     protected _pause(icon?: string): void;

package/lib/ux/action/spinner.d.ts

@@ -1,5 +1,5 @@
-import { ActionBase, ActionType } from './base';
-import { Options } from './types';
+import { ActionBase, type ActionType } from './base';
+import { type Options } from './types';
 export default class SpinnerAction extends ActionBase {
     type: ActionType;
     private color;

package/lib/ux/action/spinner.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import-x/newline-after-import, import-x/first -- these rules cause circular fix problems */
 const ansiEscapes = require('ansi-escapes');
 const ansis_1 = __importDefault(require("ansis"));
 const cli_spinners_1 = __importDefault(require("cli-spinners"));
@@ -42,7 +43,9 @@ class SpinnerAction extends base_1.ActionBase {
         if (this.spinner)
             clearInterval(this.spinner);
         this._render();
-        this.spinner = setInterval((icon) => this._render.bind(this)(icon), process.platform === 'win32' ? 500 : 100, 'spinner');
+        this.spinner = setInterval((icon) => {
+            this._render.bind(this)(icon);
+        }, process.platform === 'win32' ? 500 : 100, 'spinner');
         const interval = this.spinner;
         interval.unref();
     }

package/lib/ux/action/types.d.ts

@@ -1,4 +1,4 @@
-import * as spinners from 'cli-spinners';
+import type * as spinners from 'cli-spinners';
 export type Options = {
     stdout?: boolean;
     style?: spinners.SpinnerName | 'random';

package/lib/ux/colorize-json.js

@@ -37,7 +37,7 @@ function serializer(replacer, cycleReplacer) {
             // eslint-disable-next-line no-bitwise, @typescript-eslint/no-unused-expressions
             ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
             // eslint-disable-next-line no-bitwise, @typescript-eslint/no-unused-expressions
-            ~thisPos ? keys.splice(thisPos, Number.POSITIVE_INFINITY, key) : keys.push(key);
+            ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
             // @ts-expect-error because `this` is not typed
             if (stack.includes(value))
                 value = cycleReplacer.call(this, key, value);
@@ -59,18 +59,18 @@ function stringifyInput(json, options) {
 function tokenize(json, options) {
     let input = stringifyInput(json, options);
     const tokens = [];
-    let foundToken = false;
+    let isFoundToken = false;
     do {
         for (const tokenType of tokenTypes) {
             const match = tokenType.regex.exec(input);
             if (match) {
                 tokens.push({ type: tokenType.tokenType, value: match[0] });
                 input = input.slice(match[0].length);
-                foundToken = true;
+                isFoundToken = true;
                 break;
             }
         }
-    } while (hasRemainingTokens(input, foundToken));
+    } while (hasRemainingTokens(input, isFoundToken));
     return tokens;
 }
 function hasRemainingTokens(input, foundToken) {

package/lib/ux/index.d.ts

@@ -56,13 +56,13 @@ export declare const ux: {
      *
      * See node's util.format() for formatting options.
      */
-    stderr: (str?: string | string[] | undefined, ...args: string[]) => void;
+    stderr: (str?: string | string[], ...args: string[]) => void;
     /**
      * Log a formatted string to stdout.
      *
      * See node's util.format() for formatting options.
      */
-    stdout: (str?: string | string[] | undefined, ...args: string[]) => void;
+    stdout: (str?: string | string[], ...args: string[]) => void;
     /**
      * Prints a pretty warning message to stderr.
      */

package/lib/ux/list.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = renderList;
+/* eslint-disable import-x/first -- these rules cause circular fix problems */
 const wordwrap = require('wordwrap');
 const screen_1 = require("../screen");
 const util_1 = require("../util/util");

package/lib/ux/theme.d.ts

@@ -1,4 +1,4 @@
-import { StandardAnsi, Theme } from '../interfaces/theme';
+import { type StandardAnsi, type Theme } from '../interfaces/theme';
 /**
  * Add color to text.
  * @param color color to use. Can be hex code (e.g. `#ff0000`), rgb (e.g. `rgb(255, 255, 255)`) or a standard ansi color (e.g. `red`)

package/lib/ux/write.d.ts

@@ -1,2 +1,2 @@
-export declare const stdout: (str?: string | string[] | undefined, ...args: string[]) => void;
-export declare const stderr: (str?: string | string[] | undefined, ...args: string[]) => void;
+export declare const stdout: (str?: string | string[], ...args: string[]) => void;
+export declare const stderr: (str?: string | string[], ...args: string[]) => void;

package/package.json

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