Interface FetchEnginePublic<H, P, S>

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