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

package/dist/src/migrations/update-22-3-0/update-ssr-webpack-config.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+const tsconfig_utils_1 = require("../../generators/utils/tsconfig-utils");
+const file_change_recorder_1 = require("../../utils/file-change-recorder");
+const targets_1 = require("../../utils/targets");
+const projects_1 = require("../utils/projects");
+const serverExecutors = new Set([
+    '@angular-devkit/build-angular:server',
+    '@nx/angular:webpack-server',
+]);
+let ts;
+async function default_1(tree) {
+    const projects = await (0, projects_1.getProjectsFilteredByDependencies)([
+        'npm:@angular/ssr',
+    ]);
+    // Map project root → {tsConfigPath, serverFiles[]}
+    const projectFilesMap = new Map();
+    // First pass: collect files grouped by project
+    for (const { data: project } of projects) {
+        if (project.projectType !== 'application') {
+            continue;
+        }
+        for (const target of Object.values(project.targets ?? {})) {
+            if (!serverExecutors.has(target.executor)) {
+                continue;
+            }
+            const tsConfigServerPath = (0, devkit_1.joinPathFragments)(project.root, 'tsconfig.server.json');
+            if (!tree.exists(tsConfigServerPath)) {
+                continue;
+            }
+            // Get or create entry for this project
+            let projectEntry = projectFilesMap.get(project.root);
+            if (!projectEntry) {
+                projectEntry = {
+                    tsConfigPath: tsConfigServerPath,
+                    serverFiles: new Set(),
+                };
+                projectFilesMap.set(project.root, projectEntry);
+            }
+            // Collect server files for this project
+            for (const [, options] of (0, targets_1.allTargetOptions)(target)) {
+                if (options?.main && tree.exists(options.main)) {
+                    projectEntry.serverFiles.add(options.main);
+                }
+            }
+        }
+    }
+    if (projectFilesMap.size === 0) {
+        return;
+    }
+    // Second pass: process each project
+    ts = (0, internal_1.ensureTypescript)();
+    for (const { tsConfigPath, serverFiles } of projectFilesMap.values()) {
+        const wasUpdated = updateTsConfigServer(tree, tsConfigPath);
+        // Only update server files if tsconfig was actually modified
+        if (wasUpdated) {
+            for (const serverFile of serverFiles) {
+                updateServerImports(tree, serverFile);
+            }
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function updateTsConfigServer(tree, tsConfigPath) {
+    const compilerOptions = (0, tsconfig_utils_1.readCompilerOptionsFromTsConfig)(tree, tsConfigPath);
+    if (compilerOptions.module === ts.ModuleKind.Preserve &&
+        compilerOptions.moduleResolution === ts.ModuleResolutionKind.Bundler) {
+        // Already configured correctly, skip
+        return false;
+    }
+    (0, devkit_1.updateJson)(tree, tsConfigPath, (json) => {
+        json.compilerOptions ??= {};
+        json.compilerOptions.module = 'preserve';
+        json.compilerOptions.moduleResolution = 'bundler';
+        return json;
+    });
+    return true;
+}
+function updateServerImports(tree, serverFilePath) {
+    const content = tree.read(serverFilePath, 'utf-8');
+    const sourceFile = ts.createSourceFile(serverFilePath, content, ts.ScriptTarget.Latest, true);
+    const allImportDeclarations = sourceFile.statements.filter(ts.isImportDeclaration);
+    if (allImportDeclarations.length === 0) {
+        return;
+    }
+    let recorder;
+    // Find namespace imports (import * as X from 'Y')
+    for (const importDecl of allImportDeclarations) {
+        if (!ts.isStringLiteral(importDecl.moduleSpecifier)) {
+            continue;
+        }
+        const namedBindings = importDecl.importClause?.namedBindings;
+        // Check if this is a namespace import (import * as X) and there's no
+        // default import (e.g., "import express, * as types from 'express'")
+        if (namedBindings &&
+            ts.isNamespaceImport(namedBindings) &&
+            !importDecl.importClause?.name) {
+            const importName = namedBindings.name.text;
+            const moduleSpecifier = importDecl.moduleSpecifier.text;
+            recorder ??= new file_change_recorder_1.FileChangeRecorder(tree, serverFilePath);
+            // import * as express from 'express' -> import express from 'express'
+            recorder.replace(importDecl, `import ${importName} from '${moduleSpecifier}';`);
+        }
+    }
+    if (recorder) {
+        recorder.applyChanges();
+    }
+}

package/dist/src/migrations/update-22-3-0/update-ssr-webpack-config.md

@@ -0,0 +1,71 @@
+#### Updates Webpack-Based SSR Configuration
+
+Updates the TypeScript configuration and import syntax for webpack-based server-side rendering (SSR) projects. This migration sets `module: "preserve"` and `moduleResolution: "bundler"` in `tsconfig.server.json` to align with Angular's build requirements, and updates server file imports from namespace imports (`import * as express`) to default imports (`import express`) to work correctly with the new module format.
+
+#### Examples
+
+For webpack-based SSR projects (using `@nx/angular:webpack-server` or `@angular-devkit/build-angular:server`), the migration updates the `tsconfig.server.json` file:
+
+##### Before
+
+```jsonc {7-8}
+// apps/my-app/tsconfig.server.json
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "target": "es2022",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "types": ["node"],
+  },
+  "files": ["src/main.server.ts", "src/server.ts"],
+}
+```
+
+##### After
+
+```jsonc {7-8}
+// apps/my-app/tsconfig.server.json
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "target": "es2022",
+    "module": "preserve",
+    "moduleResolution": "bundler",
+    "types": ["node"],
+  },
+  "files": ["src/main.server.ts", "src/server.ts"],
+}
+```
+
+The migration also updates import statements in the `server.ts` file to use default imports instead of namespace imports:
+
+##### Before
+
+```ts {2-4}
+// apps/my-app/src/server.ts
+import * as express from 'express';
+import * as compression from 'compression';
+import * as cors from 'cors';
+
+const app = express();
+app.use(compression());
+app.use(cors());
+```
+
+##### After
+
+```ts {2-4}
+// apps/my-app/src/server.ts
+import express from 'express';
+import compression from 'compression';
+import cors from 'cors';
+
+const app = express();
+app.use(compression());
+app.use(cors());
+```
+
+Projects that already have the correct TypeScript configuration or projects without a `tsconfig.server.json` file are not modified by this migration.

package/dist/src/migrations/update-22-3-0/update-typescript-lib.d.ts

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

package/dist/src/migrations/update-22-3-0/update-typescript-lib.md

@@ -0,0 +1,103 @@
+#### Update TypeScript `lib` compiler option to ES2022
+
+Updates the TypeScript `lib` compiler option in Angular projects to ensure compatibility with Angular v21+, which requires ES2022 as the minimum ECMAScript version. The migration upgrades any ES versions older than ES2022 (such as ES2015, ES2020, etc.) to ES2022 while preserving other library entries like `'dom'`, `'webworker'`, etc.
+
+#### Examples
+
+The migration processes TypeScript configuration files referenced by Angular project build targets and updates the `lib` compiler option when outdated ES versions are detected:
+
+##### Before
+
+```jsonc {4}
+// apps/my-app/tsconfig.app.json
+{
+  "compilerOptions": {
+    "lib": ["es2020", "dom"],
+  },
+}
+```
+
+##### After
+
+```jsonc {4}
+// apps/my-app/tsconfig.app.json
+{
+  "compilerOptions": {
+    "lib": ["dom", "es2022"],
+  },
+}
+```
+
+When the `lib` array contains only an ES version older than ES2022 without additional entries, it is upgraded:
+
+##### Before
+
+```jsonc {4}
+// apps/my-app/tsconfig.app.json
+{
+  "compilerOptions": {
+    "lib": ["es2020"],
+  },
+}
+```
+
+##### After
+
+```jsonc {4}
+// apps/my-app/tsconfig.app.json
+{
+  "compilerOptions": {
+    "lib": ["es2022"],
+  },
+}
+```
+
+If the configuration already uses ES2022 or higher (e.g., `'es2023'`, `'esnext'`), no changes are made:
+
+##### Before
+
+```jsonc {4}
+// apps/my-app/tsconfig.app.json
+{
+  "compilerOptions": {
+    "lib": ["es2022", "dom"],
+  },
+}
+```
+
+##### After
+
+```jsonc {4}
+// apps/my-app/tsconfig.app.json
+{
+  "compilerOptions": {
+    "lib": ["es2022", "dom"],
+  },
+}
+```
+
+When the `lib` array contains multiple library entries, only the ES version is upgraded while all other entries are preserved:
+
+##### Before
+
+```jsonc {4}
+// apps/my-app/tsconfig.app.json
+{
+  "compilerOptions": {
+    "lib": ["es2020", "dom", "webworker"],
+  },
+}
+```
+
+##### After
+
+```jsonc {4}
+// apps/my-app/tsconfig.app.json
+{
+  "compilerOptions": {
+    "lib": ["dom", "webworker", "es2022"],
+  },
+}
+```
+
+The migration only processes TypeScript configuration files that are referenced by Angular project build targets, ensuring that only Angular-specific configurations are updated.

package/dist/src/migrations/update-22-3-0/update-unit-test-runner-option.d.ts

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

package/dist/src/migrations/update-22-3-0/update-unit-test-runner-option.md

@@ -0,0 +1,33 @@
+#### Update `vitest` unit test runner option to `vitest-analog` in generator defaults
+
+Updates the `unitTestRunner` generator default from `vitest` to `vitest-analog` in `nx.json`. The `vitest` option has been split into two explicit options: `vitest-angular` (uses `@angular/build:unit-test`) and `vitest-analog` (uses AnalogJS-based setup).
+
+#### Examples
+
+The migration updates generator defaults in `nx.json`:
+
+##### Before
+
+```jsonc {5}
+// nx.json
+{
+  "generators": {
+    "@nx/angular:application": {
+      "unitTestRunner": "vitest",
+    },
+  },
+}
+```
+
+##### After
+
+```jsonc {5}
+// nx.json
+{
+  "generators": {
+    "@nx/angular:application": {
+      "unitTestRunner": "vitest-analog",
+    },
+  },
+}
+```

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.d.ts

@@ -0,0 +1,9 @@
+import { type Tree } from '@nx/devkit';
+export default function migrateCreateNodesV2ToCreateNodes(tree: Tree): Promise<void>;
+/**
+ * Rewrites named imports and re-exports of `createNodesV2` to `createNodes`
+ * when they come from one of the given module specifiers. Only the named
+ * bindings are touched — the module specifier, the `import`/`export` keyword,
+ * any `type` modifier, and any default import are left untouched.
+ */
+export declare function rewriteCreateNodesV2Imports(source: string, specifiers: ReadonlySet<string>): string;

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateCreateNodesV2ToCreateNodes;
+exports.rewriteCreateNodesV2Imports = rewriteCreateNodesV2Imports;
+const devkit_1 = require("@nx/devkit");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const DEPRECATED_NAME = 'createNodesV2';
+const CANONICAL_NAME = 'createNodes';
+// Module specifiers from which `@nx/angular` publicly exposes `createNodesV2`.
+// A named import or re-export of `createNodesV2` from one of these is rewritten
+// to the canonical `createNodes` export.
+const TARGET_SPECIFIERS = new Set(['@nx/angular/plugin']);
+let ts;
+async function migrateCreateNodesV2ToCreateNodes(tree) {
+    let touchedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!TS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original || !original.includes(DEPRECATED_NAME)) {
+            return;
+        }
+        const updated = rewriteCreateNodesV2Imports(original, TARGET_SPECIFIERS);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Renamed \`${DEPRECATED_NAME}\` imports to \`${CANONICAL_NAME}\` in ${touchedCount} file(s).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+/**
+ * Rewrites named imports and re-exports of `createNodesV2` to `createNodes`
+ * when they come from one of the given module specifiers. Only the named
+ * bindings are touched — the module specifier, the `import`/`export` keyword,
+ * any `type` modifier, and any default import are left untouched.
+ */
+function rewriteCreateNodesV2Imports(source, specifiers) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    const changes = [];
+    let renameLocalUsages = false;
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            renameLocalUsages =
+                collectImportRewrite(sourceFile, stmt, specifiers, changes) ||
+                    renameLocalUsages;
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, specifiers, changes);
+        }
+    }
+    // Renaming a local `createNodesV2` import binding to `createNodes` (a lone
+    // `{ createNodesV2 }`, or one deduped against an existing `createNodes`)
+    // changes the name in scope, so value references to `createNodesV2` in the
+    // file body must be renamed too — otherwise they dangle. Aliased imports and
+    // re-exports keep their local name, so they never trigger this.
+    if (renameLocalUsages) {
+        collectValueUsageRewrites(sourceFile, changes);
+    }
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+function isTargetSpecifier(node, specifiers) {
+    return ts.isStringLiteral(node) && specifiers.has(node.text);
+}
+function collectImportRewrite(sourceFile, stmt, specifiers, changes) {
+    if (!isTargetSpecifier(stmt.moduleSpecifier, specifiers)) {
+        return false;
+    }
+    const namedBindings = stmt.importClause?.namedBindings;
+    // Only `import { ... }` carries renameable named bindings. `import x`,
+    // `import * as ns`, and side-effect imports reference the module wholesale
+    // and keep working through the `createNodesV2` runtime alias, so we leave
+    // them be. A mixed `import def, { createNodesV2 }` still has its named
+    // bindings rewritten below — the default binding is untouched.
+    if (!namedBindings || !ts.isNamedImports(namedBindings)) {
+        return false;
+    }
+    // The local `createNodesV2` binding only disappears when it is imported
+    // without an alias — a lone `{ createNodesV2 }` or one deduped against an
+    // existing `createNodes`. `{ createNodesV2 as x }` keeps the local `x`, so
+    // its in-file usages are unaffected and must not be rewritten.
+    const localBindingRenamed = namedBindings.elements.some((el) => el.name.text === DEPRECATED_NAME &&
+        (el.propertyName ?? el.name).text === DEPRECATED_NAME);
+    rewriteNamedBindings(sourceFile, namedBindings, changes);
+    return localBindingRenamed;
+}
+function collectExportRewrite(sourceFile, stmt, specifiers, changes) {
+    if (!stmt.moduleSpecifier ||
+        !isTargetSpecifier(stmt.moduleSpecifier, specifiers)) {
+        return;
+    }
+    // `export { ... } from '...'` can be rewritten; `export * from '...'` has no
+    // named bindings to rename.
+    if (!stmt.exportClause || !ts.isNamedExports(stmt.exportClause)) {
+        return;
+    }
+    rewriteNamedBindings(sourceFile, stmt.exportClause, changes);
+}
+/**
+ * Re-renders the `{ ... }` of a named import/export, renaming any
+ * `createNodesV2` specifier to `createNodes`. If renaming would collide with a
+ * `createNodes` that is already present (e.g. `{ createNodes, createNodesV2 }`),
+ * the duplicate is dropped. Returns without recording a change when the binding
+ * list contains no `createNodesV2`.
+ */
+function rewriteNamedBindings(sourceFile, namedBindings, changes) {
+    const elements = namedBindings.elements;
+    const hasDeprecated = elements.some((el) => (el.propertyName ?? el.name).text === DEPRECATED_NAME);
+    if (!hasDeprecated) {
+        return;
+    }
+    const seen = new Set();
+    const rendered = [];
+    for (const el of elements) {
+        const text = renderSpecifier(el);
+        if (!seen.has(text)) {
+            seen.add(text);
+            rendered.push(text);
+        }
+    }
+    const start = namedBindings.getStart(sourceFile);
+    changes.push({
+        type: devkit_1.ChangeType.Delete,
+        start,
+        length: namedBindings.getEnd() - start,
+    }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `{ ${rendered.join(', ')} }`,
+    });
+}
+function renderSpecifier(el) {
+    const typePrefix = el.isTypeOnly ? 'type ' : '';
+    const rename = (name) => name === DEPRECATED_NAME ? CANONICAL_NAME : name;
+    // `{ name }` — no alias, so the local binding follows the rename.
+    if (!el.propertyName) {
+        return `${typePrefix}${rename(el.name.text)}`;
+    }
+    // `{ propertyName as name }` — only the imported (left) side is renamed; the
+    // local alias is preserved. A now-redundant alias such as
+    // `createNodesV2 as createNodes` collapses to `createNodes`.
+    const canonicalImported = rename(el.propertyName.text);
+    const localName = el.name.text;
+    return canonicalImported === localName
+        ? `${typePrefix}${localName}`
+        : `${typePrefix}${canonicalImported} as ${localName}`;
+}
+/**
+ * Renames value references of `createNodesV2` to `createNodes` in the file
+ * body. Only called once a local `createNodesV2` import binding has actually
+ * been renamed, so these references would otherwise dangle. Occurrences that
+ * are not references to that binding are skipped: the import/export
+ * declarations themselves, property accesses (`x.createNodesV2`), qualified
+ * type names, object-literal keys, and declaration names that shadow the
+ * import. A shorthand property (`{ createNodesV2 }`) is expanded to
+ * `{ createNodesV2: createNodes }` so the property key is preserved. Strings
+ * and comments are never `Identifier` nodes, so they are left alone.
+ */
+function collectValueUsageRewrites(sourceFile, changes) {
+    const visit = (node) => {
+        if (ts.isIdentifier(node) &&
+            node.text === DEPRECATED_NAME &&
+            isRenamableValueUsage(node)) {
+            const start = node.getStart(sourceFile);
+            changes.push({
+                type: devkit_1.ChangeType.Delete,
+                start,
+                length: node.getEnd() - start,
+            }, {
+                type: devkit_1.ChangeType.Insert,
+                index: start,
+                text: ts.isShorthandPropertyAssignment(node.parent)
+                    ? `${DEPRECATED_NAME}: ${CANONICAL_NAME}`
+                    : CANONICAL_NAME,
+            });
+        }
+        node.forEachChild(visit);
+    };
+    sourceFile.forEachChild(visit);
+}
+/**
+ * Whether a `createNodesV2` identifier is a value reference to the renamed
+ * import binding, as opposed to a position that must be left untouched.
+ */
+function isRenamableValueUsage(node) {
+    const parent = node.parent;
+    if (!parent) {
+        return false;
+    }
+    // Import/export bindings — already handled by the declaration rewrite.
+    if (ts.isImportSpecifier(parent) ||
+        ts.isExportSpecifier(parent) ||
+        ts.isImportClause(parent) ||
+        ts.isNamespaceImport(parent)) {
+        return false;
+    }
+    // `x.createNodesV2` / `X.createNodesV2` — a member name, not the binding.
+    if (ts.isPropertyAccessExpression(parent) && parent.name === node) {
+        return false;
+    }
+    if (ts.isQualifiedName(parent) && parent.right === node) {
+        return false;
+    }
+    // `{ createNodesV2: ... }` — an object-literal key, not the binding.
+    if (ts.isPropertyAssignment(parent) && parent.name === node) {
+        return false;
+    }
+    // A declaration whose name shadows the import (variable, param, etc.).
+    if ((ts.isVariableDeclaration(parent) ||
+        ts.isParameter(parent) ||
+        ts.isBindingElement(parent) ||
+        ts.isFunctionDeclaration(parent) ||
+        ts.isClassDeclaration(parent)) &&
+        parent.name === node) {
+        return false;
+    }
+    return true;
+}

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.md

@@ -0,0 +1,25 @@
+#### Rename `createNodesV2` imports to `createNodes`
+
+`@nx/angular` renamed its primary inferred-plugin export from `createNodesV2` to `createNodes`. The `createNodesV2` name is preserved as a deprecated alias for now, but new code should use `createNodes`.
+
+This migration scans every `.ts`, `.tsx`, `.cts`, and `.mts` file in your workspace and rewrites named imports and re-exports of `createNodesV2` from `@nx/angular/plugin` to `createNodes`.
+
+#### Sample Code Changes
+
+##### Before
+
+```ts
+import { createNodesV2 } from '@nx/angular/plugin';
+```
+
+##### After
+
+```ts
+import { createNodes } from '@nx/angular/plugin';
+```
+
+Aliases are preserved (`createNodesV2 as cn` becomes `createNodes as cn`), and if a file already imports both names (`{ createNodes, createNodesV2 }`) the redundant binding is dropped.
+
+#### What is not rewritten
+
+Only static `import`/`export` named bindings from `@nx/angular/plugin` are rewritten. Namespace imports, dynamic `import(...)`, `require(...)` destructuring, and property access such as `plugin.createNodesV2` are left untouched — they keep working through the `createNodesV2` runtime alias. Update those by hand if you want to drop the deprecated name everywhere.

package/dist/src/migrations/update-23-0-0/migrate-ngrx-generator-defaults.d.ts

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