@hubspot/cli 7.7.21-experimental.1 → 7.7.22-experimental.0

package/lib/prompts/previewPrompt.js

@@ -1,50 +1,43 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.previewPrompt = previewPrompt;
-exports.previewProjectPrompt = previewProjectPrompt;
-const path_1 = __importDefault(require("path"));
-const path_2 = require("@hubspot/local-dev-lib/path");
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
-async function previewPrompt(promptOptions = {}) {
-    return (0, promptUtils_1.promptUser)([
+import path from 'path';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
+export async function previewPrompt(promptOptions = {}) {
+    return promptUser([
         {
             name: 'src',
-            message: (0, lang_1.i18n)(`lib.prompts.previewPrompt.enterSrc`),
+            message: i18n(`lib.prompts.previewPrompt.enterSrc`),
             when: !promptOptions.src,
             default: '.',
             validate: (input) => {
                 if (!input) {
-                    return (0, lang_1.i18n)(`lib.prompts.previewPrompt.errors.srcRequired`);
+                    return i18n(`lib.prompts.previewPrompt.errors.srcRequired`);
                 }
                 return true;
             },
         },
         {
             name: 'dest',
-            message: (0, lang_1.i18n)(`lib.prompts.previewPrompt.enterDest`),
+            message: i18n(`lib.prompts.previewPrompt.enterDest`),
             when: !promptOptions.dest,
-            default: path_1.default.basename((0, path_2.getCwd)()),
+            default: path.basename(getCwd()),
             validate: (input) => {
                 if (!input) {
-                    return (0, lang_1.i18n)(`lib.prompts.previewPrompt.errors.destRequired`);
+                    return i18n(`lib.prompts.previewPrompt.errors.destRequired`);
                 }
                 return true;
             },
         },
     ]);
 }
-async function previewProjectPrompt(themeComponents) {
-    return (0, promptUtils_1.promptUser)([
+export async function previewProjectPrompt(themeComponents) {
+    return promptUser([
         {
             name: 'themeComponentPath',
-            message: (0, lang_1.i18n)(`lib.prompts.previewPrompt.themeProjectSelect`),
+            message: i18n(`lib.prompts.previewPrompt.themeProjectSelect`),
             type: 'list',
             choices: themeComponents.map(t => {
-                const themeName = path_1.default.basename(t.path);
+                const themeName = path.basename(t.path);
                 return {
                     name: themeName,
                     value: t.path,

package/lib/prompts/projectAddPrompt.d.ts

@@ -1,5 +1,5 @@
 import { Separator } from '@inquirer/prompts';
-import { ComponentTemplate, ComponentTemplateChoice } from '../../types/Projects';
+import { ComponentTemplate, ComponentTemplateChoice } from '../../types/Projects.js';
 type ProjectAddPromptResponse = {
     componentTemplate: ComponentTemplate;
     name: string;

package/lib/prompts/projectAddPrompt.js

@@ -1,23 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectAddPrompt = projectAddPrompt;
-exports.projectAddPromptV3 = projectAddPromptV3;
-const prompts_1 = require("@inquirer/prompts");
-const promptUtils_1 = require("./promptUtils");
-const en_1 = require("../../lang/en");
+import { Separator } from '@inquirer/prompts';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
 function findComponentByPathOrLabel(components, componentPathOrLabel) {
     return components.find(c => c.path === componentPathOrLabel || c.label === componentPathOrLabel);
 }
-async function projectAddPrompt(components, promptOptions = {}) {
+export async function projectAddPrompt(components, promptOptions = {}) {
     const providedTypeIsValid = !!promptOptions.type &&
         !!findComponentByPathOrLabel(components, promptOptions.type);
-    const result = await (0, promptUtils_1.promptUser)([
+    const result = await promptUser([
         {
             name: 'componentTemplate',
             message: () => {
                 return promptOptions.type && !providedTypeIsValid
-                    ? en_1.lib.prompts.projectAddPrompt.errors.invalidType(promptOptions.type)
-                    : en_1.lib.prompts.projectAddPrompt.selectType;
+                    ? lib.prompts.projectAddPrompt.errors.invalidType(promptOptions.type)
+                    : lib.prompts.projectAddPrompt.selectType;
             },
             when: !providedTypeIsValid,
             type: 'list',
@@ -30,11 +26,11 @@ async function projectAddPrompt(components, promptOptions = {}) {
         },
         {
             name: 'name',
-            message: en_1.lib.prompts.projectAddPrompt.enterName,
+            message: lib.prompts.projectAddPrompt.enterName,
             when: !promptOptions.name,
             validate: (input) => {
                 if (!input) {
-                    return en_1.lib.prompts.projectAddPrompt.errors.nameRequired;
+                    return lib.prompts.projectAddPrompt.errors.nameRequired;
                 }
                 return true;
             },
@@ -48,25 +44,25 @@ async function projectAddPrompt(components, promptOptions = {}) {
     }
     return result;
 }
-async function projectAddPromptV3(components, selectedFeatures) {
+export async function projectAddPromptV3(components, selectedFeatures) {
     const selectedComponents = [];
     if (selectedFeatures) {
         components.forEach(template => {
-            if (template instanceof prompts_1.Separator || !template.value) {
+            if (template instanceof Separator || !template.value) {
                 return;
             }
             if (selectedFeatures?.includes(template.value.type)) {
                 if (template.disabled) {
-                    throw new Error(en_1.lib.prompts.projectAddPrompt.errors.cannotAddFeature(template.value.type, template.disabled));
+                    throw new Error(lib.prompts.projectAddPrompt.errors.cannotAddFeature(template.value.type, template.disabled));
                 }
                 selectedComponents.push(template.value);
             }
         });
     }
-    const result = await (0, promptUtils_1.promptUser)([
+    const result = await promptUser([
         {
             name: 'componentTemplate',
-            message: en_1.lib.prompts.projectAddPrompt.selectType,
+            message: lib.prompts.projectAddPrompt.selectType,
             when: !selectedFeatures && selectedComponents.length === 0,
             type: 'checkbox',
             choices: components,

package/lib/prompts/projectDevTargetAccountPrompt.d.ts

@@ -1,5 +1,5 @@
 import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
-import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts';
+import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
 export type ProjectDevTargetAccountPromptResponse = {
     targetAccountId: number | null;
     createNestedAccount: boolean;

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -1,36 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectSandboxTargetAccountPrompt = selectSandboxTargetAccountPrompt;
-exports.selectDeveloperTestTargetAccountPrompt = selectDeveloperTestTargetAccountPrompt;
-exports.confirmDefaultAccountPrompt = confirmDefaultAccountPrompt;
-exports.confirmUseExistingDeveloperTestAccountPrompt = confirmUseExistingDeveloperTestAccountPrompt;
-const config_1 = require("@hubspot/local-dev-lib/config");
-const sandboxHubs_1 = require("@hubspot/local-dev-lib/api/sandboxHubs");
-const config_2 = require("@hubspot/local-dev-lib/constants/config");
-const getAccountIdentifier_1 = require("@hubspot/local-dev-lib/config/getAccountIdentifier");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const developerTestAccounts_1 = require("@hubspot/local-dev-lib/api/developerTestAccounts");
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
-const ui_1 = require("../ui");
-const accountTypes_1 = require("../accountTypes");
-const exitCodes_1 = require("../enums/exitCodes");
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/local-dev-lib/constants/config';
+import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { fetchDeveloperTestAccounts } from '@hubspot/local-dev-lib/api/developerTestAccounts';
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
+import { uiAccountDescription, uiCommandReference } from '../ui/index.js';
+import { isSandbox } from '../accountTypes.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 function mapNestedAccount(accountConfig) {
     const parentAccountId = accountConfig.parentAccountId ?? null;
     return {
-        name: (0, ui_1.uiAccountDescription)((0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig), false),
+        name: uiAccountDescription(getAccountIdentifier(accountConfig), false),
         value: {
-            targetAccountId: (0, config_1.getAccountId)(accountConfig.name),
+            targetAccountId: getAccountId(accountConfig.name),
             createNestedAccount: false,
             parentAccountId,
         },
     };
 }
 function getNonConfigDeveloperTestAccountName(account) {
-    return `${account.accountName} [${config_2.HUBSPOT_ACCOUNT_TYPE_STRINGS[config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]}] (${account.id})`;
+    return `${account.accountName} [${HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]}] (${account.id})`;
 }
-async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig) {
-    const defaultAccountId = (0, config_1.getAccountId)(defaultAccountConfig.name);
+export async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig) {
+    const defaultAccountId = getAccountId(defaultAccountConfig.name);
     let choices = [];
     let sandboxUsage = {
         STANDARD: { used: 0, available: 0, limit: 0 },
@@ -38,30 +32,30 @@ async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig)
     };
     try {
         if (defaultAccountId) {
-            const { data } = await (0, sandboxHubs_1.getSandboxUsageLimits)(defaultAccountId);
+            const { data } = await getSandboxUsageLimits(defaultAccountId);
             sandboxUsage = data.usage;
         }
         else {
-            logger_1.logger.error((0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.noAccountId`));
-            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+            logger.error(i18n(`lib.prompts.projectDevTargetAccountPrompt.noAccountId`));
+            process.exit(EXIT_CODES.ERROR);
         }
     }
     catch (err) {
-        logger_1.logger.debug('Unable to fetch sandbox usage limits: ', err);
+        logger.debug('Unable to fetch sandbox usage limits: ', err);
     }
     const sandboxAccounts = accounts
         .reverse()
-        .filter(config => (0, accountTypes_1.isSandbox)(config) && config.parentAccountId === defaultAccountId);
+        .filter(config => isSandbox(config) && config.parentAccountId === defaultAccountId);
     let disabledMessage = false;
     if (sandboxUsage['DEVELOPER'] && sandboxUsage['DEVELOPER'].available === 0) {
         if (sandboxAccounts.length < sandboxUsage['DEVELOPER'].limit) {
-            disabledMessage = (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.sandboxLimitWithSuggestion`, {
-                authCommand: (0, ui_1.uiCommandReference)('hs auth'),
+            disabledMessage = i18n(`lib.prompts.projectDevTargetAccountPrompt.sandboxLimitWithSuggestion`, {
+                authCommand: uiCommandReference('hs auth'),
                 limit: sandboxUsage['DEVELOPER'].limit,
             });
         }
         else {
-            disabledMessage = (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.sandboxLimit`, {
+            disabledMessage = i18n(`lib.prompts.projectDevTargetAccountPrompt.sandboxLimit`, {
                 limit: sandboxUsage['DEVELOPER'].limit,
             });
         }
@@ -69,13 +63,13 @@ async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig)
     // Order choices by Developer Sandbox -> Standard Sandbox
     choices = [
         ...sandboxAccounts
-            .filter(a => a.accountType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)
+            .filter(a => a.accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)
             .map(mapNestedAccount),
         ...sandboxAccounts
-            .filter(a => a.accountType === config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)
+            .filter(a => a.accountType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)
             .map(mapNestedAccount),
         {
-            name: (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.createNewSandboxOption`),
+            name: i18n(`lib.prompts.projectDevTargetAccountPrompt.createNewSandboxOption`),
             value: {
                 targetAccountId: null,
                 createNestedAccount: true,
@@ -83,7 +77,7 @@ async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig)
             disabled: disabledMessage,
         },
         {
-            name: (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.chooseDefaultAccountOption`),
+            name: i18n(`lib.prompts.projectDevTargetAccountPrompt.chooseDefaultAccountOption`),
             value: {
                 targetAccountId: defaultAccountId,
                 createNestedAccount: false,
@@ -92,34 +86,34 @@ async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig)
     ];
     return selectTargetAccountPrompt(defaultAccountId, 'sandbox account', choices);
 }
-async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountConfig) {
-    const defaultAccountId = (0, config_1.getAccountId)(defaultAccountConfig.name);
+export async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountConfig) {
+    const defaultAccountId = getAccountId(defaultAccountConfig.name);
     let devTestAccountsResponse;
     try {
         if (defaultAccountId) {
-            const { data } = await (0, developerTestAccounts_1.fetchDeveloperTestAccounts)(defaultAccountId);
+            const { data } = await fetchDeveloperTestAccounts(defaultAccountId);
             devTestAccountsResponse = data;
         }
         else {
-            logger_1.logger.error((0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.noAccountId`));
-            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+            logger.error(i18n(`lib.prompts.projectDevTargetAccountPrompt.noAccountId`));
+            process.exit(EXIT_CODES.ERROR);
         }
     }
     catch (err) {
-        logger_1.logger.debug('Unable to fetch developer test account usage limits: ', err);
+        logger.debug('Unable to fetch developer test account usage limits: ', err);
     }
     let disabledMessage = false;
     if (devTestAccountsResponse &&
         devTestAccountsResponse.results.length >=
             devTestAccountsResponse.maxTestPortals) {
-        disabledMessage = (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.developerTestAccountLimit`, {
-            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
+        disabledMessage = i18n(`lib.prompts.projectDevTargetAccountPrompt.developerTestAccountLimit`, {
+            authCommand: uiCommandReference('hs auth'),
             limit: devTestAccountsResponse.maxTestPortals,
         });
     }
     const devTestAccounts = [];
     if (devTestAccountsResponse && devTestAccountsResponse.results) {
-        const accountIds = accounts.map(account => (0, getAccountIdentifier_1.getAccountIdentifier)(account));
+        const accountIds = accounts.map(account => getAccountIdentifier(account));
         devTestAccountsResponse.results.forEach(acct => {
             const inConfig = accountIds.includes(acct.id);
             devTestAccounts.push({
@@ -136,7 +130,7 @@ async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountCo
     const choices = [
         ...devTestAccounts,
         {
-            name: (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.createNewDeveloperTestAccountOption`),
+            name: i18n(`lib.prompts.projectDevTargetAccountPrompt.createNewDeveloperTestAccountOption`),
             value: {
                 targetAccountId: null,
                 createNestedAccount: true,
@@ -144,16 +138,16 @@ async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountCo
             disabled: disabledMessage,
         },
     ];
-    return selectTargetAccountPrompt(defaultAccountId, config_2.HUBSPOT_ACCOUNT_TYPE_STRINGS[config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST], choices);
+    return selectTargetAccountPrompt(defaultAccountId, HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST], choices);
 }
 async function selectTargetAccountPrompt(defaultAccountId, accountType, choices) {
     const accountId = defaultAccountId;
-    const { targetAccountInfo } = await (0, promptUtils_1.promptUser)([
+    const { targetAccountInfo } = await promptUser([
         {
             name: 'targetAccountInfo',
             type: 'list',
-            message: (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.promptMessage`, {
-                accountIdentifier: (0, ui_1.uiAccountDescription)(accountId),
+            message: i18n(`lib.prompts.projectDevTargetAccountPrompt.promptMessage`, {
+                accountIdentifier: uiAccountDescription(accountId),
                 accountType,
             }),
             choices,
@@ -161,12 +155,12 @@ async function selectTargetAccountPrompt(defaultAccountId, accountType, choices)
     ]);
     return targetAccountInfo;
 }
-async function confirmDefaultAccountPrompt(accountName, accountType) {
-    const { useDefaultAccount } = await (0, promptUtils_1.promptUser)([
+export async function confirmDefaultAccountPrompt(accountName, accountType) {
+    const { useDefaultAccount } = await promptUser([
         {
             name: 'useDefaultAccount',
             type: 'confirm',
-            message: (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.confirmDefaultAccount`, {
+            message: i18n(`lib.prompts.projectDevTargetAccountPrompt.confirmDefaultAccount`, {
                 accountName,
                 accountType,
             }),
@@ -174,12 +168,12 @@ async function confirmDefaultAccountPrompt(accountName, accountType) {
     ]);
     return useDefaultAccount;
 }
-async function confirmUseExistingDeveloperTestAccountPrompt(account) {
-    const { confirmUseExistingDeveloperTestAccount } = await (0, promptUtils_1.promptUser)([
+export async function confirmUseExistingDeveloperTestAccountPrompt(account) {
+    const { confirmUseExistingDeveloperTestAccount } = await promptUser([
         {
             name: 'confirmUseExistingDeveloperTestAccount',
             type: 'confirm',
-            message: (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.confirmUseExistingDeveloperTestAccount`, {
+            message: i18n(`lib.prompts.projectDevTargetAccountPrompt.confirmUseExistingDeveloperTestAccount`, {
                 accountName: getNonConfigDeveloperTestAccountName(account),
             }),
         },

package/lib/prompts/projectNameAndDestPrompt.d.ts

@@ -1,3 +1,3 @@
-import { PromptOptionsArg, ProjectNameAndDestPromptResponse } from './selectProjectTemplatePrompt';
+import { PromptOptionsArg, ProjectNameAndDestPromptResponse } from './selectProjectTemplatePrompt.js';
 export declare function projectNameAndDestPrompt(promptOptions: PromptOptionsArg): Promise<ProjectNameAndDestPromptResponse>;
 export declare function validateProjectDirectory(input?: string): string | boolean;

package/lib/prompts/projectNameAndDestPrompt.js

@@ -1,40 +1,33 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectNameAndDestPrompt = projectNameAndDestPrompt;
-exports.validateProjectDirectory = validateProjectDirectory;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const path_2 = require("@hubspot/local-dev-lib/path");
-const en_1 = require("../../lang/en");
-const promptUtils_1 = require("./promptUtils");
-const constants_1 = require("../constants");
-async function projectNameAndDestPrompt(promptOptions) {
-    const result = await (0, promptUtils_1.promptUser)([
+import fs from 'fs';
+import path from 'path';
+import { sanitizeFileName, getCwd, untildify, isValidPath, } from '@hubspot/local-dev-lib/path';
+import { lib } from '../../lang/en.js';
+import { promptUser } from './promptUtils.js';
+import { PROJECT_CONFIG_FILE } from '../constants.js';
+export async function projectNameAndDestPrompt(promptOptions) {
+    const result = await promptUser([
         {
             name: 'name',
-            message: en_1.lib.prompts.projectNameAndDestPrompt.enterName,
+            message: lib.prompts.projectNameAndDestPrompt.enterName,
             when: !promptOptions.name,
             validate: (input) => {
                 if (!input) {
-                    return en_1.lib.prompts.projectNameAndDestPrompt.errors.nameRequired;
+                    return lib.prompts.projectNameAndDestPrompt.errors.nameRequired;
                 }
                 return true;
             },
         },
         {
             name: 'dest',
-            message: en_1.lib.prompts.projectNameAndDestPrompt.enterDest,
+            message: lib.prompts.projectNameAndDestPrompt.enterDest,
             when: !promptOptions.dest,
-            default: answers => {
-                const projectName = (0, path_2.sanitizeFileName)(promptOptions.name || answers.name);
-                return path_1.default.resolve((0, path_2.getCwd)(), projectName);
+            default: (answers) => {
+                const projectName = sanitizeFileName(promptOptions.name || answers.name);
+                return path.resolve(getCwd(), projectName);
             },
             validate: validateProjectDirectory,
-            filter: input => {
-                return (0, path_2.untildify)(input);
+            filter: (input) => {
+                return untildify(input);
             },
         },
     ]);
@@ -46,15 +39,15 @@ async function projectNameAndDestPrompt(promptOptions) {
     }
     return result;
 }
-function validateProjectDirectory(input) {
+export function validateProjectDirectory(input) {
     if (!input) {
-        return en_1.lib.prompts.projectNameAndDestPrompt.errors.destRequired;
+        return lib.prompts.projectNameAndDestPrompt.errors.destRequired;
     }
-    if (fs_1.default.existsSync(path_1.default.resolve((0, path_2.getCwd)(), path_1.default.join(input, constants_1.PROJECT_CONFIG_FILE)))) {
-        return en_1.lib.prompts.projectNameAndDestPrompt.errors.invalidDest;
+    if (fs.existsSync(path.resolve(getCwd(), path.join(input, PROJECT_CONFIG_FILE)))) {
+        return lib.prompts.projectNameAndDestPrompt.errors.invalidDest;
     }
-    if (!(0, path_2.isValidPath)(input)) {
-        return en_1.lib.prompts.projectNameAndDestPrompt.errors.invalidCharacters;
+    if (!isValidPath(input)) {
+        return lib.prompts.projectNameAndDestPrompt.errors.invalidCharacters;
     }
     return true;
 }

package/lib/prompts/projectNamePrompt.js

@@ -1,27 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectNamePrompt = projectNamePrompt;
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
-const ensureProjectExists_1 = require("../projects/ensureProjectExists");
-const ui_1 = require("../ui");
-async function projectNamePrompt(accountId, options = {}) {
-    const result = await (0, promptUtils_1.promptUser)({
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
+import { ensureProjectExists } from '../projects/ensureProjectExists.js';
+import { uiAccountDescription } from '../ui/index.js';
+export async function projectNamePrompt(accountId, options = {}) {
+    const result = await promptUser({
         name: 'projectName',
-        message: (0, lang_1.i18n)(`lib.prompts.projectNamePrompt.enterName`),
+        message: i18n(`lib.prompts.projectNamePrompt.enterName`),
         when: !options.project,
         validate: async (val) => {
             if (typeof val !== 'string' || !val) {
-                return (0, lang_1.i18n)(`lib.prompts.projectNamePrompt.errors.invalidName`);
+                return i18n(`lib.prompts.projectNamePrompt.errors.invalidName`);
             }
-            const { projectExists } = await (0, ensureProjectExists_1.ensureProjectExists)(accountId, val, {
+            const { projectExists } = await ensureProjectExists(accountId, val, {
                 allowCreate: false,
                 noLogs: true,
             });
             if (!projectExists) {
-                return (0, lang_1.i18n)(`lib.prompts.projectNamePrompt.errors.projectDoesNotExist`, {
+                return i18n(`lib.prompts.projectNamePrompt.errors.projectDoesNotExist`, {
                     projectName: val,
-                    accountIdentifier: (0, ui_1.uiAccountDescription)(accountId),
+                    accountIdentifier: uiAccountDescription(accountId),
                 });
             }
             return true;

package/lib/prompts/projectsLogsPrompt.js

@@ -1,20 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectLogsPrompt = projectLogsPrompt;
-const lang_1 = require("../lang");
-const promptUtils_1 = require("./promptUtils");
-async function projectLogsPrompt({ functionChoices, promptOptions, projectName = '', }) {
+import { i18n } from '../lang.js';
+import { promptUser } from './promptUtils.js';
+export async function projectLogsPrompt({ functionChoices, promptOptions, projectName = '', }) {
     if (!functionChoices) {
         return {};
     }
     if (functionChoices.length === 1) {
         return { functionName: functionChoices[0] };
     }
-    return (0, promptUtils_1.promptUser)([
+    return promptUser([
         {
             name: 'functionName',
             type: 'list',
-            message: (0, lang_1.i18n)(`lib.prompts.projectLogsPrompt.functionName`, {
+            message: i18n(`lib.prompts.projectLogsPrompt.functionName`, {
                 projectName,
             }),
             when: () => (!promptOptions || !promptOptions.function) &&

package/lib/prompts/promptUtils.d.ts

@@ -1,5 +1,5 @@
 import { Separator as _Separator } from '@inquirer/prompts';
-import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts';
+import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts.js';
 export declare const Separator: _Separator;
 export declare function promptUser<T extends GenericPromptResponse>(config: PromptConfig<T> | PromptConfig<T>[]): Promise<T>;
 export declare function confirmPrompt(message: string, options?: {