Function debounced

packages/core/src/resource/debounce.ts:36–165

(
  source: () => T,
  wait: NoInfer<DebounceTimer<T>>,
  options?: NoInfer<DebouncedOptions<T>>,
)

 * @see [Debouncing signals with `debounced`](guide/signals/debounced)
 */
export function debounced<T>(
  source: () => T,
  wait: NoInfer<DebounceTimer<T>>,
  options?: NoInfer<DebouncedOptions<T>>,
): Resource<T> {
  if (isInParamsFunction()) {
    throw invalidResourceCreationInParams();
  }
  if (ngDevMode && !options?.injector) {
    assertInInjectionContext(debounced);
  }
  const injector = options?.injector ?? inject(Injector);

  let active: Promise<void> | void | undefined;
  let pendingValue: T | undefined;
  let activeTimer: ReturnType<typeof setTimeout> | undefined;

  const cancelTimer = () => {
    if (activeTimer !== undefined) {
      clearTimeout(activeTimer);
      activeTimer = undefined;
    }
  };

  injector.get(DestroyRef).onDestroy(() => {
    cancelTimer();
    active = undefined;
  });

  const state = linkedSignal<
    {value: T; thrown: false} | {error: unknown; thrown: true},
    ResourceSnapshot<T>
  >({
    source: () => {
      try {
        setInParamsFunction(true);
        return {value: source(), thrown: false};
      } catch (err) {
        rethrowFatalErrors(err);
        return {error: err, thrown: true};
      } finally {
        setInParamsFunction(false);
      }
    },
    computation: (res, previous) => {
      // If we already have a state from the effect or a previous read, keep it!
      // The effect is responsible for timing and state transitions.
      if (previous !== undefined) {
        return previous.value;
      }

      // On the very first evaluation, determine the initial state synchronously.
      if (res.thrown) {
        return {status: 'error', error: res.error as Error};
      }
      return {status: 'resolved', value: res.value};
    },
  });