Logos DX
    Preparing search index...

    Interface FetchEngineCore<H, P, S>

    Core interface that FetchEngine implements.

    This interface defines what internal components (RequestExecutor, policies, stores) can access from the engine. All configuration is accessed through stores, and events are emitted through the ObserverEngine base.

    FetchEngineCore extends ObserverEngine which provides type-safe event emission. This is the ONLY way for internal components to emit events, guaranteeing type safety at emit time.

    // Components receive FetchEngineCore and access everything through it
    class RequestExecutor<H, P, S> {
        constructor(private engine: FetchEngineCore<H, P, S>) {}

        execute() {
            // Type-safe event emission through engine
            this.engine.emit('before', { state: this.engine.state.get() });

            // Access config through options store
            const timeout = this.engine.options.get('totalTimeout');
        }
    }
    interface FetchEngineCore<H = unknown, P = unknown, S = unknown> {
        config: ConfigStore<H, P, S>;
        headerStore: PropertyStore<DictAndT<H>>;
        hooks: HookEngine<FetchLifecycle<H, P, S>>;
        name: string;
        paramStore: PropertyStore<DictAndT<P>>;
        state: FetchState<S>;
        $facts(): {
            hasSpy: boolean;
            listenerCounts: Record<string, number>;
            listeners: (keyof EventMap<S, H, P>)[];
            rgxListeners: string[];
        };
        $has(event: keyof EventMap<S, H, P>): boolean;
        $has(event: RegExp): boolean;
        $has(event: string): boolean;
        $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;
        };
        clear(): void;
        debug(on?: boolean): void;
        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;
        observe<C>(
            component: C,
            options?: ObserveOptions,
        ): Child<C, EventMap<S, H, P>>;
        off(event: string | RegExp, listener?: Function): void;
        on<E extends keyof EventMap<S, H, P>>(
            event: E,
            options?: ListenerOptions,
        ): EventGenerator<EventMap<S, H, P>, E>;
        on<E extends string>(
            event: E,
            options?: ListenerOptions,
        ): EventGenerator<Record<E, any>>;
        on<E extends keyof EventMap<S, H, P>>(
            event: E,
            listener: EventCallback<EventMap<S, H, P>[E]>,
            options?: ListenerOptions,
        ): Cleanup;
        on<E extends string>(
            event: E,
            listener: EventCallback<Record<E, any>>,
            options?: ListenerOptions,
        ): Cleanup;
        on(
            event: RegExp,
            options?: ListenerOptions,
        ): EventGenerator<EventMap<S, H, P>, RegExp>;
        on(
            event: RegExp,
            listener: EventCallback<RgxEmitData<EventMap<S, H, P>>>,
            options?: ListenerOptions,
        ): Cleanup;
        once<E extends keyof EventMap<S, H, P>>(
            event: E,
            options?: ListenerOptions,
        ): EventPromise<EventMap<S, H, P>[E]>;
        once<E extends string>(
            event: E,
            options?: ListenerOptions,
        ): EventPromise<Record<E, any>>;
        once<E extends keyof EventMap<S, H, P>>(
            event: E,
            listener: EventCallback<EventMap<S, H, P>[E]>,
            options?: ListenerOptions,
        ): Cleanup;
        once<E extends string>(
            event: E,
            listener: EventCallback<Record<E, any>>,
            options?: ListenerOptions,
        ): Cleanup;
        once(
            event: RegExp,
            options?: ListenerOptions,
        ): EventPromise<RgxEmitData<EventMap<S, H, P>>>;
        once(
            event: RegExp,
            listener: EventCallback<RgxEmitData<EventMap<S, H, P>>>,
            options?: ListenerOptions,
        ): Cleanup;
        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>;
        spy(spy: Spy<EventMap<S, H, P>>, force?: boolean): void;
    }

    Type Parameters

    • H = unknown

      Headers type

    • P = unknown

      Params type

    • S = unknown

      State type

    Hierarchy

    Implemented by

    Index

    Properties

    config headerStore hooks name paramStore state

    Methods

    $facts $has $internals clear debug emit observe off on once queue spy

    Properties

    config: ConfigStore<H, P, S>

    Options store for accessing all configuration.

    Single source of truth for ALL configuration. Supports deep path access via get('retry.maxAttempts') and runtime updates via set('baseUrl', newUrl).

    Fully typed with FetchEngine.Options<H, P, S>.

    headerStore: PropertyStore<DictAndT<H>>

    Property store for headers.

    Manages default headers, method-specific headers, and resolution.

    hooks: HookEngine<FetchLifecycle<H, P, S>>

    Hook engine for the request lifecycle pipeline.

    Plugins register beforeRequest/afterRequest hooks here. The executor runs these hooks around each request.

    name: string
    paramStore: PropertyStore<DictAndT<P>>

    Property store for URL parameters.

    Manages default params, method-specific params, and resolution.

    state: FetchState<S>

    State store for managing instance state.

    Provides get/set/reset operations with event emission.

    Methods

    • 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[];
      }

    • Returns if the observable instance has the given event

      Parameters

      Returns boolean

    • Returns if the observable instance has a regex event

      Parameters

      Returns boolean

    • Returns if the observable instance has the given event

      Parameters

      • event: string

      Returns boolean

    • 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;
      }

    • Returns 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

    • Emits an event

      Type Parameters

      Parameters

      Returns void

    • 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>>

      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

    • Stop listening for an event

      Parameters

      Returns void

    • Returns an event generator that will listen for the specified event

      Type Parameters

      Parameters

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

      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

    • Returns an event generator that will listen for the specified event

      Type Parameters

      • E extends string

      Parameters

      Returns EventGenerator<Record<E, any>>

      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

    • Listens for the specified event and executes the given callback

      Type Parameters

      Parameters

      Returns Cleanup

      const obs = new ObserverEngine();

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

    • Returns an event generator that will listen for the specified event

      Type Parameters

      • E extends string

      Parameters

      Returns Cleanup

      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

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

      Parameters

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

      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

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

      Parameters

      Returns Cleanup

      const obs = new ObserverEngine();

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

    • 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

    Settings

    Member Visibility

    On This Page

    Properties
    Methods