@hubspot/cli 7.7.1-experimental.0 → 7.7.2-experimental.0

package/lib/projects/localDev/LocalDevProcess.d.ts

@@ -1,27 +1,34 @@
 import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
 import LocalDevState from './LocalDevState';
 import LocalDevLogger from './LocalDevLogger';
-import { LocalDevStateConstructorOptions, LocalDevStateListener } from '../../../types/LocalDev';
+import { LocalDevStateConstructorOptions, LocalDevStateListener, LocalDevServerMessage } from '../../../types/LocalDev';
 declare class LocalDevProcess {
     private state;
     private _logger;
     private devServerManager;
     constructor(options: LocalDevStateConstructorOptions);
     get projectDir(): string;
+    get projectId(): number;
+    get projectName(): string;
+    get targetProjectAccountId(): number;
+    get targetTestingAccountId(): number;
     get projectNodes(): {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     };
     get logger(): LocalDevLogger;
+    get configFilesUpdatedSinceLastUpload(): Set<string>;
     private setupDevServers;
     private startDevServers;
     private cleanupDevServers;
     private compareLocalProjectToDeployed;
     private projectConfigValidForUpload;
-    handleFileChange(filePath: string, event: string): void;
+    private updateProjectNodes;
+    handleFileChange(filePath: string, event: string): Promise<void>;
+    handleConfigFileChange(filePath: string, event: string): Promise<void>;
     start(): Promise<void>;
     stop(showProgress?: boolean): Promise<void>;
-    updateProjectNodes(): Promise<void>;
-    uploadProject(): Promise<void>;
-    addStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
+    uploadProject(): Promise<boolean>;
+    addStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>, callOnInit?: boolean): void;
+    sendDevServerMessage(message: LocalDevServerMessage): void;
 }
 export default LocalDevProcess;

package/lib/projects/localDev/LocalDevProcess.js

@@ -28,12 +28,27 @@ class LocalDevProcess {
     get projectDir() {
         return this.state.projectDir;
     }
+    get projectId() {
+        return this.state.projectId;
+    }
+    get projectName() {
+        return this.state.projectName;
+    }
+    get targetProjectAccountId() {
+        return this.state.targetProjectAccountId;
+    }
+    get targetTestingAccountId() {
+        return this.state.targetTestingAccountId;
+    }
     get projectNodes() {
         return this.state.projectNodes;
     }
     get logger() {
         return this._logger;
     }
+    get configFilesUpdatedSinceLastUpload() {
+        return this.state.configFilesUpdatedSinceLastUpload;
+    }
     async setupDevServers() {
         try {
             await this.devServerManager.setup();
@@ -90,7 +105,19 @@ class LocalDevProcess {
         });
         return true;
     }
-    handleFileChange(filePath, event) {
+    async updateProjectNodes() {
+        const intermediateRepresentation = await (0, project_parsing_lib_1.translateForLocalDev)({
+            projectSourceDir: path_1.default.join(this.state.projectDir, this.state.projectConfig.srcDir),
+            platformVersion: this.state.projectConfig.platformVersion,
+            accountId: this.state.targetProjectAccountId,
+        }, {
+            configFilesUpdatedSinceLastUpload: this.state.configFilesUpdatedSinceLastUpload,
+        });
+        this.state.projectNodes =
+            intermediateRepresentation.intermediateNodesIndexedByUid;
+    }
+    async handleFileChange(filePath, event) {
+        await this.updateProjectNodes();
         try {
             this.devServerManager.fileChange({ filePath, event });
         }
@@ -98,6 +125,13 @@ class LocalDevProcess {
             this.logger.fileChangeError(e);
         }
     }
+    async handleConfigFileChange(filePath, event) {
+        if (event === 'add' || event === 'change') {
+            this.state.addUpdatedConfigFileUpdatedSinceLastUpload(filePath);
+        }
+        await this.updateProjectNodes();
+        this.logger.uploadWarning();
+    }
     async start() {
         this.logger.resetSpinnies();
         // Local dev currently relies on the existence of a deployed build in the target account
@@ -132,21 +166,12 @@ class LocalDevProcess {
         }
         process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
     }
-    async updateProjectNodes() {
-        const intermediateRepresentation = await (0, project_parsing_lib_1.translateForLocalDev)({
-            projectSourceDir: path_1.default.join(this.state.projectDir, this.state.projectConfig.srcDir),
-            platformVersion: this.state.projectConfig.platformVersion,
-            accountId: this.state.targetProjectAccountId,
-        });
-        this.state.projectNodes =
-            intermediateRepresentation.intermediateNodesIndexedByUid;
-    }
     async uploadProject() {
         this.logger.uploadInitiated();
         const isUploadable = await this.projectConfigValidForUpload();
         if (!isUploadable) {
             this.logger.projectConfigMismatch();
-            return;
+            return false;
         }
         const { uploadError } = await (0, upload_1.handleProjectUpload)({
             accountId: this.state.targetProjectAccountId,
@@ -158,14 +183,19 @@ class LocalDevProcess {
         });
         if (uploadError) {
             this.logger.uploadError(uploadError);
+            return false;
         }
-        else {
-            this.logger.uploadSuccess();
-            this.logger.clearUploadWarnings();
-        }
+        this.state.resetConfigFilesUpdatedSinceLastUpload();
+        this.updateProjectNodes();
+        this.logger.uploadSuccess();
+        this.logger.clearUploadWarnings();
+        return true;
+    }
+    addStateListener(key, listener, callOnInit = false) {
+        this.state.addListener(key, listener, callOnInit);
     }
-    addStateListener(key, listener) {
-        this.state.addListener(key, listener);
+    sendDevServerMessage(message) {
+        this.state.devServerMessage = message;
     }
 }
 exports.default = LocalDevProcess;

package/lib/projects/localDev/LocalDevState.d.ts

@@ -2,26 +2,31 @@ import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
 import { ProjectConfig } from '../../../types/Projects';
-import { LocalDevStateConstructorOptions, LocalDevStateListener } from '../../../types/LocalDev';
+import { LocalDevStateConstructorOptions, LocalDevStateListener, AppLocalDevData, LocalDevServerMessage } from '../../../types/LocalDev';
 declare class LocalDevState {
     private _targetProjectAccountId;
     private _targetTestingAccountId;
     private _projectConfig;
     private _projectDir;
     private _projectId;
+    private _projectName;
     private _debug;
     private _deployedBuild?;
     private _isGithubLinked;
     private _projectNodes;
     private _env;
     private _listeners;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }: LocalDevStateConstructorOptions);
+    private _configFilesUpdatedSinceLastUpload;
+    private _appData;
+    private _devServerMessage;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }: LocalDevStateConstructorOptions);
     private runListeners;
     get targetProjectAccountId(): number;
     get targetTestingAccountId(): number;
     get projectConfig(): ProjectConfig;
     get projectDir(): string;
     get projectId(): number;
+    get projectName(): string;
     get debug(): boolean;
     get deployedBuild(): Build | undefined;
     get isGithubLinked(): boolean;
@@ -32,6 +37,14 @@ declare class LocalDevState {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     });
     get env(): Environment;
-    addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
+    get configFilesUpdatedSinceLastUpload(): Set<string>;
+    addUpdatedConfigFileUpdatedSinceLastUpload(filePath: string): void;
+    resetConfigFilesUpdatedSinceLastUpload(): void;
+    get appData(): Record<string, AppLocalDevData>;
+    getAppDataByUid(uid: string): AppLocalDevData | undefined;
+    setAppDataForUid(uid: string, appData: AppLocalDevData): void;
+    get devServerMessage(): string;
+    set devServerMessage(message: LocalDevServerMessage);
+    addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>, callOnInit?: boolean): void;
 }
 export default LocalDevState;

package/lib/projects/localDev/LocalDevState.js

@@ -1,28 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
 class LocalDevState {
     _targetProjectAccountId;
     _targetTestingAccountId;
     _projectConfig;
     _projectDir;
     _projectId;
+    _projectName;
     _debug;
     _deployedBuild;
     _isGithubLinked;
     _projectNodes;
     _env;
     _listeners;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }) {
+    _configFilesUpdatedSinceLastUpload;
+    _appData;
+    _devServerMessage;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }) {
         this._targetProjectAccountId = targetProjectAccountId;
         this._targetTestingAccountId = targetTestingAccountId;
         this._projectConfig = projectConfig;
         this._projectDir = projectDir;
         this._projectId = projectId;
+        this._projectName = projectName;
         this._debug = debug || false;
         this._deployedBuild = deployedBuild;
         this._isGithubLinked = isGithubLinked;
         this._projectNodes = initialProjectNodes;
         this._env = env;
+        this._configFilesUpdatedSinceLastUpload = new Set();
+        this._appData = {};
+        this._devServerMessage = constants_1.LOCAL_DEV_SERVER_MESSAGE_TYPES.INITIAL;
         this._listeners = {};
     }
     runListeners(key) {
@@ -47,6 +56,9 @@ class LocalDevState {
     get projectId() {
         return this._projectId;
     }
+    get projectName() {
+        return this._projectName;
+    }
     get debug() {
         return this._debug;
     }
@@ -68,11 +80,40 @@ class LocalDevState {
     get env() {
         return this._env;
     }
-    addListener(key, listener) {
+    get configFilesUpdatedSinceLastUpload() {
+        return this._configFilesUpdatedSinceLastUpload;
+    }
+    addUpdatedConfigFileUpdatedSinceLastUpload(filePath) {
+        this._configFilesUpdatedSinceLastUpload.add(filePath);
+    }
+    resetConfigFilesUpdatedSinceLastUpload() {
+        this._configFilesUpdatedSinceLastUpload.clear();
+    }
+    get appData() {
+        return { ...this._appData };
+    }
+    getAppDataByUid(uid) {
+        return { ...this._appData[uid] };
+    }
+    setAppDataForUid(uid, appData) {
+        this._appData[uid] = appData;
+        this.runListeners('appData');
+    }
+    get devServerMessage() {
+        return this._devServerMessage;
+    }
+    set devServerMessage(message) {
+        this._devServerMessage = message;
+        this.runListeners('devServerMessage');
+    }
+    addListener(key, listener, callOnInit = false) {
         if (!this._listeners[key]) {
             this._listeners[key] = [];
         }
         this._listeners[key].push(listener);
+        if (callOnInit) {
+            listener(this[key]);
+        }
     }
 }
 exports.default = LocalDevState;

package/lib/projects/localDev/LocalDevWatcher.js

@@ -19,14 +19,11 @@ class LocalDevWatcher {
         this.localDevProcess = localDevProcess;
         this.watcher = null;
     }
-    async handleWatchEvent(filePath, event, configPaths) {
-        await this.localDevProcess.updateProjectNodes();
+    handleWatchEvent(filePath, event, configPaths) {
         if (configPaths.includes(filePath)) {
-            this.localDevProcess.logger.uploadWarning();
-        }
-        else {
-            this.localDevProcess.handleFileChange(filePath, event);
+            return this.localDevProcess.handleConfigFileChange(filePath, event);
         }
+        return this.localDevProcess.handleFileChange(filePath, event);
     }
     start() {
         this.watcher = chokidar_1.default.watch(this.localDevProcess.projectDir, {

package/lib/projects/localDev/LocalDevWebsocketServer.d.ts

@@ -4,12 +4,15 @@ declare class LocalDevWebsocketServer {
     private _websocket?;
     private debug?;
     private localDevProcess;
+    private ALLOWED_ORIGINS;
     constructor(localDevProcess: LocalDevProcess, debug?: boolean);
     private websocket;
     private log;
     private logError;
     private sendMessage;
+    private handleUpload;
     private setupMessageHandlers;
+    private sendProjectData;
     private setupStateListeners;
     start(): Promise<void>;
     shutdown(): void;

package/lib/projects/localDev/LocalDevWebsocketServer.js

@@ -12,6 +12,12 @@ class LocalDevWebsocketServer {
     _websocket;
     debug;
     localDevProcess;
+    ALLOWED_ORIGINS = [
+        'https://hubspot.com',
+        'https://hubspotqa.com',
+        'https://local.hubspot.com',
+        'https://local.hubspotqa.com',
+    ];
     constructor(localDevProcess, debug) {
         this.localDevProcess = localDevProcess;
         this.debug = debug;
@@ -35,6 +41,19 @@ class LocalDevWebsocketServer {
     sendMessage(message) {
         this.websocket().send(JSON.stringify(message));
     }
+    async handleUpload() {
+        const uploadSuccess = await this.localDevProcess.uploadProject();
+        if (uploadSuccess) {
+            this.sendMessage({
+                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_SUCCESS,
+            });
+        }
+        else {
+            this.sendMessage({
+                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPLOAD_FAILURE,
+            });
+        }
+    }
     setupMessageHandlers() {
         this.websocket().on('message', data => {
             try {
@@ -44,12 +63,8 @@ class LocalDevWebsocketServer {
                     return;
                 }
                 switch (message.type) {
-                    case constants_1.LOCAL_DEV_UI_WEBSOCKET_MESSAGE_TYPES.UPLOAD:
-                        this.localDevProcess.uploadProject();
-                        break;
-                    case constants_1.LOCAL_DEV_UI_WEBSOCKET_MESSAGE_TYPES.INSTALL_DEPS:
-                        break;
-                    case constants_1.LOCAL_DEV_UI_WEBSOCKET_MESSAGE_TYPES.APP_INSTALLED:
+                    case constants_1.LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD:
+                        this.handleUpload();
                         break;
                     default:
                         this.logError(en_1.lib.LocalDevWebsocketServer.errors.unknownMessageType(message.type));
@@ -60,13 +75,30 @@ class LocalDevWebsocketServer {
             }
         });
     }
+    sendProjectData() {
+        this.sendMessage({
+            type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
+            data: {
+                projectName: this.localDevProcess.projectName,
+                projectId: this.localDevProcess.projectId,
+                targetProjectAccountId: this.localDevProcess.targetProjectAccountId,
+                targetTestingAccountId: this.localDevProcess.targetTestingAccountId,
+            },
+        });
+    }
     setupStateListeners() {
         this.localDevProcess.addStateListener('projectNodes', nodes => {
             this.sendMessage({
-                type: constants_1.LOCAL_DEV_UI_WEBSOCKET_MESSAGE_TYPES.UPDATE_PROJECT_NODES,
+                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
                 data: nodes,
             });
-        });
+        }, true);
+        this.localDevProcess.addStateListener('appData', appData => {
+            this.sendMessage({
+                type: constants_1.LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_APP_DATA,
+                data: appData,
+            });
+        }, true);
     }
     async start() {
         const portManagerIsRunning = await (0, portManager_1.isPortManagerServerRunning)();
@@ -77,10 +109,17 @@ class LocalDevWebsocketServer {
         const port = portData[SERVER_INSTANCE_ID];
         this.server = new ws_1.WebSocketServer({ port });
         this.log(en_1.lib.LocalDevWebsocketServer.logs.startup(port));
-        this.server.on('connection', ws => {
+        this.server.on('connection', (ws, req) => {
+            const origin = req.headers.origin;
+            if (!origin || !this.ALLOWED_ORIGINS.includes(origin)) {
+                ws.close(1008, en_1.lib.LocalDevWebsocketServer.errors.originNotAllowed(origin));
+                return;
+            }
             this._websocket = ws;
+            this.sendProjectData();
             this.setupMessageHandlers();
             this.setupStateListeners();
+            this.localDevProcess.sendDevServerMessage(constants_1.LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
         });
     }
     shutdown() {

package/lib/prompts/createProjectPrompt.d.ts

@@ -1,19 +1,28 @@
-import { ProjectTemplate } from '../../types/Projects';
-type CreateProjectPromptResponseWithTemplate = {
+import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplate } from '../../types/Projects';
+export type CreateProjectPromptResponse = {
+    name: string;
+    dest: string;
+    projectTemplate?: ProjectTemplate;
+    componentTemplates?: ComponentTemplate[];
+};
+type CreateProjectPromptResponseProjectTemplate = {
     name: string;
     dest: string;
     projectTemplate: ProjectTemplate;
+    componentTemplates: undefined;
 };
-type CreateProjectPromptResponseWithoutTemplate = {
+type CreateProjectPromptResponseComponentTemplates = {
     name: string;
     dest: string;
     projectTemplate?: undefined;
+    componentTemplates?: ComponentTemplate[];
 };
 type PromptOptionsArg = {
     name?: string;
     dest?: string;
     template?: string;
+    features?: string[];
 };
-export declare function createProjectPrompt(promptOptions: PromptOptionsArg, projectTemplates: ProjectTemplate[]): Promise<CreateProjectPromptResponseWithTemplate>;
-export declare function createProjectPrompt(promptOptions: PromptOptionsArg, projectTemplates?: undefined): Promise<CreateProjectPromptResponseWithoutTemplate>;
+export declare function createProjectPrompt(promptOptions: PromptOptionsArg, projectTemplates?: ProjectTemplate[], componentTemplates?: undefined): Promise<CreateProjectPromptResponseProjectTemplate>;
+export declare function createProjectPrompt(promptOptions: PromptOptionsArg, projectTemplates?: undefined, componentTemplates?: ComponentTemplateChoice[]): Promise<CreateProjectPromptResponseComponentTemplates>;
 export {};

package/lib/prompts/createProjectPrompt.js

@@ -8,43 +8,58 @@ const fs_1 = __importDefault(require("fs"));
 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");
 const constants_1 = require("../constants");
+const en_1 = require("../../lang/en");
 function validateProjectDirectory(input) {
     if (!input) {
-        return (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.errors.destRequired`);
+        return en_1.lib.prompts.createProjectPrompt.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 (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.errors.invalidDest`);
+        return en_1.lib.prompts.createProjectPrompt.errors.invalidDest;
     }
     if (!(0, path_2.isValidPath)(input)) {
-        return (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.errors.invalidCharacters`);
+        return en_1.lib.prompts.createProjectPrompt.errors.invalidCharacters;
     }
     return true;
 }
 function findTemplateByNameOrLabel(projectTemplates, templateNameOrLabel) {
     return projectTemplates.find(t => t.name === templateNameOrLabel || t.label === templateNameOrLabel);
 }
-async function createProjectPrompt(promptOptions, projectTemplates) {
+async function createProjectPrompt(promptOptions, projectTemplates, componentTemplates) {
     const createProjectFromTemplate = !!projectTemplates && projectTemplates.length > 0;
+    const createProjectFromComponents = Array.isArray(componentTemplates) && componentTemplates?.length > 0;
+    const selectedComponents = [];
+    if (createProjectFromComponents && promptOptions.features) {
+        componentTemplates.forEach(template => {
+            if (!template.value) {
+                return;
+            }
+            if (promptOptions.features?.includes(template.value.type)) {
+                if (template.disabled) {
+                    throw new Error(`Cannot create project with template '${template.value.type}'. Reasons: ${template.disabled}`);
+                }
+                selectedComponents.push(template.value);
+            }
+        });
+    }
     const providedTemplateIsValid = createProjectFromTemplate &&
         !!promptOptions.template &&
         !!findTemplateByNameOrLabel(projectTemplates, promptOptions.template);
     const result = await (0, promptUtils_1.promptUser)([
         {
             name: 'name',
-            message: (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.enterName`),
+            message: en_1.lib.prompts.createProjectPrompt.enterName,
             when: !promptOptions.name,
             validate: (input) => {
                 if (!input) {
-                    return (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.errors.nameRequired`);
+                    return en_1.lib.prompts.createProjectPrompt.errors.nameRequired;
                 }
                 return true;
             },
         },
         {
             name: 'dest',
-            message: (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.enterDest`),
+            message: en_1.lib.prompts.createProjectPrompt.enterDest,
             when: !promptOptions.dest,
             default: answers => {
                 const projectName = (0, path_2.sanitizeFileName)(promptOptions.name || answers.name);
@@ -59,10 +74,8 @@ async function createProjectPrompt(promptOptions, projectTemplates) {
             name: 'projectTemplate',
             message: () => {
                 return promptOptions.template && !providedTemplateIsValid
-                    ? (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.errors.invalidTemplate`, {
-                        template: promptOptions.template,
-                    })
-                    : (0, lang_1.i18n)(`lib.prompts.createProjectPrompt.selectTemplate`);
+                    ? en_1.lib.prompts.createProjectPrompt.errors.invalidTemplate(promptOptions.template)
+                    : en_1.lib.prompts.createProjectPrompt.selectTemplate;
             },
             when: createProjectFromTemplate && !providedTemplateIsValid,
             type: 'list',
@@ -75,6 +88,13 @@ async function createProjectPrompt(promptOptions, projectTemplates) {
                 })
                 : undefined,
         },
+        {
+            name: 'componentTemplates',
+            message: '[--features] Which features would you like your app to include?',
+            when: createProjectFromComponents && selectedComponents.length === 0,
+            type: 'checkbox',
+            choices: componentTemplates,
+        },
     ]);
     if (!result.name) {
         result.name = promptOptions.name;
@@ -82,12 +102,15 @@ async function createProjectPrompt(promptOptions, projectTemplates) {
     if (!result.dest) {
         result.dest = promptOptions.dest;
     }
+    if (!result.componentTemplates) {
+        result.componentTemplates = selectedComponents;
+    }
     if (providedTemplateIsValid) {
         result.projectTemplate = findTemplateByNameOrLabel(projectTemplates, promptOptions.template);
     }
     if (projectTemplates && projectTemplates.length > 0) {
         if (!result.projectTemplate) {
-            throw new Error((0, lang_1.i18n)(`lib.prompts.createProjectPrompt.errors.projectTemplateRequired`));
+            throw new Error(en_1.lib.prompts.createProjectPrompt.errors.projectTemplateRequired);
         }
         return result;
     }

package/lib/prompts/projectAddPrompt.d.ts

@@ -1,10 +1,14 @@
-import { ComponentTemplate } from '../../types/Projects';
+import { ComponentTemplate, ComponentTemplateChoice } from '../../types/Projects';
 type ProjectAddPromptResponse = {
     componentTemplate: ComponentTemplate;
     name: string;
 };
+type ProjectAddPromptResponseV3 = {
+    componentTemplate: ComponentTemplate[];
+};
 export declare function projectAddPrompt(components: ComponentTemplate[], promptOptions?: {
     name?: string;
     type?: string;
 }): Promise<ProjectAddPromptResponse>;
+export declare function projectAddPromptV3(components: ComponentTemplateChoice[], selectedFeatures: string[] | undefined): Promise<ProjectAddPromptResponseV3>;
 export {};

package/lib/prompts/projectAddPrompt.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectAddPrompt = projectAddPrompt;
+exports.projectAddPromptV3 = projectAddPromptV3;
 const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
+const en_1 = require("../../lang/en");
 function findComponentByPathOrLabel(components, componentPathOrLabel) {
     return components.find(c => c.path === componentPathOrLabel || c.label === componentPathOrLabel);
 }
@@ -14,10 +15,8 @@ async function projectAddPrompt(components, promptOptions = {}) {
             name: 'componentTemplate',
             message: () => {
                 return promptOptions.type && !providedTypeIsValid
-                    ? (0, lang_1.i18n)(`lib.prompts.projectAddPrompt.errors.invalidType`, {
-                        type: promptOptions.type,
-                    })
-                    : (0, lang_1.i18n)(`lib.prompts.projectAddPrompt.selectType`);
+                    ? en_1.lib.prompts.projectAddPrompt.errors.invalidType(promptOptions.type)
+                    : en_1.lib.prompts.projectAddPrompt.selectType;
             },
             when: !providedTypeIsValid,
             type: 'list',
@@ -30,11 +29,11 @@ async function projectAddPrompt(components, promptOptions = {}) {
         },
         {
             name: 'name',
-            message: (0, lang_1.i18n)(`lib.prompts.projectAddPrompt.enterName`),
+            message: en_1.lib.prompts.projectAddPrompt.enterName,
             when: !promptOptions.name,
             validate: (input) => {
                 if (!input) {
-                    return (0, lang_1.i18n)(`lib.prompts.projectAddPrompt.errors.nameRequired`);
+                    return en_1.lib.prompts.projectAddPrompt.errors.nameRequired;
                 }
                 return true;
             },
@@ -48,3 +47,32 @@ async function projectAddPrompt(components, promptOptions = {}) {
     }
     return result;
 }
+async function projectAddPromptV3(components, selectedFeatures) {
+    const selectedComponents = [];
+    if (selectedFeatures) {
+        components.forEach(template => {
+            if (!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));
+                }
+                selectedComponents.push(template.value);
+            }
+        });
+    }
+    const result = await (0, promptUtils_1.promptUser)([
+        {
+            name: 'componentTemplate',
+            message: en_1.lib.prompts.projectAddPrompt.selectType,
+            when: selectedComponents.length === 0,
+            type: 'checkbox',
+            choices: components,
+        },
+    ]);
+    if (!result.componentTemplate) {
+        result.componentTemplate = selectedComponents;
+    }
+    return result;
+}