@nx/angular 0.0.0-pr-22179-271588f

package/src/generators/application/files/standalone-components/src/main.ts__tpl__

@@ -0,0 +1,7 @@
+import { bootstrapApplication } from '@angular/platform-browser';
+import { appConfig } from './app/app.config';
+import { AppComponent } from './app/app.component';
+
+bootstrapApplication(AppComponent, appConfig).catch((err) =>
+  console.error(err)
+);

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

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

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addE2e = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../../utils/versions");
+const version_utils_1 = require("../../utils/version-utils");
+async function addE2e(tree, options) {
+    // since e2e are separate projects, default to adding plugins
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    if (options.e2eTestRunner === 'cypress') {
+        const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/cypress', versions_1.nxVersion);
+        // TODO: This can call `@nx/web:static-config` generator when ready
+        addFileServerTarget(tree, options, 'serve-static');
+        (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: `${options.name}:serve:development`,
+            baseUrl: 'http://localhost:4200',
+            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: `${(0, devkit_1.getPackageManagerCommand)().exec} nx serve ${options.name}`,
+            webServerAddress: `http://localhost:${options.port ?? 4200}`,
+            rootProject: options.rootProject,
+            addPlugin,
+        });
+    }
+}
+exports.addE2e = addE2e;
+function addFileServerTarget(tree, options, targetName) {
+    (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/web': versions_1.nxVersion });
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    const isUsingApplicationBuilder = angularMajorVersion >= 17 && options.bundler === 'esbuild';
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.name);
+    projectConfig.targets[targetName] = {
+        executor: '@nx/web:file-server',
+        options: {
+            buildTarget: `${options.name}:build`,
+            port: options.port,
+            staticFilePath: isUsingApplicationBuilder
+                ? (0, devkit_1.joinPathFragments)(options.outputPath, 'browser')
+                : undefined,
+        },
+    };
+    (0, devkit_1.updateProjectConfiguration)(tree, options.name, projectConfig);
+}

package/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/src/generators/application/lib/add-linting.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLinting = void 0;
+const eslint_1 = require("@nx/eslint");
+const add_linting_1 = require("../../add-linting/add-linting");
+async function addLinting(host, options) {
+    if (options.linter === eslint_1.Linter.None) {
+        return;
+    }
+    await (0, add_linting_1.default)(host, {
+        projectName: options.name,
+        projectRoot: options.appProjectRoot,
+        prefix: options.prefix,
+        setParserOptionsProject: options.setParserOptionsProject,
+        skipPackageJson: options.skipPackageJson,
+        unitTestRunner: options.unitTestRunner,
+        skipFormat: true,
+    });
+}
+exports.addLinting = addLinting;

package/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/src/generators/application/lib/add-proxy-config.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addProxyConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+function addProxyConfig(host, options) {
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(host, options.name);
+    if (projectConfig.targets && projectConfig.targets.serve) {
+        const pathToProxyFile = `${projectConfig.root}/proxy.conf.json`;
+        if (!host.exists(pathToProxyFile)) {
+            host.write(pathToProxyFile, '{}');
+        }
+        (0, devkit_1.updateJson)(host, pathToProxyFile, (json) => ({
+            [`/${options.backendProject}`]: {
+                target: 'http://localhost:3333',
+                secure: false,
+            },
+        }));
+        projectConfig.targets.serve.options = {
+            ...projectConfig.targets.serve.options,
+            proxyConfig: pathToProxyFile,
+        };
+        (0, devkit_1.updateProjectConfiguration)(host, options.name, projectConfig);
+    }
+}
+exports.addProxyConfig = addProxyConfig;

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addUnitTestRunner = void 0;
+const test_runners_1 = require("../../../utils/test-runners");
+const add_jest_1 = require("../../utils/add-jest");
+async function addUnitTestRunner(host, options) {
+    if (options.unitTestRunner === test_runners_1.UnitTestRunner.Jest) {
+        await (0, add_jest_1.addJest)(host, {
+            name: options.name,
+            projectRoot: options.appProjectRoot,
+            skipPackageJson: options.skipPackageJson,
+            strict: options.strict,
+        });
+    }
+}
+exports.addUnitTestRunner = addUnitTestRunner;

package/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/src/generators/application/lib/create-files.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFiles = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const update_project_root_tsconfig_1 = require("../../utils/update-project-root-tsconfig");
+const test_runners_1 = require("../../../utils/test-runners");
+const version_utils_1 = require("../../utils/version-utils");
+const selector_1 = require("../../utils/selector");
+async function createFiles(tree, options, rootOffset) {
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    const isUsingApplicationBuilder = angularMajorVersion >= 17 && options.bundler === 'esbuild';
+    const rootSelector = `${options.prefix}-root`;
+    (0, selector_1.validateHtmlSelector)(rootSelector);
+    const nxWelcomeSelector = `${options.prefix}-nx-welcome`;
+    (0, selector_1.validateHtmlSelector)(nxWelcomeSelector);
+    const substitutions = {
+        rootSelector,
+        appName: options.name,
+        inlineStyle: options.inlineStyle,
+        inlineTemplate: options.inlineTemplate,
+        style: options.style,
+        viewEncapsulation: options.viewEncapsulation,
+        unitTesting: options.unitTestRunner !== test_runners_1.UnitTestRunner.None,
+        routing: options.routing,
+        minimal: options.minimal,
+        nxWelcomeSelector,
+        rootTsConfig: (0, devkit_1.joinPathFragments)(rootOffset, (0, js_1.getRootTsConfigFileName)(tree)),
+        angularMajorVersion,
+        rootOffset,
+        isUsingApplicationBuilder,
+        tpl: '',
+    };
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '../files/base'), options.appProjectRoot, substitutions);
+    if (options.standalone) {
+        (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '../files/standalone-components'), options.appProjectRoot, substitutions);
+    }
+    else {
+        (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '../files/ng-module'), options.appProjectRoot, substitutions);
+    }
+    (0, update_project_root_tsconfig_1.updateProjectRootTsConfig)(tree, options.appProjectRoot, (0, js_1.getRelativePathToRootTsConfig)(tree, options.appProjectRoot), options.rootProject);
+    if (!options.routing) {
+        tree.delete((0, devkit_1.joinPathFragments)(options.appProjectRoot, '/src/app/app.routes.ts'));
+    }
+    if (options.skipTests || options.unitTestRunner === test_runners_1.UnitTestRunner.None) {
+        tree.delete((0, devkit_1.joinPathFragments)(options.appProjectRoot, '/src/app/app.component.spec.ts'));
+    }
+    if (options.inlineTemplate) {
+        tree.delete((0, devkit_1.joinPathFragments)(options.appProjectRoot, '/src/app/app.component.html'));
+    }
+    if (options.inlineStyle) {
+        tree.delete((0, devkit_1.joinPathFragments)(options.appProjectRoot, `/src/app/app.component.${options.style}`));
+    }
+    if (options.minimal) {
+        tree.delete((0, devkit_1.joinPathFragments)(options.appProjectRoot, 'src/app/nx-welcome.component.ts'));
+    }
+}
+exports.createFiles = createFiles;

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

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

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProject = void 0;
+const devkit_1 = require("@nx/devkit");
+const version_utils_1 = require("../../utils/version-utils");
+const add_build_target_defaults_1 = require("@nx/devkit/src/generators/add-build-target-defaults");
+function createProject(tree, options) {
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    const buildExecutor = options.bundler === 'webpack'
+        ? '@angular-devkit/build-angular:browser'
+        : angularMajorVersion >= 17
+            ? '@angular-devkit/build-angular:application'
+            : '@angular-devkit/build-angular:browser-esbuild';
+    const buildTargetOptionName = angularMajorVersion >= 17 ? 'buildTarget' : 'browserTarget';
+    const buildMainOptionName = angularMajorVersion >= 17 && options.bundler === 'esbuild'
+        ? 'browser'
+        : 'main';
+    (0, add_build_target_defaults_1.addBuildTargetDefaults)(tree, buildExecutor);
+    let budgets = undefined;
+    if (options.bundler === 'webpack' || angularMajorVersion >= 17) {
+        if (options.strict) {
+            budgets = [
+                { type: 'initial', maximumWarning: '500kb', maximumError: '1mb' },
+                {
+                    type: 'anyComponentStyle',
+                    maximumWarning: '2kb',
+                    maximumError: '4kb',
+                },
+            ];
+        }
+        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`,
+                    [buildMainOptionName]: `${options.appProjectSourceRoot}/main.ts`,
+                    polyfills: ['zone.js'],
+                    tsConfig: `${options.appProjectRoot}/tsconfig.app.json`,
+                    inlineStyleLanguage,
+                    assets: [
+                        `${options.appProjectSourceRoot}/favicon.ico`,
+                        `${options.appProjectSourceRoot}/assets`,
+                    ],
+                    styles: [`${options.appProjectSourceRoot}/styles.${options.style}`],
+                    scripts: [],
+                },
+                configurations: {
+                    production: {
+                        budgets,
+                        outputHashing: 'all',
+                    },
+                    development: {
+                        buildOptimizer: options.bundler === 'webpack' ? false : undefined,
+                        optimization: false,
+                        vendorChunk: options.bundler === 'webpack' ? true : undefined,
+                        extractLicenses: false,
+                        sourceMap: true,
+                        namedChunks: options.bundler === 'webpack' ? true : undefined,
+                    },
+                },
+                defaultConfiguration: 'production',
+            },
+            serve: {
+                executor: '@angular-devkit/build-angular:dev-server',
+                options: options.port
+                    ? {
+                        port: options.port,
+                    }
+                    : undefined,
+                configurations: {
+                    production: {
+                        [buildTargetOptionName]: `${options.name}:build:production`,
+                    },
+                    development: {
+                        [buildTargetOptionName]: `${options.name}:build:development`,
+                    },
+                },
+                defaultConfiguration: 'development',
+            },
+            'extract-i18n': {
+                executor: '@angular-devkit/build-angular:extract-i18n',
+                options: {
+                    [buildTargetOptionName]: `${options.name}:build`,
+                },
+            },
+        },
+    };
+    (0, devkit_1.addProjectConfiguration)(tree, options.name, project);
+}
+exports.createProject = createProject;

package/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/src/generators/application/lib/enable-strict-type-checking.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableStrictTypeChecking = void 0;
+const devkit_1 = require("@nx/devkit");
+function enableStrictTypeChecking(host, options) {
+    // This matches the settings defined by the Angular CLI https://angular.io/guide/strict-mode
+    const compilerOptions = {
+        forceConsistentCasingInFileNames: true,
+        strict: true,
+        noImplicitOverride: true,
+        noPropertyAccessFromIndexSignature: true,
+        noImplicitReturns: true,
+        noFallthroughCasesInSwitch: true,
+    };
+    const appTsConfigPath = `${options.appProjectRoot}/tsconfig.json`;
+    if (host.exists(appTsConfigPath)) {
+        (0, devkit_1.updateJson)(host, appTsConfigPath, (json) => {
+            json.compilerOptions = { ...json.compilerOptions, ...compilerOptions };
+            json.angularCompilerOptions = {
+                enableI18nLegacyMessageIdFormat: false,
+                strictInjectionParameters: true,
+                strictInputAccessModifiers: true,
+                strictTemplates: true,
+            };
+            return json;
+        });
+    }
+    const e2eTsConfigPath = `${options.e2eProjectRoot}/tsconfig.json`;
+    if (host.exists(e2eTsConfigPath)) {
+        (0, devkit_1.updateJson)(host, e2eTsConfigPath, (json) => {
+            json.compilerOptions = { ...json.compilerOptions, ...compilerOptions };
+            return json;
+        });
+    }
+}
+exports.enableStrictTypeChecking = enableStrictTypeChecking;

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

@@ -0,0 +1,12 @@
+export * from './add-e2e';
+export * from './add-linting';
+export * from './add-proxy-config';
+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-app-strict-default';
+export * from './set-generator-defaults';
+export * from './update-editor-tsconfig';

package/src/generators/application/lib/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./add-e2e"), exports);
+tslib_1.__exportStar(require("./add-linting"), exports);
+tslib_1.__exportStar(require("./add-proxy-config"), exports);
+tslib_1.__exportStar(require("./add-unit-test-runner"), exports);
+tslib_1.__exportStar(require("./create-files"), exports);
+tslib_1.__exportStar(require("./create-project"), exports);
+tslib_1.__exportStar(require("./enable-strict-type-checking"), exports);
+tslib_1.__exportStar(require("./normalize-options"), exports);
+tslib_1.__exportStar(require("./normalized-schema"), exports);
+tslib_1.__exportStar(require("./set-app-strict-default"), exports);
+tslib_1.__exportStar(require("./set-generator-defaults"), exports);
+tslib_1.__exportStar(require("./update-editor-tsconfig"), exports);

package/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>): Promise<NormalizedSchema>;

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+const devkit_1 = require("@nx/devkit");
+const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+const eslint_1 = require("@nx/eslint");
+const test_runners_1 = require("../../../utils/test-runners");
+const version_utils_1 = require("../../utils/version-utils");
+async function normalizeOptions(host, options) {
+    const { projectName: appProjectName, projectRoot: appProjectRoot, projectNameAndRootFormat, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
+        name: options.name,
+        projectType: 'application',
+        directory: options.directory,
+        projectNameAndRootFormat: options.projectNameAndRootFormat,
+        rootProject: options.rootProject,
+        callingGenerator: '@nx/angular:application',
+    });
+    options.rootProject = appProjectRoot === '.';
+    options.projectNameAndRootFormat = projectNameAndRootFormat;
+    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())
+        : [];
+    let bundler = options.bundler;
+    if (!bundler) {
+        const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(host);
+        bundler = angularMajorVersion >= 17 ? 'esbuild' : 'webpack';
+    }
+    // Set defaults and then overwrite with user options
+    return {
+        style: 'css',
+        routing: true,
+        inlineStyle: false,
+        inlineTemplate: false,
+        skipTests: options.unitTestRunner === test_runners_1.UnitTestRunner.None,
+        skipFormat: false,
+        unitTestRunner: test_runners_1.UnitTestRunner.Jest,
+        e2eTestRunner: test_runners_1.E2eTestRunner.Cypress,
+        linter: eslint_1.Linter.EsLint,
+        strict: true,
+        standalone: true,
+        ...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,
+    };
+}
+exports.normalizeOptions = normalizeOptions;

package/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 } from '@nx/eslint';
+export interface NormalizedSchema extends Schema {
+    linter: Linter;
+    unitTestRunner: UnitTestRunner;
+    e2eTestRunner: E2eTestRunner;
+    prefix: string;
+    appProjectRoot: string;
+    appProjectSourceRoot: string;
+    e2eProjectName: string;
+    e2eProjectRoot: string;
+    parsedTags: string[];
+    outputPath: string;
+}

package/src/generators/application/lib/normalized-schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/generators/application/lib/set-app-strict-default.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export declare function setApplicationStrictDefault(host: Tree, strict: boolean): void;

package/src/generators/application/lib/set-app-strict-default.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setApplicationStrictDefault = void 0;
+const devkit_1 = require("@nx/devkit");
+function setApplicationStrictDefault(host, strict) {
+    const nxJson = (0, devkit_1.readNxJson)(host);
+    nxJson.generators = nxJson.generators || {};
+    nxJson.generators['@nx/angular:application'] =
+        nxJson.generators['@nx/angular:application'] || {};
+    nxJson.generators['@nx/angular:application'].strict =
+        nxJson.generators['@nx/angular:application'].strict ?? strict;
+    (0, devkit_1.updateNxJson)(host, nxJson);
+}
+exports.setApplicationStrictDefault = setApplicationStrictDefault;

package/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/src/generators/application/lib/set-generator-defaults.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setGeneratorDefaults = void 0;
+const devkit_1 = require("@nx/devkit");
+function setGeneratorDefaults(tree, options) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.generators = nxJson.generators ?? {};
+    nxJson.generators['@nx/angular:application'] = {
+        e2eTestRunner: options.e2eTestRunner,
+        linter: options.linter,
+        style: options.style,
+        unitTestRunner: options.unitTestRunner,
+        ...(nxJson.generators['@nx/angular:application'] || {}),
+    };
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+exports.setGeneratorDefaults = setGeneratorDefaults;

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

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

package/src/generators/application/lib/update-editor-tsconfig.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateEditorTsConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const update_app_editor_tsconfig_excluded_files_1 = require("../../utils/update-app-editor-tsconfig-excluded-files");
+function getCompilerOptionsTypes(tsConfig) {
+    return tsConfig?.compilerOptions?.types ?? [];
+}
+function updateEditorTsConfig(tree, options) {
+    const appTsConfig = (0, devkit_1.readJson)(tree, (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'tsconfig.app.json'));
+    const types = getCompilerOptionsTypes(appTsConfig);
+    if (types?.length) {
+        (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'tsconfig.editor.json'), (json) => {
+            json.compilerOptions ??= {};
+            json.compilerOptions.types = Array.from(new Set(types));
+            return json;
+        });
+    }
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.name);
+    (0, update_app_editor_tsconfig_excluded_files_1.updateAppEditorTsConfigExcludedFiles)(tree, project);
+}
+exports.updateEditorTsConfig = updateEditorTsConfig;

package/src/generators/application/schema.d.ts

@@ -0,0 +1,34 @@
+import type { ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project-name-and-root-utils';
+import type { Linter } from '@nx/eslint';
+import type { E2eTestRunner, UnitTestRunner } from '../../utils/test-runners';
+import type { Styles } from '../utils/types';
+
+export interface Schema {
+  name: string;
+  addTailwind?: boolean;
+  skipFormat?: boolean;
+  inlineStyle?: boolean;
+  inlineTemplate?: boolean;
+  viewEncapsulation?: 'Emulated' | 'Native' | 'None';
+  routing?: boolean;
+  prefix?: string;
+  style?: Styles;
+  skipTests?: boolean;
+  directory?: string;
+  projectNameAndRootFormat?: ProjectNameAndRootFormat;
+  tags?: string;
+  linter?: Linter;
+  unitTestRunner?: UnitTestRunner;
+  e2eTestRunner?: E2eTestRunner;
+  backendProject?: string;
+  strict?: boolean;
+  standaloneConfig?: boolean;
+  port?: number;
+  setParserOptionsProject?: boolean;
+  skipPackageJson?: boolean;
+  standalone?: boolean;
+  rootProject?: boolean;
+  minimal?: boolean;
+  bundler?: 'webpack' | 'esbuild';
+  ssr?: boolean;
+}