@forklaunch/ws 0.1.8 → 0.2.0

package/lib/index.d.mts

@@ -149,7 +149,7 @@ declare class ForklaunchWebSocket<SV extends AnySchemaValidator, const ES extend
      *
      * @internal
      */
-    protected validateAndEncode(data: unknown, schema: IdiomaticSchema<SV> | undefined, allowUndefined?: boolean, context?: string): Buffer<ArrayBufferLike> | undefined;
+    protected validateAndEncode(data: unknown, schema: IdiomaticSchema<SV> | undefined, allowUndefined?: boolean, context?: string): Buffer | undefined;
     /**
      * Transforms incoming event arguments by decoding and validating them.
      *
@@ -180,7 +180,7 @@ declare class ForklaunchWebSocket<SV extends AnySchemaValidator, const ES extend
      *
      * @internal
      */
-    protected wrapListenerWithTransformation<Event extends string | symbol>(superMethod: (event: Event, listener: (ws: WebSocket, ...args: never[]) => void) => this, event: Event, listener: (ws: WebSocket, ...args: unknown[]) => void): this;
+    protected wrapListenerWithTransformation<Event extends string | symbol>(superMethod: (event: Event, listener: (this: WebSocket, ...args: never[]) => void) => this, event: Event, listener: (this: WebSocket, ...args: unknown[]) => void): this;
     /**
      * Registers an event listener with automatic data validation and transformation.
      *
@@ -361,6 +361,20 @@ declare class ForklaunchWebSocket<SV extends AnySchemaValidator, const ES extend
      * ws.emit('error', { code: 500, message: 'Server error' });
      * ```
      */
+    /**
+     * Emits an event on the WebSocket.
+     *
+     * This method passes through to the underlying EventEmitter without
+     * transforming data. The ws library uses emit() internally to dispatch
+     * incoming events (message, close, ping, pong), so encoding here would
+     * incorrectly process incoming data as outgoing data.
+     *
+     * For sending data, use the dedicated methods instead:
+     * - {@link send} for messages
+     * - {@link close} for closing with a reason
+     * - {@link ping} for ping frames
+     * - {@link pong} for pong frames
+     */
     emit<K extends keyof OutgoingEventMap<SV, ES>>(event: K, ...args: OutgoingEventMap<SV, ES>[K]): boolean;
     /**
      * Sends data over the WebSocket with automatic validation and encoding.
@@ -604,6 +618,16 @@ declare class ForklaunchWebSocketServer<SV extends AnySchemaValidator, const ES
      * ```
      */
     constructor(schemaValidator: SV, eventSchemas: ES, options?: ConstructorParameters<typeof WebSocketServer>[0], callback?: () => void);
+    /**
+     * Intercepts emit to enhance WebSocket instances on 'connection' events.
+     *
+     * When the ws library internally emits 'connection', we swap the raw WebSocket
+     * for an enhanced ForklaunchWebSocket before listeners receive it. This avoids
+     * infinite recursion that would occur if we used a listener + re-emit pattern.
+     *
+     * @internal
+     */
+    emit(event: string | symbol, ...args: unknown[]): boolean;
     /**
      * Enhances a plain WebSocket instance with ForklaunchWebSocket functionality.
      *

package/lib/index.d.ts

@@ -149,7 +149,7 @@ declare class ForklaunchWebSocket<SV extends AnySchemaValidator, const ES extend
      *
      * @internal
      */
-    protected validateAndEncode(data: unknown, schema: IdiomaticSchema<SV> | undefined, allowUndefined?: boolean, context?: string): Buffer<ArrayBufferLike> | undefined;
+    protected validateAndEncode(data: unknown, schema: IdiomaticSchema<SV> | undefined, allowUndefined?: boolean, context?: string): Buffer | undefined;
     /**
      * Transforms incoming event arguments by decoding and validating them.
      *
@@ -180,7 +180,7 @@ declare class ForklaunchWebSocket<SV extends AnySchemaValidator, const ES extend
      *
      * @internal
      */
-    protected wrapListenerWithTransformation<Event extends string | symbol>(superMethod: (event: Event, listener: (ws: WebSocket, ...args: never[]) => void) => this, event: Event, listener: (ws: WebSocket, ...args: unknown[]) => void): this;
+    protected wrapListenerWithTransformation<Event extends string | symbol>(superMethod: (event: Event, listener: (this: WebSocket, ...args: never[]) => void) => this, event: Event, listener: (this: WebSocket, ...args: unknown[]) => void): this;
     /**
      * Registers an event listener with automatic data validation and transformation.
      *
@@ -361,6 +361,20 @@ declare class ForklaunchWebSocket<SV extends AnySchemaValidator, const ES extend
      * ws.emit('error', { code: 500, message: 'Server error' });
      * ```
      */
+    /**
+     * Emits an event on the WebSocket.
+     *
+     * This method passes through to the underlying EventEmitter without
+     * transforming data. The ws library uses emit() internally to dispatch
+     * incoming events (message, close, ping, pong), so encoding here would
+     * incorrectly process incoming data as outgoing data.
+     *
+     * For sending data, use the dedicated methods instead:
+     * - {@link send} for messages
+     * - {@link close} for closing with a reason
+     * - {@link ping} for ping frames
+     * - {@link pong} for pong frames
+     */
     emit<K extends keyof OutgoingEventMap<SV, ES>>(event: K, ...args: OutgoingEventMap<SV, ES>[K]): boolean;
     /**
      * Sends data over the WebSocket with automatic validation and encoding.
@@ -604,6 +618,16 @@ declare class ForklaunchWebSocketServer<SV extends AnySchemaValidator, const ES
      * ```
      */
     constructor(schemaValidator: SV, eventSchemas: ES, options?: ConstructorParameters<typeof WebSocketServer>[0], callback?: () => void);
+    /**
+     * Intercepts emit to enhance WebSocket instances on 'connection' events.
+     *
+     * When the ws library internally emits 'connection', we swap the raw WebSocket
+     * for an enhanced ForklaunchWebSocket before listeners receive it. This avoids
+     * infinite recursion that would occur if we used a listener + re-emit pattern.
+     *
+     * @internal
+     */
+    emit(event: string | symbol, ...args: unknown[]): boolean;
     /**
      * Enhances a plain WebSocket instance with ForklaunchWebSocket functionality.
      *

package/lib/index.js

@@ -139,9 +139,8 @@ var ForklaunchWebSocket = class extends import_ws2.WebSocket {
     let transformedArgs = args;
     if (event === "message" && args.length >= 2) {
       const data = args[0];
-      const isBinary = args[1];
       const serverSchema = this.schemas.serverMessagesSchema;
-      if (typeof isBinary === "boolean" && isBinary && serverSchema) {
+      if (serverSchema) {
         const validated = this.decodeAndValidate(data, serverSchema);
         transformedArgs = [validated, false, ...args.slice(2)];
       }
@@ -179,9 +178,14 @@ var ForklaunchWebSocket = class extends import_ws2.WebSocket {
    * @internal
    */
   wrapListenerWithTransformation(superMethod, event, listener) {
-    return superMethod(event, (ws, ...args) => {
-      const transformedArgs = this.transformIncomingArgs(event, args);
-      return listener(ws, ...transformedArgs);
+    const self = this;
+    return superMethod(event, function(...args) {
+      try {
+        const transformedArgs = self.transformIncomingArgs(event, args);
+        return listener.call(this, ...transformedArgs);
+      } catch (err) {
+        import_ws2.WebSocket.prototype.emit.call(self, "error", err);
+      }
     });
   }
   on(event, listener) {
@@ -244,68 +248,22 @@ var ForklaunchWebSocket = class extends import_ws2.WebSocket {
    * ws.emit('error', { code: 500, message: 'Server error' });
    * ```
    */
+  /**
+   * Emits an event on the WebSocket.
+   *
+   * This method passes through to the underlying EventEmitter without
+   * transforming data. The ws library uses emit() internally to dispatch
+   * incoming events (message, close, ping, pong), so encoding here would
+   * incorrectly process incoming data as outgoing data.
+   *
+   * For sending data, use the dedicated methods instead:
+   * - {@link send} for messages
+   * - {@link close} for closing with a reason
+   * - {@link ping} for ping frames
+   * - {@link pong} for pong frames
+   */
   emit(event, ...args) {
-    let transformedArgs = args;
-    if (event === "message" && args.length >= 2) {
-      const typedArgs = args;
-      const data = typedArgs[0];
-      const isBinary = typedArgs[1];
-      const clientSchema = this.schemas.clientMessagesSchema;
-      if (typeof isBinary === "boolean" && isBinary && clientSchema) {
-        const encoded = this.validateAndEncode(
-          data,
-          clientSchema,
-          false,
-          "web socket message"
-        );
-        transformedArgs = [encoded, true, ...typedArgs.slice(2)];
-      }
-    } else if (event === "close" && args.length >= 2) {
-      const typedArgs = args;
-      const code = typedArgs[0];
-      const reason = typedArgs[1];
-      const encoded = this.validateAndEncode(
-        reason,
-        this.schemas.closeReasonSchema,
-        false,
-        "web socket close"
-      );
-      transformedArgs = [code, encoded, ...typedArgs.slice(2)];
-    } else if (event === "ping" && args.length >= 1) {
-      const typedArgs = args;
-      const data = typedArgs[0];
-      const encoded = this.validateAndEncode(
-        data,
-        this.schemas.pingSchema,
-        false,
-        "web socket ping"
-      );
-      transformedArgs = [encoded, ...typedArgs.slice(1)];
-    } else if (event === "pong" && args.length >= 1) {
-      const typedArgs = args;
-      const data = typedArgs[0];
-      const encoded = this.validateAndEncode(
-        data,
-        this.schemas.pongSchema,
-        false,
-        "web socket pong"
-      );
-      transformedArgs = [encoded, ...typedArgs.slice(1)];
-    } else if (event === "error" && args.length >= 1) {
-      const typedArgs = args;
-      const error = typedArgs[0];
-      const errorsSchema = this.schemas.errorsSchema;
-      if (errorsSchema) {
-        const encoded = this.validateAndEncode(
-          error,
-          errorsSchema,
-          false,
-          "web socket error"
-        );
-        transformedArgs = [encoded, ...typedArgs.slice(1)];
-      }
-    }
-    return super.emit(event, ...transformedArgs);
+    return super.emit(event, ...args);
   }
   // @ts-expect-error - Implementation accepts unknown for internal validation
   send(data, optionsOrCb, cb) {
@@ -483,10 +441,23 @@ var ForklaunchWebSocketServer = class extends import_ws4.WebSocketServer {
     super(options, callback);
     this.schemaValidator = schemaValidator;
     this.eventSchemas = eventSchemas;
-    super.on("connection", (ws, request) => {
-      const forklaunchWs = this.enhanceWebSocket(ws);
-      super.emit("connection", forklaunchWs, request);
-    });
+  }
+  /**
+   * Intercepts emit to enhance WebSocket instances on 'connection' events.
+   *
+   * When the ws library internally emits 'connection', we swap the raw WebSocket
+   * for an enhanced ForklaunchWebSocket before listeners receive it. This avoids
+   * infinite recursion that would occur if we used a listener + re-emit pattern.
+   *
+   * @internal
+   */
+  emit(event, ...args) {
+    if (event === "connection" && args.length >= 1) {
+      const ws = args[0];
+      const enhancedWs = this.enhanceWebSocket(ws);
+      return super.emit(event, enhancedWs, ...args.slice(1));
+    }
+    return super.emit(event, ...args);
   }
   /**
    * Enhances a plain WebSocket instance with ForklaunchWebSocket functionality.

package/lib/index.mjs

@@ -109,9 +109,8 @@ var ForklaunchWebSocket = class extends WebSocket {
     let transformedArgs = args;
     if (event === "message" && args.length >= 2) {
       const data = args[0];
-      const isBinary = args[1];
       const serverSchema = this.schemas.serverMessagesSchema;
-      if (typeof isBinary === "boolean" && isBinary && serverSchema) {
+      if (serverSchema) {
         const validated = this.decodeAndValidate(data, serverSchema);
         transformedArgs = [validated, false, ...args.slice(2)];
       }
@@ -149,9 +148,14 @@ var ForklaunchWebSocket = class extends WebSocket {
    * @internal
    */
   wrapListenerWithTransformation(superMethod, event, listener) {
-    return superMethod(event, (ws, ...args) => {
-      const transformedArgs = this.transformIncomingArgs(event, args);
-      return listener(ws, ...transformedArgs);
+    const self = this;
+    return superMethod(event, function(...args) {
+      try {
+        const transformedArgs = self.transformIncomingArgs(event, args);
+        return listener.call(this, ...transformedArgs);
+      } catch (err) {
+        WebSocket.prototype.emit.call(self, "error", err);
+      }
     });
   }
   on(event, listener) {
@@ -214,68 +218,22 @@ var ForklaunchWebSocket = class extends WebSocket {
    * ws.emit('error', { code: 500, message: 'Server error' });
    * ```
    */
+  /**
+   * Emits an event on the WebSocket.
+   *
+   * This method passes through to the underlying EventEmitter without
+   * transforming data. The ws library uses emit() internally to dispatch
+   * incoming events (message, close, ping, pong), so encoding here would
+   * incorrectly process incoming data as outgoing data.
+   *
+   * For sending data, use the dedicated methods instead:
+   * - {@link send} for messages
+   * - {@link close} for closing with a reason
+   * - {@link ping} for ping frames
+   * - {@link pong} for pong frames
+   */
   emit(event, ...args) {
-    let transformedArgs = args;
-    if (event === "message" && args.length >= 2) {
-      const typedArgs = args;
-      const data = typedArgs[0];
-      const isBinary = typedArgs[1];
-      const clientSchema = this.schemas.clientMessagesSchema;
-      if (typeof isBinary === "boolean" && isBinary && clientSchema) {
-        const encoded = this.validateAndEncode(
-          data,
-          clientSchema,
-          false,
-          "web socket message"
-        );
-        transformedArgs = [encoded, true, ...typedArgs.slice(2)];
-      }
-    } else if (event === "close" && args.length >= 2) {
-      const typedArgs = args;
-      const code = typedArgs[0];
-      const reason = typedArgs[1];
-      const encoded = this.validateAndEncode(
-        reason,
-        this.schemas.closeReasonSchema,
-        false,
-        "web socket close"
-      );
-      transformedArgs = [code, encoded, ...typedArgs.slice(2)];
-    } else if (event === "ping" && args.length >= 1) {
-      const typedArgs = args;
-      const data = typedArgs[0];
-      const encoded = this.validateAndEncode(
-        data,
-        this.schemas.pingSchema,
-        false,
-        "web socket ping"
-      );
-      transformedArgs = [encoded, ...typedArgs.slice(1)];
-    } else if (event === "pong" && args.length >= 1) {
-      const typedArgs = args;
-      const data = typedArgs[0];
-      const encoded = this.validateAndEncode(
-        data,
-        this.schemas.pongSchema,
-        false,
-        "web socket pong"
-      );
-      transformedArgs = [encoded, ...typedArgs.slice(1)];
-    } else if (event === "error" && args.length >= 1) {
-      const typedArgs = args;
-      const error = typedArgs[0];
-      const errorsSchema = this.schemas.errorsSchema;
-      if (errorsSchema) {
-        const encoded = this.validateAndEncode(
-          error,
-          errorsSchema,
-          false,
-          "web socket error"
-        );
-        transformedArgs = [encoded, ...typedArgs.slice(1)];
-      }
-    }
-    return super.emit(event, ...transformedArgs);
+    return super.emit(event, ...args);
   }
   // @ts-expect-error - Implementation accepts unknown for internal validation
   send(data, optionsOrCb, cb) {
@@ -455,10 +413,23 @@ var ForklaunchWebSocketServer = class extends WebSocketServer {
     super(options, callback);
     this.schemaValidator = schemaValidator;
     this.eventSchemas = eventSchemas;
-    super.on("connection", (ws, request) => {
-      const forklaunchWs = this.enhanceWebSocket(ws);
-      super.emit("connection", forklaunchWs, request);
-    });
+  }
+  /**
+   * Intercepts emit to enhance WebSocket instances on 'connection' events.
+   *
+   * When the ws library internally emits 'connection', we swap the raw WebSocket
+   * for an enhanced ForklaunchWebSocket before listeners receive it. This avoids
+   * infinite recursion that would occur if we used a listener + re-emit pattern.
+   *
+   * @internal
+   */
+  emit(event, ...args) {
+    if (event === "connection" && args.length >= 1) {
+      const ws = args[0];
+      const enhancedWs = this.enhanceWebSocket(ws);
+      return super.emit(event, enhancedWs, ...args.slice(1));
+    }
+    return super.emit(event, ...args);
   }
   /**
    * Enhances a plain WebSocket instance with ForklaunchWebSocket functionality.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forklaunch/ws",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "Typed framework for ws, by ForkLaunch.",
   "homepage": "https://github.com/forklaunch/forklaunch-js#readme",
   "bugs": {
@@ -28,21 +28,21 @@
     "@asyncapi/parser": "^3.6.0",
     "@types/ws": "^8.18.1",
     "ws": "^8.19.0",
-    "@forklaunch/common": "0.6.28",
-    "@forklaunch/core": "0.18.1",
-    "@forklaunch/validator": "0.10.28"
+    "@forklaunch/common": "0.6.29",
+    "@forklaunch/validator": "0.10.29",
+    "@forklaunch/core": "0.18.2"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.2",
-    "@typescript/native-preview": "7.0.0-dev.20260204.1",
+    "@eslint/js": "^10.0.1",
+    "@typescript/native-preview": "7.0.0-dev.20260223.1",
     "jest": "^30.2.0",
     "prettier": "^3.8.1",
     "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "tsup": "^8.5.1",
-    "typedoc": "^0.28.16",
+    "typedoc": "^0.28.17",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.54.0",
+    "typescript-eslint": "^8.56.1",
     "zod": "^4.3.6"
   },
   "scripts": {