@multiplatform.one/frappe 6.0.0

package/dist/esm/realtime.native.js

@@ -0,0 +1,358 @@
+import { io } from "socket.io-client";
+import { isBrowser } from "./util.native.js";
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var RealtimePlatform = /* @__PURE__ */function (RealtimePlatform2) {
+  RealtimePlatform2["Node"] = "node";
+  RealtimePlatform2["Web"] = "web";
+  RealtimePlatform2["ReactNative"] = "react-native";
+  return RealtimePlatform2;
+}({});
+var RealtimeModule = /* @__PURE__ */function () {
+  "use strict";
+
+  function RealtimeModule2(config) {
+    _class_call_check(this, RealtimeModule2);
+    _define_property(this, "socket", void 0);
+    _define_property(this, "handlerMap", /* @__PURE__ */new Map());
+    _define_property(this, "attachedSocketEvents", /* @__PURE__ */new Set());
+    _define_property(this, "socketEventHandlers", /* @__PURE__ */new Map());
+    _define_property(this, "socketHealthy", false);
+    _define_property(this, "isConnecting", false);
+    _define_property(this, "config", void 0);
+    this.config = {
+      ...config,
+      platform: config.platform || this.detectPlatform()
+    };
+  }
+  _create_class(RealtimeModule2, [{
+    key: "detectPlatform",
+    value: function detectPlatform() {
+      var _navigator_userAgent;
+      if (!isBrowser()) return "node";
+      if (typeof navigator !== "undefined" && ((_navigator_userAgent = navigator.userAgent) === null || _navigator_userAgent === void 0 ? void 0 : _navigator_userAgent.includes("ReactNative"))) {
+        return "react-native";
+      }
+      return "web";
+    }
+  }, {
+    key: "getSocketURL",
+    value: function getSocketURL() {
+      var base = this.config.baseURL.replace(/\/$/, "");
+      if (!this.config.socketPort) return base;
+      try {
+        var url = new URL(base);
+        url.port = String(this.config.socketPort);
+        return url.toString().replace(/\/$/, "");
+      } catch (unused) {
+        return base.replace(/(:\d+)/, `:${this.config.socketPort}`);
+      }
+    }
+  }, {
+    key: "getAuthOptions",
+    value: async function getAuthOptions() {
+      var _this_config_auth, _this_config_auth1;
+      var authOptions = {};
+      if (this.config.platform !== "web" && ((_this_config_auth = this.config.auth) === null || _this_config_auth === void 0 ? void 0 : _this_config_auth.sessionId)) {
+        var sessionId = typeof this.config.auth.sessionId === "function" ? await this.config.auth.sessionId() : this.config.auth.sessionId;
+        var Cookie = `sid=${sessionId}`;
+        authOptions.extraHeaders = {
+          Cookie
+        };
+        authOptions.transportOptions = {
+          websocket: {
+            extraHeaders: {
+              Cookie
+            }
+          },
+          polling: {
+            extraHeaders: {
+              Cookie
+            }
+          }
+        };
+      }
+      if (((_this_config_auth1 = this.config.auth) === null || _this_config_auth1 === void 0 ? void 0 : _this_config_auth1.useToken) && this.config.auth.token) {
+        var token = typeof this.config.auth.token === "function" ? await this.config.auth.token() : this.config.auth.token;
+        var authType = this.config.auth.type || "Bearer";
+        if (!authOptions.extraHeaders) authOptions.extraHeaders = {};
+        authOptions.extraHeaders.Authorization = authType === "Bearer" ? `Bearer ${token}` : `token ${token}`;
+      }
+      return authOptions;
+    }
+  }, {
+    key: "connect",
+    value: async function connect() {
+      if (this.socket || this.isConnecting) return;
+      this.isConnecting = true;
+      try {
+        var authOptions = await this.getAuthOptions();
+        var socketURL = this.getSocketURL();
+        this.socket = io(socketURL, {
+          autoConnect: false,
+          path: "/socket.io",
+          randomizationFactor: 0.5,
+          reconnection: true,
+          reconnectionAttempts: Number.POSITIVE_INFINITY,
+          reconnectionDelay: 1e3,
+          reconnectionDelayMax: 5e3,
+          timeout: 2e4,
+          transports: ["websocket", "polling"],
+          withCredentials: true,
+          ...authOptions,
+          ...this.config.socketOptions
+        });
+        this.initHandlers();
+        this.socket.connect();
+      } catch (err) {
+        this.isConnecting = false;
+        throw err;
+      }
+    }
+  }, {
+    key: "initHandlers",
+    value: function initHandlers() {
+      var _this = this;
+      if (!this.socket) return;
+      this.attachedSocketEvents.clear();
+      this.socketEventHandlers.clear();
+      this.socket.on("connect", function () {
+        var _this_socket;
+        _this.isConnecting = false;
+        _this.socketHealthy = true;
+        _this.emitToHandlers("connected", {
+          sid: (_this_socket = _this.socket) === null || _this_socket === void 0 ? void 0 : _this_socket.id
+        });
+      });
+      this.socket.on("disconnect", function (reason) {
+        _this.socketHealthy = false;
+        _this.emitToHandlers("disconnect", {
+          reason
+        });
+      });
+      this.socket.on("connect_error", function (_error) {
+        _this.isConnecting = false;
+      });
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = this.handlerMap.keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var event = _step.value;
+          this.attachSocketListener(event);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    }
+  }, {
+    key: "attachSocketListener",
+    value: (
+    /**
+    * Attaches a socket listener for an event, storing the reference to prevent duplicates.
+    */
+    function attachSocketListener(event) {
+      var _this = this;
+      if (!this.socket || this.attachedSocketEvents.has(event)) return;
+      var handler = function handler2(payload) {
+        _this.emitToHandlers(event, payload);
+      };
+      this.socketEventHandlers.set(event, handler);
+      this.attachedSocketEvents.add(event);
+      this.socket.on(event, handler);
+    })
+  }, {
+    key: "detachSocketListener",
+    value: (
+    /**
+    * Removes a socket listener for an event.
+    */
+    function detachSocketListener(event) {
+      if (!this.socket || !this.attachedSocketEvents.has(event)) return;
+      var handler = this.socketEventHandlers.get(event);
+      if (handler) {
+        this.socket.off(event, handler);
+        this.socketEventHandlers.delete(event);
+      }
+      this.attachedSocketEvents.delete(event);
+    })
+  }, {
+    key: "emitToHandlers",
+    value: function emitToHandlers(event, payload) {
+      var handlerSet = this.handlerMap.get(event);
+      if (!handlerSet) return;
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = handlerSet[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var handler = _step.value;
+          handler(payload);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    }
+  }, {
+    key: "on",
+    value: async function on(event, handler) {
+      var handlerSet = this.handlerMap.get(event);
+      if (!handlerSet) {
+        handlerSet = /* @__PURE__ */new Set();
+        this.handlerMap.set(event, handlerSet);
+      }
+      handlerSet.add(handler);
+      if (!this.socket && !this.isConnecting) {
+        await this.connect();
+      }
+      this.attachSocketListener(event);
+    }
+  }, {
+    key: "off",
+    value: function off(event, handler) {
+      var handlerSet = this.handlerMap.get(event);
+      if (!handlerSet) return;
+      handlerSet.delete(handler);
+      if (handlerSet.size === 0) {
+        this.handlerMap.delete(event);
+        this.detachSocketListener(event);
+      }
+    }
+  }, {
+    key: "subscribeDoc",
+    value: async function subscribeDoc(doctype, name) {
+      if (!this.socket) await this.connect();
+      if (this.socket && this.socketHealthy) {
+        this.socket.emit("doc_subscribe", {
+          doctype,
+          name
+        });
+      }
+    }
+  }, {
+    key: "unsubscribeDoc",
+    value: function unsubscribeDoc(doctype, name) {
+      if (this.socket && this.socketHealthy) {
+        this.socket.emit("doc_unsubscribe", {
+          doctype,
+          name
+        });
+      }
+    }
+  }, {
+    key: "subscribeList",
+    value: async function subscribeList(doctype, filters) {
+      if (!this.socket) await this.connect();
+      if (this.socket && this.socketHealthy) {
+        this.socket.emit("list_subscribe", {
+          doctype,
+          filters
+        });
+      }
+    }
+  }, {
+    key: "unsubscribeList",
+    value: function unsubscribeList(doctype) {
+      if (this.socket && this.socketHealthy) {
+        this.socket.emit("list_unsubscribe", {
+          doctype
+        });
+      }
+    }
+  }, {
+    key: "isHealthy",
+    value: function isHealthy() {
+      var _this_socket;
+      return this.socketHealthy && ((_this_socket = this.socket) === null || _this_socket === void 0 ? void 0 : _this_socket.connected) === true;
+    }
+  }, {
+    key: "disconnect",
+    value: function disconnect() {
+      if (this.socket) {
+        this.socket.disconnect();
+        this.socket = void 0;
+      }
+      this.handlerMap.clear();
+      this.attachedSocketEvents.clear();
+      this.socketEventHandlers.clear();
+      this.socketHealthy = false;
+      this.isConnecting = false;
+    }
+  }, {
+    key: "updateAuth",
+    value: async function updateAuth(auth) {
+      this.config.auth = auth;
+      this.disconnect();
+      if (this.handlerMap.size > 0) {
+        await this.connect();
+      }
+    }
+  }, {
+    key: "emit",
+    value: function emit(event, data) {
+      if (this.socket && this.socketHealthy) {
+        this.socket.emit(event, data);
+      }
+    }
+  }, {
+    key: "getSocket",
+    value: function getSocket() {
+      return this.socket;
+    }
+  }]);
+  return RealtimeModule2;
+}();
+export { RealtimeModule, RealtimePlatform };
+//# sourceMappingURL=realtime.native.js.map

package/dist/esm/realtime.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["io","isBrowser","_class_call_check","instance","Constructor","TypeError","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_create_class","protoProps","staticProps","prototype","_define_property","obj","value","RealtimePlatform","RealtimePlatform2","RealtimeModule","RealtimeModule2","config","Map","Set","platform","detectPlatform","_navigator_userAgent","navigator","userAgent","includes","getSocketURL","base","baseURL","replace","socketPort","url","URL","port","String","toString","unused","getAuthOptions","_this_config_auth","_this_config_auth1","authOptions","auth","sessionId","Cookie","extraHeaders","transportOptions","websocket","polling","useToken","token","authType","type","Authorization","connect","socket","isConnecting","socketURL","autoConnect","path","randomizationFactor","reconnection","reconnectionAttempts","Number","POSITIVE_INFINITY","reconnectionDelay","reconnectionDelayMax","timeout","transports","withCredentials","socketOptions","initHandlers","err","_this","attachedSocketEvents","clear","socketEventHandlers","on","_this_socket","socketHealthy","emitToHandlers","sid","id","reason","_error","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_iterator","handlerMap","keys","Symbol","iterator","_step","next","done","event","attachSocketListener","return","has","handler","handler2","payload","set","add","detachSocketListener","get"],"sources":["../../src/realtime.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/esm/realtime.spec.mjs

@@ -0,0 +1,327 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { RealtimeModule } from "./realtime.mjs";
+const mockSocket = {
+  connected: false,
+  on: vi.fn(),
+  off: vi.fn(),
+  emit: vi.fn(),
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  id: "mock-socket-id"
+};
+vi.mock("socket.io-client", () => ({
+  io: vi.fn(() => {
+    return mockSocket;
+  })
+}));
+describe("RealtimeModule", () => {
+  let realtime;
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSocket.connected = false;
+    mockSocket.on.mockImplementation((event, handler) => {
+      if (event === "connect") {
+        mockSocket.connected = true;
+        setTimeout(() => handler(), 0);
+      }
+    });
+    realtime = new RealtimeModule({
+      baseURL: "http://localhost:3000"
+    });
+  });
+  afterEach(() => {
+    if (realtime) {
+      realtime.disconnect();
+      realtime = void 0;
+    }
+    vi.clearAllMocks();
+  });
+  describe("constructor", () => {
+    it("should initialize without throwing", () => {
+      expect(() => new RealtimeModule({
+        baseURL: "http://localhost:3000"
+      })).not.toThrow();
+    });
+    it("should initialize with auth config", () => {
+      const auth = {
+        token: "test-token",
+        useToken: true
+      };
+      expect(() => new RealtimeModule({
+        baseURL: "http://localhost:3000",
+        auth
+      })).not.toThrow();
+    });
+    it("should detect platform", () => {
+      const originalUA = global.navigator?.userAgent;
+      Object.defineProperty(global, "navigator", {
+        value: {
+          userAgent: "ReactNative"
+        },
+        writable: true
+      });
+      const rnInstance = new RealtimeModule({
+        baseURL: "http://localhost:3000"
+      });
+      expect(rnInstance).toBeDefined();
+      if (originalUA) {
+        Object.defineProperty(global, "navigator", {
+          value: {
+            userAgent: originalUA
+          },
+          writable: true
+        });
+      }
+    });
+  });
+  describe("connect", () => {
+    it("should establish socket connection", async () => {
+      await realtime.connect();
+      expect(mockSocket.on).toHaveBeenCalledWith("connect", expect.any(Function));
+      expect(mockSocket.on).toHaveBeenCalledWith("disconnect", expect.any(Function));
+    });
+    it("should not connect twice", async () => {
+      await realtime.connect();
+      const callCount = mockSocket.on.mock.calls.length;
+      await realtime.connect();
+      expect(mockSocket.on).toHaveBeenCalledTimes(callCount);
+    });
+    it("should handle connection errors", async () => {
+      mockSocket.on.mockImplementation((event, handler) => {
+        if (event === "connect_error") {
+          setTimeout(() => handler(new Error("Connection failed")), 0);
+        }
+      });
+      await realtime.connect();
+      expect(mockSocket.on).toHaveBeenCalledWith("connect_error", expect.any(Function));
+    });
+  });
+  describe("on", () => {
+    it("should register event handler and create socket listener dynamically", async () => {
+      const handler = vi.fn();
+      await realtime.on("custom_event", handler);
+      expect(mockSocket.on).toHaveBeenCalledWith("custom_event", expect.any(Function));
+    });
+    it("should register multiple handlers for same event without duplicating socket listener", async () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+      await realtime.connect();
+      await realtime.on("doc_changed", handler1);
+      const firstCallCount = mockSocket.on.mock.calls.filter(call => call[0] === "doc_changed").length;
+      await realtime.on("doc_changed", handler2);
+      const secondCallCount = mockSocket.on.mock.calls.filter(call => call[0] === "doc_changed").length;
+      expect(firstCallCount).toBe(1);
+      expect(secondCallCount).toBe(1);
+    });
+    it("should handle any event type", async () => {
+      const events = ["doc_changed", "doc_deleted", "chat_message", "notification", "custom_event", "iot_sensor", "game_state"];
+      await realtime.connect();
+      for (const event of events) {
+        const handler = vi.fn();
+        await realtime.on(event, handler);
+      }
+      events.forEach(event => {
+        const calls = mockSocket.on.mock.calls.filter(call => call[0] === event);
+        expect(calls.length).toBe(1);
+      });
+    });
+    it("should forward events to registered handlers", async () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+      await realtime.on("test_event", handler1);
+      await realtime.on("test_event", handler2);
+      const socketListener = mockSocket.on.mock.calls.find(call => call[0] === "test_event")?.[1];
+      const payload = {
+        data: "test"
+      };
+      socketListener(payload);
+      expect(handler1).toHaveBeenCalledWith(payload);
+      expect(handler2).toHaveBeenCalledWith(payload);
+    });
+    it("should connect automatically when adding first handler", async () => {
+      const handler = vi.fn();
+      await realtime.on("test_event", handler);
+      expect(mockSocket.on).toHaveBeenCalledWith("connect", expect.any(Function));
+    });
+  });
+  describe("off", () => {
+    it("should remove event handler", async () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+      await realtime.on("test_event", handler1);
+      await realtime.on("test_event", handler2);
+      realtime.off("test_event", handler1);
+      const socketListener = mockSocket.on.mock.calls.find(call => call[0] === "test_event")?.[1];
+      const payload = {
+        data: "test"
+      };
+      socketListener(payload);
+      expect(handler1).not.toHaveBeenCalled();
+      expect(handler2).toHaveBeenCalledWith(payload);
+    });
+    it("should remove socket listener when last handler is removed", async () => {
+      const handler = vi.fn();
+      await realtime.on("test_event", handler);
+      realtime.off("test_event", handler);
+      expect(mockSocket.off).toHaveBeenCalledWith("test_event", expect.any(Function));
+    });
+    it("should not remove socket listener if other handlers remain", async () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+      await realtime.on("test_event", handler1);
+      await realtime.on("test_event", handler2);
+      realtime.off("test_event", handler1);
+      expect(mockSocket.off).not.toHaveBeenCalledWith("test_event");
+    });
+    it("should handle removing non-existent handler gracefully", () => {
+      const handler = vi.fn();
+      expect(() => realtime.off("test_event", handler)).not.toThrow();
+    });
+  });
+  describe("subscribeDoc / unsubscribeDoc", () => {
+    it("should emit doc_subscribe event", async () => {
+      mockSocket.connected = true;
+      realtime.socketHealthy = true;
+      await realtime.subscribeDoc("Task", "TASK-001");
+      expect(mockSocket.emit).toHaveBeenCalledWith("doc_subscribe", {
+        doctype: "Task",
+        name: "TASK-001"
+      });
+    });
+    it("should emit doc_unsubscribe event", async () => {
+      mockSocket.connected = true;
+      realtime.socketHealthy = true;
+      realtime.socket = mockSocket;
+      realtime.unsubscribeDoc("Task", "TASK-001");
+      expect(mockSocket.emit).toHaveBeenCalledWith("doc_unsubscribe", {
+        doctype: "Task",
+        name: "TASK-001"
+      });
+    });
+    it("should connect before subscribing if not connected", async () => {
+      await realtime.subscribeDoc("Task", "TASK-001");
+      expect(mockSocket.on).toHaveBeenCalledWith("connect", expect.any(Function));
+    });
+  });
+  describe("subscribeList / unsubscribeList", () => {
+    it("should emit list_subscribe event", async () => {
+      mockSocket.connected = true;
+      realtime.socketHealthy = true;
+      await realtime.subscribeList("Task", {
+        status: "Open"
+      });
+      expect(mockSocket.emit).toHaveBeenCalledWith("list_subscribe", {
+        doctype: "Task",
+        filters: {
+          status: "Open"
+        }
+      });
+    });
+    it("should emit list_unsubscribe event", async () => {
+      mockSocket.connected = true;
+      realtime.socketHealthy = true;
+      realtime.socket = mockSocket;
+      realtime.unsubscribeList("Task");
+      expect(mockSocket.emit).toHaveBeenCalledWith("list_unsubscribe", {
+        doctype: "Task"
+      });
+    });
+  });
+  describe("isHealthy", () => {
+    it("should return true when socket is connected and healthy", async () => {
+      await realtime.connect();
+      const connectHandler = mockSocket.on.mock.calls.find(call => call[0] === "connect")?.[1];
+      connectHandler();
+      expect(realtime.isHealthy()).toBe(true);
+    });
+    it("should return false when disconnected", () => {
+      expect(realtime.isHealthy()).toBe(false);
+    });
+    it("should return false after disconnect event", async () => {
+      await realtime.connect();
+      const connectHandler = mockSocket.on.mock.calls.find(call => call[0] === "connect")?.[1];
+      connectHandler();
+      expect(realtime.isHealthy()).toBe(true);
+      const disconnectHandler = mockSocket.on.mock.calls.find(call => call[0] === "disconnect")?.[1];
+      disconnectHandler("transport close");
+      expect(realtime.isHealthy()).toBe(false);
+    });
+  });
+  describe("disconnect", () => {
+    it("should disconnect socket", async () => {
+      await realtime.connect();
+      realtime.disconnect();
+      expect(mockSocket.disconnect).toHaveBeenCalled();
+    });
+    it("should clear all handlers", async () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+      await realtime.on("event1", handler1);
+      await realtime.on("event2", handler2);
+      realtime.disconnect();
+      expect(mockSocket.disconnect).toHaveBeenCalled();
+      const socketListener1 = mockSocket.on.mock.calls.find(call => call[0] === "event1")?.[1];
+      if (socketListener1) {
+        socketListener1({
+          data: "test"
+        });
+        expect(handler1).not.toHaveBeenCalled();
+      }
+    });
+    it("should handle multiple disconnects gracefully", () => {
+      expect(() => {
+        realtime.disconnect();
+        realtime.disconnect();
+      }).not.toThrow();
+    });
+  });
+  describe("emit", () => {
+    it("should emit events through socket", async () => {
+      mockSocket.connected = true;
+      realtime.socketHealthy = true;
+      realtime.socket = mockSocket;
+      const payload = {
+        test: "data"
+      };
+      realtime.emit("custom_event", payload);
+      expect(mockSocket.emit).toHaveBeenCalledWith("custom_event", payload);
+    });
+    it("should not emit when not connected", () => {
+      const payload = {
+        test: "data"
+      };
+      realtime.emit("custom_event", payload);
+      expect(mockSocket.emit).not.toHaveBeenCalled();
+    });
+  });
+  describe("reconnection handling", () => {
+    it("should re-register existing handlers when connection is re-established", async () => {
+      const handler = vi.fn();
+      await realtime.connect();
+      await realtime.on("test_event", handler);
+      const initialCalls = mockSocket.on.mock.calls.filter(call => call[0] === "test_event");
+      expect(initialCalls.length).toBe(1);
+      mockSocket.on.mockClear();
+      realtime.socket = void 0;
+      realtime.socketHealthy = false;
+      realtime.isConnecting = false;
+      await realtime.connect();
+      const reconnectCalls = mockSocket.on.mock.calls.filter(call => call[0] === "test_event");
+      expect(reconnectCalls.length).toBe(1);
+    });
+    it("should not maintain handlers after explicit disconnect", async () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+      await realtime.on("event1", handler1);
+      await realtime.on("event2", handler2);
+      realtime.disconnect();
+      mockSocket.on.mockClear();
+      await realtime.connect();
+      const event1Calls = mockSocket.on.mock.calls.filter(call => call[0] === "event1");
+      const event2Calls = mockSocket.on.mock.calls.filter(call => call[0] === "event2");
+      expect(event1Calls.length).toBe(0);
+      expect(event2Calls.length).toBe(0);
+    });
+  });
+});
+//# sourceMappingURL=realtime.spec.mjs.map