@oclif/core 5.1.0 → 5.1.1

package/lib/help/root.d.ts

@@ -1,4 +1,4 @@
-import * as Interfaces from '../interfaces';
+import type * as Interfaces from '../interfaces';
 import { HelpFormatter } from './formatter';
 export default class RootHelp extends HelpFormatter {
     config: Interfaces.Config;

package/lib/help/root.js

@@ -26,7 +26,7 @@ class RootHelp extends formatter_1.HelpFormatter {
     root() {
         let description = this.config.pjson.oclif.description || this.config.pjson.description || '';
         description = this.render(description);
-        description = description.split('\n')[0];
+        description = description.split('\n', 1)[0];
         let output = (0, util_1.compact)([
             (0, theme_1.colorize)(this.config?.theme?.commandSummary, description),
             this.version(),

package/lib/help/util.d.ts

@@ -1,4 +1,4 @@
-import { Deprecation, Config as IConfig } from '../interfaces';
+import { type Deprecation, type Config as IConfig } from '../interfaces';
 export declare function template(context: any): (t: string) => string;
 export declare function standardizeIDFromArgv(argv: string[], config: IConfig): string[];
 export declare function getHelpFlagAdditions(config: IConfig): string[];

package/lib/help/util.js

@@ -66,7 +66,7 @@ function standardizeIDFromArgv(argv, config) {
 function getHelpFlagAdditions(config) {
     const helpFlags = ['--help'];
     const additionalHelpFlags = config.pjson.oclif.additionalHelpFlags ?? [];
-    return [...new Set([...additionalHelpFlags, ...helpFlags]).values()];
+    return [...new Set([...additionalHelpFlags, ...helpFlags])];
 }
 function formatFlagDeprecationWarning(flag, opts) {
     let message = `The "${flag}" flag has been deprecated`;

package/lib/index.js

@@ -83,6 +83,7 @@ Object.defineProperty(exports, "CommandHelp", { enumerable: true, get: function
 Object.defineProperty(exports, "Help", { enumerable: true, get: function () { return help_1.Help; } });
 Object.defineProperty(exports, "HelpBase", { enumerable: true, get: function () { return help_1.HelpBase; } });
 Object.defineProperty(exports, "loadHelpClass", { enumerable: true, get: function () { return help_1.loadHelpClass; } });
+// eslint-disable-next-line @typescript-eslint/consistent-type-exports
 exports.Interfaces = __importStar(require("./interfaces"));
 var logger_1 = require("./logger");
 Object.defineProperty(exports, "getLogger", { enumerable: true, get: function () { return logger_1.getLogger; } });

package/lib/interfaces/args.d.ts

@@ -1,4 +1,4 @@
-import { ArgInput } from './parser';
+import { type ArgInput } from './parser';
 /**
  * Infer the args that are returned by Command.parse. This is useful for when you want to assign the args as a class property.
  *

package/lib/interfaces/config.d.ts

@@ -1,9 +1,9 @@
-import { Command } from '../command';
-import { Hook, Hooks } from './hooks';
-import { OclifConfiguration, PJSON, S3Templates } from './pjson';
-import { Options, Plugin } from './plugin';
-import { Theme } from './theme';
-import { Topic } from './topic';
+import { type Command } from '../command';
+import { type Hook, type Hooks } from './hooks';
+import { type OclifConfiguration, type PJSON, type S3Templates } from './pjson';
+import { type Options, type Plugin } from './plugin';
+import { type Theme } from './theme';
+import { type Topic } from './topic';
 export type LoadOptions = Config | Options | string | undefined;
 export type PlatformTypes = 'wsl' | NodeJS.Platform;
 export type ArchTypes = 'arm' | 'arm64' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 's390' | 's390x' | 'x32' | 'x64' | 'x86';
@@ -130,10 +130,10 @@ export interface Config {
 }
 export declare namespace Config {
     namespace s3Key {
-        interface Options {
+        type Options = {
             [key: string]: any;
             arch?: ArchTypes;
             platform?: PlatformTypes;
-        }
+        };
     }
 }

package/lib/interfaces/errors.d.ts

@@ -1,12 +1,12 @@
 export type CommandError = Error & {
     exitCode?: number;
 };
-export interface OclifError {
+export type OclifError = {
     oclif: {
         exit?: number | undefined;
     };
-}
-export interface PrettyPrintableError {
+};
+export type PrettyPrintableError = {
     /**
      * a unique error code for this error class
      */
@@ -24,4 +24,4 @@ export interface PrettyPrintableError {
      * a suggestion that may be useful or provide additional context
      */
     suggestions?: string[] | undefined;
-}
+};

package/lib/interfaces/flags.d.ts

@@ -1,4 +1,4 @@
-import { FlagInput } from './parser';
+import { type FlagInput } from './parser';
 /**
  * Infer the flags that are returned by Command.parse. This is useful for when you want to assign the flags as a class property.
  *

package/lib/interfaces/help.d.ts

@@ -1,4 +1,4 @@
-export interface HelpOptions {
+export type HelpOptions = {
     all?: boolean;
     /**
      * Use docopts as the usage. Defaults to true.
@@ -52,7 +52,7 @@ export interface HelpOptions {
     stripAnsi?: boolean;
     /**
      * Use USAGE, but some may want to use USAGE as used in gnu man pages. See help recommendations at
-     * http://www.gnu.org/software/help2man/#--help-recommendations
+     * https://www.gnu.org/software/help2man/#--help-recommendations
      */
     usageHeader?: string;
-}
+};

package/lib/interfaces/hooks.d.ts

@@ -1,11 +1,11 @@
-import { Command } from '../command';
-import { Config } from './config';
-import { Input, OutputFlags } from './parser';
-import { Plugin } from './plugin';
-interface HookMeta {
+import { type Command } from '../command';
+import { type Config } from './config';
+import { type Input, type OutputFlags } from './parser';
+import { type Plugin } from './plugin';
+type HookMeta = {
     options: Record<string, unknown>;
     return: any;
-}
+};
 type Context = {
     debug(...args: any[]): void;
     error(message: Error | string, options?: {
@@ -16,7 +16,7 @@ type Context = {
     log(message?: any, ...args: any[]): void;
     warn(message: string): void;
 };
-export interface Hooks {
+export type Hooks = {
     [event: string]: HookMeta;
     command_incomplete: {
         options: {
@@ -108,7 +108,7 @@ export interface Hooks {
         };
         return: void;
     };
-}
+};
 export type Hook<T extends keyof P, P extends Hooks = Hooks> = (this: Hook.Context, options: P[T]['options'] & {
     config: Config;
     context: Context;
@@ -160,7 +160,7 @@ export declare namespace Hook {
      * Runs when a command from an uninstalled JIT plugins is run.
      */
     type JitPluginNotInstalled = Hook<'jit_plugin_not_installed'>;
-    interface Context {
+    type Context = {
         config: Config;
         debug(...args: any[]): void;
         error(message: Error | string, options?: {
@@ -170,8 +170,8 @@ export declare namespace Hook {
         exit(code?: number): void;
         log(message?: any, ...args: any[]): void;
         warn(message: string): void;
-    }
-    interface Result<T> {
+    };
+    type Result<T> = {
         failures: Array<{
             error: Error;
             plugin: Plugin;
@@ -180,6 +180,6 @@ export declare namespace Hook {
             plugin: Plugin;
             result: T;
         }>;
-    }
+    };
 }
 export {};

package/lib/interfaces/manifest.d.ts

@@ -1,7 +1,5 @@
-import { Command } from '../command';
+import { type Command } from '../command';
 export type Manifest = {
-    commands: {
-        [id: string]: Command.Cached;
-    };
+    commands: Record<string, Command.Cached>;
     version: string;
 };

package/lib/interfaces/parser.d.ts

@@ -1,12 +1,8 @@
-import { Command } from '../command';
-import { Validation } from '../parser/errors';
-import { AlphabetLowercase, AlphabetUppercase } from './alphabet';
-export type FlagOutput = {
-    [name: string]: any;
-};
-export type ArgOutput = {
-    [name: string]: any;
-};
+import { type Command } from '../command';
+import { type Validation } from '../parser/errors';
+import { type AlphabetLowercase, type AlphabetUppercase } from './alphabet';
+export type FlagOutput = Record<string, any>;
+export type ArgOutput = Record<string, any>;
 export type CLIParseErrorOptions = {
     parse: {
         input?: ParserInput | undefined;
@@ -45,9 +41,7 @@ export type FlagUsageOptions = {
     displayRequired?: boolean;
 };
 export type Metadata = {
-    flags: {
-        [key: string]: MetadataFlag;
-    };
+    flags: Record<string, MetadataFlag>;
 };
 export type MetadataFlag = {
     setFromDefault?: boolean;
@@ -162,7 +156,7 @@ export type FlagProps = {
     /**
      * Alternate short chars that can be used for this flag.
      */
-    charAliases?: (AlphabetLowercase | AlphabetUppercase)[];
+    charAliases?: Array<AlphabetLowercase | AlphabetUppercase>;
     /**
      * Emit deprecation warning when a flag alias is provided
      */
@@ -298,7 +292,7 @@ type ReturnTypeSwitches = {
  *    - It's possible that T extends an Array, if so we want to return T so that the return isn't T[][]
  * - If requiredOrDefaulted is false && multiple is false, then the return type is T | undefined
  */
-type FlagReturnType<T, R extends ReturnTypeSwitches> = R['requiredOrDefaulted'] extends true ? R['multiple'] extends true ? [T] extends [Array<unknown>] ? T : T[] : T : R['multiple'] extends true ? [T] extends [Array<unknown>] ? T | undefined : T[] | undefined : T | undefined;
+type FlagReturnType<T, R extends ReturnTypeSwitches> = R['requiredOrDefaulted'] extends true ? R['multiple'] extends true ? [T] extends [unknown[]] ? T : T[] : T : R['multiple'] extends true ? [T] extends [unknown[]] ? T | undefined : T[] | undefined : T | undefined;
 /**
  * FlagDefinition types a function that takes `options` and returns an OptionFlag<T>.
  *
@@ -476,19 +470,13 @@ export type ParserInput = {
 export type ParserContext = Command & {
     token?: FlagToken | ArgToken | undefined;
 };
-export type FlagInput<T extends FlagOutput = {
-    [flag: string]: any;
-}> = {
+export type FlagInput<T extends FlagOutput = Record<string, any>> = {
     [P in keyof T]: Flag<T[P]>;
 };
-export type ArgInput<T extends ArgOutput = {
-    [arg: string]: any;
-}> = {
+export type ArgInput<T extends ArgOutput = Record<string, any>> = {
     [P in keyof T]: Arg<T[P]>;
 };
-export type SingleFlagTester = {
-    [key: string]: (val: any) => boolean;
-};
+export type SingleFlagTester = Record<string, (val: any) => boolean>;
 export type MultiFlagTester = (flags: FlagOutput) => boolean;
 type SimpleFlagGroup = string;
 type ComplexFlagGroup = {
@@ -496,7 +484,7 @@ type ComplexFlagGroup = {
     flags: string[];
 };
 export type FlagGroup = SimpleFlagGroup | ComplexFlagGroup;
-export interface Constraint {
+export type Constraint = {
     _evaluateAgainstFlags(flags: FlagOutput): Validation;
     allFlagCriteriaSatisfied(criterionTester: SingleFlagTester): Constraint;
     and: Constraint;
@@ -516,5 +504,5 @@ export interface Constraint {
     thisIsTrue(flagTester: MultiFlagTester): Constraint;
     unless: Constraint;
     when: Constraint;
-}
+};
 export {};

package/lib/interfaces/pjson.d.ts

@@ -1,5 +1,5 @@
-import { HelpOptions } from './help';
-import { Theme } from './theme';
+import { type HelpOptions } from './help';
+import { type Theme } from './theme';
 export type CommandDiscovery = {
     /**
      * The strategy to use for loading commands.
@@ -177,9 +177,7 @@ export type OclifConfiguration = {
     /**
      * Register hooks to run at various points in the CLI lifecycle.
      */
-    hooks?: {
-        [name: string]: string | string[] | HookOptions | HookOptions[] | (string | HookOptions)[];
-    };
+    hooks?: Record<string, string | string[] | HookOptions | HookOptions[] | Array<string | HookOptions>>;
     /**
      * Plugins that can be installed just-in-time.
      */
@@ -235,13 +233,11 @@ export type OclifConfiguration = {
     /**
      * Customize the topics in the CLI.
      */
-    topics?: {
-        [k: string]: {
-            description?: string;
-            hidden?: boolean;
-            subtopics?: OclifConfiguration['topics'];
-        };
-    };
+    topics?: Record<string, {
+        description?: string;
+        hidden?: boolean;
+        subtopics?: OclifConfiguration['topics'];
+    }>;
     /**
      * Tar flags configuration for different platforms.
      *
@@ -253,9 +249,7 @@ export type OclifConfiguration = {
      * }
      *
      */
-    tarFlags?: {
-        [platform: string]: string;
-    };
+    tarFlags?: Record<string, string>;
     update?: {
         autoupdate?: {
             debounce?: number;
@@ -296,18 +290,14 @@ export type LinkedPlugin = {
 };
 export type UserPJSON = {
     oclif: {
-        plugins?: (UserPlugin | LinkedPlugin)[];
+        plugins?: Array<UserPlugin | LinkedPlugin>;
     };
     private?: boolean;
 };
 export type PJSON = {
     [k: string]: any;
-    dependencies?: {
-        [name: string]: string;
-    };
-    devDependencies?: {
-        [name: string]: string;
-    };
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
     name: string;
     oclif: OclifConfiguration;
     version: string;

package/lib/interfaces/plugin.d.ts

@@ -1,8 +1,8 @@
-import { Command } from '../command';
-import { Logger } from './logger';
-import { HookOptions, PJSON } from './pjson';
-import { Topic } from './topic';
-export interface PluginOptions {
+import { type Command } from '../command';
+import { type Logger } from './logger';
+import { type HookOptions, type PJSON } from './pjson';
+import { type Topic } from './topic';
+export type PluginOptions = {
     children?: Plugin[] | undefined;
     errorOnManifestCreate?: boolean | undefined;
     flexibleTaxonomy?: boolean | undefined;
@@ -16,8 +16,8 @@ export interface PluginOptions {
     tag?: string | undefined;
     type?: string | undefined;
     url?: string | undefined;
-}
-export interface Options extends PluginOptions {
+};
+export type Options = {
     channel?: string | undefined;
     devPlugins?: boolean | undefined;
     enablePerf?: boolean | undefined;
@@ -32,8 +32,8 @@ export interface Options extends PluginOptions {
     plugins?: Map<string, Plugin> | undefined;
     userPlugins?: boolean | undefined;
     version?: string | undefined;
-}
-export interface Plugin {
+} & PluginOptions;
+export type Plugin = {
     /**
      * ../config version
      */
@@ -52,9 +52,7 @@ export interface Plugin {
         must: boolean;
     }): Promise<Command.Class> | undefined;
     readonly hasManifest: boolean;
-    hooks: {
-        [key: string]: HookOptions[];
-    };
+    hooks: Record<string, HookOptions[]>;
     /**
      * True if the plugin is the root plugin.
      */
@@ -101,4 +99,4 @@ export interface Plugin {
      * example: 1.2.3
      */
     version: string;
-}
+};

package/lib/interfaces/s3-manifest.d.ts

@@ -1,4 +1,4 @@
-export interface S3Manifest {
+export type S3Manifest = {
     baseDir: string;
     gz: string;
     node: {
@@ -11,4 +11,4 @@ export interface S3Manifest {
     sha256xz?: string;
     version: string;
     xz?: string;
-}
+};

package/lib/interfaces/topic.d.ts

@@ -1,5 +1,5 @@
-export interface Topic {
+export type Topic = {
     description?: string | undefined;
     hidden?: boolean | undefined;
     name: string;
-}
+};

package/lib/interfaces/ts-config.d.ts

@@ -1,4 +1,4 @@
-export interface TSConfig {
+export type TSConfig = {
     compilerOptions: {
         baseUrl?: string;
         emitDecoratorMetadata?: boolean;
@@ -20,4 +20,4 @@ export interface TSConfig {
         scope?: boolean;
         swc?: boolean;
     };
-}
+};

package/lib/logger.d.ts

@@ -1,5 +1,5 @@
-import { LoadOptions } from './interfaces/config';
-import { Logger } from './interfaces/logger';
+import { type LoadOptions } from './interfaces/config';
+import { type Logger } from './interfaces/logger';
 /**
  * Returns a logger instance for the given namespace.
  * If a namespace is provided, a child logger is returned.

package/lib/logger.js

@@ -14,7 +14,9 @@ function makeLogger(namespace = OCLIF_NS) {
     return {
         child: (ns, delimiter) => makeLogger(`${namespace}${delimiter ?? ':'}${ns}`),
         debug,
-        error: (formatter, ...args) => makeLogger(`${namespace}:error`).debug(formatter, ...args),
+        error(formatter, ...args) {
+            makeLogger(`${namespace}:error`).debug(formatter, ...args);
+        },
         info: debug,
         namespace,
         trace: debug,
@@ -74,7 +76,9 @@ function set(newLogger) {
  * Convenience function to create a debug function for a specific namespace
  */
 function makeDebug(namespace) {
-    return (formatter, ...args) => getLogger(namespace).debug(formatter, ...args);
+    return (formatter, ...args) => {
+        getLogger(namespace).debug(formatter, ...args);
+    };
 }
 function setLogger(loadOptions) {
     if (loadOptions && typeof loadOptions !== 'string' && 'logger' in loadOptions && loadOptions.logger) {

package/lib/main.d.ts

@@ -1,4 +1,4 @@
-import * as Interfaces from './interfaces';
+import type * as Interfaces from './interfaces';
 export declare const helpAddition: (argv: string[], config: Interfaces.Config) => boolean;
 export declare const versionAddition: (argv: string[], config?: Interfaces.Config) => boolean;
 export declare function run(argv?: string[], options?: Interfaces.LoadOptions): Promise<unknown>;

package/lib/main.js

@@ -28,10 +28,8 @@ const helpAddition = (argv, config) => {
 exports.helpAddition = helpAddition;
 const versionAddition = (argv, config) => {
     const additionalVersionFlags = config?.pjson.oclif.additionalVersionFlags ?? [];
-    const mergedVersionFlags = [...new Set(['--version', ...additionalVersionFlags]).values()];
-    if (mergedVersionFlags.includes(argv[0]))
-        return true;
-    return false;
+    const mergedVersionFlags = [...new Set(['--version', ...additionalVersionFlags])];
+    return Boolean(mergedVersionFlags.includes(argv[0]));
 };
 exports.versionAddition = versionAddition;
 async function run(argv, options) {
@@ -47,7 +45,7 @@ async function run(argv, options) {
     debug(`process.execPath: ${process.execPath}`);
     debug(`process.execArgv: ${process.execArgv}`);
     debug('process.argv: %O', process.argv);
-    argv = argv ?? process.argv.slice(2);
+    argv ??= process.argv.slice(2);
     // Handle the case when a file URL string or URL is passed in such as 'import.meta.url'; covert to file path.
     if (options && ((typeof options === 'string' && options.startsWith('file://')) || options instanceof node_url_1.URL)) {
         options = (0, node_url_1.fileURLToPath)(options);

package/lib/module-loader.d.ts

@@ -1,5 +1,5 @@
-import { Command } from './command';
-import { Config as IConfig, Plugin as IPlugin } from './interfaces';
+import { type Command } from './command';
+import { type Config as IConfig, type Plugin as IPlugin } from './interfaces';
 /**
  * Loads and returns a module.
  *

package/lib/module-loader.js

@@ -4,6 +4,7 @@ exports.load = load;
 exports.loadWithData = loadWithData;
 exports.loadWithDataFromManifest = loadWithDataFromManifest;
 exports.isPathModule = isPathModule;
+/* eslint-disable import-x/newline-after-import, import-x/first -- these rules cause circular fix problems */
 const getPackageType = require('get-package-type');
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -161,19 +162,19 @@ async function resolvePath(config, modulePath) {
         filePath =
             (isPlugin(config) ? await (0, ts_path_1.tsPath)(config.root, modulePath, config) : await (0, ts_path_1.tsPath)(config.root, modulePath)) ??
                 modulePath;
-        let fileExists = false;
+        let isFileExists = false;
         let isDirectory = false;
         if ((0, fs_1.existsSync)(filePath)) {
-            fileExists = true;
+            isFileExists = true;
             try {
                 if ((0, node_fs_1.lstatSync)(filePath)?.isDirectory?.()) {
-                    fileExists = false;
+                    isFileExists = false;
                     isDirectory = true;
                 }
             }
             catch { }
         }
-        if (!fileExists) {
+        if (!isFileExists) {
             // Try all supported extensions.
             let foundPath = findFile(filePath);
             if (!foundPath && isDirectory) {
@@ -202,5 +203,5 @@ function findFile(filePath) {
             return testPath;
         }
     }
-    return null;
+    return undefined;
 }

package/lib/parser/errors.d.ts

@@ -1,5 +1,5 @@
 import { CLIError } from '../errors';
-import { Arg, ArgInput, CLIParseErrorOptions, OptionFlag } from '../interfaces/parser';
+import { type Arg, type ArgInput, type CLIParseErrorOptions, type OptionFlag } from '../interfaces/parser';
 export { CLIError } from '../errors';
 export type Validation = {
     name: string;
@@ -22,9 +22,9 @@ export declare class InvalidArgsSpecError extends CLIParseError {
     });
 }
 export declare class RequiredArgsError extends CLIParseError {
-    args: Arg<any>[];
+    args: Array<Arg<any>>;
     constructor({ args, exit, flagsWithMultiple, parse, }: CLIParseErrorOptions & {
-        args: Arg<any>[];
+        args: Array<Arg<any>>;
         flagsWithMultiple?: string[];
     });
 }

package/lib/parser/help.d.ts

@@ -1,3 +1,3 @@
-import { Flag, FlagUsageOptions } from '../interfaces/parser';
+import { type Flag, type FlagUsageOptions } from '../interfaces/parser';
 export declare function flagUsage(flag: Flag<any>, options?: FlagUsageOptions): [string, string | undefined];
-export declare function flagUsages(flags: Flag<any>[], options?: FlagUsageOptions): [string, string | undefined][];
+export declare function flagUsages(flags: Array<Flag<any>>, options?: FlagUsageOptions): Array<[string, string | undefined]>;

package/lib/parser/parse.d.ts

@@ -1,4 +1,4 @@
-import { OutputArgs, OutputFlags, ParserInput, ParserOutput } from '../interfaces/parser';
+import { type OutputArgs, type OutputFlags, type ParserInput, type ParserOutput } from '../interfaces/parser';
 declare global {
     /**
      * Cache the stdin so that it can be read multiple times.
@@ -13,7 +13,7 @@ declare global {
         stdinCache?: string;
     };
 }
-export declare const readStdin: () => Promise<null | string>;
+export declare const readStdin: () => Promise<undefined | string>;
 export declare class Parser<T extends ParserInput, TFlags extends OutputFlags<T['flags']>, BFlags extends OutputFlags<T['flags']>, TArgs extends OutputArgs<T['args']>> {
     private readonly input;
     private readonly argv;