@nx/angular 21.0.0-canary.20250206-8bd0bcd → 21.0.0-canary.20250418-8619c1d

package/src/migrations/update-16-1-0/extract-standalone-config-from-bootstrap.js

@@ -1,127 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = extractStandaloneConfig;
-const devkit_1 = require("@nx/devkit");
-const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
-const path_1 = require("path");
-const projects_1 = require("../utils/projects");
-let tsModule;
-let tsquery;
-function getBootstrapCallFileInfo(tree, project, mainFilePath) {
-    const IMPORT_BOOTSTRAP_FILE = 'CallExpression:has(ImportKeyword) > StringLiteral';
-    let bootstrapCallFilePath = mainFilePath;
-    let bootstrapCallFileContents = tree.read(bootstrapCallFilePath, 'utf-8');
-    const ast = tsquery.ast(bootstrapCallFileContents);
-    const importBootstrapNodes = tsquery(ast, IMPORT_BOOTSTRAP_FILE, {
-        visitAllChildren: true,
-    });
-    if (importBootstrapNodes.length > 0 &&
-        importBootstrapNodes[0].getText().includes('./bootstrap')) {
-        bootstrapCallFilePath = (0, devkit_1.joinPathFragments)(project.sourceRoot, 'bootstrap.ts');
-        bootstrapCallFileContents = tree.read(bootstrapCallFilePath, 'utf-8');
-    }
-    return { bootstrapCallFilePath, bootstrapCallFileContents };
-}
-function getImportTokenMap(bootstrapCallFileContentsAst) {
-    const importTokenMap = new Map();
-    const importedTokensNodes = tsquery(bootstrapCallFileContentsAst, 'ImportDeclaration > ImportClause', { visitAllChildren: true });
-    for (const node of importedTokensNodes) {
-        importTokenMap.set(node.getText(), node.parent.getText());
-    }
-    return importTokenMap;
-}
-function getImportsRequiredForAppConfig(importTokenMap, appConfigNode, oldSourceFilePath, newSourceFilePath) {
-    const identifiers = tsquery.query(appConfigNode, 'Identifier:not(PropertyAssignment > Identifier)', { visitAllChildren: true });
-    const appConfigImports = new Set();
-    const originalImportsToRemove = new Set();
-    for (const identifier of identifiers) {
-        for (const key of importTokenMap.keys()) {
-            if (!key.includes(identifier.getText())) {
-                continue;
-            }
-            let importText = importTokenMap.get(key);
-            originalImportsToRemove.add(importText);
-            if (oldSourceFilePath === newSourceFilePath ||
-                oldSourceFilePath.split('/').length ===
-                    newSourceFilePath.split('/').length) {
-                appConfigImports.add(importText);
-                continue;
-            }
-            const importPath = tsquery
-                .query(importText, 'StringLiteral', {
-                visitAllChildren: true,
-            })[0]
-                .getText()
-                .replace(/'/g, '')
-                .replace(/"/g, '');
-            if (importPath.startsWith('.')) {
-                const resolvedImportPath = (0, path_1.resolve)((0, path_1.dirname)(oldSourceFilePath), importPath);
-                const newRelativeImportPath = (0, path_1.relative)((0, path_1.dirname)(newSourceFilePath), resolvedImportPath);
-                importText = importText.replace(importPath, newRelativeImportPath.startsWith('.')
-                    ? newRelativeImportPath
-                    : `./${newRelativeImportPath}`);
-            }
-            appConfigImports.add(importText);
-        }
-    }
-    return {
-        appConfigImports: Array.from(appConfigImports),
-        importsToRemoveFromSource: Array.from(originalImportsToRemove),
-    };
-}
-function getAppConfigFileContents(importsRequiredForAppConfig, appConfigText) {
-    const buildAppConfigFileContents = (importStatements, appConfig) => `import { ApplicationConfig } from '@angular/core';${importStatements.join('\n')}
-        export const appConfig: ApplicationConfig = ${appConfig}`;
-    const appConfigFileContents = buildAppConfigFileContents(importsRequiredForAppConfig, appConfigText);
-    return appConfigFileContents;
-}
-function getBootstrapCallFileContents(bootstrapCallFileContents, appConfigNode, importsRequiredForAppConfig) {
-    let newBootstrapCallFileContents = `import { appConfig } from './app/app.config';
-${bootstrapCallFileContents.slice(0, appConfigNode.getStart())}appConfig${bootstrapCallFileContents.slice(appConfigNode.getEnd())}`;
-    for (const importStatement of importsRequiredForAppConfig) {
-        newBootstrapCallFileContents = newBootstrapCallFileContents.replace(importStatement, '');
-    }
-    return newBootstrapCallFileContents;
-}
-async function extractStandaloneConfig(tree) {
-    if (!tsModule) {
-        tsModule = (0, ensure_typescript_1.ensureTypescript)();
-    }
-    if (!tsquery) {
-        tsquery = require('@phenomnomnominal/tsquery').tsquery;
-    }
-    const projects = await (0, projects_1.getProjectsFilteredByDependencies)(tree, [
-        'npm:@angular/core',
-    ]);
-    const BOOTSTRAP_APPLICATION_CALL_SELECTOR = 'CallExpression:has(Identifier[name=bootstrapApplication])';
-    const BOOTSTRAP_APPLICATION_CALL_CONFIG_SELECTOR = 'CallExpression:has(Identifier[name=bootstrapApplication]) > ObjectLiteralExpression';
-    for (const { project } of projects) {
-        if (project.projectType !== 'application') {
-            continue;
-        }
-        if (project.targets?.build?.options?.main === undefined) {
-            continue;
-        }
-        const { bootstrapCallFilePath, bootstrapCallFileContents } = getBootstrapCallFileInfo(tree, project, project.targets.build.options.main);
-        const bootstrapCallFileContentsAst = tsquery.ast(bootstrapCallFileContents);
-        const nodes = tsquery(bootstrapCallFileContentsAst, BOOTSTRAP_APPLICATION_CALL_SELECTOR, { visitAllChildren: true });
-        if (nodes.length === 0) {
-            continue;
-        }
-        const importTokenMap = getImportTokenMap(bootstrapCallFileContentsAst);
-        const bootstrapCallNode = nodes[0];
-        const appConfigNodes = tsquery(bootstrapCallNode, BOOTSTRAP_APPLICATION_CALL_CONFIG_SELECTOR, { visitAllChildren: true });
-        if (appConfigNodes.length === 0) {
-            continue;
-        }
-        const appConfigNode = appConfigNodes[0];
-        const appConfigText = appConfigNode.getText();
-        const appConfigFilePath = (0, devkit_1.joinPathFragments)(project.sourceRoot, 'app/app.config.ts');
-        const { appConfigImports, importsToRemoveFromSource } = getImportsRequiredForAppConfig(importTokenMap, appConfigNode, bootstrapCallFilePath, appConfigFilePath);
-        const appConfigFileContents = getAppConfigFileContents(appConfigImports, appConfigText);
-        tree.write(appConfigFilePath, appConfigFileContents);
-        let newBootstrapCallFileContents = getBootstrapCallFileContents(bootstrapCallFileContents, appConfigNode, importsToRemoveFromSource);
-        tree.write(bootstrapCallFilePath, newBootstrapCallFileContents);
-    }
-    await (0, devkit_1.formatFiles)(tree);
-}

package/src/migrations/update-16-1-0/remove-ngcc-invocation.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const devkit_1 = require("@nx/devkit");
-async function default_1(tree) {
-    (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
-        if (!json.scripts?.postinstall?.includes('ngcc ')) {
-            return json;
-        }
-        json.scripts.postinstall = json.scripts.postinstall
-            // special case when ngcc is at the start so we remove the && as well
-            .replace(/^(ngcc.*?&& *)(.*)/, '$2')
-            // everything else
-            .replace(/(.*?)((&& *)?ngcc.*?)((?=&)|$)(.*)/, '$1$5')
-            .trim();
-        if (json.scripts.postinstall === '') {
-            json.scripts.postinstall = undefined;
-        }
-        return json;
-    });
-    await (0, devkit_1.formatFiles)(tree);
-}

package/src/migrations/update-16-1-0/remove-render-module-platform-server-exports.d.ts

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

package/src/migrations/update-16-1-0/remove-render-module-platform-server-exports.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const tslib_1 = require("tslib");
-const devkit_1 = require("@nx/devkit");
-const ts = tslib_1.__importStar(require("typescript"));
-const file_change_recorder_1 = require("../../utils/file-change-recorder");
-async function default_1(tree) {
-    (0, devkit_1.visitNotIgnoredFiles)(tree, '/', (path) => {
-        if (path.endsWith('.ts') && !path.endsWith('.d.ts')) {
-            const content = tree.read(path, 'utf8');
-            if (content.includes('@angular/platform-server') &&
-                content.includes('renderModule')) {
-                const source = ts.createSourceFile(path, content.toString().replace(/^\uFEFF/, ''), ts.ScriptTarget.Latest, true);
-                let recorder;
-                let printer;
-                ts.forEachChild(source, function analyze(node) {
-                    if (!(ts.isExportDeclaration(node) &&
-                        node.moduleSpecifier &&
-                        ts.isStringLiteral(node.moduleSpecifier) &&
-                        node.moduleSpecifier.text === '@angular/platform-server' &&
-                        node.exportClause &&
-                        ts.isNamedExports(node.exportClause))) {
-                        // Not a @angular/platform-server named export.
-                        return;
-                    }
-                    const exportClause = node.exportClause;
-                    const newElements = [];
-                    for (const element of exportClause.elements) {
-                        if (element.name.text !== 'renderModule') {
-                            newElements.push(element);
-                        }
-                    }
-                    if (newElements.length === exportClause.elements.length) {
-                        // No changes
-                        return;
-                    }
-                    recorder ??= new file_change_recorder_1.FileChangeRecorder(tree, path);
-                    if (newElements.length) {
-                        // Update named exports as there are leftovers.
-                        const newExportClause = ts.factory.updateNamedExports(exportClause, newElements);
-                        printer ??= ts.createPrinter();
-                        const fix = printer.printNode(ts.EmitHint.Unspecified, newExportClause, source);
-                        const index = exportClause.getStart();
-                        const length = exportClause.getWidth();
-                        recorder.remove(index, index + length);
-                        recorder.insertLeft(index, fix);
-                    }
-                    else {
-                        // Delete export as no exports remain.
-                        recorder.remove(node.getStart(), node.getStart() + node.getWidth());
-                    }
-                    ts.forEachChild(node, analyze);
-                });
-                if (recorder) {
-                    recorder.applyChanges();
-                }
-            }
-        }
-    });
-    await (0, devkit_1.formatFiles)(tree);
-}

package/src/migrations/update-16-1-0/update-server-executor-config.d.ts

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

package/src/migrations/update-16-1-0/update-server-executor-config.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const devkit_1 = require("@nx/devkit");
-const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
-const executors = [
-    '@angular-devkit/build-angular:server',
-    '@nx/angular:server',
-    '@nrwl/angular:server',
-];
-async function default_1(tree) {
-    executors.forEach((executor) => {
-        (0, executor_options_utils_1.forEachExecutorOptions)(tree, executor, (_options, projectName, targetName, configurationName) => {
-            const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, projectName);
-            const configToUpdate = configurationName
-                ? projectConfiguration.targets[targetName].configurations[configurationName]
-                : projectConfiguration.targets[targetName].options;
-            if (configToUpdate?.buildOptimizer === undefined &&
-                configToUpdate?.optimization !== undefined) {
-                configToUpdate.buildOptimizer = !!configToUpdate.optimization;
-            }
-            (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
-        });
-    });
-    await (0, devkit_1.formatFiles)(tree);
-}

package/src/runtime/nx/data-persistence.d.ts

@@ -1,276 +0,0 @@
-import type { Type } from '@angular/core';
-import type { ActivatedRouteSnapshot } from '@angular/router';
-import type { Action } from '@ngrx/store';
-import type { Observable } from 'rxjs';
-export interface PessimisticUpdateOpts<T extends Array<unknown>, A> {
-    run(a: A, ...slices: [...T]): Observable<Action> | Action | void;
-    onError(a: A, e: any): Observable<any> | any;
-}
-export interface OptimisticUpdateOpts<T extends Array<unknown>, A> {
-    run(a: A, ...slices: [...T]): Observable<Action> | Action | void;
-    undoAction(a: A, e: any): Observable<Action> | Action;
-}
-export interface FetchOpts<T extends Array<unknown>, A> {
-    id?(a: A, ...slices: [...T]): any;
-    run(a: A, ...slices: [...T]): Observable<Action> | Action | void;
-    onError?(a: A, e: any): Observable<any> | any;
-}
-export interface HandleNavigationOpts<T extends Array<unknown>> {
-    run(a: ActivatedRouteSnapshot, ...slices: [...T]): Observable<Action> | Action | void;
-    onError?(a: ActivatedRouteSnapshot, e: any): Observable<any> | any;
-}
-export type ActionOrActionWithStates<T extends Array<unknown>, A> = A | [A, ...T];
-export type ActionOrActionWithState<T, A> = ActionOrActionWithStates<[T], A>;
-export type ActionStatesStream<T extends Array<unknown>, A> = Observable<ActionOrActionWithStates<T, A>>;
-export type ActionStateStream<T, A> = Observable<ActionOrActionWithStates<[T], A>>;
-/**
- * @whatItDoes Handles pessimistic updates (updating the server first).
- *
- * Updating the server, when implemented naively, suffers from race conditions and poor error handling.
- *
- * `pessimisticUpdate` addresses these problems. It runs all fetches in order, which removes race conditions
- * and forces the developer to handle errors.
- *
- * ## Example:
- *
- * ```typescript
- * @Injectable()
- * class TodoEffects {
- *   updateTodo$ = createEffect(() =>
- *     this.actions$.pipe(
- *       ofType('UPDATE_TODO'),
- *       pessimisticUpdate({
- *         // provides an action
- *         run: (action: UpdateTodo) => {
- *           // update the backend first, and then dispatch an action that will
- *           // update the client side
- *           return this.backend.updateTodo(action.todo.id, action.todo).pipe(
- *             map((updated) => ({
- *               type: 'UPDATE_TODO_SUCCESS',
- *               todo: updated,
- *             }))
- *           );
- *         },
- *         onError: (action: UpdateTodo, error: any) => {
- *           // we don't need to undo the changes on the client side.
- *           // we can dispatch an error, or simply log the error here and return `null`
- *           return null;
- *         },
- *       })
- *     )
- *   );
- *
- *   constructor(private actions$: Actions, private backend: Backend) {}
- * }
- * ```
- *
- * Note that if you don't return a new action from the run callback, you must set the dispatch property
- * of the effect to false, like this:
- *
- * ```typescript
- * class TodoEffects {
- *   updateTodo$ = createEffect(() =>
- *     this.actions$.pipe(
- *       //...
- *     ), { dispatch: false }
- *   );
- * }
- * ```
- *
- * @param opts
- *
- * @deprecated This will be removed in Nx v21. Import `pessimisticUpdate` from `@ngrx/router-store/data-persistence` instead.
- */
-export declare function pessimisticUpdate<T extends Array<unknown>, A extends Action>(opts: PessimisticUpdateOpts<T, A>): (source: ActionStatesStream<T, A>) => Observable<Action>;
-/**
- * @whatItDoes Handles optimistic updates (updating the client first).
- *
- * It runs all fetches in order, which removes race conditions and forces the developer to handle errors.
- *
- * When using `optimisticUpdate`, in case of a failure, the developer has already updated the state locally,
- * so the developer must provide an undo action.
- *
- * The error handling must be done in the callback, or by means of the undo action.
- *
- * ## Example:
- *
- * ```typescript
- * @Injectable()
- * class TodoEffects {
- *   updateTodo$ = createEffect(() =>
- *     this.actions$.pipe(
- *       ofType('UPDATE_TODO'),
- *       optimisticUpdate({
- *         // provides an action
- *         run: (action: UpdateTodo) => {
- *           return this.backend.updateTodo(action.todo.id, action.todo).pipe(
- *             mapTo({
- *               type: 'UPDATE_TODO_SUCCESS',
- *             })
- *           );
- *         },
- *         undoAction: (action: UpdateTodo, error: any) => {
- *           // dispatch an undo action to undo the changes in the client state
- *           return {
- *             type: 'UNDO_TODO_UPDATE',
- *             todo: action.todo,
- *           };
- *         },
- *       })
- *     )
- *   );
- *
- *   constructor(private actions$: Actions, private backend: Backend) {}
- * }
- * ```
- *
- * Note that if you don't return a new action from the run callback, you must set the dispatch property
- * of the effect to false, like this:
- *
- * ```typescript
- * class TodoEffects {
- *   updateTodo$ = createEffect(() =>
- *     this.actions$.pipe(
- *       //...
- *     ), { dispatch: false }
- *   );
- * }
- * ```
- *
- * @param opts
- *
- * @deprecated This will be removed in Nx v21. Import `optimisticUpdate` from `@ngrx/router-store/data-persistence` instead.
- */
-export declare function optimisticUpdate<T extends Array<unknown>, A extends Action>(opts: OptimisticUpdateOpts<T, A>): (source: ActionStatesStream<T, A>) => Observable<Action>;
-/**
- * @whatItDoes Handles data fetching.
- *
- * Data fetching implemented naively suffers from race conditions and poor error handling.
- *
- * `fetch` addresses these problems. It runs all fetches in order, which removes race conditions
- * and forces the developer to handle errors.
- *
- * ## Example:
- *
- * ```typescript
- * @Injectable()
- * class TodoEffects {
- *   loadTodos$ = createEffect(() =>
- *     this.actions$.pipe(
- *       ofType('GET_TODOS'),
- *       fetch({
- *         // provides an action
- *         run: (a: GetTodos) => {
- *           return this.backend.getAll().pipe(
- *             map((response) => ({
- *               type: 'TODOS',
- *               todos: response.todos,
- *             }))
- *           );
- *         },
- *         onError: (action: GetTodos, error: any) => {
- *           // dispatch an undo action to undo the changes in the client state
- *           return null;
- *         },
- *       })
- *     )
- *   );
- *
- *   constructor(private actions$: Actions, private backend: Backend) {}
- * }
- * ```
- *
- * This is correct, but because it set the concurrency to 1, it may not be performant.
- *
- * To fix that, you can provide the `id` function, like this:
- *
- * ```typescript
- * @Injectable()
- * class TodoEffects {
- *   loadTodo$ = createEffect(() =>
- *     this.actions$.pipe(
- *       ofType('GET_TODO'),
- *       fetch({
- *         id: (todo: GetTodo) => {
- *           return todo.id;
- *         },
- *         // provides an action
- *         run: (todo: GetTodo) => {
- *           return this.backend.getTodo(todo.id).map((response) => ({
- *             type: 'LOAD_TODO_SUCCESS',
- *             todo: response.todo,
- *           }));
- *         },
- *         onError: (action: GetTodo, error: any) => {
- *           // dispatch an undo action to undo the changes in the client state
- *           return null;
- *         },
- *       })
- *     )
- *   );
- *
- *   constructor(private actions$: Actions, private backend: Backend) {}
- * }
- * ```
- *
- * With this setup, the requests for Todo 1 will run concurrently with the requests for Todo 2.
- *
- * In addition, if there are multiple requests for Todo 1 scheduled, it will only run the last one.
- *
- * @param opts
- *
- * @deprecated This will be removed in Nx v21. Import `fetch` from `@ngrx/router-store/data-persistence` instead.
- */
-export declare function fetch<T extends Array<unknown>, A extends Action>(opts: FetchOpts<T, A>): (source: ActionStatesStream<T, A>) => Observable<Action>;
-/**
- * @whatItDoes Handles data fetching as part of router navigation.
- *
- * Data fetching implemented naively suffers from race conditions and poor error handling.
- *
- * `navigation` addresses these problems.
- *
- * It checks if an activated router state contains the passed in component type, and, if it does, runs the `run`
- * callback. It provides the activated snapshot associated with the component and the current state. And it only runs
- * the last request.
- *
- * ## Example:
- *
- * ```typescript
- * @Injectable()
- * class TodoEffects {
- *   loadTodo$ = createEffect(() =>
- *     this.actions$.pipe(
- *       // listens for the routerNavigation action from @ngrx/router-store
- *       navigation(TodoComponent, {
- *         run: (activatedRouteSnapshot: ActivatedRouteSnapshot) => {
- *           return this.backend
- *             .fetchTodo(activatedRouteSnapshot.params['id'])
- *             .pipe(
- *               map((todo) => ({
- *                 type: 'LOAD_TODO_SUCCESS',
- *                 todo: todo,
- *               }))
- *             );
- *         },
- *         onError: (
- *           activatedRouteSnapshot: ActivatedRouteSnapshot,
- *           error: any
- *         ) => {
- *           // we can log and error here and return null
- *           // we can also navigate back
- *           return null;
- *         },
- *       })
- *     )
- *   );
- *
- *   constructor(private actions$: Actions, private backend: Backend) {}
- * }
- * ```
- *
- * @param component
- * @param opts
- *
- * @deprecated This will be removed in Nx v21. Import `navigation` from `@ngrx/router-store/data-persistence` instead.
- */
-export declare function navigation<T extends Array<unknown>, A extends Action>(component: Type<any>, opts: HandleNavigationOpts<T>): (source: ActionStatesStream<T, A>) => Observable<Action<string>>;

package/testing/index.d.ts

@@ -1 +0,0 @@
-export { readAll, readFirst } from './src/testing-utils';

package/testing/ng-package.json

@@ -1,6 +0,0 @@
-{
-  "$schema": "../../../node_modules/ng-packagr/ng-package.schema.json",
-  "lib": {
-    "entryFile": "index.ts"
-  }
-}

package/testing/src/testing-utils.d.ts

@@ -1,33 +0,0 @@
-import type { Observable } from 'rxjs';
-/**
- * @deprecated This will be removed in Nx v21. If using RxJS 7, use `firstValueFrom(obs$.pipe(toArray()))`
- * or `lastValueFrom(obs$.pipe(toArray()))`. If using RxJS 6, use `obs$.pipe(toArray()).toPromise()`.
- *
- * @whatItDoes reads all the values from an observable and returns a promise
- * with an array of all values. This should be used in combination with async/await.
- *
- * ## Example
- *
- * ```typescript
- * const obs = of(1, 2, 3, 4);
- * const res = await readAll(obs)
- * expect(res).toEqual([1, 2, 3, 4]);
- * ```
- */
-export declare function readAll<T>(o: Observable<T>): Promise<T[]>;
-/**
- * @deprecated This will be removed in Nx v21. Since RxJS 7, use `firstValueFrom(obs$)`. If using RxJS 6,
- * use `obs$.pipe(first()).toPromise()`.
- *
- * @whatItDoes reads the first value from an observable and returns a promise
- * with it. This should be used in combination with async/await.
- *
- * ## Example
- *
- * ```typescript
- * const obs = of(1, 2, 3, 4);
- * const res = await readFirst(obs)
- * expect(res).toEqual(1);
- * ```
- */
-export declare function readFirst<T>(o: Observable<T>): Promise<T>;