@monolayer/sdk 1.2.0-canary.4

package/dist/cjs/workloads/stateless/broadcast/client/app-sync-client.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * @module AppSyncEventsClient
+ * The main entry point for the AWS AppSync Events WebSocket client library.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BroadcastClient = void 0;
+const uuid_1 = require("uuid");
+const connectionManager_js_1 = require("./connectionManager.js");
+const eventEmitter_js_1 = require("./eventEmitter.js");
+const messageBuilder_js_1 = require("./messageBuilder.js");
+const subscriptionManager_js_1 = require("./subscriptionManager.js");
+/**
+ * A client for interacting with the AWS AppSync Events WebSocket API.
+ * This client handles connection management, authentication, and provides
+ * an interface for subscribing to and publishing events.
+ */
+class BroadcastClient {
+    /**
+     * Creates an instance of AppSyncEventsClient.
+     * @param url The WebSocket URL for the AWS AppSync Events API.
+     * @param authorization The authorization object required for the WebSocket connection.
+     */
+    constructor(opts) {
+        this.url = opts.url;
+        this.host = opts.host;
+        this.connectionManager = new connectionManager_js_1.ConnectionManager(this.url);
+        this.eventEmitter = new eventEmitter_js_1.EventEmitter();
+        this.subscriptionManager = new subscriptionManager_js_1.SubscriptionManager(this.connectionManager, this.eventEmitter);
+        this.connected = false;
+        // Register a handler for incoming messages from the ConnectionManager
+        this.connectionManager.onMessage((message) => {
+            switch (message.type) {
+                case "subscribe_error":
+                case "publish_error":
+                case "broadcast_error":
+                    this.eventEmitter.emit("error", message);
+                    break;
+                default:
+                    this.eventEmitter.emit("message", message);
+                    break;
+            }
+        });
+        // Register a handler for connection close events from the ConnectionManager
+        this.connectionManager.onClose(() => {
+            this.connected = false;
+            this.eventEmitter.emit("disconnected");
+        });
+    }
+    /**
+     * Establishes a connection to the AWS AppSync Events WebSocket API.
+     * @returns A Promise that resolves when the connection is successfully established.
+     */
+    async connect() {
+        await this.connectionManager.connect();
+        this.connected = true;
+        this.eventEmitter.emit("connected");
+    }
+    /**
+     * Disconnects from the AWS AppSync Events WebSocket API.
+     */
+    disconnect() {
+        this.connected = false;
+        this.connectionManager.disconnect();
+    }
+    /**
+     * Subscribes to a specified channel to receive real-time events.
+     * @param channel The channel path to subscribe to.
+     * @param authorization The authorization object for the subscription.
+     * @returns The ID of the created subscription.
+     */
+    subscribe(channel, authorization, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    callback) {
+        return this.subscriptionManager.subscribe(channel, authorization, callback); // Add a dummy callback
+    }
+    subscribeTo(channelName, params, callback) {
+        const path = channelName.replace(/\[([^\]]+)\]/g, (match, key) => {
+            return params[key] || match; // If key is not found, keep the placeholder
+        });
+        // Construct the final URL
+        return this.subscriptionManager.subscribe(`default${path}`, {
+            clientId: this.connectionManager.clientId,
+            host: this.host,
+            Authorization: "--",
+        }, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        callback); // Add a dummy callback
+        return;
+    }
+    /**
+     * Unsubscribes from a previously subscribed channel.
+     * @param subscriptionId The ID of the subscription to unsubscribe from.
+     */
+    unsubscribe(subscriptionId) {
+        this.subscriptionManager.unsubscribe(subscriptionId);
+    }
+    /**
+     * Publishes events to a specified channel.
+     * @param channel The channel path to publish to.
+     * @param events An array of stringified JSON events to be published.
+     * @param authorization The authorization object for the publish operation.
+     */
+    publish(channel, events, authorization) {
+        const id = (0, uuid_1.v4)();
+        const publishMessage = (0, messageBuilder_js_1.buildPublishMessage)(id, channel, events, authorization);
+        this.connectionManager.send(JSON.stringify(publishMessage));
+    }
+    /**
+     * Registers a listener for a specific event emitted by the client.
+     * @param eventName The name of the event to listen for (e.g., 'message', 'connected', 'disconnected').
+     * @param listener The callback function to be invoked when the event is emitted.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    on(eventName, listener) {
+        this.eventEmitter.on(eventName, listener);
+    }
+    /**
+     * Removes a registered listener for a specific event.
+     * @param eventName The name of the event to remove the listener from.
+     * @param listener The callback function to be removed.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    off(eventName, listener) {
+        this.eventEmitter.off(eventName, listener);
+    }
+}
+exports.BroadcastClient = BroadcastClient;

package/dist/cjs/workloads/stateless/broadcast/client/app-sync-publisher.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @module AppSyncEventsClient
+ * The main entry point for the AWS AppSync Events WebSocket client library.
+ */
+import type { ChannelData } from "../channel-data.js";
+import type { RouteParams, ValidateUniqueParams } from "../types.js";
+/**
+ * Configuration options for the BroadcastPublisher.
+ */
+export interface BroadcastPublisherConfig {
+    url: string;
+    authorization: object;
+}
+/**
+ * Publisher.
+ * Handles connection management, authentication, and provides
+ * an interface for publishing events.
+ */
+export declare class BroadcastPublisher<C extends Record<string, ChannelData<any>>> {
+    private _channels;
+    private connectionManager;
+    private eventEmitter;
+    constructor();
+    /**
+     * Establishes a connection to the AWS AppSync Events WebSocket API.
+     * @returns A Promise that resolves when the connection is successfully established.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnects from the AWS AppSync Events WebSocket API.
+     */
+    disconnect(): void;
+    publishTo<T extends keyof C & string>(channelName: ValidateUniqueParams<T>, params: RouteParams<T>, data: C[T] extends ChannelData<infer P> ? P[] : never): Promise<boolean>;
+}

package/dist/cjs/workloads/stateless/broadcast/client/app-sync-publisher.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * @module AppSyncEventsClient
+ * The main entry point for the AWS AppSync Events WebSocket client library.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BroadcastPublisher = void 0;
+const uuid_1 = require("uuid");
+const connectionManager_js_1 = require("./connectionManager.js");
+const eventEmitter_js_1 = require("./eventEmitter.js");
+const messageBuilder_js_1 = require("./messageBuilder.js");
+/**
+ * Publisher.
+ * Handles connection management, authentication, and provides
+ * an interface for publishing events.
+ */
+class BroadcastPublisher {
+    constructor() {
+        const urlFromEnv = process.env.ML_BROADCAST_URL ?? "ws://localhost:9311";
+        this.connectionManager = new connectionManager_js_1.ConnectionManager(urlFromEnv);
+        this.eventEmitter = new eventEmitter_js_1.EventEmitter();
+        // Register a handler for incoming messages from the ConnectionManager
+        this.connectionManager.onMessage((message) => {
+            switch (message.type) {
+                case "subscribe_error":
+                case "publish_error":
+                case "broadcast_error":
+                    this.eventEmitter.emit("error", message);
+                    break;
+                default:
+                    this.eventEmitter.emit("message", message);
+                    break;
+            }
+        });
+        // Register a handler for connection close events from the ConnectionManager
+        this.connectionManager.onClose(() => {
+            this.eventEmitter.emit("disconnected");
+        });
+    }
+    /**
+     * Establishes a connection to the AWS AppSync Events WebSocket API.
+     * @returns A Promise that resolves when the connection is successfully established.
+     */
+    async connect() {
+        await this.connectionManager.connect();
+        this.eventEmitter.emit("connected");
+    }
+    /**
+     * Disconnects from the AWS AppSync Events WebSocket API.
+     */
+    disconnect() {
+        this.connectionManager.disconnect();
+    }
+    async publishTo(channelName, params, data) {
+        try {
+            const path = channelName.replace(/\[([^\]]+)\]/g, (match, key) => {
+                return params[key] || match; // If key is not found, keep the placeholder
+            });
+            await this.connect();
+            for (const payload of data) {
+                const events = JSON.stringify(payload);
+                const publishMessage = (0, messageBuilder_js_1.buildPublishMessage)((0, uuid_1.v4)(), `default${path}`, [events], {
+                    clientId: this.connectionManager.clientId,
+                    host: process.env.ML_BROADCAST_HOST ?? "localhost",
+                    Authorization: "--",
+                });
+                this.connectionManager.send(JSON.stringify(publishMessage));
+            }
+            this.disconnect();
+        }
+        catch (e) {
+            console.error(e);
+            return false;
+        }
+        return true;
+    }
+}
+exports.BroadcastPublisher = BroadcastPublisher;

package/dist/cjs/workloads/stateless/broadcast/client/authenticator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @module authenticator
+ * This module provides functions for handling the specific authentication
+ * handshake required by the AWS AppSync Events WebSocket protocol.
+ */
+/**
+ * Encodes a JSON authorization object into a Base64URL string.
+ *
+ * The AWS AppSync WebSocket protocol requires authorization credentials to be
+ * passed in a custom subprotocol header. This function takes the authorization
+ * object, stringifies it, and then encodes it into a URL-safe Base64 format
+ * by replacing `+` with `-`, `/` with `_`, and removing padding.
+ *
+ * @param authorization The authorization object to encode.
+ * @returns A Base64URL encoded string representing the authorization object.
+ */
+export declare function encodeAuthorization(authorization: object): string;
+/**
+ * Generates the full WebSocket subprotocol string for authorization.
+ *
+ * This function takes an authorization object, encodes it using `encodeAuthorization`,
+ * and then prepends the `header-` prefix as required by the AWS AppSync Events
+ * WebSocket protocol for the subprotocol header.
+ *
+ * @param authorization The authorization object to use for generating the protocol string.
+ * @returns The complete authorization subprotocol string (e.g., `header-encodedAuthString`).
+ */
+export declare function getAuthProtocol(authorization: object): string;

package/dist/cjs/workloads/stateless/broadcast/client/authenticator.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * @module authenticator
+ * This module provides functions for handling the specific authentication
+ * handshake required by the AWS AppSync Events WebSocket protocol.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeAuthorization = encodeAuthorization;
+exports.getAuthProtocol = getAuthProtocol;
+/**
+ * Encodes a JSON authorization object into a Base64URL string.
+ *
+ * The AWS AppSync WebSocket protocol requires authorization credentials to be
+ * passed in a custom subprotocol header. This function takes the authorization
+ * object, stringifies it, and then encodes it into a URL-safe Base64 format
+ * by replacing `+` with `-`, `/` with `_`, and removing padding.
+ *
+ * @param authorization The authorization object to encode.
+ * @returns A Base64URL encoded string representing the authorization object.
+ */
+function encodeAuthorization(authorization) {
+    const jsonString = JSON.stringify(authorization);
+    // Note: Using the browser's btoa function for simplicity. In a Node.js
+    // environment, this would be replaced with Buffer.from(str).toString('base64').
+    // However, for the purpose of this library, we assume a browser-like environment
+    // or a polyfill for btoa.
+    const base64 = btoa(jsonString);
+    return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+/**
+ * Generates the full WebSocket subprotocol string for authorization.
+ *
+ * This function takes an authorization object, encodes it using `encodeAuthorization`,
+ * and then prepends the `header-` prefix as required by the AWS AppSync Events
+ * WebSocket protocol for the subprotocol header.
+ *
+ * @param authorization The authorization object to use for generating the protocol string.
+ * @returns The complete authorization subprotocol string (e.g., `header-encodedAuthString`).
+ */
+function getAuthProtocol(authorization) {
+    const encodedHeader = encodeAuthorization(authorization);
+    return `header-${encodedHeader}`;
+}

package/dist/cjs/workloads/stateless/broadcast/client/broadcast-provider.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from "react";
+import type { ChannelData } from "../../../../workloads/stateless/broadcast/channel-data.js";
+import { BroadcastClient } from "./app-sync-client.js";
+export type BroadcastContext = {
+    ws: BroadcastClient<any>;
+    connected: boolean;
+} | null;
+export declare const BroadcastProvider: import("react").Context<BroadcastContext>;
+export interface BroadcastContextProviderProps {
+    urlAndHost: {
+        url: string;
+        host: string;
+    };
+    children: ReactNode;
+}
+export declare function BroadcastContextProvider({ urlAndHost, children, }: BroadcastContextProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useWebSocket<T extends Record<string, ChannelData<any>>>(): BroadcastClient<T>;

package/dist/cjs/workloads/stateless/broadcast/client/broadcast-provider.js

@@ -0,0 +1,34 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BroadcastProvider = void 0;
+exports.BroadcastContextProvider = BroadcastContextProvider;
+exports.useWebSocket = useWebSocket;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const app_sync_client_js_1 = require("./app-sync-client.js");
+exports.BroadcastProvider = (0, react_1.createContext)(null);
+function BroadcastContextProvider({ urlAndHost, children, }) {
+    const [ws] = (0, react_1.useState)((0, react_1.useMemo)(() => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new app_sync_client_js_1.BroadcastClient(urlAndHost);
+    }, [urlAndHost]));
+    const [connected, setConnected] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        async function connect() {
+            await ws.connect();
+            ws.connected = true;
+            setConnected(true);
+        }
+        connect().catch(console.error);
+        return () => ws.disconnect();
+    }, [ws]);
+    return ((0, jsx_runtime_1.jsx)(exports.BroadcastProvider.Provider, { value: { ws, connected }, children: children }));
+}
+function useWebSocket() {
+    const context = (0, react_1.use)(exports.BroadcastProvider);
+    if (!context) {
+        throw new Error("useWebSockets must be used within a <BroadcastProvider />");
+    }
+    return context.ws;
+}

package/dist/cjs/workloads/stateless/broadcast/client/client.d.ts

@@ -0,0 +1,8 @@
+import type { ChannelData } from "../../../../workloads/stateless/broadcast/channel-data.js";
+import type { RouteParams } from "../../../../workloads/stateless/broadcast/types.js";
+export declare function broadcastClient<C extends Record<string, ChannelData<any>>>(): {
+    useSubscription: <D extends keyof C & string>(channel: D, params: RouteParams<D>) => {
+        last: (D extends string ? C[D] extends ChannelData<infer P> ? P : never : never) | null;
+        all: (D extends string ? C[D] extends ChannelData<infer P> ? P : never : never)[];
+    };
+};

package/dist/cjs/workloads/stateless/broadcast/client/client.js

@@ -0,0 +1,28 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.broadcastClient = broadcastClient;
+const react_1 = require("react");
+const broadcast_provider_js_1 = require("../../../../workloads/stateless/broadcast/client/broadcast-provider.js");
+function broadcastClient() {
+    const useSubscription = (channel, params) => {
+        const [last, setLast] = (0, react_1.useState)(null);
+        const [all, setAll] = (0, react_1.useReducer)((prevItems, newItem) => {
+            return prevItems.concat(newItem);
+        }, []);
+        const [subscribe, setSubscribed] = (0, react_1.useState)(false);
+        const client = (0, broadcast_provider_js_1.useWebSocket)();
+        (0, react_1.useEffect)(() => {
+            if (client.connected && !subscribe) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                client.subscribeTo(channel, params, (payload) => {
+                    setLast(payload);
+                    setAll(payload);
+                });
+                setSubscribed(true);
+            }
+        }, [client, channel, params, subscribe]);
+        return { last, all };
+    };
+    return { useSubscription };
+}

package/dist/cjs/workloads/stateless/broadcast/client/connectionManager.d.ts

@@ -0,0 +1,62 @@
+import type { AppSyncWebSocketMessage } from "./types.js";
+/**
+ * @module ConnectionManager
+ * Manages the WebSocket connection lifecycle with the AWS AppSync Events API.
+ */
+type MessageHandler = (message: AppSyncWebSocketMessage) => void;
+type CloseHandler = (event: CloseEvent) => void;
+/**
+ * Manages the WebSocket connection to the AWS AppSync Events API.
+ * Handles connection establishment, sending initial messages, and receiving acknowledgments.
+ */
+export declare class ConnectionManager {
+    ws: WebSocket | null;
+    private readonly url;
+    private connectionTimeoutMs;
+    private keepAliveTimer;
+    private connectPromiseResolve;
+    private connectPromiseReject;
+    private messageHandler;
+    private closeHandler;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private maxReconnectDelay;
+    private _clientId?;
+    /**
+     * Creates an instance of ConnectionManager.
+     * @param url The WebSocket URL for the AWS AppSync Events API.
+     */
+    constructor(url: string);
+    clientId(): string | undefined;
+    /**
+     * Establishes a WebSocket connection to the AWS AppSync Events API.
+     * @returns A Promise that resolves when the connection is successfully established and acknowledged.
+     */
+    connect(): Promise<void>;
+    /**
+     * Registers a handler for incoming WebSocket messages.
+     * @param handler The function to call when a new message is received.
+     */
+    onMessage(handler: MessageHandler): void;
+    /**
+     * Registers a handler for WebSocket close events.
+     * @param handler The function to call when the WebSocket connection is closed.
+     */
+    onClose(handler: CloseHandler): void;
+    /**
+     * Sends a message over the WebSocket connection.
+     * @param message The message string to send.
+     */
+    send(message: string): void;
+    /**
+     * Closes the WebSocket connection gracefully.
+     * This method clears any active keep-alive timers and closes the underlying WebSocket.
+     */
+    disconnect(): void;
+    private reconnect;
+    private startKeepAliveTimer;
+    private resetKeepAliveTimer;
+    private clearKeepAliveTimer;
+}
+export {};

package/dist/cjs/workloads/stateless/broadcast/client/connectionManager.js

@@ -0,0 +1,166 @@
+"use strict";
+/// <reference lib="dom" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionManager = void 0;
+const uuid_1 = require("uuid");
+const authenticator_js_1 = require("./authenticator.js");
+const parser_js_1 = require("./parser.js");
+/**
+ * Manages the WebSocket connection to the AWS AppSync Events API.
+ * Handles connection establishment, sending initial messages, and receiving acknowledgments.
+ */
+class ConnectionManager {
+    /**
+     * Creates an instance of ConnectionManager.
+     * @param url The WebSocket URL for the AWS AppSync Events API.
+     */
+    constructor(url) {
+        this.ws = null;
+        this.connectionTimeoutMs = 0;
+        this.keepAliveTimer = null;
+        this.connectPromiseResolve = null;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.connectPromiseReject = null;
+        this.messageHandler = null;
+        this.closeHandler = null;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 10;
+        this.reconnectDelay = 1000; // 1 second
+        this.maxReconnectDelay = 30000; // 30 seconds
+        this.url = url;
+    }
+    clientId() {
+        return this._clientId;
+    }
+    /**
+     * Establishes a WebSocket connection to the AWS AppSync Events API.
+     * @returns A Promise that resolves when the connection is successfully established and acknowledged.
+     */
+    connect() {
+        return new Promise((resolve, reject) => {
+            this.connectPromiseResolve = resolve;
+            this.connectPromiseReject = reject;
+            this._clientId = (0, uuid_1.v4)();
+            this.ws = new WebSocket(this.url, [
+                "aws-appsync-event-ws",
+                (0, authenticator_js_1.getAuthProtocol)({
+                    clientId: this._clientId,
+                    host: "",
+                    Authorization: "",
+                }),
+            ]);
+            this.ws.onopen = () => {
+                this.reconnectAttempts = 0;
+                this.ws?.send(JSON.stringify({ type: "connection_init" }));
+            };
+            this.ws.onmessage = (event) => {
+                const message = (0, parser_js_1.parseMessage)(event.data);
+                switch (message.type) {
+                    case "connection_ack":
+                        this.connectionTimeoutMs = message.connectionTimeoutMs;
+                        this.startKeepAliveTimer();
+                        this.connectPromiseResolve?.();
+                        break;
+                    case "ka":
+                        this.resetKeepAliveTimer();
+                        break;
+                    default:
+                        // Pass other messages to the registered handler
+                        if (this.messageHandler) {
+                            this.messageHandler(message);
+                        }
+                        break;
+                }
+            };
+            this.ws.onerror = (error) => {
+                this.clearKeepAliveTimer();
+                this.connectPromiseReject?.(error);
+            };
+            this.ws.onclose = (event) => {
+                this.clearKeepAliveTimer();
+                if (!event.wasClean) {
+                    // Attempt to reconnect if the closure was not clean
+                    this.reconnect();
+                }
+                else {
+                    this.connectPromiseReject?.(new Error(`WebSocket closed unexpectedly: ${event.code} - ${event.reason}`));
+                }
+                // Call the registered close handler
+                if (this.closeHandler) {
+                    this.closeHandler(event);
+                }
+            };
+        });
+    }
+    /**
+     * Registers a handler for incoming WebSocket messages.
+     * @param handler The function to call when a new message is received.
+     */
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    /**
+     * Registers a handler for WebSocket close events.
+     * @param handler The function to call when the WebSocket connection is closed.
+     */
+    onClose(handler) {
+        this.closeHandler = handler;
+    }
+    /**
+     * Sends a message over the WebSocket connection.
+     * @param message The message string to send.
+     */
+    send(message) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(message);
+        }
+        else {
+            console.warn("WebSocket is not open. Message not sent.", message);
+        }
+    }
+    /**
+     * Closes the WebSocket connection gracefully.
+     * This method clears any active keep-alive timers and closes the underlying WebSocket.
+     */
+    disconnect() {
+        this.clearKeepAliveTimer();
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+            this._clientId = "";
+        }
+    }
+    reconnect() {
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+            this.reconnectAttempts++;
+            const delay = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1), this.maxReconnectDelay);
+            console.log(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})...`);
+            setTimeout(() => {
+                // Re-call connect to attempt reconnection
+                this.connect();
+            }, delay);
+        }
+        else {
+            console.error("Max reconnect attempts reached. Connection permanently lost.");
+            this.connectPromiseReject?.(new Error("Max reconnect attempts reached"));
+        }
+    }
+    startKeepAliveTimer() {
+        this.clearKeepAliveTimer();
+        this.keepAliveTimer = setTimeout(() => {
+            // If timer expires, no keep-alive message received
+            this.ws?.close();
+            this.connectPromiseReject?.(new Error("WebSocket closed due to keep-alive timeout"));
+        }, this.connectionTimeoutMs);
+    }
+    resetKeepAliveTimer() {
+        this.startKeepAliveTimer(); // Simply restart the timer
+    }
+    clearKeepAliveTimer() {
+        if (this.keepAliveTimer) {
+            clearTimeout(this.keepAliveTimer);
+            this.keepAliveTimer = null;
+        }
+    }
+}
+exports.ConnectionManager = ConnectionManager;

package/dist/cjs/workloads/stateless/broadcast/client/eventEmitter.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module EventEmitter
+ * Implements a simple event emitter pattern for handling custom events.
+ */
+type Listener = (...args: any[]) => void;
+/**
+ * A simple event emitter class that allows for subscribing to, unsubscribing from,
+ * and emitting custom events.
+ */
+export declare class EventEmitter {
+    private listeners;
+    constructor();
+    /**
+     * Registers a new listener for a specified event.
+     * @param eventName The name of the event to listen for.
+     * @param listener The callback function to be invoked when the event is emitted.
+     */
+    on(eventName: string, listener: Listener): void;
+    /**
+     * Removes a registered listener for a specified event.
+     * @param eventName The name of the event to remove the listener from.
+     * @param listener The callback function to be removed.
+     */
+    off(eventName: string, listener: Listener): void;
+    /**
+     * Emits an event, invoking all registered listeners for that event.
+     * @param eventName The name of the event to emit.
+     * @param args Any arguments to pass to the listeners.
+     */
+    emit(eventName: string, ...args: any[]): void;
+}
+export {};