@gjsify/ws 0.3.13 → 0.3.15

package/lib/esm/constants.js

@@ -1,16 +1,17 @@
-const BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
+//#region src/constants.ts
+const BINARY_TYPES = [
+	"nodebuffer",
+	"arraybuffer",
+	"fragments"
+];
 const EMPTY_BUFFER = new Uint8Array(0);
 const CONNECTING = 0;
 const OPEN = 1;
 const CLOSING = 2;
 const CLOSED = 3;
-const kWebSocket = /* @__PURE__ */ Symbol("ws:kWebSocket");
-export {
-  BINARY_TYPES,
-  CLOSED,
-  CLOSING,
-  CONNECTING,
-  EMPTY_BUFFER,
-  OPEN,
-  kWebSocket
-};
+/** Internal marker for native `globalThis.WebSocket` instances handed in via
+*  `{ socket }` option (not currently supported but reserved). */
+const kWebSocket = Symbol("ws:kWebSocket");
+
+//#endregion
+export { BINARY_TYPES, CLOSED, CLOSING, CONNECTING, EMPTY_BUFFER, OPEN, kWebSocket };

package/lib/esm/index.js

@@ -1,15 +1,13 @@
 import { WebSocket } from "./websocket.js";
 import { WebSocketServer } from "./websocket-server.js";
 import { createWebSocketStream } from "./stream.js";
+
+//#region src/index.ts
 WebSocket.WebSocket = WebSocket;
 WebSocket.WebSocketServer = WebSocketServer;
 WebSocket.Server = WebSocketServer;
 WebSocket.createWebSocketStream = createWebSocketStream;
-var index_default = WebSocket;
-export {
-  WebSocketServer as Server,
-  WebSocket,
-  WebSocketServer,
-  createWebSocketStream,
-  index_default as default
-};
+var src_default = WebSocket;
+
+//#endregion
+export { WebSocketServer as Server, WebSocketServer, WebSocket, createWebSocketStream, src_default as default };

package/lib/esm/stream.js

@@ -1,89 +1,91 @@
 import { Duplex } from "node:stream";
+
+//#region src/stream.ts
 function emitClose(stream) {
-  stream.emit("close");
+	stream.emit("close");
 }
 function duplexOnEnd() {
-  if (!this.destroyed && this._writableState.finished) {
-    this.destroy();
-  }
+	if (!this.destroyed && this._writableState.finished) {
+		this.destroy();
+	}
 }
 function duplexOnError(err) {
-  this.removeListener("error", duplexOnError);
-  this.destroy();
-  if (this.listenerCount("error") === 0) {
-    this.emit("error", err);
-  }
+	this.removeListener("error", duplexOnError);
+	this.destroy();
+	if (this.listenerCount("error") === 0) {
+		this.emit("error", err);
+	}
 }
 function createWebSocketStream(ws, options = {}) {
-  let terminateOnDestroy = true;
-  const duplex = new Duplex({
-    ...options,
-    autoDestroy: false,
-    emitClose: false,
-    objectMode: false,
-    writableObjectMode: false
-  });
-  ws.on("message", (msg, isBinary) => {
-    let data;
-    if (isBinary || duplex.readableObjectMode) {
-      data = msg;
-    } else {
-      data = typeof msg === "string" ? Buffer.from(msg) : msg;
-    }
-    if (!duplex.push(data) && typeof ws.pause === "function") ws.pause();
-  });
-  ws.once("error", (err) => {
-    if (duplex.destroyed) return;
-    terminateOnDestroy = false;
-    duplex.destroy(err);
-  });
-  ws.once("close", () => {
-    if (duplex.destroyed) return;
-    duplex.push(null);
-  });
-  duplex._destroy = function(err, callback) {
-    if (ws.readyState === ws.CLOSED) {
-      callback(err);
-      process.nextTick(emitClose, duplex);
-      return;
-    }
-    let called = false;
-    ws.once("error", (e) => {
-      called = true;
-      callback(e);
-    });
-    ws.once("close", () => {
-      if (!called) callback(err);
-      process.nextTick(emitClose, duplex);
-    });
-    if (terminateOnDestroy) ws.terminate();
-  };
-  duplex._final = function(callback) {
-    if (ws.readyState === ws.CONNECTING) {
-      ws.once("open", () => duplex._final(callback));
-      return;
-    }
-    if (ws.readyState === ws.CLOSED || ws.readyState === ws.CLOSING) {
-      callback();
-      return;
-    }
-    ws.once("close", callback);
-    ws.close();
-  };
-  duplex._read = function() {
-    if (typeof ws.resume === "function") ws.resume();
-  };
-  duplex._write = function(chunk, _encoding, callback) {
-    if (ws.readyState === ws.CONNECTING) {
-      ws.once("open", () => duplex._write(chunk, _encoding, callback));
-      return;
-    }
-    ws.send(chunk, callback);
-  };
-  duplex.on("end", duplexOnEnd);
-  duplex.on("error", duplexOnError);
-  return duplex;
+	let terminateOnDestroy = true;
+	const duplex = new Duplex({
+		...options,
+		autoDestroy: false,
+		emitClose: false,
+		objectMode: false,
+		writableObjectMode: false
+	});
+	ws.on("message", (msg, isBinary) => {
+		let data;
+		if (isBinary || duplex.readableObjectMode) {
+			data = msg;
+		} else {
+			data = typeof msg === "string" ? Buffer.from(msg) : msg;
+		}
+		if (!duplex.push(data) && typeof ws.pause === "function") ws.pause();
+	});
+	ws.once("error", (err) => {
+		if (duplex.destroyed) return;
+		terminateOnDestroy = false;
+		duplex.destroy(err);
+	});
+	ws.once("close", () => {
+		if (duplex.destroyed) return;
+		duplex.push(null);
+	});
+	duplex._destroy = function(err, callback) {
+		if (ws.readyState === ws.CLOSED) {
+			callback(err);
+			process.nextTick(emitClose, duplex);
+			return;
+		}
+		let called = false;
+		ws.once("error", (e) => {
+			called = true;
+			callback(e);
+		});
+		ws.once("close", () => {
+			if (!called) callback(err);
+			process.nextTick(emitClose, duplex);
+		});
+		if (terminateOnDestroy) ws.terminate();
+	};
+	duplex._final = function(callback) {
+		if (ws.readyState === ws.CONNECTING) {
+			ws.once("open", () => duplex._final(callback));
+			return;
+		}
+		if (ws.readyState === ws.CLOSED || ws.readyState === ws.CLOSING) {
+			callback();
+			return;
+		}
+		ws.once("close", callback);
+		ws.close();
+	};
+	duplex._read = function() {
+		if (typeof ws.resume === "function") ws.resume();
+	};
+	duplex._write = function(chunk, _encoding, callback) {
+		if (ws.readyState === ws.CONNECTING) {
+			ws.once("open", () => duplex._write(chunk, _encoding, callback));
+			return;
+		}
+		ws.send(chunk, callback);
+	};
+	duplex.on("end", duplexOnEnd);
+	duplex.on("error", duplexOnError);
+	return duplex;
 }
-export {
-  createWebSocketStream
-};
+
+//#endregion
+export { createWebSocketStream };