@nmtjs/protocol 0.12.4 → 0.12.6

package/dist/client/protocol.js

@@ -1,359 +1,358 @@
-import { createPromise } from "@nmtjs/common";
+import { createPromise, } from '@nmtjs/common';
 import { concat, decodeNumber, encodeNumber } from "../common/binary.js";
-import { ClientMessageType, ErrorCode, ServerMessageType } from "../common/enums.js";
+import { ClientMessageType, ErrorCode, ServerMessageType, } from "../common/enums.js";
 import { EventEmitter } from "./events.js";
-import { ProtocolClientBlobStream, ProtocolServerBlobStream, ProtocolServerStream } from "./stream.js";
+import { ProtocolClientBlobStream, ProtocolServerBlobStream, ProtocolServerStream, } from "./stream.js";
 export class ProtocolError extends Error {
-	code;
-	data;
-	constructor(code, message, data) {
-		super(message);
-		this.code = code;
-		this.data = data;
-	}
-	get message() {
-		return `${this.code} ${super.message}`;
-	}
-	toString() {
-		return `${this.code} ${this.message}`;
-	}
-	toJSON() {
-		return {
-			code: this.code,
-			message: this.message,
-			data: this.data
-		};
-	}
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+    get message() {
+        return `${this.code} ${super.message}`;
+    }
+    toString() {
+        return `${this.code} ${this.message}`;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            message: this.message,
+            data: this.data,
+        };
+    }
 }
 export class ProtocolClientStreams {
-	#collection = new Map();
-	get(streamId) {
-		const stream = this.#collection.get(streamId);
-		if (!stream) throw new Error("Stream not found");
-		return stream;
-	}
-	add(source, streamId, metadata) {
-		const stream = new ProtocolClientBlobStream(source, streamId, metadata);
-		this.#collection.set(streamId, stream);
-		return stream;
-	}
-	remove(streamId) {
-		this.#collection.delete(streamId);
-	}
-	abort(streamId, error) {
-		const stream = this.get(streamId);
-		stream.abort(error);
-		this.remove(streamId);
-	}
-	pull(streamId, size) {
-		const stream = this.get(streamId);
-		return stream.read(size);
-	}
-	end(streamId) {
-		this.get(streamId).end();
-		this.remove(streamId);
-	}
-	clear(error) {
-		if (error) {
-			for (const stream of this.#collection.values()) {
-				stream.abort(error);
-			}
-		}
-		this.#collection.clear();
-	}
+    #collection = new Map();
+    get(streamId) {
+        const stream = this.#collection.get(streamId);
+        if (!stream)
+            throw new Error('Stream not found');
+        return stream;
+    }
+    add(source, streamId, metadata) {
+        const stream = new ProtocolClientBlobStream(source, streamId, metadata);
+        this.#collection.set(streamId, stream);
+        return stream;
+    }
+    remove(streamId) {
+        this.#collection.delete(streamId);
+    }
+    abort(streamId, error) {
+        const stream = this.get(streamId);
+        stream.abort(error);
+        this.remove(streamId);
+    }
+    pull(streamId, size) {
+        const stream = this.get(streamId);
+        return stream.read(size);
+    }
+    end(streamId) {
+        this.get(streamId).end();
+        this.remove(streamId);
+    }
+    clear(error) {
+        if (error) {
+            for (const stream of this.#collection.values()) {
+                stream.abort(error);
+            }
+        }
+        this.#collection.clear();
+    }
 }
 export class ProtocolServerStreams {
-	#collection = new Map();
-	has(streamId) {
-		return this.#collection.has(streamId);
-	}
-	get(streamId) {
-		const stream = this.#collection.get(streamId);
-		if (!stream) throw new Error("Stream not found");
-		return stream;
-	}
-	add(streamId, stream) {
-		this.#collection.set(streamId, stream);
-		return stream;
-	}
-	remove(streamId) {
-		this.#collection.delete(streamId);
-	}
-	abort(streamId) {
-		if (this.has(streamId)) {
-			const stream = this.get(streamId);
-			stream.abort();
-			this.remove(streamId);
-		}
-	}
-	async push(streamId, chunk) {
-		const stream = this.get(streamId);
-		return await stream.push(chunk);
-	}
-	end(streamId) {
-		const stream = this.get(streamId);
-		stream.end();
-		this.remove(streamId);
-	}
-	clear(error) {
-		if (error) {
-			for (const stream of this.#collection.values()) {
-				stream.abort(error);
-			}
-		}
-		this.#collection.clear();
-	}
+    #collection = new Map();
+    has(streamId) {
+        return this.#collection.has(streamId);
+    }
+    get(streamId) {
+        const stream = this.#collection.get(streamId);
+        if (!stream)
+            throw new Error('Stream not found');
+        return stream;
+    }
+    add(streamId, stream) {
+        this.#collection.set(streamId, stream);
+        return stream;
+    }
+    remove(streamId) {
+        this.#collection.delete(streamId);
+    }
+    abort(streamId) {
+        if (this.has(streamId)) {
+            const stream = this.get(streamId);
+            stream.abort();
+            this.remove(streamId);
+        }
+    }
+    async push(streamId, chunk) {
+        const stream = this.get(streamId);
+        return await stream.push(chunk);
+    }
+    end(streamId) {
+        const stream = this.get(streamId);
+        stream.end();
+        this.remove(streamId);
+    }
+    clear(error) {
+        if (error) {
+            for (const stream of this.#collection.values()) {
+                stream.abort(error);
+            }
+        }
+        this.#collection.clear();
+    }
 }
-export let ProtocolTransportStatus = /* @__PURE__ */ function(ProtocolTransportStatus) {
-	ProtocolTransportStatus["CONNECTED"] = "CONNECTED";
-	ProtocolTransportStatus["DISCONNECTED"] = "DISCONNECTED";
-	ProtocolTransportStatus["CONNECTING"] = "CONNECTING";
-	return ProtocolTransportStatus;
-}({});
+export var ProtocolTransportStatus;
+(function (ProtocolTransportStatus) {
+    ProtocolTransportStatus["CONNECTED"] = "CONNECTED";
+    ProtocolTransportStatus["DISCONNECTED"] = "DISCONNECTED";
+    ProtocolTransportStatus["CONNECTING"] = "CONNECTING";
+})(ProtocolTransportStatus || (ProtocolTransportStatus = {}));
 export class ProtocolTransport extends EventEmitter {
-	status = ProtocolTransportStatus.DISCONNECTED;
+    status = ProtocolTransportStatus.DISCONNECTED;
 }
 export class ProtocolBaseTransformer {
-	encodeRPC(namespace, procedure, payload) {
-		return payload;
-	}
-	decodeRPC(namespace, procedure, payload) {
-		return payload;
-	}
-	decodeRPCChunk(namespace, procedure, payload) {
-		return payload;
-	}
-	decodeEvent(namespace, event, payload) {
-		return payload;
-	}
+    encodeRPC(namespace, procedure, payload) {
+        return payload;
+    }
+    decodeRPC(namespace, procedure, payload) {
+        return payload;
+    }
+    decodeRPCChunk(namespace, procedure, payload) {
+        return payload;
+    }
+    decodeEvent(namespace, event, payload) {
+        return payload;
+    }
 }
 export class BaseProtocol extends EventEmitter {
-	clientStreams = new ProtocolClientStreams();
-	serverStreams = new ProtocolServerStreams();
-	rpcStreams = new ProtocolServerStreams();
-	calls = new Map();
-	callId = 0;
-	streamId = 0;
-	constructor(format) {
-		super();
-		this.format = format;
-	}
-	get contentType() {
-		return this.format.contentType;
-	}
-	handleCallResponse(callId, call, response, transformer) {
-		if (response.error) {
-			call.reject(new ProtocolError(response.error.code, response.error.message, response.error.data));
-		} else {
-			try {
-				const transformed = transformer.decodeRPC(call.namespace, call.procedure, response.result);
-				if (response.stream) call.resolve({
-					result: transformed,
-					stream: response.stream
-				});
-				else call.resolve(transformed);
-			} catch (error) {
-				call.reject(new ProtocolError(ErrorCode.ClientRequestError, "Unable to decode response", error));
-			}
-		}
-		this.calls.delete(callId);
-	}
-	handleRpcResponse({ callId, error, result, streams }, transformer, stream) {
-		const call = this.calls.get(callId);
-		if (!call) throw new Error("Call not found");
-		for (const key in streams) {
-			const stream = streams[key];
-			this.serverStreams.add(stream.id, stream);
-		}
-		this.handleCallResponse(callId, call, error ? { error } : {
-			result,
-			stream
-		}, transformer);
-		return call;
-	}
-	handleRpcStreamResponse(response, stream, transformer) {
-		const call = this.handleRpcResponse(response, transformer, stream);
-		this.rpcStreams.add(response.callId, stream);
-		return call;
-	}
-	createCall(namespace, procedure, options) {
-		const timeoutSignal = AbortSignal.timeout(options.timeout);
-		const signal = options.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
-		const call = Object.assign(createPromise(), {
-			namespace,
-			procedure,
-			signal
-		});
-		timeoutSignal.addEventListener("abort", () => {
-			const error = new ProtocolError(ErrorCode.RequestTimeout, "Request timeout");
-			call.reject(error);
-		}, { once: true });
-		return call;
-	}
-	createRpc(namespace, procedure, payload, options, transformer) {
-		const callId = ++this.callId;
-		const call = this.createCall(namespace, procedure, options);
-		const { buffer, streams } = this.format.encodeRPC({
-			callId,
-			namespace,
-			procedure,
-			payload: transformer.encodeRPC(namespace, procedure, payload)
-		}, {
-			addStream: (blob) => {
-				const streamId = ++this.streamId;
-				return this.clientStreams.add(blob.source, streamId, blob.metadata);
-			},
-			getStream: (id) => {
-				const stream = this.clientStreams.get(id);
-				return stream;
-			}
-		});
-		this.calls.set(callId, call);
-		return {
-			callId,
-			call,
-			streams,
-			buffer
-		};
-	}
-	pushRpcStream(callId, chunk) {
-		this.rpcStreams.push(callId, chunk);
-	}
-	endRpcStream(callId) {
-		this.rpcStreams.end(callId);
-	}
-	abortRpcStream(callId) {
-		this.rpcStreams.abort(callId);
-	}
-	removeClientStream(streamId) {
-		this.clientStreams.remove(streamId);
-	}
-	pullClientStream(streamId, size) {
-		return this.clientStreams.pull(streamId, size);
-	}
-	endClientStream(streamId) {
-		this.clientStreams.end(streamId);
-	}
-	abortClientStream(streamId, error) {
-		this.clientStreams.abort(streamId, error);
-	}
-	addServerStream(stream) {
-		this.serverStreams.add(stream.id, stream);
-	}
-	removeServerStream(streamId) {
-		this.serverStreams.remove(streamId);
-	}
-	pushServerStream(streamId, chunk) {
-		return this.serverStreams.push(streamId, chunk);
-	}
-	endServerStream(streamId) {
-		this.serverStreams.end(streamId);
-	}
-	abortServerStream(streamId, error) {
-		this.serverStreams.abort(streamId);
-	}
-	emitEvent(namespace, event, payload, transformer) {
-		const transformed = transformer.decodeEvent(namespace, event, payload);
-		this.emit(`${namespace}/${event}`, transformed);
-	}
+    format;
+    clientStreams = new ProtocolClientStreams();
+    serverStreams = new ProtocolServerStreams();
+    rpcStreams = new ProtocolServerStreams();
+    calls = new Map();
+    callId = 0;
+    streamId = 0;
+    constructor(format) {
+        super();
+        this.format = format;
+    }
+    get contentType() {
+        return this.format.contentType;
+    }
+    handleCallResponse(callId, call, response, transformer) {
+        if (response.error) {
+            call.reject(new ProtocolError(response.error.code, response.error.message, response.error.data));
+        }
+        else {
+            try {
+                const transformed = transformer.decodeRPC(call.namespace, call.procedure, response.result);
+                if (response.stream)
+                    call.resolve({ result: transformed, stream: response.stream });
+                else
+                    call.resolve(transformed);
+            }
+            catch (error) {
+                call.reject(new ProtocolError(ErrorCode.ClientRequestError, 'Unable to decode response', error));
+            }
+        }
+        this.calls.delete(callId);
+    }
+    handleRpcResponse({ callId, error, result, streams }, transformer, stream) {
+        const call = this.calls.get(callId);
+        if (!call)
+            throw new Error('Call not found');
+        for (const key in streams) {
+            const stream = streams[key];
+            this.serverStreams.add(stream.id, stream);
+        }
+        this.handleCallResponse(callId, call, error ? { error } : { result, stream }, transformer);
+        return call;
+    }
+    handleRpcStreamResponse(response, stream, transformer) {
+        const call = this.handleRpcResponse(response, transformer, stream);
+        this.rpcStreams.add(response.callId, stream);
+        return call;
+    }
+    createCall(namespace, procedure, options) {
+        const timeoutSignal = AbortSignal.timeout(options.timeout);
+        const signal = options.signal
+            ? AbortSignal.any([options.signal, timeoutSignal])
+            : timeoutSignal;
+        const call = Object.assign(createPromise(), {
+            namespace,
+            procedure,
+            signal,
+        });
+        timeoutSignal.addEventListener('abort', () => {
+            const error = new ProtocolError(ErrorCode.RequestTimeout, 'Request timeout');
+            call.reject(error);
+        }, { once: true });
+        return call;
+    }
+    createRpc(namespace, procedure, payload, options, transformer) {
+        const callId = ++this.callId;
+        const call = this.createCall(namespace, procedure, options);
+        const { buffer, streams } = this.format.encodeRPC({
+            callId,
+            namespace,
+            procedure,
+            payload: transformer.encodeRPC(namespace, procedure, payload),
+        }, {
+            addStream: (blob) => {
+                const streamId = ++this.streamId;
+                return this.clientStreams.add(blob.source, streamId, blob.metadata);
+            },
+            getStream: (id) => {
+                const stream = this.clientStreams.get(id);
+                return stream;
+            },
+        });
+        this.calls.set(callId, call);
+        return { callId, call, streams, buffer };
+    }
+    pushRpcStream(callId, chunk) {
+        this.rpcStreams.push(callId, chunk);
+    }
+    endRpcStream(callId) {
+        this.rpcStreams.end(callId);
+    }
+    abortRpcStream(callId) {
+        this.rpcStreams.abort(callId);
+    }
+    removeClientStream(streamId) {
+        this.clientStreams.remove(streamId);
+    }
+    pullClientStream(streamId, size) {
+        return this.clientStreams.pull(streamId, size);
+    }
+    endClientStream(streamId) {
+        this.clientStreams.end(streamId);
+    }
+    abortClientStream(streamId, error) {
+        this.clientStreams.abort(streamId, error);
+    }
+    addServerStream(stream) {
+        this.serverStreams.add(stream.id, stream);
+    }
+    removeServerStream(streamId) {
+        this.serverStreams.remove(streamId);
+    }
+    pushServerStream(streamId, chunk) {
+        return this.serverStreams.push(streamId, chunk);
+    }
+    endServerStream(streamId) {
+        this.serverStreams.end(streamId);
+    }
+    abortServerStream(streamId, error) {
+        this.serverStreams.abort(streamId);
+    }
+    emitEvent(namespace, event, payload, transformer) {
+        const transformed = transformer.decodeEvent(namespace, event, payload);
+        this.emit(`${namespace}/${event}`, transformed);
+    }
 }
 export class Protocol extends BaseProtocol {
-	handleServerMessage(buffer, transport, transformer) {
-		const type = decodeNumber(buffer, "Uint8");
-		const messageBuffer = buffer.slice(Uint8Array.BYTES_PER_ELEMENT);
-		if (type in ServerMessageType) {
-			const messageType = type;
-			if (typeof ServerMessageType[messageType] !== "undefined") {
-				this[messageType](messageBuffer, transport, transformer);
-			} else {
-				throw new Error(`Unknown message type: ${messageType}`);
-			}
-		}
-	}
-	[ServerMessageType.Event](buffer, transport, transformer) {
-		const [namespace, event, payload] = this.format.decode(buffer);
-		this.emitEvent(namespace, event, payload, transformer);
-	}
-	[ServerMessageType.RpcResponse](buffer, transport, transformer) {
-		const response = this.format.decodeRPC(buffer, {
-			addStream: (id, callId, metadata) => {
-				return new ProtocolServerBlobStream(id, metadata, { start: () => {
-					transport.send(ClientMessageType.ServerStreamPull, encodeNumber(id, "Uint32"), {
-						callId,
-						streamId: id
-					});
-				} });
-			},
-			getStream: (id) => {
-				return this.serverStreams.get(id);
-			}
-		});
-		this.handleRpcResponse(response, transformer);
-	}
-	[ServerMessageType.RpcStreamResponse](buffer, transport, transformer) {
-		const response = this.format.decodeRPC(buffer, {
-			addStream: (id, callId, metadata) => {
-				return new ProtocolServerBlobStream(id, metadata, { start: () => {
-					transport.send(ClientMessageType.ServerStreamPull, encodeNumber(id, "Uint32"), {
-						callId,
-						streamId: id
-					});
-				} });
-			},
-			getStream: (id) => {
-				return this.serverStreams.get(id);
-			}
-		});
-		const stream = new ProtocolServerStream({ transform: (chunk, controller) => {
-			const transformed = transformer.decodeRPCChunk(call.namespace, call.procedure, chunk);
-			controller.enqueue(transformed);
-		} });
-		const call = this.handleRpcStreamResponse(response, stream, transformer);
-	}
-	[ServerMessageType.RpcStreamChunk](buffer, transport, transformer) {
-		const callId = decodeNumber(buffer, "Uint32");
-		const chunk = buffer.slice(Uint32Array.BYTES_PER_ELEMENT);
-		const payload = this.format.decode(chunk);
-		this.pushRpcStream(callId, payload);
-	}
-	[ServerMessageType.RpcStreamEnd](buffer, transport, transformer) {
-		const callId = decodeNumber(buffer, "Uint32");
-		this.endRpcStream(callId);
-	}
-	[ServerMessageType.RpcStreamAbort](buffer, transport, transformer) {
-		const callId = decodeNumber(buffer, "Uint32");
-		this.abortRpcStream(callId);
-	}
-	[ServerMessageType.ServerStreamPush](buffer, transport, transformer) {
-		const streamId = decodeNumber(buffer, "Uint32");
-		const chunk = buffer.slice(Uint32Array.BYTES_PER_ELEMENT);
-		this.pushServerStream(streamId, chunk);
-		transport.send(ClientMessageType.ServerStreamPull, encodeNumber(streamId, "Uint32"), { streamId });
-	}
-	[ServerMessageType.ServerStreamEnd](buffer, transport, transformer) {
-		const streamId = decodeNumber(buffer, "Uint32");
-		this.endServerStream(streamId);
-	}
-	[ServerMessageType.ServerStreamAbort](buffer, transport, transformer) {
-		const streamId = decodeNumber(buffer, "Uint32");
-		this.abortServerStream(streamId);
-	}
-	[ServerMessageType.ClientStreamPull](buffer, transport, transformer) {
-		const streamId = decodeNumber(buffer, "Uint32");
-		const size = decodeNumber(buffer, "Uint32", Uint32Array.BYTES_PER_ELEMENT);
-		this.pullClientStream(streamId, size).then((chunk) => {
-			if (chunk) {
-				transport.send(ClientMessageType.ClientStreamPush, concat(encodeNumber(streamId, "Uint32"), chunk), { streamId });
-			} else {
-				transport.send(ClientMessageType.ClientStreamEnd, encodeNumber(streamId, "Uint32"), { streamId });
-				this.endClientStream(streamId);
-			}
-		});
-	}
-	[ServerMessageType.ClientStreamAbort](buffer, transport, transformer) {
-		const streamId = decodeNumber(buffer, "Uint32");
-		this.abortClientStream(streamId);
-	}
+    handleServerMessage(buffer, transport, transformer) {
+        const type = decodeNumber(buffer, 'Uint8');
+        const messageBuffer = buffer.slice(Uint8Array.BYTES_PER_ELEMENT);
+        if (type in ServerMessageType) {
+            const messageType = type;
+            if (typeof ServerMessageType[messageType] !== 'undefined') {
+                this[messageType](messageBuffer, transport, transformer);
+            }
+            else {
+                throw new Error(`Unknown message type: ${messageType}`);
+            }
+        }
+    }
+    [ServerMessageType.Event](buffer, transport, transformer) {
+        const [namespace, event, payload] = this.format.decode(buffer);
+        this.emitEvent(namespace, event, payload, transformer);
+    }
+    [ServerMessageType.RpcResponse](buffer, transport, transformer) {
+        const response = this.format.decodeRPC(buffer, {
+            addStream: (id, callId, metadata) => {
+                return new ProtocolServerBlobStream(id, metadata, {
+                    start: () => {
+                        transport.send(ClientMessageType.ServerStreamPull, encodeNumber(id, 'Uint32'), { callId, streamId: id });
+                    },
+                });
+            },
+            getStream: (id) => {
+                return this.serverStreams.get(id);
+            },
+        });
+        this.handleRpcResponse(response, transformer);
+    }
+    [ServerMessageType.RpcStreamResponse](buffer, transport, transformer) {
+        const response = this.format.decodeRPC(buffer, {
+            addStream: (id, callId, metadata) => {
+                return new ProtocolServerBlobStream(id, metadata, {
+                    start: () => {
+                        transport.send(ClientMessageType.ServerStreamPull, encodeNumber(id, 'Uint32'), { callId, streamId: id });
+                    },
+                });
+            },
+            getStream: (id) => {
+                return this.serverStreams.get(id);
+            },
+        });
+        const stream = new ProtocolServerStream({
+            transform: (chunk, controller) => {
+                const transformed = transformer.decodeRPCChunk(call.namespace, call.procedure, chunk);
+                controller.enqueue(transformed);
+            },
+        });
+        const call = this.handleRpcStreamResponse(response, stream, transformer);
+    }
+    [ServerMessageType.RpcStreamChunk](buffer, transport, transformer) {
+        const callId = decodeNumber(buffer, 'Uint32');
+        const chunk = buffer.slice(Uint32Array.BYTES_PER_ELEMENT);
+        const payload = this.format.decode(chunk);
+        this.pushRpcStream(callId, payload);
+    }
+    [ServerMessageType.RpcStreamEnd](buffer, transport, transformer) {
+        const callId = decodeNumber(buffer, 'Uint32');
+        this.endRpcStream(callId);
+    }
+    [ServerMessageType.RpcStreamAbort](buffer, transport, transformer) {
+        const callId = decodeNumber(buffer, 'Uint32');
+        this.abortRpcStream(callId);
+    }
+    [ServerMessageType.ServerStreamPush](buffer, transport, transformer) {
+        const streamId = decodeNumber(buffer, 'Uint32');
+        const chunk = buffer.slice(Uint32Array.BYTES_PER_ELEMENT);
+        this.pushServerStream(streamId, chunk);
+        transport.send(ClientMessageType.ServerStreamPull, encodeNumber(streamId, 'Uint32'), { streamId });
+    }
+    [ServerMessageType.ServerStreamEnd](buffer, transport, transformer) {
+        const streamId = decodeNumber(buffer, 'Uint32');
+        this.endServerStream(streamId);
+    }
+    [ServerMessageType.ServerStreamAbort](buffer, transport, transformer) {
+        const streamId = decodeNumber(buffer, 'Uint32');
+        this.abortServerStream(streamId);
+    }
+    [ServerMessageType.ClientStreamPull](buffer, transport, transformer) {
+        const streamId = decodeNumber(buffer, 'Uint32');
+        const size = decodeNumber(buffer, 'Uint32', Uint32Array.BYTES_PER_ELEMENT);
+        this.pullClientStream(streamId, size).then((chunk) => {
+            if (chunk) {
+                transport.send(ClientMessageType.ClientStreamPush, concat(encodeNumber(streamId, 'Uint32'), chunk), { streamId });
+            }
+            else {
+                transport.send(ClientMessageType.ClientStreamEnd, encodeNumber(streamId, 'Uint32'), { streamId });
+                this.endClientStream(streamId);
+            }
+        });
+    }
+    [ServerMessageType.ClientStreamAbort](buffer, transport, transformer) {
+        const streamId = decodeNumber(buffer, 'Uint32');
+        this.abortClientStream(streamId);
+    }
 }
-
-//# sourceMappingURL=protocol.js.map