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

package/lib/prompts/projectNamePrompt.js

@@ -1,24 +1,27 @@
-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({
+"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)({
         name: 'projectName',
-        message: i18n(`lib.prompts.projectNamePrompt.enterName`),
+        message: (0, lang_1.i18n)(`lib.prompts.projectNamePrompt.enterName`),
         when: !options.project,
         validate: async (val) => {
             if (typeof val !== 'string' || !val) {
-                return i18n(`lib.prompts.projectNamePrompt.errors.invalidName`);
+                return (0, lang_1.i18n)(`lib.prompts.projectNamePrompt.errors.invalidName`);
             }
-            const { projectExists } = await ensureProjectExists(accountId, val, {
+            const { projectExists } = await (0, ensureProjectExists_1.ensureProjectExists)(accountId, val, {
                 allowCreate: false,
                 noLogs: true,
             });
             if (!projectExists) {
-                return i18n(`lib.prompts.projectNamePrompt.errors.projectDoesNotExist`, {
+                return (0, lang_1.i18n)(`lib.prompts.projectNamePrompt.errors.projectDoesNotExist`, {
                     projectName: val,
-                    accountIdentifier: uiAccountDescription(accountId),
+                    accountIdentifier: (0, ui_1.uiAccountDescription)(accountId),
                 });
             }
             return true;

package/lib/prompts/projectsLogsPrompt.js

@@ -1,17 +1,20 @@
-import { i18n } from '../lang.js';
-import { promptUser } from './promptUtils.js';
-export async function projectLogsPrompt({ functionChoices, promptOptions, projectName = '', }) {
+"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 = '', }) {
     if (!functionChoices) {
         return {};
     }
     if (functionChoices.length === 1) {
         return { functionName: functionChoices[0] };
     }
-    return promptUser([
+    return (0, promptUtils_1.promptUser)([
         {
             name: 'functionName',
             type: 'list',
-            message: i18n(`lib.prompts.projectLogsPrompt.functionName`, {
+            message: (0, lang_1.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.js';
+import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts';
 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?: {

package/lib/prompts/promptUtils.js

@@ -1,11 +1,22 @@
-import { confirm, Separator as _Separator, select, input, checkbox, password, number, } from '@inquirer/prompts';
-export const Separator = new _Separator();
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Separator = void 0;
+exports.promptUser = promptUser;
+exports.confirmPrompt = confirmPrompt;
+exports.listPrompt = listPrompt;
+exports.inputPrompt = inputPrompt;
+const prompts_1 = require("@inquirer/prompts");
+const exitCodes_1 = require("../enums/exitCodes");
+exports.Separator = new prompts_1.Separator();
+function isUserCancellationError(error) {
+    return error instanceof Error && error.name === 'ExitPromptError';
+}
 function mapPromptChoicesToChoices(choices) {
     return (choices?.map(choice => {
         if (typeof choice === 'string') {
             return { value: choice, name: choice };
         }
-        else if (choice instanceof _Separator) {
+        else if (choice instanceof prompts_1.Separator) {
             return choice;
         }
         return {
@@ -16,78 +27,84 @@ function mapPromptChoicesToChoices(choices) {
         };
     }) || []);
 }
-function handleArrayConfig(config) {
-    return (async () => {
-        const result = {};
-        for (const prompt of config) {
-            if (prompt.when !== undefined) {
-                const shouldPrompt = typeof prompt.when === 'function'
-                    ? prompt.when()
-                    : (prompt.when ?? true);
-                if (!shouldPrompt) {
-                    continue;
-                }
-            }
-            if (typeof prompt.message === 'function') {
-                prompt.message = prompt.message(result);
+async function handleArrayConfig(config) {
+    const result = {};
+    for (const prompt of config) {
+        if (prompt.when !== undefined) {
+            const shouldPrompt = typeof prompt.when === 'function'
+                ? prompt.when()
+                : (prompt.when ?? true);
+            if (!shouldPrompt) {
+                continue;
             }
-            // Pass the accumulated results to each prompt
-            const promptWithAnswers = {
-                ...prompt,
-                default: typeof prompt.default === 'function'
-                    ? (answers) => {
-                        const mergedAnswers = { ...answers, ...result };
-                        return prompt.default(mergedAnswers);
-                    }
-                    : prompt.default,
-            };
-            const response = await promptUser(promptWithAnswers);
-            Object.assign(result, response);
         }
-        return result;
-    })();
-}
-export function promptUser(config) {
-    if (Array.isArray(config)) {
-        return handleArrayConfig(config);
+        if (typeof prompt.message === 'function') {
+            prompt.message = prompt.message(result);
+        }
+        // Pass the accumulated results to each prompt
+        const promptWithAnswers = {
+            ...prompt,
+            default: typeof prompt.default === 'function'
+                ? (answers) => {
+                    const mergedAnswers = { ...answers, ...result };
+                    return prompt.default(mergedAnswers);
+                }
+                : prompt.default,
+        };
+        const response = await promptUser(promptWithAnswers);
+        Object.assign(result, response);
     }
-    else {
-        if (config.when !== undefined) {
-            const shouldPrompt = typeof config.when === 'function'
-                ? config.when()
-                : (config.when ?? true);
-            if (!shouldPrompt) {
-                return Promise.resolve({});
+    return result;
+}
+async function promptUser(config) {
+    try {
+        if (Array.isArray(config)) {
+            return await handleArrayConfig(config);
+        }
+        else {
+            if (config.when !== undefined) {
+                const shouldPrompt = typeof config.when === 'function'
+                    ? config.when()
+                    : (config.when ?? true);
+                if (!shouldPrompt) {
+                    return Promise.resolve({});
+                }
             }
         }
+        switch (config.type) {
+            case 'list':
+                return await handleSelectPrompt(config);
+            case 'input':
+                return await handleInputPrompt(config);
+            case 'confirm':
+                return await handleConfirmPrompt(config);
+            case 'checkbox':
+                return await handleCheckboxPrompt(config);
+            case 'password':
+                return await handlePasswordPrompt(config);
+            case 'number':
+                return await handleNumberPrompt(config);
+            case 'rawlist':
+                return await handleRawListPrompt(config);
+            default:
+                return await handleInputPrompt(config);
+        }
     }
-    switch (config.type) {
-        case 'list':
-            return handleSelectPrompt(config);
-        case 'input':
-            return handleInputPrompt(config);
-        case 'confirm':
-            return handleConfirmPrompt(config);
-        case 'checkbox':
-            return handleCheckboxPrompt(config);
-        case 'password':
-            return handlePasswordPrompt(config);
-        case 'number':
-            return handleNumberPrompt(config);
-        case 'rawlist':
-            return handleRawListPrompt(config);
-        default:
-            return handleInputPrompt(config);
+    catch (error) {
+        if (isUserCancellationError(error)) {
+            process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+        }
+        throw error;
     }
 }
 function handleRawListPrompt(config) {
     const choices = mapPromptChoicesToChoices(config.choices);
     choices.map((choice, index) => {
-        if (!(choice instanceof _Separator)) {
+        if (!(choice instanceof prompts_1.Separator)) {
             choice.name = `${index + 1}) ${choice.name}`;
         }
     });
-    return select({
+    return (0, prompts_1.select)({
         message: config.message,
         choices: choices,
         pageSize: config.pageSize,
@@ -95,14 +112,14 @@ function handleRawListPrompt(config) {
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleNumberPrompt(config) {
-    return number({
+    return (0, prompts_1.number)({
         message: config.message,
         default: config.default,
         validate: config.validate,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handlePasswordPrompt(config) {
-    return password({
+    return (0, prompts_1.password)({
         message: config.message,
         mask: '*',
         validate: config.validate,
@@ -110,7 +127,7 @@ function handlePasswordPrompt(config) {
 }
 function handleCheckboxPrompt(config) {
     const choices = mapPromptChoicesToChoices(config.choices);
-    return checkbox({
+    return (0, prompts_1.checkbox)({
         message: config.message,
         choices: choices,
         pageSize: config.pageSize,
@@ -123,7 +140,7 @@ function handleConfirmPrompt(config) {
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleInputPrompt(config) {
-    return input({
+    return (0, prompts_1.input)({
         message: config.message,
         default: config.default,
         validate: config.validate,
@@ -132,22 +149,22 @@ function handleInputPrompt(config) {
 }
 function handleSelectPrompt(config) {
     const choices = mapPromptChoicesToChoices(config.choices);
-    return select({
+    return (0, prompts_1.select)({
         message: config.message,
         choices: choices,
         default: config.default,
         pageSize: config.pageSize,
     }).then(resp => ({ [config.name]: resp }));
 }
-export async function confirmPrompt(message, options = {}) {
+async function confirmPrompt(message, options = {}) {
     const { defaultAnswer = true } = options;
-    const choice = await confirm({
+    const choice = await (0, prompts_1.confirm)({
         message,
         default: defaultAnswer,
     });
     return choice;
 }
-export async function listPrompt(message, { choices, when, defaultAnswer, validate, }) {
+async function listPrompt(message, { choices, when, defaultAnswer, validate, }) {
     const { choice } = await promptUser({
         name: 'choice',
         type: 'list',
@@ -159,7 +176,7 @@ export async function listPrompt(message, { choices, when, defaultAnswer, valida
     });
     return choice;
 }
-export async function inputPrompt(message, { when, validate, defaultAnswer, } = {}) {
+async function inputPrompt(message, { when, validate, defaultAnswer, } = {}) {
     const { input } = await promptUser({
         name: 'input',
         type: 'input',

package/lib/prompts/sandboxesPrompt.d.ts

@@ -1,4 +1,4 @@
-import { SandboxAccountType } from '../../types/sandboxes.js';
+import { SandboxAccountType } from '../../types/Sandboxes';
 type SandboxTypePromptResponse = {
     type: SandboxAccountType;
 };

package/lib/prompts/sandboxesPrompt.js

@@ -1,64 +1,68 @@
-import { promptUser } from './promptUtils.js';
-import { i18n } from '../lang.js';
-import { uiAccountDescription } from '../ui/index.js';
-import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
-import { isSandbox } from '../accountTypes.js';
-import { getConfigDefaultAccount, getConfigAccounts, } from '@hubspot/local-dev-lib/config';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sandboxTypePrompt = sandboxTypePrompt;
+exports.deleteSandboxPrompt = deleteSandboxPrompt;
+const promptUtils_1 = require("./promptUtils");
+const lang_1 = require("../lang");
+const ui_1 = require("../ui");
+const config_1 = require("@hubspot/local-dev-lib/constants/config");
+const getAccountIdentifier_1 = require("@hubspot/local-dev-lib/config/getAccountIdentifier");
+const accountTypes_1 = require("../accountTypes");
+const config_2 = require("@hubspot/local-dev-lib/config");
 function mapSandboxAccountChoices(portals) {
     return (portals
-        ?.filter(p => isSandbox(p))
+        ?.filter(p => (0, accountTypes_1.isSandbox)(p))
         .map(p => ({
-        name: uiAccountDescription(getAccountIdentifier(p), false),
-        value: p.name || getAccountIdentifier(p),
+        name: (0, ui_1.uiAccountDescription)((0, getAccountIdentifier_1.getAccountIdentifier)(p), false),
+        value: p.name || (0, getAccountIdentifier_1.getAccountIdentifier)(p),
     })) || []);
 }
 function mapNonSandboxAccountChoices(portals) {
     return (portals
-        ?.filter(p => !isSandbox(p))
+        ?.filter(p => !(0, accountTypes_1.isSandbox)(p))
         .map(p => ({
-        name: `${p.name} (${getAccountIdentifier(p)})`,
-        value: p.name || getAccountIdentifier(p),
+        name: `${p.name} (${(0, getAccountIdentifier_1.getAccountIdentifier)(p)})`,
+        value: p.name || (0, getAccountIdentifier_1.getAccountIdentifier)(p),
     })) || []);
 }
-export async function sandboxTypePrompt() {
-    return promptUser([
+async function sandboxTypePrompt() {
+    return (0, promptUtils_1.promptUser)([
         {
             name: 'type',
-            message: i18n(`lib.prompts.sandboxesPrompt.type.message`),
+            message: (0, lang_1.i18n)(`lib.prompts.sandboxesPrompt.type.message`),
             type: 'list',
             choices: [
                 {
-                    name: i18n(`lib.prompts.sandboxesPrompt.type.developer`),
-                    value: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                    name: (0, lang_1.i18n)(`lib.prompts.sandboxesPrompt.type.developer`),
+                    value: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
                 },
                 {
-                    name: i18n(`lib.prompts.sandboxesPrompt.type.standard`),
-                    value: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+                    name: (0, lang_1.i18n)(`lib.prompts.sandboxesPrompt.type.standard`),
+                    value: config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
                 },
             ],
-            default: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+            default: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
         },
     ]);
 }
-export function deleteSandboxPrompt(promptParentAccount = false) {
-    const accountsList = getConfigAccounts();
+function deleteSandboxPrompt(promptParentAccount = false) {
+    const accountsList = (0, config_2.getConfigAccounts)();
     const choices = promptParentAccount
         ? mapNonSandboxAccountChoices(accountsList)
         : mapSandboxAccountChoices(accountsList);
     if (!choices.length) {
         return Promise.resolve(undefined);
     }
-    return promptUser([
+    return (0, promptUtils_1.promptUser)([
         {
             name: 'account',
-            message: i18n(promptParentAccount
+            message: (0, lang_1.i18n)(promptParentAccount
                 ? `lib.prompts.sandboxesPrompt.selectParentAccountName`
                 : `lib.prompts.sandboxesPrompt.selectAccountName`),
             type: 'list',
             pageSize: 20,
             choices,
-            default: getConfigDefaultAccount(),
+            default: (0, config_2.getConfigDefaultAccount)(),
         },
     ]);
 }

package/lib/prompts/secretPrompt.js

@@ -1,26 +1,31 @@
-import { promptUser } from './promptUtils.js';
-import { i18n } from '../lang.js';
-export function secretValuePrompt() {
-    return promptUser([
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secretValuePrompt = secretValuePrompt;
+exports.secretNamePrompt = secretNamePrompt;
+exports.secretListPrompt = secretListPrompt;
+const promptUtils_1 = require("./promptUtils");
+const lang_1 = require("../lang");
+function secretValuePrompt() {
+    return (0, promptUtils_1.promptUser)([
         {
             name: 'secretValue',
             type: 'password',
             mask: '*',
-            message: i18n(`lib.prompts.secretPrompt.enterValue`),
+            message: (0, lang_1.i18n)(`lib.prompts.secretPrompt.enterValue`),
         },
     ]);
 }
-export function secretNamePrompt() {
-    return promptUser([
+function secretNamePrompt() {
+    return (0, promptUtils_1.promptUser)([
         {
             name: 'secretName',
             type: 'input',
-            message: i18n(`lib.prompts.secretPrompt.enterName`),
+            message: (0, lang_1.i18n)(`lib.prompts.secretPrompt.enterName`),
         },
     ]);
 }
-export function secretListPrompt(secrets, message) {
-    return promptUser([
+function secretListPrompt(secrets, message) {
+    return (0, promptUtils_1.promptUser)([
         {
             name: 'secretToModify',
             type: 'list',

package/lib/prompts/selectAppPrompt.js

@@ -1,21 +1,24 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
-import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
-import { debugError } from '../errorHandlers/index.js';
-import { lib } from '../../lang/en.js';
-import { listPrompt } from '../prompts/promptUtils.js';
-export async function selectAppPrompt(accountId, appId) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectAppPrompt = selectAppPrompt;
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const appsDev_1 = require("@hubspot/local-dev-lib/api/appsDev");
+const index_1 = require("../errorHandlers/index");
+const en_1 = require("../../lang/en");
+const promptUtils_1 = require("../prompts/promptUtils");
+async function selectAppPrompt(accountId, appId) {
     let availableApps = [];
     try {
-        const appsResponse = await fetchPublicAppsForPortal(accountId);
+        const appsResponse = await (0, appsDev_1.fetchPublicAppsForPortal)(accountId);
         if (appsResponse.data.results) {
             availableApps = appsResponse.data.results;
         }
     }
     catch (err) {
-        debugError(err);
+        (0, index_1.debugError)(err);
     }
     if (availableApps.length === 0) {
-        logger.error(lib.prompts.selectAppPrompt.errors.noApps);
+        logger_1.logger.error(en_1.lib.prompts.selectAppPrompt.errors.noApps);
         return null;
     }
     if (appId) {
@@ -24,10 +27,10 @@ export async function selectAppPrompt(accountId, appId) {
             return targetApp;
         }
         else {
-            logger.error(lib.prompts.selectAppPrompt.errors.invalidAppId);
+            logger_1.logger.error(en_1.lib.prompts.selectAppPrompt.errors.invalidAppId);
         }
     }
-    const appPromptValue = await listPrompt(lib.prompts.selectAppPrompt.selectAppId, {
+    const appPromptValue = await (0, promptUtils_1.listPrompt)(en_1.lib.prompts.selectAppPrompt.selectAppId, {
         choices: availableApps.map(app => ({
             name: `${app.name} (${app.id})`,
             value: app,

package/lib/prompts/selectHubDBTablePrompt.js

@@ -1,38 +1,44 @@
-import fs from 'fs';
-import { promptUser } from './promptUtils.js';
-import { i18n } from '../lang.js';
-import { debugError } from '../errorHandlers/index.js';
-import { logger } from '@hubspot/local-dev-lib/logger';
-import { fetchTables } from '@hubspot/local-dev-lib/api/hubdb';
-import { EXIT_CODES } from '../enums/exitCodes.js';
-import { isValidPath, untildify } from '@hubspot/local-dev-lib/path';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectHubDBTablePrompt = selectHubDBTablePrompt;
+const fs_1 = __importDefault(require("fs"));
+const promptUtils_1 = require("./promptUtils");
+const lang_1 = require("../lang");
+const index_1 = require("../errorHandlers/index");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const hubdb_1 = require("@hubspot/local-dev-lib/api/hubdb");
+const exitCodes_1 = require("../enums/exitCodes");
+const path_1 = require("@hubspot/local-dev-lib/path");
 async function fetchHubDBOptions(accountId) {
     try {
-        const { data: { results: tables }, } = await fetchTables(accountId);
+        const { data: { results: tables }, } = await (0, hubdb_1.fetchTables)(accountId);
         if (tables.length === 0) {
-            logger.log(i18n(`lib.prompts.selectHubDBTablePrompt.errors.noTables`, {
+            logger_1.logger.log((0, lang_1.i18n)(`lib.prompts.selectHubDBTablePrompt.errors.noTables`, {
                 accountId,
             }));
-            process.exit(EXIT_CODES.SUCCESS);
+            process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
         }
         return tables;
     }
     catch (error) {
-        debugError(error, { accountId });
-        logger.error(i18n(`lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables`, {
+        (0, index_1.debugError)(error, { accountId });
+        logger_1.logger.error((0, lang_1.i18n)(`lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables`, {
             accountId,
         }));
-        process.exit(EXIT_CODES.ERROR);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
-export async function selectHubDBTablePrompt({ accountId, options, skipDestPrompt = true, }) {
+async function selectHubDBTablePrompt({ accountId, options, skipDestPrompt = true, }) {
     const hubdbTables = (await fetchHubDBOptions(accountId)) || [];
     const id = options.tableId?.toString();
     const isValidTable = options.tableId && hubdbTables.find(table => table.id === id);
-    return promptUser([
+    return (0, promptUtils_1.promptUser)([
         {
             name: 'tableId',
-            message: i18n(`lib.prompts.selectHubDBTablePrompt.selectTable`),
+            message: (0, lang_1.i18n)(`lib.prompts.selectHubDBTablePrompt.selectTable`),
             when: !id && !isValidTable,
             type: 'list',
             choices: hubdbTables.map(table => {
@@ -44,22 +50,22 @@ export async function selectHubDBTablePrompt({ accountId, options, skipDestPromp
         },
         {
             name: 'dest',
-            message: i18n(`lib.prompts.selectHubDBTablePrompt.enterDest`),
+            message: (0, lang_1.i18n)(`lib.prompts.selectHubDBTablePrompt.enterDest`),
             when: !options.dest && !skipDestPrompt,
             validate: (input) => {
                 if (!input) {
-                    return i18n(`lib.prompts.selectHubDBTablePrompt.errors.destRequired`);
+                    return (0, lang_1.i18n)(`lib.prompts.selectHubDBTablePrompt.errors.destRequired`);
                 }
-                if (fs.existsSync(input)) {
-                    return i18n(`lib.prompts.selectHubDBTablePrompt.errors.invalidDest`);
+                if (fs_1.default.existsSync(input)) {
+                    return (0, lang_1.i18n)(`lib.prompts.selectHubDBTablePrompt.errors.invalidDest`);
                 }
-                if (!isValidPath(input)) {
-                    return i18n(`lib.prompts.selectHubDBTablePrompt.errors.invalidCharacters`);
+                if (!(0, path_1.isValidPath)(input)) {
+                    return (0, lang_1.i18n)(`lib.prompts.selectHubDBTablePrompt.errors.invalidCharacters`);
                 }
                 return true;
             },
             filter: (input) => {
-                return untildify(input);
+                return (0, path_1.untildify)(input);
             },
         },
     ]);

package/lib/prompts/selectProjectTemplatePrompt.d.ts

@@ -1,5 +1,5 @@
 import { Separator } from '@inquirer/prompts';
-import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplate } from '../../types/Projects.js';
+import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplate } from '../../types/Projects';
 export type SelectProjectTemplatePromptResponse = {
     projectTemplate?: ProjectTemplate;
     componentTemplates?: ComponentTemplate[];