@elevasis/ui 1.0.0

package/dist/sse/index.d.ts

@@ -0,0 +1,83 @@
+interface EventSourceMessage {
+    id: string;
+    event: string;
+    data: string;
+    retry?: number;
+}
+
+interface FetchEventSourceWithTokenRefreshOptions {
+    url: string;
+    getToken: () => Promise<string | undefined>;
+    headers?: Record<string, string>;
+    signal: AbortSignal;
+    /** Delay in ms before reconnecting after token refresh. Defaults to 2000. */
+    tokenRefreshDelayMs?: number;
+    onopen?: (response: Response) => void | Promise<void>;
+    onmessage?: (event: EventSourceMessage) => void;
+    onerror?: (error: unknown) => void;
+    onclose?: () => void;
+}
+/**
+ * Wrapper around fetchEventSource that handles token expiration and automatic retry with fresh token.
+ *
+ * When a 401 response is received:
+ * 1. Aborts current connection
+ * 2. Waits for tokenRefreshDelayMs (default 2s)
+ * 3. Fetches fresh token
+ * 4. Reconnects with new token
+ */
+declare function fetchEventSourceWithTokenRefresh(options: FetchEventSourceWithTokenRefreshOptions): Promise<void>;
+
+interface SSEConnectionManagerOptions {
+    /** Grace period in ms before closing idle connections. Defaults to 5000. */
+    closeGracePeriodMs?: number;
+}
+/**
+ * SSE Connection Manager
+ *
+ * Ensures only ONE SSE connection exists per endpoint, preventing duplicate
+ * connections when components re-render or remount.
+ *
+ * Benefits:
+ * - Prevents resource waste from duplicate connections
+ * - Eliminates race conditions from overlapping connections
+ * - Automatically manages connection lifecycle
+ * - Shares single connection across multiple subscribers
+ */
+declare class SSEConnectionManager {
+    private connections;
+    private closeGracePeriodMs;
+    constructor(options?: SSEConnectionManagerOptions);
+    /**
+     * Subscribe to an SSE endpoint
+     *
+     * If a connection already exists for this endpoint, reuses it.
+     * Otherwise, creates a new connection.
+     *
+     * @param key - Unique identifier for the connection (e.g., 'notifications', 'resource-executive-agent')
+     * @param subscriberId - Unique identifier for this subscriber (usually component instance)
+     * @param options - SSE connection options
+     * @returns Unsubscribe function to call when component unmounts
+     */
+    subscribe(key: string, subscriberId: string, options: Omit<FetchEventSourceWithTokenRefreshOptions, 'signal'>): () => void;
+    /**
+     * Unsubscribe from an SSE endpoint
+     *
+     * If this is the last subscriber, closes the connection after grace period.
+     */
+    private unsubscribe;
+    /**
+     * Force close a connection and all its subscribers
+     */
+    closeConnection(key: string): void;
+    /**
+     * Get current connection status
+     */
+    getConnectionInfo(): Map<string, {
+        url: string;
+        subscribers: number;
+    }>;
+}
+
+export { SSEConnectionManager, fetchEventSourceWithTokenRefresh };
+export type { FetchEventSourceWithTokenRefreshOptions, SSEConnectionManagerOptions };

package/dist/sse/index.js

@@ -0,0 +1,185 @@
+import { fetchEventSource } from '@microsoft/fetch-event-source';
+
+// src/sse/fetchEventSourceWithTokenRefresh.ts
+async function fetchEventSourceWithTokenRefresh(options) {
+  const {
+    url,
+    getToken,
+    headers: additionalHeaders,
+    signal,
+    tokenRefreshDelayMs = 2e3,
+    onopen,
+    onmessage,
+    onerror,
+    onclose
+  } = options;
+  let reconnectTimeout = null;
+  let isActive = true;
+  let controller = new AbortController();
+  let shouldReconnect = false;
+  let hasConnected = false;
+  const cleanup = () => {
+    isActive = false;
+    shouldReconnect = false;
+    controller.abort();
+    if (reconnectTimeout) {
+      clearTimeout(reconnectTimeout);
+      reconnectTimeout = null;
+    }
+  };
+  signal.addEventListener("abort", cleanup);
+  const connect = async () => {
+    if (!isActive || signal.aborted) {
+      return;
+    }
+    shouldReconnect = false;
+    const token = await getToken();
+    const headers = {
+      ...token ? { Authorization: `Bearer ${token}` } : {},
+      ...additionalHeaders
+    };
+    try {
+      await fetchEventSource(url, {
+        method: "GET",
+        headers,
+        signal: controller.signal,
+        async onopen(response) {
+          if (response.ok && response.headers.get("content-type")?.includes("text/event-stream")) {
+            if (!hasConnected) {
+              hasConnected = true;
+            }
+            if (onopen) {
+              await onopen(response);
+            }
+            return;
+          }
+          if (response.status === 401) {
+            shouldReconnect = true;
+            hasConnected = false;
+            controller.abort();
+            return;
+          }
+          throw new Error(`Unexpected response: ${response.status}`);
+        },
+        onmessage(event) {
+          onmessage?.(event);
+        },
+        onerror(error) {
+          if (error instanceof Error && error.name === "AbortError") {
+            throw error;
+          }
+          onerror?.(error);
+        },
+        onclose() {
+          onclose?.();
+        }
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError" && shouldReconnect) {
+        if (isActive && !reconnectTimeout && !signal.aborted) {
+          reconnectTimeout = setTimeout(() => {
+            controller = new AbortController();
+            reconnectTimeout = null;
+            connect();
+          }, tokenRefreshDelayMs);
+        }
+        return;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        return;
+      }
+      throw error;
+    }
+  };
+  await connect();
+}
+
+// src/sse/SSEConnectionManager.ts
+var SSEConnectionManager = class {
+  connections = /* @__PURE__ */ new Map();
+  closeGracePeriodMs;
+  constructor(options = {}) {
+    this.closeGracePeriodMs = options.closeGracePeriodMs ?? 5e3;
+  }
+  /**
+   * Subscribe to an SSE endpoint
+   *
+   * If a connection already exists for this endpoint, reuses it.
+   * Otherwise, creates a new connection.
+   *
+   * @param key - Unique identifier for the connection (e.g., 'notifications', 'resource-executive-agent')
+   * @param subscriberId - Unique identifier for this subscriber (usually component instance)
+   * @param options - SSE connection options
+   * @returns Unsubscribe function to call when component unmounts
+   */
+  subscribe(key, subscriberId, options) {
+    const existing = this.connections.get(key);
+    if (existing) {
+      if (existing.closeTimeout) {
+        clearTimeout(existing.closeTimeout);
+        existing.closeTimeout = void 0;
+      }
+      existing.subscribers.add(subscriberId);
+    } else {
+      const controller = new AbortController();
+      this.connections.set(key, {
+        controller,
+        subscribers: /* @__PURE__ */ new Set([subscriberId]),
+        url: options.url
+      });
+      fetchEventSourceWithTokenRefresh({
+        ...options,
+        signal: controller.signal
+      });
+    }
+    return () => this.unsubscribe(key, subscriberId);
+  }
+  /**
+   * Unsubscribe from an SSE endpoint
+   *
+   * If this is the last subscriber, closes the connection after grace period.
+   */
+  unsubscribe(key, subscriberId) {
+    const connection = this.connections.get(key);
+    if (!connection) {
+      return;
+    }
+    connection.subscribers.delete(subscriberId);
+    if (connection.subscribers.size === 0 && !connection.closeTimeout) {
+      connection.closeTimeout = setTimeout(() => {
+        const current = this.connections.get(key);
+        if (current && current.subscribers.size === 0) {
+          this.closeConnection(key);
+        }
+      }, this.closeGracePeriodMs);
+    }
+  }
+  /**
+   * Force close a connection and all its subscribers
+   */
+  closeConnection(key) {
+    const connection = this.connections.get(key);
+    if (connection) {
+      if (connection.closeTimeout) {
+        clearTimeout(connection.closeTimeout);
+      }
+      connection.controller.abort();
+      this.connections.delete(key);
+    }
+  }
+  /**
+   * Get current connection status
+   */
+  getConnectionInfo() {
+    const info = /* @__PURE__ */ new Map();
+    this.connections.forEach((connection, key) => {
+      info.set(key, {
+        url: connection.url,
+        subscribers: connection.subscribers.size
+      });
+    });
+    return info;
+  }
+};
+
+export { SSEConnectionManager, fetchEventSourceWithTokenRefresh };