Class FetchEngine<H, P, S, RH>

name

$facts

• $facts(): {
      hasSpy: boolean;
      listenerCounts: Record<string, number>;
      listeners: (keyof EventMap<S, H, P>)[];
      rgxListeners: string[];
  }

  Returns facts about the the internal state of the observable instance.

  Returns {
      hasSpy: boolean;
      listenerCounts: Record<string, number>;
      listeners: (keyof EventMap<S, H, P>)[];
      rgxListeners: string[];
  }

$has

• $has(event: keyof EventMap<S, H, P>): boolean

  Returns if the observable instance has the given event

  Parameters

  • event: keyof EventMap<S, H, P>

  Returns boolean

• $has(event: RegExp): boolean

  Returns if the observable instance has a regex event

  Parameters

  • event: RegExp

  Returns boolean

• $has(event: string): boolean

  Returns if the observable instance has the given event

  Parameters

  • event: string

  Returns boolean

$internals

• $internals(): {
      internalListener: EventTarget;
      listenerMap: Map<keyof EventMap<S, H, P>, Set<Func>>;
      name: string;
      rgxListenerMap: Map<string, Set<Func>>;
      spy: Spy<EventMap<S, H, P>> | undefined;
  }

  The internals of the observable instance.

  NOTE: Do not use this to try to meddle with the internals of the observable instance. This is for debugging purposes only.

  Returns {
      internalListener: EventTarget;
      listenerMap: Map<keyof EventMap<S, H, P>, Set<Func>>;
      name: string;
      rgxListenerMap: Map<string, Set<Func>>;
      spy: Spy<EventMap<S, H, P>> | undefined;
  }

clear

• clear(): void

  Returns void

debug

• debug(on?: boolean): void

  Enables or disables debugging for the observable instance. Works in conjunction with your spy function. Provides a stack trace of events that are triggered, listened to, and cleaned up.

  Parameters

  • Optionalon: boolean

    Whether to enable or disable debugging

  Returns void

emit

• emit<E extends string | RegExp>(
      event: E,
      data?: E extends keyof EventMap<S, H, P>
          ? EventMap<S, H, P>[E]
          : E extends string ? Record<E, any>[E] : unknown,
  ): void

  Emits an event

  Type Parameters

  • E extends string | RegExp

  Parameters

  • event: E
  • Optionaldata: E extends keyof EventMap<S, H, P>
        ? EventMap<S, H, P>[E]
        : E extends string ? Record<E, any>[E] : unknown

  Returns void

observe

• observe<C>(component: C, options?: ObserveOptions): Child<C, EventMap<S, H, P>>

  Observes given component as an extension of this observable instance.

  Type Parameters

  • C

  Parameters

  • component: C

    Component to wrap events around

  • Optionaloptions: ObserveOptions

    Optional configuration including signal for cleanup

  Returns Child<C, EventMap<S, H, P>>

  Example

  const obs = new ObserverEngine();
  
  const modal = {};
  
  obs.observe(modal);
  
  modal.on('modal-open', () => {});
  
  obs.trigger('modal-open'); // opens modal
  modal.trigger('modal-open'); // opens modal
  
  modal.cleanup(); // clears all event listeners
  Copy

off

• off(event: string | RegExp, listener?: Function): void

  Stop listening for an event

  Parameters

  • event: string | RegExp
  • Optionallistener: Function

  Returns void

on

• on<E extends keyof EventMap<S, H, P>>(
      event: E,
      options?: ListenerOptions,
  ): EventGenerator<EventMap<S, H, P>, E>

  Returns an event generator that will listen for the specified event

  Type Parameters

  • E extends keyof EventMap<S, H, P>

  Parameters

  • event: E
  • Optionaloptions: ListenerOptions

  Returns EventGenerator<EventMap<S, H, P>, E>

  Example

  const obs = new ObserverEngine();
  
  const something = obs.on('something');
  const data = await something.next(); // waits for next event
  something.emit('special'); // emits data to listeners
  
  something.cleanup(); // stops listening for events
  Copy

• on<E extends string>(
      event: E,
      options?: ListenerOptions,
  ): EventGenerator<Record<E, any>>

  Returns an event generator that will listen for the specified event

  Type Parameters

  • E extends string

  Parameters

  • event: E
  • Optionaloptions: ListenerOptions

  Returns EventGenerator<Record<E, any>>

  Example

  const obs = new ObserverEngine();
  
  const something = obs.on('something');
  const data = await something.next(); // waits for next event
  something.emit('special'); // emits data to listeners
  
  something.cleanup(); // stops listening for events
  Copy

• on<E extends keyof EventMap<S, H, P>>(
      event: E,
      listener: EventCallback<EventMap<S, H, P>[E]>,
      options?: ListenerOptions,
  ): Cleanup

  Listens for the specified event and executes the given callback

  Type Parameters

  • E extends keyof EventMap<S, H, P>

  Parameters

  • event: E
  • listener: EventCallback<EventMap<S, H, P>[E]>
  • Optionaloptions: ListenerOptions

  Returns Cleanup

  Example

  const obs = new ObserverEngine();
  
  obs.on('something', (data) => {
     console.log(data);
  });
  Copy

• on<E extends string>(
      event: E,
      listener: EventCallback<Record<E, any>>,
      options?: ListenerOptions,
  ): Cleanup

  Returns an event generator that will listen for the specified event

  Type Parameters

  • E extends string

  Parameters

  • event: E
  • listener: EventCallback<Record<E, any>>
  • Optionaloptions: ListenerOptions

  Returns Cleanup

  Example

  const obs = new ObserverEngine();
  
  const something = obs.on('something');
  const data = await something.next(); // waits for next event
  something.emit('special'); // emits data to listeners
  
  something.cleanup(); // stops listening for events
  Copy

• on(
      event: RegExp,
      options?: ListenerOptions,
  ): EventGenerator<EventMap<S, H, P>, RegExp>

  Returns an event generator that will listen for all events matching the regex

  Parameters

  • event: RegExp
  • Optionaloptions: ListenerOptions

  Returns EventGenerator<EventMap<S, H, P>, RegExp>

  Example

  const obs = new ObserverEngine();
  
  const onEvent = obs.on(/some/);
  const { event, data } = await onEvent.next(); // waits for next event
  onEvent.emit('something'); // emits data to listeners
  
  onEvent.cleanup(); // stops listening for events
  Copy

• on(
      event: RegExp,
      listener: EventCallback<RgxEmitData<EventMap<S, H, P>>>,
      options?: ListenerOptions,
  ): Cleanup

  Listens for all events matching the regex and executes the given callback

  Parameters

  • event: RegExp
  • listener: EventCallback<RgxEmitData<EventMap<S, H, P>>>
  • Optionaloptions: ListenerOptions

  Returns Cleanup

  Example

  const obs = new ObserverEngine();
  
  obs.on(/some/, ({ event, data }) => {
      console.log(event, data);
  });
  Copy

once

• once<E extends keyof EventMap<S, H, P>>(
      event: E,
      options?: ListenerOptions,
  ): EventPromise<EventMap<S, H, P>[E]>

  Returns an event promise that resolves when the specified event is emitted

  Type Parameters

  • E extends keyof EventMap<S, H, P>

  Parameters

  • event: E
  • Optionaloptions: ListenerOptions

  Returns EventPromise<EventMap<S, H, P>[E]>

• once<E extends string>(
      event: E,
      options?: ListenerOptions,
  ): EventPromise<Record<E, any>>

  Returns an event promise that resolves when the specified event is emitted. This overload is untyped and can be used to listen for any event that is emitted.

  Type Parameters

  • E extends string

  Parameters

  • event: E
  • Optionaloptions: ListenerOptions

  Returns EventPromise<Record<E, any>>

• once<E extends keyof EventMap<S, H, P>>(
      event: E,
      listener: EventCallback<EventMap<S, H, P>[E]>,
      options?: ListenerOptions,
  ): Cleanup

  Executes a callback once when the specified event is emitted

  Type Parameters

  • E extends keyof EventMap<S, H, P>

  Parameters

  • event: E
  • listener: EventCallback<EventMap<S, H, P>[E]>
  • Optionaloptions: ListenerOptions

  Returns Cleanup

• once<E extends string>(
      event: E,
      listener: EventCallback<Record<E, any>>,
      options?: ListenerOptions,
  ): Cleanup

  Executes a callback once when the specified event is emitted. This overload is untyped and can be used to listen for any event that is emitted.

  Type Parameters

  • E extends string

  Parameters

  • event: E
  • listener: EventCallback<Record<E, any>>
  • Optionaloptions: ListenerOptions

  Returns Cleanup

• once(
      event: RegExp,
      options?: ListenerOptions,
  ): EventPromise<RgxEmitData<EventMap<S, H, P>>>

  Returns an event promise that resolves when any events matching the regex are emitted

  Parameters

  • event: RegExp
  • Optionaloptions: ListenerOptions

  Returns EventPromise<RgxEmitData<EventMap<S, H, P>>>

• once(
      event: RegExp,
      listener: EventCallback<RgxEmitData<EventMap<S, H, P>>>,
      options?: ListenerOptions,
  ): Cleanup

  Executes a callback once when any events matching the regex are emitted

  Parameters

  • event: RegExp
  • listener: EventCallback<RgxEmitData<EventMap<S, H, P>>>
  • Optionaloptions: ListenerOptions

  Returns Cleanup

queue

• queue<E extends RegExp | (keyof EventMap<S, H, P>)>(
      event: E,
      process: (data: EventData<EventMap<S, H, P>, E>) => any,
      options: QueueOpts,
  ): EventQueue<EventMap<S, H, P>, E>

  Type Parameters

  • E extends RegExp | (keyof EventMap<S, H, P>)

  Parameters

  • event: E
  • process: (data: EventData<EventMap<S, H, P>, E>) => any
  • options: QueueOpts

  Returns EventQueue<EventMap<S, H, P>, E>

spy

• spy(spy: Spy<EventMap<S, H, P>>, force?: boolean): void

  Sets the spy function for the observable instance.

  Parameters

  • spy: Spy<EventMap<S, H, P>>

    The spy function to set

  • Optionalforce: boolean

    Whether to force the spy function to be set even if one is already set

  Returns void

Staticcopy

• copy<Shape extends Record<string, any>>(
      source: ObserverEngine<Shape>,
      target: ObserverEngine<Shape>,
      options?: TransferOptions<Shape>,
  ): void

  Copies all matching listeners from source to target without removing them from the source. Target's existing listeners are preserved.

  Useful when forking an engine so both instances react to the same events independently.

  Type Parameters

  • Shape extends Record<string, any>

  Parameters

  • source: ObserverEngine<Shape>
  • target: ObserverEngine<Shape>
  • Optionaloptions: TransferOptions<Shape>

  Returns void

  Example

  const primary = new ObserverEngine();
      const mirror = new ObserverEngine();
  
      primary.on('update', handler);
  
      ObserverEngine.copy(primary, mirror);
      // Both engines now have the 'update' listener
  Copy

  Example

  // Copy everything except internal events
      ObserverEngine.copy(primary, mirror, {
          exclude: [/^__/]
      });
  Copy

Statictransfer

• transfer<Shape extends Record<string, any>>(
      source: ObserverEngine<Shape>,
      target: ObserverEngine<Shape>,
      options?: TransferOptions<Shape>,
  ): void

  Transfers all matching listeners from source to target, removing them from the source. Target's existing listeners are preserved.

  Useful when cloning an engine (e.g. FetchEngine) and carrying over observability listeners to the new instance.

  Type Parameters

  • Shape extends Record<string, any>

  Parameters

  • source: ObserverEngine<Shape>
  • target: ObserverEngine<Shape>
  • Optionaloptions: TransferOptions<Shape>

  Returns void

  Example

  const old = new ObserverEngine();
      const next = new ObserverEngine();
  
      old.on('ready', handler);
  
      ObserverEngine.transfer(old, next);
      // `next` now owns the 'ready' listener; `old` has none
  Copy

  Example

  // Transfer only specific events
      ObserverEngine.transfer(old, next, {
          filter: ['ready', /^user\./]
      });
  Copy