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

package/lib/prompts/personalAccessKeyPrompt.js

@@ -1,42 +1,49 @@
-import open from 'open';
-import { OAUTH_SCOPES, DEFAULT_OAUTH_SCOPES, } from '@hubspot/local-dev-lib/constants/auth';
-import { deleteEmptyConfigFile } from '@hubspot/local-dev-lib/config';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { logger } from '@hubspot/local-dev-lib/logger';
-import { promptUser } from './promptUtils.js';
-import { getCliAccountNamePromptConfig, } from './accountNamePrompt.js';
-import { uiInfoSection } from '../ui/index.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
-import { lib } from '../../lang/en.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAUTH_FLOW = void 0;
+exports.personalAccessKeyPrompt = personalAccessKeyPrompt;
+const open_1 = __importDefault(require("open"));
+const auth_1 = require("@hubspot/local-dev-lib/constants/auth");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const urls_1 = require("@hubspot/local-dev-lib/urls");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const promptUtils_1 = require("./promptUtils");
+const accountNamePrompt_1 = require("./accountNamePrompt");
+const ui_1 = require("../ui");
+const exitCodes_1 = require("../enums/exitCodes");
+const en_1 = require("../../lang/en");
 /**
  * Displays notification to user that we are about to open the browser,
  * then opens their browser to the personal-access-key shortlink
  */
-export async function personalAccessKeyPrompt({ env, account, }) {
-    const websiteOrigin = getHubSpotWebsiteOrigin(env);
+async function personalAccessKeyPrompt({ env, account, }) {
+    const websiteOrigin = (0, urls_1.getHubSpotWebsiteOrigin)(env);
     let url = `${websiteOrigin}/l/personal-access-key`;
     if (process.env.BROWSER !== 'none') {
-        uiInfoSection(lib.prompts.personalAccessKeyPrompt.personalAccessKeySetupTitle, () => {
-            logger.log(lib.prompts.personalAccessKeyPrompt.personalAccessKeyBrowserOpenPrep);
+        (0, ui_1.uiInfoSection)(en_1.lib.prompts.personalAccessKeyPrompt.personalAccessKeySetupTitle, () => {
+            logger_1.logger.log(en_1.lib.prompts.personalAccessKeyPrompt.personalAccessKeyBrowserOpenPrep);
         });
         if (account) {
             url = `${websiteOrigin}/personal-access-key/${account}`;
         }
-        const { personalAccessKeyBrowserOpenPrep: choice } = await promptUser([
+        const { personalAccessKeyBrowserOpenPrep: choice } = await (0, promptUtils_1.promptUser)([
             PERSONAL_ACCESS_KEY_BROWSER_OPEN_PREP,
         ]);
         if (!choice) {
-            deleteEmptyConfigFile();
-            process.exit(EXIT_CODES.SUCCESS);
+            (0, config_1.deleteEmptyConfigFile)();
+            process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
         }
         if (choice ===
-            lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices
+            en_1.lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices
                 .OPEN_BROWSER) {
-            open(url, { url: true });
-            logger.log(lib.prompts.personalAccessKeyPrompt.logs.openingWebBrowser(url));
+            (0, open_1.default)(url, { url: true });
+            logger_1.logger.log(en_1.lib.prompts.personalAccessKeyPrompt.logs.openingWebBrowser(url));
         }
     }
-    const { personalAccessKey } = await promptUser(PERSONAL_ACCESS_KEY);
+    const { personalAccessKey } = await (0, promptUtils_1.promptUser)(PERSONAL_ACCESS_KEY);
     return {
         personalAccessKey,
         env,
@@ -44,24 +51,24 @@ export async function personalAccessKeyPrompt({ env, account, }) {
 }
 const ACCOUNT_ID = {
     name: 'accountId',
-    message: lib.prompts.personalAccessKeyPrompt.enterAccountId,
+    message: en_1.lib.prompts.personalAccessKeyPrompt.enterAccountId,
     type: 'number',
     validate(val) {
         if (!Number.isNaN(val) && val !== undefined && val > 0) {
             return true;
         }
-        return lib.prompts.personalAccessKeyPrompt.errors.invalidAccountId;
+        return en_1.lib.prompts.personalAccessKeyPrompt.errors.invalidAccountId;
     },
 };
 const CLIENT_ID = {
     name: 'clientId',
-    message: lib.prompts.personalAccessKeyPrompt.enterClientId,
+    message: en_1.lib.prompts.personalAccessKeyPrompt.enterClientId,
     validate(val) {
         if (typeof val !== 'string') {
-            return lib.prompts.personalAccessKeyPrompt.errors.invalidOauthClientId;
+            return en_1.lib.prompts.personalAccessKeyPrompt.errors.invalidOauthClientId;
         }
         else if (val.length !== 36) {
-            return lib.prompts.personalAccessKeyPrompt.errors
+            return en_1.lib.prompts.personalAccessKeyPrompt.errors
                 .invalidOauthClientIdLength;
         }
         return true;
@@ -69,18 +76,18 @@ const CLIENT_ID = {
 };
 const CLIENT_SECRET = {
     name: 'clientSecret',
-    message: lib.prompts.personalAccessKeyPrompt.enterClientSecret,
+    message: en_1.lib.prompts.personalAccessKeyPrompt.enterClientSecret,
     validate(val) {
         if (typeof val !== 'string') {
-            return lib.prompts.personalAccessKeyPrompt.errors
+            return en_1.lib.prompts.personalAccessKeyPrompt.errors
                 .invalidOauthClientSecret;
         }
         else if (val.length !== 36) {
-            return lib.prompts.personalAccessKeyPrompt.errors
+            return en_1.lib.prompts.personalAccessKeyPrompt.errors
                 .invalidOauthClientSecretLength;
         }
         else if (val[0] === '*') {
-            return lib.prompts.personalAccessKeyPrompt.errors
+            return en_1.lib.prompts.personalAccessKeyPrompt.errors
                 .invalidOauthClientSecretCopy;
         }
         return true;
@@ -90,13 +97,13 @@ const PERSONAL_ACCESS_KEY_BROWSER_OPEN_PREP = {
     name: 'personalAccessKeyBrowserOpenPrep',
     type: 'list',
     message: 'Choose your preferred method of authentication',
-    choices: Object.values(lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices),
-    default: lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices
+    choices: Object.values(en_1.lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices),
+    default: en_1.lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices
         .OPEN_BROWSER,
 };
 const PERSONAL_ACCESS_KEY = {
     name: 'personalAccessKey',
-    message: lib.prompts.personalAccessKeyPrompt.enterPersonalAccessKey,
+    message: en_1.lib.prompts.personalAccessKeyPrompt.enterPersonalAccessKey,
     transformer: (val) => {
         if (!val)
             return val;
@@ -108,11 +115,11 @@ const PERSONAL_ACCESS_KEY = {
     },
     validate(val) {
         if (!val || typeof val !== 'string') {
-            return lib.prompts.personalAccessKeyPrompt.errors
+            return en_1.lib.prompts.personalAccessKeyPrompt.errors
                 .invalidPersonalAccessKey;
         }
         else if (val[0] === '•') {
-            return lib.prompts.personalAccessKeyPrompt.errors
+            return en_1.lib.prompts.personalAccessKeyPrompt.errors
                 .invalidPersonalAccessKeyCopy;
         }
         return true;
@@ -121,12 +128,12 @@ const PERSONAL_ACCESS_KEY = {
 const SCOPES = {
     type: 'checkbox',
     name: 'scopes',
-    message: lib.prompts.personalAccessKeyPrompt.selectScopes,
-    default: [...DEFAULT_OAUTH_SCOPES],
-    choices: [...OAUTH_SCOPES],
+    message: en_1.lib.prompts.personalAccessKeyPrompt.selectScopes,
+    default: [...auth_1.DEFAULT_OAUTH_SCOPES],
+    choices: [...auth_1.OAUTH_SCOPES],
 };
-export const OAUTH_FLOW = [
-    getCliAccountNamePromptConfig(),
+exports.OAUTH_FLOW = [
+    (0, accountNamePrompt_1.getCliAccountNamePromptConfig)(),
     ACCOUNT_ID,
     CLIENT_ID,
     CLIENT_SECRET,

package/lib/prompts/previewPrompt.js

@@ -1,43 +1,50 @@
-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([
+"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)([
         {
             name: 'src',
-            message: i18n(`lib.prompts.previewPrompt.enterSrc`),
+            message: (0, lang_1.i18n)(`lib.prompts.previewPrompt.enterSrc`),
             when: !promptOptions.src,
             default: '.',
             validate: (input) => {
                 if (!input) {
-                    return i18n(`lib.prompts.previewPrompt.errors.srcRequired`);
+                    return (0, lang_1.i18n)(`lib.prompts.previewPrompt.errors.srcRequired`);
                 }
                 return true;
             },
         },
         {
             name: 'dest',
-            message: i18n(`lib.prompts.previewPrompt.enterDest`),
+            message: (0, lang_1.i18n)(`lib.prompts.previewPrompt.enterDest`),
             when: !promptOptions.dest,
-            default: path.basename(getCwd()),
+            default: path_1.default.basename((0, path_2.getCwd)()),
             validate: (input) => {
                 if (!input) {
-                    return i18n(`lib.prompts.previewPrompt.errors.destRequired`);
+                    return (0, lang_1.i18n)(`lib.prompts.previewPrompt.errors.destRequired`);
                 }
                 return true;
             },
         },
     ]);
 }
-export async function previewProjectPrompt(themeComponents) {
-    return promptUser([
+async function previewProjectPrompt(themeComponents) {
+    return (0, promptUtils_1.promptUser)([
         {
             name: 'themeComponentPath',
-            message: i18n(`lib.prompts.previewPrompt.themeProjectSelect`),
+            message: (0, lang_1.i18n)(`lib.prompts.previewPrompt.themeProjectSelect`),
             type: 'list',
             choices: themeComponents.map(t => {
-                const themeName = path.basename(t.path);
+                const themeName = path_1.default.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.js';
+import { ComponentTemplate, ComponentTemplateChoice } from '../../types/Projects';
 type ProjectAddPromptResponse = {
     componentTemplate: ComponentTemplate;
     name: string;

package/lib/prompts/projectAddPrompt.js

@@ -1,19 +1,23 @@
-import { Separator } from '@inquirer/prompts';
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
+"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");
 function findComponentByPathOrLabel(components, componentPathOrLabel) {
     return components.find(c => c.path === componentPathOrLabel || c.label === componentPathOrLabel);
 }
-export async function projectAddPrompt(components, promptOptions = {}) {
+async function projectAddPrompt(components, promptOptions = {}) {
     const providedTypeIsValid = !!promptOptions.type &&
         !!findComponentByPathOrLabel(components, promptOptions.type);
-    const result = await promptUser([
+    const result = await (0, promptUtils_1.promptUser)([
         {
             name: 'componentTemplate',
             message: () => {
                 return promptOptions.type && !providedTypeIsValid
-                    ? lib.prompts.projectAddPrompt.errors.invalidType(promptOptions.type)
-                    : lib.prompts.projectAddPrompt.selectType;
+                    ? en_1.lib.prompts.projectAddPrompt.errors.invalidType(promptOptions.type)
+                    : en_1.lib.prompts.projectAddPrompt.selectType;
             },
             when: !providedTypeIsValid,
             type: 'list',
@@ -26,11 +30,11 @@ export async function projectAddPrompt(components, promptOptions = {}) {
         },
         {
             name: 'name',
-            message: lib.prompts.projectAddPrompt.enterName,
+            message: en_1.lib.prompts.projectAddPrompt.enterName,
             when: !promptOptions.name,
             validate: (input) => {
                 if (!input) {
-                    return lib.prompts.projectAddPrompt.errors.nameRequired;
+                    return en_1.lib.prompts.projectAddPrompt.errors.nameRequired;
                 }
                 return true;
             },
@@ -44,25 +48,25 @@ export async function projectAddPrompt(components, promptOptions = {}) {
     }
     return result;
 }
-export async function projectAddPromptV3(components, selectedFeatures) {
+async function projectAddPromptV3(components, selectedFeatures) {
     const selectedComponents = [];
     if (selectedFeatures) {
         components.forEach(template => {
-            if (template instanceof Separator || !template.value) {
+            if (template instanceof prompts_1.Separator || !template.value) {
                 return;
             }
             if (selectedFeatures?.includes(template.value.type)) {
                 if (template.disabled) {
-                    throw new Error(lib.prompts.projectAddPrompt.errors.cannotAddFeature(template.value.type, template.disabled));
+                    throw new Error(en_1.lib.prompts.projectAddPrompt.errors.cannotAddFeature(template.value.type, template.disabled));
                 }
                 selectedComponents.push(template.value);
             }
         });
     }
-    const result = await promptUser([
+    const result = await (0, promptUtils_1.promptUser)([
         {
             name: 'componentTemplate',
-            message: lib.prompts.projectAddPrompt.selectType,
+            message: en_1.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.js';
+import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts';
 export type ProjectDevTargetAccountPromptResponse = {
     targetAccountId: number | null;
     createNestedAccount: boolean;

package/lib/prompts/projectDevTargetAccountPrompt.js

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

package/lib/prompts/projectNameAndDestPrompt.d.ts

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

package/lib/prompts/projectNameAndDestPrompt.js

@@ -1,33 +1,40 @@
-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([
+"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)([
         {
             name: 'name',
-            message: lib.prompts.projectNameAndDestPrompt.enterName,
+            message: en_1.lib.prompts.projectNameAndDestPrompt.enterName,
             when: !promptOptions.name,
             validate: (input) => {
                 if (!input) {
-                    return lib.prompts.projectNameAndDestPrompt.errors.nameRequired;
+                    return en_1.lib.prompts.projectNameAndDestPrompt.errors.nameRequired;
                 }
                 return true;
             },
         },
         {
             name: 'dest',
-            message: lib.prompts.projectNameAndDestPrompt.enterDest,
+            message: en_1.lib.prompts.projectNameAndDestPrompt.enterDest,
             when: !promptOptions.dest,
-            default: (answers) => {
-                const projectName = sanitizeFileName(promptOptions.name || answers.name);
-                return path.resolve(getCwd(), projectName);
+            default: answers => {
+                const projectName = (0, path_2.sanitizeFileName)(promptOptions.name || answers.name);
+                return path_1.default.resolve((0, path_2.getCwd)(), projectName);
             },
             validate: validateProjectDirectory,
-            filter: (input) => {
-                return untildify(input);
+            filter: input => {
+                return (0, path_2.untildify)(input);
             },
         },
     ]);
@@ -39,15 +46,15 @@ export async function projectNameAndDestPrompt(promptOptions) {
     }
     return result;
 }
-export function validateProjectDirectory(input) {
+function validateProjectDirectory(input) {
     if (!input) {
-        return lib.prompts.projectNameAndDestPrompt.errors.destRequired;
+        return en_1.lib.prompts.projectNameAndDestPrompt.errors.destRequired;
     }
-    if (fs.existsSync(path.resolve(getCwd(), path.join(input, PROJECT_CONFIG_FILE)))) {
-        return lib.prompts.projectNameAndDestPrompt.errors.invalidDest;
+    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 (!isValidPath(input)) {
-        return lib.prompts.projectNameAndDestPrompt.errors.invalidCharacters;
+    if (!(0, path_2.isValidPath)(input)) {
+        return en_1.lib.prompts.projectNameAndDestPrompt.errors.invalidCharacters;
     }
     return true;
 }