{"version":3,"file":"angular-kit-effects.mjs","sources":["../../../../libs/effects/src/lib/assert-injector.ts","../../../../libs/effects/src/lib/effects.functional.ts","../../../../libs/effects/src/angular-kit-effects.ts"],"sourcesContent":["import {\n  Injector,\n  assertInInjectionContext,\n  inject,\n  runInInjectionContext,\n} from '@angular/core';\n\n/**\n * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`\n * After assertion, `assertInjector` runs the `runner` function with the guaranteed `Injector`\n * whether it is the default `Injector` within the current **Injection Context**\n * or the custom `Injector` that was passed in.\n *\n * @template {() => any} Runner - Runner is a function that can return anything\n * @param {Function} fn - the Function to pass in `assertInInjectionContext`\n * @param {Injector | undefined | null} injector - the optional \"custom\" Injector\n * @param {Runner} runner - the runner fn\n * @returns {ReturnType<Runner>} result - returns the result of the Runner\n *\n * @example\n * ```ts\n * function injectValue(injector?: Injector) {\n *  return assertInjector(injectValue, injector, () => 'value');\n * }\n *\n * injectValue(); // string\n * ```\n */\nexport function assertInjector<Runner extends () => any>(\n  // eslint-disable-next-line @typescript-eslint/ban-types -- mirrors Angular assertInInjectionContext signature\n  fn: Function,\n  injector: Injector | undefined | null,\n  runner: Runner,\n): ReturnType<Runner>;\n/**\n * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`\n * After assertion, `assertInjector` returns a guaranteed `Injector` whether it is the default `Injector`\n * within the current **Injection Context** or the custom `Injector` that was passed in.\n *\n * @param {Function} fn - the Function to pass in `assertInInjectionContext`\n * @param {Injector | undefined | null} injector - the optional \"custom\" Injector\n * @returns Injector\n *\n * @example\n * ```ts\n * function injectDestroy(injector?: Injector) {\n *  injector = assertInjector(injectDestroy, injector);\n *\n *  return runInInjectionContext(injector, () => {\n *    // code\n *  })\n * }\n * ```\n */\nexport function assertInjector(\n  // eslint-disable-next-line @typescript-eslint/ban-types -- mirrors Angular assertInInjectionContext signature\n  fn: Function,\n  injector: Injector | undefined | null,\n): Injector;\nexport function assertInjector(\n  // eslint-disable-next-line @typescript-eslint/ban-types -- mirrors Angular assertInInjectionContext signature\n  fn: Function,\n  injector: Injector | undefined | null,\n  runner?: () => any,\n) {\n  !injector && assertInInjectionContext(fn);\n  const assertedInjector = injector ?? inject(Injector);\n\n  if (!runner) return assertedInjector;\n  return runInInjectionContext(assertedInjector, runner);\n}\n","import {\n  DestroyRef,\n  ErrorHandler,\n  inject,\n  Injector,\n  runInInjectionContext,\n} from '@angular/core';\nimport {\n  catchError,\n  EMPTY,\n  Observable,\n  pipe,\n  ReplaySubject,\n  Subscription,\n  tap,\n} from 'rxjs';\nimport { assertInjector } from './assert-injector';\n\nexport type EffectCleanUpRef = {\n  cleanUp: () => void;\n};\n\nexport type RunOptions = {\n  onCleanUp?: () => void;\n};\n\nexport type RxEffect = {\n  run(sub: Subscription, options?: RunOptions): EffectCleanUpRef;\n  run<T>(o$: Observable<T>, options?: RunOptions): EffectCleanUpRef;\n  run<T>(\n    o$: Observable<T>,\n    sideEffectFn: (arg: T) => void,\n    options?: RunOptions\n  ): EffectCleanUpRef;\n  run<T>(\n    obsOrSub: Observable<T> | Subscription,\n    options?: RunOptions\n  ): EffectCleanUpRef;\n  runOnInstanceDestroy: (sideEffectFn: () => void) => EffectCleanUpRef;\n  cleanUp: () => void;\n};\n\nexport type EffectsSetupFn = (\n  rxEffect: Pick<RxEffect, 'run' | 'runOnInstanceDestroy'>\n) => void;\n\nfunction isRunOptions(obj: unknown): obj is RunOptions {\n  return (\n    typeof obj === 'object' &&\n    obj !== null &&\n    typeof (obj as RunOptions).onCleanUp === 'function'\n  );\n}\n\nfunction noopCleanUpRef(): EffectCleanUpRef {\n  return { cleanUp: () => void 0 };\n}\n\n/**\n * @description\n * Functional way to setup observable based side effects.\n *\n * It will destroy itself when the provided {@link DestroyRef} is destroyed.\n *\n * Must be called in an injection context, unless an `injector` or a\n * `destroyRef` is provided via options.\n *\n * @param setupFn\n * @param options\n *\n * @example\n *\n * const ef = rxEffect(({run, runOnInstanceDestroy}) => {\n *     run(source$, console.log)\n *\n *     run(source$.subscribe(console.log))\n *\n *     run(source$.pipe(tap(console.log)))\n *\n *     runOnInstanceDestroy(() => {\n *       // any teardown logic, e.g unsubscribe from any source, clear timers etc.\n *     })\n * })\n */\nexport function rxEffect(\n  setupFn?: EffectsSetupFn,\n  options?: {\n    injector?: Injector;\n    destroyRef?: DestroyRef;\n  }\n): RxEffect {\n  const providedDestroyRef = options?.destroyRef ?? null;\n\n  let injector: Injector | null = null;\n  try {\n    injector = assertInjector(rxEffect, options?.injector);\n  } catch (error) {\n    // a provided DestroyRef replaces the injection context requirement\n    if (!providedDestroyRef) throw error;\n  }\n\n  if (!injector) {\n    // outside any injection context: no ErrorHandler available\n    return createEffects(setupFn, providedDestroyRef as DestroyRef, null);\n  }\n\n  return runInInjectionContext(injector, () =>\n    createEffects(\n      setupFn,\n      providedDestroyRef ?? inject(DestroyRef),\n      inject(ErrorHandler, { optional: true })\n    )\n  );\n}\n\nfunction createEffects(\n  setupFn: EffectsSetupFn | undefined,\n  destroyRef: DestroyRef,\n  errorHandler: ErrorHandler | null\n): RxEffect {\n  let nextId = 0;\n  let destroyed = false;\n  const rootSub = new Subscription();\n  const idSubMap = new Map<number, Subscription>();\n  const destroyHook$$ = new ReplaySubject<void>(1);\n\n  /**\n   * Route errors thrown by user provided cleanup logic to the ErrorHandler\n   * so one failing teardown cannot break the remaining cleanup work.\n   * Rethrows when no ErrorHandler is available.\n   */\n  function invokeGuarded(fn: () => void): void {\n    try {\n      fn();\n    } catch (error) {\n      if (errorHandler) {\n        errorHandler.handleError(error);\n      } else {\n        throw error;\n      }\n    }\n  }\n\n  function register(subscription: Subscription): number {\n    const effectId = nextId++;\n    idSubMap.set(effectId, subscription);\n    // remove the map entry as soon as the subscription closes for any\n    // reason (manual cleanUp, instance destroy, completion, error)\n    subscription.add(() => idSubMap.delete(effectId));\n    rootSub.add(subscription);\n    return effectId;\n  }\n\n  /**\n   * Cancel a registered side effect\n   * @param effectId\n   */\n  function unregister(effectId: number): void {\n    idSubMap.get(effectId)?.unsubscribe();\n    idSubMap.delete(effectId);\n  }\n\n  /**\n   * @description\n   * Manage the subscription of an observable and execute the side effect.\n   *\n   * Unsubscribes automatically when the provided {@link DestroyRef} is destroyed.\n   *\n   * Manually unsubscribe by calling {@link EffectCleanUpRef.cleanUp}.\n   *\n   * @example\n   * ```typescript\n   * ef = rxEffect(({run})=> run(source$.subscribe(console.log)))\n   * ```\n   * @param sub\n   * @param options\n   */\n  function run(sub: Subscription, options?: RunOptions): EffectCleanUpRef;\n  /**\n   * @description\n   * Subscribe to the passed observable and execute the side effect.\n   *\n   * Unsubscribes automatically when the provided {@link DestroyRef} is destroyed.\n   *\n   * Manually unsubscribe by calling {@link EffectCleanUpRef.cleanUp}.\n   *\n   * @example\n   * ```typescript\n   * ef = rxEffect(({run})=> run(source$.pipe(tap(console.log))))\n   * ```\n   *\n   * @param o$\n   * @param options\n   */\n  function run<T>(o$: Observable<T>, options?: RunOptions): EffectCleanUpRef;\n  /**\n   * @description\n   * Subscribe to the passed observable and execute the side effect.\n   *\n   * Unsubscribes automatically when the provided {@link DestroyRef} is destroyed.\n   *\n   * Manually unsubscribe by calling {@link EffectCleanUpRef.cleanUp}.\n   *\n   * @example\n   * ```typescript\n   * const trigger$ = of(1);\n   * const effect = console.log;\n   * ef = rxEffect(({run})=> run(trigger$, effect))\n   * ```\n   *\n   * @param o$\n   * @param sideEffectFn\n   * @param options\n   */\n  function run<T>(\n    o$: Observable<T>,\n    sideEffectFn: (arg: T) => void,\n    options?: RunOptions\n  ): EffectCleanUpRef;\n  /**\n   * @description\n   * Accepts a source that is either an observable or an already created\n   * subscription (union typed variables).\n   *\n   * @param obsOrSub\n   * @param options\n   */\n  function run<T>(\n    obsOrSub: Observable<T> | Subscription,\n    options?: RunOptions\n  ): EffectCleanUpRef;\n  function run<T>(\n    obsOrSub: Observable<T> | Subscription,\n    sideEffectFnOrOptions?: ((arg: T) => void) | RunOptions,\n    options?: RunOptions\n  ): EffectCleanUpRef {\n    const sideEffectFn =\n      typeof sideEffectFnOrOptions === 'function'\n        ? sideEffectFnOrOptions\n        : undefined;\n    const runOptions = isRunOptions(sideEffectFnOrOptions)\n      ? sideEffectFnOrOptions\n      : isRunOptions(options)\n      ? options\n      : undefined;\n\n    if (destroyed) {\n      // the instance is gone: never start new work. A passed subscription\n      // is already live, so it is stopped and its cleanup executed.\n      if (obsOrSub instanceof Subscription) {\n        try {\n          obsOrSub.unsubscribe();\n        } finally {\n          if (runOptions?.onCleanUp) invokeGuarded(runOptions.onCleanUp);\n        }\n      }\n      return noopCleanUpRef();\n    }\n\n    const subscription =\n      obsOrSub instanceof Subscription\n        ? obsOrSub\n        : obsOrSub\n            .pipe(\n              // execute operation/ side effect\n              sideEffectFn ? tap(sideEffectFn) : pipe(),\n              catchError((error) => {\n                if (errorHandler) {\n                  errorHandler.handleError(error);\n                } else {\n                  // no ErrorHandler available (destroyRef-only usage).\n                  // Rethrowing here would surface via rxjs' unhandled error\n                  // reporting, which crashes the host app; log instead so the\n                  // failure stays visible without taking the app down.\n                  console.error('[rxEffect] Unhandled source error:', error);\n                }\n                return EMPTY;\n              })\n            )\n            .subscribe();\n\n    const effectId = register(subscription);\n\n    // onCleanUp must execute exactly once: on manual cleanUp or on\n    // instance destroy, whichever comes first\n    let cleanUpExecuted = false;\n    const executeOnCleanUp = () => {\n      if (cleanUpExecuted) return;\n      cleanUpExecuted = true;\n      if (runOptions?.onCleanUp) invokeGuarded(runOptions.onCleanUp);\n    };\n\n    let destroyHookSub: Subscription | null = null;\n    if (runOptions?.onCleanUp) {\n      destroyHookSub = destroyHook$$.subscribe(executeOnCleanUp);\n      rootSub.add(destroyHookSub);\n    }\n\n    return {\n      cleanUp: () => {\n        try {\n          executeOnCleanUp();\n        } finally {\n          destroyHookSub?.unsubscribe();\n          unregister(effectId);\n        }\n      },\n    };\n  }\n\n  /**\n   * Execute a sideEffect when the rxEffect instance is destroyed or cleaned up.\n   *\n   * When called after the instance was already destroyed the sideEffect\n   * executes immediately (mirrors RxJS `Subscription.add` on a closed subscription).\n   * @param sideEffectFn\n   */\n  function runOnInstanceDestroy(sideEffectFn: () => void): EffectCleanUpRef {\n    if (destroyed) {\n      invokeGuarded(sideEffectFn);\n      return noopCleanUpRef();\n    }\n    return run(\n      destroyHook$$.pipe(tap(() => invokeGuarded(sideEffectFn))).subscribe()\n    );\n  }\n\n  // Cleanup function - idempotent\n  function cleanUp(): void {\n    if (destroyed) return;\n    destroyed = true;\n    destroyHook$$.next(void 0);\n    destroyHook$$.complete();\n    rootSub.unsubscribe();\n    idSubMap.clear();\n  }\n\n  const effects: RxEffect = {\n    run,\n    runOnInstanceDestroy,\n    cleanUp,\n  };\n\n  // Register the cleanup on destroy BEFORE running the setup so effects\n  // registered before a throwing setupFn do not leak\n  destroyRef.onDestroy(() => {\n    effects.cleanUp();\n  });\n\n  if (setupFn) {\n    try {\n      setupFn({\n        run: effects.run,\n        runOnInstanceDestroy: effects.runOnInstanceDestroy,\n      });\n    } catch (error) {\n      try {\n        effects.cleanUp();\n      } catch (cleanUpError) {\n        // the setup error takes precedence over failing teardown logic\n        errorHandler?.handleError(cleanUpError);\n      }\n      throw error;\n    }\n  }\n\n  return effects;\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}