@whateverjs/client 0.1.3

package/README.md

@@ -0,0 +1,15 @@
+# client
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.11. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/index.ts

@@ -0,0 +1,228 @@
+import type { WsContract, WsServerEventMap, InferWsSchema } from "@whateverjs/core";
+
+type WsClientEventMap<TContract extends WsContract<any, any>> = {
+  [TEvent in keyof TContract["clientToServer"] & string]: InferWsSchema<
+    TContract["clientToServer"][TEvent]
+  >;
+};
+
+interface WsClientOptions {
+  protocols?: string | string[];
+  url: string;
+  connectTimeoutMs?: number;
+}
+
+type ClientMessageHandler<
+  TContract extends WsContract<any, any>,
+  TEvent extends keyof WsServerEventMap<TContract> & string,
+> = (payload: WsServerEventMap<TContract>[TEvent]) => void;
+
+export type WireMessage =
+  | { t: "e"; e: string; d?: unknown }
+  | { t: "h"; ts: number }
+  | { t: "a"; ts: number };
+
+const wsTextDecoder = new TextDecoder();
+const wsHeartbeatPrefix = '{"t":"h","ts":';
+const wsAckPrefix = '{"t":"a","ts":';
+
+function parseCompactTimestamp(
+  value: string,
+  prefix: string,
+): number | null {
+  if (!value.startsWith(prefix) || !value.endsWith("}")) {
+    return null;
+  }
+
+  const timestamp = Number(value.slice(prefix.length, -1));
+  if (!Number.isFinite(timestamp)) {
+    return null;
+  }
+
+  return timestamp;
+}
+
+function parseWireMessageFromString(value: string): WireMessage | null {
+  const heartbeatTs = parseCompactTimestamp(value, wsHeartbeatPrefix);
+  if (heartbeatTs !== null) {
+    return { t: "h", ts: heartbeatTs };
+  }
+
+  const ackTs = parseCompactTimestamp(value, wsAckPrefix);
+  if (ackTs !== null) {
+    return { t: "a", ts: ackTs };
+  }
+
+  try {
+    const parsed = JSON.parse(value) as unknown;
+
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+
+    const message = parsed as Record<string, unknown>;
+
+    if (message.t === "e" && typeof message.e === "string") {
+      return message as WireMessage;
+    }
+
+    if (
+      (message.t === "h" || message.t === "a") &&
+      typeof message.ts === "number"
+    ) {
+      return message as WireMessage;
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function parseWireMessage(value: unknown): WireMessage | null {
+  if (typeof value === "string") {
+    return parseWireMessageFromString(value);
+  }
+
+  if (value instanceof ArrayBuffer) {
+    return parseWireMessageFromString(wsTextDecoder.decode(value));
+  }
+
+  if (ArrayBuffer.isView(value)) {
+    const view = value as ArrayBufferView;
+    return parseWireMessageFromString(
+      wsTextDecoder.decode(
+        new Uint8Array(view.buffer, view.byteOffset, view.byteLength),
+      ),
+    );
+  }
+
+  if (typeof Blob !== "undefined" && value instanceof Blob) {
+    return null;
+  }
+
+  return null;
+}
+
+function serializeEventMessage(event: string, payload: unknown): string {
+  return `{"t":"e","e":${JSON.stringify(event)},"d":${JSON.stringify(payload)}}`;
+}
+
+export class TypedWsClient<TContract extends WsContract<any, any>> {
+  private socket: WebSocket | null = null;
+  private readonly handlers = new Map<
+    string,
+    Set<ClientMessageHandler<TContract, any>>
+  >();
+
+  constructor(
+    readonly contract: TContract,
+    private readonly options: WsClientOptions,
+  ) {}
+
+  isConnected(): boolean {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+
+  async connect(): Promise<void> {
+    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+      return;
+    }
+
+    const socket = new WebSocket(this.options.url, this.options.protocols);
+    this.socket = socket;
+
+    await new Promise<void>((resolve, reject) => {
+      const timeoutMs = this.options.connectTimeoutMs ?? 5_000;
+      const timeout = setTimeout(() => {
+        reject(new Error(`WebSocket connect timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      socket.onopen = () => {
+        clearTimeout(timeout);
+        resolve();
+      };
+
+      socket.onerror = () => {
+        clearTimeout(timeout);
+        reject(new Error("WebSocket connection failed"));
+      };
+    });
+
+    socket.onmessage = (event) => {
+      const message = parseWireMessage(event.data);
+
+      if (!message) {
+        return;
+      }
+
+      if (message.t === "h") {
+        socket.send(`{"t":"a","ts":${message.ts}}`);
+        return;
+      }
+
+      if (message.t === "a") {
+        return;
+      }
+
+      if (message.t === "e") {
+        const eventHandlers = this.handlers.get(message.e);
+
+        if (!eventHandlers || eventHandlers.size === 0) {
+          return;
+        }
+
+        for (const handler of eventHandlers) {
+          handler(message.d as never);
+        }
+      }
+    };
+  }
+
+  disconnect(code = 1000, reason = "Client disconnect"): void {
+    if (!this.socket) {
+      return;
+    }
+
+    this.socket.close(code, reason);
+    this.socket = null;
+  }
+
+  send<TEvent extends keyof WsClientEventMap<TContract> & string>(
+    event: TEvent,
+    payload: WsClientEventMap<TContract>[TEvent],
+  ): void {
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+
+    this.socket.send(serializeEventMessage(event, payload));
+  }
+
+  on<TEvent extends keyof WsServerEventMap<TContract> & string>(
+    event: TEvent,
+    handler: ClientMessageHandler<TContract, TEvent>,
+  ): () => void {
+    const eventHandlers =
+      this.handlers.get(event) ??
+      new Set<ClientMessageHandler<TContract, any>>();
+
+    eventHandlers.add(handler as ClientMessageHandler<TContract, any>);
+    this.handlers.set(event, eventHandlers);
+
+    return () => {
+      eventHandlers.delete(handler as ClientMessageHandler<TContract, any>);
+
+      if (eventHandlers.size === 0) {
+        this.handlers.delete(event);
+      }
+    };
+  }
+}
+
+export { TypedHttpClient } from "./http-client";
+export type {
+  HttpClientRequestOptions,
+  HttpRouteDefinition,
+  HttpRouteMap,
+} from "./http-client";

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@whateverjs/client",
+  "version": "0.1.3",
+  "main": "./index.ts",
+  "module": "./index.ts",
+  "types": "./index.ts",
+  "exports": {
+    ".": {
+      "types": "./index.ts",
+      "default": "./index.ts"
+    }
+  },
+  "files": [
+    "index.ts",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "@whateverjs/core": "^0.1.0",
+    "typescript": "^5"
+  }
+}