@nx/angular 16.0.0-beta.5 → 16.0.0-beta.7

package/fesm2020/nx-angular.mjs

@@ -1,8 +1,351 @@
-"use strict";
+import { ROUTER_NAVIGATION } from '@ngrx/router-store';
+import { isObservable, of } from 'rxjs';
+import { concatMap, groupBy, mergeMap, switchMap, filter, map, catchError } from 'rxjs/operators';
+
+/**
+ *
+ * @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
+ */
+function pessimisticUpdate(opts) {
+    return (source) => {
+        return source.pipe(mapActionAndState(), concatMap(runWithErrorHandling(opts.run, opts.onError)));
+    };
+}
+/**
+ *
+ * @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
+ */
+function optimisticUpdate(opts) {
+    return (source) => {
+        return source.pipe(mapActionAndState(), concatMap(runWithErrorHandling(opts.run, opts.undoAction)));
+    };
+}
+/**
+ *
+ * @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
+ */
+function fetch(opts) {
+    return (source) => {
+        if (opts.id) {
+            const groupedFetches = source.pipe(mapActionAndState(), groupBy(([action, ...store]) => {
+                return opts.id(action, ...store);
+            }));
+            return groupedFetches.pipe(mergeMap((pairs) => pairs.pipe(switchMap(runWithErrorHandling(opts.run, opts.onError)))));
+        }
+        return source.pipe(mapActionAndState(), concatMap(runWithErrorHandling(opts.run, opts.onError)));
+    };
+}
+/**
+ * @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
+ */
+function navigation(component, opts) {
+    return (source) => {
+        const nav = source.pipe(mapActionAndState(), filter(([action]) => isStateSnapshot(action)), map(([action, ...slices]) => {
+            if (!isStateSnapshot(action)) {
+                // Because of the above filter we'll never get here,
+                // but this properly type narrows `action`
+                return;
+            }
+            return [
+                findSnapshot(component, action.payload.routerState.root),
+                ...slices,
+            ];
+        }), filter(([snapshot]) => !!snapshot));
+        return nav.pipe(switchMap(runWithErrorHandling(opts.run, opts.onError)));
+    };
+}
+function isStateSnapshot(action) {
+    return action.type === ROUTER_NAVIGATION;
+}
+function runWithErrorHandling(run, onError) {
+    return ([action, ...slices]) => {
+        try {
+            const r = wrapIntoObservable(run(action, ...slices));
+            return r.pipe(catchError((e) => wrapIntoObservable(onError(action, e))));
+        }
+        catch (e) {
+            return wrapIntoObservable(onError(action, e));
+        }
+    };
+}
+/**
+ * @whatItDoes maps Observable<Action | [Action, State]> to
+ * Observable<[Action, State]>
+ */
+function mapActionAndState() {
+    return (source) => {
+        return source.pipe(map((value) => normalizeActionAndState(value)));
+    };
+}
+/**
+ * @whatItDoes Normalizes either a bare action or an array of action and slices
+ * into an array of action and slices (or undefined)
+ */
+function normalizeActionAndState(args) {
+    let action, slices;
+    if (args instanceof Array) {
+        [action, ...slices] = args;
+    }
+    else {
+        slices = [];
+        action = args;
+    }
+    return [action, ...slices];
+}
+function findSnapshot(component, s) {
+    if (s.routeConfig && s.routeConfig.component === component) {
+        return s;
+    }
+    for (const c of s.children) {
+        const ss = findSnapshot(component, c);
+        if (ss) {
+            return ss;
+        }
+    }
+    return null;
+}
+function wrapIntoObservable(obj) {
+    if (isObservable(obj)) {
+        return obj;
+    }
+    else if (!obj) {
+        return of();
+    }
+    else {
+        return of(obj);
+    }
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./index"), exports);
+
+export { fetch, navigation, optimisticUpdate, pessimisticUpdate };
 //# sourceMappingURL=nx-angular.mjs.map

package/fesm2020/nx-angular.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"nx-angular.mjs","sources":["../../../../packages/angular/nx-angular.ts"],"sourcesContent":["/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";AAAA;;AAEG;;;AAEH,OAAwB,CAAA,YAAA,CAAA,OAAA,CAAA,SAAA,CAAA,EAAA,OAAA,CAAA"}
+{"version":3,"file":"nx-angular.mjs","sources":["../../../../packages/angular/src/runtime/nx/data-persistence.ts","../../../../packages/angular/nx-angular.ts"],"sourcesContent":["import type { Type } from '@angular/core';\nimport type {\n  ActivatedRouteSnapshot,\n  RouterStateSnapshot,\n} from '@angular/router';\nimport type { RouterNavigationAction } from '@ngrx/router-store';\nimport { ROUTER_NAVIGATION } from '@ngrx/router-store';\nimport type { Action } from '@ngrx/store';\nimport type { Observable } from 'rxjs';\nimport { isObservable, of } from 'rxjs';\nimport {\n  catchError,\n  concatMap,\n  filter,\n  groupBy,\n  map,\n  mergeMap,\n  switchMap,\n} from 'rxjs/operators';\n\nexport interface PessimisticUpdateOpts<T extends Array<unknown>, A> {\n  run(a: A, ...slices: [...T]): Observable<Action> | Action | void;\n  onError(a: A, e: any): Observable<any> | any;\n}\n\nexport interface OptimisticUpdateOpts<T extends Array<unknown>, A> {\n  run(a: A, ...slices: [...T]): Observable<Action> | Action | void;\n  undoAction(a: A, e: any): Observable<Action> | Action;\n}\n\nexport interface FetchOpts<T extends Array<unknown>, A> {\n  id?(a: A, ...slices: [...T]): any;\n  run(a: A, ...slices: [...T]): Observable<Action> | Action | void;\n  onError?(a: A, e: any): Observable<any> | any;\n}\n\nexport interface HandleNavigationOpts<T extends Array<unknown>> {\n  run(\n    a: ActivatedRouteSnapshot,\n    ...slices: [...T]\n  ): Observable<Action> | Action | void;\n  onError?(a: ActivatedRouteSnapshot, e: any): Observable<any> | any;\n}\n\nexport type ActionOrActionWithStates<T extends Array<unknown>, A> =\n  | A\n  | [A, ...T];\nexport type ActionOrActionWithState<T, A> = ActionOrActionWithStates<[T], A>;\nexport type ActionStatesStream<T extends Array<unknown>, A> = Observable<\n  ActionOrActionWithStates<T, A>\n>;\nexport type ActionStateStream<T, A> = Observable<\n  ActionOrActionWithStates<[T], A>\n>;\n\n/**\n *\n * @whatItDoes Handles pessimistic updates (updating the server first).\n *\n * Updating the server, when implemented naively, suffers from race conditions and poor error handling.\n *\n * `pessimisticUpdate` addresses these problems. It runs all fetches in order, which removes race conditions\n * and forces the developer to handle errors.\n *\n * ## Example:\n *\n * ```typescript\n * @Injectable()\n * class TodoEffects {\n *   updateTodo$ = createEffect(() =>\n *     this.actions$.pipe(\n *       ofType('UPDATE_TODO'),\n *       pessimisticUpdate({\n *         // provides an action\n *         run: (action: UpdateTodo) => {\n *           // update the backend first, and then dispatch an action that will\n *           // update the client side\n *           return this.backend.updateTodo(action.todo.id, action.todo).pipe(\n *             map((updated) => ({\n *               type: 'UPDATE_TODO_SUCCESS',\n *               todo: updated,\n *             }))\n *           );\n *         },\n *         onError: (action: UpdateTodo, error: any) => {\n *           // we don't need to undo the changes on the client side.\n *           // we can dispatch an error, or simply log the error here and return `null`\n *           return null;\n *         },\n *       })\n *     )\n *   );\n *\n *   constructor(private actions$: Actions, private backend: Backend) {}\n * }\n * ```\n *\n * Note that if you don't return a new action from the run callback, you must set the dispatch property\n * of the effect to false, like this:\n *\n * ```typescript\n * class TodoEffects {\n *   updateTodo$ = createEffect(() =>\n *     this.actions$.pipe(\n *       //...\n *     ), { dispatch: false }\n *   );\n * }\n * ```\n *\n * @param opts\n */\nexport function pessimisticUpdate<T extends Array<unknown>, A extends Action>(\n  opts: PessimisticUpdateOpts<T, A>\n) {\n  return (source: ActionStatesStream<T, A>): Observable<Action> => {\n    return source.pipe(\n      mapActionAndState(),\n      concatMap(runWithErrorHandling(opts.run, opts.onError))\n    );\n  };\n}\n\n/**\n *\n * @whatItDoes Handles optimistic updates (updating the client first).\n *\n * It runs all fetches in order, which removes race conditions and forces the developer to handle errors.\n *\n * When using `optimisticUpdate`, in case of a failure, the developer has already updated the state locally,\n * so the developer must provide an undo action.\n *\n * The error handling must be done in the callback, or by means of the undo action.\n *\n * ## Example:\n *\n * ```typescript\n * @Injectable()\n * class TodoEffects {\n *   updateTodo$ = createEffect(() =>\n *     this.actions$.pipe(\n *       ofType('UPDATE_TODO'),\n *       optimisticUpdate({\n *         // provides an action\n *         run: (action: UpdateTodo) => {\n *           return this.backend.updateTodo(action.todo.id, action.todo).pipe(\n *             mapTo({\n *               type: 'UPDATE_TODO_SUCCESS',\n *             })\n *           );\n *         },\n *         undoAction: (action: UpdateTodo, error: any) => {\n *           // dispatch an undo action to undo the changes in the client state\n *           return {\n *             type: 'UNDO_TODO_UPDATE',\n *             todo: action.todo,\n *           };\n *         },\n *       })\n *     )\n *   );\n *\n *   constructor(private actions$: Actions, private backend: Backend) {}\n * }\n * ```\n *\n * Note that if you don't return a new action from the run callback, you must set the dispatch property\n * of the effect to false, like this:\n *\n * ```typescript\n * class TodoEffects {\n *   updateTodo$ = createEffect(() =>\n *     this.actions$.pipe(\n *       //...\n *     ), { dispatch: false }\n *   );\n * }\n * ```\n *\n * @param opts\n */\nexport function optimisticUpdate<T extends Array<unknown>, A extends Action>(\n  opts: OptimisticUpdateOpts<T, A>\n) {\n  return (source: ActionStatesStream<T, A>): Observable<Action> => {\n    return source.pipe(\n      mapActionAndState(),\n      concatMap(runWithErrorHandling(opts.run, opts.undoAction))\n    );\n  };\n}\n\n/**\n *\n * @whatItDoes Handles data fetching.\n *\n * Data fetching implemented naively suffers from race conditions and poor error handling.\n *\n * `fetch` addresses these problems. It runs all fetches in order, which removes race conditions\n * and forces the developer to handle errors.\n *\n * ## Example:\n *\n * ```typescript\n * @Injectable()\n * class TodoEffects {\n *   loadTodos$ = createEffect(() =>\n *     this.actions$.pipe(\n *       ofType('GET_TODOS'),\n *       fetch({\n *         // provides an action\n *         run: (a: GetTodos) => {\n *           return this.backend.getAll().pipe(\n *             map((response) => ({\n *               type: 'TODOS',\n *               todos: response.todos,\n *             }))\n *           );\n *         },\n *         onError: (action: GetTodos, error: any) => {\n *           // dispatch an undo action to undo the changes in the client state\n *           return null;\n *         },\n *       })\n *     )\n *   );\n *\n *   constructor(private actions$: Actions, private backend: Backend) {}\n * }\n * ```\n *\n * This is correct, but because it set the concurrency to 1, it may not be performant.\n *\n * To fix that, you can provide the `id` function, like this:\n *\n * ```typescript\n * @Injectable()\n * class TodoEffects {\n *   loadTodo$ = createEffect(() =>\n *     this.actions$.pipe(\n *       ofType('GET_TODO'),\n *       fetch({\n *         id: (todo: GetTodo) => {\n *           return todo.id;\n *         },\n *         // provides an action\n *         run: (todo: GetTodo) => {\n *           return this.backend.getTodo(todo.id).map((response) => ({\n *             type: 'LOAD_TODO_SUCCESS',\n *             todo: response.todo,\n *           }));\n *         },\n *         onError: (action: GetTodo, error: any) => {\n *           // dispatch an undo action to undo the changes in the client state\n *           return null;\n *         },\n *       })\n *     )\n *   );\n *\n *   constructor(private actions$: Actions, private backend: Backend) {}\n * }\n * ```\n *\n * With this setup, the requests for Todo 1 will run concurrently with the requests for Todo 2.\n *\n * In addition, if there are multiple requests for Todo 1 scheduled, it will only run the last one.\n *\n * @param opts\n */\nexport function fetch<T extends Array<unknown>, A extends Action>(\n  opts: FetchOpts<T, A>\n) {\n  return (source: ActionStatesStream<T, A>): Observable<Action> => {\n    if (opts.id) {\n      const groupedFetches = source.pipe(\n        mapActionAndState(),\n        groupBy(([action, ...store]) => {\n          return opts.id(action, ...store);\n        })\n      );\n\n      return groupedFetches.pipe(\n        mergeMap((pairs) =>\n          pairs.pipe(switchMap(runWithErrorHandling(opts.run, opts.onError)))\n        )\n      );\n    }\n\n    return source.pipe(\n      mapActionAndState(),\n      concatMap(runWithErrorHandling(opts.run, opts.onError))\n    );\n  };\n}\n\n/**\n * @whatItDoes Handles data fetching as part of router navigation.\n *\n * Data fetching implemented naively suffers from race conditions and poor error handling.\n *\n * `navigation` addresses these problems.\n *\n * It checks if an activated router state contains the passed in component type, and, if it does, runs the `run`\n * callback. It provides the activated snapshot associated with the component and the current state. And it only runs\n * the last request.\n *\n * ## Example:\n *\n * ```typescript\n * @Injectable()\n * class TodoEffects {\n *   loadTodo$ = createEffect(() =>\n *     this.actions$.pipe(\n *       // listens for the routerNavigation action from @ngrx/router-store\n *       navigation(TodoComponent, {\n *         run: (activatedRouteSnapshot: ActivatedRouteSnapshot) => {\n *           return this.backend\n *             .fetchTodo(activatedRouteSnapshot.params['id'])\n *             .pipe(\n *               map((todo) => ({\n *                 type: 'LOAD_TODO_SUCCESS',\n *                 todo: todo,\n *               }))\n *             );\n *         },\n *         onError: (\n *           activatedRouteSnapshot: ActivatedRouteSnapshot,\n *           error: any\n *         ) => {\n *           // we can log and error here and return null\n *           // we can also navigate back\n *           return null;\n *         },\n *       })\n *     )\n *   );\n *\n *   constructor(private actions$: Actions, private backend: Backend) {}\n * }\n * ```\n *\n * @param component\n * @param opts\n */\nexport function navigation<T extends Array<unknown>, A extends Action>(\n  component: Type<any>,\n  opts: HandleNavigationOpts<T>\n) {\n  return (source: ActionStatesStream<T, A>) => {\n    const nav = source.pipe(\n      mapActionAndState(),\n      filter(([action]) => isStateSnapshot(action)),\n      map(([action, ...slices]) => {\n        if (!isStateSnapshot(action)) {\n          // Because of the above filter we'll never get here,\n          // but this properly type narrows `action`\n          return;\n        }\n\n        return [\n          findSnapshot(component, action.payload.routerState.root),\n          ...slices,\n        ] as [ActivatedRouteSnapshot, ...T];\n      }),\n      filter(([snapshot]) => !!snapshot)\n    );\n\n    return nav.pipe(switchMap(runWithErrorHandling(opts.run, opts.onError)));\n  };\n}\n\nfunction isStateSnapshot(\n  action: any\n): action is RouterNavigationAction<RouterStateSnapshot> {\n  return action.type === ROUTER_NAVIGATION;\n}\n\nfunction runWithErrorHandling<T extends Array<unknown>, A, R>(\n  run: (a: A, ...slices: [...T]) => Observable<R> | R | void,\n  onError: any\n) {\n  return ([action, ...slices]: [A, ...T]): Observable<R> => {\n    try {\n      const r = wrapIntoObservable(run(action, ...slices));\n      return r.pipe(catchError((e) => wrapIntoObservable(onError(action, e))));\n    } catch (e) {\n      return wrapIntoObservable(onError(action, e));\n    }\n  };\n}\n\n/**\n * @whatItDoes maps Observable<Action | [Action, State]> to\n * Observable<[Action, State]>\n */\nfunction mapActionAndState<T extends Array<unknown>, A>() {\n  return (source: Observable<ActionOrActionWithStates<T, A>>) => {\n    return source.pipe(\n      map((value) => normalizeActionAndState(value) as [A, ...T])\n    );\n  };\n}\n\n/**\n * @whatItDoes Normalizes either a bare action or an array of action and slices\n * into an array of action and slices (or undefined)\n */\nfunction normalizeActionAndState<T extends Array<unknown>, A>(\n  args: ActionOrActionWithStates<T, A>\n): [A, ...T] {\n  let action: A, slices: T;\n\n  if (args instanceof Array) {\n    [action, ...slices] = args;\n  } else {\n    slices = [] as T;\n    action = args;\n  }\n\n  return [action, ...slices];\n}\n\nfunction findSnapshot(\n  component: Type<any>,\n  s: ActivatedRouteSnapshot\n): ActivatedRouteSnapshot {\n  if (s.routeConfig && s.routeConfig.component === component) {\n    return s;\n  }\n  for (const c of s.children) {\n    const ss = findSnapshot(component, c);\n    if (ss) {\n      return ss;\n    }\n  }\n  return null;\n}\n\nfunction wrapIntoObservable<O>(obj: Observable<O> | O | void): Observable<O> {\n  if (isObservable(obj)) {\n    return obj;\n  } else if (!obj) {\n    return of();\n  } else {\n    return of(obj as O);\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}

package/migrations.json

@@ -176,6 +176,18 @@
       "version": "16.0.0-beta.1",
       "description": "Replace @nrwl/angular with @nx/angular",
       "implementation": "./src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages"
+    },
+    "remove-protractor-defaults-from-generators": {
+      "cli": "nx",
+      "version": "16.0.0-beta.6",
+      "description": "Remove protractor as default e2eTestRunner from nxJson and project configurations",
+      "implementation": "./src/migrations/update-16-0-0/remove-protractor-defaults"
+    },
+    "remove-karma-defaults-from-generators": {
+      "cli": "nx",
+      "version": "16.0.0-beta.6",
+      "description": "Remove karma as default unitTestRunner from nxJson and project configurations",
+      "implementation": "./src/migrations/update-16-0-0/remove-karma-defaults"
     }
   },
   "packageJsonUpdates": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/angular",
-  "version": "16.0.0-beta.5",
+  "version": "16.0.0-beta.7",
   "private": false,
   "description": "The Nx Plugin for Angular contains executors, generators, and utilities for managing Angular applications and libraries within an Nx workspace. It provides: \n\n- Integration with libraries such as Storybook, Jest, ESLint, Tailwind CSS, and Cypress. \n\n- Generators to help scaffold code quickly (like: Micro Frontends, Libraries, both internal to your codebase and publishable to npm) \n\n- Upgrading AngularJS applications \n\n- Single Component Application Modules (SCAMs) \n\n- NgRx helpers. \n\n- Utilities for automatic workspace refactoring.",
   "repository": {
@@ -72,14 +72,14 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
-    "@nrwl/angular": "16.0.0-beta.5",
-    "@nx/cypress": "16.0.0-beta.5",
-    "@nx/devkit": "16.0.0-beta.5",
-    "@nx/jest": "16.0.0-beta.5",
-    "@nx/js": "16.0.0-beta.5",
-    "@nx/linter": "16.0.0-beta.5",
-    "@nx/webpack": "16.0.0-beta.5",
-    "@nx/workspace": "16.0.0-beta.5",
+    "@nrwl/angular": "16.0.0-beta.7",
+    "@nx/cypress": "16.0.0-beta.7",
+    "@nx/devkit": "16.0.0-beta.7",
+    "@nx/jest": "16.0.0-beta.7",
+    "@nx/js": "16.0.0-beta.7",
+    "@nx/linter": "16.0.0-beta.7",
+    "@nx/webpack": "16.0.0-beta.7",
+    "@nx/workspace": "16.0.0-beta.7",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "chalk": "^4.1.0",
     "chokidar": "^3.5.1",
@@ -120,5 +120,5 @@
   "fesm2015": "fesm2015/nx-angular.mjs",
   "typings": "index.d.ts",
   "sideEffects": false,
-  "gitHead": "04fed26279d04c2b02663df5872c6857eb7914bf"
+  "gitHead": "eb477479bf73bca940323a66e486221f00006c0f"
 }

package/src/migrations/update-16-0-0/remove-karma-defaults.d.ts

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

package/src/migrations/update-16-0-0/remove-karma-defaults.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const GENERATORS = ['application', 'library', 'host', 'remote'];
+const CANDIDATE_GENERATOR_COLLECTIONS = ['@nrwl/angular', '@nx/angular'];
+function removeKarmaDefaults(tree) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const nxJson = (0, devkit_1.readNxJson)(tree);
+        if (nxJson.generators) {
+            const updatedConfig = updateUnitTestRunner(nxJson.generators);
+            if (updatedConfig) {
+                (0, devkit_1.updateNxJson)(tree, nxJson);
+            }
+        }
+        const projects = (0, devkit_1.getProjects)(tree);
+        for (const [projectName, projectConfig] of projects) {
+            if (projectConfig.generators) {
+                const updatedProject = updateUnitTestRunner(projectConfig.generators);
+                if (updatedProject) {
+                    (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfig);
+                }
+            }
+        }
+        yield (0, devkit_1.formatFiles)(tree);
+    });
+}
+exports.default = removeKarmaDefaults;
+function updateUnitTestRunner(generatorsConfig) {
+    const generators = Object.entries(generatorsConfig);
+    let updatedConfig = false;
+    for (const [generatorName, generatorDefaults] of generators) {
+        if (CANDIDATE_GENERATOR_COLLECTIONS.includes(generatorName)) {
+            for (const possibleGenerator of GENERATORS) {
+                if (generatorDefaults[possibleGenerator] &&
+                    generatorDefaults[possibleGenerator]['unitTestRunner'] &&
+                    generatorDefaults[possibleGenerator]['unitTestRunner'] === 'karma') {
+                    generatorsConfig[generatorName][possibleGenerator]['unitTestRunner'] =
+                        undefined;
+                    updatedConfig = true;
+                }
+            }
+        }
+        if (!GENERATORS.map((v) => `@nrwl/angular:${v}`).includes(generatorName) &&
+            !GENERATORS.map((v) => `@nx/angular:${v}`).includes(generatorName)) {
+            continue;
+        }
+        if (generatorDefaults['unitTestRunner'] &&
+            generatorDefaults['unitTestRunner'] === 'karma') {
+            generatorsConfig[generatorName]['unitTestRunner'] = undefined;
+            updatedConfig = true;
+        }
+    }
+    return updatedConfig;
+}
+//# sourceMappingURL=remove-karma-defaults.js.map

package/src/migrations/update-16-0-0/remove-karma-defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-karma-defaults.js","sourceRoot":"","sources":["../../../../../../packages/angular/src/migrations/update-16-0-0/remove-karma-defaults.ts"],"names":[],"mappings":";;;AAKA,uCAMoB;AAEpB,MAAM,UAAU,GAAG,CAAC,aAAa,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;AAChE,MAAM,+BAA+B,GAAG,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;AAEzE,SAA8B,mBAAmB,CAAC,IAAU;;QAC1D,MAAM,MAAM,GAAG,IAAA,mBAAU,EAAC,IAAI,CAAC,CAAC;QAEhC,IAAI,MAAM,CAAC,UAAU,EAAE;YACrB,MAAM,aAAa,GAAG,oBAAoB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YAE9D,IAAI,aAAa,EAAE;gBACjB,IAAA,qBAAY,EAAC,IAAI,EAAE,MAAM,CAAC,CAAC;aAC5B;SACF;QAED,MAAM,QAAQ,GAAG,IAAA,oBAAW,EAAC,IAAI,CAAC,CAAC;QAEnC,KAAK,MAAM,CAAC,WAAW,EAAE,aAAa,CAAC,IAAI,QAAQ,EAAE;YACnD,IAAI,aAAa,CAAC,UAAU,EAAE;gBAC5B,MAAM,cAAc,GAAG,oBAAoB,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;gBAEtE,IAAI,cAAc,EAAE;oBAClB,IAAA,mCAA0B,EAAC,IAAI,EAAE,WAAW,EAAE,aAAa,CAAC,CAAC;iBAC9D;aACF;SACF;QAED,MAAM,IAAA,oBAAW,EAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;CAAA;AAxBD,sCAwBC;AAED,SAAS,oBAAoB,CAC3B,gBAEsC;IAEtC,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAEpD,IAAI,aAAa,GAAG,KAAK,CAAC;IAC1B,KAAK,MAAM,CAAC,aAAa,EAAE,iBAAiB,CAAC,IAAI,UAAU,EAAE;QAC3D,IAAI,+BAA+B,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE;YAC3D,KAAK,MAAM,iBAAiB,IAAI,UAAU,EAAE;gBAC1C,IACE,iBAAiB,CAAC,iBAAiB,CAAC;oBACpC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC,gBAAgB,CAAC;oBACtD,iBAAiB,CAAC,iBAAiB,CAAC,CAAC,gBAAgB,CAAC,KAAK,OAAO,EAClE;oBACA,gBAAgB,CAAC,aAAa,CAAC,CAAC,iBAAiB,CAAC,CAAC,gBAAgB,CAAC;wBAClE,SAAS,CAAC;oBACZ,aAAa,GAAG,IAAI,CAAC;iBACtB;aACF;SACF;QAED,IACE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC;YACpE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC,EAClE;YACA,SAAS;SACV;QAED,IACE,iBAAiB,CAAC,gBAAgB,CAAC;YACnC,iBAAiB,CAAC,gBAAgB,CAAC,KAAK,OAAO,EAC/C;YACA,gBAAgB,CAAC,aAAa,CAAC,CAAC,gBAAgB,CAAC,GAAG,SAAS,CAAC;YAC9D,aAAa,GAAG,IAAI,CAAC;SACtB;KACF;IAED,OAAO,aAAa,CAAC;AACvB,CAAC"}

package/src/migrations/update-16-0-0/remove-protractor-defaults.d.ts

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

package/src/migrations/update-16-0-0/remove-protractor-defaults.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const GENERATORS = ['application', 'host', 'remote'];
+const CANDIDATE_GENERATOR_COLLECTIONS = ['@nrwl/angular', '@nx/angular'];
+function removeProtractorDefaults(tree) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const nxJson = (0, devkit_1.readNxJson)(tree);
+        if (nxJson.generators) {
+            const updatedConfig = updateE2ETestRunner(nxJson.generators);
+            if (updatedConfig) {
+                (0, devkit_1.updateNxJson)(tree, nxJson);
+            }
+        }
+        const projects = (0, devkit_1.getProjects)(tree);
+        for (const [projectName, projectConfig] of projects) {
+            if (projectConfig.generators) {
+                const updatedProject = updateE2ETestRunner(projectConfig.generators);
+                if (updatedProject) {
+                    (0, devkit_1.updateProjectConfiguration)(tree, projectName, projectConfig);
+                }
+            }
+        }
+        yield (0, devkit_1.formatFiles)(tree);
+    });
+}
+exports.default = removeProtractorDefaults;
+function updateE2ETestRunner(generatorsConfig) {
+    const generators = Object.entries(generatorsConfig);
+    let updatedConfig = false;
+    for (const [generatorName, generatorDefaults] of generators) {
+        if (CANDIDATE_GENERATOR_COLLECTIONS.includes(generatorName)) {
+            for (const possibleGenerator of GENERATORS) {
+                if (generatorDefaults[possibleGenerator] &&
+                    generatorDefaults[possibleGenerator]['e2eTestRunner'] &&
+                    generatorDefaults[possibleGenerator]['e2eTestRunner'] === 'protractor') {
+                    generatorsConfig[generatorName][possibleGenerator]['e2eTestRunner'] =
+                        undefined;
+                    updatedConfig = true;
+                }
+            }
+        }
+        if (!GENERATORS.map((v) => `@nrwl/angular:${v}`).includes(generatorName) &&
+            !GENERATORS.map((v) => `@nx/angular:${v}`).includes(generatorName)) {
+            continue;
+        }
+        if (generatorDefaults['e2eTestRunner'] &&
+            generatorDefaults['e2eTestRunner'] === 'protractor') {
+            generatorsConfig[generatorName]['e2eTestRunner'] = undefined;
+            updatedConfig = true;
+        }
+    }
+    return updatedConfig;
+}
+//# sourceMappingURL=remove-protractor-defaults.js.map

package/src/migrations/update-16-0-0/remove-protractor-defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-protractor-defaults.js","sourceRoot":"","sources":["../../../../../../packages/angular/src/migrations/update-16-0-0/remove-protractor-defaults.ts"],"names":[],"mappings":";;;AAKA,uCAMoB;AAEpB,MAAM,UAAU,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;AACrD,MAAM,+BAA+B,GAAG,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;AAEzE,SAA8B,wBAAwB,CAAC,IAAU;;QAC/D,MAAM,MAAM,GAAG,IAAA,mBAAU,EAAC,IAAI,CAAC,CAAC;QAEhC,IAAI,MAAM,CAAC,UAAU,EAAE;YACrB,MAAM,aAAa,GAAG,mBAAmB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;YAE7D,IAAI,aAAa,EAAE;gBACjB,IAAA,qBAAY,EAAC,IAAI,EAAE,MAAM,CAAC,CAAC;aAC5B;SACF;QAED,MAAM,QAAQ,GAAG,IAAA,oBAAW,EAAC,IAAI,CAAC,CAAC;QAEnC,KAAK,MAAM,CAAC,WAAW,EAAE,aAAa,CAAC,IAAI,QAAQ,EAAE;YACnD,IAAI,aAAa,CAAC,UAAU,EAAE;gBAC5B,MAAM,cAAc,GAAG,mBAAmB,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;gBAErE,IAAI,cAAc,EAAE;oBAClB,IAAA,mCAA0B,EAAC,IAAI,EAAE,WAAW,EAAE,aAAa,CAAC,CAAC;iBAC9D;aACF;SACF;QAED,MAAM,IAAA,oBAAW,EAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;CAAA;AAxBD,2CAwBC;AAED,SAAS,mBAAmB,CAC1B,gBAEsC;IAEtC,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAEpD,IAAI,aAAa,GAAG,KAAK,CAAC;IAC1B,KAAK,MAAM,CAAC,aAAa,EAAE,iBAAiB,CAAC,IAAI,UAAU,EAAE;QAC3D,IAAI,+BAA+B,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE;YAC3D,KAAK,MAAM,iBAAiB,IAAI,UAAU,EAAE;gBAC1C,IACE,iBAAiB,CAAC,iBAAiB,CAAC;oBACpC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC,eAAe,CAAC;oBACrD,iBAAiB,CAAC,iBAAiB,CAAC,CAAC,eAAe,CAAC,KAAK,YAAY,EACtE;oBACA,gBAAgB,CAAC,aAAa,CAAC,CAAC,iBAAiB,CAAC,CAAC,eAAe,CAAC;wBACjE,SAAS,CAAC;oBACZ,aAAa,GAAG,IAAI,CAAC;iBACtB;aACF;SACF;QAED,IACE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC;YACpE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC,EAClE;YACA,SAAS;SACV;QAED,IACE,iBAAiB,CAAC,eAAe,CAAC;YAClC,iBAAiB,CAAC,eAAe,CAAC,KAAK,YAAY,EACnD;YACA,gBAAgB,CAAC,aAAa,CAAC,CAAC,eAAe,CAAC,GAAG,SAAS,CAAC;YAC7D,aAAa,GAAG,IAAI,CAAC;SACtB;KACF;IAED,OAAO,aAAa,CAAC;AACvB,CAAC"}