| 1 | {"version":3,"file":"ngrx-effects.mjs","sources":["../../../../modules/effects/src/models.ts","../../../../modules/effects/src/effect_creator.ts","../../../../modules/effects/src/utils.ts","../../../../modules/effects/src/effect_decorator.ts","../../../../modules/effects/src/effects_metadata.ts","../../../../modules/effects/src/effects_resolver.ts","../../../../modules/effects/src/effects_error_handler.ts","../../../../modules/effects/src/actions.ts","../../../../modules/effects/src/effect_notification.ts","../../../../modules/effects/src/lifecycle_hooks.ts","../../../../modules/effects/src/tokens.ts","../../../../modules/effects/src/effect_sources.ts","../../../../modules/effects/src/effects_runner.ts","../../../../modules/effects/src/effects_root_module.ts","../../../../modules/effects/src/effects_feature_module.ts","../../../../modules/effects/src/effects_module.ts","../../../../modules/effects/src/act.ts","../../../../modules/effects/src/concat_latest_from.ts","../../../../modules/effects/index.ts","../../../../modules/effects/ngrx-effects.ts"],"sourcesContent":["/**\n * Configures an effect created by `createEffect`.\n */\nexport interface EffectConfig {\n /**\n * Determines if the action emitted by the effect is dispatched to the store.\n * If false, effect does not need to return type `Observable<Action>`.\n */\n dispatch?: boolean;\n /**\n * Determines if the effect will be resubscribed to if an error occurs in the main actions stream.\n */\n useEffectsErrorHandler?: boolean;\n}\n\nexport const DEFAULT_EFFECT_CONFIG: Readonly<Required<EffectConfig>> = {\n dispatch: true,\n useEffectsErrorHandler: true,\n};\n\nexport const CREATE_EFFECT_METADATA_KEY = '__@ngrx/effects_create__';\n\nexport interface CreateEffectMetadata {\n [CREATE_EFFECT_METADATA_KEY]: EffectConfig;\n}\n\nexport type EffectPropertyKey<T extends Object> = Exclude<\n keyof T,\n keyof Object\n>;\n\nexport interface EffectMetadata<T extends Object>\n extends Required<EffectConfig> {\n propertyName: EffectPropertyKey<T>;\n}\n\nexport type EffectsMetadata<T> = {\n [key in EffectPropertyKey<T>]?: EffectConfig;\n};\n","import { Observable } from 'rxjs';\nimport { Action, ActionCreator } from '@ngrx/store';\nimport {\n EffectMetadata,\n EffectConfig,\n DEFAULT_EFFECT_CONFIG,\n CreateEffectMetadata,\n CREATE_EFFECT_METADATA_KEY,\n} from './models';\n\ntype DispatchType<T> = T extends { dispatch: infer U } ? U : true;\ntype ObservableType<T, OriginalType> = T extends false ? OriginalType : Action;\ntype EffectResult<OT> = Observable<OT> | ((...args: any[]) => Observable<OT>);\ntype ConditionallyDisallowActionCreator<DT, Result> = DT extends false\n ? unknown // If DT (DispatchType is false, then we don't enforce any return types)\n : Result extends EffectResult<infer OT>\n ? OT extends ActionCreator\n ? 'ActionCreator cannot be dispatched. Did you forget to call the action creator function?'\n : unknown\n : unknown;\n\n/**\n * @description\n * Creates an effect from an `Observable` and an `EffectConfig`.\n *\n * @param source A function which returns an `Observable`.\n * @param config A `Partial<EffectConfig>` to configure the effect. By default, `dispatch` is true and `useEffectsErrorHandler` is true.\n * @returns If `EffectConfig`#`dispatch` is true, returns `Observable<Action>`. Else, returns `Observable<unknown>`.\n *\n * @usageNotes\n *\n * ** Mapping to a different action **\n * ```ts\n * effectName$ = createEffect(\n * () => this.actions$.pipe(\n * ofType(FeatureActions.actionOne),\n * map(() => FeatureActions.actionTwo())\n * )\n * );\n * ```\n *\n * ** Non-dispatching effects **\n * ```ts\n * effectName$ = createEffect(\n * () => this.actions$.pipe(\n * ofType(FeatureActions.actionOne),\n * tap(() => console.log('Action One Dispatched'))\n * ),\n * { dispatch: false }\n * // FeatureActions.actionOne is not dispatched\n * );\n * ```\n */\nexport function createEffect<\n C extends EffectConfig,\n DT extends DispatchType<C>,\n OT extends ObservableType<DT, OT>,\n R extends EffectResult<OT>\n>(\n source: () => R & ConditionallyDisallowActionCreator<DT, R>,\n config?: Partial<C>\n): R & CreateEffectMetadata {\n const effect = source();\n const value: EffectConfig = {\n ...DEFAULT_EFFECT_CONFIG,\n ...config, // Overrides any defaults if values are provided\n };\n Object.defineProperty(effect, CREATE_EFFECT_METADATA_KEY, {\n value,\n });\n return effect as typeof effect & CreateEffectMetadata;\n}\n\nexport function getCreateEffectMetadata<\n T extends { [props in keyof T]: Object }\n>(instance: T): EffectMetadata<T>[] {\n const propertyNames = Object.getOwnPropertyNames(instance) as Array<keyof T>;\n\n const metadata: EffectMetadata<T>[] = propertyNames\n .filter((propertyName) => {\n if (\n instance[propertyName] &&\n instance[propertyName].hasOwnProperty(CREATE_EFFECT_METADATA_KEY)\n ) {\n // If the property type has overridden `hasOwnProperty` we need to ensure\n // that the metadata is valid (containing a `dispatch`property)\n // https://github.com/ngrx/platform/issues/2975\n const property = instance[propertyName] as any;\n return property[CREATE_EFFECT_METADATA_KEY].hasOwnProperty('dispatch');\n }\n return false;\n })\n .map((propertyName) => {\n const metaData = (instance[propertyName] as any)[\n CREATE_EFFECT_METADATA_KEY\n ];\n return {\n propertyName,\n ...metaData,\n };\n });\n\n return metadata;\n}\n","export function getSourceForInstance<T>(instance: T): T {\n return Object.getPrototypeOf(instance);\n}\n","import { compose } from '@ngrx/store';\n\nimport {\n DEFAULT_EFFECT_CONFIG,\n EffectConfig,\n EffectMetadata,\n EffectPropertyKey,\n} from './models';\nimport { getSourceForInstance } from './utils';\n\nconst METADATA_KEY = '__@ngrx/effects__';\n\n/**\n * @deprecated The Effect decorator (`@Effect`) is deprecated in favor for the `createEffect` method.\n * See the docs for more info {@link https://ngrx.io/guide/migration/v11#the-effect-decorator}\n */\nexport function Effect(config: EffectConfig = {}) {\n return function <T extends Object, K extends EffectPropertyKey<T>>(\n target: T,\n propertyName: K\n ) {\n const metadata: EffectMetadata<T> = {\n ...DEFAULT_EFFECT_CONFIG,\n ...config, // Overrides any defaults if values are provided\n propertyName,\n };\n addEffectMetadataEntry<T>(target, metadata);\n };\n}\n\nexport function getEffectDecoratorMetadata<T>(\n instance: T\n): EffectMetadata<T>[] {\n const effectsDecorators: EffectMetadata<T>[] = compose(\n getEffectMetadataEntries,\n getSourceForInstance\n )(instance);\n\n return effectsDecorators;\n}\n\n/**\n * Type guard to detemine whether METADATA_KEY is already present on the Class\n * constructor\n */\nfunction hasMetadataEntries<T extends Object>(\n sourceProto: T\n): sourceProto is typeof sourceProto & {\n constructor: typeof sourceProto.constructor & {\n [METADATA_KEY]: EffectMetadata<T>[];\n };\n} {\n return sourceProto.constructor.hasOwnProperty(METADATA_KEY);\n}\n\n/** Add Effect Metadata to the Effect Class constructor under specific key */\nfunction addEffectMetadataEntry<T extends object>(\n sourceProto: T,\n metadata: EffectMetadata<T>\n) {\n if (hasMetadataEntries(sourceProto)) {\n sourceProto.constructor[METADATA_KEY].push(metadata);\n } else {\n Object.defineProperty(sourceProto.constructor, METADATA_KEY, {\n value: [metadata],\n });\n }\n}\n\nfunction getEffectMetadataEntries<T extends object>(\n sourceProto: T\n): EffectMetadata<T>[] {\n return hasMetadataEntries(sourceProto)\n ? sourceProto.constructor[METADATA_KEY]\n : [];\n}\n","import { EffectMetadata, EffectsMetadata } from './models';\nimport { getCreateEffectMetadata } from './effect_creator';\nimport { getEffectDecoratorMetadata } from './effect_decorator';\n\nexport function getEffectsMetadata<T>(instance: T): EffectsMetadata<T> {\n return getSourceMetadata(instance).reduce(\n (\n acc: EffectsMetadata<T>,\n { propertyName, dispatch, useEffectsErrorHandler }\n ) => {\n acc[propertyName] = { dispatch, useEffectsErrorHandler };\n return acc;\n },\n {}\n );\n}\n\nexport function getSourceMetadata<T>(instance: T): EffectMetadata<T>[] {\n const effects: Array<(instance: T) => EffectMetadata<T>[]> = [\n getEffectDecoratorMetadata,\n getCreateEffectMetadata,\n ];\n\n return effects.reduce<EffectMetadata<T>[]>(\n (sources, source) => sources.concat(source(instance)),\n []\n );\n}\n","import { Action } from '@ngrx/store';\nimport { merge, Observable } from 'rxjs';\nimport { ignoreElements, map, materialize } from 'rxjs/operators';\n\nimport { EffectNotification } from './effect_notification';\nimport { getSourceMetadata } from './effects_metadata';\nimport { EffectsErrorHandler } from './effects_error_handler';\nimport { getSourceForInstance } from './utils';\nimport { ErrorHandler } from '@angular/core';\n\nexport function mergeEffects(\n sourceInstance: any,\n globalErrorHandler: ErrorHandler,\n effectsErrorHandler: EffectsErrorHandler\n): Observable<EffectNotification> {\n const sourceName = getSourceForInstance(sourceInstance).constructor.name;\n\n const observables$: Observable<any>[] = getSourceMetadata(sourceInstance).map(\n ({\n propertyName,\n dispatch,\n useEffectsErrorHandler,\n }): Observable<EffectNotification> => {\n const observable$: Observable<any> =\n typeof sourceInstance[propertyName] === 'function'\n ? sourceInstance[propertyName]()\n : sourceInstance[propertyName];\n\n const effectAction$ = useEffectsErrorHandler\n ? effectsErrorHandler(observable$, globalErrorHandler)\n : observable$;\n\n if (dispatch === false) {\n return effectAction$.pipe(ignoreElements());\n }\n\n const materialized$ = effectAction$.pipe(materialize<Action>());\n\n return materialized$.pipe(\n map(\n (notification): EffectNotification => ({\n effect: sourceInstance[propertyName],\n notification,\n propertyName,\n sourceName,\n sourceInstance,\n })\n )\n );\n }\n );\n\n return merge(...observables$);\n}\n","import { ErrorHandler } from '@angular/core';\nimport { Action } from '@ngrx/store';\nimport { Observable } from 'rxjs';\nimport { catchError } from 'rxjs/operators';\n\nexport type EffectsErrorHandler = <T extends Action>(\n observable$: Observable<T>,\n errorHandler: ErrorHandler\n) => Observable<T>;\n\nconst MAX_NUMBER_OF_RETRY_ATTEMPTS = 10;\n\nexport function defaultEffectsErrorHandler<T extends Action>(\n observable$: Observable<T>,\n errorHandler: ErrorHandler,\n retryAttemptLeft: number = MAX_NUMBER_OF_RETRY_ATTEMPTS\n): Observable<T> {\n return observable$.pipe(\n catchError((error) => {\n if (errorHandler) errorHandler.handleError(error);\n if (retryAttemptLeft <= 1) {\n return observable$; // last attempt\n }\n // Return observable that produces this particular effect\n return defaultEffectsErrorHandler(\n observable$,\n errorHandler,\n retryAttemptLeft - 1\n );\n })\n );\n}\n","import { Inject, Injectable } from '@angular/core';\nimport {\n Action,\n ActionCreator,\n Creator,\n ScannedActionsSubject,\n} from '@ngrx/store';\nimport { Observable, OperatorFunction, Operator } from 'rxjs';\nimport { filter } from 'rxjs/operators';\n\n@Injectable()\nexport class Actions<V = Action> extends Observable<V> {\n constructor(@Inject(ScannedActionsSubject) source?: Observable<V>) {\n super();\n\n if (source) {\n this.source = source;\n }\n }\n\n override lift<R>(operator: Operator<V, R>): Observable<R> {\n const observable = new Actions<R>();\n observable.source = this;\n observable.operator = operator;\n return observable;\n }\n}\n\n// Module-private helper type\ntype ActionExtractor<\n T extends string | AC,\n AC extends ActionCreator<string, Creator>,\n E\n> = T extends string ? E : ReturnType<Extract<T, AC>>;\n\nexport function ofType<\n AC extends ActionCreator<string, Creator>[],\n U extends Action = Action,\n V = ReturnType<AC[number]>\n>(...allowedTypes: AC): OperatorFunction<U, V>;\n\nexport function ofType<\n E extends Extract<U, { type: T1 }>,\n AC extends ActionCreator<string, Creator>,\n T1 extends string | AC,\n U extends Action = Action,\n V = T1 extends string ? E : ReturnType<Extract<T1, AC>>\n>(t1: T1): OperatorFunction<U, V>;\nexport function ofType<\n E extends Extract<U, { type: T1 | T2 }>,\n AC extends ActionCreator<string, Creator>,\n T1 extends string | AC,\n T2 extends string | AC,\n U extends Action = Action,\n V = ActionExtractor<T1 | T2, AC, E>\n>(t1: T1, t2: T2): OperatorFunction<U, V>;\nexport function ofType<\n E extends Extract<U, { type: T1 | T2 | T3 }>,\n AC extends ActionCreator<string, Creator>,\n T1 extends string | AC,\n T2 extends string | AC,\n T3 extends string | AC,\n U extends Action = Action,\n V = ActionExtractor<T1 | T2 | T3, AC, E>\n>(t1: T1, t2: T2, t3: T3): OperatorFunction<U, V>;\nexport function ofType<\n E extends Extract<U, { type: T1 | T2 | T3 | T4 }>,\n AC extends ActionCreator<string, Creator>,\n T1 extends string | AC,\n T2 extends string | AC,\n T3 extends string | AC,\n T4 extends string | AC,\n U extends Action = Action,\n V = ActionExtractor<T1 | T2 | T3 | T4, AC, E>\n>(t1: T1, t2: T2, t3: T3, t4: T4): OperatorFunction<U, V>;\nexport function ofType<\n E extends Extract<U, { type: T1 | T2 | T3 | T4 | T5 }>,\n AC extends ActionCreator<string, Creator>,\n T1 extends string | AC,\n T2 extends string | AC,\n T3 extends string | AC,\n T4 extends string | AC,\n T5 extends string | AC,\n U extends Action = Action,\n V = ActionExtractor<T1 | T2 | T3 | T4 | T5, AC, E>\n>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): OperatorFunction<U, V>;\n/**\n * Fallback for more than 5 arguments.\n * There is no inference, so the return type is the same as the input -\n * Observable<Action>.\n *\n * We provide a type parameter, even though TS will not infer it from the\n * arguments, to preserve backwards compatibility with old versions of ngrx.\n */\nexport function ofType<V extends Action>(\n ...allowedTypes: Array<string | ActionCreator<string, Creator>>\n): OperatorFunction<Action, V>;\n/**\n * `ofType` filters an Observable of `Actions` into an Observable of the actions\n * whose type strings are passed to it.\n *\n * For example, if `actions` has type `Actions<AdditionAction|SubstractionAction>`, and\n * the type of the `Addition` action is `add`, then\n * `actions.pipe(ofType('add'))` returns an `Observable<AdditionAction>`.\n *\n * Properly typing this function is hard and requires some advanced TS tricks\n * below.\n *\n * Type narrowing automatically works, as long as your `actions` object\n * starts with a `Actions<SomeUnionOfActions>` instead of generic `Actions`.\n *\n * For backwards compatibility, when one passes a single type argument\n * `ofType<T>('something')` the result is an `Observable<T>`. Note, that `T`\n * completely overrides any possible inference from 'something'.\n *\n * Unfortunately, for unknown 'actions: Actions' these types will produce\n * 'Observable<never>'. In such cases one has to manually set the generic type\n * like `actions.ofType<AdditionAction>('add')`.\n *\n * @usageNotes\n *\n * Filter the Actions stream on the \"customers page loaded\" action\n *\n * ```ts\n * import { ofType } from '@ngrx/effects';\n * import * fromCustomers from '../customers';\n *\n * this.actions$.pipe(\n * ofType(fromCustomers.pageLoaded)\n * )\n * ```\n */\nexport function ofType(\n ...allowedTypes: Array<string | ActionCreator<string, Creator>>\n): OperatorFunction<Action, Action> {\n return filter((action: Action) =>\n allowedTypes.some((typeOrActionCreator) => {\n if (typeof typeOrActionCreator === 'string') {\n // Comparing the string to type\n return typeOrActionCreator === action.type;\n }\n\n // We are filtering by ActionCreator\n return typeOrActionCreator.type === action.type;\n })\n );\n}\n","import { ErrorHandler } from '@angular/core';\nimport { Action } from '@ngrx/store';\nimport { Notification, Observable } from 'rxjs';\n\nexport interface EffectNotification {\n effect: Observable<any> | (() => Observable<any>);\n propertyName: PropertyKey;\n sourceName: string;\n sourceInstance: any;\n notification: Notification<Action | null | undefined>;\n}\n\nexport function reportInvalidActions(\n output: EffectNotification,\n reporter: ErrorHandler\n) {\n if (output.notification.kind === 'N') {\n const action = output.notification.value;\n const isInvalidAction = !isAction(action);\n\n if (isInvalidAction) {\n reporter.handleError(\n new Error(\n `Effect ${getEffectName(\n output\n )} dispatched an invalid action: ${stringify(action)}`\n )\n );\n }\n }\n}\n\nfunction isAction(action: any): action is Action {\n return (\n typeof action !== 'function' &&\n action &&\n action.type &&\n typeof action.type === 'string'\n );\n}\n\nfunction getEffectName({\n propertyName,\n sourceInstance,\n sourceName,\n}: EffectNotification) {\n const isMethod = typeof sourceInstance[propertyName] === 'function';\n\n return `\"${sourceName}.${String(propertyName)}${isMethod ? '()' : ''}\"`;\n}\n\nfunction stringify(action: Action | null | undefined) {\n try {\n return JSON.stringify(action);\n } catch {\n return action;\n }\n}\n","import { Observable } from 'rxjs';\nimport { EffectNotification } from '.';\nimport { Action } from '@ngrx/store';\n\n/**\n * @description\n * Interface to set an identifier for effect instances.\n *\n * By default, each Effects class is registered\n * once regardless of how many times the Effect class\n * is loaded. By implementing this interface, you define\n * a unique identifier to register an Effects class instance\n * multiple times.\n *\n * @usageNotes\n *\n * ### Set an identifier for an Effects class\n *\n * ```ts\n * class EffectWithIdentifier implements OnIdentifyEffects {\n * constructor(private effectIdentifier: string) {}\n *\n * ngrxOnIdentifyEffects() {\n * return this.effectIdentifier;\n * }\n *\n * ```\n */\nexport declare interface OnIdentifyEffects {\n /**\n * @description\n * String identifier to differentiate effect instances.\n */\n ngrxOnIdentifyEffects(): string;\n}\n\nexport const onIdentifyEffectsKey: keyof OnIdentifyEffects =\n 'ngrxOnIdentifyEffects';\n\nexport function isOnIdentifyEffects(\n instance: any\n): instance is OnIdentifyEffects {\n return isFunction(instance, onIdentifyEffectsKey);\n}\n\n/**\n * @description\n * Interface to control the lifecycle of effects.\n *\n * By default, effects are merged and subscribed to the store. Implement the OnRunEffects interface to control the lifecycle of the resolved effects.\n *\n * @usageNotes\n *\n * ### Implement the OnRunEffects interface on an Effects class\n *\n * ```ts\n * export class UserEffects implements OnRunEffects {\n * constructor(private actions$: Actions) {}\n *\n * ngrxOnRunEffects(resolvedEffects$: Observable<EffectNotification>) {\n * return this.actions$.pipe(\n * ofType('LOGGED_IN'),\n * exhaustMap(() =>\n * resolvedEffects$.pipe(\n * takeUntil(this.actions$.pipe(ofType('LOGGED_OUT')))\n * )\n * )\n * );\n * }\n * }\n * ```\n */\nexport declare interface OnRunEffects {\n /**\n * @description\n * Method to control the lifecycle of effects.\n */\n ngrxOnRunEffects(\n resolvedEffects$: Observable<EffectNotification>\n ): Observable<EffectNotification>;\n}\n\nexport const onRunEffectsKey: keyof OnRunEffects = 'ngrxOnRunEffects';\n\nexport function isOnRunEffects(instance: any): instance is OnRunEffects {\n return isFunction(instance, onRunEffectsKey);\n}\n\n/**\n * @description\n * Interface to dispatch an action after effect registration.\n *\n * Implement this interface to dispatch a custom action after\n * the effect has been added. You can listen to this action\n * in the rest of the application to execute something after\n * the effect is registered.\n *\n * @usageNotes\n *\n * ### Set an identifier for an Effects class\n *\n * ```ts\n * class EffectWithInitAction implements OnInitEffects {\n * ngrxOnInitEffects() {\n * return { type: '[EffectWithInitAction] Init' };\n * }\n * ```\n */\nexport declare interface OnInitEffects {\n /**\n * @description\n * Action to be dispatched after the effect is registered.\n */\n ngrxOnInitEffects(): Action;\n}\n\nexport const onInitEffects: keyof OnInitEffects = 'ngrxOnInitEffects';\n\nexport function isOnInitEffects(instance: any): instance is OnInitEffects {\n return isFunction(instance, onInitEffects);\n}\n\nfunction isFunction(instance: any, functionName: string) {\n return (\n instance &&\n functionName in instance &&\n typeof instance[functionName] === 'function'\n );\n}\n","import { InjectionToken, Type } from '@angular/core';\nimport { EffectsErrorHandler } from './effects_error_handler';\n\nexport const _ROOT_EFFECTS_GUARD = new InjectionToken<void>(\n '@ngrx/effects Internal Root Guard'\n);\nexport const USER_PROVIDED_EFFECTS = new InjectionToken<Type<any>[][]>(\n '@ngrx/effects User Provided Effects'\n);\nexport const _ROOT_EFFECTS = new InjectionToken<Type<any>[]>(\n '@ngrx/effects Internal Root Effects'\n);\nexport const ROOT_EFFECTS = new InjectionToken<Type<any>[]>(\n '@ngrx/effects Root Effects'\n);\nexport const _FEATURE_EFFECTS = new InjectionToken<Type<any>[]>(\n '@ngrx/effects Internal Feature Effects'\n);\nexport const FEATURE_EFFECTS = new InjectionToken<any[][]>(\n '@ngrx/effects Feature Effects'\n);\nexport const EFFECTS_ERROR_HANDLER = new InjectionToken<EffectsErrorHandler>(\n '@ngrx/effects Effects Error Handler'\n);\n","import { ErrorHandler, Inject, Injectable } from '@angular/core';\nimport { Action } from '@ngrx/store';\nimport { Notification, Observable, Subject, merge } from 'rxjs';\nimport {\n dematerialize,\n exhaustMap,\n filter,\n groupBy,\n map,\n mergeMap,\n take,\n} from 'rxjs/operators';\n\nimport {\n reportInvalidActions,\n EffectNotification,\n} from './effect_notification';\nimport { EffectsErrorHandler } from './effects_error_handler';\nimport { mergeEffects } from './effects_resolver';\nimport {\n onIdentifyEffectsKey,\n onRunEffectsKey,\n OnRunEffects,\n onInitEffects,\n isOnIdentifyEffects,\n isOnRunEffects,\n isOnInitEffects,\n} from './lifecycle_hooks';\nimport { EFFECTS_ERROR_HANDLER } from './tokens';\nimport { getSourceForInstance } from './utils';\n\n@Injectable()\nexport class EffectSources extends Subject<any> {\n constructor(\n private errorHandler: ErrorHandler,\n @Inject(EFFECTS_ERROR_HANDLER)\n private effectsErrorHandler: EffectsErrorHandler\n ) {\n super();\n }\n\n addEffects(effectSourceInstance: any): void {\n this.next(effectSourceInstance);\n }\n\n /**\n * @internal\n */\n toActions(): Observable<Action> {\n return this.pipe(\n groupBy(getSourceForInstance),\n mergeMap((source$) => {\n return source$.pipe(groupBy(effectsInstance));\n }),\n mergeMap((source$) => {\n const effect$ = source$.pipe(\n exhaustMap((sourceInstance) => {\n return resolveEffectSource(\n this.errorHandler,\n this.effectsErrorHandler\n )(sourceInstance);\n }),\n map((output) => {\n reportInvalidActions(output, this.errorHandler);\n return output.notification;\n }),\n filter(\n (\n notification\n ): notification is Notification<Action> & {\n kind: 'N';\n value: Action;\n } => notification.kind === 'N' && notification.value != null\n ),\n dematerialize()\n );\n\n // start the stream with an INIT action\n // do this only for the first Effect instance\n const init$ = source$.pipe(\n take(1),\n filter(isOnInitEffects),\n map((instance) => instance.ngrxOnInitEffects())\n );\n\n return merge(effect$, init$);\n })\n );\n }\n}\n\nfunction effectsInstance(sourceInstance: any) {\n if (isOnIdentifyEffects(sourceInstance)) {\n return sourceInstance.ngrxOnIdentifyEffects();\n }\n\n return '';\n}\n\nfunction resolveEffectSource(\n errorHandler: ErrorHandler,\n effectsErrorHandler: EffectsErrorHandler\n): (sourceInstance: any) => Observable<EffectNotification> {\n return (sourceInstance) => {\n const mergedEffects$ = mergeEffects(\n sourceInstance,\n errorHandler,\n effectsErrorHandler\n );\n\n if (isOnRunEffects(sourceInstance)) {\n return sourceInstance.ngrxOnRunEffects(mergedEffects$);\n }\n\n return mergedEffects$;\n };\n}\n","import { Injectable, OnDestroy } from '@angular/core';\nimport { Store } from '@ngrx/store';\nimport { Subscription } from 'rxjs';\n\nimport { EffectSources } from './effect_sources';\n\n@Injectable()\nexport class EffectsRunner implements OnDestroy {\n private effectsSubscription: Subscription | null = null;\n\n constructor(\n private effectSources: EffectSources,\n private store: Store<any>\n ) {}\n\n start() {\n if (!this.effectsSubscription) {\n this.effectsSubscription = this.effectSources\n .toActions()\n .subscribe(this.store);\n }\n }\n\n ngOnDestroy() {\n if (this.effectsSubscription) {\n this.effectsSubscription.unsubscribe();\n this.effectsSubscription = null;\n }\n }\n}\n","import { NgModule, Inject, Optional } from '@angular/core';\nimport {\n createAction,\n StoreModule,\n Store,\n StoreRootModule,\n StoreFeatureModule,\n} from '@ngrx/store';\nimport { EffectsRunner } from './effects_runner';\nimport { EffectSources } from './effect_sources';\nimport { ROOT_EFFECTS, _ROOT_EFFECTS_GUARD } from './tokens';\n\nexport const ROOT_EFFECTS_INIT = '@ngrx/effects/init';\nexport const rootEffectsInit = createAction(ROOT_EFFECTS_INIT);\n\n@NgModule({})\nexport class EffectsRootModule {\n constructor(\n private sources: EffectSources,\n runner: EffectsRunner,\n store: Store<any>,\n @Inject(ROOT_EFFECTS) rootEffects: any[],\n @Optional() storeRootModule: StoreRootModule,\n @Optional() storeFeatureModule: StoreFeatureModule,\n @Optional()\n @Inject(_ROOT_EFFECTS_GUARD)\n guard: any\n ) {\n runner.start();\n\n rootEffects.forEach((effectSourceInstance) =>\n sources.addEffects(effectSourceInstance)\n );\n\n store.dispatch({ type: ROOT_EFFECTS_INIT });\n }\n\n addEffects(effectSourceInstance: any) {\n this.sources.addEffects(effectSourceInstance);\n }\n}\n","import { NgModule, Inject, Optional } from '@angular/core';\nimport { StoreRootModule, StoreFeatureModule } from '@ngrx/store';\nimport { EffectsRootModule } from './effects_root_module';\nimport { FEATURE_EFFECTS } from './tokens';\n\n@NgModule({})\nexport class EffectsFeatureModule {\n constructor(\n root: EffectsRootModule,\n @Inject(FEATURE_EFFECTS) effectSourceGroups: any[][],\n @Optional() storeRootModule: StoreRootModule,\n @Optional() storeFeatureModule: StoreFeatureModule\n ) {\n effectSourceGroups.forEach((group) =>\n group.forEach((effectSourceInstance) =>\n root.addEffects(effectSourceInstance)\n )\n );\n }\n}\n","import {\n Injector,\n ModuleWithProviders,\n NgModule,\n Optional,\n Self,\n SkipSelf,\n Type,\n} from '@angular/core';\nimport { Actions } from './actions';\nimport { EffectSources } from './effect_sources';\nimport { EffectsFeatureModule } from './effects_feature_module';\nimport { defaultEffectsErrorHandler } from './effects_error_handler';\nimport { EffectsRootModule } from './effects_root_module';\nimport { EffectsRunner } from './effects_runner';\nimport {\n _FEATURE_EFFECTS,\n _ROOT_EFFECTS,\n _ROOT_EFFECTS_GUARD,\n EFFECTS_ERROR_HANDLER,\n FEATURE_EFFECTS,\n ROOT_EFFECTS,\n USER_PROVIDED_EFFECTS,\n} from './tokens';\n\n@NgModule({})\nexport class EffectsModule {\n static forFeature(\n featureEffects: Type<any>[] = []\n ): ModuleWithProviders<EffectsFeatureModule> {\n return {\n ngModule: EffectsFeatureModule,\n providers: [\n featureEffects,\n {\n provide: _FEATURE_EFFECTS,\n multi: true,\n useValue: featureEffects,\n },\n {\n provide: USER_PROVIDED_EFFECTS,\n multi: true,\n useValue: [],\n },\n {\n provide: FEATURE_EFFECTS,\n multi: true,\n useFactory: createEffects,\n deps: [Injector, _FEATURE_EFFECTS, USER_PROVIDED_EFFECTS],\n },\n ],\n };\n }\n\n static forRoot(\n rootEffects: Type<any>[] = []\n ): ModuleWithProviders<EffectsRootModule> {\n return {\n ngModule: EffectsRootModule,\n providers: [\n {\n provide: EFFECTS_ERROR_HANDLER,\n useValue: defaultEffectsErrorHandler,\n },\n EffectsRunner,\n EffectSources,\n Actions,\n rootEffects,\n {\n provide: _ROOT_EFFECTS,\n useValue: [rootEffects],\n },\n {\n provide: _ROOT_EFFECTS_GUARD,\n useFactory: _provideForRootGuard,\n deps: [\n [EffectsRunner, new Optional(), new SkipSelf()],\n [_ROOT_EFFECTS, new Self()],\n ],\n },\n {\n provide: USER_PROVIDED_EFFECTS,\n multi: true,\n useValue: [],\n },\n {\n provide: ROOT_EFFECTS,\n useFactory: createEffects,\n deps: [Injector, _ROOT_EFFECTS, USER_PROVIDED_EFFECTS],\n },\n ],\n };\n }\n}\n\nexport function createEffects(\n injector: Injector,\n effectGroups: Type<any>[][],\n userProvidedEffectGroups: Type<any>[][]\n): any[] {\n const mergedEffects: Type<any>[] = [];\n\n for (const effectGroup of effectGroups) {\n mergedEffects.push(...effectGroup);\n }\n\n for (const userProvidedEffectGroup of userProvidedEffectGroups) {\n mergedEffects.push(...userProvidedEffectGroup);\n }\n\n return createEffectInstances(injector, mergedEffects);\n}\n\nexport function createEffectInstances(\n injector: Injector,\n effects: Type<any>[]\n): any[] {\n return effects.map((effect) => injector.get(effect));\n}\n\nexport function _provideForRootGuard(\n runner: EffectsRunner,\n rootEffects: any[][]\n): any {\n // check whether any effects are actually passed\n const hasEffects = !(rootEffects.length === 1 && rootEffects[0].length === 0);\n if (hasEffects && runner) {\n throw new TypeError(\n `EffectsModule.forRoot() called twice. Feature modules should use EffectsModule.forFeature() instead.`\n );\n }\n return 'guarded';\n}\n","import { Action } from '@ngrx/store';\nimport {\n defer,\n merge,\n Notification,\n Observable,\n OperatorFunction,\n Subject,\n} from 'rxjs';\nimport {\n concatMap,\n dematerialize,\n filter,\n finalize,\n map,\n materialize,\n} from 'rxjs/operators';\n\n/** Represents config with named parameters for act */\nexport interface ActConfig<\n Input,\n OutputAction extends Action,\n ErrorAction extends Action,\n CompleteAction extends Action,\n UnsubscribeAction extends Action\n> {\n // Project function that produces the output actions in success cases\n project: (input: Input, index: number) => Observable<OutputAction>;\n // Error handle function for project\n // error that happened during project execution\n // input value that project errored with\n error: (error: any, input: Input) => ErrorAction;\n // Optional complete action provider\n // count is the number of actions project emitted before completion\n // input value that project completed with\n complete?: (count: number, input: Input) => CompleteAction;\n // Optional flattening operator\n operator?: <Input, OutputAction>(\n project: (input: Input, index: number) => Observable<OutputAction>\n ) => OperatorFunction<Input, OutputAction>;\n // Optional unsubscribe action provider\n // count is the number of actions project emitted before unsubscribing\n // input value that was unsubscribed from\n unsubscribe?: (count: number, input: Input) => UnsubscribeAction;\n}\n\nexport function act<\n Input,\n OutputAction extends Action,\n ErrorAction extends Action\n>(\n project: (input: Input, index: number) => Observable<OutputAction>,\n error: (error: any, input: Input) => ErrorAction\n): (source: Observable<Input>) => Observable<OutputAction | ErrorAction>;\nexport function act<\n Input,\n OutputAction extends Action,\n ErrorAction extends Action,\n CompleteAction extends Action = never,\n UnsubscribeAction extends Action = never\n>(\n config: ActConfig<\n Input,\n OutputAction,\n ErrorAction,\n CompleteAction,\n UnsubscribeAction\n >\n): (\n source: Observable<Input>\n) => Observable<\n OutputAction | ErrorAction | CompleteAction | UnsubscribeAction\n>;\n/**\n * Wraps project fn with error handling making it safe to use in Effects.\n * Takes either a config with named properties that represent different possible\n * callbacks or project/error callbacks that are required.\n */\nexport function act<\n Input,\n OutputAction extends Action,\n ErrorAction extends Action,\n CompleteAction extends Action = never,\n UnsubscribeAction extends Action = never\n>(\n /** Allow to take either config object or project/error functions */\n configOrProject:\n | ActConfig<\n Input,\n OutputAction,\n ErrorAction,\n CompleteAction,\n UnsubscribeAction\n >\n | ((input: Input, index: number) => Observable<OutputAction>),\n errorFn?: (error: any, input: Input) => ErrorAction\n): (\n source: Observable<Input>\n) => Observable<\n OutputAction | ErrorAction | CompleteAction | UnsubscribeAction\n> {\n const { project, error, complete, operator, unsubscribe } =\n typeof configOrProject === 'function'\n ? {\n project: configOrProject,\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n error: errorFn!,\n operator: concatMap,\n complete: undefined,\n unsubscribe: undefined,\n }\n : { ...configOrProject, operator: configOrProject.operator || concatMap };\n\n type ResultAction =\n | OutputAction\n | ErrorAction\n | CompleteAction\n | UnsubscribeAction;\n return (source) =>\n defer(\n (): Observable<ResultAction> => {\n const subject = new Subject<UnsubscribeAction>();\n return merge(\n source.pipe(\n operator((input, index) =>\n defer(() => {\n let completed = false;\n let errored = false;\n let projectedCount = 0;\n return project(input, index).pipe(\n materialize(),\n map((notification):\n | (Notification<\n ErrorAction | CompleteAction | OutputAction\n > & {\n kind: 'N';\n value: ErrorAction | CompleteAction | OutputAction;\n })\n | undefined => {\n switch (notification.kind) {\n case 'E':\n errored = true;\n return new Notification(\n 'N',\n error(notification.error, input)\n ) as Notification<ErrorAction> & {\n kind: 'N';\n value: ErrorAction;\n };\n case 'C':\n completed = true;\n return complete\n ? (new Notification(\n 'N',\n complete(projectedCount, input)\n ) as Notification<CompleteAction> & {\n kind: 'N';\n value: CompleteAction;\n })\n : undefined;\n default:\n ++projectedCount;\n return notification as Notification<OutputAction> & {\n kind: 'N';\n value: OutputAction;\n };\n }\n }),\n filter((n): n is NonNullable<typeof n> => n != null),\n dematerialize(),\n finalize(() => {\n if (!completed && !errored && unsubscribe) {\n subject.next(unsubscribe(projectedCount, input));\n }\n })\n );\n })\n )\n ),\n subject\n );\n }\n );\n}\n","import { Observable, ObservedValueOf, of, OperatorFunction, pipe } from 'rxjs';\nimport { concatMap, withLatestFrom } from 'rxjs/operators';\n\n// The array overload is needed first because we want to maintain the proper order in the resulting tuple\nexport function concatLatestFrom<T extends Observable<unknown>[], V>(\n observablesFactory: (value: V) => [...T]\n): OperatorFunction<V, [V, ...{ [i in keyof T]: ObservedValueOf<T[i]> }]>;\nexport function concatLatestFrom<T extends Observable<unknown>, V>(\n observableFactory: (value: V) => T\n): OperatorFunction<V, [V, ObservedValueOf<T>]>;\n/**\n * `concatLatestFrom` combines the source value\n * and the last available value from a lazily evaluated Observable\n * in a new array\n *\n * @usageNotes\n *\n * Select the active customer from the NgRx Store\n *\n * ```ts\n * import { concatLatestFrom } from '@ngrx/effects';\n * import * fromCustomers from '../customers';\n *\n * this.actions$.pipe(\n * concatLatestFrom(() => this.store.select(fromCustomers.selectActiveCustomer))\n * )\n * ```\n *\n * Select a customer from the NgRx Store by its id that is available on the action\n *\n * ```ts\n * import { concatLatestFrom } from '@ngrx/effects';\n * import * fromCustomers from '../customers';\n *\n * this.actions$.pipe(\n * concatLatestFrom((action) => this.store.select(fromCustomers.selectCustomer(action.customerId)))\n * )\n * ```\n */\nexport function concatLatestFrom<\n T extends Observable<unknown>[] | Observable<unknown>,\n V,\n R = [\n V,\n ...(T extends Observable<unknown>[]\n ? { [i in keyof T]: ObservedValueOf<T[i]> }\n : [ObservedValueOf<T>])\n ]\n>(observablesFactory: (value: V) => T): OperatorFunction<V, R> {\n return pipe(\n concatMap((value) => {\n const observables = observablesFactory(value);\n const observablesAsArray = Array.isArray(observables)\n ? observables\n : [observables];\n return of(value).pipe(\n withLatestFrom(...observablesAsArray)\n ) as unknown as Observable<R>;\n })\n );\n}\n","/**\n * DO NOT EDIT\n *\n * This file is automatically generated at build\n */\n\nexport * from './public_api';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"} |