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

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const devkit_1 = require("@nx/devkit");
+const COLLECTION = '@nx/angular';
+const OLD_GENERATOR = 'ngrx';
+const OLD_KEY = `${COLLECTION}:${OLD_GENERATOR}`;
+const ROOT_STORE = 'ngrx-root-store';
+const FEATURE_STORE = 'ngrx-feature-store';
+// Options supported by ngrx-root-store. The `minimal` option is included here
+// because its semantics match the old generator (skip generating root feature
+// state files).
+const ROOT_STORE_OPTIONS = [
+    'name',
+    'route',
+    'directory',
+    'facade',
+    'minimal',
+    'skipImport',
+    'skipPackageJson',
+    'skipFormat',
+];
+// Options supported by ngrx-feature-store. `minimal` is intentionally excluded:
+// in the old generator it was a no-op for feature usage, but in
+// ngrx-feature-store it skips template generation while still wiring imports,
+// which would produce broken modules.
+const FEATURE_STORE_OPTIONS = [
+    'name',
+    'parent',
+    'route',
+    'directory',
+    'facade',
+    'barrels',
+    'skipImport',
+    'skipPackageJson',
+    'skipFormat',
+];
+async function default_1(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (nxJson?.generators && migrateGenerators(nxJson.generators)) {
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const [projectName, project] of projects) {
+        if (project.generators && migrateGenerators(project.generators)) {
+            (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function migrateGenerators(generators) {
+    const flatDefaults = generators[OLD_KEY];
+    const nestedDefaults = generators[COLLECTION]?.[OLD_GENERATOR];
+    if (!flatDefaults && !nestedDefaults) {
+        return false;
+    }
+    // Match Nx's runtime merge: nested first, then flat overrides.
+    // See `getGeneratorDefaults` in packages/nx/src/utils/params.ts.
+    const oldDefaults = {
+        ...(nestedDefaults ?? {}),
+        ...(flatDefaults ?? {}),
+    };
+    // Prefer flat when both shapes exist (it's the dominant runtime shape).
+    const useNestedFormat = !flatDefaults && !!nestedDefaults;
+    // The deprecated `module` option was an alias for `parent`. The old
+    // generator resolved `options.module ?? options.parent`, so `module` won
+    // when both were set — preserve that precedence here.
+    if (oldDefaults.module !== undefined) {
+        oldDefaults.parent = oldDefaults.module;
+    }
+    const rootStoreDefaults = pick(oldDefaults, ROOT_STORE_OPTIONS);
+    const featureStoreDefaults = pick(oldDefaults, FEATURE_STORE_OPTIONS);
+    if (Object.keys(rootStoreDefaults).length > 0) {
+        setNewDefaults(generators, ROOT_STORE, rootStoreDefaults, useNestedFormat);
+    }
+    if (Object.keys(featureStoreDefaults).length > 0) {
+        setNewDefaults(generators, FEATURE_STORE, featureStoreDefaults, useNestedFormat);
+    }
+    delete generators[OLD_KEY];
+    if (generators[COLLECTION]?.[OLD_GENERATOR] !== undefined) {
+        delete generators[COLLECTION][OLD_GENERATOR];
+        if (Object.keys(generators[COLLECTION]).length === 0) {
+            delete generators[COLLECTION];
+        }
+    }
+    return true;
+}
+function pick(obj, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (obj[key] !== undefined) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}
+function setNewDefaults(generators, generator, newDefaults, preferNestedFormat) {
+    const flatKey = `${COLLECTION}:${generator}`;
+    const existingFlat = generators[flatKey];
+    const existingNested = generators[COLLECTION]?.[generator];
+    // Per-generator destination: prefer whichever shape the user already uses
+    // for the replacement key, so the migrated defaults layer correctly under
+    // their existing values. Fall back to the input shape when neither exists.
+    const writeNested = existingNested !== undefined
+        ? true
+        : existingFlat !== undefined
+            ? false
+            : preferNestedFormat;
+    if (writeNested) {
+        generators[COLLECTION] ??= {};
+        // Existing user-set defaults take precedence over the migrated ones.
+        generators[COLLECTION][generator] = {
+            ...newDefaults,
+            ...(existingNested ?? {}),
+        };
+    }
+    else {
+        generators[flatKey] = { ...newDefaults, ...(existingFlat ?? {}) };
+    }
+}

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

@@ -0,0 +1,46 @@
+#### Split `@nx/angular:ngrx` generator defaults across the replacement generators
+
+Splits any `@nx/angular:ngrx` generator defaults set in `nx.json` or in project-level `project.json` files across the two replacement generators: `@nx/angular:ngrx-root-store` (for root state) and `@nx/angular:ngrx-feature-store` (for feature state). The `@nx/angular:ngrx` generator was removed in Nx v23.
+
+Shared options apply to both keys; `barrels` and `parent` are written only to `@nx/angular:ngrx-feature-store` (the `@nx/angular:ngrx-root-store` schema doesn't accept them). The `minimal` option is written only to `@nx/angular:ngrx-root-store` because its semantics differ between the two new generators (see Notes). The deprecated `module` option is renamed to `parent`. The obsolete `root` toggle is dropped — intent is now expressed by which generator is invoked. Existing defaults already set under the new keys are preserved.
+
+#### Examples
+
+##### Before
+
+```json title="nx.json"
+{
+  "generators": {
+    "@nx/angular:ngrx": {
+      "facade": true,
+      "minimal": true,
+      "barrels": true,
+      "module": "libs/my-lib/src/lib/my-lib-module.ts"
+    }
+  }
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "generators": {
+    "@nx/angular:ngrx-root-store": {
+      "facade": true,
+      "minimal": true
+    },
+    "@nx/angular:ngrx-feature-store": {
+      "facade": true,
+      "barrels": true,
+      "parent": "libs/my-lib/src/lib/my-lib-module.ts"
+    }
+  }
+}
+```
+
+#### Notes
+
+The `minimal` option is intentionally not propagated to `@nx/angular:ngrx-feature-store`. In the deprecated `@nx/angular:ngrx` generator, `minimal` only gated root-state file generation and was a no-op for feature-state usage. In `@nx/angular:ngrx-feature-store`, `minimal: true` skips template generation while still wiring imports to the (now missing) files, which would produce broken modules.
+
+The split is otherwise intentionally inclusive: shared options are written to both new keys so users can trim the ones they don't want. CLI invocations of `@nx/angular:ngrx` (in shell scripts, CI, or `package.json`) are not migrated — update those manually to call `@nx/angular:ngrx-root-store` or `@nx/angular:ngrx-feature-store`.

package/dist/src/migrations/update-23-0-0/migrate-with-mf-import-to-new-package.d.ts

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

package/dist/src/migrations/update-23-0-0/migrate-with-mf-import-to-new-package.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateWithMfImport;
+const devkit_1 = require("@nx/devkit");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const projects_1 = require("../utils/projects");
+const versions_1 = require("../../utils/versions");
+const NX_ANGULAR_MODULE_FEDERATION_IMPORT_SELECTOR = 'ImportDeclaration > StringLiteral[value=@nx/angular/module-federation], VariableStatement CallExpression:has(Identifier[name=require]) > StringLiteral[value=@nx/angular/module-federation]';
+const NEW_IMPORT_PATH = `'@nx/module-federation/angular'`;
+async function migrateWithMfImport(tree) {
+    const angularProjects = await (0, projects_1.getProjectsFilteredByDependencies)([
+        'npm:@nx/angular',
+    ]);
+    if (!angularProjects.length) {
+        return;
+    }
+    let anyUpdated = false;
+    for (const { data } of angularProjects) {
+        (0, devkit_1.visitNotIgnoredFiles)(tree, data.root, (filePath) => {
+            if (!filePath.endsWith('.ts') && !filePath.endsWith('.js')) {
+                return;
+            }
+            let contents = tree.read(filePath, 'utf-8');
+            if (!contents.includes('@nx/angular/module-federation')) {
+                return;
+            }
+            const sourceFile = (0, tsquery_1.ast)(contents);
+            const importNodes = (0, tsquery_1.query)(sourceFile, NX_ANGULAR_MODULE_FEDERATION_IMPORT_SELECTOR);
+            if (importNodes.length === 0) {
+                return;
+            }
+            // Iterate end-to-start so earlier replacements don't shift later offsets.
+            for (let i = importNodes.length - 1; i >= 0; i--) {
+                const node = importNodes[i];
+                contents = `${contents.slice(0, node.getStart())}${NEW_IMPORT_PATH}${contents.slice(node.getEnd())}`;
+            }
+            tree.write(filePath, contents);
+            anyUpdated = true;
+        });
+    }
+    if (anyUpdated) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/module-federation': versions_1.nxVersion });
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}

package/dist/src/migrations/update-23-0-0/migrate-with-mf-import-to-new-package.md

@@ -0,0 +1,27 @@
+#### Update withModuleFederation Import to New Package
+
+Updates the `withModuleFederation` and `withModuleFederationForSSR` imports to use `@nx/module-federation/angular`. The `@nx/angular/module-federation` re-export path was deprecated in Nx v20.2 and is now removed.
+
+#### Examples
+
+##### Before
+
+```ts title="apps/shell/webpack.config.ts"
+import {
+  withModuleFederation,
+  withModuleFederationForSSR,
+} from '@nx/angular/module-federation';
+```
+
+##### After
+
+```ts title="apps/shell/webpack.config.ts"
+import {
+  withModuleFederation,
+  withModuleFederationForSSR,
+} from '@nx/module-federation/angular';
+```
+
+#### Notes
+
+This migration runs for all projects in the workspace that depend on `@nx/angular`, ensuring imports are updated when migrating to Nx v23.

package/dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports.d.ts

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

package/dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rewriteInternalSubpathImports;
+exports.rewriteSubpathImports = rewriteSubpathImports;
+const devkit_1 = require("@nx/devkit");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const DROPPED_PREFIXES = [
+    '@nx/angular/src/utils',
+    '@nx/angular/src/generators/utils',
+    '@nx/angular/src/generators/move/move-impl',
+];
+function matchesDropped(text) {
+    return DROPPED_PREFIXES.some((p) => text === p || text.startsWith(p + '/'));
+}
+const TO_PUBLIC = '@nx/angular';
+const TO_INTERNAL = '@nx/angular/internal';
+// Symbols exported from `@nx/angular`'s public entry (packages/angular/index.ts).
+// A named import/export of one of these from `@nx/angular/src/*` is routed to
+// the public `@nx/angular` entry; everything else goes to `@nx/angular/internal`.
+const PUBLIC_SYMBOLS = new Set([]);
+// Methods on `jest` and `vi` that take a module specifier as their first arg.
+const MOCK_HELPER_METHODS = new Set([
+    'mock',
+    'unmock',
+    'doMock',
+    'dontMock',
+    'requireActual',
+    'requireMock',
+    'importActual',
+    'importMock',
+]);
+let ts;
+async function rewriteInternalSubpathImports(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 || !DROPPED_PREFIXES.some((p) => original.includes(p))) {
+            return;
+        }
+        const updated = rewriteSubpathImports(original);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Rewrote @nx/angular/src/* imports in ${touchedCount} file(s) ` +
+            `(public symbols to @nx/angular, internals to @nx/angular/internal).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function rewriteSubpathImports(source) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    const changes = [];
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            collectImportRewrite(sourceFile, stmt, changes);
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, changes);
+        }
+    }
+    collectCallExpressionRewrites(sourceFile, changes);
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+function isSubpathSpecifier(node) {
+    return ts.isStringLiteral(node) && matchesDropped(node.text);
+}
+function collectImportRewrite(sourceFile, stmt, changes) {
+    if (!isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    const clause = stmt.importClause;
+    // Pure named imports (`import { a, b } from '...'`) can be split by symbol.
+    // A default or namespace import grabs the whole module, so it can't be
+    // split — route it wholesale to the internal entry.
+    if (clause &&
+        !clause.name &&
+        clause.namedBindings &&
+        ts.isNamedImports(clause.namedBindings)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, clause.isTypeOnly, clause.namedBindings.elements, 'import', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+function collectExportRewrite(sourceFile, stmt, changes) {
+    if (!stmt.moduleSpecifier || !isSubpathSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    // `export { a, b } from '...'` can be split; `export * from '...'` cannot.
+    if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
+        rewriteNamedDeclaration(sourceFile, stmt, stmt.moduleSpecifier, stmt.isTypeOnly, stmt.exportClause.elements, 'export', changes);
+        return;
+    }
+    replaceSpecifier(sourceFile, stmt.moduleSpecifier, TO_INTERNAL, changes);
+}
+/**
+ * Partition the named bindings of an import/export declaration into the ones
+ * that resolve to `@nx/angular`'s public entry and the ones that don't. If both
+ * groups are non-empty, the single declaration is split into two.
+ */
+function rewriteNamedDeclaration(sourceFile, decl, specifier, isTypeOnly, elements, keyword, changes) {
+    const publicEls = [];
+    const internalEls = [];
+    for (const el of elements) {
+        // `propertyName` is the original name in `orig as alias`; fall back to
+        // `name` for the plain `orig` form.
+        const importedName = (el.propertyName ?? el.name).text;
+        (PUBLIC_SYMBOLS.has(importedName) ? publicEls : internalEls).push(el);
+    }
+    if (publicEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_INTERNAL, changes);
+        return;
+    }
+    if (internalEls.length === 0) {
+        replaceSpecifier(sourceFile, specifier, TO_PUBLIC, changes);
+        return;
+    }
+    // Mixed — replace the whole declaration with one statement per target.
+    const quote = sourceFile.text.charAt(specifier.getStart(sourceFile));
+    const start = decl.getStart(sourceFile);
+    const end = decl.getEnd();
+    const semicolon = sourceFile.text.charAt(end - 1) === ';' ? ';' : '';
+    const prefix = isTypeOnly ? `${keyword} type` : keyword;
+    const render = (els, target) => `${prefix} { ${els
+        .map((el) => el.getText(sourceFile))
+        .join(', ')} } from ${quote}${target}${quote}${semicolon}`;
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${render(publicEls, TO_PUBLIC)}\n${render(internalEls, TO_INTERNAL)}`,
+    });
+}
+function collectCallExpressionRewrites(sourceFile, changes) {
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            shouldRewriteCallExpression(node) &&
+            node.arguments.length >= 1 &&
+            isSubpathSpecifier(node.arguments[0])) {
+            // `require(...)`, dynamic `import(...)` and `jest.mock(...)` reference
+            // the module as a whole and can't be symbol-split, so they go to the
+            // internal entry.
+            replaceSpecifier(sourceFile, node.arguments[0], TO_INTERNAL, changes);
+        }
+        else if (ts.isImportTypeNode(node)) {
+            // `typeof import('...')` parses as an `ImportTypeNode`, not a
+            // CallExpression — its argument is `LiteralTypeNode<StringLiteral>`.
+            // The whole module is referenced, so it can't be symbol-split.
+            const literal = getImportTypeStringLiteral(node);
+            if (literal && matchesDropped(literal.text)) {
+                replaceSpecifier(sourceFile, literal, TO_INTERNAL, changes);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+}
+function getImportTypeStringLiteral(node) {
+    const arg = node.argument;
+    if (arg && ts.isLiteralTypeNode(arg) && ts.isStringLiteral(arg.literal)) {
+        return arg.literal;
+    }
+    return undefined;
+}
+function shouldRewriteCallExpression(call) {
+    const callee = call.expression;
+    // `require('...')`
+    if (ts.isIdentifier(callee) && callee.text === 'require')
+        return true;
+    // dynamic `import('...')` (runtime form parses as a CallExpression whose
+    // callee is the `import` keyword). The `typeof import('...')` type-position
+    // form is an `ImportTypeNode` (handled in `collectCallExpressionRewrites`).
+    if (callee.kind === ts.SyntaxKind.ImportKeyword)
+        return true;
+    // `jest.mock(...)` / `vi.mock(...)` and friends.
+    if (ts.isPropertyAccessExpression(callee)) {
+        const obj = callee.expression;
+        if (ts.isIdentifier(obj) &&
+            (obj.text === 'jest' || obj.text === 'vi') &&
+            MOCK_HELPER_METHODS.has(callee.name.text)) {
+            return true;
+        }
+    }
+    return false;
+}
+function replaceSpecifier(sourceFile, literal, target, changes) {
+    const start = literal.getStart(sourceFile);
+    const end = literal.getEnd();
+    const quote = sourceFile.text.charAt(start);
+    changes.push({ type: devkit_1.ChangeType.Delete, start, length: end - start }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `${quote}${target}${quote}`,
+    });
+}

package/dist/src/migrations/utils/projects.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectGraphProjectNode } from '@nx/devkit';
+export declare function getProjectsFilteredByDependencies(dependencies: string[]): Promise<ProjectGraphProjectNode[]>;

package/dist/src/plugins/plugin.d.ts

@@ -0,0 +1,23 @@
+import { type CreateNodes } from '@nx/devkit';
+export interface AngularPluginOptions {
+    targetNamePrefix?: string;
+}
+type AngularTargetConfiguration = {
+    builder: string;
+    options?: Record<string, any>;
+    configurations?: Record<string, any>;
+    defaultConfiguration?: string;
+};
+export type AngularProjectConfiguration = {
+    projectType: 'application' | 'library';
+    root: string;
+    sourceRoot?: string;
+    architect?: Record<string, AngularTargetConfiguration>;
+    targets?: Record<string, AngularTargetConfiguration>;
+};
+export declare const createNodes: CreateNodes<AngularPluginOptions>;
+/**
+ * @deprecated Use {@link createNodes} instead. This will be removed in Nx 24.
+ */
+export declare const createNodesV2: CreateNodes<AngularPluginOptions>;
+export {};