@nx/angular 23.0.0-pr.35413.460eeef → 23.0.0-rc.0

package/dist/src/generators/application/application.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applicationGenerator = applicationGenerator;
+const internal_1 = require("@nx/devkit/internal");
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const assert_supported_angular_version_1 = require("../../utils/assert-supported-angular-version");
+const convert_to_rspack_1 = require("../convert-to-rspack/convert-to-rspack");
+const init_1 = require("../init/init");
+const setup_ssr_1 = require("../setup-ssr/setup-ssr");
+const ensure_angular_dependencies_1 = require("../utils/ensure-angular-dependencies");
+const validations_1 = require("../utils/validations");
+const version_utils_1 = require("../utils/version-utils");
+const lib_1 = require("./lib");
+async function applicationGenerator(tree, schema) {
+    (0, assert_supported_angular_version_1.assertSupportedAngularVersion)(tree);
+    (0, validations_1.assertNotUsingTsSolutionSetup)(tree, 'application');
+    (0, lib_1.validateOptions)(tree, schema);
+    const isRspack = schema.bundler === 'rspack';
+    if (isRspack) {
+        schema.bundler = 'webpack';
+    }
+    const options = await (0, lib_1.normalizeOptions)(tree, schema, isRspack);
+    const rootOffset = (0, devkit_1.offsetFromRoot)(options.appProjectRoot);
+    await (0, js_1.initGenerator)(tree, {
+        ...options,
+        tsConfigName: options.rootProject ? 'tsconfig.json' : 'tsconfig.base.json',
+        js: false,
+        skipFormat: true,
+    });
+    await (0, init_1.angularInitGenerator)(tree, {
+        ...options,
+        skipFormat: true,
+        addPlugin: options.addPlugin,
+    });
+    if (!options.skipPackageJson) {
+        (0, ensure_angular_dependencies_1.ensureAngularDependencies)(tree, options.zoneless);
+    }
+    (0, lib_1.createProject)(tree, options);
+    await (0, lib_1.createFiles)(tree, options, rootOffset);
+    await (0, lib_1.addLinting)(tree, options);
+    const unitTestRunnerTask = await (0, lib_1.addUnitTestRunner)(tree, options);
+    const e2ePort = await (0, lib_1.addE2e)(tree, options);
+    (0, lib_1.addServeStaticTarget)(tree, options, options.e2eTestRunner !== 'none' ? e2ePort : options.port);
+    (0, lib_1.updateTsconfigFiles)(tree, options);
+    (0, lib_1.setGeneratorDefaults)(tree, options);
+    if (options.rootProject) {
+        const nxJson = (0, devkit_1.readNxJson)(tree);
+        nxJson.defaultProject = options.name;
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+    if (options.backendProject) {
+        (0, lib_1.addProxyConfig)(tree, options);
+    }
+    if (options.ssr) {
+        await (0, setup_ssr_1.setupSsr)(tree, {
+            project: options.name,
+            standalone: options.standalone,
+            skipPackageJson: options.skipPackageJson,
+            serverRouting: options.serverRouting,
+        });
+    }
+    if (isRspack) {
+        await (0, convert_to_rspack_1.convertToRspack)(tree, {
+            project: options.name,
+            skipInstall: options.skipPackageJson,
+            skipFormat: true,
+        });
+        if (options.ssr) {
+            const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+            (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, './files/rspack-ssr'), options.appProjectSourceRoot, {
+                pathToDistFolder: (0, devkit_1.joinPathFragments)((0, devkit_1.offsetFromRoot)(options.appProjectRoot), options.outputPath, 'browser'),
+                zoneless: options.zoneless,
+                useDefaultImport: angularMajorVersion >= 21,
+                angularMajorVersion,
+                tmpl: '',
+            });
+        }
+    }
+    if (!options.skipPackageJson) {
+        const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+        const devDependencies = {};
+        const packageVersions = (0, version_utils_1.versions)(tree);
+        if (angularMajorVersion >= 20) {
+            const angularDevkitVersion = (0, version_utils_1.getInstalledAngularDevkitVersion)(tree) ??
+                packageVersions.angularDevkitVersion;
+            if (options.bundler === 'esbuild') {
+                devDependencies['@angular/build'] = angularDevkitVersion;
+            }
+            else if (isRspack) {
+                devDependencies['@angular/build'] = angularDevkitVersion;
+                devDependencies['@angular-devkit/build-angular'] = angularDevkitVersion;
+            }
+            else {
+                devDependencies['@angular-devkit/build-angular'] = angularDevkitVersion;
+            }
+        }
+        if (options.style === 'less') {
+            devDependencies['less'] = packageVersions.lessVersion;
+        }
+        if (Object.keys(devDependencies).length) {
+            (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, true);
+        }
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return async () => {
+        await unitTestRunnerTask();
+        (0, devkit_1.installPackagesTask)(tree);
+        (0, internal_1.logShowProjectCommand)(options.name);
+    };
+}
+exports.default = applicationGenerator;

package/dist/src/generators/application/lib/add-e2e.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function addE2e(tree: Tree, options: NormalizedSchema): Promise<number>;

package/dist/src/generators/application/lib/add-e2e.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addE2e = addE2e;
+const internal_1 = require("@nx/devkit/internal");
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../../utils/versions");
+async function addE2e(tree, options) {
+    // since e2e are separate projects, default to adding plugins
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPlugin = nxJson['useInferencePlugins'] !== false &&
+        process.env.NX_ADD_PLUGINS !== 'false';
+    const e2eWebServerInfo = getAngularE2EWebServerInfo(tree, options.name, options.port);
+    if (options.e2eTestRunner === 'cypress') {
+        const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/cypress', versions_1.nxVersion);
+        (0, devkit_1.addProjectConfiguration)(tree, options.e2eProjectName, {
+            projectType: 'application',
+            root: options.e2eProjectRoot,
+            sourceRoot: (0, devkit_1.joinPathFragments)(options.e2eProjectRoot, 'src'),
+            targets: {},
+            tags: [],
+            implicitDependencies: [options.name],
+        });
+        await configurationGenerator(tree, {
+            project: options.e2eProjectName,
+            directory: 'src',
+            linter: options.linter,
+            skipPackageJson: options.skipPackageJson,
+            skipFormat: true,
+            devServerTarget: e2eWebServerInfo.e2eDevServerTarget,
+            baseUrl: e2eWebServerInfo.e2eWebServerAddress,
+            webServerCommands: {
+                default: e2eWebServerInfo.e2eWebServerCommand,
+                production: e2eWebServerInfo.e2eCiWebServerCommand,
+            },
+            ciWebServerCommand: e2eWebServerInfo.e2eCiWebServerCommand,
+            ciBaseUrl: e2eWebServerInfo.e2eCiBaseUrl,
+            rootProject: options.rootProject,
+            addPlugin,
+        });
+    }
+    else if (options.e2eTestRunner === 'playwright') {
+        const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/playwright', versions_1.nxVersion);
+        (0, devkit_1.addProjectConfiguration)(tree, options.e2eProjectName, {
+            projectType: 'application',
+            root: options.e2eProjectRoot,
+            sourceRoot: (0, devkit_1.joinPathFragments)(options.e2eProjectRoot, 'src'),
+            targets: {},
+            implicitDependencies: [options.name],
+        });
+        await configurationGenerator(tree, {
+            project: options.e2eProjectName,
+            skipFormat: true,
+            skipPackageJson: options.skipPackageJson,
+            directory: 'src',
+            js: false,
+            linter: options.linter,
+            setParserOptionsProject: options.setParserOptionsProject,
+            webServerCommand: e2eWebServerInfo.e2eWebServerCommand,
+            webServerAddress: e2eWebServerInfo.e2eWebServerAddress,
+            rootProject: options.rootProject,
+            addPlugin,
+        });
+    }
+    return e2eWebServerInfo.e2ePort;
+}
+function getAngularE2EWebServerInfo(tree, projectName, portOverride) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    let e2ePort = portOverride ?? 4200;
+    const serveTargetOptions = (0, internal_1.readTargetDefaultsForTarget)('serve', nxJson.targetDefaults)?.options;
+    if (serveTargetOptions?.port || serveTargetOptions?.env?.PORT) {
+        e2ePort = serveTargetOptions.port || serveTargetOptions.env.PORT;
+    }
+    const pm = (0, devkit_1.getPackageManagerCommand)();
+    return {
+        e2eCiBaseUrl: `http://localhost:${e2ePort}`,
+        e2eCiWebServerCommand: `${pm.exec} nx run ${projectName}:serve-static`,
+        e2eWebServerCommand: `${pm.exec} nx run ${projectName}:serve`,
+        e2eWebServerAddress: `http://localhost:${e2ePort}`,
+        e2eDevServerTarget: `${projectName}:serve`,
+        e2ePort,
+    };
+}

package/dist/src/generators/application/lib/add-linting.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function addLinting(host: Tree, options: NormalizedSchema): Promise<void>;

package/dist/src/generators/application/lib/add-proxy-config.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function addProxyConfig(host: Tree, options: NormalizedSchema): void;

package/dist/src/generators/application/lib/add-serve-static-target.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function addServeStaticTarget(tree: Tree, options: NormalizedSchema, port: number): void;

package/dist/src/generators/application/lib/add-unit-test-runner.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratorCallback, Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function addUnitTestRunner(host: Tree, options: NormalizedSchema): Promise<GeneratorCallback>;

package/dist/src/generators/application/lib/add-unit-test-runner.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addUnitTestRunner = addUnitTestRunner;
+const test_runners_1 = require("../../../utils/test-runners");
+const add_jest_1 = require("../../utils/add-jest");
+const add_vitest_1 = require("../../utils/add-vitest");
+async function addUnitTestRunner(host, options) {
+    switch (options.unitTestRunner) {
+        case test_runners_1.UnitTestRunner.Jest:
+            await (0, add_jest_1.addJest)(host, {
+                name: options.name,
+                projectRoot: options.appProjectRoot,
+                skipPackageJson: options.skipPackageJson,
+                strict: options.strict,
+                addPlugin: options.addPlugin,
+                runtimeTsconfigFileName: 'tsconfig.app.json',
+                zoneless: options.zoneless,
+            });
+            return () => { };
+        case test_runners_1.UnitTestRunner.VitestAngular:
+            return (0, add_vitest_1.addVitestAngular)(host, {
+                name: options.name,
+                projectRoot: options.appProjectRoot,
+                skipPackageJson: options.skipPackageJson,
+            });
+        case test_runners_1.UnitTestRunner.VitestAnalog:
+            return (0, add_vitest_1.addVitestAnalog)(host, {
+                name: options.name,
+                projectRoot: options.appProjectRoot,
+                skipFormat: options.skipFormat,
+                skipPackageJson: options.skipPackageJson,
+                strict: options.strict,
+                addPlugin: options.addPlugin,
+                zoneless: options.zoneless,
+            });
+        default:
+            return () => { };
+    }
+}

package/dist/src/generators/application/lib/create-files.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function createFiles(tree: Tree, options: NormalizedSchema, rootOffset: string): Promise<void>;

package/dist/src/generators/application/lib/create-project.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function createProject(tree: Tree, options: NormalizedSchema): void;

package/dist/src/generators/application/lib/create-project.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProject = createProject;
+const internal_1 = require("@nx/devkit/internal");
+const devkit_1 = require("@nx/devkit");
+const version_utils_1 = require("../../utils/version-utils");
+function createProject(tree, options) {
+    let project;
+    if (options.bundler === 'esbuild') {
+        project = createProjectForEsbuild(tree, options);
+    }
+    else {
+        project = createProjectForWebpack(tree, options);
+    }
+    (0, devkit_1.addProjectConfiguration)(tree, options.name, project);
+}
+function createProjectForEsbuild(tree, options) {
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    const buildExecutor = angularMajorVersion >= 20
+        ? '@angular/build:application'
+        : '@angular-devkit/build-angular:application';
+    (0, internal_1.addBuildTargetDefaults)(tree, buildExecutor);
+    let budgets = undefined;
+    if (options.strict) {
+        budgets = [
+            { type: 'initial', maximumWarning: '500kb', maximumError: '1mb' },
+            {
+                type: 'anyComponentStyle',
+                maximumWarning: '4kb',
+                maximumError: '8kb',
+            },
+        ];
+    }
+    else {
+        budgets = [
+            { type: 'initial', maximumWarning: '2mb', maximumError: '5mb' },
+            {
+                type: 'anyComponentStyle',
+                maximumWarning: '6kb',
+                maximumError: '10kb',
+            },
+        ];
+    }
+    const inlineStyleLanguage = options?.style !== 'css' ? options.style : undefined;
+    const project = {
+        name: options.name,
+        projectType: 'application',
+        prefix: options.prefix,
+        root: options.appProjectRoot,
+        sourceRoot: options.appProjectSourceRoot,
+        tags: options.parsedTags,
+        targets: {
+            build: {
+                executor: buildExecutor,
+                outputs: ['{options.outputPath}'],
+                options: {
+                    outputPath: options.outputPath,
+                    index: angularMajorVersion >= 20
+                        ? undefined
+                        : `${options.appProjectSourceRoot}/index.html`,
+                    browser: `${options.appProjectSourceRoot}/main.ts`,
+                    polyfills: options.zoneless ? undefined : ['zone.js'],
+                    tsConfig: (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'tsconfig.app.json'),
+                    inlineStyleLanguage,
+                    assets: [
+                        {
+                            glob: '**/*',
+                            input: (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'public'),
+                        },
+                    ],
+                    styles: [`${options.appProjectSourceRoot}/styles.${options.style}`],
+                },
+                configurations: {
+                    production: {
+                        budgets,
+                        outputHashing: 'all',
+                    },
+                    development: {
+                        optimization: false,
+                        extractLicenses: false,
+                        sourceMap: true,
+                    },
+                },
+                defaultConfiguration: 'production',
+            },
+            serve: {
+                continuous: true,
+                executor: angularMajorVersion >= 20
+                    ? '@angular/build:dev-server'
+                    : '@angular-devkit/build-angular:dev-server',
+                options: options.port ? { port: options.port } : undefined,
+                configurations: {
+                    production: {
+                        buildTarget: `${options.name}:build:production`,
+                    },
+                    development: {
+                        buildTarget: `${options.name}:build:development`,
+                    },
+                },
+                defaultConfiguration: 'development',
+            },
+            'extract-i18n': angularMajorVersion < 21
+                ? {
+                    executor: angularMajorVersion >= 20
+                        ? '@angular/build:extract-i18n'
+                        : '@angular-devkit/build-angular:extract-i18n',
+                    options: {
+                        buildTarget: `${options.name}:build`,
+                    },
+                }
+                : undefined,
+        },
+    };
+    return project;
+}
+function createProjectForWebpack(tree, options) {
+    const buildExecutor = '@angular-devkit/build-angular:browser';
+    (0, internal_1.addBuildTargetDefaults)(tree, buildExecutor);
+    let budgets = undefined;
+    if (options.strict) {
+        budgets = [
+            { type: 'initial', maximumWarning: '500kb', maximumError: '1mb' },
+            {
+                type: 'anyComponentStyle',
+                maximumWarning: '4kb',
+                maximumError: '8kb',
+            },
+        ];
+    }
+    else {
+        budgets = [
+            { type: 'initial', maximumWarning: '2mb', maximumError: '5mb' },
+            {
+                type: 'anyComponentStyle',
+                maximumWarning: '6kb',
+                maximumError: '10kb',
+            },
+        ];
+    }
+    const inlineStyleLanguage = options?.style !== 'css' ? options.style : undefined;
+    const project = {
+        name: options.name,
+        projectType: 'application',
+        prefix: options.prefix,
+        root: options.appProjectRoot,
+        sourceRoot: options.appProjectSourceRoot,
+        tags: options.parsedTags,
+        targets: {
+            build: {
+                executor: buildExecutor,
+                outputs: ['{options.outputPath}'],
+                options: {
+                    outputPath: options.outputPath,
+                    index: `${options.appProjectSourceRoot}/index.html`,
+                    main: `${options.appProjectSourceRoot}/main.ts`,
+                    polyfills: options.zoneless ? undefined : ['zone.js'],
+                    tsConfig: (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'tsconfig.app.json'),
+                    inlineStyleLanguage,
+                    assets: [
+                        {
+                            glob: '**/*',
+                            input: (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'public'),
+                        },
+                    ],
+                    styles: [`${options.appProjectSourceRoot}/styles.${options.style}`],
+                },
+                configurations: {
+                    production: {
+                        budgets,
+                        outputHashing: 'all',
+                    },
+                    development: {
+                        buildOptimizer: false,
+                        optimization: false,
+                        vendorChunk: true,
+                        extractLicenses: false,
+                        sourceMap: true,
+                        namedChunks: true,
+                    },
+                },
+                defaultConfiguration: 'production',
+            },
+            serve: {
+                continuous: true,
+                executor: '@angular-devkit/build-angular:dev-server',
+                options: options.port ? { port: options.port } : undefined,
+                configurations: {
+                    production: {
+                        buildTarget: `${options.name}:build:production`,
+                    },
+                    development: {
+                        buildTarget: `${options.name}:build:development`,
+                    },
+                },
+                defaultConfiguration: 'development',
+            },
+            'extract-i18n': {
+                executor: '@angular-devkit/build-angular:extract-i18n',
+                options: {
+                    buildTarget: `${options.name}:build`,
+                },
+            },
+        },
+    };
+    return project;
+}

package/dist/src/generators/application/lib/enable-strict-type-checking.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function enableStrictTypeChecking(host: Tree, options: NormalizedSchema): void;

package/dist/src/generators/application/lib/index.d.ts

@@ -0,0 +1,13 @@
+export * from './add-e2e';
+export * from './add-linting';
+export * from './add-proxy-config';
+export * from './add-serve-static-target';
+export * from './add-unit-test-runner';
+export * from './create-files';
+export * from './create-project';
+export * from './enable-strict-type-checking';
+export * from './normalize-options';
+export * from './normalized-schema';
+export * from './set-generator-defaults';
+export * from './update-tsconfig-files';
+export * from './validate-options';

package/dist/src/generators/application/lib/normalize-options.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+import type { Schema } from '../schema';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function normalizeOptions(host: Tree, options: Partial<Schema>, isRspack?: boolean): Promise<NormalizedSchema>;

package/dist/src/generators/application/lib/normalize-options.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = normalizeOptions;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const test_runners_1 = require("../../../utils/test-runners");
+const version_utils_1 = require("../../utils/version-utils");
+function arePluginsExplicitlyDisabled(host) {
+    const { useInferencePlugins } = (0, devkit_1.readNxJson)(host);
+    const addPluginEnvVar = process.env.NX_ADD_PLUGINS;
+    return useInferencePlugins === false || addPluginEnvVar === 'false';
+}
+function validateBundler(bundler) {
+    if (['esbuild', 'webpack', 'rspack'].includes(bundler)) {
+        return bundler;
+    }
+    throw new Error(`Invalid bundler: ${bundler}. Please use one of the following: 'esbuild', 'webpack', 'rspack'.`);
+}
+async function normalizeOptions(host, options, isRspack) {
+    await (0, internal_1.ensureRootProjectName)(options, 'application');
+    const { projectName: appProjectName, projectRoot: appProjectRoot } = await (0, internal_1.determineProjectNameAndRootOptions)(host, {
+        name: options.name,
+        projectType: 'application',
+        directory: options.directory,
+        rootProject: options.rootProject,
+    });
+    options.rootProject = appProjectRoot === '.';
+    const e2eProjectName = options.rootProject ? 'e2e' : `${appProjectName}-e2e`;
+    const e2eProjectRoot = options.rootProject ? 'e2e' : `${appProjectRoot}-e2e`;
+    const parsedTags = options.tags
+        ? options.tags.split(',').map((s) => s.trim())
+        : [];
+    const bundler = validateBundler(options.bundler ?? 'esbuild');
+    const addPlugin = options.addPlugin ?? (!arePluginsExplicitlyDisabled(host) && isRspack);
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(host);
+    const zonelessDefaultValue = angularMajorVersion >= 21 ? true : false;
+    const unitTestRunner = options.unitTestRunner ??
+        (angularMajorVersion >= 21 && bundler === 'esbuild'
+            ? test_runners_1.UnitTestRunner.VitestAngular
+            : angularMajorVersion >= 21
+                ? test_runners_1.UnitTestRunner.VitestAnalog
+                : test_runners_1.UnitTestRunner.Jest);
+    // Set defaults and then overwrite with user options
+    return {
+        addPlugin,
+        style: 'css',
+        routing: true,
+        inlineStyle: false,
+        inlineTemplate: false,
+        skipTests: unitTestRunner === test_runners_1.UnitTestRunner.None,
+        skipFormat: false,
+        e2eTestRunner: test_runners_1.E2eTestRunner.Playwright,
+        linter: 'eslint',
+        strict: true,
+        standalone: true,
+        directory: appProjectRoot,
+        ...options,
+        prefix: options.prefix || 'app',
+        name: appProjectName,
+        appProjectRoot,
+        appProjectSourceRoot: `${appProjectRoot}/src`,
+        e2eProjectRoot,
+        e2eProjectName,
+        parsedTags,
+        bundler,
+        outputPath: (0, devkit_1.joinPathFragments)('dist', !options.rootProject ? appProjectRoot : appProjectName),
+        ssr: options.ssr ?? false,
+        unitTestRunner,
+        zoneless: options.zoneless ?? zonelessDefaultValue,
+    };
+}

package/dist/src/generators/application/lib/normalized-schema.d.ts

@@ -0,0 +1,15 @@
+import { E2eTestRunner, UnitTestRunner } from '../../../utils/test-runners';
+import type { Schema } from '../schema';
+import { Linter, LinterType } from '@nx/eslint';
+export interface NormalizedSchema extends Schema {
+    linter: Linter | LinterType;
+    unitTestRunner: UnitTestRunner;
+    e2eTestRunner: E2eTestRunner;
+    prefix: string;
+    appProjectRoot: string;
+    appProjectSourceRoot: string;
+    e2eProjectName: string;
+    e2eProjectRoot: string;
+    parsedTags: string[];
+    outputPath: string;
+}

package/dist/src/generators/application/lib/set-generator-defaults.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function setGeneratorDefaults(tree: Tree, options: NormalizedSchema): void;

package/dist/src/generators/application/lib/update-tsconfig-files.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function updateTsconfigFiles(tree: Tree, options: NormalizedSchema): void;