@yxcinebendjebbar/asdc 0.0.5 → 0.0.6

package/dist/core/errors.d.ts

@@ -1,10 +1,10 @@
 export declare class HttpToolkitError extends Error {
-    config?: unknown | undefined;
-    constructor(message: string, config?: unknown | undefined);
+    config?: unknown;
+    constructor(message: string, config?: unknown);
 }
 export declare class NetworkError extends HttpToolkitError {
-    cause?: unknown | undefined;
-    constructor(message: string, cause?: unknown | undefined, config?: unknown);
+    cause?: unknown;
+    constructor(message: string, cause?: unknown, config?: unknown);
 }
 export declare class TimeoutError extends HttpToolkitError {
     constructor(message?: string, config?: unknown);

package/dist/http/HttpClient.d.ts

@@ -3,12 +3,12 @@ import { HttpResponse } from '../core/Response.ts';
 import { InterceptorManager } from '../core/InterceptorManager.ts';
 import type { Transport } from '../transport/Transport.ts';
 export declare class HttpClient {
-    private readonly config;
-    private readonly transport;
     readonly interceptors: {
         request: InterceptorManager<RequestConfig>;
         response: InterceptorManager<HttpResponse<unknown>>;
     };
+    private readonly config;
+    private readonly transport;
     constructor(config?: ClientConfig, transport?: Transport);
     request<T = unknown>(config: RequestConfig): Promise<HttpResponse<T>>;
     private method;

package/dist/http/HttpClient.js

@@ -2,12 +2,12 @@ import { InterceptorManager } from "../core/InterceptorManager.js";
 import { ResponseError } from "../core/errors.js";
 import { FetchTransport } from "../transport/FetchTransport.js";
 export class HttpClient {
-    config;
-    transport;
     interceptors = {
         request: new InterceptorManager(),
         response: new InterceptorManager(),
     };
+    config;
+    transport;
     constructor(config = {}, transport = new FetchTransport()) {
         this.config = config;
         this.transport = transport;

package/dist/index.d.ts

@@ -6,4 +6,8 @@ export * from './transport/Transport.ts';
 export * from './transport/FetchTransport.ts';
 export * from './http/HttpClient.ts';
 export * from './ws/WebSocketClient.ts';
+export * from './rpc/RpcError.ts';
+export * from './rpc/RpcTransport.ts';
+export * from './rpc/HttpRpcAdapter.ts';
+export * from './rpc/WebSocketRpcAdapter.ts';
 export * from './rpc/JsonRpcClient.ts';

package/dist/index.js

@@ -6,4 +6,8 @@ export * from "./transport/Transport.js";
 export * from "./transport/FetchTransport.js";
 export * from "./http/HttpClient.js";
 export * from "./ws/WebSocketClient.js";
+export * from "./rpc/RpcError.js";
+export * from "./rpc/RpcTransport.js";
+export * from "./rpc/HttpRpcAdapter.js";
+export * from "./rpc/WebSocketRpcAdapter.js";
 export * from "./rpc/JsonRpcClient.js";

package/dist/rpc/HttpRpcAdapter.d.ts

@@ -0,0 +1,8 @@
+import { HttpClient } from '../http/HttpClient.ts';
+import { RpcTransport } from './RpcTransport.ts';
+export declare class HttpRpcAdapter implements RpcTransport {
+    private readonly client;
+    private readonly endpoint;
+    constructor(client: HttpClient, endpoint?: string);
+    call<T = unknown>(payload: unknown): Promise<T>;
+}

package/dist/rpc/HttpRpcAdapter.js

@@ -0,0 +1,16 @@
+import { RpcError } from "./RpcError.js";
+export class HttpRpcAdapter {
+    client;
+    endpoint;
+    constructor(client, endpoint = '/') {
+        this.client = client;
+        this.endpoint = endpoint;
+    }
+    async call(payload) {
+        const res = await this.client.post(this.endpoint, payload);
+        if (res.data.error) {
+            throw new RpcError(res.data.error.message, res.data.error.code, res.data.error.data);
+        }
+        return res.data.result;
+    }
+}

package/dist/rpc/JsonRpcClient.d.ts

@@ -1,17 +1,8 @@
-import { HttpClient } from '../http/HttpClient.ts';
-import { WebSocketClient } from '../ws/WebSocketClient.ts';
-export declare class RpcError extends Error {
-    code: number;
-    data?: unknown | undefined;
-    constructor(message: string, code: number, data?: unknown | undefined);
-}
+import { RpcTransport } from './RpcTransport.ts';
+export { RpcError } from './RpcError.ts';
 export declare class JsonRpcClient {
-    private readonly transport;
-    private readonly endpoint;
     private nextId;
-    private pending;
-    constructor(transport: HttpClient | WebSocketClient, endpoint?: string);
+    private readonly transport;
+    constructor(transport: RpcTransport);
     call<T = unknown>(method: string, params?: unknown): Promise<T>;
-    private handleMessage;
-    private rejectAllPending;
 }

package/dist/rpc/JsonRpcClient.js

@@ -1,67 +1,13 @@
-import { WebSocketClient } from "../ws/WebSocketClient.js";
-export class RpcError extends Error {
-    code;
-    data;
-    constructor(message, code, data) {
-        super(message);
-        this.code = code;
-        this.data = data;
-        this.name = 'RpcError';
-    }
-}
+export { RpcError } from "./RpcError.js";
 export class JsonRpcClient {
-    transport;
-    endpoint;
     nextId = 1;
-    pending = new Map();
-    constructor(transport, endpoint = '/') {
+    transport;
+    constructor(transport) {
         this.transport = transport;
-        this.endpoint = endpoint;
-        if (transport instanceof WebSocketClient) {
-            transport.on('message', (raw) => this.handleMessage(raw));
-            transport.on('close', () => this.rejectAllPending(new RpcError('WebSocket closed', -32000)));
-            transport.on('error', () => this.rejectAllPending(new RpcError('WebSocket error', -32000)));
-        }
     }
     async call(method, params) {
         const id = this.nextId++;
         const payload = { jsonrpc: '2.0', id, method, params };
-        const transport = this.transport;
-        if (transport instanceof WebSocketClient) {
-            return new Promise((resolve, reject) => {
-                this.pending.set(id, { resolve: resolve, reject });
-                transport.send(JSON.stringify(payload));
-            });
-        }
-        const res = await transport.post(this.endpoint, payload);
-        if (res.data.error) {
-            throw new RpcError(res.data.error.message, res.data.error.code, res.data.error.data);
-        }
-        return res.data.result;
-    }
-    handleMessage(raw) {
-        let msg;
-        try {
-            msg = JSON.parse(raw);
-        }
-        catch {
-            return;
-        }
-        const pending = this.pending.get(msg.id);
-        if (!pending)
-            return;
-        this.pending.delete(msg.id);
-        if (msg.error) {
-            pending.reject(new RpcError(msg.error.message, msg.error.code, msg.error.data));
-        }
-        else {
-            pending.resolve(msg.result);
-        }
-    }
-    rejectAllPending(error) {
-        for (const pending of this.pending.values()) {
-            pending.reject(error);
-        }
-        this.pending.clear();
+        return this.transport.call(payload);
     }
 }

package/dist/rpc/RpcError.d.ts

@@ -0,0 +1,5 @@
+export declare class RpcError extends Error {
+    code: number;
+    data?: unknown;
+    constructor(message: string, code: number, data?: unknown);
+}

package/dist/rpc/RpcError.js

@@ -0,0 +1,10 @@
+export class RpcError extends Error {
+    code;
+    data;
+    constructor(message, code, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = 'RpcError';
+    }
+}

package/dist/rpc/RpcTransport.d.ts

@@ -0,0 +1,3 @@
+export interface RpcTransport {
+    call<T = unknown>(payload: unknown): Promise<T>;
+}

package/dist/rpc/RpcTransport.js

@@ -0,0 +1 @@
+export {};

package/dist/rpc/WebSocketRpcAdapter.d.ts

@@ -0,0 +1,10 @@
+import { WebSocketClient } from '../ws/WebSocketClient.ts';
+import { RpcTransport } from './RpcTransport.ts';
+export declare class WebSocketRpcAdapter implements RpcTransport {
+    private pending;
+    private readonly client;
+    constructor(client: WebSocketClient);
+    call<T = unknown>(payload: unknown): Promise<T>;
+    private handleMessage;
+    private rejectAllPending;
+}

package/dist/rpc/WebSocketRpcAdapter.js

@@ -0,0 +1,41 @@
+import { RpcError } from "./RpcError.js";
+export class WebSocketRpcAdapter {
+    pending = new Map();
+    client;
+    constructor(client) {
+        this.client = client;
+        this.client.on('message', (parsed) => this.handleMessage(parsed));
+        this.client.on('close', () => this.rejectAllPending(new RpcError('WebSocket closed', -32000)));
+        this.client.on('error', () => this.rejectAllPending(new RpcError('WebSocket error', -32000)));
+    }
+    async call(payload) {
+        const id = payload.id;
+        return new Promise((resolve, reject) => {
+            if (id !== undefined) {
+                this.pending.set(id, { resolve: resolve, reject });
+            }
+            this.client.send(payload);
+        });
+    }
+    handleMessage(msg) {
+        if (!msg || typeof msg !== 'object' || !('id' in msg))
+            return;
+        const response = msg;
+        const pending = this.pending.get(response.id);
+        if (!pending)
+            return;
+        this.pending.delete(response.id);
+        if (response.error) {
+            pending.reject(new RpcError(response.error.message, response.error.code, response.error.data));
+        }
+        else {
+            pending.resolve(response.result);
+        }
+    }
+    rejectAllPending(error) {
+        for (const pending of this.pending.values()) {
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+}

package/dist/ws/WebSocketClient.d.ts

@@ -4,17 +4,21 @@ export interface ReconnectPolicy {
     maxAttempts?: number;
     delayMs?: (attempt: number) => number;
 }
+export type WebSocketFactory = (url: string) => WebSocket;
 export declare class WebSocketClient {
-    private readonly url;
-    private readonly reconnect;
     private ws?;
     private listeners;
     private attempt;
     private shouldReconnect;
-    constructor(url: string, reconnect?: ReconnectPolicy);
-    connect(): void;
+    private messageQueue;
+    private readonly url;
+    private readonly reconnect;
+    private readonly factory;
+    constructor(url: string, reconnect?: ReconnectPolicy, factory?: WebSocketFactory);
+    private connect;
     private tryReconnect;
-    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    private flushQueue;
+    send(data: unknown, isRaw?: boolean): void;
     close(code?: number, reason?: string): void;
     on(event: WSEvent, listener: Listener): void;
     off(event: WSEvent, listener: Listener): void;

package/dist/ws/WebSocketClient.js

@@ -1,19 +1,41 @@
 export class WebSocketClient {
-    url;
-    reconnect;
     ws;
     listeners = new Map();
     attempt = 0;
     shouldReconnect = true;
-    constructor(url, reconnect = { maxAttempts: 5, delayMs: (a) => Math.min(1000 * 2 ** a, 30000) }) {
+    messageQueue = [];
+    url;
+    reconnect;
+    factory;
+    constructor(url, reconnect = { maxAttempts: 5, delayMs: (a) => Math.min(1000 * 2 ** a, 30000) }, factory = (u) => new WebSocket(u)) {
         this.url = url;
         this.reconnect = reconnect;
+        this.factory = factory;
     }
     connect() {
+        if (this.ws && (this.ws.readyState === WebSocket.CONNECTING || this.ws.readyState === WebSocket.OPEN)) {
+            return;
+        }
         this.shouldReconnect = true;
-        this.ws = new WebSocket(this.url);
-        this.ws.addEventListener('open', (e) => this.emit('open', e));
-        this.ws.addEventListener('message', (e) => this.emit('message', e.data));
+        this.ws = this.factory(this.url);
+        this.ws.addEventListener('open', (e) => {
+            this.flushQueue();
+            this.emit('open', e);
+        });
+        this.ws.addEventListener('message', (e) => {
+            const data = e.data;
+            let parsed = data;
+            try {
+                if (typeof data === 'string') {
+                    parsed = JSON.parse(data);
+                }
+            }
+            catch {
+                // Keep as raw data
+            }
+            // Pass both parsed (or raw if not JSON) and original raw data
+            this.emit('message', parsed, data);
+        });
         this.ws.addEventListener('close', (e) => {
             this.emit('close', e);
             if (this.shouldReconnect)
@@ -29,8 +51,31 @@ export class WebSocketClient {
         this.attempt++;
         setTimeout(() => this.connect(), delay);
     }
-    send(data) {
-        this.ws?.send(data);
+    flushQueue() {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        while (this.messageQueue.length > 0) {
+            const msg = this.messageQueue.shift();
+            if (msg !== undefined) {
+                this.ws.send(msg);
+            }
+        }
+    }
+    send(data, isRaw = false) {
+        let payload;
+        if (isRaw) {
+            payload = data;
+        }
+        else {
+            payload = typeof data === 'string' ? data : JSON.stringify(data);
+        }
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            this.messageQueue.push(payload);
+            this.connect();
+        }
+        else {
+            this.ws.send(payload);
+        }
     }
     close(code, reason) {
         this.shouldReconnect = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yxcinebendjebbar/asdc",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "A zero-dependency, OOP HTTP/WebSocket/RPC client designed to be ported cleanly to other languages",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",