next-ws 2.0.13 → 2.1.0

package/dist/client/index.cjs

@@ -38,14 +38,13 @@ __export(client_exports, {
 module.exports = __toCommonJS(client_exports);
 
 // src/client/context.tsx
-var import_react = __toESM(require("react"), 1);
-var import_react2 = require("react");
-var WebSocketContext = (0, import_react2.createContext)(null);
+var import_react = __toESM(require("react"));
+var WebSocketContext = (0, import_react.createContext)(null);
 WebSocketContext.displayName = "WebSocketContext";
 var WebSocketConsumer = WebSocketContext.Consumer;
 function WebSocketProvider(p) {
   const clientRef = (0, import_react.useRef)(null);
-  (0, import_react2.useEffect)(() => {
+  (0, import_react.useEffect)(() => {
     if (typeof window === "undefined") return;
     if (clientRef.current) {
       clientRef.current.close();
@@ -62,7 +61,7 @@ function WebSocketProvider(p) {
   return /* @__PURE__ */ import_react.default.createElement(WebSocketContext.Provider, { value: clientRef.current }, p.children);
 }
 function useWebSocket() {
-  const context = (0, import_react2.useContext)(WebSocketContext);
+  const context = (0, import_react.useContext)(WebSocketContext);
   if (context === void 0)
     throw new Error("useWebSocket must be used within a WebSocketProvider");
   return context;

package/dist/server/index.cjs

@@ -38,179 +38,237 @@ __export(server_exports, {
 });
 module.exports = __toCommonJS(server_exports);
 
+// src/server/persistent.ts
+function useGlobal(key) {
+  return [
+    function get() {
+      return Reflect.get(globalThis, key);
+    },
+    function set(value) {
+      return Reflect.set(globalThis, key, value);
+    },
+    function use(getter) {
+      const existing = Reflect.get(globalThis, key);
+      if (existing) return existing;
+      Reflect.set(globalThis, key, getter());
+      return Reflect.get(globalThis, key);
+    }
+  ];
+}
+var [getHttpServer, setHttpServer, useHttpServer] = (
+  //
+  useGlobal(
+    Symbol.for("next-ws.http-server")
+    //
+  )
+);
+var [getWebSocketServer, setWebSocketServer, useWebSocketServer] = (
+  //
+  useGlobal(
+    Symbol.for("next-ws.websocket-server")
+    //
+  )
+);
+var [getRequestStorage, setRequestStorage, useRequestStorage] = (
+  //
+  useGlobal(
+    Symbol.for("next-ws.request-store")
+    //
+  )
+);
+
 // src/server/setup.ts
-var logger3 = __toESM(require("next/dist/build/output/log.js"), 1);
+var import_node_async_hooks = require("async_hooks");
+var logger2 = __toESM(require("next/dist/build/output/log.js"));
 var import_ws = require("ws");
 
-// src/server/helpers/persistent.ts
-var logger = __toESM(require("next/dist/build/output/log.js"), 1);
-function getEnvironmentMeta() {
-  const isCustomServer = !process.title.startsWith("next-");
-  const isMainProcess = process.env.NEXT_WS_MAIN_PROCESS === "1";
-  const isDevelopment = process.env.NODE_ENV === "development";
-  return { isCustomServer, isMainProcess, isDevelopment };
-}
-function mainProcessOnly(fnName) {
-  if (process.env.NEXT_WS_SKIP_ENVIRONMENT_CHECK === "1") return;
-  const meta = getEnvironmentMeta();
-  if (!meta.isMainProcess) {
-    throw new Error(
-      `[next-ws] Attempt to invoke '${fnName}' outside the main process.
-You may be attempting to interact with the WebSocket server outside of a SOCKET handler. This will fail in production, as Next.js employs a worker process for routing, which do not have access to the WebSocket server on the main process.
-You can resolve this by using a custom server.`
-    );
-  } else if (!meta.isCustomServer) {
-    logger.warnOnce(
-      `[next-ws] Caution: The function '${fnName}' was invoked without a custom server.
-This could lead to unintended behaviour, especially if you're attempting to interact with the WebSocket server outside of a SOCKET handler.
-Please note, while such configurations might function during development, they will fail in production. This is because Next.js employs a worker process for routing in production, which do not have access to the WebSocket server on the main process.
-You can resolve this by using a custom server.`
-    );
-  }
-}
-var NextWsHttpServer = Symbol.for("NextWs_HttpServer");
-function setHttpServer(server) {
-  Reflect.set(globalThis, NextWsHttpServer, server);
-}
-function getHttpServer() {
-  mainProcessOnly("getHttpServer");
-  return Reflect.get(globalThis, NextWsHttpServer);
-}
-function useHttpServer(server) {
-  const existing = getHttpServer();
-  if (existing) return existing;
-  if (server) setHttpServer(server);
-  return server;
-}
-var NextWsWebSocketServer = Symbol.for("NextWs_WebSocketServer");
-function setWebSocketServer(wsServer) {
-  Reflect.set(globalThis, NextWsWebSocketServer, wsServer);
-}
-function getWebSocketServer() {
-  mainProcessOnly("getWebSocketServer");
-  return Reflect.get(globalThis, NextWsWebSocketServer);
-}
-function useWebSocketServer(wsServer) {
-  const existing = getWebSocketServer();
-  if (existing) return existing;
-  if (wsServer) setWebSocketServer(wsServer);
-  return wsServer;
-}
-
-// src/server/helpers/route.ts
-var import_node_url = require("url");
-var logger2 = __toESM(require("next/dist/build/output/log.js"), 1);
-function createRouteRegex(routePattern) {
+// src/server/helpers/match.ts
+function compileRoutePattern(routePattern) {
   const escapedPattern = routePattern.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-  const paramRegex = escapedPattern.replace(/\\\[([a-zA-Z0-9_]+)\\\]/g, "(?<$1>[^/]+)").replace(/\\\[(?:\\\.){3}([a-zA-Z0-9_]+)\\\]/g, "(?<rest_$1>.+)");
+  const paramRegex = escapedPattern.replace(/\\\[\\\[(?:\\\.){3}([a-z0-9_]+)\\\]\\\]/gi, "?(?<r_o_$1>.+)?").replace(/\\\[(?:\\\.){3}([a-z0-9_]+)\\\]/gi, "(?<r_$1>.+)").replace(/\\\[([a-z0-9_]+)\\\]/gi, "(?<$1>[^/]+)");
   return new RegExp(`^${paramRegex}$`);
 }
-function getRouteParams(routePattern, routePath) {
-  const routeRegex = createRouteRegex(routePattern);
-  const match = routePath.replace(/\/+$/, "").match(routeRegex);
+function getRouteParams(routePattern, requestPathname) {
+  const routeRegex = compileRoutePattern(routePattern);
+  const match = requestPathname.replace(/\/+$/, "").match(routeRegex);
   if (!match) return null;
   if (!match.groups) return {};
   const params = {};
   for (let [k, v] of Object.entries(match.groups)) {
-    if (k.startsWith("rest_")) {
-      k = k.slice(5);
-      v = v.split("/");
+    if (k.startsWith("r_")) {
+      const optional = k.startsWith("r_o_");
+      k = k.slice(optional ? 4 : 2);
+      v = v?.split("/");
     }
-    Reflect.set(params, k, v);
+    if (v) Reflect.set(params, k, v);
   }
   return params;
 }
-function resolvePathToRoute(nextServer, requestPath) {
-  const basePath = nextServer.serverOptions.conf.basePath;
-  const routes = {
+function findMatchingRoute(nextServer, requestPathname) {
+  const basePath = nextServer.serverOptions?.conf.basePath || "";
+  const appPathRoutes = {
     // @ts-expect-error - appPathRoutes is protected
     ...nextServer.appPathRoutes,
     // @ts-expect-error - getAppPathRoutes is protected
     ...nextServer.getAppPathRoutes()
   };
-  let pathToRoute = null;
-  for (const [routePath, [filePath]] of Object.entries(routes)) {
+  let matchedRoute = void 0;
+  for (const [routePath, [filePath]] of Object.entries(appPathRoutes)) {
+    if (!routePath || !filePath) continue;
     const realPath = `${basePath}${routePath}`;
-    const routeParams = getRouteParams(realPath, requestPath);
-    if (routeParams) pathToRoute = { filePath, routeParams };
+    const routeParams = getRouteParams(realPath, requestPathname);
+    if (routeParams) matchedRoute = { filename: filePath, params: routeParams };
   }
-  return pathToRoute || null;
+  return matchedRoute;
 }
-async function importRouteModule(nextServer, filePath) {
+
+// src/server/helpers/module.ts
+var logger = __toESM(require("next/dist/build/output/log.js"));
+async function importRouteModule(nextServer, filePathname) {
   try {
     if ("hotReloader" in nextServer) {
       await nextServer.hotReloader?.ensurePage({
-        page: filePath,
+        page: filePathname,
         clientOnly: false
       });
     } else if ("ensurePage" in nextServer) {
-      await nextServer.ensurePage({ page: filePath, clientOnly: false });
+      await nextServer.ensurePage({ page: filePathname, clientOnly: false });
     } else {
-      logger2.warnOnce(
+      logger.warnOnce(
         "[next-ws] unable to ensure page, you may need to open the route in your browser first so Next.js compiles it"
       );
     }
   } catch {
   }
-  const buildPagePath = nextServer.getPagePath(filePath);
-  return importModule(buildPagePath);
-}
-async function importModule(modulePath) {
-  const moduleUrl = (0, import_node_url.pathToFileURL)(modulePath).toString();
   try {
-    return import(moduleUrl);
-  } catch (requireError) {
-    try {
-      return require(modulePath);
-    } catch (requireError2) {
-      console.error(`Both import and require failed for ${modulePath}`);
-      throw requireError2;
-    }
+    const buildPagePath = nextServer.getPagePath(filePathname);
+    return (await require(buildPagePath)).routeModule;
+  } catch (cause) {
+    console.error(cause);
+    return void 0;
   }
 }
-async function getSocketHandler(routeModule) {
-  if (routeModule.default instanceof Promise)
-    return getSocketHandler(await routeModule.default);
-  return routeModule?.default?.routeModule?.userland?.SOCKET ?? routeModule?.routeModule?.userland?.SOCKET ?? routeModule?.default?.handlers?.SOCKET ?? routeModule?.handlers?.SOCKET;
+
+// src/server/helpers/request.ts
+var import_server = require("next/server");
+function toNextRequest(message) {
+  const controller = new AbortController();
+  const headers = new Headers(message.headers);
+  const protocol = "encrypted" in message.socket ? "https" : "http";
+  const url = `${protocol}://${headers.get("host")}${message.url}`;
+  message.once("aborted", () => controller.abort());
+  return new import_server.NextRequest(url, {
+    method: message.method,
+    headers,
+    body: message.method === "GET" || message.method === "HEAD" ? void 0 : message,
+    signal: controller.signal,
+    referrer: headers.get("referer") || void 0
+  });
+}
+
+// src/server/helpers/store.ts
+var import_cookies = require("next/dist/compiled/@edge-runtime/cookies");
+var ReadonlyHeaders = class extends Headers {
+  append() {
+    throw new Error("Headers are read-only");
+  }
+  set() {
+    throw new Error("Headers are read-only");
+  }
+  delete() {
+    throw new Error("Headers are read-only");
+  }
+};
+var ReadonlyRequestsCookies = class extends import_cookies.RequestCookies {
+  set() {
+    throw new Error("Cookies are read-only");
+  }
+  delete() {
+    throw new Error("Cookies are read-only");
+  }
+};
+function createRequestStore(request) {
+  return {
+    headers: new ReadonlyHeaders(request.headers),
+    cookies: new ReadonlyRequestsCookies(request.headers)
+  };
 }
 
 // src/server/setup.ts
 function setupWebSocketServer(nextServer) {
-  process.env.NEXT_WS_MAIN_PROCESS = String(1);
-  process.env.NEXT_WS_SKIP_ENVIRONMENT_CHECK = String(1);
-  const httpServer = useHttpServer(nextServer.serverOptions?.httpServer);
-  const wsServer = useWebSocketServer(new import_ws.WebSocketServer({ noServer: true }));
-  process.env.NEXT_WS_SKIP_ENVIRONMENT_CHECK = String(0);
+  const httpServer = (
+    //
+    // @ts-expect-error - serverOptions is protected
+    useHttpServer(() => nextServer.serverOptions?.httpServer)
+  );
   if (!httpServer)
-    return logger3.error("[next-ws] was not able to find the HTTP server");
-  if (!wsServer)
-    return logger3.error("[next-ws] was not able to find the WebSocket server");
-  logger3.ready("[next-ws] has started the WebSocket server");
-  httpServer.on("upgrade", async (request, socket, head) => {
-    const url = new URL(request.url ?? "", "ws://next");
-    const pathname = url.pathname;
+    return logger2.error("[next-ws] was not able to find the HTTP server");
+  const wsServer = (
+    //
+    useWebSocketServer(() => new import_ws.WebSocketServer({ noServer: true }))
+  );
+  const requestStorage = (
+    //
+    useRequestStorage(() => new import_node_async_hooks.AsyncLocalStorage())
+  );
+  logger2.ready("[next-ws] has started the WebSocket server");
+  const kAttached = Symbol.for("next-ws.http-server.attached");
+  if (Reflect.has(httpServer, kAttached)) return;
+  Reflect.set(httpServer, kAttached, true);
+  httpServer.on("upgrade", async (message, socket, head) => {
+    const request = toNextRequest(message);
+    const pathname = request.nextUrl.pathname;
     if (pathname.includes("/_next")) return;
-    const routeInfo = resolvePathToRoute(nextServer, pathname);
-    if (!routeInfo) {
-      logger3.error(`[next-ws] could not find module for page ${pathname}`);
-      return socket.destroy();
+    const route = findMatchingRoute(nextServer, pathname);
+    if (!route) {
+      logger2.error(`[next-ws] could not find route for page ${pathname}`);
+      return socket.end();
     }
-    const routeModule = await importRouteModule(nextServer, routeInfo.filePath);
-    if (!routeModule) {
-      logger3.error(`[next-ws] could not find module for page ${pathname}`);
-      return socket.destroy();
+    const module2 = await importRouteModule(nextServer, route.filename);
+    if (!module2) {
+      logger2.error(`[next-ws] could not import module for page ${pathname}`);
+      return socket.end();
     }
-    const socketHandler = await getSocketHandler(routeModule);
-    if (!socketHandler || typeof socketHandler !== "function") {
-      logger3.error(`[next-ws] ${pathname} does not export a SOCKET handler`);
-      return socket.destroy();
+    const handleUpgrade = module2.userland.UPGRADE;
+    const handleSocket = module2.userland.SOCKET;
+    if ((!handleUpgrade || typeof handleUpgrade !== "function") && (!handleSocket || typeof handleSocket !== "function")) {
+      logger2.error(`[next-ws] route '${pathname}' does not export a handler`);
+      return socket.end();
     }
-    return wsServer.handleUpgrade(request, socket, head, async (c, r) => {
-      const routeContext = { params: routeInfo.routeParams };
-      const handleClose = await socketHandler(c, r, wsServer, routeContext);
-      if (typeof handleClose === "function")
-        c.once("close", () => handleClose());
+    if (handleSocket)
+      logger2.warnOnce(
+        "DeprecationWarning: [next-ws] SOCKET is deprecated, prefer UPGRADE instead, see https://github.com/apteryxxyz/next-ws#-usage"
+      );
+    wsServer.handleUpgrade(message, socket, head, async (client) => {
+      wsServer.emit("connection", client, message);
+      try {
+        const context = { params: route.params };
+        if (handleUpgrade) {
+          await requestStorage.run(
+            createRequestStore(request),
+            //
+            () => handleUpgrade(client, wsServer, request, context)
+          );
+        } else if (handleSocket) {
+          const handleClose = (
+            //
+            await handleSocket(client, message, wsServer, context)
+          );
+          if (typeof handleClose === "function")
+            client.once("close", () => handleClose());
+        }
+      } catch (cause) {
+        logger2.error(
+          `[next-ws] error in socket handler for '${pathname}'`,
+          cause
+        );
+        try {
+          client.close(1011, "Internal Server Error");
+        } catch {
+        }
+      }
     });
+    return;
   });
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server/index.d.ts

@@ -1,32 +1,54 @@
+import * as next_server from 'next/server';
+import * as http from 'http';
+import * as ws from 'ws';
 import NextNodeServer from 'next/dist/server/next-server.js';
-import { Server } from 'node:http';
-import { WebSocketServer } from 'ws';
-
-declare function setupWebSocketServer(nextServer: NextNodeServer): void;
 
 /**
- * Set the HTTP server that the WebSocket server should listen on, must be called before the WebSocket server is created.
- * @param server The HTTP server.
+ * WebSocket socket handler.
+ * @param client WebSocket client instance
+ * @param request Node.js HTTP incoming message instance
+ * @param server WebSocket server instance
+ * @param context Route context
+ * @deprecated Prefer UPGRADE and {@link UpgradeHandler}
+ */
+type SocketHandler = (client: ws.WebSocket, request: http.IncomingMessage, server: ws.WebSocketServer, context: {
+    params: Record<string, string | string[]>;
+}) => unknown;
+/**
+ * WebSocket upgrade handler.
+ * @param client WebSocket client instance
+ * @param server WebSocket server instance
+ * @param request Next.js request instance
+ * @param context Route context
  */
-declare function setHttpServer(server: Server): void;
+type UpgradeHandler = (client: ws.WebSocket, server: ws.WebSocketServer, request: next_server.NextRequest, context: RouteContext<string>) => unknown;
+
 /**
- * Get the HTTP server that the WebSocket server is listening on.
- * @remark If you want to access the HTTP server outside of a SOCKET handler, you must be using a custom server.
- * @returns The HTTP server.
- * @throws If attempting to access the HTTP server outside of the main process.
+ * Extract the parameters from a route pattern.
  */
-declare function getHttpServer(): Server;
+type RouteParams<Pattern extends string> = Pattern extends `${infer Before}[[...${infer Param}]]${infer After}` ? RouteParams<Before> & {
+    [K in Param]?: string[];
+} & RouteParams<After> : Pattern extends `${infer Before}[...${infer Param}]${infer After}` ? RouteParams<Before> & {
+    [K in Param]: string[];
+} & RouteParams<After> : Pattern extends `${infer Before}[${infer Param}]${infer After}` ? RouteParams<Before> & {
+    [K in Param]: string;
+} & RouteParams<After> : {};
 /**
- * Set the WebSocket server that the WebSocket server should listen on, must be called before the WebSocket server is created.
- * @param wsServer The WebSocket server.
+ * Route context object containing the parameters.
  */
-declare function setWebSocketServer(wsServer: WebSocketServer): void;
+type RouteContext<Path extends string> = {
+    params: Record<string, string | string[] | undefined> & RouteParams<Path> & RouteParams<Path>;
+};
+
+declare const getHttpServer: () => http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | undefined;
+declare const setHttpServer: (value: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>) => boolean;
+declare const getWebSocketServer: () => ws.WebSocketServer | undefined;
+declare const setWebSocketServer: (value: ws.WebSocketServer) => boolean;
+
 /**
- * Get the WebSocket server that the WebSocket server is listening on.
- * @remark If you want to access the WebSocket server outside of a SOCKET handler, you must be using a custom server.
- * @returns The WebSocket server.
- * @throws If attempting to access the WebSocket server outside of the main process.
+ * Attach the WebSocket server to the HTTP server.
+ * @param nextServer Next.js Node server instance
  */
-declare function getWebSocketServer(): WebSocketServer;
+declare function setupWebSocketServer(nextServer: NextNodeServer): void;
 
-export { getHttpServer, getWebSocketServer, setHttpServer, setWebSocketServer, setupWebSocketServer };
+export { type RouteContext, type SocketHandler, type UpgradeHandler, getHttpServer, getWebSocketServer, setHttpServer, setWebSocketServer, setupWebSocketServer };

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "next-ws",
-  "version": "2.0.13",
-  "type": "module",
+  "version": "2.1.0",
   "description": "Add support for WebSockets in the Next.js app directory",
   "license": "MIT",
   "keywords": [
@@ -28,43 +27,49 @@
   "exports": {
     "./client": {
       "types": "./dist/client/index.d.ts",
-      "import": "./dist/client/index.js",
-      "require": "./dist/client/index.cjs"
+      "default": "./dist/client/index.cjs"
     },
     "./server": {
       "types": "./dist/server/index.d.ts",
-      "import": "./dist/server/index.js",
-      "require": "./dist/server/index.cjs"
+      "default": "./dist/server/index.cjs"
     },
     "./package.json": "./package.json"
   },
+  "dependencies": {
+    "jscodeshift": "^17.3.0",
+    "minimist": "^1.2.8",
+    "semver": "^7.7.2"
+  },
   "peerDependencies": {
-    "next": ">=13.1.1",
+    "next": ">=13.5.1",
     "react": "*",
     "ws": "*"
   },
   "devDependencies": {
-    "@biomejs/biome": "^1.9.4",
-    "@changesets/changelog-git": "^0.2.0",
+    "@biomejs/biome": "^2.2.0",
+    "@changesets/changelog-git": "^0.2.1",
     "@changesets/cli": "^2.27.12",
-    "@playwright/test": "^1.50.1",
+    "@favware/npm-deprecate": "^2.0.0",
+    "@playwright/test": "^1.55.0",
+    "@types/jscodeshift": "^17.3.0",
     "@types/minimist": "^1.2.5",
-    "@types/node": "^22.13.1",
-    "@types/react": "^19.0.8",
-    "@types/semver": "^7.5.8",
-    "@types/ws": "^8.5.14",
-    "chalk": "^5.4.1",
+    "@types/node": "^24.3.0",
+    "@types/react": "19.1.10",
+    "@types/semver": "^7.7.0",
+    "@types/ws": "^8.18.1",
+    "chalk": "^5.6.0",
     "husky": "^9.1.7",
-    "minimist": "^1.2.8",
+    "next": "15.5.0",
     "pinst": "^3.0.0",
-    "semver": "^7.7.1",
-    "tsup": "^8.3.6",
-    "typescript": "^5.7.3"
+    "react": "19.1.1",
+    "react-dom": "19.1.1",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.2"
   },
   "scripts": {
+    "check": "tsc --noEmit",
     "lint": "biome ci .",
     "format": "biome check . --write",
-    "check": "tsc --noEmit",
     "build": "tsup",
     "dev": "tsup --watch",
     "test": "playwright test",

package/dist/chunk-3RG5ZIWI.js

@@ -1,10 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-export {
-  __require
-};

package/dist/client/index.d.cts

@@ -1,27 +0,0 @@
-import React from 'react';
-
-declare const WebSocketContext: React.Context<WebSocket | null>;
-declare const WebSocketConsumer: React.Consumer<WebSocket | null>;
-/**
- * Provides a WebSocket client to its children via context,
- * allowing for easy access to the WebSocket from anywhere in the app.
- * @param props WebSocket parameters and children.
- * @returns JSX Element
- * @deprecated `WebSocketProvider` is deprecated, use your own implementation instead.
- */
-declare function WebSocketProvider(p: React.PropsWithChildren<{
-    /** The URL for the WebSocket to connect to. */
-    url: string;
-    /** The subprotocols to use. */
-    protocols?: string[] | string;
-    /** The binary type to use. */
-    binaryType?: BinaryType;
-}>): React.JSX.Element;
-/**
- * Access the websocket from anywhere in the app, so long as it's wrapped in a WebSocketProvider.
- * @returns WebSocket client when connected, null when disconnected.
- * @deprecated `useWebSocket` is deprecated, use your own implementation instead.
- */
-declare function useWebSocket(): WebSocket | null;
-
-export { WebSocketConsumer, WebSocketContext, WebSocketProvider, useWebSocket };

package/dist/client/index.js

@@ -1,38 +0,0 @@
-import "../chunk-3RG5ZIWI.js";
-
-// src/client/context.tsx
-import React, { useRef } from "react";
-import { createContext, useContext, useEffect } from "react";
-var WebSocketContext = createContext(null);
-WebSocketContext.displayName = "WebSocketContext";
-var WebSocketConsumer = WebSocketContext.Consumer;
-function WebSocketProvider(p) {
-  const clientRef = useRef(null);
-  useEffect(() => {
-    if (typeof window === "undefined") return;
-    if (clientRef.current) {
-      clientRef.current.close();
-      clientRef.current = null;
-    }
-    const client = new WebSocket(p.url, p.protocols);
-    if (p.binaryType) client.binaryType = p.binaryType;
-    clientRef.current = client;
-    return () => {
-      client.close();
-      clientRef.current = null;
-    };
-  }, [p.url, p.protocols, p.binaryType]);
-  return /* @__PURE__ */ React.createElement(WebSocketContext.Provider, { value: clientRef.current }, p.children);
-}
-function useWebSocket() {
-  const context = useContext(WebSocketContext);
-  if (context === void 0)
-    throw new Error("useWebSocket must be used within a WebSocketProvider");
-  return context;
-}
-export {
-  WebSocketConsumer,
-  WebSocketContext,
-  WebSocketProvider,
-  useWebSocket
-};

package/dist/server/index.d.cts

@@ -1,32 +0,0 @@
-import NextNodeServer from 'next/dist/server/next-server.js';
-import { Server } from 'node:http';
-import { WebSocketServer } from 'ws';
-
-declare function setupWebSocketServer(nextServer: NextNodeServer): void;
-
-/**
- * Set the HTTP server that the WebSocket server should listen on, must be called before the WebSocket server is created.
- * @param server The HTTP server.
- */
-declare function setHttpServer(server: Server): void;
-/**
- * Get the HTTP server that the WebSocket server is listening on.
- * @remark If you want to access the HTTP server outside of a SOCKET handler, you must be using a custom server.
- * @returns The HTTP server.
- * @throws If attempting to access the HTTP server outside of the main process.
- */
-declare function getHttpServer(): Server;
-/**
- * Set the WebSocket server that the WebSocket server should listen on, must be called before the WebSocket server is created.
- * @param wsServer The WebSocket server.
- */
-declare function setWebSocketServer(wsServer: WebSocketServer): void;
-/**
- * Get the WebSocket server that the WebSocket server is listening on.
- * @remark If you want to access the WebSocket server outside of a SOCKET handler, you must be using a custom server.
- * @returns The WebSocket server.
- * @throws If attempting to access the WebSocket server outside of the main process.
- */
-declare function getWebSocketServer(): WebSocketServer;
-
-export { getHttpServer, getWebSocketServer, setHttpServer, setWebSocketServer, setupWebSocketServer };