wispjs 2.3.6 → 3.0.0

package/dist/wisp_socket/ws_adapter.js

@@ -0,0 +1,130 @@
+import WebSocket from "ws";
+import { EventEmitter } from "node:events";
+/**
+ * A thin adapter that exposes a Socket.IO-like event API over a plain `ws`
+ * WebSocket.
+ *
+ * The new backend speaks a simple JSON envelope rather than the Socket.IO /
+ * Engine.IO framing:
+ *
+ * ```json
+ * { "event": "console output", "args": ["...line..."] }
+ * ```
+ *
+ * `args` is omitted entirely when an event carries no payload
+ * (e.g. `{ "event": "auth success" }`).
+ *
+ * This class translates between that envelope and the `.on/.once/.off/.emit`
+ * surface the rest of the codebase already uses, so the calling code barely
+ * changes.
+ *
+ * @remarks
+ * We *compose* an EventEmitter instead of extending one on purpose: extending
+ * it would mean overriding `emit()`, which EventEmitter also calls internally
+ * (e.g. the `newListener` event) — so every `.on()` would try to send a frame
+ * to the server. Composition keeps "emit to the wire" and "fire local
+ * listeners" cleanly separate.
+ *
+ * @internal
+ */
+export class WispWebSocket {
+    constructor(url, opts = {}) {
+        this.emitter = new EventEmitter();
+        this.url = url;
+        this.origin = opts.origin;
+        // The pool registers a handful of listeners per worker; silence the
+        // default 10-listener warning.
+        this.emitter.setMaxListeners(0);
+    }
+    /**
+     * Opens the underlying WebSocket and wires up frame translation.
+     */
+    connect() {
+        const ws = new WebSocket(this.url, this.origin ? { origin: this.origin } : undefined);
+        this.ws = ws;
+        // Map ws lifecycle onto the Socket.IO-style events the pool listens for
+        ws.on("open", () => this.emitter.emit("connect"));
+        ws.on("close", (code, reason) => {
+            this.emitter.emit("disconnect", reason?.toString() || `code ${code}`);
+        });
+        ws.on("error", (err) => this.emitter.emit("connect_error", err));
+        ws.on("message", (data, isBinary) => {
+            if (isBinary)
+                return;
+            let frame;
+            try {
+                frame = JSON.parse(data.toString());
+            }
+            catch {
+                return; // ignore anything that isn't our JSON envelope
+            }
+            const event = frame.event;
+            if (!event)
+                return;
+            const args = frame.args ?? [];
+            // EventEmitter throws if "error" is emitted with no listener; guard it.
+            if (event === "error" && this.emitter.listenerCount("error") === 0) {
+                console.error("[ws] server error frame:", ...args);
+                return;
+            }
+            this.emitter.emit(event, ...args);
+        });
+        return this;
+    }
+    /**
+     * Sends an event to the server as a `{ event, args }` JSON frame.
+     *
+     * @remarks
+     * Unlike EventEmitter.emit, this does NOT fire local listeners — it writes
+     * to the socket. Incoming frames fire local listeners via the internal
+     * emitter.
+     */
+    emit(event, ...args) {
+        this.outgoingListener?.(event, ...args);
+        const frame = JSON.stringify(args.length ? { event, args } : { event });
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(frame);
+        }
+        else {
+            console.error(`[ws] dropped outgoing "${event}" — socket not open`);
+        }
+        return true;
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+        return this;
+    }
+    once(event, listener) {
+        this.emitter.once(event, listener);
+        return this;
+    }
+    /**
+     * Removes a specific listener, or — matching Socket.IO's behaviour — all
+     * listeners for an event when no listener is given.
+     */
+    off(event, listener) {
+        if (listener) {
+            this.emitter.off(event, listener);
+        }
+        else {
+            this.emitter.removeAllListeners(event);
+        }
+        return this;
+    }
+    removeAllListeners(event) {
+        this.emitter.removeAllListeners(event);
+        return this;
+    }
+    /**
+     * Registers a callback invoked for every outgoing emit (parity with
+     * Socket.IO's `onAnyOutgoing`, used for logging).
+     */
+    onAnyOutgoing(listener) {
+        this.outgoingListener = listener;
+        return this;
+    }
+    disconnect() {
+        this.ws?.close();
+        return this;
+    }
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "wispjs",
-  "version": "2.3.6",
+  "version": "3.0.0",
   "type": "module",
   "description": "A package for interacting with Wisp-based server panels",
   "main": "dist/wisp.js",
   "types": "dist/wisp.d.ts",
   "scripts": {
     "build": "tsc",
-    "build-docs": "typedoc wisp.ts wisp_api/index.ts wisp_socket/index.ts wisp_api/apis/*"
+    "build-docs": "typedoc wisp.ts wisp_api/index.ts wisp_socket/index.ts wisp_socket/git.ts wisp_socket/filesystem.ts wisp_api/apis/*"
   },
   "repository": {
     "type": "git",
@@ -20,10 +20,12 @@
   },
   "homepage": "https://github.com/CFC-Servers/WispJS#readme",
   "dependencies": {
-    "socket.io-client": "^4.7.2"
+    "strip-ansi": "^7.1.0",
+    "ws": "^8.21.0"
   },
   "devDependencies": {
     "@types/node": "^20.5.4",
+    "@types/ws": "^8.18.1",
     "typedoc": "^0.25.4",
     "typescript": "^5.3.3"
   }