@cloudpss/ubrpc 0.4.12 → 0.4.14

package/dist/auth.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="ws" />
-import type WebSocket from 'isomorphic-ws';
-import type { ConnectionID, RpcMetadata } from './types/payload.js';
-/** 接受认证消息 */
-export declare function waitAuth(socket: WebSocket, seq?: number, id?: ConnectionID): Promise<[number, ConnectionID, RpcMetadata]>;
+/// <reference types="ws" />
+import type WebSocket from 'isomorphic-ws';
+import type { ConnectionID, RpcMetadata } from './types/payload.js';
+/** 接受认证消息 */
+export declare function waitAuth(socket: WebSocket, seq?: number, id?: ConnectionID): Promise<[number, ConnectionID, RpcMetadata]>;

package/dist/auth.js

@@ -1,52 +1,52 @@
-import { decodePayload, deserializeError } from './utils/serialize.js';
-import { VERSION } from './version.js';
-const AUTH_TIMEOUT = 5000;
-/** 接受认证消息 */
-export function waitAuth(socket, seq, id) {
-    return new Promise((resolve, reject) => {
-        const isResponse = seq != null && id != null;
-        const timeout = setTimeout(() => {
-            reject(new Error(`Failed to authenticate, no ${isResponse ? 'response' : 'request'} in ${AUTH_TIMEOUT}ms`));
-            finalize();
-        }, AUTH_TIMEOUT);
-        const handleMessage = (ev) => {
-            try {
-                const payload = decodePayload(ev.data);
-                if (!payload || payload.type !== 'auth') {
-                    if (isResponse)
-                        return reject(new Error(`Failed to authenticate, bad response from server`));
-                    else
-                        return reject(new Error(`Failed to authenticate, bad request from client`));
-                }
-                if (payload.version !== VERSION) {
-                    return reject(new Error(`Failed to authenticate, version not match, expected ${VERSION}, got ${payload.version}`));
-                }
-                if (isResponse) {
-                    if (payload.seq !== seq) {
-                        return reject(new Error(`Failed to authenticate, bad response seq from server`));
-                    }
-                    if (payload.id !== id) {
-                        return reject(new Error(`Failed to authenticate, bad response id from server`));
-                    }
-                }
-                if (payload.error) {
-                    return reject(deserializeError(payload.error));
-                }
-                const metadata = typeof payload.metadata != 'object' ? {} : payload.metadata ?? {};
-                resolve([payload.seq, payload.id, metadata]);
-            }
-            catch (ex) {
-                reject(ex);
-            }
-            finally {
-                finalize();
-            }
-        };
-        const finalize = () => {
-            clearTimeout(timeout);
-            socket.removeListener('message', handleMessage);
-        };
-        socket.addEventListener('message', handleMessage, { once: true });
-    });
-}
+import { decodePayload, deserializeError } from './utils/serialize.js';
+import { VERSION } from './version.js';
+const AUTH_TIMEOUT = 5000;
+/** 接受认证消息 */
+export function waitAuth(socket, seq, id) {
+    return new Promise((resolve, reject) => {
+        const isResponse = seq != null && id != null;
+        const timeout = setTimeout(() => {
+            reject(new Error(`Failed to authenticate, no ${isResponse ? 'response' : 'request'} in ${AUTH_TIMEOUT}ms`));
+            finalize();
+        }, AUTH_TIMEOUT);
+        const handleMessage = (ev) => {
+            try {
+                const payload = decodePayload(ev.data);
+                if (!payload || payload.type !== 'auth') {
+                    if (isResponse)
+                        return reject(new Error(`Failed to authenticate, bad response from server`));
+                    else
+                        return reject(new Error(`Failed to authenticate, bad request from client`));
+                }
+                if (payload.version !== VERSION) {
+                    return reject(new Error(`Failed to authenticate, version not match, expected ${VERSION}, got ${payload.version}`));
+                }
+                if (isResponse) {
+                    if (payload.seq !== seq) {
+                        return reject(new Error(`Failed to authenticate, bad response seq from server`));
+                    }
+                    if (payload.id !== id) {
+                        return reject(new Error(`Failed to authenticate, bad response id from server`));
+                    }
+                }
+                if (payload.error) {
+                    return reject(deserializeError(payload.error));
+                }
+                const metadata = typeof payload.metadata != 'object' ? {} : payload.metadata ?? {};
+                resolve([payload.seq, payload.id, metadata]);
+            }
+            catch (ex) {
+                reject(ex);
+            }
+            finally {
+                finalize();
+            }
+        };
+        const finalize = () => {
+            clearTimeout(timeout);
+            socket.removeListener('message', handleMessage);
+        };
+        socket.addEventListener('message', handleMessage, { once: true });
+    });
+}
 //# sourceMappingURL=auth.js.map

package/dist/client.d.ts

@@ -1,16 +1,16 @@
-/// <reference types="ws" />
-import WebSocket from 'isomorphic-ws';
-import { RpcSocket } from './socket.js';
-import type { RpcMetadata } from './types/payload.js';
-import type { RpcObject } from './types/utils.js';
-/** 由 WS Client 建立的 RPC 连接 */
-export declare class RpcClientSocket<TRemote extends {}, TLocal extends {}> extends RpcSocket<TRemote, TLocal> {
-    constructor(url: string | URL, metadata?: RpcMetadata, local?: RpcObject<TLocal>);
-    readonly url: string;
-    /** @inheritdoc */
-    protected authSocket(): Promise<RpcMetadata>;
-    /** @inheritdoc */
-    protected onClose(ev: WebSocket.CloseEvent): void;
-    /** 建立连接 */
-    protected connect(): void;
-}
+/// <reference types="ws" />
+import WebSocket from 'isomorphic-ws';
+import { RpcSocket } from './socket.js';
+import type { RpcMetadata } from './types/payload.js';
+import type { RpcObject } from './types/utils.js';
+/** 由 WS Client 建立的 RPC 连接 */
+export declare class RpcClientSocket<TRemote extends {}, TLocal extends {}> extends RpcSocket<TRemote, TLocal> {
+    constructor(url: string | URL, metadata?: RpcMetadata, local?: RpcObject<TLocal>);
+    readonly url: string;
+    /** @inheritdoc */
+    protected authSocket(): Promise<RpcMetadata>;
+    /** @inheritdoc */
+    protected onClose(ev: WebSocket.CloseEvent): void;
+    /** 建立连接 */
+    protected connect(): void;
+}

package/dist/client.js

@@ -1,48 +1,48 @@
-import WebSocket from 'isomorphic-ws';
-import { v4 } from 'uuid';
-import { waitAuth } from './auth.js';
-import { RpcSocket } from './socket.js';
-import { send } from './utils/messaging.js';
-import { VERSION } from './version.js';
-/** 由 WS Client 建立的 RPC 连接 */
-export class RpcClientSocket extends RpcSocket {
-    constructor(url, metadata, local) {
-        super(v4(), local);
-        this._localMetadata = metadata;
-        this.url = typeof url == 'string' ? url : url.href;
-        this.seq = 2;
-        this.connect();
-    }
-    /** @inheritdoc */
-    async authSocket() {
-        const socket = this.socket;
-        const seq = this.nextSeq();
-        send(socket, 'auth', {
-            seq,
-            id: this.id,
-            version: VERSION,
-            metadata: this.localMetadata ?? {},
-        });
-        const [, , metadata] = await waitAuth(socket, seq, this.id);
-        return metadata;
-    }
-    /** @inheritdoc */
-    onClose(ev) {
-        super.onClose(ev);
-        if (ev.code === 1000)
-            return;
-        setTimeout(() => {
-            this.connect();
-        }, 1000);
-    }
-    /** 建立连接 */
-    connect() {
-        this.socket = new WebSocket(this.url);
-        this.ready.catch(() => {
-            setTimeout(() => {
-                this.connect();
-            }, 2000);
-        });
-    }
-}
+import WebSocket from 'isomorphic-ws';
+import { v4 } from 'uuid';
+import { waitAuth } from './auth.js';
+import { RpcSocket } from './socket.js';
+import { send } from './utils/messaging.js';
+import { VERSION } from './version.js';
+/** 由 WS Client 建立的 RPC 连接 */
+export class RpcClientSocket extends RpcSocket {
+    constructor(url, metadata, local) {
+        super(v4(), local);
+        this._localMetadata = metadata;
+        this.url = typeof url == 'string' ? url : url.href;
+        this.seq = 2;
+        this.connect();
+    }
+    /** @inheritdoc */
+    async authSocket() {
+        const socket = this.socket;
+        const seq = this.nextSeq();
+        send(socket, 'auth', {
+            seq,
+            id: this.id,
+            version: VERSION,
+            metadata: this.localMetadata ?? {},
+        });
+        const [, , metadata] = await waitAuth(socket, seq, this.id);
+        return metadata;
+    }
+    /** @inheritdoc */
+    onClose(ev) {
+        super.onClose(ev);
+        if (ev.code === 1000)
+            return;
+        setTimeout(() => {
+            this.connect();
+        }, 1000);
+    }
+    /** 建立连接 */
+    connect() {
+        this.socket = new WebSocket(this.url);
+        this.ready.catch(() => {
+            setTimeout(() => {
+                this.connect();
+            }, 2000);
+        });
+    }
+}
 //# sourceMappingURL=client.js.map

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { RpcClientSocket } from './client.js';
-export { RpcSocket } from './socket.js';
-export { RpcServer, RpcServerSocket } from './server.js';
+export { RpcClientSocket } from './client.js';
+export { RpcSocket } from './socket.js';
+export { RpcServer, RpcServerSocket } from './server.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-export { RpcClientSocket } from './client.js';
-export { RpcSocket } from './socket.js';
-export { RpcServer, RpcServerSocket } from './server.js';
+export { RpcClientSocket } from './client.js';
+export { RpcSocket } from './socket.js';
+export { RpcServer, RpcServerSocket } from './server.js';
 //# sourceMappingURL=index.js.map

package/dist/server.d.ts

@@ -1,44 +1,44 @@
-/// <reference types="ws" />
-import type WebSocket from 'isomorphic-ws';
-import { RpcSocket } from './socket.js';
-import type { ConnectionID, RpcMetadata } from './types/payload.js';
-import type { RpcObject } from './types/utils.js';
-declare const kOnClose: unique symbol;
-declare const kMetadata: unique symbol;
-declare const kReplaceSocket: unique symbol;
-/** 认证过的 socket */
-type WebSocketWithMetadata = WebSocket & {
-    [kMetadata]: RpcMetadata;
-};
-/** 由 WS Server 建立的 RPC 连接组 */
-export declare class RpcServer<TRemote extends {}, TLocal extends {}> {
-    /** 认证客户端 */
-    readonly authenticator: (metadata: RpcMetadata) => RpcMetadata | Promise<RpcMetadata>;
-    constructor(local?: RpcObject<TLocal> | ((socket: RpcServerSocket<TRemote, TLocal>) => RpcObject<TLocal>), 
-    /** 认证客户端 */
-    authenticator?: (metadata: RpcMetadata) => RpcMetadata | Promise<RpcMetadata>);
-    /** 用于响应调用的本地对象 */
-    readonly local?: (socket: RpcServerSocket<TRemote, TLocal>) => RpcObject<TLocal>;
-    readonly sockets: Map<string, RpcServerSocket<TRemote, TLocal>>;
-    /** WebSocket 连接后调用此方法建立 RPC 连接 */
-    connect(socket: WebSocket): Promise<RpcServerSocket<TRemote, TLocal>>;
-    /** 认证客户端 */
-    protected authSocket(socket: WebSocket): Promise<[ConnectionID, RpcMetadata]>;
-    private readonly disconnectingSockets;
-    /** WebSocket 断开时调用 */
-    [kOnClose](socket: RpcServerSocket<TRemote, TLocal>, ev: WebSocket.CloseEvent): void;
-}
-/** 由 WS Server 建立的 RPC 连接 */
-export declare class RpcServerSocket<TRemote extends object, TLocal extends object> extends RpcSocket<TRemote, TLocal> {
-    readonly server: RpcServer<TRemote, TLocal>;
-    constructor(id: ConnectionID, server: RpcServer<TRemote, TLocal>);
-    /** @inheritdoc */
-    protected authSocket(): Promise<RpcMetadata>;
-    /** @inheritdoc */
-    protected get local(): RpcObject<TLocal> | undefined;
-    /** @inheritdoc */
-    protected onClose(ev: WebSocket.CloseEvent): void;
-    /** 替换 socket */
-    [kReplaceSocket](newSocket: WebSocketWithMetadata): Promise<void>;
-}
-export {};
+/// <reference types="ws" />
+import type WebSocket from 'isomorphic-ws';
+import { RpcSocket } from './socket.js';
+import type { ConnectionID, RpcMetadata } from './types/payload.js';
+import type { RpcObject } from './types/utils.js';
+declare const kOnClose: unique symbol;
+declare const kMetadata: unique symbol;
+declare const kReplaceSocket: unique symbol;
+/** 认证过的 socket */
+type WebSocketWithMetadata = WebSocket & {
+    [kMetadata]: RpcMetadata;
+};
+/** 由 WS Server 建立的 RPC 连接组 */
+export declare class RpcServer<TRemote extends {}, TLocal extends {}> {
+    /** 认证客户端 */
+    readonly authenticator: (metadata: RpcMetadata) => RpcMetadata | Promise<RpcMetadata>;
+    constructor(local?: RpcObject<TLocal> | ((socket: RpcServerSocket<TRemote, TLocal>) => RpcObject<TLocal>), 
+    /** 认证客户端 */
+    authenticator?: (metadata: RpcMetadata) => RpcMetadata | Promise<RpcMetadata>);
+    /** 用于响应调用的本地对象 */
+    readonly local?: (socket: RpcServerSocket<TRemote, TLocal>) => RpcObject<TLocal>;
+    readonly sockets: Map<string, RpcServerSocket<TRemote, TLocal>>;
+    /** WebSocket 连接后调用此方法建立 RPC 连接 */
+    connect(socket: WebSocket): Promise<RpcServerSocket<TRemote, TLocal>>;
+    /** 认证客户端 */
+    protected authSocket(socket: WebSocket): Promise<[ConnectionID, RpcMetadata]>;
+    private readonly disconnectingSockets;
+    /** WebSocket 断开时调用 */
+    [kOnClose](socket: RpcServerSocket<TRemote, TLocal>, ev: WebSocket.CloseEvent): void;
+}
+/** 由 WS Server 建立的 RPC 连接 */
+export declare class RpcServerSocket<TRemote extends object, TLocal extends object> extends RpcSocket<TRemote, TLocal> {
+    readonly server: RpcServer<TRemote, TLocal>;
+    constructor(id: ConnectionID, server: RpcServer<TRemote, TLocal>);
+    /** @inheritdoc */
+    protected authSocket(): Promise<RpcMetadata>;
+    /** @inheritdoc */
+    protected get local(): RpcObject<TLocal> | undefined;
+    /** @inheritdoc */
+    protected onClose(ev: WebSocket.CloseEvent): void;
+    /** 替换 socket */
+    [kReplaceSocket](newSocket: WebSocketWithMetadata): Promise<void>;
+}
+export {};

package/dist/server.js

@@ -1,118 +1,118 @@
-import { waitAuth } from './auth.js';
-import { RpcSocket } from './socket.js';
-import { send } from './utils/messaging.js';
-import { serializeError } from './utils/serialize.js';
-import { VERSION } from './version.js';
-const kOnClose = Symbol('kOnClose');
-const kMetadata = Symbol('kMetadata');
-const kReplaceSocket = Symbol('kReplaceSocket');
-/** 由 WS Server 建立的 RPC 连接组 */
-export class RpcServer {
-    constructor(local, 
-    /** 认证客户端 */
-    authenticator = () => ({})) {
-        this.authenticator = authenticator;
-        this.sockets = new Map();
-        this.disconnectingSockets = new Map();
-        if (local == null) {
-            this.local = undefined;
-        }
-        else if (typeof local == 'function') {
-            this.local = local;
-        }
-        else {
-            this.local = () => local;
-        }
-    }
-    /** WebSocket 连接后调用此方法建立 RPC 连接 */
-    async connect(socket) {
-        const s = socket;
-        const [id, metadata] = await this.authSocket(socket);
-        s[kMetadata] = metadata;
-        let client = this.sockets.get(id);
-        if (!client) {
-            client = new RpcServerSocket(id, this);
-            this.sockets.set(id, client);
-        }
-        else {
-            const tid = this.disconnectingSockets.get(id);
-            if (tid != null) {
-                this.disconnectingSockets.delete(id);
-                clearTimeout(tid);
-            }
-        }
-        await client[kReplaceSocket](s);
-        return client;
-    }
-    /** 认证客户端 */
-    async authSocket(socket) {
-        let seq, id, remoteMetadata;
-        try {
-            [seq, id, remoteMetadata] = await waitAuth(socket);
-            const localMetadata = await this.authenticator(remoteMetadata);
-            send(socket, 'auth', {
-                seq,
-                id,
-                version: VERSION,
-                metadata: localMetadata,
-            });
-            return [id, remoteMetadata];
-        }
-        catch (ex) {
-            if (seq != null && id != null) {
-                send(socket, 'auth', {
-                    seq,
-                    id,
-                    version: VERSION,
-                    metadata: {},
-                    error: serializeError(ex),
-                });
-            }
-            else {
-                send(socket, 'error', {
-                    seq: 1,
-                    error: serializeError(ex),
-                });
-            }
-            socket.close(3401, 'Auth error');
-            throw ex;
-        }
-    }
-    /** WebSocket 断开时调用 */
-    [kOnClose](socket, ev) {
-        const delay = ev.code === 1000 ? 0 : 5000;
-        const tid = setTimeout(() => {
-            socket.destroy();
-            this.sockets.delete(socket.id);
-            this.disconnectingSockets.delete(socket.id);
-        }, delay);
-        this.disconnectingSockets.set(socket.id, tid);
-    }
-}
-/** 由 WS Server 建立的 RPC 连接 */
-export class RpcServerSocket extends RpcSocket {
-    constructor(id, server) {
-        super(id);
-        this.server = server;
-        this.seq = 1;
-    }
-    /** @inheritdoc */
-    authSocket() {
-        return Promise.resolve(this.socket[kMetadata]);
-    }
-    /** @inheritdoc */
-    get local() {
-        return this.server.local?.(this);
-    }
-    /** @inheritdoc */
-    onClose(ev) {
-        super.onClose(ev);
-        this.server[kOnClose](this, ev);
-    }
-    /** 替换 socket */
-    [kReplaceSocket](newSocket) {
-        this.socket = newSocket;
-        return this.ready;
-    }
-}
+import { waitAuth } from './auth.js';
+import { RpcSocket } from './socket.js';
+import { send } from './utils/messaging.js';
+import { serializeError } from './utils/serialize.js';
+import { VERSION } from './version.js';
+const kOnClose = Symbol('kOnClose');
+const kMetadata = Symbol('kMetadata');
+const kReplaceSocket = Symbol('kReplaceSocket');
+/** 由 WS Server 建立的 RPC 连接组 */
+export class RpcServer {
+    constructor(local, 
+    /** 认证客户端 */
+    authenticator = () => ({})) {
+        this.authenticator = authenticator;
+        this.sockets = new Map();
+        this.disconnectingSockets = new Map();
+        if (local == null) {
+            this.local = undefined;
+        }
+        else if (typeof local == 'function') {
+            this.local = local;
+        }
+        else {
+            this.local = () => local;
+        }
+    }
+    /** WebSocket 连接后调用此方法建立 RPC 连接 */
+    async connect(socket) {
+        const s = socket;
+        const [id, metadata] = await this.authSocket(socket);
+        s[kMetadata] = metadata;
+        let client = this.sockets.get(id);
+        if (!client) {
+            client = new RpcServerSocket(id, this);
+            this.sockets.set(id, client);
+        }
+        else {
+            const tid = this.disconnectingSockets.get(id);
+            if (tid != null) {
+                this.disconnectingSockets.delete(id);
+                clearTimeout(tid);
+            }
+        }
+        await client[kReplaceSocket](s);
+        return client;
+    }
+    /** 认证客户端 */
+    async authSocket(socket) {
+        let seq, id, remoteMetadata;
+        try {
+            [seq, id, remoteMetadata] = await waitAuth(socket);
+            const localMetadata = await this.authenticator(remoteMetadata);
+            send(socket, 'auth', {
+                seq,
+                id,
+                version: VERSION,
+                metadata: localMetadata,
+            });
+            return [id, remoteMetadata];
+        }
+        catch (ex) {
+            if (seq != null && id != null) {
+                send(socket, 'auth', {
+                    seq,
+                    id,
+                    version: VERSION,
+                    metadata: {},
+                    error: serializeError(ex),
+                });
+            }
+            else {
+                send(socket, 'error', {
+                    seq: 1,
+                    error: serializeError(ex),
+                });
+            }
+            socket.close(3401, 'Auth error');
+            throw ex;
+        }
+    }
+    /** WebSocket 断开时调用 */
+    [kOnClose](socket, ev) {
+        const delay = ev.code === 1000 ? 0 : 5000;
+        const tid = setTimeout(() => {
+            socket.destroy();
+            this.sockets.delete(socket.id);
+            this.disconnectingSockets.delete(socket.id);
+        }, delay);
+        this.disconnectingSockets.set(socket.id, tid);
+    }
+}
+/** 由 WS Server 建立的 RPC 连接 */
+export class RpcServerSocket extends RpcSocket {
+    constructor(id, server) {
+        super(id);
+        this.server = server;
+        this.seq = 1;
+    }
+    /** @inheritdoc */
+    authSocket() {
+        return Promise.resolve(this.socket[kMetadata]);
+    }
+    /** @inheritdoc */
+    get local() {
+        return this.server.local?.(this);
+    }
+    /** @inheritdoc */
+    onClose(ev) {
+        super.onClose(ev);
+        this.server[kOnClose](this, ev);
+    }
+    /** 替换 socket */
+    [kReplaceSocket](newSocket) {
+        this.socket = newSocket;
+        return this.ready;
+    }
+}
 //# sourceMappingURL=server.js.map