@dooboostore/simple-boot-http-server 1.0.23 → 1.0.24

package/dist/cjs/session/SessionManager.js

@@ -20,7 +20,7 @@ __export(SessionManager_exports, {
   SessionManager: () => SessionManager
 });
 module.exports = __toCommonJS(SessionManager_exports);
-var import_RandomUtils = require("@dooboostore/core/random/RandomUtils");
+var import_core = require("@dooboostore/core");
 var import_RequestResponse = require("../models/RequestResponse");
 class SessionManager {
   constructor(option) {
@@ -69,7 +69,7 @@ class SessionManager {
     return now - access >= this.option.sessionOption.expiredTime;
   }
   makeUUID() {
-    return import_RandomUtils.RandomUtils.uuid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
+    return import_core.RandomUtils.uuid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
   }
   async session(rrOrUUID) {
     let uuid;

package/dist/cjs/session/SessionManager.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/session/SessionManager.ts"],
-  "sourcesContent": ["import {RandomUtils} from '@dooboostore/core/random/RandomUtils'\nimport {HttpServerOption} from '../option/HttpServerOption';\nimport {RequestResponse} from '../models/RequestResponse';\n\nexport class SessionManager {\n    private sessions = new Map<string, { access: number, data?: any }>();\n    public sessionOption: { key: string; expiredTime: number, provider?: {uuids: () => Promise<string[]>, delete: (uuid: string) => Promise<void>, get: (uuid: string) => Promise<{ access: number, data?: any }>, set: (uuid: string, data: { access: number, data?: any }) => Promise<void>} };\n\n    constructor(private option: HttpServerOption) {\n        this.sessionOption = option.sessionOption;\n        setInterval(async () => {\n            const uuids = (await this.getSessionUUIDs());\n            for (const uuid of uuids) {\n                const dataSet = await this.getSessionDataSet(uuid);\n                if (dataSet && this.isExpired(dataSet.access)) {\n                    await this.deleteSession(uuid);\n                }\n            }\n        }, this.sessionOption.expiredTime);\n    }\n\n    async getSessionUUIDs() {\n        if (this.sessionOption.provider?.uuids) {\n            return this.sessionOption.provider.uuids();\n        } else {\n            return Array.from(this.sessions.keys());\n        }\n    }\n\n    async deleteSession(uuid: string) {\n        if (this.sessionOption.provider?.delete) {\n            this.sessionOption.provider.delete(uuid);\n        } else {\n            this.sessions.delete(uuid);\n        }\n    }\n\n    async getSessionDataSet(uuid: string) {\n        if (this.sessionOption.provider?.get) {\n            return this.sessionOption.provider.get(uuid);\n        } else {\n            return this.sessions.get(uuid);\n        }\n    }\n\n    async setSessionDataSet(uuid: string, dataSet: { access: number, data?: any }) {\n        if (this.sessionOption.provider?.set) {\n            this.sessionOption.provider.set(uuid, dataSet);\n        } else {\n            this.sessions.set(uuid, dataSet);\n        }\n    }\n\n    isExpired(access: number, now: number = Date.now()) {\n        return (now - access) >= this.option.sessionOption.expiredTime;\n    }\n\n    makeUUID() {\n        return RandomUtils.uuid('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx');\n    }\n\n    async session(): Promise<{ uuid: string, dataSet: { access: number, data?: any } }>;\n    async session(uuid: string): Promise<{ uuid: string, dataSet: { access: number, data?: any } }>;\n    async session(rr: RequestResponse): Promise<{ uuid: string, dataSet: { access: number, data?: any } }>;\n    async session(rrOrUUID?: string | RequestResponse): Promise<{ uuid: string, dataSet: { access: number, data?: any } } >{\n        let uuid: string;\n        if (rrOrUUID instanceof RequestResponse) {\n            uuid = rrOrUUID.reqCookieGet(this.sessionOption.key) ?? this.makeUUID();\n        } else if (typeof rrOrUUID === 'string') {\n            uuid = rrOrUUID;\n        } else {\n            uuid = this.makeUUID()\n        }\n        let dataSet = await this.getSessionDataSet(uuid);\n        const now = Date.now();\n        if (dataSet) {\n            if (this.isExpired(dataSet.access, now)) {\n                delete dataSet.data;\n            }\n            dataSet.access = now;\n        } else {\n            dataSet = {\n                access: now\n            }\n        }\n        await this.setSessionDataSet(uuid, dataSet);\n        return {uuid, dataSet};\n    }\n}"],
-  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAA0B;AAE1B,6BAA8B;AAEvB,MAAM,eAAe;AAAA,EAIxB,YAAoB,QAA0B;AAA1B;AAHpB,SAAQ,WAAW,oBAAI,IAA4C;AAI/D,SAAK,gBAAgB,OAAO;AAC5B,gBAAY,YAAY;AACpB,YAAM,QAAS,MAAM,KAAK,gBAAgB;AAC1C,iBAAW,QAAQ,OAAO;AACtB,cAAM,UAAU,MAAM,KAAK,kBAAkB,IAAI;AACjD,YAAI,WAAW,KAAK,UAAU,QAAQ,MAAM,GAAG;AAC3C,gBAAM,KAAK,cAAc,IAAI;AAAA,QACjC;AAAA,MACJ;AAAA,IACJ,GAAG,KAAK,cAAc,WAAW;AAAA,EACrC;AAAA,EAEA,MAAM,kBAAkB;AACpB,QAAI,KAAK,cAAc,UAAU,OAAO;AACpC,aAAO,KAAK,cAAc,SAAS,MAAM;AAAA,IAC7C,OAAO;AACH,aAAO,MAAM,KAAK,KAAK,SAAS,KAAK,CAAC;AAAA,IAC1C;AAAA,EACJ;AAAA,EAEA,MAAM,cAAc,MAAc;AAC9B,QAAI,KAAK,cAAc,UAAU,QAAQ;AACrC,WAAK,cAAc,SAAS,OAAO,IAAI;AAAA,IAC3C,OAAO;AACH,WAAK,SAAS,OAAO,IAAI;AAAA,IAC7B;AAAA,EACJ;AAAA,EAEA,MAAM,kBAAkB,MAAc;AAClC,QAAI,KAAK,cAAc,UAAU,KAAK;AAClC,aAAO,KAAK,cAAc,SAAS,IAAI,IAAI;AAAA,IAC/C,OAAO;AACH,aAAO,KAAK,SAAS,IAAI,IAAI;AAAA,IACjC;AAAA,EACJ;AAAA,EAEA,MAAM,kBAAkB,MAAc,SAAyC;AAC3E,QAAI,KAAK,cAAc,UAAU,KAAK;AAClC,WAAK,cAAc,SAAS,IAAI,MAAM,OAAO;AAAA,IACjD,OAAO;AACH,WAAK,SAAS,IAAI,MAAM,OAAO;AAAA,IACnC;AAAA,EACJ;AAAA,EAEA,UAAU,QAAgB,MAAc,KAAK,IAAI,GAAG;AAChD,WAAQ,MAAM,UAAW,KAAK,OAAO,cAAc;AAAA,EACvD;AAAA,EAEA,WAAW;AACP,WAAO,+BAAY,KAAK,kCAAkC;AAAA,EAC9D;AAAA,EAKA,MAAM,QAAQ,UAAyG;AACnH,QAAI;AACJ,QAAI,oBAAoB,wCAAiB;AACrC,aAAO,SAAS,aAAa,KAAK,cAAc,GAAG,KAAK,KAAK,SAAS;AAAA,IAC1E,WAAW,OAAO,aAAa,UAAU;AACrC,aAAO;AAAA,IACX,OAAO;AACH,aAAO,KAAK,SAAS;AAAA,IACzB;AACA,QAAI,UAAU,MAAM,KAAK,kBAAkB,IAAI;AAC/C,UAAM,MAAM,KAAK,IAAI;AACrB,QAAI,SAAS;AACT,UAAI,KAAK,UAAU,QAAQ,QAAQ,GAAG,GAAG;AACrC,eAAO,QAAQ;AAAA,MACnB;AACA,cAAQ,SAAS;AAAA,IACrB,OAAO;AACH,gBAAU;AAAA,QACN,QAAQ;AAAA,MACZ;AAAA,IACJ;AACA,UAAM,KAAK,kBAAkB,MAAM,OAAO;AAC1C,WAAO,EAAC,MAAM,QAAO;AAAA,EACzB;AACJ;",
+  "sourcesContent": ["import {RandomUtils} from '@dooboostore/core'\nimport { HttpServerOption, SessionOption } from '../option/HttpServerOption';\nimport {RequestResponse} from '../models/RequestResponse';\n\nexport class SessionManager {\n    private sessions = new Map<string, { access: number, data?: any }>();\n    public sessionOption: SessionOption;\n\n    constructor(private option: HttpServerOption) {\n        this.sessionOption = option.sessionOption;\n        setInterval(async () => {\n            const uuids = (await this.getSessionUUIDs());\n            for (const uuid of uuids) {\n                const dataSet = await this.getSessionDataSet(uuid);\n                if (dataSet && this.isExpired(dataSet.access)) {\n                    await this.deleteSession(uuid);\n                }\n            }\n        }, this.sessionOption.expiredTime);\n    }\n\n    async getSessionUUIDs() {\n        if (this.sessionOption.provider?.uuids) {\n            return this.sessionOption.provider.uuids();\n        } else {\n            return Array.from(this.sessions.keys());\n        }\n    }\n\n    async deleteSession(uuid: string) {\n        if (this.sessionOption.provider?.delete) {\n            this.sessionOption.provider.delete(uuid);\n        } else {\n            this.sessions.delete(uuid);\n        }\n    }\n\n    async getSessionDataSet(uuid: string) {\n        if (this.sessionOption.provider?.get) {\n            return this.sessionOption.provider.get(uuid);\n        } else {\n            return this.sessions.get(uuid);\n        }\n    }\n\n    async setSessionDataSet(uuid: string, dataSet: { access: number, data?: any }) {\n        if (this.sessionOption.provider?.set) {\n            this.sessionOption.provider.set(uuid, dataSet);\n        } else {\n            this.sessions.set(uuid, dataSet);\n        }\n    }\n\n    isExpired(access: number, now: number = Date.now()) {\n        return (now - access) >= this.option.sessionOption.expiredTime;\n    }\n\n    makeUUID() {\n        return RandomUtils.uuid('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx');\n    }\n\n    async session(): Promise<{ uuid: string, dataSet: { access: number, data?: any } }>;\n    async session(uuid: string): Promise<{ uuid: string, dataSet: { access: number, data?: any } }>;\n    async session(rr: RequestResponse): Promise<{ uuid: string, dataSet: { access: number, data?: any } }>;\n    async session(rrOrUUID?: string | RequestResponse): Promise<{ uuid: string, dataSet: { access: number, data?: any } } >{\n        let uuid: string;\n        if (rrOrUUID instanceof RequestResponse) {\n            uuid = rrOrUUID.reqCookieGet(this.sessionOption.key) ?? this.makeUUID();\n        } else if (typeof rrOrUUID === 'string') {\n            uuid = rrOrUUID;\n        } else {\n            uuid = this.makeUUID()\n        }\n        let dataSet = await this.getSessionDataSet(uuid);\n        const now = Date.now();\n        if (dataSet) {\n            if (this.isExpired(dataSet.access, now)) {\n                delete dataSet.data;\n            }\n            dataSet.access = now;\n        } else {\n            dataSet = {\n                access: now\n            }\n        }\n        await this.setSessionDataSet(uuid, dataSet);\n        return {uuid, dataSet};\n    }\n}"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA0B;AAE1B,6BAA8B;AAEvB,MAAM,eAAe;AAAA,EAIxB,YAAoB,QAA0B;AAA1B;AAHpB,SAAQ,WAAW,oBAAI,IAA4C;AAI/D,SAAK,gBAAgB,OAAO;AAC5B,gBAAY,YAAY;AACpB,YAAM,QAAS,MAAM,KAAK,gBAAgB;AAC1C,iBAAW,QAAQ,OAAO;AACtB,cAAM,UAAU,MAAM,KAAK,kBAAkB,IAAI;AACjD,YAAI,WAAW,KAAK,UAAU,QAAQ,MAAM,GAAG;AAC3C,gBAAM,KAAK,cAAc,IAAI;AAAA,QACjC;AAAA,MACJ;AAAA,IACJ,GAAG,KAAK,cAAc,WAAW;AAAA,EACrC;AAAA,EAEA,MAAM,kBAAkB;AACpB,QAAI,KAAK,cAAc,UAAU,OAAO;AACpC,aAAO,KAAK,cAAc,SAAS,MAAM;AAAA,IAC7C,OAAO;AACH,aAAO,MAAM,KAAK,KAAK,SAAS,KAAK,CAAC;AAAA,IAC1C;AAAA,EACJ;AAAA,EAEA,MAAM,cAAc,MAAc;AAC9B,QAAI,KAAK,cAAc,UAAU,QAAQ;AACrC,WAAK,cAAc,SAAS,OAAO,IAAI;AAAA,IAC3C,OAAO;AACH,WAAK,SAAS,OAAO,IAAI;AAAA,IAC7B;AAAA,EACJ;AAAA,EAEA,MAAM,kBAAkB,MAAc;AAClC,QAAI,KAAK,cAAc,UAAU,KAAK;AAClC,aAAO,KAAK,cAAc,SAAS,IAAI,IAAI;AAAA,IAC/C,OAAO;AACH,aAAO,KAAK,SAAS,IAAI,IAAI;AAAA,IACjC;AAAA,EACJ;AAAA,EAEA,MAAM,kBAAkB,MAAc,SAAyC;AAC3E,QAAI,KAAK,cAAc,UAAU,KAAK;AAClC,WAAK,cAAc,SAAS,IAAI,MAAM,OAAO;AAAA,IACjD,OAAO;AACH,WAAK,SAAS,IAAI,MAAM,OAAO;AAAA,IACnC;AAAA,EACJ;AAAA,EAEA,UAAU,QAAgB,MAAc,KAAK,IAAI,GAAG;AAChD,WAAQ,MAAM,UAAW,KAAK,OAAO,cAAc;AAAA,EACvD;AAAA,EAEA,WAAW;AACP,WAAO,wBAAY,KAAK,kCAAkC;AAAA,EAC9D;AAAA,EAKA,MAAM,QAAQ,UAAyG;AACnH,QAAI;AACJ,QAAI,oBAAoB,wCAAiB;AACrC,aAAO,SAAS,aAAa,KAAK,cAAc,GAAG,KAAK,KAAK,SAAS;AAAA,IAC1E,WAAW,OAAO,aAAa,UAAU;AACrC,aAAO;AAAA,IACX,OAAO;AACH,aAAO,KAAK,SAAS;AAAA,IACzB;AACA,QAAI,UAAU,MAAM,KAAK,kBAAkB,IAAI;AAC/C,UAAM,MAAM,KAAK,IAAI;AACrB,QAAI,SAAS;AACT,UAAI,KAAK,UAAU,QAAQ,QAAQ,GAAG,GAAG;AACrC,eAAO,QAAQ;AAAA,MACnB;AACA,cAAQ,SAAS;AAAA,IACrB,OAAO;AACH,gBAAU;AAAA,QACN,QAAQ;AAAA,MACZ;AAAA,IACJ;AACA,UAAM,KAAK,kBAAkB,MAAM,OAAO;AAC1C,WAAO,EAAC,MAAM,QAAO;AAAA,EACzB;AACJ;",
   "names": []
 }

package/dist/cjs/websocket/WebSocketClient.js

@@ -0,0 +1,554 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WebSocketClient_exports = {};
+__export(WebSocketClient_exports, {
+  WebSocketClient: () => WebSocketClient
+});
+module.exports = __toCommonJS(WebSocketClient_exports);
+var import_core = require("@dooboostore/core");
+var import_core2 = require("@dooboostore/core");
+__reExport(WebSocketClient_exports, require("@dooboostore/core"), module.exports);
+class WebSocketClient {
+  constructor(connection, config) {
+    this.topics = /* @__PURE__ */ new Map();
+    this.pendingMessages = [];
+    this.pendingBinaryMessages = [];
+    this.isConnected = false;
+    this._subject = new import_core2.Subject();
+    this.currentRetryCount = 0;
+    this.isManualClose = false;
+    this.isConnecting = false;
+    if (typeof connection === "string" || connection instanceof URL) {
+      this.connectionUrl = connection;
+    } else {
+      this.connectionUrl = connection.url;
+      this.connectionProtocols = connection.protocols;
+    }
+    this.retryConnectionCount = config?.retryConnectionCount ?? 0;
+    this.retryConnectionDelay = config?.retryConnectionDelay ?? 1e3;
+    this.maxPendingMessages = config?.maxPendingMessages ?? 1e3;
+    this.maxPendingBinaryMessages = config?.maxPendingBinaryMessages ?? 100;
+    this.connect();
+  }
+  get observable() {
+    return this._subject.asObservable();
+  }
+  connect() {
+    if (this.isConnecting) {
+      return;
+    }
+    if (this.websocket && (this.websocket.readyState === WebSocket.OPEN || this.websocket.readyState === WebSocket.CONNECTING)) {
+      return;
+    }
+    this.isConnecting = true;
+    if (this.connectionProtocols) {
+      this.websocket = new WebSocket(this.connectionUrl, this.connectionProtocols);
+    } else {
+      this.websocket = new WebSocket(this.connectionUrl);
+    }
+    this.websocket.binaryType = "arraybuffer";
+    this.websocket.addEventListener("open", () => {
+      this.isConnecting = false;
+      this.isConnected = true;
+      this.currentRetryCount = 0;
+      if (this.reconnectTimeout) {
+        clearTimeout(this.reconnectTimeout);
+        this.reconnectTimeout = void 0;
+      }
+      console.log("WebSocket connected");
+      this.onOpenCallback?.();
+      this.topics.forEach((topicData, uuid) => {
+        if (!topicData.subscription.closed) {
+          const subscribeTopic = {
+            type: "subscribe",
+            uuid,
+            target: topicData.target
+          };
+          this.websocket.send(JSON.stringify(subscribeTopic));
+        }
+      });
+      while (this.pendingMessages.length > 0) {
+        const message = this.pendingMessages.shift();
+        this.websocket.send(JSON.stringify(message));
+      }
+      while (this.pendingBinaryMessages.length > 0) {
+        const message = this.pendingBinaryMessages.shift();
+        if (message) {
+          this.websocket.send(message);
+        }
+      }
+    });
+    this.websocket.addEventListener("close", (event) => {
+      this.isConnecting = false;
+      this.isConnected = false;
+      console.log("WebSocket closed", event.code, event.reason);
+      this.onCloseCallback?.();
+      if (!this.isManualClose) {
+        this.attemptReconnect();
+      }
+    });
+    this.websocket.addEventListener("error", (error) => {
+      console.error("WebSocket error:", error);
+    });
+    this.websocket.addEventListener("message", async (event) => {
+      const topic = await this.parseIncomingTopic(event.data);
+      if (!topic) {
+        return;
+      }
+      this._subject.next(topic);
+      this.observer?.(topic);
+      if (topic.uuid) {
+        const topicData = this.topics.get(topic.uuid);
+        if (topicData) {
+          const observer = topicData.observer;
+          const nextCallback = typeof observer === "function" ? observer : observer.next;
+          const errorCallback = typeof observer === "function" ? void 0 : observer.error;
+          const eventCallback = typeof observer === "function" ? void 0 : observer.event;
+          if ("state" in topic && topic.state === "success") {
+            await nextCallback(topic.body, { socket: this.websocket });
+          } else if ("state" in topic && topic.state === "error" && errorCallback) {
+            await errorCallback(topic.body);
+          } else if ("type" in topic && topic.type === "unsubscribe") {
+            topicData.subscription.closed = true;
+            this.topics.delete(topic.uuid);
+            topicData.onUnsubscribes.forEach((it) => it("server"));
+          } else if ("type" in topic && topic.type === "event" && eventCallback) {
+            let eventResponse = typeof eventCallback === "function" ? await eventCallback(topic.event, topic.body, { socket: this.websocket }) : await eventCallback[topic.event]?.(topic.body, { socket: this.websocket });
+            if (eventResponse !== void 0 && eventResponse !== null) {
+              const value = {
+                uuid: topic.uuid,
+                eventUUID: topic.eventUUID,
+                type: topic.type,
+                body: eventResponse
+              };
+              this.websocket.send(JSON.stringify(value));
+            }
+          }
+        }
+      }
+    });
+  }
+  attemptReconnect() {
+    if (this.currentRetryCount >= this.retryConnectionCount) {
+      console.error(`WebSocket reconnection failed after ${this.retryConnectionCount} attempts`);
+      return;
+    }
+    if (this.reconnectTimeout) {
+      return;
+    }
+    this.currentRetryCount++;
+    console.log(`Attempting to reconnect... (${this.currentRetryCount}/${this.retryConnectionCount})`);
+    this.reconnectTimeout = window.setTimeout(() => {
+      this.reconnectTimeout = void 0;
+      this.connect();
+    }, this.retryConnectionDelay);
+  }
+  sendMessage(message) {
+    if (this.isConnected && this.websocket.readyState === WebSocket.OPEN) {
+      this.websocket.send(JSON.stringify(message));
+      return;
+    }
+    if (message.type === "subscribe" || message.type === "unsubscribe") {
+      return;
+    }
+    if (this.maxPendingMessages <= 0) {
+      return;
+    }
+    if (this.pendingMessages.length >= this.maxPendingMessages) {
+      this.pendingMessages.shift();
+    }
+    this.pendingMessages.push(message);
+  }
+  sendBinary(data) {
+    if (this.isConnected && this.websocket.readyState === WebSocket.OPEN) {
+      this.websocket.send(data);
+      return;
+    }
+    if (this.maxPendingBinaryMessages <= 0) {
+      return;
+    }
+    if (this.pendingBinaryMessages.length >= this.maxPendingBinaryMessages) {
+      this.pendingBinaryMessages.shift();
+    }
+    this.pendingBinaryMessages.push(data);
+  }
+  async parseIncomingTopic(data) {
+    if (typeof data === "string") {
+      try {
+        return JSON.parse(data);
+      } catch (error) {
+        console.warn("Invalid WebSocket payload:", error);
+        return void 0;
+      }
+    }
+    if (data instanceof ArrayBuffer) {
+      return this.parseBinaryTopic(data);
+    }
+    if (typeof Blob !== "undefined" && data instanceof Blob) {
+      const buffer = await data.arrayBuffer();
+      return this.parseBinaryTopic(buffer);
+    }
+    return void 0;
+  }
+  parseBinaryTopic(data) {
+    if (data.byteLength < 4) {
+      return void 0;
+    }
+    const view = new DataView(data);
+    const jsonLength = view.getUint32(0, true);
+    const jsonStart = 4;
+    const jsonEnd = jsonStart + jsonLength;
+    if (data.byteLength < jsonEnd) {
+      return void 0;
+    }
+    const jsonBytes = new Uint8Array(data, jsonStart, jsonLength);
+    let meta;
+    try {
+      const decoder = new TextDecoder();
+      meta = JSON.parse(decoder.decode(jsonBytes));
+    } catch (error) {
+      console.warn("Invalid WebSocket binary payload:", error);
+      return void 0;
+    }
+    const filesMeta = Array.isArray(meta.files) ? meta.files : [];
+    const fileMap = /* @__PURE__ */ new Map();
+    filesMeta.forEach((file) => {
+      if (!file || typeof file.id !== "string" || typeof file.size !== "number" || typeof file.offset !== "number") {
+        return;
+      }
+      const start = jsonEnd + file.offset;
+      const end = start + file.size;
+      if (start < jsonEnd || end > data.byteLength) {
+        return;
+      }
+      const slice = data.slice(start, end);
+      const mime = file.mime || "application/octet-stream";
+      let fileValue;
+      if (typeof File !== "undefined") {
+        fileValue = new File([slice], file.name || "file", { type: mime });
+      } else {
+        fileValue = { name: file.name || "file", mime, size: file.size, buffer: slice };
+      }
+      fileMap.set(file.id, fileValue);
+    });
+    const replaceFileRefs = (value) => {
+      if (value && typeof value === "object" && "$file" in value && typeof value.$file === "string") {
+        const file = fileMap.get(value.$file);
+        if (file) {
+          return file;
+        }
+      }
+      if (Array.isArray(value)) {
+        return value.map((item) => replaceFileRefs(item));
+      }
+      if (value && typeof value === "object") {
+        const result = {};
+        Object.keys(value).forEach((key) => {
+          result[key] = replaceFileRefs(value[key]);
+        });
+        return result;
+      }
+      return value;
+    };
+    meta.body = replaceFileRefs(meta.body);
+    return meta;
+  }
+  isBinaryPayload(value) {
+    if (!value) {
+      return false;
+    }
+    if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) {
+      return true;
+    }
+    if (typeof Uint8Array !== "undefined" && value instanceof Uint8Array) {
+      return true;
+    }
+    if (typeof Blob !== "undefined" && value instanceof Blob) {
+      return true;
+    }
+    if (value && typeof value === "object" && "buffer" in value) {
+      const bufferValue = value.buffer;
+      return this.isBinaryPayload(bufferValue);
+    }
+    return false;
+  }
+  hasBinaryPayload(value) {
+    if (this.isBinaryPayload(value)) {
+      return true;
+    }
+    if (Array.isArray(value)) {
+      return value.some((item) => this.hasBinaryPayload(item));
+    }
+    if (value && typeof value === "object") {
+      return Object.keys(value).some((key) => this.hasBinaryPayload(value[key]));
+    }
+    return false;
+  }
+  async buildBinaryMessage(body, meta) {
+    const fileRefs = /* @__PURE__ */ new Map();
+    const fileEntries = [];
+    let fileIndex = 0;
+    const registerFile = (value) => {
+      const existing = fileRefs.get(value);
+      if (existing) {
+        return existing;
+      }
+      const id = `f${++fileIndex}`;
+      fileRefs.set(value, id);
+      let name = "file";
+      let mime = "application/octet-stream";
+      let buffer;
+      if (typeof Blob !== "undefined" && value instanceof Blob) {
+        const fileLike = value;
+        if ("name" in fileLike && typeof fileLike.name === "string") {
+          name = fileLike.name || name;
+        }
+        mime = fileLike.type || mime;
+        buffer = fileLike.arrayBuffer();
+      } else if (value && typeof value === "object" && "buffer" in value) {
+        const fileLike = value;
+        if (typeof fileLike.name === "string") {
+          name = fileLike.name || name;
+        }
+        if (typeof fileLike.mime === "string") {
+          mime = fileLike.mime || mime;
+        }
+        const innerBuffer = fileLike.buffer;
+        if (typeof Blob !== "undefined" && innerBuffer instanceof Blob) {
+          buffer = innerBuffer.arrayBuffer();
+        } else if (typeof Uint8Array !== "undefined" && innerBuffer instanceof Uint8Array) {
+          const sliced = innerBuffer.buffer.slice(innerBuffer.byteOffset, innerBuffer.byteOffset + innerBuffer.byteLength);
+          buffer = Promise.resolve(sliced instanceof ArrayBuffer ? sliced : new Uint8Array(sliced).buffer);
+        } else if (typeof ArrayBuffer !== "undefined" && innerBuffer instanceof ArrayBuffer) {
+          buffer = Promise.resolve(innerBuffer);
+        } else {
+          buffer = Promise.resolve(new ArrayBuffer(0));
+        }
+      } else if (typeof Uint8Array !== "undefined" && value instanceof Uint8Array) {
+        const view = value;
+        const sliced = view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
+        buffer = Promise.resolve(sliced instanceof ArrayBuffer ? sliced : new Uint8Array(sliced).buffer);
+      } else if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) {
+        buffer = Promise.resolve(value);
+      } else {
+        buffer = Promise.resolve(new ArrayBuffer(0));
+      }
+      fileEntries.push({ id, name, mime, buffer });
+      return id;
+    };
+    const replaceFiles = (value) => {
+      if (this.isBinaryPayload(value)) {
+        const id = registerFile(value);
+        return { $file: id };
+      }
+      if (Array.isArray(value)) {
+        return value.map((item) => replaceFiles(item));
+      }
+      if (value && typeof value === "object") {
+        const result = {};
+        Object.keys(value).forEach((key) => {
+          result[key] = replaceFiles(value[key]);
+        });
+        return result;
+      }
+      return value;
+    };
+    const payload = replaceFiles(body);
+    const buffers = await Promise.all(fileEntries.map((entry) => entry.buffer));
+    let offset = 0;
+    const files = fileEntries.map((entry, index) => {
+      const size = buffers[index].byteLength;
+      const fileMeta = {
+        id: entry.id,
+        name: entry.name,
+        mime: entry.mime,
+        size,
+        offset
+      };
+      offset += size;
+      return fileMeta;
+    });
+    const json = JSON.stringify({
+      type: meta.type,
+      uuid: meta.uuid,
+      requestUUID: meta.requestUUID,
+      body: payload,
+      files
+    });
+    const encoder = new TextEncoder();
+    const jsonBytes = encoder.encode(json);
+    const header = new Uint8Array(4);
+    new DataView(header.buffer).setUint32(0, jsonBytes.byteLength, true);
+    const totalSize = header.byteLength + jsonBytes.byteLength + offset;
+    const combined = new Uint8Array(totalSize);
+    combined.set(header, 0);
+    combined.set(jsonBytes, header.byteLength);
+    let cursor = header.byteLength + jsonBytes.byteLength;
+    buffers.forEach((buffer) => {
+      const view = buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : new Uint8Array(buffer);
+      combined.set(view, cursor);
+      cursor += buffer.byteLength;
+    });
+    return combined.buffer;
+  }
+  subject(target, option) {
+    const self = this;
+    const uuid = import_core.RandomUtils.uuid4();
+    const onUnsubscribes = [];
+    if (option?.onUnsubscribe) {
+      onUnsubscribes.push(option.onUnsubscribe);
+    }
+    if (option?.observer && typeof option.observer !== "function" && option.observer.complete) {
+      onUnsubscribes.push(() => option.observer.complete());
+    }
+    const topicSubject = new import_core2.Subject();
+    onUnsubscribes.push(() => topicSubject.complete());
+    let isClosed = false;
+    let activeSubscription;
+    const unsubscribeLogic = () => {
+      if (isClosed) return;
+      const unSubscribeTopic = { type: "unsubscribe", uuid };
+      self.sendMessage(unSubscribeTopic);
+      isClosed = true;
+      self.topics.delete(uuid);
+      onUnsubscribes.forEach((it) => it("manual"));
+      if (activeSubscription) {
+        activeSubscription.closed = true;
+      }
+    };
+    const doSubscribe = (observer) => {
+      const subscription = {
+        closed: isClosed,
+        unsubscribe: unsubscribeLogic
+      };
+      const wrappedObserver = {
+        next: (data, meta) => {
+          topicSubject.next(data);
+          if (observer) {
+            return typeof observer === "function" ? observer(data, meta) : observer.next(data, meta);
+          }
+        },
+        error: (err) => {
+          topicSubject.error(err);
+          if (observer && typeof observer !== "function" && observer.error) {
+            observer.error(err);
+          }
+        },
+        event: observer && typeof observer !== "function" ? observer.event : void 0
+      };
+      self.topics.set(uuid, { observer: wrappedObserver, target, subscription, onUnsubscribes });
+      const subscribeTopic = { type: "subscribe", uuid, target, body: option?.subScribeBody };
+      self.sendMessage(subscribeTopic);
+      activeSubscription = subscription;
+      return subscription;
+    };
+    if (option?.observer) {
+      doSubscribe(option.observer);
+    }
+    return {
+      get closed() {
+        return isClosed;
+      },
+      unsubscribe: unsubscribeLogic,
+      get observable() {
+        return new import_core2.Observable((subscriber) => {
+          if (!activeSubscription && !isClosed) {
+            doSubscribe();
+          }
+          return topicSubject.subscribe({
+            next: (value) => subscriber.next(value),
+            error: (err) => subscriber.error(err),
+            complete: () => subscriber.complete()
+          });
+        });
+      },
+      send: (body) => {
+        if (!activeSubscription && !self.topics.has(uuid) && !isClosed) {
+          doSubscribe();
+        }
+        const requestUUID = import_core.RandomUtils.uuid4();
+        if (self.hasBinaryPayload(body)) {
+          self.buildBinaryMessage(body, { type: option?.type, uuid, requestUUID }).then((buffer) => self.sendBinary(buffer));
+        } else {
+          const value = { type: option?.type, uuid, requestUUID, body };
+          self.sendMessage(value);
+        }
+        return topicSubject.pipe(import_core2.MessageOperator.filter((data) => data && data.requestUUID === requestUUID));
+      },
+      onUnsubscribe: (callback) => {
+        onUnsubscribes.push(callback);
+      }
+    };
+  }
+  onOpen(callback) {
+    this.onOpenCallback = callback;
+  }
+  onClose(callback) {
+    this.onCloseCallback = callback;
+  }
+  subscribe(observer) {
+    this.observer = observer;
+  }
+  close() {
+    this.isManualClose = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = void 0;
+    }
+    this.pendingMessages = [];
+    this.pendingBinaryMessages = [];
+    this.isConnecting = false;
+    this.topics.forEach((topicData) => {
+      topicData.subscription.closed = true;
+      topicData.onUnsubscribes.forEach((it) => it("manual"));
+    });
+    this.topics.clear();
+    this.websocket.close();
+  }
+  reconnect() {
+    this.isManualClose = true;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+    }
+    const reconnectAfterClose = () => {
+      console.log("close websocket");
+      this.isManualClose = false;
+      this.currentRetryCount = 0;
+      this.connect();
+    };
+    if (this.websocket.readyState === WebSocket.CLOSED || this.websocket.readyState === WebSocket.CLOSING) {
+      reconnectAfterClose();
+    } else {
+      this.websocket.addEventListener("close", reconnectAfterClose, { once: true });
+      this.websocket.close();
+    }
+  }
+  getReadyState() {
+    return this.websocket.readyState;
+  }
+  isConnectionOpen() {
+    return this.isConnected && this.websocket.readyState === WebSocket.OPEN;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebSocketClient,
+  ...require("@dooboostore/core")
+});
+//# sourceMappingURL=WebSocketClient.js.map