@dotwire/client 0.0.0-stage → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,785 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DotwireClient: () => DotwireClient,
+  DotwireClientError: () => DotwireClientError,
+  DotwireRoomHandle: () => DotwireRoomHandle,
+  isSystemSender: () => isSystemSender,
+  toDotwireClientError: () => toDotwireClientError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+function isSystemSender(senderId) {
+  if (!senderId) return false;
+  const lower = senderId.toLowerCase();
+  return lower === "system" || lower.startsWith("system:") || lower.startsWith("bot:");
+}
+
+// src/errors.ts
+var DotwireClientError = class extends Error {
+  status;
+  kind;
+  code;
+  reason;
+  retryAfterMs;
+  constructor(init) {
+    super(init.reason ?? init.code ?? `dotwire request failed with status ${init.status}`);
+    this.name = "DotwireClientError";
+    this.status = init.status;
+    this.kind = init.kind;
+    this.code = init.code;
+    this.reason = init.reason;
+    this.retryAfterMs = init.retryAfterMs;
+  }
+};
+async function toDotwireClientError(response) {
+  const status = response.status;
+  let code;
+  let reason;
+  try {
+    const body = await response.json();
+    if (body && typeof body === "object") {
+      const record = body;
+      if (typeof record.error === "string") code = record.error;
+      if (typeof record.reason === "string") reason = record.reason;
+    }
+  } catch {
+  }
+  let retryAfterMs;
+  const retryAfterHeader = response.headers?.get?.("Retry-After");
+  if (retryAfterHeader) {
+    const seconds = Number(retryAfterHeader);
+    if (!Number.isNaN(seconds)) {
+      retryAfterMs = seconds * 1e3;
+    }
+  }
+  return new DotwireClientError({ status, kind: classifyKind(status, code), code, reason, retryAfterMs });
+}
+function classifyKind(status, code) {
+  switch (status) {
+    case 400:
+      return "BadRequest";
+    case 401:
+      return "Unauthorized";
+    case 403:
+      return "Forbidden";
+    case 404:
+      return "NotFound";
+    case 422:
+      return code === "presend_rejected" ? "PresendRejected" : "BadRequest";
+    case 429:
+      return "RateLimited";
+    case 503:
+      return "Unavailable";
+    default:
+      return "Unknown";
+  }
+}
+
+// src/client.ts
+var import_signalr = require("@microsoft/signalr");
+
+// src/seq-set.ts
+var BoundedSeqSet = class {
+  constructor(capacity = 1e3) {
+    this.capacity = capacity;
+  }
+  capacity;
+  seen = /* @__PURE__ */ new Set();
+  has(seq) {
+    return this.seen.has(seq);
+  }
+  add(seq) {
+    if (this.seen.has(seq)) return;
+    this.seen.add(seq);
+    if (this.seen.size > this.capacity) {
+      const oldest = this.seen.values().next().value;
+      if (oldest !== void 0) {
+        this.seen.delete(oldest);
+      }
+    }
+  }
+};
+
+// src/room.ts
+var DotwireRoomHandle = class {
+  constructor(roomId, client) {
+    this.roomId = roomId;
+    this.client = client;
+  }
+  roomId;
+  client;
+  autoStopTypingTimer = null;
+  lastTypingSentAt = 0;
+  isCurrentlyTyping = false;
+  listeners = [];
+  /**
+   * Subscribes on the hub and, when `history` is given, fetches and delivers that many of the
+   * latest messages (spec §6) before returning them.
+   */
+  async subscribe(options = {}) {
+    await this.client.subscribe(this.roomId);
+    if (options.history === void 0) {
+      return void 0;
+    }
+    const page = await this.client.getHistory(this.roomId, { limit: options.history });
+    for (const message of page.messages) {
+      this.client.deliverMessage(message);
+    }
+    return page;
+  }
+  async unsubscribe() {
+    this.clearTypingTimer();
+    return this.client.unsubscribe(this.roomId);
+  }
+  async sendMessage(content, timeoutMs) {
+    return this.client.sendMessage(this.roomId, content, timeoutMs);
+  }
+  async getHistory(options = {}) {
+    return this.client.getHistory(this.roomId, options);
+  }
+  async getParticipants(timeoutMs) {
+    return this.client.getParticipants(this.roomId, timeoutMs);
+  }
+  async sendTyping(isTyping) {
+    this.clearTypingTimer();
+    this.isCurrentlyTyping = isTyping;
+    if (isTyping) {
+      this.lastTypingSentAt = Date.now();
+      const autoStopMs = this.client.options.autoStopTypingMs ?? 3e3;
+      this.autoStopTypingTimer = setTimeout(() => {
+        this.stopTyping().catch(() => {
+        });
+      }, autoStopMs);
+    }
+    return this.client.sendTyping(this.roomId, isTyping);
+  }
+  async startTyping() {
+    return this.sendTyping(true);
+  }
+  async stopTyping() {
+    this.clearTypingTimer();
+    if (this.isCurrentlyTyping) {
+      this.isCurrentlyTyping = false;
+      return this.client.sendTyping(this.roomId, false);
+    }
+  }
+  async notifyTyping() {
+    const now = Date.now();
+    const throttleMs = this.client.options.typingThrottleMs ?? 1e3;
+    const autoStopMs = this.client.options.autoStopTypingMs ?? 3e3;
+    this.clearTypingTimer();
+    this.autoStopTypingTimer = setTimeout(() => {
+      this.stopTyping().catch(() => {
+      });
+    }, autoStopMs);
+    if (!this.isCurrentlyTyping || now - this.lastTypingSentAt >= throttleMs) {
+      this.isCurrentlyTyping = true;
+      this.lastTypingSentAt = now;
+      await this.client.sendTyping(this.roomId, true);
+    }
+  }
+  clearTypingTimer() {
+    if (this.autoStopTypingTimer) {
+      clearTimeout(this.autoStopTypingTimer);
+      this.autoStopTypingTimer = null;
+    }
+  }
+  onMessage(handler) {
+    const unsub = this.client.onMessage((message) => {
+      if (message.roomId === this.roomId) {
+        handler(message);
+      }
+    });
+    this.listeners.push(unsub);
+    return unsub;
+  }
+  onSystemMessage(handler) {
+    const unsub = this.client.onMessage((message) => {
+      if (message.roomId === this.roomId && isSystemSender(message.senderId)) {
+        handler(message);
+      }
+    });
+    this.listeners.push(unsub);
+    return unsub;
+  }
+  onUserMessage(handler) {
+    const unsub = this.client.onMessage((message) => {
+      if (message.roomId === this.roomId && !isSystemSender(message.senderId)) {
+        handler(message);
+      }
+    });
+    this.listeners.push(unsub);
+    return unsub;
+  }
+  onMessageRetracted(handler) {
+    const unsub = this.client.onMessageRetracted((payload) => {
+      if (payload.roomId === this.roomId) {
+        handler(payload);
+      }
+    });
+    this.listeners.push(unsub);
+    return unsub;
+  }
+  onMembershipRevoked(handler) {
+    const unsub = this.client.onMembershipRevoked((payload) => {
+      if (payload.roomId === this.roomId) {
+        handler(payload);
+      }
+    });
+    this.listeners.push(unsub);
+    return unsub;
+  }
+  onTyping(handler) {
+    const unsub = this.client.onTyping((notification) => {
+      if (notification.roomId === this.roomId) {
+        handler(notification);
+      }
+    });
+    this.listeners.push(unsub);
+    return unsub;
+  }
+  onTypingWithExpiry(handler, autoExpireMs = 3500) {
+    const expiryTimers = /* @__PURE__ */ new Map();
+    const unsub = this.client.onTyping((notification) => {
+      if (notification.roomId !== this.roomId) return;
+      const existing = expiryTimers.get(notification.userId);
+      if (existing) {
+        clearTimeout(existing);
+        expiryTimers.delete(notification.userId);
+      }
+      handler(notification);
+      if (notification.isTyping) {
+        const timer = setTimeout(() => {
+          expiryTimers.delete(notification.userId);
+          handler({
+            roomId: this.roomId,
+            userId: notification.userId,
+            isTyping: false
+          });
+        }, autoExpireMs);
+        expiryTimers.set(notification.userId, timer);
+      }
+    });
+    const cleanup = () => {
+      unsub();
+      for (const timer of expiryTimers.values()) {
+        clearTimeout(timer);
+      }
+      expiryTimers.clear();
+    };
+    this.listeners.push(cleanup);
+    return cleanup;
+  }
+  onPresence(handler) {
+    const unsub = this.client.onPresence((delta) => {
+      if (delta.roomId === this.roomId) {
+        handler(delta);
+      }
+    });
+    this.listeners.push(unsub);
+    return unsub;
+  }
+  release() {
+    this.clearTypingTimer();
+    for (const cleanup of this.listeners) {
+      cleanup();
+    }
+    this.listeners.length = 0;
+    this.client.releaseRoomHandle(this);
+  }
+  dispose() {
+    this.release();
+    this.unsubscribe().catch(() => {
+    });
+  }
+};
+
+// src/token.ts
+var TokenManager = class {
+  constructor(tokenUrl, marginMs, fetchImpl = fetch) {
+    this.tokenUrl = tokenUrl;
+    this.marginMs = marginMs;
+    this.fetchImpl = fetchImpl;
+  }
+  tokenUrl;
+  marginMs;
+  fetchImpl;
+  cachedToken = null;
+  cachedExpMs = null;
+  pending = null;
+  async getToken() {
+    if (this.cachedToken !== null && !this.isExpiringSoon()) {
+      return this.cachedToken;
+    }
+    if (!this.pending) {
+      this.pending = this.fetchAndCache().finally(() => {
+        this.pending = null;
+      });
+    }
+    return this.pending;
+  }
+  isExpiringSoon() {
+    if (this.cachedExpMs === null) return false;
+    return Date.now() >= this.cachedExpMs - this.marginMs;
+  }
+  async fetchAndCache() {
+    const response = await this.fetchImpl(this.tokenUrl, { credentials: "include" });
+    if (!response.ok) {
+      throw await toDotwireClientError(response);
+    }
+    const body = await response.json();
+    this.cachedToken = body.token;
+    this.cachedExpMs = decodeExpMs(body.token);
+    return this.cachedToken;
+  }
+};
+function decodeExpMs(token) {
+  const parts = token.split(".");
+  if (parts.length < 2) return null;
+  try {
+    const payload = JSON.parse(base64UrlDecode(parts[1]));
+    return typeof payload.exp === "number" ? payload.exp * 1e3 : null;
+  } catch {
+    return null;
+  }
+}
+function base64UrlDecode(segment) {
+  const base64 = segment.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64.padEnd(base64.length + (4 - base64.length % 4) % 4, "=");
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(padded, "base64").toString("utf-8");
+  }
+  const binary = atob(padded);
+  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+  return new TextDecoder("utf-8").decode(bytes);
+}
+
+// src/client.ts
+var DotwireClient = class {
+  constructor(options) {
+    this.options = options;
+    if (!options.tokenUrl && !options.getAccessToken) {
+      throw new Error('DotwireClient requires either "tokenUrl" or "getAccessToken".');
+    }
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.hubPath = options.hubPath ?? "/hub/rooms";
+    if (options.getAccessToken) {
+      this.getToken = options.getAccessToken;
+    } else {
+      const tokenManager = new TokenManager(options.tokenUrl, options.tokenRefreshMarginMs ?? 3e4);
+      this.getToken = () => tokenManager.getToken();
+    }
+    this.connection = this.buildConnection();
+    this.registerHubHandlers();
+    this.registerUnloadHandler();
+  }
+  options;
+  baseUrl;
+  hubPath;
+  connection;
+  getToken;
+  messageListeners = /* @__PURE__ */ new Set();
+  retractedListeners = /* @__PURE__ */ new Set();
+  revokedListeners = /* @__PURE__ */ new Set();
+  typingListeners = /* @__PURE__ */ new Set();
+  presenceListeners = /* @__PURE__ */ new Set();
+  stateListeners = /* @__PURE__ */ new Set();
+  subscribedRooms = /* @__PURE__ */ new Set();
+  roomState = /* @__PURE__ */ new Map();
+  activeRoomHandles = /* @__PURE__ */ new Set();
+  unloadListener = null;
+  pendingConnect = null;
+  buildConnection() {
+    const url = `${this.baseUrl}${this.hubPath}`;
+    const httpOptions = {
+      accessTokenFactory: () => this.getToken()
+    };
+    if ((this.options.transport ?? "websockets") === "websockets") {
+      httpOptions.transport = import_signalr.HttpTransportType.WebSockets;
+      httpOptions.skipNegotiation = true;
+    }
+    if (this.options.connectionFactory) {
+      return this.options.connectionFactory(url, httpOptions);
+    }
+    const builder = new import_signalr.HubConnectionBuilder().withUrl(url, httpOptions).configureLogging(mapLogLevel(this.options.logLevel));
+    if (this.options.automaticReconnect !== false) {
+      builder.withAutomaticReconnect();
+    }
+    const connection = builder.build();
+    connection.serverTimeoutInMilliseconds = this.options.serverTimeoutMs ?? 9e4;
+    connection.keepAliveIntervalInMilliseconds = this.options.keepAliveIntervalMs ?? 15e3;
+    return connection;
+  }
+  registerHubHandlers() {
+    this.connection.on("ReceiveMessage", (message) => {
+      this.deliverMessage(message);
+    });
+    this.connection.on("UserTyping", (notification) => {
+      for (const listener of this.typingListeners) {
+        listener(notification);
+      }
+    });
+    this.connection.on("PresenceUpdated", (delta) => {
+      for (const listener of this.presenceListeners) {
+        listener(delta);
+      }
+    });
+    this.connection.on("MessageRetracted", (payload) => {
+      for (const listener of this.retractedListeners) {
+        listener(payload);
+      }
+    });
+    this.connection.on("MembershipRevoked", (payload) => {
+      this.subscribedRooms.delete(payload.roomId);
+      const state = this.roomState.get(payload.roomId);
+      if (state) state.subscribed = false;
+      for (const listener of this.revokedListeners) {
+        listener(payload);
+      }
+    });
+    this.connection.onclose(() => {
+      this.notifyStateChange("disconnected");
+    });
+    this.connection.onreconnecting(() => {
+      this.notifyStateChange("reconnecting");
+    });
+    this.connection.onreconnected(async () => {
+      this.notifyStateChange("connected");
+      for (const roomId of Array.from(this.subscribedRooms)) {
+        const resumeFrom = this.roomState.get(roomId)?.lastSeq ?? null;
+        try {
+          await this.connection.invoke("Subscribe", roomId);
+        } catch {
+          continue;
+        }
+        if (this.options.gapFillOnReconnect === false || resumeFrom === null) continue;
+        try {
+          await this.gapFill(roomId, resumeFrom);
+        } catch {
+        }
+      }
+    });
+  }
+  registerUnloadHandler() {
+    if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+      const onUnload = () => {
+        this.disconnect().catch(() => {
+        });
+      };
+      window.addEventListener("beforeunload", onUnload);
+      window.addEventListener("pagehide", onUnload);
+      this.unloadListener = () => {
+        window.removeEventListener("beforeunload", onUnload);
+        window.removeEventListener("pagehide", onUnload);
+      };
+    }
+  }
+  notifyStateChange(state) {
+    for (const listener of this.stateListeners) {
+      listener(state);
+    }
+  }
+  getOrCreateRoomState(roomId) {
+    let state = this.roomState.get(roomId);
+    if (!state) {
+      state = { subscribed: false, lastSeq: null, seen: new BoundedSeqSet(1e3) };
+      this.roomState.set(roomId, state);
+    }
+    return state;
+  }
+  /**
+   * Applies seq dedupe/tracking (spec §6) and, if the message is new, notifies listeners.
+   * Used for both live `ReceiveMessage` delivery and history/gap-fill replay.
+   */
+  deliverMessage(message) {
+    const state = this.getOrCreateRoomState(message.roomId);
+    if (state.seen.has(message.seq)) return;
+    state.seen.add(message.seq);
+    if (state.lastSeq === null || message.seq > state.lastSeq) {
+      state.lastSeq = message.seq;
+    }
+    for (const listener of this.messageListeners) {
+      listener(message);
+    }
+  }
+  async gapFill(roomId, fromSeq) {
+    const pageSize = this.options.gapFillPageSize ?? 100;
+    let afterSeq = fromSeq;
+    let hasMore = true;
+    while (hasMore) {
+      const page = await this.getHistory(roomId, { afterSeq, limit: pageSize });
+      if (page.messages.length === 0) break;
+      for (const message of page.messages) {
+        this.deliverMessage({ ...message, replayed: true });
+        afterSeq = Math.max(afterSeq, message.seq);
+      }
+      hasMore = page.hasMore;
+    }
+  }
+  getConnectionState() {
+    switch (this.connection.state) {
+      case import_signalr.HubConnectionState.Connected:
+        return "connected";
+      case import_signalr.HubConnectionState.Connecting:
+        return "connecting";
+      case import_signalr.HubConnectionState.Reconnecting:
+        return "reconnecting";
+      case import_signalr.HubConnectionState.Disconnecting:
+        return "disconnecting";
+      default:
+        return "disconnected";
+    }
+  }
+  async connect() {
+    if (this.connection.state === import_signalr.HubConnectionState.Connected) {
+      return;
+    }
+    if (!this.pendingConnect) {
+      this.pendingConnect = (async () => {
+        this.notifyStateChange("connecting");
+        await this.connection.start();
+        this.notifyStateChange("connected");
+      })().finally(() => {
+        this.pendingConnect = null;
+      });
+    }
+    return this.pendingConnect;
+  }
+  async disconnect() {
+    if (this.connection.state === import_signalr.HubConnectionState.Disconnected) {
+      return;
+    }
+    this.notifyStateChange("disconnecting");
+    await this.connection.stop();
+    this.subscribedRooms.clear();
+    this.notifyStateChange("disconnected");
+  }
+  room(roomId) {
+    const handle = new DotwireRoomHandle(roomId, this);
+    this.activeRoomHandles.add(handle);
+    return handle;
+  }
+  releaseRoomHandle(handle) {
+    this.activeRoomHandles.delete(handle);
+  }
+  async subscribe(roomId) {
+    if (this.connection.state !== import_signalr.HubConnectionState.Connected) {
+      await this.connect();
+    }
+    await this.connection.invoke("Subscribe", roomId);
+    this.subscribedRooms.add(roomId);
+    this.getOrCreateRoomState(roomId).subscribed = true;
+  }
+  async unsubscribe(roomId) {
+    if (this.connection.state === import_signalr.HubConnectionState.Connected) {
+      await this.connection.invoke("Unsubscribe", roomId);
+    }
+    this.subscribedRooms.delete(roomId);
+    const state = this.roomState.get(roomId);
+    if (state) state.subscribed = false;
+  }
+  async sendTyping(roomId, isTyping) {
+    if (this.connection.state !== import_signalr.HubConnectionState.Connected) {
+      return;
+    }
+    await this.connection.invoke("Typing", roomId, isTyping);
+  }
+  async startTyping(roomId) {
+    return this.sendTyping(roomId, true);
+  }
+  async stopTyping(roomId) {
+    return this.sendTyping(roomId, false);
+  }
+  async sendMessage(roomId, content, timeoutMs) {
+    const timeout = timeoutMs ?? this.options.requestTimeoutMs ?? 15e3;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+      let response;
+      if (this.options.sendUrl) {
+        response = await fetch(this.options.sendUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          credentials: "include",
+          body: JSON.stringify({ roomId, content }),
+          signal: controller.signal
+        });
+      } else {
+        const token = await this.getToken();
+        response = await fetch(`${this.baseUrl}/rooms/${roomId}/messages`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
+          body: JSON.stringify({ content }),
+          signal: controller.signal
+        });
+      }
+      if (!response.ok) {
+        throw await toDotwireClientError(response);
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async getHistory(roomId, options = {}) {
+    const token = await this.getToken();
+    const params = new URLSearchParams();
+    if (options.afterSeq !== void 0) params.set("afterSeq", options.afterSeq.toString());
+    if (options.beforeSeq !== void 0) params.set("beforeSeq", options.beforeSeq.toString());
+    if (options.limit !== void 0) params.set("limit", options.limit.toString());
+    const qs = params.toString();
+    const url = `${this.baseUrl}/rooms/${roomId}/messages${qs ? `?${qs}` : ""}`;
+    const timeout = options.timeoutMs ?? this.options.requestTimeoutMs ?? 15e3;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${token}`
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw await toDotwireClientError(response);
+      }
+      const body = await response.json();
+      const messages = body.messages.map((m) => ({
+        roomId: body.roomId,
+        seq: m.seq,
+        senderId: m.senderId,
+        time: m.time,
+        content: m.content
+      }));
+      return { messages, hasMore: body.hasMore };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async getParticipants(roomId, timeoutMs) {
+    const token = await this.getToken();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs ?? this.options.requestTimeoutMs ?? 15e3);
+    try {
+      const response = await fetch(`${this.baseUrl}/rooms/${roomId}/participants`, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${token}` },
+        signal: controller.signal
+      });
+      if (!response.ok) throw await toDotwireClientError(response);
+      return await response.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  onMessage(handler) {
+    this.messageListeners.add(handler);
+    return () => {
+      this.messageListeners.delete(handler);
+    };
+  }
+  onSystemMessage(handler) {
+    return this.onMessage((message) => {
+      if (isSystemSender(message.senderId)) {
+        handler(message);
+      }
+    });
+  }
+  onUserMessage(handler) {
+    return this.onMessage((message) => {
+      if (!isSystemSender(message.senderId)) {
+        handler(message);
+      }
+    });
+  }
+  onMessageRetracted(handler) {
+    this.retractedListeners.add(handler);
+    return () => {
+      this.retractedListeners.delete(handler);
+    };
+  }
+  onMembershipRevoked(handler) {
+    this.revokedListeners.add(handler);
+    return () => {
+      this.revokedListeners.delete(handler);
+    };
+  }
+  onTyping(handler) {
+    this.typingListeners.add(handler);
+    return () => {
+      this.typingListeners.delete(handler);
+    };
+  }
+  onPresence(handler) {
+    this.presenceListeners.add(handler);
+    return () => {
+      this.presenceListeners.delete(handler);
+    };
+  }
+  onStateChange(handler) {
+    this.stateListeners.add(handler);
+    return () => {
+      this.stateListeners.delete(handler);
+    };
+  }
+  dispose() {
+    if (this.unloadListener) {
+      this.unloadListener();
+      this.unloadListener = null;
+    }
+    for (const room of this.activeRoomHandles) {
+      room.dispose();
+    }
+    this.activeRoomHandles.clear();
+    this.disconnect().catch(() => {
+    });
+  }
+};
+function mapLogLevel(level) {
+  switch (level) {
+    case "error":
+      return import_signalr.LogLevel.Error;
+    case "warning":
+      return import_signalr.LogLevel.Warning;
+    case "information":
+      return import_signalr.LogLevel.Information;
+    case "debug":
+      return import_signalr.LogLevel.Debug;
+    case "none":
+    default:
+      return import_signalr.LogLevel.None;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DotwireClient,
+  DotwireClientError,
+  DotwireRoomHandle,
+  isSystemSender,
+  toDotwireClientError
+});
+//# sourceMappingURL=index.cjs.map