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

package/dist/src/generators/federate-module/lib/add-path-to-exposes.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPathToExposes = addPathToExposes;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+let tsModule;
+function addPathToExposes(tree, { projectPath, moduleName, modulePath }) {
+    const moduleFederationConfigPath = (0, devkit_1.joinPathFragments)(projectPath, tree.exists((0, devkit_1.joinPathFragments)(projectPath, 'module-federation.config.ts'))
+        ? 'module-federation.config.ts'
+        : 'module-federation.config.js');
+    updateExposesProperty(tree, moduleFederationConfigPath, moduleName, modulePath);
+}
+function updateExposesProperty(tree, moduleFederationConfigPath, moduleName, modulePath) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    const fileContent = tree.read(moduleFederationConfigPath, 'utf-8');
+    const source = tsModule.createSourceFile(moduleFederationConfigPath, fileContent, tsModule.ScriptTarget.ES2015, true);
+    const exposesObject = findExposes(source);
+    if (!exposesObject)
+        return;
+    const newEntry = createObjectEntry(moduleName, modulePath);
+    const updatedSourceFile = updateExposesPropertyinAST(source, exposesObject, newEntry);
+    writeToConfig(tree, moduleFederationConfigPath, source, updatedSourceFile);
+}
+function findExposes(sourceFile) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    let exposesObject = null;
+    const visit = (node) => {
+        if (tsModule.isPropertyAssignment(node) &&
+            tsModule.isIdentifier(node.name) &&
+            node.name.text === 'exposes' &&
+            tsModule.isObjectLiteralExpression(node.initializer)) {
+            exposesObject = node.initializer;
+        }
+        else {
+            tsModule.forEachChild(node, visit);
+        }
+    };
+    tsModule.forEachChild(sourceFile, visit);
+    return exposesObject;
+}
+// Create a new property assignment
+function createObjectEntry(moduleName, modulePath) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    return tsModule.factory.createPropertyAssignment(tsModule.factory.createStringLiteral(`./${moduleName}`, true), tsModule.factory.createStringLiteral(modulePath, true));
+}
+// Update the exposes property in the AST
+function updateExposesPropertyinAST(source, exposesObject, newEntry) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    const updatedExposes = tsModule.factory.updateObjectLiteralExpression(exposesObject, [...exposesObject.properties, newEntry]);
+    const transform = (context) => {
+        const visit = (node) => {
+            // Comparing nodes indirectly to ensure type compatibility. You must ensure that the nodes are identical.
+            return tsModule.isObjectLiteralExpression(node) && node === exposesObject
+                ? updatedExposes
+                : tsModule.visitEachChild(node, visit, context);
+        };
+        return (node) => tsModule.visitNode(node, visit);
+    };
+    return tsModule.transform(source, [transform]).transformed[0];
+}
+// Write the updated AST to the file (module-federation.config.js)
+function writeToConfig(tree, filename, source, updatedSourceFile) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    const printer = tsModule.createPrinter();
+    const update = printer.printNode(tsModule.EmitHint.Unspecified, updatedSourceFile, source);
+    tree.write(filename, update);
+}

package/dist/src/generators/federate-module/lib/add-path-to-ts-config.d.ts

@@ -0,0 +1,8 @@
+import { type Tree } from '@nx/devkit';
+type AddPathToTsConfigOptions = {
+    remoteName: string;
+    moduleName: string;
+    pathToFile: string;
+};
+export declare function addPathToTsConfig(tree: Tree, { remoteName, moduleName, pathToFile }: AddPathToTsConfigOptions): void;
+export {};

package/dist/src/generators/federate-module/lib/add-remote.d.ts

@@ -0,0 +1,7 @@
+import type { GeneratorCallback, Tree } from '@nx/devkit';
+import { type Schema } from '../schema';
+export declare function addRemote(tree: Tree, schema: Schema): Promise<{
+    tasks: GeneratorCallback[];
+    projectRoot: any;
+    remoteName: any;
+}>;

package/dist/src/generators/federate-module/lib/add-remote.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addRemote = addRemote;
+const tslib_1 = require("tslib");
+const internal_1 = require("@nx/devkit/internal");
+const test_runners_1 = require("../../../utils/test-runners");
+const remote_1 = tslib_1.__importDefault(require("../../remote/remote"));
+const check_remote_exists_1 = require("./check-remote-exists");
+async function addRemote(tree, schema) {
+    const tasks = [];
+    const remote = (0, check_remote_exists_1.getRemoteIfExists)(tree, schema.remote);
+    let projectRoot, remoteName;
+    if (!remote) {
+        const remoteGeneratorCallback = await (0, remote_1.default)(tree, {
+            name: schema.remote,
+            directory: schema.remoteDirectory,
+            host: schema.host,
+            standalone: schema.standalone,
+            unitTestRunner: schema.unitTestRunner,
+            e2eTestRunner: schema.e2eTestRunner ?? test_runners_1.E2eTestRunner.Cypress,
+            skipFormat: true,
+        });
+        tasks.push(remoteGeneratorCallback);
+        const { projectName, projectRoot: remoteRoot } = await (0, internal_1.determineProjectNameAndRootOptions)(tree, {
+            name: schema.remote,
+            directory: schema.remoteDirectory,
+            projectType: 'application',
+        });
+        projectRoot = remoteRoot;
+        remoteName = projectName;
+    }
+    else {
+        projectRoot = remote.root;
+        remoteName = remote.name;
+    }
+    // TODO(Colum): add implicit dependency if the path points to a file in a different project
+    return {
+        tasks,
+        projectRoot,
+        remoteName,
+    };
+}

package/dist/src/generators/federate-module/lib/check-remote-exists.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function getRemoteIfExists(tree: Tree, remote: string): false | import("@nx/devkit").ProjectConfiguration;

package/dist/src/generators/federate-module/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './add-remote';
+export * from './add-path-to-ts-config';
+export * from './add-path-to-exposes';
+export * from './add-file-to-remote-tsconfig';

package/dist/src/generators/host/host.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+import type { Schema } from './schema';
+export declare function host(tree: Tree, schema: Schema): Promise<import("@nx/devkit").GeneratorCallback>;
+export default host;

package/dist/src/generators/host/host.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.host = host;
+const tslib_1 = require("tslib");
+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 test_runners_1 = require("../../utils/test-runners");
+const application_1 = tslib_1.__importDefault(require("../application/application"));
+const convert_to_rspack_1 = tslib_1.__importDefault(require("../convert-to-rspack/convert-to-rspack"));
+const remote_1 = tslib_1.__importDefault(require("../remote/remote"));
+const setup_mf_1 = require("../setup-mf/setup-mf");
+const add_mf_env_to_inputs_1 = require("../utils/add-mf-env-to-inputs");
+const assert_mf_utils_1 = require("../utils/assert-mf-utils");
+const validations_1 = require("../utils/validations");
+const version_utils_1 = require("../utils/version-utils");
+const lib_1 = require("./lib");
+async function host(tree, schema) {
+    (0, assert_supported_angular_version_1.assertSupportedAngularVersion)(tree);
+    (0, validations_1.assertNotUsingTsSolutionSetup)(tree, 'host');
+    (0, lib_1.validateOptions)(tree, schema);
+    // TODO: Replace with Rspack when confidence is high enough
+    schema.bundler ??= 'webpack';
+    const isRspack = schema.bundler === 'rspack';
+    (0, assert_mf_utils_1.assertRspackIsCSR)(schema.bundler, schema.ssr ?? false);
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    schema.zoneless ??= angularMajorVersion >= 21 ? true : false;
+    const { typescriptConfiguration = true, ...options } = schema;
+    options.standalone = options.standalone ?? true;
+    const projects = (0, devkit_1.getProjects)(tree);
+    const remotesToGenerate = [];
+    const remotesToIntegrate = [];
+    // Check to see if remotes are provided and also check if --dynamic is provided
+    // if both are check that the remotes are valid names else throw an error.
+    if (options.dynamic && options.remotes?.length > 0) {
+        options.remotes.forEach((remote) => {
+            const isValidRemote = (0, js_1.isValidVariable)(remote);
+            if (!isValidRemote.isValid) {
+                throw new Error(`Invalid remote name provided: ${remote}. ${isValidRemote.message}`);
+            }
+        });
+    }
+    if (options.remotes && options.remotes.length > 0) {
+        options.remotes.forEach((remote) => {
+            if (!projects.has(remote)) {
+                remotesToGenerate.push(remote);
+            }
+            else {
+                remotesToIntegrate.push(remote);
+            }
+        });
+    }
+    await (0, internal_1.ensureRootProjectName)(options, 'application');
+    const { projectName: hostProjectName, projectRoot: appRoot } = await (0, internal_1.determineProjectNameAndRootOptions)(tree, {
+        name: options.name,
+        projectType: 'application',
+        directory: options.directory,
+    });
+    const hostPort = options.port ?? 4200;
+    const appInstallTask = await (0, application_1.default)(tree, {
+        ...options,
+        standalone: options.standalone,
+        routing: true,
+        port: hostPort,
+        skipFormat: true,
+        bundler: 'webpack',
+    });
+    const skipE2E = !options.e2eTestRunner || options.e2eTestRunner === test_runners_1.E2eTestRunner.None;
+    await (0, setup_mf_1.setupMf)(tree, {
+        appName: hostProjectName,
+        mfType: 'host',
+        routing: true,
+        port: hostPort,
+        remotes: remotesToIntegrate ?? [],
+        federationType: options.dynamic ? 'dynamic' : 'static',
+        skipPackageJson: options.skipPackageJson,
+        skipFormat: true,
+        skipE2E,
+        e2eProjectName: skipE2E ? undefined : `${hostProjectName}-e2e`,
+        prefix: options.prefix,
+        typescriptConfiguration,
+        standalone: options.standalone,
+        setParserOptionsProject: options.setParserOptionsProject,
+    });
+    let installTasks = [appInstallTask];
+    if (options.ssr) {
+        let ssrInstallTask = await (0, lib_1.updateSsrSetup)(tree, options, hostProjectName, typescriptConfiguration);
+        installTasks.push(ssrInstallTask);
+    }
+    for (let i = 0; i < remotesToGenerate.length; i++) {
+        const remote = remotesToGenerate[i];
+        const remoteDirectory = options.directory
+            ? (0, devkit_1.joinPathFragments)(options.directory, '..', remote)
+            : appRoot === '.'
+                ? remote
+                : (0, devkit_1.joinPathFragments)(appRoot, '..', remote);
+        await (0, remote_1.default)(tree, {
+            ...options,
+            name: remote,
+            directory: remoteDirectory,
+            host: hostProjectName,
+            port: isRspack ? hostPort + i + 1 : undefined,
+            skipFormat: true,
+            standalone: options.standalone,
+            typescriptConfiguration,
+        });
+    }
+    (0, add_mf_env_to_inputs_1.addMfEnvToTargetDefaultInputs)(tree);
+    if (isRspack) {
+        await (0, convert_to_rspack_1.default)(tree, {
+            project: hostProjectName,
+            skipInstall: options.skipPackageJson,
+            skipFormat: true,
+        });
+    }
+    const project = (0, devkit_1.readProjectConfiguration)(tree, hostProjectName);
+    project.targets.serve ??= {};
+    project.targets.serve.options ??= {};
+    project.targets.serve.options.port = hostPort;
+    (0, devkit_1.updateProjectConfiguration)(tree, hostProjectName, project);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...installTasks);
+}
+exports.default = host;

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

@@ -0,0 +1,2 @@
+export * from './update-ssr-setup';
+export * from './validate-options';

package/dist/src/generators/host/lib/update-ssr-setup.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from '../schema';
+export declare function updateSsrSetup(tree: Tree, options: Schema, appName: string, typescriptConfiguration: boolean): Promise<import("@nx/devkit").GeneratorCallback>;

package/dist/src/generators/host/lib/update-ssr-setup.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSsrSetup = updateSsrSetup;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+const path_1 = require("path");
+const versions_1 = require("../../../utils/versions");
+const version_utils_1 = require("../../utils/version-utils");
+async function updateSsrSetup(tree, options, appName, typescriptConfiguration) {
+    let project = (0, devkit_1.readProjectConfiguration)(tree, appName);
+    const sourceRoot = (0, internal_1.getProjectSourceRoot)(project, tree);
+    tree.rename((0, devkit_1.joinPathFragments)(sourceRoot, 'main.server.ts'), (0, devkit_1.joinPathFragments)(sourceRoot, 'bootstrap.server.ts'));
+    const pathToServerEntry = (0, devkit_1.joinPathFragments)(sourceRoot, 'server.ts');
+    tree.write(pathToServerEntry, `import('./main.server');`);
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, '../files/common'), project.root, {
+        appName,
+        browserBundleOutput: project.targets.build.options.outputPath,
+        standalone: options.standalone,
+        zoneless: options.zoneless,
+        useDefaultImport: angularMajorVersion >= 21,
+        angularMajorVersion,
+        tmpl: '',
+    });
+    const pathToTemplateFiles = typescriptConfiguration ? 'ts' : 'js';
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, '../files', pathToTemplateFiles), project.root, {
+        tmpl: '',
+    });
+    // update project.json
+    project = (0, devkit_1.readProjectConfiguration)(tree, appName);
+    project.targets.server.executor = '@nx/angular:webpack-server';
+    project.targets.server.options.customWebpackConfig = {
+        path: (0, devkit_1.joinPathFragments)(project.root, `webpack.server.config.${pathToTemplateFiles}`),
+    };
+    if (project.targets.server.configurations &&
+        project.targets.server.configurations.development) {
+        if ('vendorChunk' in project.targets.server.configurations.development) {
+            delete project.targets.server.configurations.development.vendorChunk;
+        }
+    }
+    project.targets['serve-ssr'].executor =
+        '@nx/angular:module-federation-dev-ssr';
+    (0, devkit_1.updateProjectConfiguration)(tree, appName, project);
+    if (!options.skipPackageJson) {
+        return (0, devkit_1.addDependenciesToPackageJson)(tree, {
+            cors: versions_1.corsVersion,
+            '@module-federation/node': versions_1.moduleFederationNodeVersion,
+        }, {
+            '@types/cors': versions_1.typesCorsVersion,
+        });
+    }
+    return () => { };
+}

package/dist/src/generators/host/lib/validate-options.d.ts

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

package/dist/src/generators/host/schema.d.ts

@@ -0,0 +1,32 @@
+import type { Linter, LinterType } from '@nx/eslint';
+import type { E2eTestRunner, UnitTestRunner } from '../../utils/test-runners';
+import type { Styles } from '../utils/types';
+
+export interface Schema {
+  directory: string;
+  name?: string;
+  bundler?: 'webpack' | 'rspack';
+  port?: number;
+  remotes?: string[];
+  dynamic?: boolean;
+  setParserOptionsProject?: boolean;
+  skipPackageJson?: boolean;
+  skipPostInstall?: boolean;
+  prefix?: string;
+  style?: Styles;
+  skipTests?: boolean;
+  tags?: string;
+  linter?: Linter | LinterType;
+  unitTestRunner?: Exclude<UnitTestRunner, UnitTestRunner.VitestAngular>;
+  e2eTestRunner?: E2eTestRunner;
+  backendProject?: string;
+  strict?: boolean;
+  inlineStyle?: boolean;
+  inlineTemplate?: boolean;
+  viewEncapsulation?: 'Emulated' | 'Native' | 'None';
+  skipFormat?: boolean;
+  standalone?: boolean;
+  ssr?: boolean;
+  zoneless?: boolean;
+  typescriptConfiguration?: boolean;
+}

package/dist/src/generators/host/schema.json

@@ -0,0 +1,190 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxMFHost",
+  "cli": "nx",
+  "title": "Nx Module Federation Consumer (Host) Application",
+  "description": "Create an Angular Consumer (Host) Module Federation Application.",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g @nx/angular:host appName --remotes=remote1",
+      "description": "Create an Angular application with configuration in place for Module Federation. If the `remotes` option is provided, attach the Producer (remote) application to this application's configuration"
+    },
+    {
+      "command": "nx g @nx/angular:consumer appName --producers=remote1",
+      "description": "Create an Angular application with configuration in place for Module Federation. If the `producers` option is provided, attach the Producer (remote) application to this application's configuration"
+    }
+  ],
+  "properties": {
+    "directory": {
+      "description": "The directory of the new application.",
+      "type": "string",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "Which directory do you want to create the application in?"
+    },
+    "name": {
+      "type": "string",
+      "description": "The name to give to the Consumer (host) Angular application.",
+      "pattern": "^[a-zA-Z][^:]*$",
+      "x-priority": "important"
+    },
+    "remotes": {
+      "type": "array",
+      "description": "The names of the Producers (remote) applications to add to the Consumer (host).",
+      "x-priority": "important",
+      "alias": "producers"
+    },
+    "bundler": {
+      "type": "string",
+      "description": "The bundler to use for the host application.",
+      "default": "webpack",
+      "enum": ["webpack", "rspack"]
+    },
+    "port": {
+      "type": "number",
+      "description": "The port at which the Consumer (host) application should be served. Defaults to 4200."
+    },
+    "dynamic": {
+      "type": "boolean",
+      "description": "Should the host application use dynamic federation?",
+      "default": false
+    },
+    "style": {
+      "description": "The file extension to be used for style files.",
+      "type": "string",
+      "default": "css",
+      "enum": ["css", "scss", "sass", "less"],
+      "x-prompt": {
+        "message": "Which stylesheet format would you like to use?",
+        "type": "list",
+        "items": [
+          {
+            "value": "css",
+            "label": "CSS"
+          },
+          {
+            "value": "scss",
+            "label": "SASS(.scss)  [ https://sass-lang.com   ]"
+          },
+          {
+            "value": "sass",
+            "label": "SASS(.sass)  [ https://sass-lang.com   ]"
+          },
+          {
+            "value": "less",
+            "label": "LESS         [ https://lesscss.org     ]"
+          }
+        ]
+      }
+    },
+    "inlineStyle": {
+      "description": "Specifies if the style will be in the ts file.",
+      "type": "boolean",
+      "default": false,
+      "alias": "s"
+    },
+    "inlineTemplate": {
+      "description": "Specifies if the template will be in the ts file.",
+      "type": "boolean",
+      "default": false,
+      "alias": "t"
+    },
+    "viewEncapsulation": {
+      "description": "Specifies the view encapsulation strategy.",
+      "enum": ["Emulated", "None", "ShadowDom"],
+      "type": "string"
+    },
+    "prefix": {
+      "type": "string",
+      "format": "html-selector",
+      "description": "The prefix to apply to generated selectors.",
+      "alias": "p"
+    },
+    "skipTests": {
+      "description": "Skip creating spec files.",
+      "type": "boolean",
+      "default": false,
+      "alias": "S"
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "skipPostInstall": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add or append `ngcc` to the `postinstall` script in `package.json`.",
+      "x-priority": "internal"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["vitest-analog", "jest", "none"],
+      "description": "Test runner to use for unit tests. `vitest-analog` uses AnalogJS-based setup with `@nx/vitest`. It defaults to `vitest-analog` for Angular versions >= 21.0.0, otherwise `jest`.",
+      "x-prompt": "Which unit test runner would you like to use?"
+    },
+    "e2eTestRunner": {
+      "type": "string",
+      "enum": ["playwright", "cypress", "none"],
+      "description": "Test runner to use for end to end (E2E) tests.",
+      "x-prompt": "Which E2E test runner would you like to use?",
+      "default": "playwright"
+    },
+    "tags": {
+      "type": "string",
+      "description": "Add tags to the application (used for linting)."
+    },
+    "linter": {
+      "description": "The tool to use for running lint checks.",
+      "type": "string",
+      "enum": ["eslint", "none"],
+      "default": "eslint"
+    },
+    "backendProject": {
+      "type": "string",
+      "description": "Backend project that provides data to this application. This sets up `proxy.config.json`."
+    },
+    "strict": {
+      "type": "boolean",
+      "description": "Create an application with stricter type checking and build optimization options.",
+      "default": true
+    },
+    "setParserOptionsProject": {
+      "type": "boolean",
+      "description": "Whether or not to configure the ESLint `parserOptions.project` option. We do not do this by default for lint performance reasons.",
+      "default": false
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "standalone": {
+      "type": "boolean",
+      "description": "Whether to generate a Consumer (host) application that uses standalone components.",
+      "default": true
+    },
+    "ssr": {
+      "description": "Whether to configure SSR for the Consumer (host) application",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "important"
+    },
+    "zoneless": {
+      "description": "Generate an application that does not use `zone.js`. It defaults to `true`. _Note: this is only supported in Angular versions >= 21.0.0_",
+      "type": "boolean"
+    },
+    "typescriptConfiguration": {
+      "type": "boolean",
+      "description": "Whether the module federation configuration and webpack configuration files should use TS.",
+      "default": true
+    }
+  },
+  "additionalProperties": false,
+  "required": ["directory"]
+}

package/dist/src/generators/init/init.d.ts

@@ -0,0 +1,4 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+import { Schema } from './schema';
+export declare function angularInitGenerator(tree: Tree, options: Schema): Promise<GeneratorCallback>;
+export default angularInitGenerator;

package/dist/src/generators/init/init.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.angularInitGenerator = angularInitGenerator;
+const internal_1 = require("@nx/devkit/internal");
+const devkit_1 = require("@nx/devkit");
+const plugin_1 = require("../../plugins/plugin");
+const assert_supported_angular_version_1 = require("../../utils/assert-supported-angular-version");
+const validations_1 = require("../utils/validations");
+const version_utils_1 = require("../utils/version-utils");
+async function angularInitGenerator(tree, options) {
+    (0, assert_supported_angular_version_1.assertSupportedAngularVersion)(tree);
+    (0, validations_1.assertNotUsingTsSolutionSetup)(tree, 'init');
+    ignoreAngularCacheDirectory(tree);
+    const installTask = installAngularDevkitCoreIfMissing(tree, options);
+    // For Angular inference plugin, we only want it during import since our
+    // generators do not use `angular.json`, and `nx init` should split
+    // `angular.json` into multiple `project.json` files -- as this is preferred
+    // by most folks we've talked to.
+    options.addPlugin ??= process.env.NX_RUNNING_NX_IMPORT === 'true';
+    if (options.addPlugin) {
+        await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/angular/plugin', plugin_1.createNodes, {
+            targetNamePrefix: ['', 'angular:', 'angular-'],
+        }, options.updatePackageScripts);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return installTask;
+}
+function installAngularDevkitCoreIfMissing(tree, options) {
+    const packageVersion = (0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@angular-devkit/core');
+    if (!packageVersion) {
+        const pkgVersions = (0, version_utils_1.versions)(tree);
+        const devkitVersion = (0, version_utils_1.getInstalledAngularDevkitVersion)(tree) ??
+            pkgVersions.angularDevkitVersion;
+        try {
+            (0, devkit_1.ensurePackage)('@angular-devkit/core', devkitVersion);
+        }
+        catch {
+            // @schematics/angular cannot be required so this fails but this will still allow wrapping the schematic later on
+        }
+        if (!options.skipPackageJson) {
+            return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { ['@angular-devkit/core']: devkitVersion }, undefined, options.keepExistingVersions);
+        }
+    }
+    return () => { };
+}
+function ignoreAngularCacheDirectory(tree) {
+    const { cli } = (0, devkit_1.readNxJson)(tree);
+    // angular-specific cli config is supported though is not included in the
+    // NxJsonConfiguration type
+    const angularCacheDir = cli?.cache?.path ?? '.angular';
+    addGitIgnoreEntry(tree, angularCacheDir);
+    addPrettierIgnoreEntry(tree, angularCacheDir);
+}
+function addGitIgnoreEntry(tree, entry) {
+    if (tree.exists('.gitignore')) {
+        let content = tree.read('.gitignore', 'utf-8');
+        if (/^\.angular$/gm.test(content)) {
+            return;
+        }
+        content = `${content}\n${entry}\n`;
+        tree.write('.gitignore', content);
+    }
+    else {
+        devkit_1.logger.warn(`Couldn't find .gitignore file to update`);
+    }
+}
+function addPrettierIgnoreEntry(tree, entry) {
+    if (!tree.exists('.prettierignore')) {
+        return;
+    }
+    let content = tree.read('.prettierignore', 'utf-8');
+    if (/^\.angular(\/cache)?$/gm.test(content)) {
+        return;
+    }
+    content = `${content}\n${entry}\n`;
+    tree.write('.prettierignore', content);
+}
+exports.default = angularInitGenerator;

package/dist/src/generators/library/lib/add-children.d.ts

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