sveltekit-eventsource - v1.0.0
    Preparing search index...

    Class EventSource<S>

    Server-side SSE stream helper for SvelteKit endpoints.

    This class creates a Response streaming text/event-stream data and provides a typed emit method for sending application events based on App.Events.

    It also implements a small control protocol (magic events) used for server-requested termination via stop. Control messages MUST be decodable regardless of any user-defined serializer/deserializer.

    // routes/sse/+server.ts
    import type { RequestHandler } from "./$types";
    import { EventSource } from "$lib/server/index.js";

    export const GET: RequestHandler = () => {
      const sse = new EventSource("status");
      sse.emit("heartbeat", Date.now());
      return sse.response();
    };

    Type Parameters

    • S extends keyof App.Events = keyof App.Events

      Stream name (key of App.Events)

    Index

    Constructors

    constructor

    Properties

    off on once unsafe

    Accessors

    isOpen name

    Methods

    emit response stop

    Constructors

    • Create a new server-side SSE stream helper.

      Type Parameters

      • S extends "status" = "status"

        Stream name (key of App.Events)

      Parameters

      • name: S

        Stream name (key of App.Events) used for typing and debug output.

      • cfg: Omit<SSEConfiguration<S>, "name"> = {}

        Optional configuration (serializer, ping/retry intervals, debug logger).

      Returns EventSource<S>

    Properties

    off: <E extends string | symbol>(
        eventName: "close" | "open" | "ping" | (keyof EventEmitterEventMap) | E,
        listener: (
            ...args: E extends keyof EventSourceEventMap
                ? EventSourceEventMap[E<E>]
                : E extends keyof EventEmitterEventMap
                    ? EventEmitterEventMap[E<E>]
                    : any[],
        ) => void,
    ) => this = ...

    Unsubscribe from lifecycle events from unsafe.events.

    Type Declaration

      • <E extends string | symbol>(
            eventName: "close" | "open" | "ping" | (keyof EventEmitterEventMap) | E,
            listener: (
                ...args: E extends keyof EventSourceEventMap
                    ? EventSourceEventMap[E<E>]
                    : E extends keyof EventEmitterEventMap
                        ? EventEmitterEventMap[E<E>]
                        : any[],
            ) => void,
        ): this

      • Alias for emitter.removeListener().

        Type Parameters

        • E extends string | symbol

        Parameters

        • eventName: "close" | "open" | "ping" | (keyof EventEmitterEventMap) | E
        • listener: (
              ...args: E extends keyof EventSourceEventMap
                  ? EventSourceEventMap[E<E>]
                  : E extends keyof EventEmitterEventMap
                      ? EventEmitterEventMap[E<E>]
                      : any[],
          ) => void

        Returns this

        v10.0.0

    on: <E extends string | symbol>(
        eventName: "close" | "open" | "ping" | E | (keyof EventEmitterEventMap),
        listener: (
            ...args: E extends keyof EventSourceEventMap
                ? EventSourceEventMap[E<E>]
                : E extends keyof EventEmitterEventMap
                    ? EventEmitterEventMap[E<E>]
                    : any[],
        ) => void,
    ) => this = ...

    Subscribe to lifecycle events from unsafe.events.

    Type Declaration

      • <E extends string | symbol>(
            eventName: "close" | "open" | "ping" | E | (keyof EventEmitterEventMap),
            listener: (
                ...args: E extends keyof EventSourceEventMap
                    ? EventSourceEventMap[E<E>]
                    : E extends keyof EventEmitterEventMap
                        ? EventEmitterEventMap[E<E>]
                        : any[],
            ) => void,
        ): this

      • Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

        server.on('connection', (stream) => {
          console.log('someone connected!');
        });

        Returns a reference to the EventEmitter, so that calls can be chained.

        By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

        import { EventEmitter } from 'node:events';
        const myEE = new EventEmitter();
        myEE.on('foo', () => console.log('a'));
        myEE.prependListener('foo', () => console.log('b'));
        myEE.emit('foo');
        // Prints:
        //   b
        //   a

        Type Parameters

        • E extends string | symbol

        Parameters

        • eventName: "close" | "open" | "ping" | E | (keyof EventEmitterEventMap)

          The name of the event.

        • listener: (
              ...args: E extends keyof EventSourceEventMap
                  ? EventSourceEventMap[E<E>]
                  : E extends keyof EventEmitterEventMap
                      ? EventEmitterEventMap[E<E>]
                      : any[],
          ) => void

          The callback function

        Returns this

        v0.1.101

    once: <E extends string | symbol>(
        eventName: "close" | "open" | "ping" | (keyof EventEmitterEventMap) | E,
        listener: (
            ...args: E extends keyof EventSourceEventMap
                ? EventSourceEventMap[E<E>]
                : E extends keyof EventEmitterEventMap
                    ? EventEmitterEventMap[E<E>]
                    : any[],
        ) => void,
    ) => this = ...

    Subscribe once to lifecycle events from unsafe.events.

    Type Declaration

      • <E extends string | symbol>(
            eventName: "close" | "open" | "ping" | (keyof EventEmitterEventMap) | E,
            listener: (
                ...args: E extends keyof EventSourceEventMap
                    ? EventSourceEventMap[E<E>]
                    : E extends keyof EventEmitterEventMap
                        ? EventEmitterEventMap[E<E>]
                        : any[],
            ) => void,
        ): this

      • Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

        server.once('connection', (stream) => {
          console.log('Ah, we have our first user!');
        });

        Returns a reference to the EventEmitter, so that calls can be chained.

        By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

        import { EventEmitter } from 'node:events';
        const myEE = new EventEmitter();
        myEE.once('foo', () => console.log('a'));
        myEE.prependOnceListener('foo', () => console.log('b'));
        myEE.emit('foo');
        // Prints:
        //   b
        //   a

        Type Parameters

        • E extends string | symbol

        Parameters

        • eventName: "close" | "open" | "ping" | (keyof EventEmitterEventMap) | E

          The name of the event.

        • listener: (
              ...args: E extends keyof EventSourceEventMap
                  ? EventSourceEventMap[E<E>]
                  : E extends keyof EventEmitterEventMap
                      ? EventEmitterEventMap[E<E>]
                      : any[],
          ) => void

          The callback function

        Returns this

        v0.3.0

    unsafe: {
        events: EventEmitter<EventSourceEventMap>;
        send: (
            data: any,
            options?: Partial<{ event: string; id: number }>,
        ) => boolean;
    } = ...

    Advanced/unsafe APIs.

    Use these only if you know SSE formatting rules and accept losing type safety.

    Type Declaration

    • events: EventEmitter<EventSourceEventMap>

      Lifecycle events (open, close, ping) for the SSE stream.

    • send: (data: any, options?: Partial<{ event: string; id: number }>) => boolean

      Send an arbitrary SSE message.

    Accessors

    • get isOpen(): boolean

      Whether the stream is currently open and writable.

      Note: This becomes false when the client disconnects (stream cancel).

      Returns boolean

    Methods

    • Emit an application event to the client.

      The event name is taken from App.Events[S] and payload is typed accordingly.

      Type Parameters

      • E extends string | number | symbol

      Parameters

      • event: E

        Application event name (key of App.Events[S]).

      • message: Events[S][E] | Events[S][E][]

        Payload, or an array of payloads (each element becomes a data: line).

      • Optionalid: number

        Optional SSE event id.

      Returns boolean

      true if written; false if the stream is not open.

    • Create a SvelteKit Response that streams Server-Sent Events.

      Parameters

      • Optionalinit: ResponseInit

        Optional ResponseInit to merge headers/status.

      Returns Response

      A Response with Content-Type: text/event-stream.

      • When the client disconnects, the stream cancel callback fires and lifecycle close is emitted.
      • This method is intended to be called once per request.

    • Request the client to close the connection.

      This method emits a protocol-level "magic" message over the SSE stream.

      IMPORTANT:

      • This bypasses any user serializer.
      • The payload is always protocol JSON created by encodeMagicMessage.

      Returns boolean

      true if the magic close request was written; false if stream is not open.

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Accessors
    Methods