@salesforce/sf-plugins-core 5.0.12 → 5.0.14-dev.0

package/lib/sfCommand.js

@@ -1,25 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SfCommand = exports.StandardColors = void 0;
 /*
  * Copyright (c) 2022, salesforce.com, inc.
  * All rights reserved.
  * Licensed under the BSD 3-Clause license.
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
-const os = require("node:os");
-const core_1 = require("@oclif/core");
-const core_2 = require("@salesforce/core");
-const chalk = require("chalk");
-const ux_1 = require("./ux");
-core_2.Messages.importMessagesDirectory(__dirname);
-const messages = core_2.Messages.loadMessages('@salesforce/sf-plugins-core', 'messages');
-exports.StandardColors = {
-    error: chalk.bold.red,
-    warning: chalk.bold.yellow,
-    info: chalk.dim,
-    success: chalk.bold.green,
-};
+import os from 'node:os';
+import { Command } from '@oclif/core';
+import { envVars, Messages, SfProject, Lifecycle, EnvironmentVariable, SfError, ConfigAggregator, } from '@salesforce/core';
+import { Progress } from './ux/progress.js';
+import { Ux } from './ux/ux.js';
+import { formatActions, formatError } from './errorFormatting.js';
+import { StandardColors } from './ux/standardColors.js';
+import { confirm, secretPrompt } from './prompts.js';
+import { removeEmpty } from './util.js';
+Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
+const messages = Messages.loadMessages('@salesforce/sf-plugins-core', 'messages');
 /**
  * A base command that provided common functionality for all sf commands.
  * Functionality includes:
@@ -51,15 +46,87 @@ exports.StandardColors = {
  * }
  * ```
  */
-class SfCommand extends core_1.Command {
+export class SfCommand extends Command {
+    static enableJsonFlag = true;
+    /**
+     * Add a CONFIGURATION VARIABLES section to the help output.
+     *
+     * @example
+     * ```
+     * import { SfCommand, toHelpSection } from '@salesforce/sf-plugins-core';
+     * import { OrgConfigProperties } from '@salesforce/core';
+     * export default class MyCommand extends SfCommand {
+     *   public static configurationVariablesSection = toHelpSection(
+     *     'CONFIGURATION VARIABLES',
+     *     OrgConfigProperties.TARGET_ORG,
+     *     OrgConfigProperties.ORG_API_VERSION,
+     *   );
+     * }
+     * ```
+     */
+    static configurationVariablesSection;
+    /**
+     * Add an Environment VARIABLES section to the help output.
+     *
+     * @example
+     * ```
+     * import { SfCommand, toHelpSection } from '@salesforce/sf-plugins-core';
+     * import { EnvironmentVariable } from '@salesforce/core';
+     * export default class MyCommand extends SfCommand {
+     *   public static envVariablesSection = toHelpSection(
+     *     'ENVIRONMENT VARIABLES',
+     *     EnvironmentVariable.SF_TARGET_ORG,
+     *     EnvironmentVariable.SF_USE_PROGRESS_BAR,
+     *   );
+     * }
+     * ```
+     */
+    static envVariablesSection;
+    /**
+     * Add an ERROR CODES section to the help output.
+     *
+     * @example
+     * ```
+     * import { SfCommand, toHelpSection } from '@salesforce/sf-plugins-core';
+     * export default class MyCommand extends SfCommand {
+     *   public static errorCodes = toHelpSection(
+     *     'ERROR CODES',
+     *     { 0: 'Success', 1: 'Failure' },
+     *   );
+     * }
+     * ```
+     */
+    static errorCodes;
+    /**
+     * Set to true if the command must be executed inside a Salesforce project directory.
+     *
+     * If set to true the command will throw an error if the command is executed outside of a Salesforce project directory.
+     * Additionally, this.project will be set to the current Salesforce project (SfProject).
+     *
+     */
+    static requiresProject;
+    /**
+     * Add a spinner to the console. {@link Spinner}
+     */
+    spinner;
+    /**
+     * Add a progress bar to the console. {@link Progress}
+     */
+    progress;
+    project;
+    /**
+     * ConfigAggregator instance for accessing global and local configuration.
+     */
+    configAggregator;
+    warnings = [];
+    ux;
+    lifecycle;
     constructor(argv, config) {
         super(argv, config);
-        this.warnings = [];
-        this.ux = new ux_1.Ux({ jsonEnabled: this.jsonEnabled() });
-        this.progress = new ux_1.Progress(this.ux.outputEnabled && core_2.envVars.getBoolean(core_2.EnvironmentVariable.SF_USE_PROGRESS_BAR, true));
+        this.ux = new Ux({ jsonEnabled: this.jsonEnabled() });
+        this.progress = new Progress(this.ux.outputEnabled && envVars.getBoolean(EnvironmentVariable.SF_USE_PROGRESS_BAR, true));
         this.spinner = this.ux.spinner;
-        this.prompter = this.ux.prompter;
-        this.lifecycle = core_2.Lifecycle.getInstance();
+        this.lifecycle = Lifecycle.getInstance();
     }
     get statics() {
         return this.constructor;
@@ -70,7 +137,7 @@ class SfCommand extends core_1.Command {
         // unless it's been explicitly disabled on the command's statics
         return (super.jsonEnabled() ||
             (this.statics.enableJsonFlag !== false &&
-                core_2.envVars.getString(core_2.EnvironmentVariable.SF_CONTENT_TYPE)?.toUpperCase() === 'JSON'));
+                envVars.getString(EnvironmentVariable.SF_CONTENT_TYPE)?.toUpperCase() === 'JSON'));
     }
     /**
      * Log a success message that has the standard success message color applied.
@@ -78,7 +145,7 @@ class SfCommand extends core_1.Command {
      * @param message The message to log.
      */
     logSuccess(message) {
-        this.log(exports.StandardColors.success(message));
+        this.log(StandardColors.success(message));
     }
     /**
      * Log warning to users. If --json is enabled, then the warning will be added to the json output under the warnings property.
@@ -86,11 +153,12 @@ class SfCommand extends core_1.Command {
      * @param input {@link SfCommand.Warning} The message to log.
      */
     warn(input) {
-        const colorizedArgs = [];
         this.warnings.push(input);
         const message = typeof input === 'string' ? input : input.message;
-        colorizedArgs.push(`${exports.StandardColors.warning(messages.getMessage('warning.prefix'))} ${message}`);
-        colorizedArgs.push(...this.formatActions(typeof input === 'string' ? [] : input.actions ?? [], { actionColor: exports.StandardColors.info }));
+        const colorizedArgs = [
+            `${StandardColors.warning(messages.getMessage('warning.prefix'))} ${message}`,
+            ...formatActions(typeof input === 'string' ? [] : input.actions ?? [], { actionColor: StandardColors.info }),
+        ];
         this.logToStderr(colorizedArgs.join(os.EOL));
         return input;
     }
@@ -100,11 +168,11 @@ class SfCommand extends core_1.Command {
      * @param input {@link SfCommand.Info} The message to log.
      */
     info(input) {
-        const colorizedArgs = [];
         const message = typeof input === 'string' ? input : input.message;
-        colorizedArgs.push(`${exports.StandardColors.info(message)}`);
-        colorizedArgs.push(...this.formatActions(typeof input === 'string' ? [] : input.actions ?? [], { actionColor: exports.StandardColors.info }));
-        this.log(colorizedArgs.join(os.EOL));
+        this.log([
+            `${StandardColors.info(message)}`,
+            ...formatActions(typeof input === 'string' ? [] : input.actions ?? [], { actionColor: StandardColors.info }),
+        ].join(os.EOL));
     }
     /**
      * Warn user about sensitive information (access tokens, etc...) before logging to the console.
@@ -160,40 +228,32 @@ class SfCommand extends core_1.Command {
         // If `--json` is enabled, then the ux instance on the class will disable output, which
         // means that the logJson method will not output anything. So, we need to create a new
         // instance of the ux class that does not have output disabled in order to log the json.
-        new ux_1.Ux().styledJSON(json);
+        new Ux().styledJSON(json);
     }
     /**
-     * Prompt user for information. See https://www.npmjs.com/package/inquirer for more.
+     * Prompt user for yes/no confirmation.
+     * Avoid calling in --json scenarios and always provide a `--no-prompt` option for scripting
      *
-     * This will NOT be automatically suppressed when the --json flag is present since we assume
-     * that any command that prompts the user for required information will not also support the --json flag.
-     *
-     * If you need to conditionally suppress prompts to support json output, then do the following:
+     * @param message text to display.  Do not include a question mark.
+     * @param ms milliseconds to wait for user input.  Defaults to 60s.  Will throw an error when timeout is reached.
      *
-     * @example
-     * if (!this.jsonEnabled()) {
-     *   await this.prompt();
-     * }
      */
-    async prompt(questions, initialAnswers) {
-        return this.prompter.prompt(questions, initialAnswers);
+    // eslint-disable-next-line class-methods-use-this
+    async secretPrompt({ message, ms = 60000 }) {
+        return secretPrompt({ message, ms });
     }
     /**
-     * Simplified prompt for single-question confirmation. Times out and throws after 10s
+     * Prompt user for yes/no confirmation.
+     * Avoid calling in --json scenarios and always provide a `--no-prompt` option for scripting
+     *
+     * @param message text to display.  Do not include a question mark or Y/N.
+     * @param ms milliseconds to wait for user input.  Defaults to 10s.  Will use the default value when timeout is reached.
+     * @param defaultAnswer boolean to set the default answer to.  Defaults to false.
      *
-     * @param message text to display.  Do not include a question mark.
-     * @param ms milliseconds to wait for user input.  Defaults to 10s.
-     * @param defaultAnswer boolean to set the default answer to.  Defaults to true.
-     * @return true if the user confirms, false if they do not.
-     */
-    async confirm(message, ms = 10000, defaultAnswer = true) {
-        return this.prompter.confirm(message, ms, defaultAnswer);
-    }
-    /**
-     * Prompt user for information with a timeout (in milliseconds). See https://www.npmjs.com/package/inquirer for more.
      */
-    async timedPrompt(questions, ms = 10000, initialAnswers) {
-        return this.prompter.timedPrompt(questions, ms, initialAnswers);
+    // eslint-disable-next-line class-methods-use-this
+    async confirm({ message, ms = 10000, defaultAnswer = false }) {
+        return confirm({ message, ms, defaultAnswer });
     }
     async _run() {
         ['SIGINT', 'SIGTERM', 'SIGBREAK', 'SIGHUP'].map((listener) => {
@@ -202,8 +262,8 @@ class SfCommand extends core_1.Command {
             });
         });
         [this.configAggregator, this.project] = await Promise.all([
-            core_2.ConfigAggregator.create(),
-            ...(this.statics.requiresProject ? [this.assignProject()] : []),
+            ConfigAggregator.create(),
+            ...(this.statics.requiresProject ? [assignProject()] : []),
         ]);
         if (this.statics.state === 'beta') {
             this.warn(messages.getMessage('warning.CommandInBeta'));
@@ -252,23 +312,11 @@ class SfCommand extends core_1.Command {
             warnings: this.warnings,
         };
     }
-    // eslint-disable-next-line class-methods-use-this
-    async assignProject() {
-        try {
-            return await core_2.SfProject.resolve();
-        }
-        catch (err) {
-            if (err instanceof Error && err.name === 'InvalidProjectWorkspaceError') {
-                throw messages.createError('errors.RequiresProject');
-            }
-            throw err;
-        }
-    }
     // eslint-disable-next-line @typescript-eslint/require-await
     async catch(error) {
         // stop any spinners to prevent it from unintentionally swallowing output.
         // If there is an active spinner, it'll say "Error" instead of "Done"
-        this.spinner.stop(exports.StandardColors.error('Error'));
+        this.spinner.stop(StandardColors.error('Error'));
         // transform an unknown error into one that conforms to the interface
         // @ts-expect-error because exitCode is not on Error
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
@@ -297,10 +345,10 @@ class SfCommand extends core_1.Command {
             this.logJson(this.toErrorJson(sfCommandError));
         }
         else {
-            this.logToStderr(this.formatError(sfCommandError));
+            this.logToStderr(formatError(sfCommandError));
         }
         // Create SfError that can be thrown
-        const err = new core_2.SfError(error.message, error.name ?? 'Error', 
+        const err = new SfError(error.message, error.name ?? 'Error', 
         // @ts-expect-error because actions is not on Error
         error.actions ?? [], process.exitCode);
         err.context = sfCommandError.context;
@@ -319,65 +367,16 @@ class SfCommand extends core_1.Command {
         process.emit('sfCommandError', err);
         throw err;
     }
-    /**
-     * Format errors and actions for human consumption. Adds 'Error (<ErrorCode>):',
-     * When there are actions, we add 'Try this:' in blue
-     * followed by each action in red on its own line.
-     * If Error.code is present it is output last in parentheses
-     *
-     * @returns {string} Returns decorated messages.
-     */
-    formatError(error) {
-        const colorizedArgs = [];
-        const errorCode = typeof error.code === 'string' || typeof error.code === 'number' ? ` (${error.code})` : '';
-        const errorPrefix = `${exports.StandardColors.error(messages.getMessage('error.prefix', [errorCode]))}`;
-        colorizedArgs.push(`${errorPrefix} ${error.message}`);
-        colorizedArgs.push(...this.formatActions(error.actions ?? []));
-        if (error.stack && core_2.envVars.getString(SfCommand.SF_ENV) === core_2.Mode.DEVELOPMENT) {
-            colorizedArgs.push(exports.StandardColors.info(`\n*** Internal Diagnostic ***\n\n${error.stack}\n******\n`));
-        }
-        return colorizedArgs.join('\n');
+}
+const assignProject = async () => {
+    try {
+        return await SfProject.resolve();
     }
-    /**
-     * Utility function to format actions lines
-     *
-     * @param actions
-     * @param options
-     * @private
-     */
-    // eslint-disable-next-line class-methods-use-this
-    formatActions(actions, options = { actionColor: exports.StandardColors.info }) {
-        const colorizedArgs = [];
-        // Format any actions.
-        if (actions?.length) {
-            colorizedArgs.push(`\n${exports.StandardColors.info(messages.getMessage('actions.tryThis'))}\n`);
-            actions.forEach((action) => {
-                colorizedArgs.push(`${options.actionColor(action)}`);
-            });
+    catch (err) {
+        if (err instanceof Error && err.name === 'InvalidProjectWorkspaceError') {
+            throw messages.createError('errors.RequiresProject');
         }
-        return colorizedArgs;
+        throw err;
     }
-}
-exports.SfCommand = SfCommand;
-SfCommand.SF_ENV = 'SF_ENV';
-SfCommand.enableJsonFlag = true;
-/**
- * Flags that you can use for manipulating tables.
- *
- * @example
- * ```
- * import { SfCommand } from '@salesforce/sf-plugins-core';
- * export default class MyCommand extends SfCommand {
- *   public static flags = {
- *    ...SfCommand.tableFags,
- *    'my-flags: flags.string({ char: 'm', description: 'my flag' }),
- *   }
- * }
- * ```
- */
-SfCommand.tableFlags = core_1.ux.table.flags;
-function removeEmpty(obj) {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    return Object.fromEntries(Object.entries(obj).filter(([_, v]) => v != null));
-}
+};
 //# sourceMappingURL=sfCommand.js.map

package/lib/sfCommandNamespace.d.ts

@@ -0,0 +1,24 @@
+import { StructuredMessage } from '@salesforce/core';
+export declare namespace SfCommand {
+    type Info = StructuredMessage | string;
+    type Warning = StructuredMessage | string;
+    interface Json<T> {
+        status: number;
+        result: T;
+        warnings?: Warning[];
+    }
+    interface Error {
+        status: number;
+        name: string;
+        message: string;
+        stack: string | undefined;
+        warnings?: Warning[];
+        actions?: string[];
+        code?: unknown;
+        exitCode?: number;
+        data?: unknown;
+        context?: string;
+        commandName?: string;
+    }
+}
+//# sourceMappingURL=sfCommandNamespace.d.ts.map

package/lib/sfCommandNamespace.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sfCommandNamespace.js.map

package/lib/stubUx.d.ts

@@ -1,6 +1,5 @@
 import { SinonSandbox } from 'sinon';
-import { SfCommand } from './sfCommand';
-import { Prompter, Ux } from './ux';
+import { Ux } from './ux/ux.js';
 /**
  * Stub methods on the Ux class.
  * Even if you plan to make no assertions, this will silence the output to keep your test results clean
@@ -21,7 +20,7 @@ import { Prompter, Ux } from './ux';
 export declare function stubUx(sandbox: SinonSandbox): {
     log: import("sinon").SinonStub<[message?: string | undefined, ...args: string[]], void>;
     warn: import("sinon").SinonStub<[message: string | Error], void>;
-    table: import("sinon").SinonStub<[data: Ux.Table.Data[], columns: Ux.Table.Columns<Ux.Table.Data>, options?: import("@oclif/core/lib/cli-ux/styled/table").table.Options | undefined], void>;
+    table: import("sinon").SinonStub<[data: Ux.Table.Data[], columns: Ux.Table.Columns<Ux.Table.Data>, options?: import("@oclif/core/lib/cli-ux/styled/table.js").table.Options | undefined], void>;
     url: import("sinon").SinonStub<[text: string, uri: string, params?: {} | undefined], void>;
     styledHeader: import("sinon").SinonStub<[text: string], void>;
     styledObject: import("sinon").SinonStub<[obj: import("@salesforce/ts-types").AnyJson, keys?: string[] | undefined], void>;
@@ -50,9 +49,9 @@ export declare function stubSfCommandUx(sandbox: SinonSandbox): {
     logToStderr: import("sinon").SinonStub<[message?: string | undefined, ...args: any[]], void>;
     logSuccess: import("sinon").SinonStub<[message: string], void>;
     logSensitive: import("sinon").SinonStub<[msg?: string | undefined], void>;
-    info: import("sinon").SinonStub<[input: SfCommand.Info], void>;
-    warn: import("sinon").SinonStub<[input: SfCommand.Warning], SfCommand.Warning>;
-    table: import("sinon").SinonStub<[data: Ux.Table.Data[], columns: Ux.Table.Columns<Ux.Table.Data>, options?: import("@oclif/core/lib/cli-ux/styled/table").table.Options | undefined], void>;
+    info: import("sinon").SinonStub<[input: import("./sfCommandNamespace.js").SfCommand.Info], void>;
+    warn: import("sinon").SinonStub<[input: import("./sfCommandNamespace.js").SfCommand.Warning], import("./sfCommandNamespace.js").SfCommand.Warning>;
+    table: import("sinon").SinonStub<[data: Ux.Table.Data[], columns: Ux.Table.Columns<Ux.Table.Data>, options?: import("@oclif/core/lib/cli-ux/styled/table.js").table.Options | undefined], void>;
     url: import("sinon").SinonStub<[text: string, uri: string, params?: {} | undefined], void>;
     styledHeader: import("sinon").SinonStub<[text: string], void>;
     styledObject: import("sinon").SinonStub<[obj: import("@salesforce/ts-types").AnyJson], void>;
@@ -100,8 +99,7 @@ export declare function stubSpinner(sandbox: SinonSandbox): {
  *
  */
 export declare function stubPrompter(sandbox: SinonSandbox): {
-    prompt: import("sinon").SinonStub<[questions: Prompter.Questions<Record<string, unknown>>, initialAnswers?: Partial<Record<string, unknown>> | undefined], Promise<Record<string, unknown>>>;
-    confirm: import("sinon").SinonStub<[message: string, ms?: number | undefined, defaultAnswer?: boolean | undefined], Promise<boolean>>;
-    timedPrompt: import("sinon").SinonStub<[questions: Prompter.Questions<Record<string, unknown>>, ms?: number | undefined, initialAnswers?: Partial<Record<string, unknown>> | undefined], Promise<Record<string, unknown>>>;
+    secret: import("sinon").SinonStub<[import("./prompts.js").PromptInputs<string>], Promise<string>>;
+    confirm: import("sinon").SinonStub<[import("./prompts.js").PromptInputs<boolean>], Promise<boolean>>;
 };
 //# sourceMappingURL=stubUx.d.ts.map

package/lib/stubUx.js

@@ -1,4 +1,3 @@
-"use strict";
 /*
  * Copyright (c) 2023, salesforce.com, inc.
  * All rights reserved.
@@ -6,10 +5,9 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stubPrompter = exports.stubSpinner = exports.stubSfCommandUx = exports.stubUx = void 0;
-const sfCommand_1 = require("./sfCommand");
-const ux_1 = require("./ux");
+import { SfCommand } from './sfCommand.js';
+import { Spinner } from './ux/spinner.js';
+import { Ux } from './ux/ux.js';
 /**
  * Stub methods on the Ux class.
  * Even if you plan to make no assertions, this will silence the output to keep your test results clean
@@ -27,18 +25,17 @@ const ux_1 = require("./ux");
  * ```
  *
  */
-function stubUx(sandbox) {
+export function stubUx(sandbox) {
     return {
-        log: sandbox.stub(ux_1.Ux.prototype, 'log'),
-        warn: sandbox.stub(ux_1.Ux.prototype, 'warn'),
-        table: sandbox.stub(ux_1.Ux.prototype, 'table'),
-        url: sandbox.stub(ux_1.Ux.prototype, 'url'),
-        styledHeader: sandbox.stub(ux_1.Ux.prototype, 'styledHeader'),
-        styledObject: sandbox.stub(ux_1.Ux.prototype, 'styledObject'),
-        styledJSON: sandbox.stub(ux_1.Ux.prototype, 'styledJSON'),
+        log: sandbox.stub(Ux.prototype, 'log'),
+        warn: sandbox.stub(Ux.prototype, 'warn'),
+        table: sandbox.stub(Ux.prototype, 'table'),
+        url: sandbox.stub(Ux.prototype, 'url'),
+        styledHeader: sandbox.stub(Ux.prototype, 'styledHeader'),
+        styledObject: sandbox.stub(Ux.prototype, 'styledObject'),
+        styledJSON: sandbox.stub(Ux.prototype, 'styledJSON'),
     };
 }
-exports.stubUx = stubUx;
 /**
  * Stub methods on the Ux class.
  * Even if you plan to make no assertions, this will silence the output to keep your test results clean
@@ -56,23 +53,22 @@ exports.stubUx = stubUx;
  * ```
  *
  */
-function stubSfCommandUx(sandbox) {
+export function stubSfCommandUx(sandbox) {
     return {
-        log: sandbox.stub(sfCommand_1.SfCommand.prototype, 'log'),
-        logJson: sandbox.stub(sfCommand_1.SfCommand.prototype, 'logJson'),
-        logToStderr: sandbox.stub(sfCommand_1.SfCommand.prototype, 'logToStderr'),
-        logSuccess: sandbox.stub(sfCommand_1.SfCommand.prototype, 'logSuccess'),
-        logSensitive: sandbox.stub(sfCommand_1.SfCommand.prototype, 'logSensitive'),
-        info: sandbox.stub(sfCommand_1.SfCommand.prototype, 'info'),
-        warn: sandbox.stub(sfCommand_1.SfCommand.prototype, 'warn'),
-        table: sandbox.stub(sfCommand_1.SfCommand.prototype, 'table'),
-        url: sandbox.stub(sfCommand_1.SfCommand.prototype, 'url'),
-        styledHeader: sandbox.stub(sfCommand_1.SfCommand.prototype, 'styledHeader'),
-        styledObject: sandbox.stub(sfCommand_1.SfCommand.prototype, 'styledObject'),
-        styledJSON: sandbox.stub(sfCommand_1.SfCommand.prototype, 'styledJSON'),
+        log: sandbox.stub(SfCommand.prototype, 'log'),
+        logJson: sandbox.stub(SfCommand.prototype, 'logJson'),
+        logToStderr: sandbox.stub(SfCommand.prototype, 'logToStderr'),
+        logSuccess: sandbox.stub(SfCommand.prototype, 'logSuccess'),
+        logSensitive: sandbox.stub(SfCommand.prototype, 'logSensitive'),
+        info: sandbox.stub(SfCommand.prototype, 'info'),
+        warn: sandbox.stub(SfCommand.prototype, 'warn'),
+        table: sandbox.stub(SfCommand.prototype, 'table'),
+        url: sandbox.stub(SfCommand.prototype, 'url'),
+        styledHeader: sandbox.stub(SfCommand.prototype, 'styledHeader'),
+        styledObject: sandbox.stub(SfCommand.prototype, 'styledObject'),
+        styledJSON: sandbox.stub(SfCommand.prototype, 'styledJSON'),
     };
 }
-exports.stubSfCommandUx = stubSfCommandUx;
 /**
  * Stub the SfCommand spinner.
  * Even if you plan to make no assertions, this will silence the output to keep your test results clean
@@ -90,13 +86,12 @@ exports.stubSfCommandUx = stubSfCommandUx;
  * ```
  *
  */
-function stubSpinner(sandbox) {
+export function stubSpinner(sandbox) {
     return {
-        start: sandbox.stub(ux_1.Spinner.prototype, 'start'),
-        stop: sandbox.stub(ux_1.Spinner.prototype, 'stop'),
+        start: sandbox.stub(Spinner.prototype, 'start'),
+        stop: sandbox.stub(Spinner.prototype, 'stop'),
     };
 }
-exports.stubSpinner = stubSpinner;
 /**
  * Stub the SfCommand prompter.
  *
@@ -115,12 +110,10 @@ exports.stubSpinner = stubSpinner;
  * ```
  *
  */
-function stubPrompter(sandbox) {
+export function stubPrompter(sandbox) {
     return {
-        prompt: sandbox.stub(ux_1.Prompter.prototype, 'prompt'),
-        confirm: sandbox.stub(ux_1.Prompter.prototype, 'confirm'),
-        timedPrompt: sandbox.stub(ux_1.Prompter.prototype, 'timedPrompt'),
+        secret: sandbox.stub(SfCommand.prototype, 'secretPrompt'),
+        confirm: sandbox.stub(SfCommand.prototype, 'confirm'),
     };
 }
-exports.stubPrompter = stubPrompter;
 //# sourceMappingURL=stubUx.js.map