{"version":3,"sources":["node_modules/@ngrx/effects/fesm2022/ngrx-effects.mjs"],"sourcesContent":["import * as i1 from 'rxjs';\nimport { merge, Observable, Subject, defer } from 'rxjs';\nimport { ignoreElements, materialize, map, catchError, filter, groupBy, mergeMap, exhaustMap, dematerialize, take, concatMap, finalize } from 'rxjs/operators';\nimport * as i0 from '@angular/core';\nimport { InjectionToken, Injectable, Inject, NgModule, Optional, inject, ENVIRONMENT_INITIALIZER, makeEnvironmentProviders } from '@angular/core';\nimport * as i3 from '@ngrx/store';\nimport { ScannedActionsSubject, createAction, ROOT_STORE_PROVIDER, FEATURE_STATE_PROVIDER, Store } from '@ngrx/store';\nexport { concatLatestFrom } from '@ngrx/operators';\nconst DEFAULT_EFFECT_CONFIG = {\n  dispatch: true,\n  functional: false,\n  useEffectsErrorHandler: true\n};\nconst CREATE_EFFECT_METADATA_KEY = '__@ngrx/effects_create__';\n\n/**\n * @description\n *\n * Creates an effect from a source and an `EffectConfig`.\n *\n * @param source A function which returns an observable or observable factory.\n * @param config A `EffectConfig` to configure the effect. By default,\n * `dispatch` is true, `functional` is false, and `useEffectsErrorHandler` is\n * true.\n * @returns If `EffectConfig`#`functional` is true, returns the source function.\n * Else, returns the source function result. When `EffectConfig`#`dispatch` is\n * true, the source function result needs to be `Observable<Action>`.\n *\n * @usageNotes\n *\n * ### Class Effects\n *\n * ```ts\n * @Injectable()\n * export class FeatureEffects {\n *   // mapping to a different action\n *   readonly effect1$ = createEffect(\n *     () => this.actions$.pipe(\n *       ofType(FeatureActions.actionOne),\n *       map(() => FeatureActions.actionTwo())\n *     )\n *   );\n *\n *   // non-dispatching effect\n *   readonly effect2$ = createEffect(\n *     () => this.actions$.pipe(\n *       ofType(FeatureActions.actionTwo),\n *       tap(() => console.log('Action Two Dispatched'))\n *     ),\n *     { dispatch: false } // FeatureActions.actionTwo is not dispatched\n *   );\n *\n *   constructor(private readonly actions$: Actions) {}\n * }\n * ```\n *\n * ### Functional Effects\n *\n * ```ts\n * // mapping to a different action\n * export const loadUsers = createEffect(\n *   (actions$ = inject(Actions), usersService = inject(UsersService)) => {\n *     return actions$.pipe(\n *       ofType(UsersPageActions.opened),\n *       exhaustMap(() => {\n *         return usersService.getAll().pipe(\n *           map((users) => UsersApiActions.usersLoadedSuccess({ users })),\n *           catchError((error) =>\n *             of(UsersApiActions.usersLoadedFailure({ error }))\n *           )\n *         );\n *       })\n *     );\n *   },\n *   { functional: true }\n * );\n *\n * // non-dispatching functional effect\n * export const logDispatchedActions = createEffect(\n *   () => inject(Actions).pipe(tap(console.log)),\n *   { functional: true, dispatch: false }\n * );\n * ```\n */\nfunction createEffect(source, config = {}) {\n  const effect = config.functional ? source : source();\n  const value = {\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;\n}\nfunction getCreateEffectMetadata(instance) {\n  const propertyNames = Object.getOwnPropertyNames(instance);\n  const metadata = propertyNames.filter(propertyName => {\n    if (instance[propertyName] && instance[propertyName].hasOwnProperty(CREATE_EFFECT_METADATA_KEY)) {\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];\n      return property[CREATE_EFFECT_METADATA_KEY].hasOwnProperty('dispatch');\n    }\n    return false;\n  }).map(propertyName => {\n    const metaData = instance[propertyName][CREATE_EFFECT_METADATA_KEY];\n    return {\n      propertyName,\n      ...metaData\n    };\n  });\n  return metadata;\n}\nfunction getEffectsMetadata(instance) {\n  return getSourceMetadata(instance).reduce((acc, {\n    propertyName,\n    dispatch,\n    useEffectsErrorHandler\n  }) => {\n    acc[propertyName] = {\n      dispatch,\n      useEffectsErrorHandler\n    };\n    return acc;\n  }, {});\n}\nfunction getSourceMetadata(instance) {\n  return getCreateEffectMetadata(instance);\n}\nfunction getSourceForInstance(instance) {\n  return Object.getPrototypeOf(instance);\n}\nfunction isClassInstance(obj) {\n  return !!obj.constructor && obj.constructor.name !== 'Object' && obj.constructor.name !== 'Function';\n}\nfunction isClass(classOrRecord) {\n  return typeof classOrRecord === 'function';\n}\nfunction getClasses(classesAndRecords) {\n  return classesAndRecords.filter(isClass);\n}\nfunction isToken(tokenOrRecord) {\n  return tokenOrRecord instanceof InjectionToken || isClass(tokenOrRecord);\n}\nfunction mergeEffects(sourceInstance, globalErrorHandler, effectsErrorHandler) {\n  const source = getSourceForInstance(sourceInstance);\n  const isClassBasedEffect = !!source && source.constructor.name !== 'Object';\n  const sourceName = isClassBasedEffect ? source.constructor.name : null;\n  const observables$ = getSourceMetadata(sourceInstance).map(({\n    propertyName,\n    dispatch,\n    useEffectsErrorHandler\n  }) => {\n    const observable$ = typeof sourceInstance[propertyName] === 'function' ? sourceInstance[propertyName]() : sourceInstance[propertyName];\n    const effectAction$ = useEffectsErrorHandler ? effectsErrorHandler(observable$, globalErrorHandler) : observable$;\n    if (dispatch === false) {\n      return effectAction$.pipe(ignoreElements());\n    }\n    const materialized$ = effectAction$.pipe(materialize());\n    return materialized$.pipe(map(notification => ({\n      effect: sourceInstance[propertyName],\n      notification,\n      propertyName,\n      sourceName,\n      sourceInstance\n    })));\n  });\n  return merge(...observables$);\n}\nconst MAX_NUMBER_OF_RETRY_ATTEMPTS = 10;\nfunction defaultEffectsErrorHandler(observable$, errorHandler, retryAttemptLeft = MAX_NUMBER_OF_RETRY_ATTEMPTS) {\n  return observable$.pipe(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(observable$, errorHandler, retryAttemptLeft - 1);\n  }));\n}\nlet Actions = /*#__PURE__*/(() => {\n  class Actions extends Observable {\n    constructor(source) {\n      super();\n      if (source) {\n        this.source = source;\n      }\n    }\n    lift(operator) {\n      const observable = new Actions();\n      observable.source = this;\n      observable.operator = operator;\n      return observable;\n    }\n    /** @nocollapse */\n    static {\n      this.ɵfac = function Actions_Factory(t) {\n        return new (t || Actions)(i0.ɵɵinject(ScannedActionsSubject));\n      };\n    }\n    /** @nocollapse */\n    static {\n      this.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n        token: Actions,\n        factory: Actions.ɵfac,\n        providedIn: 'root'\n      });\n    }\n  }\n  return Actions;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\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 */\nfunction ofType(...allowedTypes) {\n  return filter(action => allowedTypes.some(typeOrActionCreator => {\n    if (typeof typeOrActionCreator === 'string') {\n      // Comparing the string to type\n      return typeOrActionCreator === action.type;\n    }\n    // We are filtering by ActionCreator\n    return typeOrActionCreator.type === action.type;\n  }));\n}\nconst _ROOT_EFFECTS_GUARD = new InjectionToken('@ngrx/effects Internal Root Guard');\nconst USER_PROVIDED_EFFECTS = new InjectionToken('@ngrx/effects User Provided Effects');\nconst _ROOT_EFFECTS = new InjectionToken('@ngrx/effects Internal Root Effects');\nconst _ROOT_EFFECTS_INSTANCES = new InjectionToken('@ngrx/effects Internal Root Effects Instances');\nconst _FEATURE_EFFECTS = new InjectionToken('@ngrx/effects Internal Feature Effects');\nconst _FEATURE_EFFECTS_INSTANCE_GROUPS = new InjectionToken('@ngrx/effects Internal Feature Effects Instance Groups');\nconst EFFECTS_ERROR_HANDLER = new InjectionToken('@ngrx/effects Effects Error Handler', {\n  providedIn: 'root',\n  factory: () => defaultEffectsErrorHandler\n});\nconst ROOT_EFFECTS_INIT = '@ngrx/effects/init';\nconst rootEffectsInit = createAction(ROOT_EFFECTS_INIT);\nfunction reportInvalidActions(output, reporter) {\n  if (output.notification.kind === 'N') {\n    const action = output.notification.value;\n    const isInvalidAction = !isAction(action);\n    if (isInvalidAction) {\n      reporter.handleError(new Error(`Effect ${getEffectName(output)} dispatched an invalid action: ${stringify(action)}`));\n    }\n  }\n}\nfunction isAction(action) {\n  return typeof action !== 'function' && action && action.type && typeof action.type === 'string';\n}\nfunction getEffectName({\n  propertyName,\n  sourceInstance,\n  sourceName\n}) {\n  const isMethod = typeof sourceInstance[propertyName] === 'function';\n  const isClassBasedEffect = !!sourceName;\n  return isClassBasedEffect ? `\"${sourceName}.${String(propertyName)}${isMethod ? '()' : ''}\"` : `\"${String(propertyName)}()\"`;\n}\nfunction stringify(action) {\n  try {\n    return JSON.stringify(action);\n  } catch {\n    return action;\n  }\n}\nconst onIdentifyEffectsKey = 'ngrxOnIdentifyEffects';\nfunction isOnIdentifyEffects(instance) {\n  return isFunction(instance, onIdentifyEffectsKey);\n}\nconst onRunEffectsKey = 'ngrxOnRunEffects';\nfunction isOnRunEffects(instance) {\n  return isFunction(instance, onRunEffectsKey);\n}\nconst onInitEffects = 'ngrxOnInitEffects';\nfunction isOnInitEffects(instance) {\n  return isFunction(instance, onInitEffects);\n}\nfunction isFunction(instance, functionName) {\n  return instance && functionName in instance && typeof instance[functionName] === 'function';\n}\nlet EffectSources = /*#__PURE__*/(() => {\n  class EffectSources extends Subject {\n    constructor(errorHandler, effectsErrorHandler) {\n      super();\n      this.errorHandler = errorHandler;\n      this.effectsErrorHandler = effectsErrorHandler;\n    }\n    addEffects(effectSourceInstance) {\n      this.next(effectSourceInstance);\n    }\n    /**\n     * @internal\n     */\n    toActions() {\n      return this.pipe(groupBy(effectsInstance => isClassInstance(effectsInstance) ? getSourceForInstance(effectsInstance) : effectsInstance), mergeMap(source$ => {\n        return source$.pipe(groupBy(effectsInstance));\n      }), mergeMap(source$ => {\n        const effect$ = source$.pipe(exhaustMap(sourceInstance => {\n          return resolveEffectSource(this.errorHandler, this.effectsErrorHandler)(sourceInstance);\n        }), map(output => {\n          reportInvalidActions(output, this.errorHandler);\n          return output.notification;\n        }), filter(notification => notification.kind === 'N' && notification.value != null), dematerialize());\n        // start the stream with an INIT action\n        // do this only for the first Effect instance\n        const init$ = source$.pipe(take(1), filter(isOnInitEffects), map(instance => instance.ngrxOnInitEffects()));\n        return merge(effect$, init$);\n      }));\n    }\n    /** @nocollapse */\n    static {\n      this.ɵfac = function EffectSources_Factory(t) {\n        return new (t || EffectSources)(i0.ɵɵinject(i0.ErrorHandler), i0.ɵɵinject(EFFECTS_ERROR_HANDLER));\n      };\n    }\n    /** @nocollapse */\n    static {\n      this.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n        token: EffectSources,\n        factory: EffectSources.ɵfac,\n        providedIn: 'root'\n      });\n    }\n  }\n  return EffectSources;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nfunction effectsInstance(sourceInstance) {\n  if (isOnIdentifyEffects(sourceInstance)) {\n    return sourceInstance.ngrxOnIdentifyEffects();\n  }\n  return '';\n}\nfunction resolveEffectSource(errorHandler, effectsErrorHandler) {\n  return sourceInstance => {\n    const mergedEffects$ = mergeEffects(sourceInstance, errorHandler, effectsErrorHandler);\n    if (isOnRunEffects(sourceInstance)) {\n      return sourceInstance.ngrxOnRunEffects(mergedEffects$);\n    }\n    return mergedEffects$;\n  };\n}\nlet EffectsRunner = /*#__PURE__*/(() => {\n  class EffectsRunner {\n    get isStarted() {\n      return !!this.effectsSubscription;\n    }\n    constructor(effectSources, store) {\n      this.effectSources = effectSources;\n      this.store = store;\n      this.effectsSubscription = null;\n    }\n    start() {\n      if (!this.effectsSubscription) {\n        this.effectsSubscription = this.effectSources.toActions().subscribe(this.store);\n      }\n    }\n    ngOnDestroy() {\n      if (this.effectsSubscription) {\n        this.effectsSubscription.unsubscribe();\n        this.effectsSubscription = null;\n      }\n    }\n    /** @nocollapse */\n    static {\n      this.ɵfac = function EffectsRunner_Factory(t) {\n        return new (t || EffectsRunner)(i0.ɵɵinject(EffectSources), i0.ɵɵinject(i3.Store));\n      };\n    }\n    /** @nocollapse */\n    static {\n      this.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n        token: EffectsRunner,\n        factory: EffectsRunner.ɵfac,\n        providedIn: 'root'\n      });\n    }\n  }\n  return EffectsRunner;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet EffectsRootModule = /*#__PURE__*/(() => {\n  class EffectsRootModule {\n    constructor(sources, runner, store, rootEffectsInstances, storeRootModule, storeFeatureModule, guard) {\n      this.sources = sources;\n      runner.start();\n      for (const effectsInstance of rootEffectsInstances) {\n        sources.addEffects(effectsInstance);\n      }\n      store.dispatch({\n        type: ROOT_EFFECTS_INIT\n      });\n    }\n    addEffects(effectsInstance) {\n      this.sources.addEffects(effectsInstance);\n    }\n    /** @nocollapse */\n    static {\n      this.ɵfac = function EffectsRootModule_Factory(t) {\n        return new (t || EffectsRootModule)(i0.ɵɵinject(EffectSources), i0.ɵɵinject(EffectsRunner), i0.ɵɵinject(i3.Store), i0.ɵɵinject(_ROOT_EFFECTS_INSTANCES), i0.ɵɵinject(i3.StoreRootModule, 8), i0.ɵɵinject(i3.StoreFeatureModule, 8), i0.ɵɵinject(_ROOT_EFFECTS_GUARD, 8));\n      };\n    }\n    /** @nocollapse */\n    static {\n      this.ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n        type: EffectsRootModule\n      });\n    }\n    /** @nocollapse */\n    static {\n      this.ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({});\n    }\n  }\n  return EffectsRootModule;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet EffectsFeatureModule = /*#__PURE__*/(() => {\n  class EffectsFeatureModule {\n    constructor(effectsRootModule, effectsInstanceGroups, storeRootModule, storeFeatureModule) {\n      const effectsInstances = effectsInstanceGroups.flat();\n      for (const effectsInstance of effectsInstances) {\n        effectsRootModule.addEffects(effectsInstance);\n      }\n    }\n    /** @nocollapse */\n    static {\n      this.ɵfac = function EffectsFeatureModule_Factory(t) {\n        return new (t || EffectsFeatureModule)(i0.ɵɵinject(EffectsRootModule), i0.ɵɵinject(_FEATURE_EFFECTS_INSTANCE_GROUPS), i0.ɵɵinject(i3.StoreRootModule, 8), i0.ɵɵinject(i3.StoreFeatureModule, 8));\n      };\n    }\n    /** @nocollapse */\n    static {\n      this.ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n        type: EffectsFeatureModule\n      });\n    }\n    /** @nocollapse */\n    static {\n      this.ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({});\n    }\n  }\n  return EffectsFeatureModule;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nlet EffectsModule = /*#__PURE__*/(() => {\n  class EffectsModule {\n    static forFeature(...featureEffects) {\n      const effects = featureEffects.flat();\n      const effectsClasses = getClasses(effects);\n      return {\n        ngModule: EffectsFeatureModule,\n        providers: [effectsClasses, {\n          provide: _FEATURE_EFFECTS,\n          multi: true,\n          useValue: effects\n        }, {\n          provide: USER_PROVIDED_EFFECTS,\n          multi: true,\n          useValue: []\n        }, {\n          provide: _FEATURE_EFFECTS_INSTANCE_GROUPS,\n          multi: true,\n          useFactory: createEffectsInstances,\n          deps: [_FEATURE_EFFECTS, USER_PROVIDED_EFFECTS]\n        }]\n      };\n    }\n    static forRoot(...rootEffects) {\n      const effects = rootEffects.flat();\n      const effectsClasses = getClasses(effects);\n      return {\n        ngModule: EffectsRootModule,\n        providers: [effectsClasses, {\n          provide: _ROOT_EFFECTS,\n          useValue: [effects]\n        }, {\n          provide: _ROOT_EFFECTS_GUARD,\n          useFactory: _provideForRootGuard\n        }, {\n          provide: USER_PROVIDED_EFFECTS,\n          multi: true,\n          useValue: []\n        }, {\n          provide: _ROOT_EFFECTS_INSTANCES,\n          useFactory: createEffectsInstances,\n          deps: [_ROOT_EFFECTS, USER_PROVIDED_EFFECTS]\n        }]\n      };\n    }\n    /** @nocollapse */\n    static {\n      this.ɵfac = function EffectsModule_Factory(t) {\n        return new (t || EffectsModule)();\n      };\n    }\n    /** @nocollapse */\n    static {\n      this.ɵmod = /* @__PURE__ */i0.ɵɵdefineNgModule({\n        type: EffectsModule\n      });\n    }\n    /** @nocollapse */\n    static {\n      this.ɵinj = /* @__PURE__ */i0.ɵɵdefineInjector({});\n    }\n  }\n  return EffectsModule;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\nfunction createEffectsInstances(effectsGroups, userProvidedEffectsGroups) {\n  const effects = [];\n  for (const effectsGroup of effectsGroups) {\n    effects.push(...effectsGroup);\n  }\n  for (const userProvidedEffectsGroup of userProvidedEffectsGroups) {\n    effects.push(...userProvidedEffectsGroup);\n  }\n  return effects.map(effectsTokenOrRecord => isToken(effectsTokenOrRecord) ? inject(effectsTokenOrRecord) : effectsTokenOrRecord);\n}\nfunction _provideForRootGuard() {\n  const runner = inject(EffectsRunner, {\n    optional: true,\n    skipSelf: true\n  });\n  const rootEffects = inject(_ROOT_EFFECTS, {\n    self: true\n  });\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(`EffectsModule.forRoot() called twice. Feature modules should use EffectsModule.forFeature() instead.`);\n  }\n  return 'guarded';\n}\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 */\nfunction act( /** Allow to take either config object or project/error functions */\nconfigOrProject, errorFn) {\n  const {\n    project,\n    error,\n    complete,\n    operator,\n    unsubscribe\n  } = typeof configOrProject === 'function' ? {\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,\n    operator: configOrProject.operator || concatMap\n  };\n  return source => defer(() => {\n    const subject = new Subject();\n    return merge(source.pipe(operator((input, index) => defer(() => {\n      let completed = false;\n      let errored = false;\n      let projectedCount = 0;\n      return project(input, index).pipe(materialize(), map(notification => {\n        switch (notification.kind) {\n          case 'E':\n            errored = true;\n            return {\n              kind: 'N',\n              value: error(notification.error, input)\n            };\n          case 'C':\n            completed = true;\n            return complete ? {\n              kind: 'N',\n              value: complete(projectedCount, input)\n            } : undefined;\n          default:\n            ++projectedCount;\n            return notification;\n        }\n      }), filter(n => n != null), dematerialize(), finalize(() => {\n        if (!completed && !errored && unsubscribe) {\n          subject.next(unsubscribe(projectedCount, input));\n        }\n      }));\n    }))), subject);\n  });\n}\n\n/**\n * @usageNotes\n *\n * ### Providing effects at the root level\n *\n * ```ts\n * bootstrapApplication(AppComponent, {\n *   providers: [provideEffects(RouterEffects)],\n * });\n * ```\n *\n * ### Providing effects at the feature level\n *\n * ```ts\n * const booksRoutes: Route[] = [\n *   {\n *     path: '',\n *     providers: [provideEffects(BooksApiEffects)],\n *     children: [\n *       { path: '', component: BookListComponent },\n *       { path: ':id', component: BookDetailsComponent },\n *     ],\n *   },\n * ];\n * ```\n */\nfunction provideEffects(...effects) {\n  const effectsClassesAndRecords = effects.flat();\n  const effectsClasses = getClasses(effectsClassesAndRecords);\n  return makeEnvironmentProviders([effectsClasses, {\n    provide: ENVIRONMENT_INITIALIZER,\n    multi: true,\n    useValue: () => {\n      inject(ROOT_STORE_PROVIDER);\n      inject(FEATURE_STATE_PROVIDER, {\n        optional: true\n      });\n      const effectsRunner = inject(EffectsRunner);\n      const effectSources = inject(EffectSources);\n      const shouldInitEffects = !effectsRunner.isStarted;\n      if (shouldInitEffects) {\n        effectsRunner.start();\n      }\n      for (const effectsClassOrRecord of effectsClassesAndRecords) {\n        const effectsInstance = isClass(effectsClassOrRecord) ? inject(effectsClassOrRecord) : effectsClassOrRecord;\n        effectSources.addEffects(effectsInstance);\n      }\n      if (shouldInitEffects) {\n        const store = inject(Store);\n        store.dispatch(rootEffectsInit());\n      }\n    }\n  }]);\n}\n\n/**\n * DO NOT EDIT\n *\n * This file is automatically generated at build\n */\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { Actions, EFFECTS_ERROR_HANDLER, EffectSources, EffectsFeatureModule, EffectsModule, EffectsRootModule, EffectsRunner, ROOT_EFFECTS_INIT, USER_PROVIDED_EFFECTS, act, createEffect, defaultEffectsErrorHandler, getEffectsMetadata, mergeEffects, ofType, provideEffects, rootEffectsInit };\n"],"mappings":"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","names":["DEFAULT_EFFECT_CONFIG","CREATE_EFFECT_METADATA_KEY","createEffect","source","config","effect","value","__spreadValues","getCreateEffectMetadata","instance","propertyName","metaData","getSourceMetadata","instance","getCreateEffectMetadata","getSourceForInstance","isClassInstance","obj","isClass","classOrRecord","getClasses","classesAndRecords","isToken","tokenOrRecord","InjectionToken","mergeEffects","sourceInstance","globalErrorHandler","effectsErrorHandler","source","sourceName","observables$","propertyName","dispatch","useEffectsErrorHandler","observable$","effectAction$","ignoreElements","materialize","map","notification","merge","MAX_NUMBER_OF_RETRY_ATTEMPTS","defaultEffectsErrorHandler","errorHandler","retryAttemptLeft","catchError","error","Actions","_Actions","Observable","operator","observable","t","ɵɵinject","ScannedActionsSubject","ɵɵdefineInjectable","ofType","allowedTypes","filter","action","typeOrActionCreator","_ROOT_EFFECTS_GUARD","USER_PROVIDED_EFFECTS","_ROOT_EFFECTS","_ROOT_EFFECTS_INSTANCES","_FEATURE_EFFECTS","_FEATURE_EFFECTS_INSTANCE_GROUPS","EFFECTS_ERROR_HANDLER","ROOT_EFFECTS_INIT","rootEffectsInit","createAction","reportInvalidActions","output","reporter","isAction","getEffectName","stringify","isMethod","onIdentifyEffectsKey","isOnIdentifyEffects","isFunction","onRunEffectsKey","isOnRunEffects","onInitEffects","isOnInitEffects","functionName","EffectSources","_EffectSources","Subject","effectSourceInstance","groupBy","effectsInstance","mergeMap","source$","effect$","exhaustMap","resolveEffectSource","dematerialize","init$","take","ErrorHandler","mergedEffects$","EffectsRunner","_EffectsRunner","effectSources","store","Store","EffectsRootModule","_EffectsRootModule","sources","runner","rootEffectsInstances","storeRootModule","storeFeatureModule","guard","StoreRootModule","StoreFeatureModule","ɵɵdefineNgModule","ɵɵdefineInjector","EffectsFeatureModule","_EffectsFeatureModule","effectsRootModule","effectsInstanceGroups","effectsInstances","EffectsModule","_EffectsModule","featureEffects","effects","effectsClasses","createEffectsInstances","rootEffects","_provideForRootGuard","effectsGroups","userProvidedEffectsGroups","effectsGroup","userProvidedEffectsGroup","effectsTokenOrRecord","inject"],"x_google_ignoreList":[0]}