@hubspot/cli 7.7.27-experimental.1 → 7.7.28-experimental.0

package/lib/prompts/__tests__/createModulePrompt.test.js

@@ -0,0 +1,187 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createModulePrompt } from '../createModulePrompt.js';
+import { promptUser } from '../promptUtils.js';
+vi.mock('../promptUtils.js');
+const mockPromptUser = vi.mocked(promptUser);
+describe('createModulePrompt', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('when all parameters are provided', () => {
+        it('should return provided values without prompting', async () => {
+            const commandArgs = {
+                moduleLabel: 'My Module',
+                reactType: true,
+                contentTypes: 'LANDING_PAGE,SITE_PAGE',
+                global: false,
+                availableForNewContent: true,
+            };
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                moduleLabel: 'My Module',
+                reactType: true,
+                contentTypes: ['LANDING_PAGE', 'SITE_PAGE'],
+                global: false,
+                availableForNewContent: true,
+            });
+        });
+        it('should use default values when optional parameters not provided', async () => {
+            const commandArgs = {
+                moduleLabel: 'My Module',
+            };
+            mockPromptUser.mockResolvedValue({
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: true,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'reactType' }),
+                expect.objectContaining({ name: 'contentTypes' }),
+                expect.objectContaining({ name: 'global' }),
+                expect.objectContaining({ name: 'availableForNewContent' }),
+            ]);
+            expect(result).toEqual({
+                moduleLabel: 'My Module',
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: true,
+            });
+        });
+        it('should parse contentTypes string correctly', async () => {
+            const commandArgs = {
+                moduleLabel: 'Test Module',
+                contentTypes: 'BLOG_POST, EMAIL, LANDING_PAGE',
+            };
+            mockPromptUser.mockResolvedValue({
+                reactType: false,
+                global: false,
+                availableForNewContent: true,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(result.contentTypes).toEqual([
+                'BLOG_POST',
+                'EMAIL',
+                'LANDING_PAGE',
+            ]);
+        });
+    });
+    describe('when some parameters are missing', () => {
+        it('should only prompt for missing parameters', async () => {
+            const commandArgs = {
+                moduleLabel: 'My Module',
+                reactType: true,
+            };
+            mockPromptUser.mockResolvedValue({
+                contentTypes: ['SITE_PAGE'],
+                global: true,
+                availableForNewContent: false,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'contentTypes' }),
+                expect.objectContaining({ name: 'global' }),
+                expect.objectContaining({ name: 'availableForNewContent' }),
+            ]);
+            expect(result).toEqual({
+                moduleLabel: 'My Module',
+                reactType: true,
+                contentTypes: ['SITE_PAGE'],
+                global: true,
+                availableForNewContent: false,
+            });
+        });
+    });
+    describe('when no parameters are provided', () => {
+        it('should prompt for all parameters', async () => {
+            mockPromptUser.mockResolvedValue({
+                moduleLabel: 'Prompted Module',
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: true,
+            });
+            const result = await createModulePrompt();
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'moduleLabel' }),
+                expect.objectContaining({ name: 'reactType' }),
+                expect.objectContaining({ name: 'contentTypes' }),
+                expect.objectContaining({ name: 'global' }),
+                expect.objectContaining({ name: 'availableForNewContent' }),
+            ]);
+            expect(result).toEqual({
+                moduleLabel: 'Prompted Module',
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: true,
+            });
+        });
+    });
+    describe('parameter precedence', () => {
+        it('should prioritize command args over prompted values', async () => {
+            const commandArgs = {
+                moduleLabel: 'Args Module',
+                global: true,
+            };
+            mockPromptUser.mockResolvedValue({
+                reactType: false,
+                contentTypes: ['EMAIL'],
+                availableForNewContent: false,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(result).toEqual({
+                moduleLabel: 'Args Module', // from commandArgs
+                reactType: false, // from prompt
+                contentTypes: ['EMAIL'], // from prompt
+                global: true, // from commandArgs
+                availableForNewContent: false, // from prompt
+            });
+        });
+        it('should handle boolean false values correctly', async () => {
+            const commandArgs = {
+                moduleLabel: 'Test Module',
+                reactType: false,
+                contentTypes: 'ANY',
+                global: false,
+                availableForNewContent: false,
+            };
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                moduleLabel: 'Test Module',
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: false,
+            });
+        });
+        it('should handle mixed scenario with partial command args and prompting', async () => {
+            const commandArgs = {
+                moduleLabel: 'Partial Module',
+                contentTypes: 'BLOG_POST,BLOG_LISTING',
+            };
+            mockPromptUser.mockResolvedValue({
+                reactType: true,
+                global: false,
+                availableForNewContent: true,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'reactType' }),
+                expect.objectContaining({ name: 'global' }),
+                expect.objectContaining({ name: 'availableForNewContent' }),
+            ]);
+            expect(result).toEqual({
+                moduleLabel: 'Partial Module', // from commandArgs
+                reactType: true, // from prompt
+                contentTypes: ['BLOG_POST', 'BLOG_LISTING'], // from commandArgs (parsed)
+                global: false, // from prompt
+                availableForNewContent: true, // from prompt
+            });
+        });
+    });
+});

package/lib/prompts/__tests__/createTemplatePrompt.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/prompts/__tests__/createTemplatePrompt.test.js

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createTemplatePrompt } from '../createTemplatePrompt.js';
+import { promptUser } from '../promptUtils.js';
+vi.mock('../promptUtils.js');
+const mockPromptUser = vi.mocked(promptUser);
+describe('createTemplatePrompt', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('when templateType is provided', () => {
+        it('should return provided templateType without prompting', async () => {
+            const commandArgs = {
+                templateType: 'page-template',
+            };
+            const result = await createTemplatePrompt(commandArgs);
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                templateType: 'page-template',
+            });
+        });
+        it('should work with different template types', async () => {
+            const testCases = [
+                'email-template',
+                'partial',
+                'global-partial',
+                'blog-listing-template',
+                'blog-post-template',
+                'search-template',
+                'section',
+            ];
+            for (const templateType of testCases) {
+                const commandArgs = { templateType };
+                const result = await createTemplatePrompt(commandArgs);
+                expect(mockPromptUser).not.toHaveBeenCalled();
+                expect(result).toEqual({ templateType });
+                vi.resetAllMocks();
+            }
+        });
+    });
+    describe('when templateType is not provided', () => {
+        it('should prompt for templateType', async () => {
+            mockPromptUser.mockResolvedValue({
+                templateType: 'page-template',
+            });
+            const result = await createTemplatePrompt();
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    name: 'templateType',
+                    type: 'list',
+                    choices: expect.any(Array),
+                }),
+            ]);
+            expect(result).toEqual({
+                templateType: 'page-template',
+            });
+        });
+        it('should prompt when commandArgs is empty', async () => {
+            mockPromptUser.mockResolvedValue({
+                templateType: 'email-template',
+            });
+            const result = await createTemplatePrompt({});
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'templateType' }),
+            ]);
+            expect(result).toEqual({
+                templateType: 'email-template',
+            });
+        });
+        it('should prompt when templateType is undefined', async () => {
+            const commandArgs = {
+                templateType: undefined,
+            };
+            mockPromptUser.mockResolvedValue({
+                templateType: 'partial',
+            });
+            const result = await createTemplatePrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'templateType' }),
+            ]);
+            expect(result).toEqual({
+                templateType: 'partial',
+            });
+        });
+    });
+    describe('integration scenarios', () => {
+        it('should handle mixed usage patterns', async () => {
+            // First call with templateType provided
+            let result = await createTemplatePrompt({
+                templateType: 'blog-post-template',
+            });
+            expect(result.templateType).toBe('blog-post-template');
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            // Second call without templateType
+            mockPromptUser.mockResolvedValue({
+                templateType: 'section',
+            });
+            result = await createTemplatePrompt();
+            expect(result.templateType).toBe('section');
+            expect(mockPromptUser).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/lib/prompts/confirmImportDataPrompt.d.ts

@@ -0,0 +1 @@
+export declare function confirmImportDataPrompt(targetAccountId: number, dataFileNames: string[]): Promise<boolean>;

package/lib/prompts/confirmImportDataPrompt.js

@@ -0,0 +1,12 @@
+import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+export async function confirmImportDataPrompt(targetAccountId, dataFileNames) {
+    const account = getAccountConfig(targetAccountId);
+    const { confirmImportData } = await promptUser({
+        type: 'confirm',
+        name: 'confirmImportData',
+        message: lib.prompts.confirmImportDataPrompt.message(dataFileNames, account),
+    });
+    return confirmImportData;
+}

package/lib/prompts/createFunctionPrompt.d.ts

@@ -1,8 +1,9 @@
+import { CreateArgs } from '../../types/Cms.js';
 type CreateFunctionPromptResponse = {
     functionsFolder: string;
     filename: string;
     endpointMethod: string;
     endpointPath: string;
 };
-export declare function createFunctionPrompt(): Promise<CreateFunctionPromptResponse>;
+export declare function createFunctionPrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateFunctionPromptResponse>;
 export {};

package/lib/prompts/createFunctionPrompt.js

@@ -55,11 +55,40 @@ const ENDPOINT_PATH_PROMPT = {
         return true;
     },
 };
-export function createFunctionPrompt() {
-    return promptUser([
-        FUNCTIONS_FOLDER_PROMPT,
-        FUNCTION_FILENAME_PROMPT,
-        ENDPOINT_METHOD_PROMPT,
-        ENDPOINT_PATH_PROMPT,
-    ]);
+export function createFunctionPrompt(commandArgs = {}) {
+    // Check if all required parameters are provided (endpointMethod has default)
+    const hasAllRequired = commandArgs.functionsFolder &&
+        commandArgs.filename &&
+        commandArgs.endpointPath;
+    if (hasAllRequired) {
+        return Promise.resolve({
+            functionsFolder: commandArgs.functionsFolder,
+            filename: commandArgs.filename,
+            endpointMethod: commandArgs.endpointMethod || 'GET',
+            endpointPath: commandArgs.endpointPath,
+        });
+    }
+    const prompts = [];
+    // Only prompt for missing parameters
+    if (!commandArgs.functionsFolder) {
+        prompts.push(FUNCTIONS_FOLDER_PROMPT);
+    }
+    if (!commandArgs.filename) {
+        prompts.push(FUNCTION_FILENAME_PROMPT);
+    }
+    if (!commandArgs.endpointMethod) {
+        prompts.push(ENDPOINT_METHOD_PROMPT);
+    }
+    if (!commandArgs.endpointPath) {
+        prompts.push(ENDPOINT_PATH_PROMPT);
+    }
+    return promptUser(prompts).then(promptResponse => {
+        // Merge prompted values with provided commandArgs
+        return {
+            functionsFolder: commandArgs.functionsFolder || promptResponse.functionsFolder,
+            filename: commandArgs.filename || promptResponse.filename,
+            endpointMethod: commandArgs.endpointMethod || promptResponse.endpointMethod || 'GET',
+            endpointPath: commandArgs.endpointPath || promptResponse.endpointPath,
+        };
+    });
 }

package/lib/prompts/createModulePrompt.d.ts

@@ -1,3 +1,4 @@
+import { CreateArgs } from '../../types/Cms.js';
 type CreateModulePromptResponse = {
     moduleLabel: string;
     reactType: boolean;
@@ -5,5 +6,5 @@ type CreateModulePromptResponse = {
     global: boolean;
     availableForNewContent: boolean;
 };
-export declare function createModulePrompt(): Promise<CreateModulePromptResponse>;
+export declare function createModulePrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateModulePromptResponse>;
 export {};

package/lib/prompts/createModulePrompt.js

@@ -58,7 +58,54 @@ const AVAILABLE_FOR_NEW_CONTENT = {
     message: i18n(`lib.prompts.createModulePrompt.availableForNewContent`),
     default: true,
 };
-export function createModulePrompt() {
+export function createModulePrompt(commandArgs = {}) {
+    // Check if moduleLabel is provided (main requirement to skip full prompting)
+    // but still allow individual parameter prompting for enhanced UX
+    if (commandArgs.moduleLabel) {
+        const prompts = [];
+        // Only prompt for parameters not explicitly provided
+        if (commandArgs.reactType === undefined) {
+            prompts.push(REACT_TYPE_PROMPT);
+        }
+        if (!commandArgs.contentTypes) {
+            prompts.push(CONTENT_TYPES_PROMPT);
+        }
+        if (commandArgs.global === undefined) {
+            prompts.push(GLOBAL_PROMPT);
+        }
+        if (commandArgs.availableForNewContent === undefined) {
+            prompts.push(AVAILABLE_FOR_NEW_CONTENT);
+        }
+        // If no additional prompts needed, return with defaults
+        if (prompts.length === 0) {
+            const contentTypesArray = commandArgs.contentTypes
+                ? commandArgs.contentTypes.split(',').map((t) => t.trim())
+                : ['ANY'];
+            return Promise.resolve({
+                moduleLabel: commandArgs.moduleLabel,
+                reactType: commandArgs.reactType ?? false,
+                contentTypes: contentTypesArray,
+                global: commandArgs.global ?? false,
+                availableForNewContent: commandArgs.availableForNewContent ?? true,
+            });
+        }
+        // Prompt only for missing optional parameters
+        return promptUser(prompts).then(promptResponse => {
+            const contentTypesArray = commandArgs.contentTypes
+                ? commandArgs.contentTypes.split(',').map((t) => t.trim())
+                : promptResponse.contentTypes || ['ANY'];
+            return {
+                moduleLabel: commandArgs.moduleLabel,
+                reactType: commandArgs.reactType ?? promptResponse.reactType ?? false,
+                contentTypes: contentTypesArray,
+                global: commandArgs.global ?? promptResponse.global ?? false,
+                availableForNewContent: commandArgs.availableForNewContent ??
+                    promptResponse.availableForNewContent ??
+                    true,
+            };
+        });
+    }
+    // No moduleLabel provided, prompt for everything (original behavior)
     return promptUser([
         MODULE_LABEL_PROMPT,
         REACT_TYPE_PROMPT,

package/lib/prompts/createTemplatePrompt.d.ts

@@ -1,27 +1,6 @@
-declare const templateTypeChoices: [{
-    readonly name: "page";
-    readonly value: "page-template";
-}, {
-    readonly name: "email";
-    readonly value: "email-template";
-}, {
-    readonly name: "partial";
-    readonly value: "partial";
-}, {
-    readonly name: "global partial";
-    readonly value: "global-partial";
-}, {
-    readonly name: "blog listing";
-    readonly value: "blog-listing-template";
-}, {
-    readonly name: "blog post";
-    readonly value: "blog-post-template";
-}, {
-    readonly name: "search results";
-    readonly value: "search-template";
-}];
+import { CreateArgs, TemplateType } from '../../types/Cms.js';
 interface CreateTemplatePromptResponse {
-    templateType: (typeof templateTypeChoices)[number]['value'];
+    templateType: TemplateType;
 }
-export declare function createTemplatePrompt(): Promise<CreateTemplatePromptResponse>;
+export declare function createTemplatePrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateTemplatePromptResponse>;
 export {};

package/lib/prompts/createTemplatePrompt.js

@@ -8,6 +8,7 @@ const templateTypeChoices = [
     { name: 'blog listing', value: 'blog-listing-template' },
     { name: 'blog post', value: 'blog-post-template' },
     { name: 'search results', value: 'search-template' },
+    { name: 'section', value: 'section' },
 ];
 const TEMPLATE_TYPE_PROMPT = {
     type: 'list',
@@ -16,6 +17,13 @@ const TEMPLATE_TYPE_PROMPT = {
     default: 'page',
     choices: templateTypeChoices,
 };
-export function createTemplatePrompt() {
+export function createTemplatePrompt(commandArgs = {}) {
+    // If templateType is provided, return it directly
+    if (commandArgs.templateType) {
+        return Promise.resolve({
+            templateType: commandArgs.templateType,
+        });
+    }
+    // No templateType provided, prompt for it (original behavior)
     return promptUser([TEMPLATE_TYPE_PROMPT]);
 }

package/lib/prompts/importDataFilePathPrompt.d.ts

@@ -0,0 +1 @@
+export declare function importDataFilePathPrompt(): Promise<string>;

package/lib/prompts/importDataFilePathPrompt.js

@@ -0,0 +1,24 @@
+import { validateImportRequestFile } from '@hubspot/local-dev-lib/crm';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { logError } from '../errorHandlers/index.js';
+import { uiLogger } from '../ui/logger.js';
+export async function importDataFilePathPrompt() {
+    uiLogger.log(lib.prompts.importDataFilePathPrompt.promptContext);
+    const { filePath } = await promptUser({
+        type: 'input',
+        name: 'filePath',
+        message: lib.prompts.importDataFilePathPrompt.promptMessage,
+        validate: (filePath) => {
+            try {
+                validateImportRequestFile(filePath);
+                return true;
+            }
+            catch (error) {
+                logError(error);
+                return false;
+            }
+        },
+    });
+    return filePath;
+}

package/lib/prompts/importDataTestAccountSelectPrompt.d.ts

@@ -0,0 +1,3 @@
+export declare function importDataTestAccountSelectPrompt(parentAccountId: number): Promise<{
+    selectedAccountId: number;
+}>;

package/lib/prompts/importDataTestAccountSelectPrompt.js

@@ -0,0 +1,29 @@
+import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { promptUser } from './promptUtils.js';
+import { getConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { uiAccountDescription } from '../ui/index.js';
+import { lib } from '../../lang/en.js';
+export async function importDataTestAccountSelectPrompt(parentAccountId) {
+    const accounts = getConfigAccounts();
+    if (!accounts) {
+        throw new Error(lib.prompts.importDataTestAccountSelectPrompt.errors.noAccountsFound);
+    }
+    const childAccounts = accounts
+        .filter(account => account.parentAccountId === parentAccountId)
+        .map(account => {
+        return {
+            name: uiAccountDescription(getAccountIdentifier(account)),
+            value: getAccountIdentifier(account),
+        };
+    })
+        .filter(account => account.value !== undefined && account.name !== undefined);
+    if (childAccounts.length === 0) {
+        throw new Error(lib.prompts.importDataTestAccountSelectPrompt.errors.noChildTestAccountsFound(parentAccountId));
+    }
+    return promptUser({
+        type: 'list',
+        name: 'selectedAccountId',
+        message: '[--account] Select a developer test account:',
+        choices: childAccounts,
+    });
+}

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -151,6 +151,7 @@ async function selectTargetAccountPrompt(defaultAccountId, accountType, choices)
                 accountType,
             }),
             choices,
+            loop: false,
         },
     ]);
     return targetAccountInfo;

package/lib/prompts/promptUtils.d.ts

@@ -1,15 +1,21 @@
 import { Separator as _Separator } from '@inquirer/prompts';
 import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts.js';
 export declare const Separator: _Separator;
+export declare const PROMPT_THEME: {
+    prefix: {
+        idle: string;
+    };
+};
 export declare function promptUser<T extends GenericPromptResponse>(config: PromptConfig<T> | PromptConfig<T>[]): Promise<T>;
 export declare function confirmPrompt(message: string, options?: {
     defaultAnswer?: boolean;
 }): Promise<boolean>;
-export declare function listPrompt<T = string>(message: string, { choices, when, defaultAnswer, validate, }: {
+export declare function listPrompt<T = string>(message: string, { choices, when, defaultAnswer, validate, loop, }: {
     choices: PromptChoices<T>;
     when?: PromptWhen;
     defaultAnswer?: string | number | boolean;
     validate?: (input: T[]) => (boolean | string) | Promise<boolean | string>;
+    loop?: boolean;
 }): Promise<T>;
 export declare function inputPrompt(message: string, { when, validate, defaultAnswer, }?: {
     when?: boolean | (() => boolean);

package/lib/prompts/promptUtils.js

@@ -1,6 +1,8 @@
 import { confirm, Separator as _Separator, select, input, checkbox, password, number, } from '@inquirer/prompts';
 import { EXIT_CODES } from '../enums/exitCodes.js';
+import chalk from 'chalk';
 export const Separator = new _Separator();
+export const PROMPT_THEME = { prefix: { idle: chalk.green('?') } };
 function isUserCancellationError(error) {
     return error instanceof Error && error.name === 'ExitPromptError';
 }
@@ -102,6 +104,8 @@ function handleRawListPrompt(config) {
         choices: choices,
         pageSize: config.pageSize,
         default: config.default,
+        loop: config.loop,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleNumberPrompt(config) {
@@ -109,6 +113,7 @@ function handleNumberPrompt(config) {
         message: config.message,
         default: config.default,
         validate: config.validate,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handlePasswordPrompt(config) {
@@ -116,6 +121,7 @@ function handlePasswordPrompt(config) {
         message: config.message,
         mask: '*',
         validate: config.validate,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleCheckboxPrompt(config) {
@@ -125,6 +131,8 @@ function handleCheckboxPrompt(config) {
         choices: choices,
         pageSize: config.pageSize,
         validate: config.validate,
+        loop: config.loop,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleConfirmPrompt(config) {
@@ -138,6 +146,7 @@ function handleInputPrompt(config) {
         default: config.default,
         validate: config.validate,
         transformer: config.transformer,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleSelectPrompt(config) {
@@ -147,6 +156,8 @@ function handleSelectPrompt(config) {
         choices: choices,
         default: config.default,
         pageSize: config.pageSize,
+        loop: config.loop,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 export async function confirmPrompt(message, options = {}) {
@@ -154,10 +165,11 @@ export async function confirmPrompt(message, options = {}) {
     const choice = await confirm({
         message,
         default: defaultAnswer,
+        theme: PROMPT_THEME,
     });
     return choice;
 }
-export async function listPrompt(message, { choices, when, defaultAnswer, validate, }) {
+export async function listPrompt(message, { choices, when, defaultAnswer, validate, loop, }) {
     const { choice } = await promptUser({
         name: 'choice',
         type: 'list',
@@ -166,6 +178,7 @@ export async function listPrompt(message, { choices, when, defaultAnswer, valida
         when,
         default: defaultAnswer,
         validate,
+        loop,
     });
     return choice;
 }

package/lib/ui/__tests__/removeAnsiCodes.test.d.ts

@@ -0,0 +1 @@
+export {};