@hubspot/cli 8.0.10-experimental.5 → 8.0.10-experimental.6

package/lib/prompts/accountNamePrompt.d.ts

@@ -1,11 +0,0 @@
-import { PromptConfig } from '../../types/Prompts.js';
-import { AccountType } from '@hubspot/local-dev-lib/types/Accounts';
-export type AccountNamePromptResponse = {
-    name: string;
-};
-export declare function getCliAccountNamePromptConfig(defaultName?: string): PromptConfig<AccountNamePromptResponse>;
-export declare function cliAccountNamePrompt(defaultName?: string): Promise<AccountNamePromptResponse>;
-export declare function hubspotAccountNamePrompt({ accountType, currentPortalCount, }: {
-    accountType: AccountType;
-    currentPortalCount?: number;
-}): Promise<AccountNamePromptResponse>;

package/lib/prompts/accountNamePrompt.js

@@ -1,64 +0,0 @@
-import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-export function getCliAccountNamePromptConfig(defaultName) {
-    return {
-        name: 'name',
-        message: lib.prompts.accountNamePrompt.enterAccountName,
-        default: defaultName,
-        validate(val) {
-            if (typeof val !== 'string') {
-                return lib.prompts.accountNamePrompt.errors.invalidName;
-            }
-            else if (!val.length) {
-                return lib.prompts.accountNamePrompt.errors.nameRequired;
-            }
-            else if (val.indexOf(' ') >= 0) {
-                return lib.prompts.accountNamePrompt.errors.spacesInName;
-            }
-            return getConfigAccountIfExists(val)
-                ? lib.prompts.accountNamePrompt.errors.accountNameExists(val)
-                : true;
-        },
-    };
-}
-export function cliAccountNamePrompt(defaultName) {
-    return promptUser(getCliAccountNamePromptConfig(defaultName));
-}
-export function hubspotAccountNamePrompt({ accountType, currentPortalCount = 0, }) {
-    const isDevelopmentSandbox = accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX;
-    const isSandbox = accountType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX ||
-        isDevelopmentSandbox;
-    const isDeveloperTestAccount = accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST;
-    let promptMessageString;
-    let defaultName;
-    if (isSandbox) {
-        promptMessageString = isDevelopmentSandbox
-            ? lib.prompts.accountNamePrompt.enterDevelopmentSandboxName
-            : lib.prompts.accountNamePrompt.enterStandardSandboxName;
-    }
-    else if (isDeveloperTestAccount) {
-        promptMessageString =
-            lib.prompts.accountNamePrompt.enterDeveloperTestAccountName;
-        defaultName = lib.prompts.accountNamePrompt.developerTestAccountDefaultName(currentPortalCount + 1);
-    }
-    return promptUser([
-        {
-            name: 'name',
-            message: promptMessageString,
-            validate(val) {
-                if (typeof val !== 'string') {
-                    return lib.prompts.accountNamePrompt.errors.invalidName;
-                }
-                else if (!val.trim().length) {
-                    return lib.prompts.accountNamePrompt.errors.nameRequired;
-                }
-                return getConfigAccountIfExists(val)
-                    ? lib.prompts.accountNamePrompt.errors.accountNameExists(val)
-                    : true;
-            },
-            default: defaultName,
-        },
-    ]);
-}

package/lib/prompts/accountsPrompt.d.ts

@@ -1,2 +0,0 @@
-export declare const AUTHENTICATE_NEW_ACCOUNT_VALUE = -1;
-export declare function selectAccountFromConfig(prompt?: string, includeAuthOption?: boolean): Promise<number>;

package/lib/prompts/accountsPrompt.js

@@ -1,33 +0,0 @@
-import { getConfigDefaultAccountIfExists, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
-import { promptUser } from './promptUtils.js';
-import { commands } from '../../lang/en.js';
-import { uiAccountDescription } from '../ui/index.js';
-export const AUTHENTICATE_NEW_ACCOUNT_VALUE = -1;
-function mapAccountChoices(portals) {
-    return (portals?.map(p => ({
-        name: uiAccountDescription(p.accountId, false),
-        value: p.accountId,
-    })) || []);
-}
-export async function selectAccountFromConfig(prompt = '', includeAuthOption = false) {
-    const accountsList = getAllConfigAccounts();
-    const defaultAccount = getConfigDefaultAccountIfExists();
-    const choices = mapAccountChoices(accountsList);
-    if (includeAuthOption) {
-        choices.push({
-            name: commands.account.subcommands.use.authenticateNewAccount,
-            value: AUTHENTICATE_NEW_ACCOUNT_VALUE,
-        });
-    }
-    const { default: selectedDefault } = await promptUser([
-        {
-            type: 'list',
-            name: 'default',
-            pageSize: 20,
-            message: prompt || commands.account.subcommands.use.promptMessage,
-            choices,
-            default: defaultAccount?.accountId ?? undefined,
-        },
-    ]);
-    return selectedDefault;
-}

package/lib/prompts/cmsFieldPrompt.d.ts

@@ -1 +0,0 @@
-export declare function fieldsJsPrompt(filePath: string, projectDir: string, skipFiles?: string[]): Promise<[string, string[]]>;

package/lib/prompts/cmsFieldPrompt.js

@@ -1,40 +0,0 @@
-import path from 'path';
-import fs from 'fs';
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-import { escapeRegExp } from '@hubspot/local-dev-lib/escapeRegExp';
-const FIELDS_FILES = ['fields.json', 'fields.js', 'fields.cjs', 'fields.mjs'];
-export async function fieldsJsPrompt(filePath, projectDir, skipFiles = []) {
-    const dirName = path.dirname(filePath);
-    // Get a list of all field files in the directory, resolve their absolute path, and remove the ones that we already skipped.
-    const fileChoices = fs
-        .readdirSync(dirName)
-        .filter(file => FIELDS_FILES.includes(file))
-        .map(file => path.resolve(dirName, file))
-        .filter(file => !skipFiles.includes(file));
-    if (!fileChoices.length)
-        return [filePath, []];
-    if (fileChoices.length === 1)
-        return [fileChoices[0], []];
-    // We get the directory above the project one so that relative paths are printed with the root of the project dir attached.
-    projectDir = projectDir.substring(0, projectDir.lastIndexOf('/'));
-    const projectDirRegex = new RegExp(`^${escapeRegExp(projectDir)}`);
-    const fileDir = path.dirname(fileChoices[0]).replace(projectDirRegex, '');
-    const selection = fileChoices.map(fileChoice => ({
-        name: fileChoice.replace(projectDirRegex, ''),
-        value: fileChoice,
-    }));
-    const promptVal = await promptUser([
-        {
-            message: lib.prompts.uploadPrompt.fieldsPrompt(fileDir),
-            type: 'list',
-            name: 'filePathChoice',
-            choices: selection,
-        },
-    ]);
-    const choice = promptVal.filePathChoice;
-    // Add the ones that were not picked to skip files array.
-    const notPicked = fileChoices.filter(item => item !== choice);
-    skipFiles.push(...notPicked);
-    return [choice, skipFiles];
-}

package/lib/prompts/confirmImportDataPrompt.d.ts

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

package/lib/prompts/confirmImportDataPrompt.js

@@ -1,12 +0,0 @@
-import { getConfigAccountById } 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 = getConfigAccountById(targetAccountId);
-    const { confirmImportData } = await promptUser({
-        type: 'confirm',
-        name: 'confirmImportData',
-        message: lib.prompts.confirmImportDataPrompt.message(dataFileNames, account),
-    });
-    return confirmImportData;
-}

package/lib/prompts/createApiSamplePrompt.d.ts

@@ -1,10 +0,0 @@
-import { ApiSampleConfig } from '../../types/Cms.js';
-type SampleTypePromptResponse = {
-    sampleType?: string;
-};
-type LanguagePromptResponse = {
-    sampleLanguage?: string;
-};
-type CreateApiSamplePromptResponse = SampleTypePromptResponse & LanguagePromptResponse;
-export declare function createApiSamplePrompt(samplesConfig: ApiSampleConfig): Promise<CreateApiSamplePromptResponse>;
-export {};

package/lib/prompts/createApiSamplePrompt.js

@@ -1,58 +0,0 @@
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-function getSampleTypesPrompt(choices) {
-    return {
-        type: 'rawlist',
-        name: 'sampleType',
-        message: lib.prompts.createApiSamplePrompt.selectApiSampleApp,
-        choices: choices.map(choice => ({
-            name: `${choice.name} - ${choice.description}`,
-            value: choice.id,
-        })),
-        validate: function (input) {
-            return new Promise(function (resolve, reject) {
-                if (input && input.length > 0) {
-                    resolve(true);
-                }
-                else {
-                    reject(lib.prompts.createApiSamplePrompt.errors.apiSampleAppRequired);
-                }
-            });
-        },
-    };
-}
-function getLanguagesPrompt(choices) {
-    return {
-        type: 'rawlist',
-        name: 'sampleLanguage',
-        message: lib.prompts.createApiSamplePrompt.selectLanguage,
-        choices: choices.map(choice => ({
-            name: choice,
-            value: choice,
-        })),
-        validate: function (input) {
-            return new Promise(function (resolve, reject) {
-                if (input && input.length > 0) {
-                    resolve(true);
-                }
-                reject(lib.prompts.createApiSamplePrompt.errors.languageRequired);
-            });
-        },
-    };
-}
-export async function createApiSamplePrompt(samplesConfig) {
-    try {
-        const { samples } = samplesConfig;
-        const sampleTypeAnswer = await promptUser(getSampleTypesPrompt(samples));
-        const chosenSample = samples.find(sample => sample.id === sampleTypeAnswer.sampleType);
-        const { languages } = chosenSample;
-        const languagesAnswer = await promptUser(getLanguagesPrompt(languages));
-        return {
-            ...sampleTypeAnswer,
-            ...languagesAnswer,
-        };
-    }
-    catch (e) {
-        return {};
-    }
-}

package/lib/prompts/createDeveloperTestAccountConfigPrompt.d.ts

@@ -1,25 +0,0 @@
-import { AccountLevel, DeveloperTestAccountConfig } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
-declare const hubs: {
-    MARKETING: string;
-    OPS: string;
-    SERVICE: string;
-    SALES: string;
-    CONTENT: string;
-    COMMERCE: string;
-};
-type HubName = keyof typeof hubs;
-export type HubConfig = {
-    hub: HubName;
-    tier: AccountLevel;
-};
-export declare function createDeveloperTestAccountConfigPrompt(args?: {
-    name?: string;
-    description?: string;
-    marketingLevel?: AccountLevel;
-    opsLevel?: AccountLevel;
-    serviceLevel?: AccountLevel;
-    salesLevel?: AccountLevel;
-    contentLevel?: AccountLevel;
-    commerceLevel?: AccountLevel;
-}, supportFlags?: boolean): Promise<DeveloperTestAccountConfig>;
-export {};

package/lib/prompts/createDeveloperTestAccountConfigPrompt.js

@@ -1,162 +0,0 @@
-import { Separator } from '@inquirer/prompts';
-import { lib } from '../../lang/en.js';
-import { promptUser } from './promptUtils.js';
-const hubs = {
-    MARKETING: 'marketingLevel',
-    OPS: 'opsLevel',
-    SERVICE: 'serviceLevel',
-    SALES: 'salesLevel',
-    CONTENT: 'contentLevel',
-    COMMERCE: 'commerceLevel',
-};
-const AccountTiers = {
-    FREE: 'FREE',
-    STARTER: 'STARTER',
-    PROFESSIONAL: 'PROFESSIONAL',
-    ENTERPRISE: 'ENTERPRISE',
-};
-const makeHubTiers = (hubKey, omitTiers) => {
-    const hubTypeKey = hubKey.toLowerCase();
-    const hubName = lib.prompts.createDeveloperTestAccountConfigPrompt.hubTypes[hubTypeKey];
-    return [
-        {
-            name: `${hubName} [${AccountTiers.FREE}]`,
-            value: { hub: hubKey, tier: AccountTiers.FREE },
-        },
-        {
-            name: `${hubName} [${AccountTiers.STARTER}]`,
-            value: { hub: hubKey, tier: AccountTiers.STARTER },
-        },
-        {
-            name: `${hubName} [${AccountTiers.PROFESSIONAL}]`,
-            value: { hub: hubKey, tier: AccountTiers.PROFESSIONAL },
-        },
-        {
-            name: `${hubName} [${AccountTiers.ENTERPRISE}]`,
-            value: { hub: hubKey, tier: AccountTiers.ENTERPRISE },
-        },
-    ].filter(tier => !omitTiers || !omitTiers.includes(tier.value.tier));
-};
-const TEST_ACCOUNT_TIERS = [
-    ...makeHubTiers('MARKETING'),
-    new Separator(),
-    ...makeHubTiers('OPS'),
-    new Separator(),
-    ...makeHubTiers('SERVICE'),
-    new Separator(),
-    ...makeHubTiers('SALES'),
-    new Separator(),
-    ...makeHubTiers('CONTENT'),
-    new Separator(),
-    ...makeHubTiers('COMMERCE', [AccountTiers.STARTER]),
-    new Separator(),
-];
-export async function createDeveloperTestAccountConfigPrompt(args = {}, supportFlags = true) {
-    const hasAnyTierLevels = !!(args.marketingLevel ||
-        args.opsLevel ||
-        args.serviceLevel ||
-        args.salesLevel ||
-        args.contentLevel ||
-        args.commerceLevel);
-    const result = await promptUser([
-        {
-            name: 'accountName',
-            message: lib.prompts.createDeveloperTestAccountConfigPrompt.namePrompt(supportFlags),
-            type: 'input',
-            when: !args.name,
-            validate: value => {
-                if (!value) {
-                    return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
-                        .nameRequired;
-                }
-                return true;
-            },
-        },
-        {
-            name: 'description',
-            message: lib.prompts.createDeveloperTestAccountConfigPrompt.descriptionPrompt(supportFlags),
-            type: 'input',
-            when: !args.description,
-        },
-    ]);
-    const accountName = args.name || result.accountName;
-    const description = args.description || result.description;
-    let accountLevels = {};
-    if (hasAnyTierLevels) {
-        accountLevels = {
-            marketingLevel: args.marketingLevel || AccountTiers.ENTERPRISE,
-            opsLevel: args.opsLevel || AccountTiers.ENTERPRISE,
-            serviceLevel: args.serviceLevel || AccountTiers.ENTERPRISE,
-            salesLevel: args.salesLevel || AccountTiers.ENTERPRISE,
-            contentLevel: args.contentLevel || AccountTiers.ENTERPRISE,
-            commerceLevel: args.commerceLevel || AccountTiers.ENTERPRISE,
-        };
-    }
-    else {
-        const tierChoiceResult = await promptUser({
-            name: 'useDefaultAccountLevels',
-            message: lib.prompts.createDeveloperTestAccountConfigPrompt
-                .useDefaultAccountLevelsPrompt.message,
-            type: 'list',
-            choices: [
-                {
-                    name: lib.prompts.createDeveloperTestAccountConfigPrompt
-                        .useDefaultAccountLevelsPrompt.default,
-                    value: 'default',
-                },
-                {
-                    name: lib.prompts.createDeveloperTestAccountConfigPrompt
-                        .useDefaultAccountLevelsPrompt.manual,
-                    value: 'manual',
-                },
-            ],
-        });
-        if (tierChoiceResult.useDefaultAccountLevels === 'default') {
-            accountLevels = {
-                marketingLevel: AccountTiers.ENTERPRISE,
-                opsLevel: AccountTiers.ENTERPRISE,
-                serviceLevel: AccountTiers.ENTERPRISE,
-                salesLevel: AccountTiers.ENTERPRISE,
-                contentLevel: AccountTiers.ENTERPRISE,
-                commerceLevel: AccountTiers.ENTERPRISE,
-            };
-        }
-        else {
-            const tierResult = await promptUser({
-                name: 'testAccountLevels',
-                message: lib.prompts.createDeveloperTestAccountConfigPrompt.tiersPrompt,
-                type: 'checkbox',
-                pageSize: 13,
-                choices: TEST_ACCOUNT_TIERS,
-                loop: false,
-                validate: choices => {
-                    if (choices?.length < Object.keys(hubs).length) {
-                        return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
-                            .allHubsRequired;
-                    }
-                    const hubMap = {};
-                    for (const choice of choices) {
-                        const { hub } = choice.value;
-                        if (hubMap[hub]) {
-                            return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
-                                .tiersError;
-                        }
-                        hubMap[hub] = true;
-                    }
-                    return true;
-                },
-            });
-            accountLevels = tierResult.testAccountLevels.reduce((acc, level) => {
-                const { hub: hubName, tier: hubTier } = level;
-                const hubLevel = hubs[hubName];
-                acc[hubLevel] = hubTier;
-                return acc;
-            }, {});
-        }
-    }
-    return {
-        accountName,
-        description,
-        ...accountLevels,
-    };
-}

package/lib/prompts/createFunctionPrompt.d.ts

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

package/lib/prompts/createFunctionPrompt.js

@@ -1,94 +0,0 @@
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-const FUNCTIONS_FOLDER_PROMPT = {
-    name: 'functionsFolder',
-    message: lib.prompts.createFunctionPrompt.enterFolder,
-    validate(val) {
-        if (typeof val !== 'string') {
-            return lib.prompts.createFunctionPrompt.errors.invalid;
-        }
-        else if (!val.length) {
-            return lib.prompts.createFunctionPrompt.errors.blank;
-        }
-        else if (val.indexOf(' ') >= 0) {
-            return lib.prompts.createFunctionPrompt.errors.space;
-        }
-        return true;
-    },
-};
-const FUNCTION_FILENAME_PROMPT = {
-    name: 'filename',
-    message: lib.prompts.createFunctionPrompt.enterFilename,
-    validate(val) {
-        if (typeof val !== 'string') {
-            return lib.prompts.createFunctionPrompt.errors.invalid;
-        }
-        else if (!val.length) {
-            return lib.prompts.createFunctionPrompt.errors.blank;
-        }
-        else if (val.indexOf(' ') >= 0) {
-            return lib.prompts.createFunctionPrompt.errors.space;
-        }
-        return true;
-    },
-};
-const ENDPOINT_METHOD_PROMPT = {
-    type: 'list',
-    name: 'endpointMethod',
-    message: lib.prompts.createFunctionPrompt.selectEndpointMethod,
-    default: 'GET',
-    choices: ['DELETE', 'GET', 'PATCH', 'POST', 'PUT'],
-};
-const ENDPOINT_PATH_PROMPT = {
-    name: 'endpointPath',
-    message: lib.prompts.createFunctionPrompt.enterEndpointPath,
-    validate(val) {
-        if (typeof val !== 'string') {
-            return lib.prompts.createFunctionPrompt.errors.invalid;
-        }
-        else if (!val.length) {
-            return lib.prompts.createFunctionPrompt.errors.blank;
-        }
-        else if (val.indexOf(' ') >= 0) {
-            return lib.prompts.createFunctionPrompt.errors.space;
-        }
-        return true;
-    },
-};
-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,10 +0,0 @@
-import { CreateArgs } from '../../types/Cms.js';
-type CreateModulePromptResponse = {
-    moduleLabel: string;
-    reactType: boolean;
-    contentTypes: string[];
-    global: boolean;
-    availableForNewContent: boolean;
-};
-export declare function createModulePrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateModulePromptResponse>;
-export {};

package/lib/prompts/createModulePrompt.js

@@ -1,116 +0,0 @@
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-const MODULE_LABEL_PROMPT = {
-    name: 'moduleLabel',
-    message: lib.prompts.createModulePrompt.enterLabel,
-    validate(val) {
-        if (typeof val !== 'string') {
-            return lib.prompts.createModulePrompt.errors.invalidLabel;
-        }
-        else if (!val.length) {
-            return lib.prompts.createModulePrompt.errors.labelRequired;
-        }
-        return true;
-    },
-};
-const REACT_TYPE_PROMPT = {
-    type: 'confirm',
-    name: 'reactType',
-    message: lib.prompts.createModulePrompt.selectReactType,
-    default: false,
-};
-const CONTENT_TYPES_PROMPT = {
-    type: 'checkbox',
-    name: 'contentTypes',
-    message: lib.prompts.createModulePrompt.selectContentType,
-    choices: [
-        { name: 'Any', value: 'ANY', checked: true },
-        { name: 'Landing page', value: 'LANDING_PAGE' },
-        { name: 'Site page', value: 'SITE_PAGE' },
-        { name: 'Blog post', value: 'BLOG_POST' },
-        { name: 'Blog listing', value: 'BLOG_LISTING' },
-        { name: 'Email', value: 'EMAIL' },
-        { name: 'Knowledge base', value: 'KNOWLEDGE_BASE' },
-        { name: 'Quote template', value: 'QUOTE_TEMPLATE' },
-        { name: 'Customer portal', value: 'CUSTOMER_PORTAL' },
-        { name: 'Web interactive', value: 'WEB_INTERACTIVE' },
-        { name: 'Subscription', value: 'SUBSCRIPTION' },
-        { name: 'Membership', value: 'MEMBERSHIP' },
-    ],
-    validate: (input) => {
-        return new Promise(function (resolve, reject) {
-            if (input.length > 0) {
-                resolve(true);
-            }
-            reject(lib.prompts.createModulePrompt.errors.contentTypeRequired);
-        });
-    },
-};
-const GLOBAL_PROMPT = {
-    type: 'confirm',
-    name: 'global',
-    message: lib.prompts.createModulePrompt.confirmGlobal,
-    default: false,
-};
-const AVAILABLE_FOR_NEW_CONTENT = {
-    type: 'confirm',
-    name: 'availableForNewContent',
-    message: lib.prompts.createModulePrompt.availableForNewContent,
-    default: true,
-};
-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,
-        CONTENT_TYPES_PROMPT,
-        GLOBAL_PROMPT,
-        AVAILABLE_FOR_NEW_CONTENT,
-    ]);
-}

package/lib/prompts/createTemplatePrompt.d.ts

@@ -1,6 +0,0 @@
-import { CreateArgs, TemplateType } from '../../types/Cms.js';
-interface CreateTemplatePromptResponse {
-    templateType: TemplateType;
-}
-export declare function createTemplatePrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateTemplatePromptResponse>;
-export {};