@nx/angular 23.0.0-pr.35465.2bc2643 → 23.0.0-rc.1

package/dist/src/generators/utils/add-vitest.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addVitestAngular = addVitestAngular;
+exports.addVitestAnalog = addVitestAnalog;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const devkit_internals_1 = require("nx/src/devkit-internals");
+const semver_1 = require("semver");
+const versions_1 = require("../../utils/versions");
+const version_utils_1 = require("./version-utils");
+async function addVitestAngular(tree, options) {
+    validateVitestVersion(tree);
+    const executor = options.useNxUnitTestRunnerExecutor
+        ? '@nx/angular:unit-test'
+        : '@angular/build:unit-test';
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.name);
+    project.targets ??= {};
+    project.targets.test = { executor, options: { watch: false } };
+    (0, devkit_1.updateProjectConfiguration)(tree, options.name, project);
+    const nxJson = (0, devkit_1.readNxJson)(tree) ?? {};
+    const existing = (0, internal_1.normalizeTargetDefaults)(nxJson.targetDefaults).find((entry) => entry.executor === executor &&
+        entry.target === undefined &&
+        entry.projects === undefined &&
+        entry.plugin === undefined);
+    if (!existing) {
+        (0, internal_1.upsertTargetDefault)(tree, nxJson, {
+            executor,
+            cache: true,
+            inputs: nxJson.namedInputs && 'production' in nxJson.namedInputs
+                ? ['default', '^production']
+                : ['default', '^default'],
+        });
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+    configureTypeScriptForVitest(tree, options.projectRoot);
+    addVitestScreenshotsToGitIgnore(tree);
+    if (options.skipPackageJson) {
+        return () => { };
+    }
+    const pkgVersions = (0, version_utils_1.versions)(tree, { minAngularMajorVersion: 21 });
+    const angularDevkitVersion = (0, version_utils_1.getInstalledAngularDevkitVersion)(tree) ?? pkgVersions.angularDevkitVersion;
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        '@angular/build': angularDevkitVersion,
+        jsdom: pkgVersions.jsdomVersion,
+        vitest: pkgVersions.vitestVersion,
+    }, undefined, true);
+}
+async function addVitestAnalog(tree, options) {
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    const tasks = [];
+    if (!options.skipPackageJson) {
+        const angularDevkitVersion = (0, version_utils_1.getInstalledAngularDevkitVersion)(tree) ??
+            (0, version_utils_1.versions)(tree).angularDevkitVersion;
+        const devDependencies = {
+            '@angular/build': angularDevkitVersion,
+            // `@analogjs/vite-plugin-angular` (wired in by `@nx/vitest`'s
+            // configurationGenerator for `uiFramework: 'angular'`) registers
+            // an `angularVitestPlugin` whose `transform` hook downlevels
+            // `@angular/*` fesm2022 modules via
+            // `vite.transformWithOxc({ target: 'es2016', … })` so Zone.js
+            // `fakeAsync` can intercept async/await. The lowered code emits
+            // external `@oxc-project/runtime/helpers/*` imports (oxc default
+            // `HelperMode = 'Runtime'`). Nothing in the upstream chain
+            // (analogjs, @angular/core, vite, rolldown) declares the runtime
+            // in a way that's resolvable from the consumer's workspace, so
+            // it must be added here.
+            '@oxc-project/runtime': versions_1.oxcProjectRuntimeVersion,
+        };
+        // Add compatible vitest/jsdom versions BEFORE calling configurationGenerator
+        // so that @nx/vitest respects existing versions
+        if (angularMajorVersion < 21) {
+            const pkgVersions = (0, version_utils_1.versions)(tree);
+            devDependencies['vitest'] = pkgVersions.vitestVersion;
+            devDependencies['jsdom'] = pkgVersions.jsdomVersion;
+        }
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, true));
+    }
+    (0, devkit_1.ensurePackage)('@nx/vitest', versions_1.nxVersion);
+    const { configurationGenerator, } = require('@nx/vitest/generators');
+    tasks.push(await configurationGenerator(tree, {
+        project: options.name,
+        uiFramework: 'angular',
+        testEnvironment: 'jsdom',
+        coverageProvider: 'v8',
+        addPlugin: options.addPlugin ?? false,
+        skipFormat: options.skipFormat,
+        skipPackageJson: options.skipPackageJson,
+        zoneless: options.zoneless,
+    }));
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+function validateVitestVersion(tree) {
+    let installedVitestVersion = null;
+    // Try to get the actual installed version from node_modules
+    try {
+        const { packageJson } = (0, devkit_internals_1.readModulePackageJson)('vitest');
+        installedVitestVersion = packageJson.version;
+    }
+    catch { }
+    const pkgVersions = (0, version_utils_1.versions)(tree, { minAngularMajorVersion: 21 });
+    const requiredRange = pkgVersions.vitestVersion;
+    if (installedVitestVersion) {
+        if (!(0, semver_1.satisfies)(installedVitestVersion, requiredRange, {
+            includePrerelease: true,
+        })) {
+            throw new Error(`The installed vitest version "${installedVitestVersion}" is not compatible with the version range Angular requires: "${requiredRange}".`);
+        }
+        return;
+    }
+    // not installed, get it from package.json
+    installedVitestVersion = (0, devkit_1.getDependencyVersionFromPackageJson)(tree, 'vitest');
+    if (!installedVitestVersion) {
+        // not declared anywhere, it'll be installed with the correct version
+        return;
+    }
+    if ((0, semver_1.valid)(installedVitestVersion)) {
+        if (!(0, semver_1.satisfies)(installedVitestVersion, requiredRange, {
+            includePrerelease: true,
+        })) {
+            throw new Error(`The installed vitest version "${installedVitestVersion}" is not compatible with the version range Angular requires: "${requiredRange}".`);
+        }
+    }
+    else if ((0, semver_1.validRange)(installedVitestVersion)) {
+        // it's a range from package.json, check if it intersects with the required range
+        if (!(0, semver_1.intersects)(installedVitestVersion, requiredRange, {
+            includePrerelease: true,
+        })) {
+            throw new Error(`The declared vitest version range "${installedVitestVersion}" does not overlap with the version range Angular requires: "${requiredRange}". When installed, this may cause compatibility issues.`);
+        }
+    }
+    else {
+        // it can be anything, we don't have a way to validate it
+        // log a warning and continue
+        devkit_1.logger.warn(`The declared vitest version "${installedVitestVersion}" is not a valid semver range, ` +
+            `so we can't validate if it's compatible with the version range Angular requires: "${requiredRange}". ` +
+            `The generation will continue, but you may encounter issues if the version is not compatible.`);
+    }
+}
+function configureTypeScriptForVitest(tree, projectRoot) {
+    (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.spec.json'), {
+        extends: './tsconfig.json',
+        compilerOptions: {
+            outDir: `${(0, devkit_1.offsetFromRoot)(projectRoot)}dist/out-tsc`,
+            types: ['vitest/globals'],
+        },
+        include: ['src/**/*.ts', 'src/**/*.d.ts'],
+    });
+    const projectTsconfigPath = (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.json');
+    (0, devkit_1.updateJson)(tree, projectTsconfigPath, (json) => {
+        json.references ??= [];
+        if (!json.references.some((ref) => ref.path === './tsconfig.spec.json')) {
+            json.references.push({ path: './tsconfig.spec.json' });
+        }
+        return json;
+    });
+}
+function addVitestScreenshotsToGitIgnore(tree) {
+    if (tree.exists('.gitignore')) {
+        let content = tree.read('.gitignore', 'utf-8');
+        if (/^__screenshots__\/$/gm.test(content)) {
+            return;
+        }
+        content = `${content}\n__screenshots__/\n`;
+        tree.write('.gitignore', content);
+    }
+    else {
+        devkit_1.logger.warn(`Couldn't find .gitignore file to update`);
+    }
+}

package/dist/src/generators/utils/app-components-info.d.ts

@@ -0,0 +1,9 @@
+import { type ProjectConfiguration, type Tree } from '@nx/devkit';
+export type ComponentMetadata = {
+    fileName: string;
+    extensionlessFileName: string;
+    path: string;
+    symbolName: string;
+};
+export declare function getAppComponentInfo(tree: Tree, componentFileSuffix: string, project: ProjectConfiguration): ComponentMetadata;
+export declare function getNxWelcomeComponentInfo(tree: Tree, componentFileSuffix: string, project: ProjectConfiguration): ComponentMetadata;

package/dist/src/generators/utils/app-components-info.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppComponentInfo = getAppComponentInfo;
+exports.getNxWelcomeComponentInfo = getNxWelcomeComponentInfo;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+const node_path_1 = require("node:path");
+const version_utils_1 = require("./version-utils");
+function getAppComponentInfo(tree, componentFileSuffix, project) {
+    return getComponentInfo(tree, 'app', componentFileSuffix, project);
+}
+function getNxWelcomeComponentInfo(tree, componentFileSuffix, project) {
+    return getComponentInfo(tree, 'nx-welcome', componentFileSuffix, project);
+}
+// TODO(leo): follow this up and improve it by using static analysis
+function getComponentInfo(tree, component, componentFileSuffix, project) {
+    const sourceRoot = (0, internal_1.getProjectSourceRoot)(project, tree);
+    let componentPath = (0, devkit_1.joinPathFragments)(sourceRoot, `app/${component}.component.ts`);
+    if (!tree.exists(componentPath)) {
+        componentPath = (0, devkit_1.joinPathFragments)(sourceRoot, `app/${component}.ts`);
+    }
+    if (!tree.exists(componentPath)) {
+        if (componentFileSuffix) {
+            componentPath = (0, devkit_1.joinPathFragments)(sourceRoot, `app/${component}${componentFileSuffix}.ts`);
+        }
+    }
+    if (!tree.exists(componentPath)) {
+        const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+        componentPath = (0, devkit_1.joinPathFragments)(sourceRoot, angularMajorVersion >= 20
+            ? `app/${component}.ts`
+            : `app/${component}.component.ts`);
+    }
+    const fileName = (0, node_path_1.basename)(componentPath);
+    const extensionlessFileName = fileName.slice(0, -3);
+    return {
+        fileName,
+        extensionlessFileName,
+        path: componentPath,
+        symbolName: (0, devkit_1.names)(extensionlessFileName).className,
+    };
+}

package/dist/src/generators/utils/artifact-types.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export declare function getComponentType(tree: Tree): string | undefined;
+export declare function getModuleTypeSeparator(tree: Tree): '-' | '.';

package/dist/src/generators/utils/assert-mf-utils.d.ts

@@ -0,0 +1 @@
+export declare function assertRspackIsCSR(bundler: 'webpack' | 'rspack', ssr: boolean): void;

package/dist/src/generators/utils/dependencies.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function addBuildableLibrariesPostCssDependencies(tree: Tree): void;

package/dist/src/generators/utils/ensure-angular-dependencies.d.ts

@@ -0,0 +1,2 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+export declare function ensureAngularDependencies(tree: Tree, zoneless: boolean): GeneratorCallback;

package/dist/src/generators/utils/entry-point.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export declare function locateLibraryEntryPointFromDirectory(tree: Tree, directory: string, projectRoot: string, projectSourceRoot: string): string | null;

package/dist/src/generators/utils/export-scam.d.ts

@@ -0,0 +1,11 @@
+import type { Tree } from '@nx/devkit';
+export type GenerationOptions = {
+    directory: string;
+    filePath: string;
+    name: string;
+    projectName: string;
+    modulePath: string;
+    export?: boolean;
+    inlineScam?: boolean;
+};
+export declare function exportScam(tree: Tree, options: GenerationOptions): void;

package/dist/src/generators/utils/find-module.d.ts

@@ -0,0 +1,4 @@
+import type { Tree } from '@nx/devkit';
+import { ngModuleDecoratorProperty } from './insert-ngmodule-import';
+export declare function findModule(tree: Tree, path: string, module?: string): string;
+export declare function addToNgModule(tree: Tree, path: string, modulePath: string, name: string, className: string, fileName: string, ngModuleProperty: ngModuleDecoratorProperty, isFlat?: boolean, isExported?: boolean): void;

package/dist/src/generators/utils/find-module.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findModule = findModule;
+exports.addToNgModule = addToNgModule;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const internal_1 = require("@nx/js/internal");
+const js_1 = require("@nx/js");
+const insert_ngmodule_import_1 = require("./insert-ngmodule-import");
+let tsModule;
+function findModule(tree, path, module) {
+    const candidatePaths = [];
+    let pathToSearch = path;
+    while (pathToSearch !== '.' && pathToSearch !== '/') {
+        if (module) {
+            const pathToModule = (0, devkit_1.joinPathFragments)(pathToSearch, module);
+            if (tree.exists(pathToModule)) {
+                candidatePaths.push(pathToModule);
+                break;
+            }
+        }
+        else {
+            const potentialOptions = tree
+                .children(pathToSearch)
+                .filter((f) => f.endsWith('.module.ts') || f.endsWith('-module.ts'));
+            if (potentialOptions.length > 0) {
+                candidatePaths.push(...potentialOptions.map((p) => (0, devkit_1.joinPathFragments)(pathToSearch, p)));
+                break;
+            }
+        }
+        pathToSearch = (0, path_1.dirname)(pathToSearch);
+    }
+    if (candidatePaths.length === 0) {
+        throw new Error('Could not find a declaring module file.');
+    }
+    const modules = candidatePaths.filter((p) => {
+        const moduleContents = tree.read(p, 'utf-8');
+        return moduleContents.includes('@NgModule');
+    });
+    if (modules.length === 0) {
+        throw new Error(candidatePaths.length === 1
+            ? `Declaring module file (${candidatePaths[0]}) does not contain an @NgModule Declaration.`
+            : `Declaring module files (${candidatePaths.join(', ')}) do not contain an @NgModule Declaration.`);
+    }
+    if (modules.length > 1) {
+        throw new Error(`More than one NgModule was found. Please provide the NgModule you wish to use.`);
+    }
+    return modules[0];
+}
+function addToNgModule(tree, path, modulePath, name, className, fileName, ngModuleProperty, 
+// TODO(leo): remove once all consumers are updated
+// // check if exported in the public api
+isFlat = true, isExported = false) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    let relativePath = `${(0, devkit_1.joinPathFragments)(path.replace((0, path_1.dirname)(modulePath), ''), !isFlat ? name : '', `${fileName}`)}`;
+    relativePath = relativePath.startsWith('/')
+        ? `.${relativePath}`
+        : `./${relativePath}`;
+    const moduleContents = tree.read(modulePath, 'utf-8');
+    const source = tsModule.createSourceFile(modulePath, moduleContents, tsModule.ScriptTarget.Latest, true);
+    (0, js_1.insertImport)(tree, source, modulePath, className, relativePath);
+    (0, insert_ngmodule_import_1.insertNgModuleProperty)(tree, modulePath, className, ngModuleProperty);
+    if (isExported) {
+        (0, insert_ngmodule_import_1.insertNgModuleProperty)(tree, modulePath, className, 'exports');
+    }
+}

package/dist/src/generators/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './insert-ngmodule-import';
+export * from './find-module';

package/dist/src/generators/utils/insert-ngmodule-import.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+export type ngModuleDecoratorProperty = 'imports' | 'providers' | 'declarations' | 'exports';
+export declare function insertNgModuleProperty(tree: Tree, modulePath: string, name: string, property: ngModuleDecoratorProperty): void;
+export declare function insertNgModuleImport(tree: Tree, modulePath: string, importName: string): void;

package/dist/src/generators/utils/insert-ngmodule-import.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertNgModuleProperty = insertNgModuleProperty;
+exports.insertNgModuleImport = insertNgModuleImport;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+let tsModule;
+function insertNgModuleProperty(tree, modulePath, name, property) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    const contents = tree.read(modulePath).toString('utf-8');
+    const sourceFile = tsModule.createSourceFile(modulePath, contents, tsModule.ScriptTarget.ESNext);
+    const coreImport = findImport(sourceFile, '@angular/core');
+    if (!coreImport) {
+        throw new Error(`There are no imports from "@angular/core" in ${modulePath}.`);
+    }
+    const ngModuleNamedImport = getNamedImport(coreImport, 'NgModule');
+    const ngModuleName = ngModuleNamedImport.name.escapedText;
+    const ngModuleClassDeclaration = findDecoratedClass(sourceFile, ngModuleName);
+    const { getDecorators } = getTsEsLintTypeUtils();
+    const ngModuleDecorator = getDecorators(ngModuleClassDeclaration).find((decorator) => tsModule.isCallExpression(decorator.expression) &&
+        tsModule.isIdentifier(decorator.expression.expression) &&
+        decorator.expression.expression.escapedText === ngModuleName);
+    const ngModuleCall = ngModuleDecorator.expression;
+    if (ngModuleCall.arguments.length < 1) {
+        const newContents = (0, devkit_1.applyChangesToString)(contents, [
+            {
+                type: devkit_1.ChangeType.Insert,
+                index: ngModuleCall.getEnd() - 1,
+                text: `{ ${property}: [${name}]}`,
+            },
+        ]);
+        tree.write(modulePath, newContents);
+    }
+    else {
+        if (!tsModule.isObjectLiteralExpression(ngModuleCall.arguments[0])) {
+            throw new Error(`The NgModule options for ${ngModuleClassDeclaration.name.escapedText} in ${modulePath} is not an object literal`);
+        }
+        const ngModuleOptions = ngModuleCall
+            .arguments[0];
+        const typeProperty = findPropertyAssignment(ngModuleOptions, property);
+        if (!typeProperty) {
+            let text = `${property}: [${name}]`;
+            if (ngModuleOptions.properties.hasTrailingComma) {
+                text = `${text},`;
+            }
+            else if (ngModuleOptions.properties.length) {
+                text = `, ${text}`;
+            }
+            const newContents = (0, devkit_1.applyChangesToString)(contents, [
+                {
+                    type: devkit_1.ChangeType.Insert,
+                    index: ngModuleOptions.getEnd() - 1,
+                    text,
+                },
+            ]);
+            tree.write(modulePath, newContents);
+        }
+        else {
+            if (!tsModule.isArrayLiteralExpression(typeProperty.initializer)) {
+                throw new Error(`The NgModule ${property} for ${ngModuleClassDeclaration.name.escapedText} in ${modulePath} is not an array literal`);
+            }
+            let text;
+            if (typeProperty.initializer.elements.hasTrailingComma) {
+                text = `${name},`;
+            }
+            else if (typeProperty.initializer.elements.length) {
+                text = `, ${name}`;
+            }
+            else {
+                text = name;
+            }
+            const newContents = (0, devkit_1.applyChangesToString)(contents, [
+                {
+                    type: devkit_1.ChangeType.Insert,
+                    index: typeProperty.initializer.getEnd() - 1,
+                    text,
+                },
+            ]);
+            tree.write(modulePath, newContents);
+        }
+    }
+}
+function insertNgModuleImport(tree, modulePath, importName) {
+    insertNgModuleProperty(tree, modulePath, importName, 'imports');
+}
+function findImport(sourceFile, importPath) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    const importStatements = sourceFile.statements.filter(tsModule.isImportDeclaration);
+    return importStatements.find((statement) => statement.moduleSpecifier
+        .getText(sourceFile)
+        .replace(/['"`]/g, '')
+        .trim() === importPath);
+}
+function getNamedImport(coreImport, importName) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    if (!tsModule.isNamedImports(coreImport.importClause.namedBindings)) {
+        throw new Error(`The import from ${coreImport.moduleSpecifier} does not have named imports.`);
+    }
+    return coreImport.importClause.namedBindings.elements.find((namedImport) => namedImport.propertyName
+        ? tsModule.isIdentifier(namedImport.propertyName) &&
+            namedImport.propertyName.escapedText === importName
+        : tsModule.isIdentifier(namedImport.name) &&
+            namedImport.name.escapedText === importName);
+}
+function findDecoratedClass(sourceFile, ngModuleName) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    const classDeclarations = sourceFile.statements.filter(tsModule.isClassDeclaration);
+    const { getDecorators } = getTsEsLintTypeUtils();
+    return classDeclarations.find((declaration) => {
+        const decorators = getDecorators(declaration);
+        if (decorators) {
+            return decorators.some((decorator) => tsModule.isCallExpression(decorator.expression) &&
+                tsModule.isIdentifier(decorator.expression.expression) &&
+                decorator.expression.expression.escapedText === ngModuleName);
+        }
+        return undefined;
+    });
+}
+function findPropertyAssignment(ngModuleOptions, propertyName) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    return ngModuleOptions.properties.find((property) => tsModule.isPropertyAssignment(property) &&
+        tsModule.isIdentifier(property.name) &&
+        property.name.escapedText === propertyName);
+}
+let tsUtils;
+function getTsEsLintTypeUtils() {
+    return tsUtils ?? require('@typescript-eslint/type-utils');
+}

package/dist/src/generators/utils/path.d.ts

@@ -0,0 +1 @@
+export declare function getRelativeImportToFile(sourceFilePath: string, targetFilePath: string): string;

package/dist/src/generators/utils/project.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export declare function getProjectPrefix(tree: Tree, project: string): string | undefined;

package/dist/src/generators/utils/selector.d.ts

@@ -0,0 +1,3 @@
+import { names } from '@nx/devkit';
+export declare function buildSelector(name: string, prefix: string | undefined, projectPrefix: string | undefined, casing: keyof Pick<ReturnType<typeof names>, 'fileName' | 'propertyName'>): string;
+export declare function validateHtmlSelector(selector: string): void;

package/dist/src/generators/utils/storybook-ast/component-info.d.ts

@@ -0,0 +1,11 @@
+import { Tree } from '@nx/devkit';
+import type { EntryPoint } from './entry-point';
+export interface ComponentInfo {
+    componentFileName: string;
+    moduleFolderPath: string;
+    name: string;
+    path: string;
+    entryPointName: string;
+}
+export declare function getComponentsInfo(tree: Tree, entryPoint: EntryPoint, moduleFilePaths: string[], projectName: string): ComponentInfo[];
+export declare function getStandaloneComponentsInfo(tree: Tree, entryPoint: EntryPoint): ComponentInfo[];