@ngrx/data 15.4.0 → 16.0.0-rc.0

package/esm2022/src/dataservices/entity-data.service.mjs

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./default-data.service";
+/**
+ * Registry of EntityCollection data services that make REST-like CRUD calls
+ * to entity collection endpoints.
+ */
+class EntityDataService {
+    // TODO:  Optionally inject specialized entity data services
+    // for those that aren't derived from BaseDataService.
+    constructor(defaultDataServiceFactory) {
+        this.defaultDataServiceFactory = defaultDataServiceFactory;
+        this.services = {};
+    }
+    /**
+     * Get (or create) a data service for entity type
+     * @param entityName - the name of the type
+     *
+     * Examples:
+     *   getService('Hero'); // data service for Heroes, untyped
+     *   getService<Hero>('Hero'); // data service for Heroes, typed as Hero
+     */
+    getService(entityName) {
+        entityName = entityName.trim();
+        let service = this.services[entityName];
+        if (!service) {
+            service = this.defaultDataServiceFactory.create(entityName);
+            this.services[entityName] = service;
+        }
+        return service;
+    }
+    /**
+     * Register an EntityCollectionDataService for an entity type
+     * @param entityName - the name of the entity type
+     * @param service - data service for that entity type
+     *
+     * Examples:
+     *   registerService('Hero', myHeroDataService);
+     *   registerService('Villain', myVillainDataService);
+     */
+    registerService(entityName, service) {
+        this.services[entityName.trim()] = service;
+    }
+    /**
+     * Register a batch of data services.
+     * @param services - data services to merge into existing services
+     *
+     * Examples:
+     *   registerServices({
+     *     Hero: myHeroDataService,
+     *     Villain: myVillainDataService
+     *   });
+     */
+    registerServices(services) {
+        this.services = { ...this.services, ...services };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityDataService, deps: [{ token: i1.DefaultDataServiceFactory }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityDataService }); }
+}
+export { EntityDataService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityDataService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DefaultDataServiceFactory }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/dataservices/http-url-generator.mjs

@@ -0,0 +1,88 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../utils/interfaces";
+/**
+ * Known resource URLS for specific entity types.
+ * Each entity's resource URLS are endpoints that
+ * target single entity and multi-entity HTTP operations.
+ * Used by the `DefaultHttpUrlGenerator`.
+ */
+export class EntityHttpResourceUrls {
+}
+/**
+ * Generate the base part of an HTTP URL for
+ * single entity or entity collection resource
+ */
+export class HttpUrlGenerator {
+}
+class DefaultHttpUrlGenerator {
+    constructor(pluralizer) {
+        this.pluralizer = pluralizer;
+        /**
+         * Known single-entity and collection resource URLs for HTTP calls.
+         * Generator methods returns these resource URLs for a given entity type name.
+         * If the resources for an entity type name are not know, it generates
+         * and caches a resource name for future use
+         */
+        this.knownHttpResourceUrls = {};
+    }
+    /**
+     * Get or generate the entity and collection resource URLs for the given entity type name
+     * @param entityName {string} Name of the entity type, e.g, 'Hero'
+     * @param root {string} Root path to the resource, e.g., 'some-api`
+     */
+    getResourceUrls(entityName, root, trailingSlashEndpoints = false) {
+        let resourceUrls = this.knownHttpResourceUrls[entityName];
+        if (!resourceUrls) {
+            const nRoot = trailingSlashEndpoints ? root : normalizeRoot(root);
+            resourceUrls = {
+                entityResourceUrl: `${nRoot}/${entityName}/`.toLowerCase(),
+                collectionResourceUrl: `${nRoot}/${this.pluralizer.pluralize(entityName)}/`.toLowerCase(),
+            };
+            this.registerHttpResourceUrls({ [entityName]: resourceUrls });
+        }
+        return resourceUrls;
+    }
+    /**
+     * Create the path to a single entity resource
+     * @param entityName {string} Name of the entity type, e.g, 'Hero'
+     * @param root {string} Root path to the resource, e.g., 'some-api`
+     * @returns complete path to resource, e.g, 'some-api/hero'
+     */
+    entityResource(entityName, root, trailingSlashEndpoints) {
+        return this.getResourceUrls(entityName, root, trailingSlashEndpoints)
+            .entityResourceUrl;
+    }
+    /**
+     * Create the path to a multiple entity (collection) resource
+     * @param entityName {string} Name of the entity type, e.g, 'Hero'
+     * @param root {string} Root path to the resource, e.g., 'some-api`
+     * @returns complete path to resource, e.g, 'some-api/heroes'
+     */
+    collectionResource(entityName, root) {
+        return this.getResourceUrls(entityName, root).collectionResourceUrl;
+    }
+    /**
+     * Register known single-entity and collection resource URLs for HTTP calls
+     * @param entityHttpResourceUrls {EntityHttpResourceUrls} resource urls for specific entity type names
+     * Well-formed resource urls end in a '/';
+     * Note: this method does not ensure that resource urls are well-formed.
+     */
+    registerHttpResourceUrls(entityHttpResourceUrls) {
+        this.knownHttpResourceUrls = {
+            ...this.knownHttpResourceUrls,
+            ...(entityHttpResourceUrls || {}),
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DefaultHttpUrlGenerator, deps: [{ token: i1.Pluralizer }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DefaultHttpUrlGenerator }); }
+}
+export { DefaultHttpUrlGenerator };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DefaultHttpUrlGenerator, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Pluralizer }]; } });
+/** Remove leading & trailing spaces or slashes */
+export function normalizeRoot(root) {
+    return root.replace(/^[/\s]+|[/\s]+$/g, '');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-url-generator.js","sourceRoot":"","sources":["../../../../../../modules/data/src/dataservices/http-url-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;AAG3C;;;;;GAKG;AACH,MAAM,OAAgB,sBAAsB;CAE3C;AAuBD;;;GAGG;AACH,MAAM,OAAgB,gBAAgB;CAwBrC;AAED,MACa,uBAAuB;IASlC,YAAoB,UAAsB;QAAtB,eAAU,GAAV,UAAU,CAAY;QAR1C;;;;;WAKG;QACO,0BAAqB,GAA2B,EAAE,CAAC;IAEhB,CAAC;IAE9C;;;;OAIG;IACO,eAAe,CACvB,UAAkB,EAClB,IAAY,EACZ,yBAAkC,KAAK;QAEvC,IAAI,YAAY,GAAG,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;QAC1D,IAAI,CAAC,YAAY,EAAE;YACjB,MAAM,KAAK,GAAG,sBAAsB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YAClE,YAAY,GAAG;gBACb,iBAAiB,EAAE,GAAG,KAAK,IAAI,UAAU,GAAG,CAAC,WAAW,EAAE;gBAC1D,qBAAqB,EAAE,GAAG,KAAK,IAAI,IAAI,CAAC,UAAU,CAAC,SAAS,CAC1D,UAAU,CACX,GAAG,CAAC,WAAW,EAAE;aACnB,CAAC;YACF,IAAI,CAAC,wBAAwB,CAAC,EAAE,CAAC,UAAU,CAAC,EAAE,YAAY,EAAE,CAAC,CAAC;SAC/D;QACD,OAAO,YAAY,CAAC;IACtB,CAAC;IAED;;;;;OAKG;IACH,cAAc,CACZ,UAAkB,EAClB,IAAY,EACZ,sBAA+B;QAE/B,OAAO,IAAI,CAAC,eAAe,CAAC,UAAU,EAAE,IAAI,EAAE,sBAAsB,CAAC;aAClE,iBAAiB,CAAC;IACvB,CAAC;IAED;;;;;OAKG;IACH,kBAAkB,CAAC,UAAkB,EAAE,IAAY;QACjD,OAAO,IAAI,CAAC,eAAe,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,qBAAqB,CAAC;IACtE,CAAC;IAED;;;;;OAKG;IACH,wBAAwB,CACtB,sBAA8C;QAE9C,IAAI,CAAC,qBAAqB,GAAG;YAC3B,GAAG,IAAI,CAAC,qBAAqB;YAC7B,GAAG,CAAC,sBAAsB,IAAI,EAAE,CAAC;SAClC,CAAC;IACJ,CAAC;iIAzEU,uBAAuB;qIAAvB,uBAAuB;;SAAvB,uBAAuB;2FAAvB,uBAAuB;kBADnC,UAAU;;AA6EX,kDAAkD;AAClD,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAO,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAAC;AAC9C,CAAC","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Pluralizer } from '../utils/interfaces';\n\n/**\n * Known resource URLS for specific entity types.\n * Each entity's resource URLS are endpoints that\n * target single entity and multi-entity HTTP operations.\n * Used by the `DefaultHttpUrlGenerator`.\n */\nexport abstract class EntityHttpResourceUrls {\n  [entityName: string]: HttpResourceUrls;\n}\n\n/**\n * Resource URLS for HTTP operations that target single entity\n * and multi-entity endpoints.\n */\nexport interface HttpResourceUrls {\n  /**\n   * The URL path for a single entity endpoint, e.g, `some-api-root/hero/`\n   * such as you'd use to add a hero.\n   * Example: `httpClient.post<Hero>('some-api-root/hero/', addedHero)`.\n   * Note trailing slash (/).\n   */\n  entityResourceUrl: string;\n  /**\n   * The URL path for a multiple-entity endpoint, e.g, `some-api-root/heroes/`\n   * such as you'd use when getting all heroes.\n   * Example: `httpClient.get<Hero[]>('some-api-root/heroes/')`\n   * Note trailing slash (/).\n   */\n  collectionResourceUrl: string;\n}\n\n/**\n * Generate the base part of an HTTP URL for\n * single entity or entity collection resource\n */\nexport abstract class HttpUrlGenerator {\n  /**\n   * Return the base URL for a single entity resource,\n   * e.g., the base URL to get a single hero by its id\n   */\n  abstract entityResource(\n    entityName: string,\n    root: string,\n    trailingSlashEndpoints: boolean\n  ): string;\n\n  /**\n   * Return the base URL for a collection resource,\n   * e.g., the base URL to get all heroes\n   */\n  abstract collectionResource(entityName: string, root: string): string;\n\n  /**\n   * Register known single-entity and collection resource URLs for HTTP calls\n   * @param entityHttpResourceUrls {EntityHttpResourceUrls} resource urls for specific entity type names\n   */\n  abstract registerHttpResourceUrls(\n    entityHttpResourceUrls?: EntityHttpResourceUrls\n  ): void;\n}\n\n@Injectable()\nexport class DefaultHttpUrlGenerator implements HttpUrlGenerator {\n  /**\n   * Known single-entity and collection resource URLs for HTTP calls.\n   * Generator methods returns these resource URLs for a given entity type name.\n   * If the resources for an entity type name are not know, it generates\n   * and caches a resource name for future use\n   */\n  protected knownHttpResourceUrls: EntityHttpResourceUrls = {};\n\n  constructor(private pluralizer: Pluralizer) {}\n\n  /**\n   * Get or generate the entity and collection resource URLs for the given entity type name\n   * @param entityName {string} Name of the entity type, e.g, 'Hero'\n   * @param root {string} Root path to the resource, e.g., 'some-api`\n   */\n  protected getResourceUrls(\n    entityName: string,\n    root: string,\n    trailingSlashEndpoints: boolean = false\n  ): HttpResourceUrls {\n    let resourceUrls = this.knownHttpResourceUrls[entityName];\n    if (!resourceUrls) {\n      const nRoot = trailingSlashEndpoints ? root : normalizeRoot(root);\n      resourceUrls = {\n        entityResourceUrl: `${nRoot}/${entityName}/`.toLowerCase(),\n        collectionResourceUrl: `${nRoot}/${this.pluralizer.pluralize(\n          entityName\n        )}/`.toLowerCase(),\n      };\n      this.registerHttpResourceUrls({ [entityName]: resourceUrls });\n    }\n    return resourceUrls;\n  }\n\n  /**\n   * Create the path to a single entity resource\n   * @param entityName {string} Name of the entity type, e.g, 'Hero'\n   * @param root {string} Root path to the resource, e.g., 'some-api`\n   * @returns complete path to resource, e.g, 'some-api/hero'\n   */\n  entityResource(\n    entityName: string,\n    root: string,\n    trailingSlashEndpoints: boolean\n  ): string {\n    return this.getResourceUrls(entityName, root, trailingSlashEndpoints)\n      .entityResourceUrl;\n  }\n\n  /**\n   * Create the path to a multiple entity (collection) resource\n   * @param entityName {string} Name of the entity type, e.g, 'Hero'\n   * @param root {string} Root path to the resource, e.g., 'some-api`\n   * @returns complete path to resource, e.g, 'some-api/heroes'\n   */\n  collectionResource(entityName: string, root: string): string {\n    return this.getResourceUrls(entityName, root).collectionResourceUrl;\n  }\n\n  /**\n   * Register known single-entity and collection resource URLs for HTTP calls\n   * @param entityHttpResourceUrls {EntityHttpResourceUrls} resource urls for specific entity type names\n   * Well-formed resource urls end in a '/';\n   * Note: this method does not ensure that resource urls are well-formed.\n   */\n  registerHttpResourceUrls(\n    entityHttpResourceUrls: EntityHttpResourceUrls\n  ): void {\n    this.knownHttpResourceUrls = {\n      ...this.knownHttpResourceUrls,\n      ...(entityHttpResourceUrls || {}),\n    };\n  }\n}\n\n/** Remove leading & trailing spaces or slashes */\nexport function normalizeRoot(root: string) {\n  return root.replace(/^[/\\s]+|[/\\s]+$/g, '');\n}\n"]}

package/esm2022/src/dataservices/persistence-result-handler.service.mjs

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import { DataServiceError, } from './data-service-error';
+import { makeErrorOp, makeSuccessOp } from '../actions/entity-op';
+import * as i0 from "@angular/core";
+import * as i1 from "../utils/interfaces";
+import * as i2 from "../actions/entity-action-factory";
+/**
+ * Handling of responses from persistence operation
+ */
+export class PersistenceResultHandler {
+}
+/**
+ * Default handling of responses from persistence operation,
+ * specifically an EntityDataService
+ */
+class DefaultPersistenceResultHandler {
+    constructor(logger, entityActionFactory) {
+        this.logger = logger;
+        this.entityActionFactory = entityActionFactory;
+    }
+    /** Handle successful result of persistence operation on an EntityAction */
+    handleSuccess(originalAction) {
+        const successOp = makeSuccessOp(originalAction.payload.entityOp);
+        return (data) => this.entityActionFactory.createFromAction(originalAction, {
+            entityOp: successOp,
+            data,
+        });
+    }
+    /** Handle error result of persistence operation on an EntityAction */
+    handleError(originalAction) {
+        const errorOp = makeErrorOp(originalAction.payload.entityOp);
+        return (err) => {
+            const error = err instanceof DataServiceError ? err : new DataServiceError(err, null);
+            const errorData = { error, originalAction };
+            this.logger.error(errorData);
+            const action = this.entityActionFactory.createFromAction(originalAction, {
+                entityOp: errorOp,
+                data: errorData,
+            });
+            return action;
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DefaultPersistenceResultHandler, deps: [{ token: i1.Logger }, { token: i2.EntityActionFactory }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DefaultPersistenceResultHandler }); }
+}
+export { DefaultPersistenceResultHandler };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DefaultPersistenceResultHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Logger }, { type: i2.EntityActionFactory }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/dispatchers/entity-cache-dispatcher.mjs

@@ -0,0 +1,164 @@
+import { Injectable, Inject } from '@angular/core';
+import { ScannedActionsSubject } from '@ngrx/store';
+import { of, throwError } from 'rxjs';
+import { filter, mergeMap, shareReplay, take } from 'rxjs/operators';
+import { PersistanceCanceled } from './entity-dispatcher';
+import { ClearCollections, EntityCacheAction, LoadCollections, MergeQuerySet, SetEntityCache, SaveEntities, SaveEntitiesCancel, } from '../actions/entity-cache-action';
+import * as i0 from "@angular/core";
+import * as i1 from "../utils/correlation-id-generator";
+import * as i2 from "./entity-dispatcher-default-options";
+import * as i3 from "@ngrx/store";
+import * as i4 from "rxjs";
+/**
+ * Dispatches Entity Cache actions to the EntityCache reducer
+ */
+class EntityCacheDispatcher {
+    constructor(
+    /** Generates correlation ids for query and save methods */
+    correlationIdGenerator, 
+    /**
+     * Dispatcher options configure dispatcher behavior such as
+     * whether add is optimistic or pessimistic by default.
+     */
+    defaultDispatcherOptions, 
+    /** Actions scanned by the store after it processed them with reducers. */
+    scannedActions$, 
+    /** The store, scoped to the EntityCache */
+    store) {
+        this.correlationIdGenerator = correlationIdGenerator;
+        this.defaultDispatcherOptions = defaultDispatcherOptions;
+        this.store = store;
+        // Replay because sometimes in tests will fake data service with synchronous observable
+        // which makes subscriber miss the dispatched actions.
+        // Of course that's a testing mistake. But easy to forget, leading to painful debugging.
+        this.reducedActions$ = scannedActions$.pipe(shareReplay(1));
+        // Start listening so late subscriber won't miss the most recent action.
+        this.raSubscription = this.reducedActions$.subscribe();
+    }
+    /**
+     * Dispatch an Action to the store.
+     * @param action the Action
+     * @returns the dispatched Action
+     */
+    dispatch(action) {
+        this.store.dispatch(action);
+        return action;
+    }
+    /**
+     * Dispatch action to cancel the saveEntities request with matching correlation id.
+     * @param correlationId The correlation id for the corresponding action
+     * @param [reason] explains why canceled and by whom.
+     * @param [entityNames] array of entity names so can turn off loading flag for their collections.
+     * @param [tag] tag to identify the operation from the app perspective.
+     */
+    cancelSaveEntities(correlationId, reason, entityNames, tag) {
+        if (!correlationId) {
+            throw new Error('Missing correlationId');
+        }
+        const action = new SaveEntitiesCancel(correlationId, reason, entityNames, tag);
+        this.dispatch(action);
+    }
+    /** Clear the named entity collections in cache
+     * @param [collections] Array of names of the collections to clear.
+     * If empty array, does nothing. If null/undefined/no array, clear all collections.
+     * @param [tag] tag to identify the operation from the app perspective.
+     */
+    clearCollections(collections, tag) {
+        this.dispatch(new ClearCollections(collections, tag));
+    }
+    /**
+     * Load multiple entity collections at the same time.
+     * before any selectors$ observables emit.
+     * @param collections The collections to load, typically the result of a query.
+     * @param [tag] tag to identify the operation from the app perspective.
+     * in the form of a map of entity collections.
+     */
+    loadCollections(collections, tag) {
+        this.dispatch(new LoadCollections(collections, tag));
+    }
+    /**
+     * Merges entities from a query result
+     * that returned entities from multiple collections.
+     * Corresponding entity cache reducer should add and update all collections
+     * at the same time, before any selectors$ observables emit.
+     * @param querySet The result of the query in the form of a map of entity collections.
+     * These are the entity data to merge into the respective collections.
+     * @param mergeStrategy How to merge a queried entity when it is already in the collection.
+     * The default is MergeStrategy.PreserveChanges
+     * @param [tag] tag to identify the operation from the app perspective.
+     */
+    mergeQuerySet(querySet, mergeStrategy, tag) {
+        this.dispatch(new MergeQuerySet(querySet, mergeStrategy, tag));
+    }
+    /**
+     * Create entity cache action for replacing the entire entity cache.
+     * Dangerous because brute force but useful as when re-hydrating an EntityCache
+     * from local browser storage when the application launches.
+     * @param cache New state of the entity cache
+     * @param [tag] tag to identify the operation from the app perspective.
+     */
+    setEntityCache(cache, tag) {
+        this.dispatch(new SetEntityCache(cache, tag));
+    }
+    /**
+     * Dispatch action to save multiple entity changes to remote storage.
+     * Relies on an Ngrx Effect such as EntityEffects.saveEntities$.
+     * Important: only call if your server supports the SaveEntities protocol
+     * through your EntityDataService.saveEntities method.
+     * @param changes Either the entities to save, as an array of {ChangeSetItem}, or
+     * a ChangeSet that holds such changes.
+     * @param url The server url which receives the save request
+     * @param [options] options such as tag, correlationId, isOptimistic, and mergeStrategy.
+     * These values are defaulted if not supplied.
+     * @returns A terminating Observable<ChangeSet> with data returned from the server
+     * after server reports successful save OR the save error.
+     * TODO: should return the matching entities from cache rather than the raw server data.
+     */
+    saveEntities(changes, url, options) {
+        const changeSet = Array.isArray(changes) ? { changes } : changes;
+        options = options || {};
+        const correlationId = options.correlationId == null
+            ? this.correlationIdGenerator.next()
+            : options.correlationId;
+        const isOptimistic = options.isOptimistic == null
+            ? this.defaultDispatcherOptions.optimisticSaveEntities || false
+            : options.isOptimistic === true;
+        const tag = options.tag || 'Save Entities';
+        options = { ...options, correlationId, isOptimistic, tag };
+        const action = new SaveEntities(changeSet, url, options);
+        this.dispatch(action);
+        return this.getSaveEntitiesResponseData$(options.correlationId).pipe(shareReplay(1));
+    }
+    /**
+     * Return Observable of data from the server-success SaveEntities action with
+     * the given Correlation Id, after that action was processed by the ngrx store.
+     * or else put the server error on the Observable error channel.
+     * @param crid The correlationId for both the save and response actions.
+     */
+    getSaveEntitiesResponseData$(crid) {
+        /**
+         * reducedActions$ must be replay observable of the most recent action reduced by the store.
+         * because the response action might have been dispatched to the store
+         * before caller had a chance to subscribe.
+         */
+        return this.reducedActions$.pipe(filter((act) => act.type === EntityCacheAction.SAVE_ENTITIES_SUCCESS ||
+            act.type === EntityCacheAction.SAVE_ENTITIES_ERROR ||
+            act.type === EntityCacheAction.SAVE_ENTITIES_CANCEL), filter((act) => crid === act.payload.correlationId), take(1), mergeMap((act) => {
+            return act.type === EntityCacheAction.SAVE_ENTITIES_CANCEL
+                ? throwError(new PersistanceCanceled(act.payload.reason))
+                : act.type === EntityCacheAction.SAVE_ENTITIES_SUCCESS
+                    ? of(act.payload.changeSet)
+                    : throwError(act.payload);
+        }));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityCacheDispatcher, deps: [{ token: i1.CorrelationIdGenerator }, { token: i2.EntityDispatcherDefaultOptions }, { token: ScannedActionsSubject }, { token: i3.Store }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityCacheDispatcher }); }
+}
+export { EntityCacheDispatcher };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityCacheDispatcher, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.CorrelationIdGenerator }, { type: i2.EntityDispatcherDefaultOptions }, { type: i4.Observable, decorators: [{
+                    type: Inject,
+                    args: [ScannedActionsSubject]
+                }] }, { type: i3.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-cache-dispatcher.js","sourceRoot":"","sources":["../../../../../../modules/data/src/dispatchers/entity-cache-dispatcher.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject } from '@angular/core';\nimport { Action, ScannedActionsSubject, Store } from '@ngrx/store';\n\nimport { Observable, of, Subscription, throwError } from 'rxjs';\nimport { filter, mergeMap, shareReplay, take } from 'rxjs/operators';\n\nimport { CorrelationIdGenerator } from '../utils/correlation-id-generator';\nimport { EntityActionOptions } from '../actions/entity-action';\nimport { EntityCache } from '../reducers/entity-cache';\nimport { EntityDispatcherDefaultOptions } from './entity-dispatcher-default-options';\n\nimport { MergeStrategy } from '../actions/merge-strategy';\nimport { PersistanceCanceled } from './entity-dispatcher';\n\nimport { ChangeSet, ChangeSetItem } from '../actions/entity-cache-change-set';\nimport {\n  ClearCollections,\n  EntityCacheAction,\n  EntityCacheQuerySet,\n  LoadCollections,\n  MergeQuerySet,\n  SetEntityCache,\n  SaveEntities,\n  SaveEntitiesCancel,\n  SaveEntitiesError,\n  SaveEntitiesSuccess,\n} from '../actions/entity-cache-action';\n\n/**\n * Dispatches Entity Cache actions to the EntityCache reducer\n */\n@Injectable()\nexport class EntityCacheDispatcher {\n  /**\n   * Actions scanned by the store after it processed them with reducers.\n   * A replay observable of the most recent action reduced by the store.\n   */\n  reducedActions$: Observable<Action>;\n  private raSubscription: Subscription;\n\n  constructor(\n    /** Generates correlation ids for query and save methods */\n    private correlationIdGenerator: CorrelationIdGenerator,\n    /**\n     * Dispatcher options configure dispatcher behavior such as\n     * whether add is optimistic or pessimistic by default.\n     */\n    private defaultDispatcherOptions: EntityDispatcherDefaultOptions,\n    /** Actions scanned by the store after it processed them with reducers. */\n    @Inject(ScannedActionsSubject) scannedActions$: Observable<Action>,\n    /** The store, scoped to the EntityCache */\n    private store: Store<EntityCache>\n  ) {\n    // Replay because sometimes in tests will fake data service with synchronous observable\n    // which makes subscriber miss the dispatched actions.\n    // Of course that's a testing mistake. But easy to forget, leading to painful debugging.\n    this.reducedActions$ = scannedActions$.pipe(shareReplay(1));\n    // Start listening so late subscriber won't miss the most recent action.\n    this.raSubscription = this.reducedActions$.subscribe();\n  }\n\n  /**\n   * Dispatch an Action to the store.\n   * @param action the Action\n   * @returns the dispatched Action\n   */\n  dispatch(action: Action): Action {\n    this.store.dispatch(action);\n    return action;\n  }\n\n  /**\n   * Dispatch action to cancel the saveEntities request with matching correlation id.\n   * @param correlationId The correlation id for the corresponding action\n   * @param [reason] explains why canceled and by whom.\n   * @param [entityNames] array of entity names so can turn off loading flag for their collections.\n   * @param [tag] tag to identify the operation from the app perspective.\n   */\n  cancelSaveEntities(\n    correlationId: any,\n    reason?: string,\n    entityNames?: string[],\n    tag?: string\n  ): void {\n    if (!correlationId) {\n      throw new Error('Missing correlationId');\n    }\n    const action = new SaveEntitiesCancel(\n      correlationId,\n      reason,\n      entityNames,\n      tag\n    );\n    this.dispatch(action);\n  }\n\n  /** Clear the named entity collections in cache\n   * @param [collections] Array of names of the collections to clear.\n   * If empty array, does nothing. If null/undefined/no array, clear all collections.\n   * @param [tag] tag to identify the operation from the app perspective.\n   */\n  clearCollections(collections?: string[], tag?: string) {\n    this.dispatch(new ClearCollections(collections, tag));\n  }\n\n  /**\n   * Load multiple entity collections at the same time.\n   * before any selectors$ observables emit.\n   * @param collections The collections to load, typically the result of a query.\n   * @param [tag] tag to identify the operation from the app perspective.\n   * in the form of a map of entity collections.\n   */\n  loadCollections(collections: EntityCacheQuerySet, tag?: string) {\n    this.dispatch(new LoadCollections(collections, tag));\n  }\n\n  /**\n   * Merges entities from a query result\n   * that returned entities from multiple collections.\n   * Corresponding entity cache reducer should add and update all collections\n   * at the same time, before any selectors$ observables emit.\n   * @param querySet The result of the query in the form of a map of entity collections.\n   * These are the entity data to merge into the respective collections.\n   * @param mergeStrategy How to merge a queried entity when it is already in the collection.\n   * The default is MergeStrategy.PreserveChanges\n   * @param [tag] tag to identify the operation from the app perspective.\n   */\n  mergeQuerySet(\n    querySet: EntityCacheQuerySet,\n    mergeStrategy?: MergeStrategy,\n    tag?: string\n  ) {\n    this.dispatch(new MergeQuerySet(querySet, mergeStrategy, tag));\n  }\n\n  /**\n   * Create entity cache action for replacing the entire entity cache.\n   * Dangerous because brute force but useful as when re-hydrating an EntityCache\n   * from local browser storage when the application launches.\n   * @param cache New state of the entity cache\n   * @param [tag] tag to identify the operation from the app perspective.\n   */\n  setEntityCache(cache: EntityCache, tag?: string) {\n    this.dispatch(new SetEntityCache(cache, tag));\n  }\n\n  /**\n   * Dispatch action to save multiple entity changes to remote storage.\n   * Relies on an Ngrx Effect such as EntityEffects.saveEntities$.\n   * Important: only call if your server supports the SaveEntities protocol\n   * through your EntityDataService.saveEntities method.\n   * @param changes Either the entities to save, as an array of {ChangeSetItem}, or\n   * a ChangeSet that holds such changes.\n   * @param url The server url which receives the save request\n   * @param [options] options such as tag, correlationId, isOptimistic, and mergeStrategy.\n   * These values are defaulted if not supplied.\n   * @returns A terminating Observable<ChangeSet> with data returned from the server\n   * after server reports successful save OR the save error.\n   * TODO: should return the matching entities from cache rather than the raw server data.\n   */\n  saveEntities(\n    changes: ChangeSetItem[] | ChangeSet,\n    url: string,\n    options?: EntityActionOptions\n  ): Observable<ChangeSet> {\n    const changeSet = Array.isArray(changes) ? { changes } : changes;\n    options = options || {};\n    const correlationId =\n      options.correlationId == null\n        ? this.correlationIdGenerator.next()\n        : options.correlationId;\n    const isOptimistic =\n      options.isOptimistic == null\n        ? this.defaultDispatcherOptions.optimisticSaveEntities || false\n        : options.isOptimistic === true;\n    const tag = options.tag || 'Save Entities';\n    options = { ...options, correlationId, isOptimistic, tag };\n    const action = new SaveEntities(changeSet, url, options);\n    this.dispatch(action);\n    return this.getSaveEntitiesResponseData$(options.correlationId).pipe(\n      shareReplay(1)\n    );\n  }\n\n  /**\n   * Return Observable of data from the server-success SaveEntities action with\n   * the given Correlation Id, after that action was processed by the ngrx store.\n   * or else put the server error on the Observable error channel.\n   * @param crid The correlationId for both the save and response actions.\n   */\n  private getSaveEntitiesResponseData$(crid: any): Observable<ChangeSet> {\n    /**\n     * reducedActions$ must be replay observable of the most recent action reduced by the store.\n     * because the response action might have been dispatched to the store\n     * before caller had a chance to subscribe.\n     */\n    return this.reducedActions$.pipe(\n      filter(\n        (act: Action) =>\n          act.type === EntityCacheAction.SAVE_ENTITIES_SUCCESS ||\n          act.type === EntityCacheAction.SAVE_ENTITIES_ERROR ||\n          act.type === EntityCacheAction.SAVE_ENTITIES_CANCEL\n      ),\n      filter((act: Action) => crid === (act as any).payload.correlationId),\n      take(1),\n      mergeMap((act) => {\n        return act.type === EntityCacheAction.SAVE_ENTITIES_CANCEL\n          ? throwError(\n              new PersistanceCanceled(\n                (act as SaveEntitiesCancel).payload.reason\n              )\n            )\n          : act.type === EntityCacheAction.SAVE_ENTITIES_SUCCESS\n          ? of((act as SaveEntitiesSuccess).payload.changeSet)\n          : throwError((act as SaveEntitiesError).payload);\n      })\n    );\n  }\n}\n"]}

package/esm2022/src/dispatchers/entity-commands.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-commands.js","sourceRoot":"","sources":["../../../../../../modules/data/src/dispatchers/entity-commands.ts"],"names":[],"mappings":"","sourcesContent":["import { Observable } from 'rxjs';\nimport { EntityActionOptions } from '../actions/entity-action';\nimport { QueryParams } from '../dataservices/interfaces';\n\n/** Commands that update the remote server. */\nexport interface EntityServerCommands<T> {\n  /**\n   * Dispatch action to save a new entity to remote storage.\n   * @param entity entity to add, which may omit its key if pessimistic and the server creates the key;\n   * must have a key if optimistic save.\n   * @returns A terminating Observable of the entity\n   * after server reports successful save or the save error.\n   */\n  add(\n    entity: Partial<T>,\n    options?: EntityActionOptions & { isOptimistic?: false }\n  ): Observable<T>;\n  add(\n    entity: T,\n    options: EntityActionOptions & { isOptimistic: true }\n  ): Observable<T>;\n  add(entity: T, options?: EntityActionOptions): Observable<T>;\n\n  /**\n   * Dispatch action to cancel the persistence operation (query or save) with the given correlationId.\n   * @param correlationId The correlation id for the corresponding EntityAction\n   * @param [reason] explains why canceled and by whom.\n   * @param [options] options such as the tag\n   */\n  cancel(\n    correlationId: any,\n    reason?: string,\n    options?: EntityActionOptions\n  ): void;\n\n  /**\n   * Dispatch action to delete entity from remote storage by key.\n   * @param key The entity to delete\n   * @param [options] options that influence save and merge behavior\n   * @returns A terminating Observable of the deleted key\n   * after server reports successful save or the save error.\n   */\n  delete(entity: T, options?: EntityActionOptions): Observable<number | string>;\n\n  /**\n   * Dispatch action to delete entity from remote storage by key.\n   * @param key The primary key of the entity to remove\n   * @param [options] options that influence save and merge behavior\n   * @returns Observable of the deleted key\n   * after server reports successful save or the save error.\n   */\n  delete(\n    key: number | string,\n    options?: EntityActionOptions\n  ): Observable<number | string>;\n\n  /**\n   * Dispatch action to query remote storage for all entities and\n   * merge the queried entities into the cached collection.\n   * @param [options] options that influence merge behavior\n   * @returns A terminating Observable of the collection\n   * after server reports successful query or the query error.\n   * @see load()\n   */\n  getAll(options?: EntityActionOptions): Observable<T[]>;\n\n  /**\n   * Dispatch action to query remote storage for the entity with this primary key.\n   * If the server returns an entity,\n   * merge it into the cached collection.\n   * @param key The primary key of the entity to get.\n   * @param [options] options that influence merge behavior\n   * @returns A terminating Observable of the queried entities that are in the collection\n   * after server reports success or the query error.\n   */\n  getByKey(key: any, options?: EntityActionOptions): Observable<T>;\n\n  /**\n   * Dispatch action to query remote storage for the entities that satisfy a query expressed\n   * with either a query parameter map or an HTTP URL query string,\n   * and merge the results into the cached collection.\n   * @param queryParams the query in a form understood by the server\n   * @param [options] options that influence merge behavior\n   * @returns A terminating Observable of the queried entities\n   * after server reports successful query or the query error.\n   */\n  getWithQuery(\n    queryParams: QueryParams | string,\n    options?: EntityActionOptions\n  ): Observable<T[]>;\n\n  /**\n   * Dispatch action to query remote storage for all entities and\n   * completely replace the cached collection with the queried entities.\n   * @param [options] options that influence load behavior\n   * @returns A terminating Observable of the entities in the collection\n   * after server reports successful query or the query error.\n   * @see getAll\n   */\n  load(options?: EntityActionOptions): Observable<T[]>;\n\n  /**\n   * Dispatch action to query remote storage for the entities that satisfy a query expressed\n   * with either a query parameter map or an HTTP URL query string, and\n   * completely replace the cached collection with the queried entities.\n   * @param queryParams the query in a form understood by the server\n   * @param [options] options that influence load behavior\n   * @returns A terminating Observable of the entities in the collection\n   * after server reports successful query or the query error.\n   * @see getWithQuery\n   */\n  loadWithQuery(\n    queryParams: QueryParams | string,\n    options?: EntityActionOptions\n  ): Observable<T[]>;\n\n  /**\n   * Dispatch action to save the updated entity (or partial entity) in remote storage.\n   * The update entity may be partial (but must have its key)\n   * in which case it patches the existing entity.\n   * @param entity update entity, which might be a partial of T but must at least have its key.\n   * @param [options] options that influence save and merge behavior\n   * @returns A terminating Observable of the updated entity\n   * after server reports successful save or the save error.\n   */\n  update(entity: Partial<T>, options?: EntityActionOptions): Observable<T>;\n\n  /**\n   * Dispatch action to save a new or update an existing entity to remote storage.\n   * Only dispatch this action if your server supports upsert.\n   * @param entity entity to upsert, which may omit its key if pessimistic and the server creates the key;\n   * must have a key if optimistic save.\n   * @returns A terminating Observable of the entity\n   * after server reports successful save or the save error.\n   */\n  upsert(entity: T, options?: EntityActionOptions): Observable<T>;\n}\n\n/*** A collection's cache-only commands, which do not update remote storage ***/\n\nexport interface EntityCacheCommands<T> {\n  /**\n   * Replace all entities in the cached collection.\n   * Does not save to remote storage.\n   * @param entities to add directly to cache.\n   * @param [options] options such as mergeStrategy\n   */\n  addAllToCache(entities: T[], options?: EntityActionOptions): void;\n\n  /**\n   * Add a new entity directly to the cache.\n   * Does not save to remote storage.\n   * Ignored if an entity with the same primary key is already in cache.\n   * @param entity to add directly to cache.\n   * @param [options] options such as mergeStrategy\n   */\n  addOneToCache(entity: T, options?: EntityActionOptions): void;\n\n  /**\n   * Add multiple new entities directly to the cache.\n   * Does not save to remote storage.\n   * Entities with primary keys already in cache are ignored.\n   * @param entities to add directly to cache.\n   * @param [options] options such as mergeStrategy\n   */\n  addManyToCache(entities: T[], options?: EntityActionOptions): void;\n\n  /** Clear the cached entity collection */\n  clearCache(options?: EntityActionOptions): void;\n\n  /**\n   * Remove an entity directly from the cache.\n   * Does not delete that entity from remote storage.\n   * @param entity The entity to remove\n   * @param [options] options such as mergeStrategy\n   */\n  removeOneFromCache(entity: T, options?: EntityActionOptions): void;\n\n  /**\n   * Remove an entity directly from the cache.\n   * Does not delete that entity from remote storage.\n   * @param key The primary key of the entity to remove\n   * @param [options] options such as mergeStrategy\n   */\n  removeOneFromCache(key: number | string, options?: EntityActionOptions): void;\n\n  /**\n   * Remove multiple entities directly from the cache.\n   * Does not delete these entities from remote storage.\n   * @param entity The entities to remove\n   * @param [options] options such as mergeStrategy\n   */\n  removeManyFromCache(entities: T[], options?: EntityActionOptions): void;\n\n  /**\n   * Remove multiple entities directly from the cache.\n   * Does not delete these entities from remote storage.\n   * @param keys The primary keys of the entities to remove\n   * @param [options] options such as mergeStrategy\n   */\n  removeManyFromCache(\n    keys: (number | string)[],\n    options?: EntityActionOptions\n  ): void;\n\n  /**\n   * Update a cached entity directly.\n   * Does not update that entity in remote storage.\n   * Ignored if an entity with matching primary key is not in cache.\n   * The update entity may be partial (but must have its key)\n   * in which case it patches the existing entity.\n   * @param entity to update directly in cache.\n   * @param [options] options such as mergeStrategy\n   */\n  updateOneInCache(entity: Partial<T>, options?: EntityActionOptions): void;\n\n  /**\n   * Update multiple cached entities directly.\n   * Does not update these entities in remote storage.\n   * Entities whose primary keys are not in cache are ignored.\n   * Update entities may be partial but must at least have their keys.\n   * such partial entities patch their cached counterparts.\n   * @param entities to update directly in cache.\n   * @param [options] options such as mergeStrategy\n   */\n  updateManyInCache(\n    entities: Partial<T>[],\n    options?: EntityActionOptions\n  ): void;\n\n  /**\n   * Insert or update a cached entity directly.\n   * Does not save to remote storage.\n   * Upsert entity might be a partial of T but must at least have its key.\n   * Pass the Update<T> structure as the payload.\n   * @param entity to upsert directly in cache.\n   * @param [options] options such as mergeStrategy\n   */\n  upsertOneInCache(entity: Partial<T>, options?: EntityActionOptions): void;\n\n  /**\n   * Insert or update multiple cached entities directly.\n   * Does not save to remote storage.\n   * Upsert entities might be partial but must at least have their keys.\n   * Pass an array of the Update<T> structure as the payload.\n   * @param entities to upsert directly in cache.\n   * @param [options] options such as mergeStrategy\n   */\n  upsertManyInCache(\n    entities: Partial<T>[],\n    options?: EntityActionOptions\n  ): void;\n\n  /**\n   * Set the pattern that the collection's filter applies\n   * when using the `filteredEntities` selector.\n   */\n  setFilter(pattern: any, options?: EntityActionOptions): void;\n\n  /** Set the loaded flag */\n  setLoaded(isLoaded: boolean, options?: EntityActionOptions): void;\n\n  /** Set the loading flag */\n  setLoading(isLoading: boolean, options?: EntityActionOptions): void;\n}\n\n/** Commands that dispatch entity actions for a collection */\nexport interface EntityCommands<T>\n  extends EntityServerCommands<T>,\n    EntityCacheCommands<T> {}\n"]}

package/esm2022/src/dispatchers/entity-dispatcher-default-options.mjs

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Default options for EntityDispatcher behavior
+ * such as whether `add()` is optimistic or pessimistic by default.
+ * An optimistic save modifies the collection immediately and before saving to the server.
+ * A pessimistic save modifies the collection after the server confirms the save was successful.
+ * This class initializes the defaults to the safest values.
+ * Provide an alternative to change the defaults for all entity collections.
+ */
+class EntityDispatcherDefaultOptions {
+    constructor() {
+        /** True if added entities are saved optimistically; false if saved pessimistically. */
+        this.optimisticAdd = false;
+        /** True if deleted entities are saved optimistically; false if saved pessimistically. */
+        this.optimisticDelete = true;
+        /** True if updated entities are saved optimistically; false if saved pessimistically. */
+        this.optimisticUpdate = false;
+        /** True if upsert entities are saved optimistically; false if saved pessimistically. */
+        this.optimisticUpsert = false;
+        /** True if entities in a cache saveEntities request are saved optimistically; false if saved pessimistically. */
+        this.optimisticSaveEntities = false;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityDispatcherDefaultOptions, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityDispatcherDefaultOptions }); }
+}
+export { EntityDispatcherDefaultOptions };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityDispatcherDefaultOptions, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/dispatchers/entity-dispatcher-factory.mjs

@@ -0,0 +1,68 @@
+import { Inject, Injectable } from '@angular/core';
+import { ScannedActionsSubject } from '@ngrx/store';
+import { shareReplay } from 'rxjs/operators';
+import { defaultSelectId } from '../utils/utilities';
+import { ENTITY_CACHE_SELECTOR_TOKEN, } from '../selectors/entity-cache-selector';
+import { EntityDispatcherBase } from './entity-dispatcher-base';
+import * as i0 from "@angular/core";
+import * as i1 from "../actions/entity-action-factory";
+import * as i2 from "@ngrx/store";
+import * as i3 from "./entity-dispatcher-default-options";
+import * as i4 from "../utils/correlation-id-generator";
+import * as i5 from "rxjs";
+/** Creates EntityDispatchers for entity collections */
+class EntityDispatcherFactory {
+    constructor(entityActionFactory, store, entityDispatcherDefaultOptions, scannedActions$, entityCacheSelector, correlationIdGenerator) {
+        this.entityActionFactory = entityActionFactory;
+        this.store = store;
+        this.entityDispatcherDefaultOptions = entityDispatcherDefaultOptions;
+        this.entityCacheSelector = entityCacheSelector;
+        this.correlationIdGenerator = correlationIdGenerator;
+        // Replay because sometimes in tests will fake data service with synchronous observable
+        // which makes subscriber miss the dispatched actions.
+        // Of course that's a testing mistake. But easy to forget, leading to painful debugging.
+        this.reducedActions$ = scannedActions$.pipe(shareReplay(1));
+        // Start listening so late subscriber won't miss the most recent action.
+        this.raSubscription = this.reducedActions$.subscribe();
+    }
+    /**
+     * Create an `EntityDispatcher` for an entity type `T` and store.
+     */
+    create(
+    /** Name of the entity type */
+    entityName, 
+    /**
+     * Function that returns the primary key for an entity `T`.
+     * Usually acquired from `EntityDefinition` metadata.
+     * @param {IdSelector<T>} selectId
+     */
+    selectId = defaultSelectId, 
+    /** Defaults for options that influence dispatcher behavior such as whether
+     * `add()` is optimistic or pessimistic;
+     * @param {Partial<EntityDispatcherDefaultOptions>} defaultOptions
+     */
+    defaultOptions = {}) {
+        // merge w/ defaultOptions with injected defaults
+        const options = {
+            ...this.entityDispatcherDefaultOptions,
+            ...defaultOptions,
+        };
+        return new EntityDispatcherBase(entityName, this.entityActionFactory, this.store, selectId, options, this.reducedActions$, this.entityCacheSelector, this.correlationIdGenerator);
+    }
+    ngOnDestroy() {
+        this.raSubscription.unsubscribe();
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityDispatcherFactory, deps: [{ token: i1.EntityActionFactory }, { token: i2.Store }, { token: i3.EntityDispatcherDefaultOptions }, { token: ScannedActionsSubject }, { token: ENTITY_CACHE_SELECTOR_TOKEN }, { token: i4.CorrelationIdGenerator }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityDispatcherFactory }); }
+}
+export { EntityDispatcherFactory };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EntityDispatcherFactory, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.EntityActionFactory }, { type: i2.Store }, { type: i3.EntityDispatcherDefaultOptions }, { type: i5.Observable, decorators: [{
+                    type: Inject,
+                    args: [ScannedActionsSubject]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ENTITY_CACHE_SELECTOR_TOKEN]
+                }] }, { type: i4.CorrelationIdGenerator }]; } });
+//# sourceMappingURL=data:application/json;base64,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