@hubspot/cli 7.5.11-experimental.0 → 7.6.0-beta.1

package/lib/projects/add/legacyAddComponent.d.ts

@@ -0,0 +1,5 @@
+import { ProjectConfig } from '../../../types/Projects';
+export declare function legacyAddComponent(args: {
+    name?: string;
+    type?: string;
+}, projectDir: string, projectConfig: ProjectConfig): Promise<void>;

package/lib/projects/add/legacyAddComponent.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyAddComponent = legacyAddComponent;
+const Projects_1 = require("../../../types/Projects");
+const structure_1 = require("../structure");
+const errorHandlers_1 = require("../../errorHandlers");
+const en_1 = require("../../../lang/en");
+const legacy_1 = require("../create/legacy");
+const projectAddPrompt_1 = require("../../prompts/projectAddPrompt");
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../../constants");
+const github_1 = require("@hubspot/local-dev-lib/github");
+const logger_1 = require("../../ui/logger");
+async function legacyAddComponent(args, projectDir, projectConfig) {
+    // We currently only support adding private apps to projects
+    let projectContainsPublicApp = false;
+    try {
+        const components = await (0, structure_1.findProjectComponents)(projectDir);
+        projectContainsPublicApp = components.some(c => c.type === Projects_1.ComponentTypes.PublicApp);
+    }
+    catch (err) {
+        (0, errorHandlers_1.debugError)(err);
+    }
+    if (projectContainsPublicApp) {
+        throw new Error(en_1.commands.project.add.error.projectContainsPublicApp);
+    }
+    logger_1.uiLogger.log(en_1.commands.project.add.creatingComponent(projectConfig.name));
+    const components = await (0, legacy_1.getProjectComponentListFromRepo)(projectConfig.platformVersion);
+    if (!components || !components.length) {
+        throw new Error(en_1.commands.project.add.error.failedToFetchComponentList);
+    }
+    const projectAddPromptResponse = await (0, projectAddPrompt_1.projectAddPrompt)(components, args);
+    try {
+        const componentPath = path_1.default.join(projectDir, projectConfig.srcDir, projectAddPromptResponse.name);
+        await (0, github_1.cloneGithubRepo)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, componentPath, {
+            sourceDir: projectAddPromptResponse.componentTemplate.path,
+            branch: 'main',
+            hideLogs: true,
+        });
+        logger_1.uiLogger.success(en_1.commands.project.add.success(projectAddPromptResponse.name));
+    }
+    catch (error) {
+        throw new Error(en_1.commands.project.add.error.failedToDownloadComponent);
+    }
+}

package/lib/projects/add/v3AddComponent.d.ts

@@ -0,0 +1,8 @@
+import { ProjectConfig } from '../../../types/Projects';
+export declare function v3AddComponent(args: {
+    name?: string;
+    type?: string;
+    features?: string[];
+    auth?: string;
+    distribution?: string;
+}, projectDir: string, projectConfig: ProjectConfig): Promise<void>;

package/lib/projects/add/v3AddComponent.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v3AddComponent = v3AddComponent;
+const en_1 = require("../../../lang/en");
+const legacy_1 = require("../create/legacy");
+const v3_1 = require("../create/v3");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const projectAddPrompt_1 = require("../../prompts/projectAddPrompt");
+const constants_1 = require("../../constants");
+const components_1 = require("../components");
+const project_1 = require("@hubspot/project-parsing-lib/src/lib/project");
+const constants_2 = require("@hubspot/project-parsing-lib/src/lib/constants");
+const github_1 = require("@hubspot/local-dev-lib/github");
+const errorHandlers_1 = require("../../errorHandlers");
+const logger_1 = require("../../ui/logger");
+async function v3AddComponent(args, projectDir, projectConfig) {
+    logger_1.uiLogger.log(en_1.commands.project.add.creatingComponent(projectConfig.name));
+    const config = await (0, legacy_1.getConfigForPlatformVersion)(projectConfig.platformVersion);
+    const { components, parentComponents } = config;
+    if (!components || !components.length) {
+        throw new Error(en_1.commands.project.add.error.failedToFetchComponentList);
+    }
+    const projectSrcDirectory = path_1.default.join(projectDir, projectConfig.srcDir);
+    const projectMetadata = await (0, project_1.getProjectMetadata)(projectSrcDirectory);
+    let derivedAuthType;
+    let derivedDistribution;
+    const appsMetadata = projectMetadata.components[constants_2.AppKey];
+    const shouldCreateApp = appsMetadata.count === 0;
+    if (shouldCreateApp) {
+        const { authType, distribution } = await (0, v3_1.createV3App)(args.auth, args.distribution);
+        derivedDistribution = distribution;
+        derivedAuthType = authType;
+    }
+    else if (appsMetadata.count > appsMetadata.maxCount) {
+        throw new Error(en_1.lib.projects.create.errors.exceededMaxNumberOfApps(appsMetadata.maxCount));
+    }
+    else {
+        const apps = appsMetadata.hsMetaFiles.map(appLoc => {
+            try {
+                return JSON.parse(fs_1.default.readFileSync(appLoc, 'utf8'));
+            }
+            catch (err) {
+                throw new Error(en_1.lib.projects.create.errors.unableToParseAppConfig(appLoc));
+            }
+        });
+        derivedDistribution = apps[0].config?.distribution;
+        derivedAuthType = apps[0].config?.auth?.type;
+    }
+    const componentTemplateChoices = (0, v3_1.calculateComponentTemplateChoices)(components, derivedAuthType, derivedDistribution, projectMetadata);
+    const projectAddPromptResponse = await (0, projectAddPrompt_1.projectAddPromptV3)(componentTemplateChoices, args.features);
+    try {
+        const components = projectAddPromptResponse.componentTemplate?.map((componentTemplate) => {
+            return path_1.default.join(projectConfig.platformVersion, componentTemplate.path);
+        }) || [];
+        if (shouldCreateApp) {
+            const parentComponent = parentComponents?.find(possibleParent => {
+                return (possibleParent.type === v3_1.PROJECT_WITH_APP &&
+                    possibleParent.authType === derivedAuthType &&
+                    possibleParent.distribution === derivedDistribution);
+            });
+            if (parentComponent) {
+                components.push(path_1.default.join(projectConfig.platformVersion, parentComponent.path));
+            }
+        }
+        await (0, github_1.cloneGithubRepo)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectDir, {
+            sourceDir: components,
+            hideLogs: true,
+            branch: 'main',
+            handleCollision: components_1.handleComponentCollision,
+        });
+        logger_1.uiLogger.success(en_1.commands.project.add.success(projectAddPromptResponse.componentTemplate
+            .map(template => `'${template.label}'`)
+            .join(', '), projectAddPromptResponse.componentTemplate.length > 1));
+    }
+    catch (error) {
+        (0, errorHandlers_1.debugError)(error);
+        throw new Error(en_1.commands.project.add.error.failedToDownloadComponent, {
+            cause: error,
+        });
+    }
+}

package/lib/projects/buildAndDeploy.js

@@ -17,6 +17,8 @@ const urls_1 = require("./urls");
 const exitCodes_1 = require("../enums/exitCodes");
 const en_1 = require("../../lang/en");
 const logger_1 = require("../ui/logger");
+const constants_2 = require("@hubspot/project-parsing-lib/src/lib/constants");
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
 const SPINNER_STATUS = {
     SPINNING: 'spinning',
 };
@@ -71,14 +73,27 @@ function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrin
             structureFn(accountId, taskName, taskId),
         ]);
         const subtasks = getSubtasks(initialTaskStatus);
-        const tasksById = subtasks.reduce((acc, subtask) => {
+        const hiddenComponentBuildIds = [];
+        const tasksById = subtasks
+            .filter(subtask => {
+            // TODO: Remove this filtering logic when visible=false for SERVERLESS_PACKAGE
+            const shouldBeVisible = getSubtaskType(subtask) !== (0, project_parsing_lib_1.mapToInternalType)(constants_2.AppFunctionsPackageKey);
+            if (!shouldBeVisible) {
+                hiddenComponentBuildIds.push(subtask.id);
+            }
+            return shouldBeVisible;
+        })
+            .reduce((acc, subtask) => {
             const { id, visible } = subtask;
             if (visible) {
                 acc[id] = subtask;
             }
             return acc;
         }, {});
-        const structuredTasks = Object.keys(taskStructure).map(key => {
+        const structuredTasks = Object.keys(taskStructure)
+            // TODO: Remove this filtering logic when visible=false for SERVERLESS_PACKAGE
+            .filter(buildId => !hiddenComponentBuildIds.includes(buildId))
+            .map(key => {
             return {
                 ...tasksById[key],
                 subtasks: taskStructure[key]
@@ -213,7 +228,7 @@ function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrin
 }
 function pollBuildAutodeployStatus(accountId, taskName, buildId) {
     return new Promise((resolve, reject) => {
-        let maxIntervals = (30 * 1000) / constants_1.DEFAULT_POLLING_DELAY; // Num of intervals in ~30s
+        let maxIntervals = (15 * 1000) / constants_1.DEFAULT_POLLING_DELAY; // Num of intervals in ~15s
         const pollInterval = setInterval(async () => {
             let build;
             try {

package/lib/projects/components.d.ts

@@ -0,0 +1,2 @@
+import { Collision } from '@hubspot/local-dev-lib/types/Archive';
+export declare function handleComponentCollision({ dest, src, collisions }: Collision): void;

package/lib/projects/components.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleComponentCollision = handleComponentCollision;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+// Handles a collision between component source files
+function handleComponentCollision({ dest, src, collisions }) {
+    const hsMetaFiles = [];
+    const packageJsonFiles = [];
+    const sourceFiles = [];
+    collisions.forEach(collision => {
+        if (collision.endsWith(project_parsing_lib_1.metafileExtension)) {
+            hsMetaFiles.push(collision);
+        }
+        else if (path_1.default.parse(collision).base === 'package.json') {
+            packageJsonFiles.push(collision);
+        }
+        else {
+            sourceFiles.push(collision);
+        }
+    });
+    const sourceFilenameMapping = sourceFiles.reduce((acc, filename) => {
+        const { name, ext, dir } = path_1.default.parse(filename);
+        return {
+            ...acc,
+            [filename]: path_1.default.join(dir, `${name}-${Date.now()}${ext}`),
+        };
+    }, {});
+    const metafileExtensionPrefix = path_1.default.parse(project_parsing_lib_1.metafileExtension).name;
+    const metaFilenameMapping = hsMetaFiles.reduce((acc, filename) => {
+        const { name, dir } = path_1.default.parse(filename);
+        return {
+            ...acc,
+            [filename]: path_1.default.join(dir, `${name.replace(metafileExtensionPrefix, '')}-${Date.now()}${project_parsing_lib_1.metafileExtension}`),
+        };
+    }, {});
+    // Update the metafiles that might contain references to the old filenames
+    hsMetaFiles.forEach(file => {
+        updateMetaFile({
+            dest,
+            src,
+            file,
+            sourceFilenameMapping,
+            metaFilenameMapping,
+        });
+    });
+    // Copy the renamed files into their new destination location
+    Object.entries(sourceFilenameMapping).forEach(([key, value]) => {
+        fs_1.default.copyFileSync(path_1.default.join(src, key), path_1.default.join(dest, value));
+    });
+    if (packageJsonFiles.length) {
+        handlePackageJsonCollisions(dest, src, packageJsonFiles);
+    }
+}
+function updateMetaFile({ dest, src, file, sourceFilenameMapping, metaFilenameMapping, }) {
+    let text = fs_1.default.readFileSync(path_1.default.join(src, file), 'utf-8');
+    Object.entries(sourceFilenameMapping).forEach(([key, value]) => {
+        const { base: oldFileName } = path_1.default.parse(key);
+        const { base: newFileName } = path_1.default.parse(value);
+        text = text.replace(oldFileName, newFileName);
+    });
+    fs_1.default.writeFileSync(path_1.default.join(dest, metaFilenameMapping[file]), text);
+}
+function handlePackageJsonCollisions(dest, src, packageJsonFiles) {
+    packageJsonFiles.forEach(file => {
+        const existingPackageJsonContents = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dest, file), 'utf-8'));
+        const newPackageJsonContents = JSON.parse(fs_1.default.readFileSync(path_1.default.join(src, file), 'utf-8'));
+        existingPackageJsonContents.dependencies = {
+            ...newPackageJsonContents.dependencies,
+            ...existingPackageJsonContents.dependencies,
+        };
+        existingPackageJsonContents.devDependencies = {
+            ...newPackageJsonContents.devDependencies,
+            ...existingPackageJsonContents.devDependencies,
+        };
+        fs_1.default.writeFileSync(path_1.default.join(dest, file), JSON.stringify(existingPackageJsonContents, null, 2));
+    });
+}

package/lib/projects/create/index.d.ts

@@ -0,0 +1,23 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { ProjectTemplateRepoConfig } from '../../../types/Projects';
+import { CreateProjectPromptResponse } from '../../prompts/createProjectPrompt';
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../../types/Yargs';
+import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
+export type ProjectCreateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    name?: string;
+    dest?: string;
+    templateSource?: RepoPath;
+    template?: string;
+    features?: string[];
+    platformVersion: string;
+    projectBase?: string;
+    auth?: string;
+    distribution?: string;
+};
+export declare function handleProjectCreationFlow(args: ArgumentsCamelCase<ProjectCreateArgs>): Promise<{
+    authType?: string;
+    distribution?: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    createProjectPromptResponse: CreateProjectPromptResponse;
+}>;

package/lib/projects/create/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleProjectCreationFlow = handleProjectCreationFlow;
+const createProjectPrompt_1 = require("../../prompts/createProjectPrompt");
+const constants_1 = require("../../constants");
+const buildAndDeploy_1 = require("../buildAndDeploy");
+const v3_1 = require("./v3");
+const legacy_1 = require("./legacy");
+const logger_1 = require("../../ui/logger");
+const en_1 = require("../../../lang/en");
+const exitCodes_1 = require("../../enums/exitCodes");
+async function handleProjectCreationFlow(args) {
+    const { platformVersion, templateSource, projectBase, auth: providedAuth, distribution: providedDistribution, } = args;
+    const repo = templateSource || constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
+    if ((0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await (0, v3_1.v3ComponentFlow)(platformVersion, projectBase, providedAuth, providedDistribution);
+        const createProjectPromptResponse = await (0, createProjectPrompt_1.createProjectPrompt)(args, undefined, projectContents !== v3_1.EMPTY_PROJECT ? componentTemplateChoices : undefined);
+        return {
+            authType,
+            distribution,
+            repoConfig,
+            projectContents,
+            createProjectPromptResponse,
+        };
+    }
+    const projectTemplates = await (0, legacy_1.getProjectTemplateListFromRepo)(repo, 'main');
+    if (!projectTemplates.length) {
+        logger_1.uiLogger.error(en_1.commands.project.create.errors.failedToFetchProjectList);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    const createProjectPromptResponse = await (0, createProjectPrompt_1.createProjectPrompt)(args, projectTemplates);
+    return { createProjectPromptResponse };
+}

package/lib/projects/create/legacy.d.ts

@@ -0,0 +1,6 @@
+import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
+import { ProjectTemplate, ComponentTemplate, ProjectTemplateRepoConfig } from '../../../types/Projects';
+export declare const EMPTY_PROJECT_TEMPLATE_NAME = "no-template";
+export declare function getConfigForPlatformVersion(platformVersion: string): Promise<ProjectTemplateRepoConfig> | never;
+export declare function getProjectComponentListFromRepo(platformVersion: string): Promise<ComponentTemplate[]>;
+export declare function getProjectTemplateListFromRepo(templateSource: RepoPath, githubRef: string): Promise<ProjectTemplate[]>;

package/lib/projects/{create.js → create/legacy.js}

@@ -1,24 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EMPTY_PROJECT_TEMPLATE_NAME = void 0;
+exports.getConfigForPlatformVersion = getConfigForPlatformVersion;
 exports.getProjectComponentListFromRepo = getProjectComponentListFromRepo;
 exports.getProjectTemplateListFromRepo = getProjectTemplateListFromRepo;
 const github_1 = require("@hubspot/local-dev-lib/api/github");
-const constants_1 = require("../constants");
-const exitCodes_1 = require("../enums/exitCodes");
-const index_1 = require("../errorHandlers/index");
-const en_1 = require("../../lang/en");
-const logger_1 = require("../ui/logger");
+const constants_1 = require("../../constants");
+const exitCodes_1 = require("../../enums/exitCodes");
+const errorHandlers_1 = require("../../errorHandlers");
+const logger_1 = require("../../ui/logger");
+const buildAndDeploy_1 = require("../buildAndDeploy");
+const en_1 = require("../../../lang/en");
+const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
 exports.EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';
-const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path', 'insertPath'];
-async function getProjectComponentListFromRepo(githubRef) {
+async function getConfigForPlatformVersion(platformVersion) {
+    let path = '';
+    if ((0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+        path = `${platformVersion}/`;
+    }
+    const { data } = await (0, github_1.fetchRepoFile)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, 'main');
+    return data;
+}
+async function getProjectComponentListFromRepo(platformVersion) {
     let config;
     try {
-        const { data } = await (0, github_1.fetchRepoFile)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'config.json', githubRef);
-        config = data;
+        config = await getConfigForPlatformVersion(platformVersion);
     }
     catch (err) {
-        (0, index_1.debugError)(err);
+        (0, errorHandlers_1.debugError)(err);
     }
     if (config) {
         return config[constants_1.PROJECT_COMPONENT_TYPES.COMPONENTS] || [];
@@ -32,7 +41,7 @@ async function getProjectTemplateListFromRepo(templateSource, githubRef) {
         config = data;
     }
     catch (e) {
-        (0, index_1.debugError)(e);
+        (0, errorHandlers_1.debugError)(e);
         logger_1.uiLogger.error(en_1.lib.projects.create.errors.missingConfigFileTemplateSource);
         return process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }

package/lib/projects/create/v3.d.ts

@@ -0,0 +1,27 @@
+import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplateRepoConfig } from '../../../types/Projects';
+import { ProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project';
+import { CreateProjectPromptResponse } from '../../prompts/createProjectPrompt';
+export declare const EMPTY_PROJECT = "empty";
+export declare const PROJECT_WITH_APP = "app";
+export declare function createV3App(providedAuth: string | undefined, providedDistribution: string | undefined): Promise<{
+    authType: string;
+    distribution: string;
+}>;
+export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, projectMetadata?: ProjectMetadata): ComponentTemplateChoice[];
+type V3ComponentInfo = {
+    authType?: string;
+    distribution?: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    componentTemplateChoices?: ComponentTemplateChoice[];
+};
+export declare function v3ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined): Promise<V3ComponentInfo>;
+export declare function generateComponentPaths({ createProjectPromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }: {
+    createProjectPromptResponse: CreateProjectPromptResponse;
+    platformVersion: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    authType?: string;
+    distribution?: string;
+}): string[];
+export {};

package/lib/projects/create/v3.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROJECT_WITH_APP = exports.EMPTY_PROJECT = void 0;
+exports.createV3App = createV3App;
+exports.calculateComponentTemplateChoices = calculateComponentTemplateChoices;
+exports.v3ComponentFlow = v3ComponentFlow;
+exports.generateComponentPaths = generateComponentPaths;
+const constants_1 = require("../../constants");
+const en_1 = require("../../../lang/en");
+const promptUtils_1 = require("../../prompts/promptUtils");
+const chalk_1 = __importDefault(require("chalk"));
+const buildAndDeploy_1 = require("../buildAndDeploy");
+const path_1 = __importDefault(require("path"));
+const legacy_1 = require("./legacy");
+const errorHandlers_1 = require("../../errorHandlers");
+const exitCodes_1 = require("../../enums/exitCodes");
+const inquirer = require('inquirer');
+exports.EMPTY_PROJECT = 'empty';
+exports.PROJECT_WITH_APP = 'app';
+async function createV3App(providedAuth, providedDistribution) {
+    let authType;
+    if (providedAuth &&
+        providedDistribution === constants_1.marketplaceDistribution &&
+        providedAuth !== constants_1.oAuth) {
+        throw new Error(en_1.lib.projects.create.errors.invalidAuthDistCombo(providedAuth, providedDistribution));
+    }
+    const distribution = providedDistribution ||
+        (await (0, promptUtils_1.listPrompt)(en_1.lib.projects.create.prompt.distribution, {
+            choices: [
+                {
+                    name: en_1.lib.projects.create.prompt.marketPlaceDistribution,
+                    value: constants_1.marketplaceDistribution,
+                },
+                {
+                    name: en_1.lib.projects.create.prompt.privateDistribution,
+                    value: constants_1.privateDistribution,
+                },
+            ],
+        }));
+    if (distribution === constants_1.marketplaceDistribution) {
+        // This is the only valid auth type for marketplace
+        authType = constants_1.oAuth;
+    }
+    else {
+        authType =
+            providedAuth ||
+                (await (0, promptUtils_1.listPrompt)(en_1.lib.projects.create.prompt.auth, {
+                    choices: [
+                        { name: en_1.lib.projects.create.prompt.staticAuth, value: constants_1.staticAuth },
+                        { name: en_1.lib.projects.create.prompt.oauth, value: constants_1.oAuth },
+                    ],
+                }));
+    }
+    return {
+        distribution,
+        authType,
+    };
+}
+function calculateComponentTemplateChoices(components, authType, distribution, projectMetadata) {
+    const enabledComponents = [];
+    const disabledComponents = [];
+    components.forEach(template => {
+        const { supportedAuthTypes, supportedDistributions } = template;
+        const disabledReasons = [];
+        if (projectMetadata) {
+            const { count, maxCount } = projectMetadata.components[template.type];
+            if (count >= maxCount) {
+                disabledReasons.push(en_1.commands.project.add.error.maxExceeded(maxCount));
+            }
+        }
+        if (Array.isArray(supportedAuthTypes) &&
+            authType &&
+            !supportedAuthTypes.includes(authType)) {
+            disabledReasons.push(en_1.commands.project.add.error.authTypeNotAllowed(authType));
+        }
+        if (Array.isArray(supportedDistributions) &&
+            distribution &&
+            !supportedDistributions.includes(distribution)) {
+            disabledReasons.push(en_1.commands.project.add.error.distributionNotAllowed(distribution));
+        }
+        if (disabledReasons.length > 0) {
+            disabledComponents.push({
+                name: `[${chalk_1.default.yellow('DISABLED')}] ${template.label}`,
+                value: template,
+                disabled: disabledReasons.join(' '),
+            });
+        }
+        else {
+            enabledComponents.push({
+                name: template.label,
+                value: template,
+            });
+        }
+    });
+    return disabledComponents.length
+        ? [...enabledComponents, new inquirer.Separator(), ...disabledComponents]
+        : [...enabledComponents];
+}
+async function v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution) {
+    let repoConfig = undefined;
+    let authType;
+    let distribution;
+    try {
+        repoConfig = await (0, legacy_1.getConfigForPlatformVersion)(platformVersion);
+    }
+    catch (error) {
+        (0, errorHandlers_1.logError)(error);
+        return process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    }
+    const projectContentsChoice = projectBase ||
+        (await (0, promptUtils_1.listPrompt)(en_1.commands.project.create.prompts.parentComponents, {
+            choices: [
+                {
+                    name: en_1.commands.project.create.prompts.emptyProject,
+                    value: exports.EMPTY_PROJECT,
+                },
+                { name: en_1.commands.project.create.prompts.app, value: exports.PROJECT_WITH_APP },
+            ],
+        }));
+    if (projectContentsChoice === exports.PROJECT_WITH_APP) {
+        const { authType: selectedAuthType, distribution: selectedDistribution } = await createV3App(providedAuth, providedDistribution);
+        authType = selectedAuthType;
+        distribution = selectedDistribution;
+    }
+    const componentTemplateChoices = calculateComponentTemplateChoices(repoConfig?.components || [], authType, distribution);
+    return {
+        componentTemplateChoices,
+        authType,
+        distribution,
+        projectContents: projectContentsChoice,
+        repoConfig,
+    };
+}
+function generateComponentPaths({ createProjectPromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }) {
+    if (!(0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+        return [];
+    }
+    const components = createProjectPromptResponse.componentTemplates?.map((componentTemplate) => {
+        return path_1.default.join(platformVersion, componentTemplate.path);
+    }) || [];
+    if (projectContents && projectContents !== exports.EMPTY_PROJECT) {
+        const parentComponent = repoConfig?.parentComponents?.find(possibleParent => {
+            return (possibleParent.type === projectContents &&
+                possibleParent.authType === authType &&
+                possibleParent.distribution === distribution);
+        });
+        if (parentComponent) {
+            components.push(path_1.default.join(platformVersion, parentComponent.path));
+        }
+    }
+    if (repoConfig?.defaultFiles) {
+        components.push(path_1.default.join(platformVersion, repoConfig?.defaultFiles));
+    }
+    return components;
+}

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

@@ -0,0 +1,30 @@
+import { AppIRNode } from '../../../types/ProjectComponents';
+import LocalDevState from './LocalDevState';
+import LocalDevLogger from './LocalDevLogger';
+type AppDevModeInterfaceConstructorOptions = {
+    localDevState: LocalDevState;
+    localDevLogger: LocalDevLogger;
+};
+declare class AppDevModeInterface {
+    localDevState: LocalDevState;
+    localDevLogger: LocalDevLogger;
+    _appNode?: AppIRNode | null;
+    marketplaceAppInstalls?: number;
+    constructor(options: AppDevModeInterfaceConstructorOptions);
+    private get appNode();
+    private get appData();
+    private set appData(value);
+    private isAutomaticallyInstallable;
+    private getAppInstallUrl;
+    private fetchAppData;
+    private checkMarketplaceAppInstalls;
+    private autoInstallStaticAuthApp;
+    private installAppOrOpenInstallUrl;
+    private checkTestAccountAppInstallation;
+    private setUpLocalDevServerMessageListeners;
+    setup(args: any): Promise<void>;
+    start(): Promise<void>;
+    fileChange(filePath: string, event: string): Promise<void>;
+    cleanup(): Promise<void>;
+}
+export default AppDevModeInterface;