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

package/dist/src/generators/utils/testing.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTestApplication = generateTestApplication;
+exports.generateTestHostApplication = generateTestHostApplication;
+exports.generateTestRemoteApplication = generateTestRemoteApplication;
+exports.generateTestLibrary = generateTestLibrary;
+exports.createStorybookTestWorkspaceForLib = createStorybookTestWorkspaceForLib;
+const devkit_1 = require("@nx/devkit");
+const testing_1 = require("@nx/devkit/testing");
+const internal_1 = require("@nx/js/internal");
+const test_runners_1 = require("../../utils/test-runners");
+const application_1 = require("../application/application");
+const component_1 = require("../component/component");
+const host_1 = require("../host/host");
+const library_1 = require("../library/library");
+const remote_1 = require("../remote/remote");
+async function generateTestApplication(tree, options) {
+    tree.write('.gitignore', '');
+    await (0, application_1.applicationGenerator)(tree, {
+        ...options,
+    });
+}
+async function generateTestHostApplication(tree, options) {
+    tree.write('.gitignore', '');
+    await (0, host_1.host)(tree, { ...options });
+}
+async function generateTestRemoteApplication(tree, options) {
+    tree.write('.gitignore', '');
+    await (0, remote_1.remote)(tree, { ...options });
+}
+async function generateTestLibrary(tree, options) {
+    tree.write('.gitignore', '');
+    await (0, library_1.libraryGenerator)(tree, {
+        ...options,
+    });
+}
+async function createStorybookTestWorkspaceForLib(libName) {
+    let tree = (0, testing_1.createTreeWithEmptyWorkspace)({ layout: 'apps-libs' });
+    tree.write('.gitignore', '');
+    await (0, library_1.libraryGenerator)(tree, {
+        directory: libName,
+        buildable: false,
+        linter: 'eslint',
+        publishable: false,
+        skipFormat: true,
+        unitTestRunner: test_runners_1.UnitTestRunner.Jest,
+        standalone: false,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'test-button',
+        path: `${libName}/src/lib/test-button/test-button`,
+        standalone: false,
+        skipFormat: true,
+    });
+    tree.write(`${libName}/src/lib/test-button/test-button.ts`, `import { Component, Input } from '@angular/core';
+
+export type ButtonStyle = 'default' | 'primary' | 'accent';
+
+@Component({
+  selector: 'proj-test-button',
+  templateUrl: './test-button.html',
+  styleUrls: ['./test-button.css']
+})
+export class TestButton {
+  @Input('buttonType') type = 'button';
+  @Input() style: ButtonStyle = 'default';
+  @Input() age?: number;
+  @Input() isOn = false;
+}`);
+    tree.write(`${libName}/src/lib/test-button/test-button.html`, `<button [attr.type]="type" [ngClass]="style"></button>`);
+    const modulePath = `${libName}/src/lib/${libName}-module.ts`;
+    tree.write(modulePath, `import * as ButtonExports from './test-button/test-button';
+    ${tree.read(modulePath)}`);
+    // create a module with component that gets exported in a barrel file
+    generateModule(tree, {
+        name: 'barrel',
+        project: libName,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'barrel-button',
+        path: `${libName}/src/lib/barrel/barrel-button/barrel-button`,
+        module: 'barrel',
+        standalone: false,
+        skipFormat: true,
+    });
+    tree.write(`${libName}/src/lib/barrel/barrel-button/index.ts`, `export * from './barrel-button';`);
+    tree.write(`${libName}/src/lib/barrel/barrel-module.ts`, `import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BarrelButton } from './barrel-button';
+
+@NgModule({
+  imports: [CommonModule],
+  declarations: [BarrelButton],
+})
+export class BarrelModule {}`);
+    // create a module with components that get Angular exported and declared by variable
+    generateModule(tree, {
+        name: 'variable-declare',
+        project: libName,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'variable-declare-button',
+        path: `${libName}/src/lib/variable-declare/variable-declare-button/variable-declare-button`,
+        module: 'variable-declare',
+        standalone: false,
+        skipFormat: true,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'variable-declare-view',
+        path: `${libName}/src/lib/variable-declare/variable-declare-view/variable-declare-view`,
+        module: 'variable-declare',
+        standalone: false,
+        skipFormat: true,
+    });
+    tree.write(`${libName}/src/lib/variable-declare/variable-declare-module.ts`, `import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { VariableDeclareButton } from './variable-declare-button/variable-declare-button';
+import { VariableDeclareView } from './variable-declare-view/variable-declare-view';
+
+const COMPONENTS = [
+  VariableDeclareButton,
+  VariableDeclareView
+]
+
+@NgModule({
+  imports: [CommonModule],
+  declarations: COMPONENTS,
+  exports: COMPONENTS
+})
+export class VariableDeclareModule {}`);
+    // create a module with components that get Angular exported and declared by variable
+    generateModule(tree, {
+        name: 'variable-spread-declare',
+        project: libName,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'variable-spread-declare-button',
+        path: `${libName}/src/lib/variable-spread-declare/variable-spread-declare-button/variable-spread-declare-button`,
+        module: 'variable-spread-declare',
+        standalone: false,
+        skipFormat: true,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'variable-spread-declare-view',
+        path: `${libName}/src/lib/variable-spread-declare/variable-spread-declare-view/variable-spread-declare-view`,
+        module: 'variable-spread-declare',
+        standalone: false,
+        skipFormat: true,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'variable-spread-declare-anotherview',
+        path: `${libName}/src/lib/variable-spread-declare/variable-spread-declare-anotherview/variable-spread-declare-anotherview`,
+        module: 'variable-spread-declare',
+        standalone: false,
+        skipFormat: true,
+    });
+    tree.write(`${libName}/src/lib/variable-spread-declare/variable-spread-declare-module.ts`, `import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { VariableSpreadDeclareButton } from './variable-spread-declare-button/variable-spread-declare-button';
+import { VariableSpreadDeclareView } from './variable-spread-declare-view/variable-spread-declare-view';
+import { VariableSpreadDeclareAnotherview } from './variable-spread-declare-anotherview/variable-spread-declare-anotherview';
+
+const COMPONENTS = [
+  VariableSpreadDeclareButton,
+  VariableSpreadDeclareView
+]
+
+@NgModule({
+  imports: [CommonModule],
+  declarations: [...COMPONENTS, VariableSpreadDeclareAnotherview],
+})
+export class VariableSpreadDeclareModule {}`);
+    // create a module where declared components are pulled from a static member of the module
+    generateModule(tree, {
+        name: 'static-member-declarations',
+        project: libName,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'cmp1',
+        path: `${libName}/src/lib/static-member-declarations/cmp1/cmp1`,
+        module: 'static-member-declarations',
+        standalone: false,
+        skipFormat: true,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'cmp2',
+        path: `${libName}/src/lib/static-member-declarations/cmp2/cmp2`,
+        module: 'static-member-declarations',
+        standalone: false,
+        skipFormat: true,
+    });
+    tree.write(`${libName}/src/lib/static-member-declarations/static-member-declarations-module.ts`, `import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { Cmp1 } from './cmp1/cmp1';
+import { Cmp2 } from './cmp2/cmp2';
+
+@NgModule({
+  imports: [CommonModule],
+  declarations: StaticMemberDeclarationsModule.COMPONENTS,
+  exports: StaticMemberDeclarationsModule.COMPONENTS
+})
+export class StaticMemberDeclarationsModule {
+  static readonly COMPONENTS = [Cmp1, Cmp2];
+}`);
+    // create another button in a nested subpath
+    generateModule(tree, {
+        name: 'nested',
+        project: libName,
+        path: `${libName}/src/lib`,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'nested-button',
+        module: 'nested',
+        path: `${libName}/src/lib/nested/nested-button/nested-button`,
+        standalone: false,
+        skipFormat: true,
+    });
+    await (0, component_1.componentGenerator)(tree, {
+        name: 'test-other',
+        path: `${libName}/src/lib/test-other/test-other`,
+        standalone: false,
+        skipFormat: true,
+    });
+    return tree;
+}
+function generateModule(tree, options) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    if (options.path === undefined) {
+        const sourceRoot = (0, internal_1.getProjectSourceRoot)(project, tree);
+        const projectDirName = project.projectType === 'application' ? 'app' : 'lib';
+        options.path = `${sourceRoot}/${projectDirName}`;
+    }
+    const moduleNames = (0, devkit_1.names)(options.name);
+    const moduleFilePath = `${options.path}/${moduleNames.fileName}/${moduleNames.fileName}-module.ts`;
+    tree.write(moduleFilePath, `import { NgModule } from '@angular/core';
+  import { CommonModule } from '@angular/common';
+
+  @NgModule({
+    declarations: [],
+    imports: [CommonModule],
+  })
+  export class ${moduleNames.className}Module {}`);
+}

package/dist/src/generators/utils/tsconfig-utils.d.ts

@@ -0,0 +1,12 @@
+import type { Tree } from '@nx/devkit';
+import type * as ts from 'typescript';
+/**
+ * Gets the resolved value of a specific compiler option from the TypeScript configuration hierarchy.
+ *
+ * @param tree - The file system tree
+ * @param tsConfigPath - Path to the tsconfig file to resolve
+ * @param optionName - Name of the compiler option to retrieve
+ * @returns The resolved value of the compiler option, or undefined if not set
+ */
+export declare function getDefinedCompilerOption(tree: Tree, tsConfigPath: string, optionName: keyof ts.CompilerOptions): any | undefined;
+export declare function readCompilerOptionsFromTsConfig(tree: Tree, tsConfigPath: string): ts.CompilerOptions;

package/dist/src/generators/utils/tsconfig-utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefinedCompilerOption = getDefinedCompilerOption;
+exports.readCompilerOptionsFromTsConfig = readCompilerOptionsFromTsConfig;
+const internal_1 = require("@nx/js/internal");
+const node_path_1 = require("node:path");
+/**
+ * Gets the resolved value of a specific compiler option from the TypeScript configuration hierarchy.
+ *
+ * @param tree - The file system tree
+ * @param tsConfigPath - Path to the tsconfig file to resolve
+ * @param optionName - Name of the compiler option to retrieve
+ * @returns The resolved value of the compiler option, or undefined if not set
+ */
+function getDefinedCompilerOption(tree, tsConfigPath, optionName) {
+    const compilerOptions = readCompilerOptionsFromTsConfig(tree, tsConfigPath);
+    return compilerOptions[optionName];
+}
+function readCompilerOptionsFromTsConfig(tree, tsConfigPath) {
+    const ts = (0, internal_1.ensureTypescript)();
+    const tsSysFromTree = {
+        ...ts.sys,
+        readDirectory: () => [],
+        readFile: (path) => tree.read(path, 'utf-8'),
+        fileExists: (path) => tree.exists(path),
+    };
+    const parsed = ts.parseJsonConfigFileContent(ts.readConfigFile(tsConfigPath, tsSysFromTree.readFile).config, tsSysFromTree, (0, node_path_1.dirname)(tsConfigPath));
+    return parsed.options;
+}

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

@@ -0,0 +1 @@
+export type Styles = 'css' | 'less' | 'scss' | 'sass';

package/dist/src/generators/utils/update-app-editor-tsconfig-excluded-files.d.ts

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

package/dist/src/generators/utils/update-project-root-tsconfig.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export { extractTsConfigBase } from '@nx/js';
+export declare function updateProjectRootTsConfig(host: Tree, projectRoot: string, relativePathToRootTsConfig: string, isRootProject?: boolean): void;

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

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+export declare function validateProject(tree: Tree, projectName: string): void;
+export declare function validateClassName(className: string): void;
+export declare function assertNotUsingTsSolutionSetup(tree: Tree, generatorName: string): void;

package/dist/src/generators/utils/validations.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProject = validateProject;
+exports.validateClassName = validateClassName;
+exports.assertNotUsingTsSolutionSetup = assertNotUsingTsSolutionSetup;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+function validateProject(tree, projectName) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    if (!projects.has(projectName)) {
+        throw new Error(`Project "${projectName}" does not exist! Please provide an existing project name.`);
+    }
+}
+// The below validation matches that of the Angular CLI:
+// https://github.com/angular/angular-cli/blob/1316930a1cbad8e71a4454743862cfa9253bef4e/packages/schematics/angular/utility/validation.ts#L25
+// See: https://github.com/tc39/proposal-regexp-unicode-property-escapes/blob/fe6d07fad74cd0192d154966baa1e95e7cda78a1/README.md#other-examples
+const ecmaIdentifierNameRegExp = /^(?:[$_\p{ID_Start}])(?:[$_\u200C\u200D\p{ID_Continue}])*$/u;
+function validateClassName(className) {
+    if (!ecmaIdentifierNameRegExp.test(className)) {
+        throw new Error(`Class name "${className}" is invalid.`);
+    }
+}
+function assertNotUsingTsSolutionSetup(tree, generatorName) {
+    if (process.env.NX_IGNORE_UNSUPPORTED_TS_SETUP === 'true' ||
+        !(0, internal_1.isUsingTsSolutionSetup)(tree)) {
+        return;
+    }
+    const artifactString = generatorName === 'init'
+        ? `"@nx/angular" plugin`
+        : `"@nx/angular:${generatorName}" generator`;
+    devkit_1.output.error({
+        title: `The ${artifactString} doesn't support the existing TypeScript setup`,
+        bodyLines: [
+            `The Angular framework doesn't support a TypeScript setup with project references. See https://github.com/angular/angular/issues/37276 for more details.`,
+            `You can ignore this error, at your own risk, by setting the "NX_IGNORE_UNSUPPORTED_TS_SETUP" environment variable to "true".`,
+        ],
+    });
+    throw new Error(`The ${artifactString} doesn't support the existing TypeScript setup. See the error above.`);
+}

package/dist/src/generators/utils/version-utils.d.ts

@@ -0,0 +1,29 @@
+import { type Tree } from '@nx/devkit';
+import { type PackageCompatVersions, type SupportedVersion, supportedVersions, type VersionMap } from '../../utils/backward-compatible-versions';
+export declare function getInstalledAngularDevkitVersion(tree: Tree): string | null;
+export declare function getInstalledAngularVersion(tree: Tree): string;
+export declare function getInstalledAngularMajorVersion(tree: Tree): number;
+export declare function getInstalledAngularVersionInfo(tree: Tree): {
+    version: string;
+    major: number;
+};
+export declare function getInstalledPackageVersionInfo(tree: Tree, pkgName: string): {
+    major: number;
+    version: string;
+};
+export declare function versions(tree: Tree): PackageCompatVersions;
+export declare function versions<V extends SupportedVersion>(tree: Tree, options: {
+    minAngularMajorVersion: V;
+}): MinVersionReturnType<V>;
+/**
+ * Temporary helper to abstract away the version of angular-rspack to be installed
+ * until we stop supporting Angular 19.
+ */
+export declare function getAngularRspackVersion(tree: Tree): string;
+type TakeUntil<Arr extends readonly any[], Target> = Arr extends readonly [
+    infer Head,
+    ...infer Rest
+] ? Head extends Target ? [Head] : [Head, ...TakeUntil<Rest, Target>] : [];
+type VersionsAtLeast<MinV extends SupportedVersion> = Extract<SupportedVersion, TakeUntil<typeof supportedVersions, MinV>[number]>;
+type MinVersionReturnType<MinV extends SupportedVersion> = VersionMap[VersionsAtLeast<MinV>];
+export {};

package/dist/src/generators/utils/version-utils.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstalledAngularDevkitVersion = getInstalledAngularDevkitVersion;
+exports.getInstalledAngularVersion = getInstalledAngularVersion;
+exports.getInstalledAngularMajorVersion = getInstalledAngularMajorVersion;
+exports.getInstalledAngularVersionInfo = getInstalledAngularVersionInfo;
+exports.getInstalledPackageVersionInfo = getInstalledPackageVersionInfo;
+exports.versions = versions;
+exports.getAngularRspackVersion = getAngularRspackVersion;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const semver_1 = require("semver");
+const backward_compatible_versions_1 = require("../../utils/backward-compatible-versions");
+const latestVersions = tslib_1.__importStar(require("../../utils/versions"));
+const versions_1 = require("../../utils/versions");
+function getInstalledAngularDevkitVersion(tree) {
+    return ((0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@angular-devkit/build-angular') ?? (0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@angular/build'));
+}
+function getInstalledAngularVersion(tree) {
+    return (0, internal_1.getDeclaredPackageVersion)(tree, '@angular/core', versions_1.angularVersion);
+}
+function getInstalledAngularMajorVersion(tree) {
+    return (0, semver_1.major)(getInstalledAngularVersion(tree));
+}
+function getInstalledAngularVersionInfo(tree) {
+    const installedVersion = getInstalledAngularVersion(tree);
+    return {
+        version: installedVersion,
+        major: (0, semver_1.major)(installedVersion),
+    };
+}
+function getInstalledPackageVersionInfo(tree, pkgName) {
+    const version = (0, devkit_1.getDependencyVersionFromPackageJson)(tree, pkgName);
+    return version ? { major: (0, semver_1.major)((0, semver_1.coerce)(version)), version } : null;
+}
+function versions(tree, options) {
+    const majorAngularVersion = getInstalledAngularMajorVersion(tree);
+    if (options?.minAngularMajorVersion &&
+        majorAngularVersion < options.minAngularMajorVersion) {
+        throw new Error(`This operation requires Angular ${options.minAngularMajorVersion}+, but found version ${majorAngularVersion}. ` +
+            `This shouldn't happen. Please report it as a bug and include the stack trace.`);
+    }
+    return backward_compatible_versions_1.backwardCompatibleVersions[majorAngularVersion] ?? latestVersions;
+}
+/**
+ * Temporary helper to abstract away the version of angular-rspack to be installed
+ * until we stop supporting Angular 19.
+ */
+function getAngularRspackVersion(tree) {
+    const majorAngularVersion = getInstalledAngularMajorVersion(tree);
+    // Starting with Angular 20, we can use an Angular Rspack version that is
+    // aligned with the Nx version
+    return majorAngularVersion === 19
+        ? backward_compatible_versions_1.backwardCompatibleVersions[19].angularRspackVersion
+        : latestVersions.nxVersion;
+}

package/dist/src/generators/web-worker/lib/add-snippet.d.ts

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

package/dist/src/generators/web-worker/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './normalize-options';
+export * from './add-snippet';

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

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

package/dist/src/generators/web-worker/web-worker.d.ts

@@ -0,0 +1,4 @@
+import type { Tree } from '@nx/devkit';
+import type { WebWorkerGeneratorOptions } from './schema';
+export declare function webWorkerGenerator(tree: Tree, rawOptions: WebWorkerGeneratorOptions): Promise<void>;
+export default webWorkerGenerator;

package/dist/src/generators/web-worker/web-worker.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webWorkerGenerator = webWorkerGenerator;
+const devkit_1 = require("@nx/devkit");
+const assert_supported_angular_version_1 = require("../../utils/assert-supported-angular-version");
+const lib_1 = require("./lib");
+const js_1 = require("@nx/js");
+async function webWorkerGenerator(tree, rawOptions) {
+    (0, assert_supported_angular_version_1.assertSupportedAngularVersion)(tree);
+    const options = (0, lib_1.normalizeOptions)(tree, rawOptions);
+    const workerNames = (0, devkit_1.names)(options.name);
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const substitutions = {
+        rootOffset: (0, devkit_1.offsetFromRoot)(projectConfig.root),
+        rootTsConfig: (0, js_1.getRelativePathToRootTsConfig)(tree, projectConfig.root),
+        name: workerNames.fileName,
+        tpl: '',
+    };
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, './files/worker'), options.path, substitutions);
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, './files/config'), projectConfig.root, substitutions);
+    if (options.snippet) {
+        (0, lib_1.addSnippet)(tree, workerNames.fileName, options.path);
+    }
+    projectConfig.targets['build'].options.webWorkerTsConfig ??=
+        (0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.worker.json');
+    if (projectConfig.targets['test']) {
+        projectConfig.targets['test'].options.webWorkerTsConfig ??=
+            (0, devkit_1.joinPathFragments)(projectConfig.root, 'tsconfig.worker.json');
+    }
+    (0, devkit_1.updateProjectConfiguration)(tree, options.project, projectConfig);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.default = webWorkerGenerator;

package/dist/src/migrations/update-19-2-1/add-typescript-eslint-utils.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export declare const typescriptEslintUtilsVersion = "^7.16.0";
+export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-19-5-0/update-angular-cli.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export declare const angularCliVersion = "~18.1.0";
+export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-19-6-0/turn-off-dts-by-default.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-19-6-0/update-angular-cli.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export declare const angularCliVersion = "~18.2.0";
+export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-19-6-1/ensure-depends-on-for-mf.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-19-6-1/ensure-depends-on-for-mf.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+async function default_1(tree) {
+    let usesModuleFederation = false;
+    (0, internal_1.forEachExecutorOptions)(tree, '@nx/angular:webpack-browser', (options) => {
+        const webpackConfig = options.webpackConfig;
+        if (!webpackConfig) {
+            return;
+        }
+        const webpackContents = tree.read(webpackConfig, 'utf-8');
+        if (['withModuleFederation', 'withModuleFederationForSSR'].some((p) => webpackContents.includes(p))) {
+            usesModuleFederation = true;
+        }
+    });
+    if (!usesModuleFederation) {
+        return;
+    }
+    const nxJson = (0, devkit_1.readNxJson)(tree) ?? {};
+    const nxMFDevRemotesEnvVar = 'NX_MF_DEV_REMOTES';
+    const webpackExecutor = '@nx/angular:webpack-browser';
+    const defaultInputs = [
+        ...(nxJson.namedInputs && 'production' in nxJson.namedInputs
+            ? ['production', '^production']
+            : ['default', '^default']),
+        { env: nxMFDevRemotesEnvVar },
+    ];
+    const existing = (0, internal_1.normalizeTargetDefaults)(nxJson.targetDefaults).find((e) => e.executor === webpackExecutor &&
+        e.target === undefined &&
+        e.projects === undefined &&
+        e.plugin === undefined);
+    if (!existing) {
+        (0, internal_1.upsertTargetDefault)(tree, nxJson, {
+            executor: webpackExecutor,
+            cache: true,
+            inputs: defaultInputs,
+            dependsOn: ['^build'],
+        });
+    }
+    else {
+        const dependsOn = [...(existing.dependsOn ?? [])];
+        if (!dependsOn.includes('^build'))
+            dependsOn.push('^build');
+        const inputs = [...(existing.inputs ?? [])];
+        if (!inputs.find((i) => typeof i === 'string' ? false : i['env'] === nxMFDevRemotesEnvVar)) {
+            inputs.push({ env: nxMFDevRemotesEnvVar });
+        }
+        (0, internal_1.upsertTargetDefault)(tree, nxJson, {
+            executor: webpackExecutor,
+            ...(existing.cache !== undefined ? { cache: existing.cache } : {}),
+            inputs,
+            dependsOn,
+        });
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+    await (0, devkit_1.formatFiles)(tree);
+}

package/dist/src/migrations/update-20-2-0/add-localize-polyfill-to-targets.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export declare const executorsToAddPolyfillTo: string[];
+export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-20-2-0/add-localize-polyfill-to-targets.md

@@ -0,0 +1,44 @@
+#### Add Localize Polyfill to Targets
+
+Add the '@angular/localize/init' polyfill to the 'polyfills' option of targets using esbuild-based executors.
+
+#### Sample Code Changes
+
+Add the `@angular/localize/init` polyfill to any of these executors:
+
+- `@angular/build:application`
+- `@angular-devkit/build-angular:application`
+- `@nx/angular:application`
+- `@angular-devkit/build-angular:browser-esbuild`
+- `@nx/angular:browser-esbuild`
+
+##### Before
+
+```json title="apps/app1/project.json"
+{
+  "targets": {
+    "build": {
+      "executor": "@angular/build:application",
+      "options": {
+        "localize": true
+      }
+    }
+  }
+}
+```
+
+##### After
+
+```json title="apps/app1/project.json"
+{
+  "targets": {
+    "build": {
+      "executor": "@angular/build:application",
+      "options": {
+        "localize": true,
+        "polyfills": ["@angular/localize/init"]
+      }
+    }
+  }
+}
+```

package/dist/src/migrations/update-20-2-0/disable-angular-eslint-prefer-standalone.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;