@kabyeon/nexusjs 0.6.5

package/dist/ws/index.js

@@ -0,0 +1,796 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/core/decorators/controller.ts
+import"reflect-metadata";
+function Controller(prefix = "/") {
+  return (target) => {
+    const normalized = normalizePrefix(prefix);
+    const meta = { prefix: normalized };
+    Reflect.defineMetadata(METADATA_KEY.CONTROLLER, meta, target);
+  };
+}
+function getControllerMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.CONTROLLER, target) ?? { prefix: "/" };
+}
+function isController(target) {
+  return Reflect.hasMetadata(METADATA_KEY.CONTROLLER, target);
+}
+function normalizePrefix(prefix) {
+  if (!prefix)
+    return "";
+  if (prefix !== "/" && prefix.endsWith("/")) {
+    return prefix.slice(0, -1);
+  }
+  return prefix;
+}
+var init_controller = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/http-methods.ts
+import"reflect-metadata";
+function defineRoute(method, path) {
+  return (target, propertyKey, descriptor) => {
+    const routes = Reflect.getMetadata(METADATA_KEY.ROUTES, target.constructor) ?? [];
+    routes.push({
+      method,
+      path: normalizePath(path),
+      propertyKey,
+      handler: descriptor.value
+    });
+    Reflect.defineMetadata(METADATA_KEY.ROUTES, routes, target.constructor);
+  };
+}
+function normalizePath(path) {
+  if (!path || path === "/")
+    return "/";
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function getRoutes(target) {
+  return Reflect.getMetadata(METADATA_KEY.ROUTES, target) ?? [];
+}
+var Get = (path = "/") => defineRoute("GET", path), Post = (path = "/") => defineRoute("POST", path), Put = (path = "/") => defineRoute("PUT", path), Delete = (path = "/") => defineRoute("DELETE", path), Patch = (path = "/") => defineRoute("PATCH", path), Options = (path = "/") => defineRoute("OPTIONS", path), Head = (path = "/") => defineRoute("HEAD", path);
+var init_http_methods = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/params.ts
+import"reflect-metadata";
+function createParamDecorator(type, data) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target, propertyKey);
+    } else {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target);
+    }
+  };
+}
+function getParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+}
+var Req = () => createParamDecorator(PARAM_TYPES.REQUEST), Res = () => createParamDecorator(PARAM_TYPES.RESPONSE), Next = () => createParamDecorator(PARAM_TYPES.NEXT), Body = (key) => createParamDecorator(PARAM_TYPES.BODY, key), Query = (key) => createParamDecorator(PARAM_TYPES.QUERY, key), Param = (key) => createParamDecorator(PARAM_TYPES.PARAM, key), Headers = (key) => createParamDecorator(PARAM_TYPES.HEADERS, key), Ctx = () => createParamDecorator(PARAM_TYPES.CTX), User = () => createParamDecorator(PARAM_TYPES.USER);
+var init_params = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/validate.ts
+import"reflect-metadata";
+function Validate(options) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(METADATA_KEY.VALIDATE, options, target.constructor, propertyKey);
+  };
+}
+function getValidationMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.VALIDATE, target, propertyKey);
+}
+var init_validate = __esm(() => {
+  init_constants();
+});
+
+// src/ws/service.ts
+var WEBSOCKET_SERVICE_TOKEN = Symbol.for("nexus:WebSocketService");
+
+class WebSocketService {
+  clients = new Map;
+  rooms = new Map;
+  onConnectListeners = [];
+  onDisconnectListeners = [];
+  register(client) {
+    this.clients.set(client.id, client);
+    for (const cb of this.onConnectListeners) {
+      try {
+        cb(client);
+      } catch {}
+    }
+    return client.id;
+  }
+  unregister(client) {
+    this.clients.delete(client.id);
+    for (const room of client.rooms) {
+      const set = this.rooms.get(room);
+      if (set) {
+        set.delete(client.id);
+        if (set.size === 0)
+          this.rooms.delete(room);
+      }
+    }
+    for (const cb of this.onDisconnectListeners) {
+      try {
+        cb(client);
+      } catch {}
+    }
+  }
+  get size() {
+    return this.clients.size;
+  }
+  getConnections() {
+    return [...this.clients.values()];
+  }
+  getConnection(id) {
+    return this.clients.get(id);
+  }
+  joinRoom(client, room) {
+    const impl = client;
+    impl.joinRoom(room);
+    let set = this.rooms.get(room);
+    if (!set) {
+      set = new Set;
+      this.rooms.set(room, set);
+    }
+    set.add(client.id);
+  }
+  leaveRoom(client, room) {
+    const impl = client;
+    impl.leaveRoom(room);
+    const set = this.rooms.get(room);
+    if (set) {
+      set.delete(client.id);
+      if (set.size === 0)
+        this.rooms.delete(room);
+    }
+  }
+  leaveAllRooms(client) {
+    const impl = client;
+    for (const room of impl.rooms) {
+      const set = this.rooms.get(room);
+      if (set) {
+        set.delete(client.id);
+        if (set.size === 0)
+          this.rooms.delete(room);
+      }
+    }
+    impl.rooms.clear();
+  }
+  getRoomMembers(room) {
+    const ids = this.rooms.get(room);
+    if (!ids)
+      return [];
+    const out = [];
+    for (const id of ids) {
+      const c = this.clients.get(id);
+      if (c)
+        out.push(c);
+    }
+    return out;
+  }
+  getRooms() {
+    return [...this.rooms.keys()];
+  }
+  hasRoom(room) {
+    const set = this.rooms.get(room);
+    return !!set && set.size > 0;
+  }
+  broadcast(data, filter) {
+    for (const client of this.clients.values()) {
+      if (filter && !filter(client))
+        continue;
+      try {
+        client.send(data);
+      } catch {}
+    }
+  }
+  broadcastToRoom(room, data) {
+    const ids = this.rooms.get(room);
+    if (!ids)
+      return;
+    for (const id of ids) {
+      const client = this.clients.get(id);
+      if (!client)
+        continue;
+      try {
+        client.send(data);
+      } catch {}
+    }
+  }
+  sendTo(id, data) {
+    const client = this.clients.get(id);
+    if (!client)
+      return false;
+    try {
+      client.send(data);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  closeAll(code = 1001, reason = "Server shutting down") {
+    for (const client of this.clients.values()) {
+      try {
+        client.close(code, reason);
+      } catch {}
+    }
+  }
+  onConnect(cb) {
+    this.onConnectListeners.push(cb);
+  }
+  onDisconnect(cb) {
+    this.onDisconnectListeners.push(cb);
+  }
+}
+// src/ws/client.ts
+import { randomUUID } from "crypto";
+
+class WebSocketClientImpl {
+  id;
+  rooms = new Set;
+  data = {};
+  _underlying;
+  constructor(underlying, id) {
+    this.id = id ?? randomUUID();
+    this._underlying = underlying;
+  }
+  get url() {
+    return this._underlying.url;
+  }
+  get protocol() {
+    return this._underlying.protocol;
+  }
+  get readyState() {
+    return this._underlying.readyState;
+  }
+  send(data) {
+    if (typeof data === "object" && !(data instanceof ArrayBuffer) && !(data instanceof Uint8Array)) {
+      this._underlying.send(JSON.stringify(data));
+    } else {
+      this._underlying.send(data);
+    }
+  }
+  close(code, reason) {
+    this._underlying.close(code, reason);
+  }
+  setData(data) {
+    Object.assign(this.data, data);
+  }
+  joinRoom(room) {
+    this.rooms.add(room);
+  }
+  leaveRoom(room) {
+    this.rooms.delete(room);
+  }
+  raw() {
+    return this._underlying;
+  }
+}
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/core/decorators/index.ts
+init_controller();
+
+// src/core/decorators/injectable.ts
+init_constants();
+import"reflect-metadata";
+function Injectable(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+    if (options.scope) {
+      Reflect.defineMetadata("nexus:di:scope", options.scope, target);
+    }
+  };
+}
+function isInjectable(target) {
+  return Reflect.hasMetadata(METADATA_KEY.INJECTABLE, target);
+}
+function getScope(target) {
+  return Reflect.getMetadata("nexus:di:scope", target);
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(METADATA_KEY.INJECT, target) ?? new Map;
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(METADATA_KEY.INJECT, existing, target);
+  };
+}
+
+// src/core/decorators/index.ts
+init_http_methods();
+init_params();
+init_validate();
+
+// src/core/decorators/repository.ts
+init_constants();
+import"reflect-metadata";
+function Repository(entityToken) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.REPOSITORY, { entity: entityToken }, target);
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+  };
+}
+function getRepositoryMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.REPOSITORY, target);
+}
+function isRepository(target) {
+  return Reflect.hasMetadata(METADATA_KEY.REPOSITORY, target);
+}
+// src/core/decorators/metadata.ts
+init_constants();
+// src/ws/runtime/index.ts
+function detectRuntime() {
+  if (typeof globalThis.Bun !== "undefined")
+    return "bun";
+  if (typeof process !== "undefined" && process.versions?.node)
+    return "node";
+  if (typeof globalThis.caches !== "undefined" && typeof globalThis.WebSocketPair !== "undefined") {
+    return "cloudflare";
+  }
+  return "unknown";
+}
+
+// src/ws/module.ts
+class WebSocketModule {
+  static forRoot(config = {}) {
+    const fullConfig = {
+      path: config.path ?? "/ws",
+      json: config.json ?? true,
+      heartbeatSeconds: config.heartbeatSeconds ?? 30,
+      onUnknownRuntime: config.onUnknownRuntime ?? "throw",
+      gateways: config.gateways ?? []
+    };
+
+    class ConfiguredWebSocketModule {
+      service;
+      constructor(service) {
+        this.service = service;
+      }
+      detectRuntime() {
+        return detectRuntime();
+      }
+    }
+    ConfiguredWebSocketModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          WebSocketService,
+          { provide: WEBSOCKET_SERVICE_TOKEN, useExisting: WebSocketService },
+          { provide: "WS_CONFIG", useValue: fullConfig }
+        ],
+        exports: [WebSocketService, WEBSOCKET_SERVICE_TOKEN, "WS_CONFIG"]
+      }),
+      __legacyDecorateParamTS(0, Inject(WEBSOCKET_SERVICE_TOKEN)),
+      __legacyMetadataTS("design:paramtypes", [
+        typeof WebSocketService === "undefined" ? Object : WebSocketService
+      ])
+    ], ConfiguredWebSocketModule);
+    Object.defineProperty(ConfiguredWebSocketModule, "name", {
+      value: "ConfiguredWebSocketModule"
+    });
+    return ConfiguredWebSocketModule;
+  }
+}
+WebSocketModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      WebSocketService,
+      { provide: WEBSOCKET_SERVICE_TOKEN, useExisting: WebSocketService }
+    ],
+    exports: [WebSocketService, WEBSOCKET_SERVICE_TOKEN]
+  })
+], WebSocketModule);
+// src/ws/decorators.ts
+var GATEWAY_KEY = Symbol.for("nexus:ws:gateway");
+var LIFECYCLE_KEY = Symbol.for("nexus:ws:lifecycle");
+function WebSocketGateway(path) {
+  return function(target) {
+    const ctor = target;
+    const proto = ctor.prototype ?? target;
+    const handlers = {};
+    for (const name of Object.getOwnPropertyNames(proto)) {
+      if (name === "constructor")
+        continue;
+      const m = proto[name];
+      if (typeof m === "function" && m[LIFECYCLE_KEY]) {
+        Object.assign(handlers, m[LIFECYCLE_KEY]);
+      }
+    }
+    proto[GATEWAY_KEY] = { path, handlers };
+  };
+}
+function getGatewayPath(target) {
+  const t = target;
+  const meta = t[GATEWAY_KEY];
+  return meta?.path;
+}
+function makeLifecycleDecorator(lifecycle) {
+  return function(_target, propertyKey, descriptor) {
+    const fn = descriptor.value;
+    if (typeof fn !== "function")
+      return descriptor;
+    fn[LIFECYCLE_KEY] = fn[LIFECYCLE_KEY] ?? {};
+    fn[LIFECYCLE_KEY][lifecycle] = String(propertyKey);
+    return descriptor;
+  };
+}
+function OnWebSocketOpen() {
+  return makeLifecycleDecorator("open");
+}
+function OnWebSocketMessage() {
+  return makeLifecycleDecorator("message");
+}
+function OnWebSocketClose() {
+  return makeLifecycleDecorator("close");
+}
+function OnWebSocketError() {
+  return makeLifecycleDecorator("error");
+}
+function getLifecycleHandlers(target) {
+  const t = target;
+  if (t[GATEWAY_KEY]?.handlers)
+    return t[GATEWAY_KEY].handlers;
+  const out = {};
+  const proto = t.prototype ?? t;
+  for (const name of Object.getOwnPropertyNames(proto)) {
+    if (name === "constructor")
+      continue;
+    const m = proto[name];
+    if (typeof m === "function" && m[LIFECYCLE_KEY]) {
+      Object.assign(out, m[LIFECYCLE_KEY]);
+    }
+  }
+  return out;
+}
+
+// src/ws/runtime/bun.ts
+class BunWsAdapter {
+  service;
+  options;
+  constructor(service, options = {}) {
+    this.service = service;
+    this.options = options;
+  }
+  async install(app, gateways) {
+    const { createBunWebSocket } = await import("hono/bun");
+    const { upgradeWebSocket, websocket } = createBunWebSocket();
+    for (const Gateway of gateways) {
+      const path = getGatewayPath(Gateway.prototype);
+      if (!path) {
+        throw new Error(`WebSocket gateway ${Gateway.name} is missing @WebSocketGateway(path)`);
+      }
+      const handlers = getLifecycleHandlers(Gateway.prototype);
+      const opts = this.options;
+      app.get(path, upgradeWebSocket((_c) => {
+        const gateway = new Gateway;
+        if (gateway && "setService" in gateway && typeof gateway.setService === "function") {
+          gateway.setService(this.service);
+        }
+        return {
+          onOpen: (_evt, ws) => {
+            const client = new WebSocketClientImpl(ws);
+            this.service.register(client);
+            (opts.onOpen ?? this.defaultOnOpen)(client);
+            if (handlers.open) {
+              Promise.resolve(gateway[handlers.open](client)).catch((err) => opts.onError?.(client, err));
+            }
+          },
+          onMessage: (evt, ws) => {
+            const id = ws.__clientId;
+            const client = id ? this.service.getConnection(id) : undefined;
+            if (!client)
+              return;
+            const raw = evt.data;
+            const data = this.parseMessage(raw);
+            if (handlers.message) {
+              Promise.resolve(gateway[handlers.message](client, data)).catch((err) => opts.onError?.(client, err));
+            }
+          },
+          onClose: (evt, ws) => {
+            const id = ws.__clientId;
+            const client = id ? this.service.getConnection(id) : undefined;
+            if (!client)
+              return;
+            this.service.unregister(client);
+            (opts.onClose ?? this.defaultOnClose)(client, evt.code, evt.reason);
+            if (handlers.close) {
+              Promise.resolve(gateway[handlers.close](client, evt.code, evt.reason)).catch((err) => opts.onError?.(client, err));
+            }
+          },
+          onError: (evt, ws) => {
+            const id = ws.__clientId;
+            const client = id ? this.service.getConnection(id) : undefined;
+            if (!client)
+              return;
+            const err = evt.error ?? new Error("WebSocket error");
+            if (handlers.error) {
+              Promise.resolve(gateway[handlers.error](client, err)).catch(() => {});
+            } else {
+              opts.onError?.(client, err);
+            }
+          }
+        };
+      }));
+    }
+    return { websocket };
+  }
+  parseMessage(raw) {
+    if (this.options.json === false)
+      return raw;
+    if (typeof raw === "string") {
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return raw;
+      }
+    }
+    return raw;
+  }
+  defaultOnOpen(_client) {}
+  defaultOnClose(_client, _code, _reason) {}
+}
+// src/ws/runtime/node.ts
+class NodeWsAdapter {
+  service;
+  options;
+  constructor(service, options = {}) {
+    this.service = service;
+    this.options = options;
+  }
+  async bind(gateways) {
+    let WS;
+    try {
+      WS = (await import("ws")).default ? await import("ws") : await import("ws");
+      const WebSocketServer = WS.WebSocketServer ?? WS.Server ?? WS.default?.WebSocketServer;
+      if (!WebSocketServer)
+        throw new Error("no WebSocketServer export");
+    } catch (err) {
+      throw new Error("WebSocketModule.forRoot() on Node requires the `ws` package. Install with: bun add ws");
+    }
+    const handlers = new Map;
+    const gatewayInstances = new Map;
+    for (const Gateway of gateways) {
+      const path = getGatewayPath(Gateway.prototype);
+      if (!path)
+        continue;
+      gatewayInstances.set(path, Gateway);
+      handlers.set(path, (req) => {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        return url.pathname === path;
+      });
+    }
+    const wss = new WS.WebSocketServer({ noServer: true });
+    const opts = this.options;
+    const service = this.service;
+    wss.on("connection", (ws, req) => {
+      const url = new URL(req.url ?? "/", "http://localhost");
+      const path = url.pathname;
+      const Gateway = gatewayInstances.get(path);
+      if (!Gateway) {
+        ws.close(1008, "Unknown path");
+        return;
+      }
+      const gateway = new Gateway;
+      if (gateway && "setService" in gateway && typeof gateway.setService === "function") {
+        gateway.setService(service);
+      }
+      const client = new WebSocketClientImpl(adaptUnderlying(ws, req));
+      service.register(client);
+      (opts.onOpen ?? (() => {}))(client);
+      const handlers2 = getLifecycleHandlers(Gateway.prototype);
+      ws.on("message", (data) => {
+        const parsed = this.parseMessage(data);
+        if (handlers2.message) {
+          Promise.resolve(gateway[handlers2.message](client, parsed)).catch((err) => opts.onError?.(client, err));
+        }
+      });
+      ws.on("close", (code, reasonBuf) => {
+        const reason = reasonBuf?.toString?.() ?? "";
+        service.unregister(client);
+        (opts.onClose ?? (() => {}))(client, code, reason);
+        if (handlers2.close) {
+          Promise.resolve(gateway[handlers2.close](client, code, reason)).catch((err) => opts.onError?.(client, err));
+        }
+      });
+      ws.on("error", (err) => {
+        if (handlers2.error) {
+          Promise.resolve(gateway[handlers2.error](client, err)).catch(() => {});
+        } else {
+          opts.onError?.(client, err);
+        }
+      });
+    });
+    return {
+      handleUpgrade(req, socket, head, callback) {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        const handler = handlers.get(url.pathname);
+        if (!handler || !handler(req)) {
+          socket.write(`HTTP/1.1 404 Not Found\r
+\r
+`);
+          socket.destroy();
+          return;
+        }
+        wss.handleUpgrade(req, socket, head, callback ?? (() => {}));
+      }
+    };
+  }
+  parseMessage(raw) {
+    if (this.options.json === false)
+      return raw;
+    if (typeof raw === "string") {
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return raw;
+      }
+    }
+    if (raw && typeof raw === "object" && "toString" in raw) {
+      const s = raw.toString();
+      try {
+        return JSON.parse(s);
+      } catch {
+        return s;
+      }
+    }
+    return raw;
+  }
+}
+function adaptUnderlying(ws, req) {
+  return {
+    send(data, _options) {
+      ws.send(data);
+    },
+    close(code, reason) {
+      ws.close(code, reason);
+    },
+    get readyState() {
+      return ws.readyState;
+    },
+    get url() {
+      return req.url ?? null;
+    },
+    get protocol() {
+      return ws.protocol ?? null;
+    }
+  };
+}
+export {
+  getLifecycleHandlers,
+  getGatewayPath,
+  detectRuntime,
+  WebSocketService,
+  WebSocketModule,
+  WebSocketGateway,
+  WebSocketClientImpl,
+  WEBSOCKET_SERVICE_TOKEN,
+  OnWebSocketOpen,
+  OnWebSocketMessage,
+  OnWebSocketError,
+  OnWebSocketClose,
+  NodeWsAdapter,
+  BunWsAdapter
+};
+
+//# debugId=CC6E4E5365D7A8D564756E2164756E21
+//# sourceMappingURL=index.js.map