@oclif/core 3.0.0-beta.1 → 3.0.0-beta.3

package/lib/execute.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const settings_1 = require("./settings");
+const flush_1 = require("./ux/flush");
+const handle_1 = require("./errors/handle");
+const main_1 = require("./main");
+/**
+ * Load and run oclif CLI
+ *
+ * @param options - options to load the CLI
+ * @returns Promise<void>
+ *
+ * @example For ESM dev.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({development: true, dir: import.meta.url})
+ * })()
+ * ```
+ *
+ * @example For ESM run.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({dir: import.meta.url})
+ * })()
+ * ```
+ *
+ * @example For CJS dev.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({development: true, dir: __dirname})
+ * })()
+ * ```
+ *
+ * @example For CJS run.js
+ * ```
+ * #!/usr/bin/env node
+ * void (async () => {
+ *   const oclif = await import('@oclif/core')
+ *   await oclif.execute({dir: __dirname})
+ * })()
+ * ```
+ */
+async function execute(options) {
+    if (options.development) {
+        // In dev mode -> use ts-node and dev plugins
+        process.env.NODE_ENV = 'development';
+        settings_1.default.debug = true;
+    }
+    return (0, main_1.default)(options.args ?? process.argv.slice(2), options.loadOptions ?? options.dir)
+        .then(async (result) => {
+        (0, flush_1.default)();
+        return result;
+    })
+        .catch(async (error) => (0, handle_1.default)(error));
+}
+exports.default = execute;

package/lib/flags.js

@@ -4,6 +4,7 @@ exports.help = exports.version = exports.string = exports.url = exports.file = e
 const url_1 = require("url");
 const help_1 = require("./help");
 const util_1 = require("./util");
+const errors_1 = require("./errors");
 function custom(defaults) {
     return (options = {}) => {
         return {
@@ -29,12 +30,12 @@ exports.boolean = boolean;
 exports.integer = custom({
     parse: async (input, _, opts) => {
         if (!/^-?\d+$/.test(input))
-            throw new Error(`Expected an integer but received: ${input}`);
+            throw new errors_1.CLIError(`Expected an integer but received: ${input}`);
         const num = Number.parseInt(input, 10);
         if (opts.min !== undefined && num < opts.min)
-            throw new Error(`Expected an integer greater than or equal to ${opts.min} but received: ${input}`);
+            throw new errors_1.CLIError(`Expected an integer greater than or equal to ${opts.min} but received: ${input}`);
         if (opts.max !== undefined && num > opts.max)
-            throw new Error(`Expected an integer less than or equal to ${opts.max} but received: ${input}`);
+            throw new errors_1.CLIError(`Expected an integer less than or equal to ${opts.max} but received: ${input}`);
         return num;
     },
 });
@@ -84,7 +85,8 @@ const help = (opts = {}) => {
         description: 'Show CLI help.',
         ...opts,
         parse: async (_, cmd) => {
-            new help_1.Help(cmd.config).showHelp(cmd.id ? [cmd.id, ...cmd.argv] : cmd.argv);
+            const Help = await (0, help_1.loadHelpClass)(cmd.config);
+            await new Help(cmd.config, cmd.config.pjson.helpOptions).showHelp(cmd.id ? [cmd.id, ...cmd.argv] : cmd.argv);
             cmd.exit(0);
         },
     });

package/lib/help/index.js

@@ -10,7 +10,7 @@ const util_1 = require("../util");
 const util_2 = require("./util");
 const formatter_1 = require("./formatter");
 const config_1 = require("../config/config");
-const stream_1 = require("../cli-ux/stream");
+const stream_1 = require("../ux/stream");
 var command_2 = require("./command");
 Object.defineProperty(exports, "CommandHelp", { enumerable: true, get: function () { return command_2.CommandHelp; } });
 var util_3 = require("./util");
@@ -91,7 +91,7 @@ class Help extends HelpBase {
         const command = this.config.findCommand(subject);
         if (command) {
             if (command.hasDynamicHelp && command.pluginType !== 'jit') {
-                const dynamicCommand = await (0, config_1.toCached)(await command.load(), undefined, false);
+                const dynamicCommand = await (0, config_1.toCached)(await command.load());
                 await this.showCommandHelp(dynamicCommand);
             }
             else {
@@ -123,7 +123,7 @@ class Help extends HelpBase {
         const depth = name.split(':').length;
         const subTopics = this.sortedTopics.filter(t => t.name.startsWith(name + ':') && t.name.split(':').length === depth + 1);
         const subCommands = this.sortedCommands.filter(c => c.id.startsWith(name + ':') && c.id.split(':').length === depth + 1);
-        const plugin = this.config.plugins.find(p => p.name === command.pluginName);
+        const plugin = this.config.plugins.get(command.pluginName);
         const state = this.config.pjson?.oclif?.state || plugin?.pjson?.oclif?.state || command.state;
         if (state) {
             this.log(state === 'deprecated' ?

package/lib/index.d.ts

@@ -1,5 +1,7 @@
 import { Command } from './command';
-import { run, execute } from './main';
+import run from './main';
+import execute from './execute';
+import handle from './errors/handle';
 import { Config, Plugin, tsPath, toCached } from './config';
 import * as Interfaces from './interfaces';
 import * as Errors from './errors';
@@ -9,10 +11,10 @@ import { CommandHelp, HelpBase, Help, loadHelpClass } from './help';
 import { toStandardizedId, toConfiguredId } from './help/util';
 import * as Parser from './parser';
 import { Hook } from './interfaces/hooks';
-import { settings, Settings } from './settings';
+import settings, { Settings } from './settings';
 import { HelpSection, HelpSectionRenderer, HelpSectionKeyValueTable } from './help/formatter';
-import * as ux from './cli-ux';
-import { stderr, stdout } from './cli-ux/stream';
-import { Performance } from './performance';
-declare const flush: typeof ux.ux.flush;
-export { Args, Command, CommandHelp, Config, Errors, Flags, loadHelpClass, Help, HelpBase, HelpSection, HelpSectionRenderer, HelpSectionKeyValueTable, Hook, Interfaces, Parser, Plugin, Performance, run, toCached, tsPath, toStandardizedId, toConfiguredId, settings, Settings, flush, ux, execute, stderr, stdout, };
+import ux from './ux';
+import { stderr, stdout } from './ux/stream';
+import Performance from './performance';
+import flush from './ux/flush';
+export { Args, Command, CommandHelp, Config, Errors, execute, Flags, flush, handle, Help, HelpBase, HelpSection, HelpSectionKeyValueTable, HelpSectionRenderer, Hook, Interfaces, loadHelpClass, Parser, Performance, Plugin, run, settings, Settings, stderr, stdout, toCached, toConfiguredId, toStandardizedId, tsPath, ux, };

package/lib/index.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stdout = exports.stderr = exports.execute = exports.ux = exports.flush = exports.settings = exports.toConfiguredId = exports.toStandardizedId = exports.tsPath = exports.toCached = exports.run = exports.Performance = exports.Plugin = exports.Parser = exports.Interfaces = exports.HelpBase = exports.Help = exports.loadHelpClass = exports.Flags = exports.Errors = exports.Config = exports.CommandHelp = exports.Command = exports.Args = void 0;
-const semver = require("semver");
+exports.ux = exports.tsPath = exports.toStandardizedId = exports.toConfiguredId = exports.toCached = exports.stdout = exports.stderr = exports.settings = exports.run = exports.Plugin = exports.Performance = exports.Parser = exports.loadHelpClass = exports.Interfaces = exports.HelpBase = exports.Help = exports.handle = exports.flush = exports.Flags = exports.execute = exports.Errors = exports.Config = exports.CommandHelp = exports.Command = exports.Args = void 0;
 const command_1 = require("./command");
 Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_1.Command; } });
 const main_1 = require("./main");
-Object.defineProperty(exports, "run", { enumerable: true, get: function () { return main_1.run; } });
-Object.defineProperty(exports, "execute", { enumerable: true, get: function () { return main_1.execute; } });
+exports.run = main_1.default;
+const execute_1 = require("./execute");
+exports.execute = execute_1.default;
+const handle_1 = require("./errors/handle");
+exports.handle = handle_1.default;
 const config_1 = require("./config");
 Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
 Object.defineProperty(exports, "Plugin", { enumerable: true, get: function () { return config_1.Plugin; } });
@@ -31,17 +33,16 @@ Object.defineProperty(exports, "toConfiguredId", { enumerable: true, get: functi
 const Parser = require("./parser");
 exports.Parser = Parser;
 const settings_1 = require("./settings");
-Object.defineProperty(exports, "settings", { enumerable: true, get: function () { return settings_1.settings; } });
-const ux = require("./cli-ux");
-exports.ux = ux;
-const util_2 = require("./util");
-const stream_1 = require("./cli-ux/stream");
+exports.settings = settings_1.default;
+const ux_1 = require("./ux");
+exports.ux = ux_1.default;
+const stream_1 = require("./ux/stream");
 Object.defineProperty(exports, "stderr", { enumerable: true, get: function () { return stream_1.stderr; } });
 Object.defineProperty(exports, "stdout", { enumerable: true, get: function () { return stream_1.stdout; } });
 const performance_1 = require("./performance");
-Object.defineProperty(exports, "Performance", { enumerable: true, get: function () { return performance_1.Performance; } });
-const flush = ux.flush;
-exports.flush = flush;
+exports.Performance = performance_1.default;
+const flush_1 = require("./ux/flush");
+exports.flush = flush_1.default;
 function checkCWD() {
     try {
         process.cwd();
@@ -52,11 +53,4 @@ function checkCWD() {
         }
     }
 }
-function checkNodeVersion() {
-    const pjson = (0, util_2.requireJson)(__dirname, '..', 'package.json');
-    if (!semver.satisfies(process.versions.node, pjson.engines.node)) {
-        stream_1.stderr.write(`WARNING\nWARNING Node version must be ${pjson.engines.node} to use this CLI\nWARNING Current node version: ${process.versions.node}\nWARNING\n`);
-    }
-}
 checkCWD();
-checkNodeVersion();

package/lib/interfaces/config.d.ts

@@ -21,91 +21,90 @@ export type VersionDetails = {
     rootPath?: string;
 };
 export interface Config {
-    name: string;
-    version: string;
-    channel: string;
-    pjson: PJSON.CLI;
-    root: string;
+    readonly name: string;
+    readonly version: string;
+    readonly channel: string;
+    readonly pjson: PJSON.CLI;
+    readonly root: string;
     /**
      * process.arch
      */
-    arch: ArchTypes;
+    readonly arch: ArchTypes;
     /**
      * bin name of CLI command
      */
-    bin: string;
+    readonly bin: string;
     /**
      * cache directory to use for CLI
      *
      * example ~/Library/Caches/mycli or ~/.cache/mycli
      */
-    cacheDir: string;
+    readonly cacheDir: string;
     /**
      * config directory to use for CLI
      *
      * example: ~/.config/mycli
      */
-    configDir: string;
+    readonly configDir: string;
     /**
      * data directory to use for CLI
      *
      * example: ~/.local/share/mycli
      */
-    dataDir: string;
+    readonly dataDir: string;
     /**
      * base dirname to use in cacheDir/configDir/dataDir
      */
-    dirname: string;
+    readonly dirname: string;
     /**
      * points to a file that should be appended to for error logs
      *
      * example: ~/Library/Caches/mycli/error.log
      */
-    errlog: string;
+    readonly errlog: string;
     /**
      * path to home directory
      *
      * example: /home/myuser
      */
-    home: string;
+    readonly home: string;
     /**
      * process.platform
      */
-    platform: PlatformTypes;
+    readonly platform: PlatformTypes;
     /**
      * active shell
      */
-    shell: string;
+    readonly shell: string;
     /**
      * user agent to use for http calls
      *
      * example: mycli/1.2.3 (darwin-x64) node-9.0.0
      */
-    userAgent: string;
+    readonly userAgent: string;
     /**
      * if windows
      */
-    windows: boolean;
+    readonly windows: boolean;
     /**
      * debugging level
      *
      * set by ${BIN}_DEBUG or DEBUG=$BIN
      */
-    debug: number;
+    readonly debug: number;
     /**
      * npm registry to use for installing plugins
      */
-    npmRegistry?: string;
-    userPJSON?: PJSON.User;
-    plugins: Plugin[];
-    binPath?: string;
+    readonly npmRegistry?: string;
+    readonly plugins: Map<string, Plugin>;
+    readonly binPath?: string;
     /**
      * name of any bin aliases that will execute the cli
      */
-    binAliases?: string[];
-    nsisCustomization?: string;
-    valid: boolean;
-    flexibleTaxonomy?: boolean;
+    readonly binAliases?: string[];
+    readonly nsisCustomization?: string;
+    readonly valid: boolean;
+    readonly flexibleTaxonomy?: boolean;
     topicSeparator: ':' | ' ';
     readonly commands: Command.Loadable[];
     readonly topics: Topic[];
@@ -135,6 +134,7 @@ export interface Config {
     s3Url(key: string): string;
     s3Key(type: 'versioned' | 'unversioned', ext: '.tar.gz' | '.tar.xz', options?: Config.s3Key.Options): string;
     s3Key(type: keyof PJSON.S3.Templates, options?: Config.s3Key.Options): string;
+    getPluginsList(): Plugin[];
 }
 export declare namespace Config {
     namespace s3Key {

package/lib/interfaces/parser.d.ts

@@ -62,88 +62,26 @@ export type DefaultContext<T> = {
 /**
  * Type to define a default value for a flag.
  * @param context The context of the flag.
- * @param isWritingManifest Informs the function that a manifest file is being written.
- * The manifest file is used to store the flag definitions, with a default value if present, for a command and is published to npm.
- * When a manifest file is being written, the default value may contain data that should not be included in the manifest.
- * The plugin developer can use isWritingManifest to determine if the default value should be omitted from the manifest.
- * in the function's implementation.
- * @example
- * static flags = {
- *   foo: flags.string({
- *     defaultHelp: async (context, isWritingManifest) => {
- *       if (isWritingManifest) {
- *         return undefined
- *       }
- *       return 'value that is used outside a manifest'
- *     },
- *    }),
- *  }
  */
-export type FlagDefault<T, P = CustomOptions> = T | ((context: DefaultContext<P & OptionFlag<T, P>>, isWritingManifest?: boolean) => Promise<T>);
+export type FlagDefault<T, P = CustomOptions> = T | ((context: DefaultContext<P & OptionFlag<T, P>>) => Promise<T>);
 /**
  * Type to define a defaultHelp value for a flag.
  * The defaultHelp value is used in the help output for the flag and when writing a manifest.
  * It is also can be used to provide a value for the flag when issuing certain error messages.
  *
  * @param context The context of the flag.
- * @param isWritingManifest Informs the function that a manifest file is being written.
- * The manifest file is used to store the flag definitions, with a default value if present via defaultHelp, for a command and is published to npm.
- * When a manifest file is being written, the default value may contain data that should not be included in the manifest.
- * The plugin developer can use isWritingManifest to determine if the defaultHelp value should be omitted from the manifest.
- * in the function's implementation.
- * @example
- * static flags = {
- *   foo: flags.string({
- *     defaultHelp: async (context, isWritingManifest) => {
- *       if (isWritingManifest) {
- *         return undefined
- *       }
- *       return 'value that is used outside a manifest'
- *     },
- *    }),
- *  }
  */
-export type FlagDefaultHelp<T, P = CustomOptions> = T | ((context: DefaultContext<P & OptionFlag<T, P>>, isWritingManifest?: boolean) => Promise<string | undefined>);
+export type FlagDefaultHelp<T, P = CustomOptions> = T | ((context: DefaultContext<P & OptionFlag<T, P>>) => Promise<string | undefined>);
 /**
  * Type to define a default value for an arg.
  * @param context The context of the arg.
- * @param isWritingManifest Informs the function that a manifest file is being written.
- * The manifest file is used to store the arg definitions, with a default value if present, for a command and is published to npm.
- * When a manifest file is being written, the default value may contain data that should not be included in the manifest.
- * The plugin developer can use isWritingManifest to determine if the default value should be omitted from the manifest.
- * in the function's implementation.
- * @example
- *   public static readonly args = {
- *     one: Args.string({
- *       default: async (context, isWritingManifest) => {
- *          if (isWritingManifest) {
- *             return undefined
- *          }
- *          return 'value that is used outside a manifest'
- *       }),
- *   };
  */
-export type ArgDefault<T, P = CustomOptions> = T | ((context: DefaultContext<Arg<T, P>>, isWritingManifest?: boolean) => Promise<T>);
+export type ArgDefault<T, P = CustomOptions> = T | ((context: DefaultContext<Arg<T, P>>) => Promise<T>);
 /**
  * Type to define a defaultHelp value for an arg.
  * @param context The context of the arg.
- * @param isWritingManifest Informs the function that a manifest file is being written.
- * The manifest file is used to store the arg definitions, with a default value if present via defaultHelp, for a command and is published to npm.
- * When a manifest file is being written, the default value may contain data that should not be included in the manifest.
- * The plugin developer can use isWritingManifest to determine if the default value should be omitted from the manifest.
- * in the function's implementation.
- * @example
- *   public static readonly args = {
- *     one: Args.string({
- *       defaultHelp: async (context, isWritingManifest) => {
- *          if (isWritingManifest) {
- *             return undefined
- *          }
- *          return 'value that is used outside a manifest'
- *       }),
- *   };
  */
-export type ArgDefaultHelp<T, P = CustomOptions> = T | ((context: DefaultContext<Arg<T, P>>, isWritingManifest?: boolean) => Promise<string | undefined>);
+export type ArgDefaultHelp<T, P = CustomOptions> = T | ((context: DefaultContext<Arg<T, P>>) => Promise<string | undefined>);
 export type FlagRelationship = string | {
     name: string;
     when: (flags: Record<string, unknown>) => Promise<boolean>;
@@ -226,6 +164,11 @@ export type FlagProps = {
      * separate on spaces.
      */
     delimiter?: ',';
+    /**
+     * If true, the value returned by defaultHelp will not be cached in the oclif.manifest.json.
+     * This is helpful if the default value contains sensitive data that shouldn't be published to npm.
+     */
+    noCacheDefault?: boolean;
 };
 export type ArgProps = {
     name: string;
@@ -245,6 +188,11 @@ export type ArgProps = {
     required?: boolean;
     options?: string[];
     ignoreStdin?: boolean;
+    /**
+     * If true, the value returned by defaultHelp will not be cached in the oclif.manifest.json.
+     * This is helpful if the default value contains sensitive data that shouldn't be published to npm.
+     */
+    noCacheDefault?: boolean;
 };
 export type BooleanFlagProps = FlagProps & {
     type: 'boolean';

package/lib/interfaces/pjson.d.ts

@@ -1,6 +1,7 @@
 import { HelpOptions } from './help';
 export interface PJSON {
     [k: string]: any;
+    version: string;
     dependencies?: {
         [name: string]: string;
     };
@@ -12,6 +13,7 @@ export interface PJSON {
         bin?: string;
         dirname?: string;
         hooks?: Record<string, string | string[]>;
+        plugins?: string[];
     };
 }
 export declare namespace PJSON {

package/lib/interfaces/plugin.d.ts

@@ -8,8 +8,10 @@ export interface PluginOptions {
     tag?: string;
     ignoreManifest?: boolean;
     errorOnManifestCreate?: boolean;
+    respectNoCacheDefault?: boolean;
     parent?: Plugin;
     children?: Plugin[];
+    flexibleTaxonomy?: boolean;
 }
 export interface Options extends PluginOptions {
     devPlugins?: boolean;
@@ -18,6 +20,7 @@ export interface Options extends PluginOptions {
     channel?: string;
     version?: string;
     enablePerf?: boolean;
+    plugins?: Map<string, Plugin>;
 }
 export interface Plugin {
     /**
@@ -49,6 +52,10 @@ export interface Plugin {
      * examples: core, link, user, dev
      */
     type: string;
+    /**
+     * Plugin is written in ESM or CommonJS
+     */
+    moduleType: 'module' | 'commonjs';
     /**
      * base path of plugin
      */
@@ -74,5 +81,5 @@ export interface Plugin {
     findCommand(id: string, opts?: {
         must: boolean;
     }): Promise<Command.Class> | undefined;
-    load(isWritingManifest: boolean): Promise<void>;
+    load(): Promise<void>;
 }

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

@@ -7,5 +7,14 @@ export interface TSConfig {
         esModuleInterop?: boolean;
         experimentalDecorators?: boolean;
         emitDecoratorMetadata?: boolean;
+        module?: string;
+        moduleResolution?: string;
+        sourceMap?: boolean;
+        jsx?: boolean;
+    };
+    'ts-node'?: {
+        esm?: boolean;
+        experimentalSpecifierResolution?: 'node' | 'explicit';
+        scope?: boolean;
     };
 }

package/lib/main.d.ts

@@ -2,57 +2,4 @@ import * as Interfaces from './interfaces';
 import { Config } from './config';
 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>;
-/**
- * Load and run oclif CLI
- *
- * @param options - options to load the CLI
- * @returns Promise<void>
- *
- * @example For ESM dev.js
- * ```
- * #!/usr/bin/env ts-node
- * // eslint-disable-next-line node/shebang
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'esm', development: true, dir: import.meta.url})
- * })()
- * ```
- *
- * @example For ESM run.js
- * ```
- * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'esm', dir: import.meta.url})
- * })()
- * ```
- *
- * @example For CJS dev.js
- * ```
- * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'cjs', development: true, dir: __dirname})
- * })()
- * ```
- *
- * @example For CJS run.js
- * ```
- * #!/usr/bin/env node
- * // eslint-disable-next-line node/shebang
- * (async () => {
- *   const oclif = await import('@oclif/core')
- *   await oclif.execute({type: 'cjs', dir: import.meta.url})
- * })()
- * ```
- */
-export declare function execute(options: {
-    type: 'cjs' | 'esm';
-    dir: string;
-    args?: string[];
-    loadOptions?: Interfaces.LoadOptions;
-    development?: boolean;
-}): Promise<void>;
+export default function run(argv?: string[], options?: Interfaces.LoadOptions): Promise<unknown>;