@nx/angular 0.0.0-pr-22179-271588f

package/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2017-2023 Narwhal Technologies Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,68 @@
+<p style="text-align: center;">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-dark.svg">
+    <img alt="Nx - Smart Monorepos · Fast CI" src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-light.svg" width="100%">
+  </picture>
+</p>
+
+<div style="text-align: center;">
+
+[![CircleCI](https://circleci.com/gh/nrwl/nx.svg?style=svg)](https://circleci.com/gh/nrwl/nx)
+[![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
+[![NPM Version](https://badge.fury.io/js/%40nrwl%2Fworkspace.svg)](https://www.npmjs.com/@nx/workspace)
+[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+[![Join the chat at https://gitter.im/nrwl-nx/community](https://badges.gitter.im/nrwl-nx/community.svg)](https://gitter.im/nrwl-nx/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
+
+</div>
+
+
+<hr>
+
+# Nx: Smart Monorepos · Fast CI
+
+Nx is a build system with built-in tooling and advanced CI capabilities. It helps you maintain and scale monorepos, both locally and on CI.
+
+This package is an [Angular plugin for Nx](https://nx.dev/packages/angular).
+
+## Getting Started
+
+### Creating an Nx Workspace
+
+**Using `npx`**
+
+```bash
+npx create-nx-workspace
+```
+
+**Using `npm init`**
+
+```bash
+npm init nx-workspace
+```
+
+**Using `yarn create`**
+
+```bash
+yarn create nx-workspace
+```
+
+### Adding Nx to an Existing Repository
+
+Run:
+
+```bash
+npx nx@latest init
+```
+
+## Documentation & Resources
+
+- [Nx.Dev: Documentation, Guides, Tutorials](https://nx.dev)
+- [Intro to Nx](https://nx.dev/getting-started/intro)
+- [Official Nx YouTube Channel](https://www.youtube.com/@NxDevtools)
+- [Blog Posts About Nx](https://blog.nrwl.io/nx/home)
+
+<p style="text-align: center;"><a href="https://nx.dev/#learning-materials" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-courses-and-videos.svg" 
+width="100%" alt="Nx - Smart Monorepos · Fast CI"></a></p>
+

package/esm2022/index.mjs

@@ -0,0 +1,2 @@
+export { fetch, navigation, optimisticUpdate, pessimisticUpdate, } from './src/runtime/nx/data-persistence';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxLQUFLLEVBQ0wsVUFBVSxFQUNWLGdCQUFnQixFQUNoQixpQkFBaUIsR0FDbEIsTUFBTSxtQ0FBbUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gIGZldGNoLFxuICBuYXZpZ2F0aW9uLFxuICBvcHRpbWlzdGljVXBkYXRlLFxuICBwZXNzaW1pc3RpY1VwZGF0ZSxcbn0gZnJvbSAnLi9zcmMvcnVudGltZS9ueC9kYXRhLXBlcnNpc3RlbmNlJztcbiJdfQ==

package/esm2022/mf/index.mjs

@@ -0,0 +1,2 @@
+export { setRemoteUrlResolver, setRemoteDefinitions, loadRemoteModule, } from './mf';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyL21mL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxvQkFBb0IsRUFDcEIsb0JBQW9CLEVBQ3BCLGdCQUFnQixHQUNqQixNQUFNLE1BQU0sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gIHNldFJlbW90ZVVybFJlc29sdmVyLFxuICBzZXRSZW1vdGVEZWZpbml0aW9ucyxcbiAgbG9hZFJlbW90ZU1vZHVsZSxcbn0gZnJvbSAnLi9tZic7XG4iXX0=

package/esm2022/mf/mf.mjs

@@ -0,0 +1,48 @@
+let resolveRemoteUrl;
+export function setRemoteUrlResolver(_resolveRemoteUrl) {
+    resolveRemoteUrl = _resolveRemoteUrl;
+}
+let remoteUrlDefinitions;
+export function setRemoteDefinitions(definitions) {
+    remoteUrlDefinitions = definitions;
+}
+let remoteModuleMap = new Map();
+let remoteContainerMap = new Map();
+export async function loadRemoteModule(remoteName, moduleName) {
+    const remoteModuleKey = `${remoteName}:${moduleName}`;
+    if (remoteModuleMap.has(remoteModuleKey)) {
+        return remoteModuleMap.get(remoteModuleKey);
+    }
+    const container = remoteContainerMap.has(remoteName)
+        ? remoteContainerMap.get(remoteName)
+        : await loadRemoteContainer(remoteName);
+    const factory = await container.get(moduleName);
+    const Module = factory();
+    remoteModuleMap.set(remoteModuleKey, Module);
+    return Module;
+}
+function loadModule(url) {
+    return import(/* webpackIgnore:true */ url);
+}
+let initialSharingScopeCreated = false;
+async function loadRemoteContainer(remoteName) {
+    if (!resolveRemoteUrl && !remoteUrlDefinitions) {
+        throw new Error('Call setRemoteDefinitions or setRemoteUrlResolver to allow Dynamic Federation to find the remote apps correctly.');
+    }
+    if (!initialSharingScopeCreated) {
+        initialSharingScopeCreated = true;
+        await __webpack_init_sharing__('default');
+    }
+    const remoteUrl = remoteUrlDefinitions
+        ? remoteUrlDefinitions[remoteName]
+        : await resolveRemoteUrl(remoteName);
+    let containerUrl = remoteUrl;
+    if (!remoteUrl.endsWith('.mjs') && !remoteUrl.endsWith('.js')) {
+        containerUrl = `${remoteUrl}${remoteUrl.endsWith('/') ? '' : '/'}remoteEntry.mjs`;
+    }
+    const container = await loadModule(containerUrl);
+    await container.init(__webpack_share_scopes__.default);
+    remoteContainerMap.set(remoteName, container);
+    return container;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/mf/nx-angular-mf.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibngtYW5ndWxhci1tZi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FuZ3VsYXIvbWYvbngtYW5ndWxhci1tZi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/nx-angular.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibngtYW5ndWxhci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2FuZ3VsYXIvbngtYW5ndWxhci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/src/runtime/nx/data-persistence.mjs

@@ -0,0 +1,344 @@
+import { ROUTER_NAVIGATION } from '@ngrx/router-store';
+import { isObservable, of } from 'rxjs';
+import { catchError, concatMap, filter, groupBy, map, mergeMap, switchMap, } 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-persistence.js","sourceRoot":"","sources":["../../../../../../../packages/angular/src/runtime/nx/data-persistence.ts"],"names":[],"mappings":"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","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"]}

package/esm2022/testing/index.mjs

@@ -0,0 +1,2 @@
+export { readAll, readFirst } from './src/testing-utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9hbmd1bGFyL3Rlc3RpbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IHJlYWRBbGwsIHJlYWRGaXJzdCB9IGZyb20gJy4vc3JjL3Rlc3RpbmctdXRpbHMnO1xuIl19

package/esm2022/testing/nx-angular-testing.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibngtYW5ndWxhci10ZXN0aW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYW5ndWxhci90ZXN0aW5nL254LWFuZ3VsYXItdGVzdGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/testing/src/testing-utils.mjs

@@ -0,0 +1,36 @@
+import { first, toArray } from 'rxjs/operators';
+/**
+ * @deprecated This will be removed in a later version of Nx. Since RxJS 7, use firstValueFrom(obs$.pipe(toArray())) or lastValueFrom(obs$.pipe(toArray())).
+ *
+ * @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 function readAll(o) {
+    return o.pipe(toArray()).toPromise();
+}
+/**
+ * @deprecated This will be removed in a later version of Nx. Since RxJS 7, use firstValueFrom(obs$)
+ *
+ * @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 function readFirst(o) {
+    return o.pipe(first()).toPromise();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/executors.d.ts

@@ -0,0 +1,16 @@
+export * from './src/builders/module-federation-dev-ssr/module-federation-dev-ssr.impl';
+export * from './src/builders/webpack-browser/webpack-browser.impl';
+export * from './src/builders/webpack-server/webpack-server.impl';
+export * from './src/executors/module-federation-dev-server/module-federation-dev-server.impl';
+export * from './src/executors/delegate-build/delegate-build.impl';
+export * from './src/executors/ng-packagr-lite/ng-packagr-lite.impl';
+export * from './src/executors/package/package.impl';
+export * from './src/executors/browser-esbuild/browser-esbuild.impl';
+export * from './src/executors/application/application.impl';
+export * from './src/executors/extract-i18n/extract-i18n.impl';
+import { executeDevServerBuilder } from './src/builders/dev-server/dev-server.impl';
+export { 
+/**
+ * @deprecated Use executeDevServerBuilder instead. It will be removed in Nx v19.
+ */
+executeDevServerBuilder as executeWebpackDevServerBuilder, executeDevServerBuilder, };

package/executors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDevServerBuilder = exports.executeWebpackDevServerBuilder = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./src/builders/module-federation-dev-ssr/module-federation-dev-ssr.impl"), exports);
+tslib_1.__exportStar(require("./src/builders/webpack-browser/webpack-browser.impl"), exports);
+tslib_1.__exportStar(require("./src/builders/webpack-server/webpack-server.impl"), exports);
+tslib_1.__exportStar(require("./src/executors/module-federation-dev-server/module-federation-dev-server.impl"), exports);
+tslib_1.__exportStar(require("./src/executors/delegate-build/delegate-build.impl"), exports);
+tslib_1.__exportStar(require("./src/executors/ng-packagr-lite/ng-packagr-lite.impl"), exports);
+tslib_1.__exportStar(require("./src/executors/package/package.impl"), exports);
+tslib_1.__exportStar(require("./src/executors/browser-esbuild/browser-esbuild.impl"), exports);
+tslib_1.__exportStar(require("./src/executors/application/application.impl"), exports);
+tslib_1.__exportStar(require("./src/executors/extract-i18n/extract-i18n.impl"), exports);
+const dev_server_impl_1 = require("./src/builders/dev-server/dev-server.impl");
+Object.defineProperty(exports, "executeWebpackDevServerBuilder", { enumerable: true, get: function () { return dev_server_impl_1.executeDevServerBuilder; } });
+Object.defineProperty(exports, "executeDevServerBuilder", { enumerable: true, get: function () { return dev_server_impl_1.executeDevServerBuilder; } });