@4players/odin-common 1.5.1 → 1.6.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.6.0
+
+- Removed unused WebSocket and RPC functionality
+
 ## 1.5.0
 
 - Added `generateUUID`

package/lib/cjs/index.js

@@ -29,12 +29,10 @@ __exportStar(require("./utility/iterable"), exports);
 __exportStar(require("./utility/environment"), exports);
 __exportStar(require("./utility/json"), exports);
 __exportStar(require("./utility/result"), exports);
-__exportStar(require("./utility/rpc"), exports);
 __exportStar(require("./utility/selector"), exports);
 __exportStar(require("./utility/sleep"), exports);
 __exportStar(require("./utility/strand"), exports);
 __exportStar(require("./utility/url"), exports);
 __exportStar(require("./utility/uuid"), exports);
 __exportStar(require("./utility/validation"), exports);
-__exportStar(require("./utility/websocket"), exports);
 __exportStar(require("./plugin/api"), exports);

package/lib/esm/index.js

@@ -13,12 +13,10 @@ export * from './utility/iterable';
 export * from './utility/environment';
 export * from './utility/json';
 export * from './utility/result';
-export * from './utility/rpc';
 export * from './utility/selector';
 export * from './utility/sleep';
 export * from './utility/strand';
 export * from './utility/url';
 export * from './utility/uuid';
 export * from './utility/validation';
-export * from './utility/websocket';
 export * from './plugin/api';

package/lib/index.d.ts

@@ -13,12 +13,10 @@ export * from './utility/iterable';
 export * from './utility/environment';
 export * from './utility/json';
 export * from './utility/result';
-export * from './utility/rpc';
 export * from './utility/selector';
 export * from './utility/sleep';
 export * from './utility/strand';
 export * from './utility/url';
 export * from './utility/uuid';
 export * from './utility/validation';
-export * from './utility/websocket';
 export * from './plugin/api';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4players/odin-common",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "A collection of commonly used type definitions and utility functions across ODIN web projects",
   "author": "Josho Bleicker <josho.bleicker@4players.io> (https://www.4players.io)",
   "homepage": "https://www.4players.io",
@@ -27,13 +27,11 @@
   "dependencies": {
     "@msgpack/msgpack": "~3.0.0-beta2",
     "uuid": "~9.0.0",
-    "ws": "~8.16.0",
     "zod": "~3.22.0"
   },
   "devDependencies": {
     "@types/node": "~20.11.0",
     "@types/uuid": "~9.0.0",
-    "@types/ws": "~8.5.0",
     "@typescript-eslint/eslint-plugin": "~7.1.0",
     "@typescript-eslint/parser": "~7.1.0",
     "eslint": "~8.57.0",

package/lib/cjs/utility/rpc.js

@@ -1,225 +0,0 @@
-"use strict";
-/* eslint-disable no-dupe-class-members */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isKnownRpcMessage = exports.parseRpcMessage = exports.parseRpc = exports.TypedRpcConnection = exports.RpcConnection = exports.msgpackDecode = exports.msgpackEncode = void 0;
-const msgpack = require("@msgpack/msgpack");
-const serialization_1 = require("../schema/serialization");
-const result_1 = require("./result");
-function msgpackEncode(value) {
-    return msgpack.encode(value);
-}
-exports.msgpackEncode = msgpackEncode;
-function msgpackDecode(buffer) {
-    return msgpack.decode(buffer);
-}
-exports.msgpackDecode = msgpackDecode;
-class RpcConnection {
-    get closed() {
-        return this._Close.signal.aborted;
-    }
-    get closeSignal() {
-        return this._Close.signal;
-    }
-    constructor(webSocket) {
-        this.webSocket = webSocket;
-        this._SendQueue = [];
-        this._RecvQueue = [];
-        this._Requests = new Map();
-        this._Close = new AbortController();
-        this._NextId = 1;
-        this.webSocket.addEventListener('open', this._OnWebSocketOpen.bind(this));
-        this.webSocket.addEventListener('close', this.close.bind(this));
-        this.webSocket.addEventListener('message', this._OnWebSocketMessage.bind(this));
-        this.webSocket.binaryType = 'arraybuffer';
-        this._Close.signal.addEventListener('abort', this._Cleanup.bind(this), {
-            once: true,
-        });
-    }
-    request(name, properties, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closed) {
-                return Promise.resolve('closed');
-            }
-            const id = this._NextId;
-            const timeoutId = timeout === undefined
-                ? undefined
-                : setTimeout(() => this._TimeoutRequest(id), timeout);
-            this._Send([0, id, name, properties]);
-            return new Promise((resolve) => {
-                this._Requests.set(id, { resolve, timeoutId });
-                this._NextId += 1;
-            });
-        });
-    }
-    notify(name, properties) {
-        if (this.closed === false) {
-            this._Send([2, name, properties]);
-        }
-    }
-    recv() {
-        if (this.closed === false) {
-            return new Promise((resolve) => this._RecvQueue.push(resolve));
-        }
-        else {
-            return Promise.resolve('closed');
-        }
-    }
-    close() {
-        this._Close.abort();
-    }
-    _TimeoutRequest(requestId) {
-        const request = this._Requests.get(requestId);
-        if (request === undefined)
-            return;
-        this._Requests.delete(requestId);
-        clearTimeout(request.timeoutId);
-        request.resolve('timeout');
-    }
-    _Send(message) {
-        this.webSocket.send(msgpack.encode(message));
-    }
-    _OnWebSocketOpen(ev) {
-        for (const data in this._SendQueue) {
-            this.webSocket.send(data);
-        }
-        this._SendQueue.length = 0;
-    }
-    _OnWebSocketMessage(ev) {
-        const rpc = parseRpc(ev.data);
-        if (rpc.type !== 'Success') {
-            this.webSocket.close();
-            return;
-        }
-        switch (rpc.value[0]) {
-            case 0:
-                this._Send([1, rpc.value[1], 'not supported', undefined]);
-                break;
-            case 1:
-                this._OnResponse(rpc.value[1], rpc.value[2], rpc.value[3]);
-                break;
-            case 2:
-                this._OnEvent(rpc.value[1], rpc.value[2]);
-                break;
-        }
-    }
-    _OnResponse(id, error, result) {
-        const request = this._Requests.get(id);
-        if (request === undefined)
-            return;
-        clearTimeout(request.timeoutId);
-        request.resolve(error === null ? (0, result_1.success)(result) : (0, result_1.failure)(error));
-    }
-    _OnEvent(name, properties) {
-        const receiver = this._RecvQueue.shift();
-        if (receiver !== undefined) {
-            receiver({ name, properties });
-        }
-    }
-    _Cleanup() {
-        for (const request of this._Requests.values()) {
-            clearTimeout(request.timeoutId);
-            request.resolve('closed');
-        }
-        this._Requests.clear();
-        for (const accept of this._RecvQueue) {
-            accept('closed');
-        }
-        this._RecvQueue.length = 0;
-        this._SendQueue.length = 0;
-        this.webSocket.close();
-    }
-}
-exports.RpcConnection = RpcConnection;
-class TypedRpcConnection extends RpcConnection {
-    constructor(webSocket, _Commands, _Events) {
-        super(webSocket);
-        this._Commands = _Commands;
-        this._Events = _Events;
-    }
-    request(name, properties, timeout) {
-        const _super = Object.create(null, {
-            request: { get: () => super.request }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            properties = this._Commands[name].request.parse(properties);
-            const response = yield (timeout !== undefined
-                ? _super.request.call(this, name, properties, timeout)
-                : _super.request.call(this, name, properties));
-            if (response === 'closed' ||
-                response === 'timeout' ||
-                response.type === 'Failure') {
-                return response;
-            }
-            const parsed = this._Commands[name].response.safeParse(response.value);
-            if (parsed.success) {
-                response.value = parsed.data;
-                return response;
-            }
-            else {
-                return (0, result_1.failure)(`response schema failed validation: ${parsed.error}`);
-            }
-        });
-    }
-    notify(name, properties) {
-        properties = this._Commands[name].request.parse(properties);
-        super.notify(name, properties);
-    }
-    recv() {
-        const _super = Object.create(null, {
-            recv: { get: () => super.recv }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const event = yield _super.recv.call(this);
-            if (event === 'closed')
-                return event;
-            const parsed = parseRpcMessage(this._Events, event);
-            if (parsed !== undefined) {
-                return parsed;
-            }
-            if (!isKnownRpcMessage(this._Events, event.name)) {
-                console.warn(`dropping unknown event ${event.name}`);
-            }
-            else {
-                console.error(`schema validation for ${event.name} failed; closing connection`);
-                this.close();
-            }
-            return 'closed';
-        });
-    }
-}
-exports.TypedRpcConnection = TypedRpcConnection;
-function parseRpc(buffer) {
-    try {
-        return (0, result_1.success)(serialization_1.MessagePackRpcSchema.parse(msgpackDecode(buffer)));
-    }
-    catch (error) {
-        return (0, result_1.failure)(String(error));
-    }
-}
-exports.parseRpc = parseRpc;
-function parseRpcMessage(events, rpc) {
-    if (!isKnownRpcMessage(events, rpc.name))
-        return undefined;
-    const parsed = events[rpc.name].safeParse(rpc.properties);
-    if (!parsed.success) {
-        return undefined;
-    }
-    return {
-        name: rpc.name,
-        properties: parsed.data,
-    };
-}
-exports.parseRpcMessage = parseRpcMessage;
-function isKnownRpcMessage(events, name) {
-    return name in events;
-}
-exports.isKnownRpcMessage = isKnownRpcMessage;

package/lib/cjs/utility/websocket.js

@@ -1,86 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.webSocketConnectOnce = exports.webSocketConnect = exports.WebSocketClient = void 0;
-const ws_1 = require("ws");
-Object.defineProperty(exports, "WebSocketClient", { enumerable: true, get: function () { return ws_1.WebSocket; } });
-const result_1 = require("./result");
-const sleep_1 = require("./sleep");
-function webSocketConnect(url, connectIntervals, clientOptions, onFailure) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const start = performance.now();
-        let connection = (0, result_1.failure)('no connection was attempted');
-        let cancelled = false;
-        const cancel = () => {
-            cancelled = true;
-        };
-        const connect = () => __awaiter(this, void 0, void 0, function* () {
-            for (let failures = 0; failures < connectIntervals.length && !cancelled; failures++) {
-                const nextReconnectAt = start + whenToConnect(failures, connectIntervals);
-                yield (0, sleep_1.sleep)(nextReconnectAt - performance.now(), 'interval');
-                if (cancelled) {
-                    return (0, result_1.failure)('cancelled');
-                }
-                connection = yield webSocketConnectOnce(url, clientOptions);
-                if (connection.type === 'Success') {
-                    return connection;
-                }
-                else if (onFailure !== undefined) {
-                    onFailure(failures + 1, cancel);
-                }
-            }
-            return connection;
-        });
-        return { connect, cancel };
-    });
-}
-exports.webSocketConnect = webSocketConnect;
-function webSocketConnectOnce(url, clientOptions) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let webSocket;
-        try {
-            webSocket = new ws_1.WebSocket(url, clientOptions);
-        }
-        catch (reason) {
-            return (0, result_1.failure)(`unable to create websocket; ${reason}`);
-        }
-        return new Promise((resolve) => {
-            const onOpen = () => {
-                cleanup();
-                resolve((0, result_1.success)(webSocket));
-            };
-            const onError = (event) => {
-                cleanup();
-                resolve((0, result_1.failure)(event.message));
-            };
-            const onClose = (event) => {
-                cleanup();
-                resolve((0, result_1.failure)(event.reason));
-            };
-            const cleanup = () => {
-                webSocket.removeEventListener('open', onOpen);
-                webSocket.removeEventListener('error', onError);
-                webSocket.removeEventListener('close', onClose);
-            };
-            webSocket.addEventListener('open', onOpen);
-            webSocket.addEventListener('error', onError);
-            webSocket.addEventListener('close', onClose);
-        });
-    });
-}
-exports.webSocketConnectOnce = webSocketConnectOnce;
-function whenToConnect(failures, connectIntervals) {
-    const past_connects = connectIntervals
-        .slice(0, failures)
-        .reduce((a, b) => a + b, 0);
-    const interval = connectIntervals[failures] * Math.random();
-    return past_connects + interval;
-}

package/lib/esm/utility/rpc.js

@@ -1,215 +0,0 @@
-/* eslint-disable no-dupe-class-members */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import * as msgpack from '@msgpack/msgpack';
-import { MessagePackRpcSchema } from '../schema/serialization';
-import { failure, success } from './result';
-export function msgpackEncode(value) {
-    return msgpack.encode(value);
-}
-export function msgpackDecode(buffer) {
-    return msgpack.decode(buffer);
-}
-export class RpcConnection {
-    get closed() {
-        return this._Close.signal.aborted;
-    }
-    get closeSignal() {
-        return this._Close.signal;
-    }
-    constructor(webSocket) {
-        this.webSocket = webSocket;
-        this._SendQueue = [];
-        this._RecvQueue = [];
-        this._Requests = new Map();
-        this._Close = new AbortController();
-        this._NextId = 1;
-        this.webSocket.addEventListener('open', this._OnWebSocketOpen.bind(this));
-        this.webSocket.addEventListener('close', this.close.bind(this));
-        this.webSocket.addEventListener('message', this._OnWebSocketMessage.bind(this));
-        this.webSocket.binaryType = 'arraybuffer';
-        this._Close.signal.addEventListener('abort', this._Cleanup.bind(this), {
-            once: true,
-        });
-    }
-    request(name, properties, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.closed) {
-                return Promise.resolve('closed');
-            }
-            const id = this._NextId;
-            const timeoutId = timeout === undefined
-                ? undefined
-                : setTimeout(() => this._TimeoutRequest(id), timeout);
-            this._Send([0, id, name, properties]);
-            return new Promise((resolve) => {
-                this._Requests.set(id, { resolve, timeoutId });
-                this._NextId += 1;
-            });
-        });
-    }
-    notify(name, properties) {
-        if (this.closed === false) {
-            this._Send([2, name, properties]);
-        }
-    }
-    recv() {
-        if (this.closed === false) {
-            return new Promise((resolve) => this._RecvQueue.push(resolve));
-        }
-        else {
-            return Promise.resolve('closed');
-        }
-    }
-    close() {
-        this._Close.abort();
-    }
-    _TimeoutRequest(requestId) {
-        const request = this._Requests.get(requestId);
-        if (request === undefined)
-            return;
-        this._Requests.delete(requestId);
-        clearTimeout(request.timeoutId);
-        request.resolve('timeout');
-    }
-    _Send(message) {
-        this.webSocket.send(msgpack.encode(message));
-    }
-    _OnWebSocketOpen(ev) {
-        for (const data in this._SendQueue) {
-            this.webSocket.send(data);
-        }
-        this._SendQueue.length = 0;
-    }
-    _OnWebSocketMessage(ev) {
-        const rpc = parseRpc(ev.data);
-        if (rpc.type !== 'Success') {
-            this.webSocket.close();
-            return;
-        }
-        switch (rpc.value[0]) {
-            case 0:
-                this._Send([1, rpc.value[1], 'not supported', undefined]);
-                break;
-            case 1:
-                this._OnResponse(rpc.value[1], rpc.value[2], rpc.value[3]);
-                break;
-            case 2:
-                this._OnEvent(rpc.value[1], rpc.value[2]);
-                break;
-        }
-    }
-    _OnResponse(id, error, result) {
-        const request = this._Requests.get(id);
-        if (request === undefined)
-            return;
-        clearTimeout(request.timeoutId);
-        request.resolve(error === null ? success(result) : failure(error));
-    }
-    _OnEvent(name, properties) {
-        const receiver = this._RecvQueue.shift();
-        if (receiver !== undefined) {
-            receiver({ name, properties });
-        }
-    }
-    _Cleanup() {
-        for (const request of this._Requests.values()) {
-            clearTimeout(request.timeoutId);
-            request.resolve('closed');
-        }
-        this._Requests.clear();
-        for (const accept of this._RecvQueue) {
-            accept('closed');
-        }
-        this._RecvQueue.length = 0;
-        this._SendQueue.length = 0;
-        this.webSocket.close();
-    }
-}
-export class TypedRpcConnection extends RpcConnection {
-    constructor(webSocket, _Commands, _Events) {
-        super(webSocket);
-        this._Commands = _Commands;
-        this._Events = _Events;
-    }
-    request(name, properties, timeout) {
-        const _super = Object.create(null, {
-            request: { get: () => super.request }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            properties = this._Commands[name].request.parse(properties);
-            const response = yield (timeout !== undefined
-                ? _super.request.call(this, name, properties, timeout)
-                : _super.request.call(this, name, properties));
-            if (response === 'closed' ||
-                response === 'timeout' ||
-                response.type === 'Failure') {
-                return response;
-            }
-            const parsed = this._Commands[name].response.safeParse(response.value);
-            if (parsed.success) {
-                response.value = parsed.data;
-                return response;
-            }
-            else {
-                return failure(`response schema failed validation: ${parsed.error}`);
-            }
-        });
-    }
-    notify(name, properties) {
-        properties = this._Commands[name].request.parse(properties);
-        super.notify(name, properties);
-    }
-    recv() {
-        const _super = Object.create(null, {
-            recv: { get: () => super.recv }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const event = yield _super.recv.call(this);
-            if (event === 'closed')
-                return event;
-            const parsed = parseRpcMessage(this._Events, event);
-            if (parsed !== undefined) {
-                return parsed;
-            }
-            if (!isKnownRpcMessage(this._Events, event.name)) {
-                console.warn(`dropping unknown event ${event.name}`);
-            }
-            else {
-                console.error(`schema validation for ${event.name} failed; closing connection`);
-                this.close();
-            }
-            return 'closed';
-        });
-    }
-}
-export function parseRpc(buffer) {
-    try {
-        return success(MessagePackRpcSchema.parse(msgpackDecode(buffer)));
-    }
-    catch (error) {
-        return failure(String(error));
-    }
-}
-export function parseRpcMessage(events, rpc) {
-    if (!isKnownRpcMessage(events, rpc.name))
-        return undefined;
-    const parsed = events[rpc.name].safeParse(rpc.properties);
-    if (!parsed.success) {
-        return undefined;
-    }
-    return {
-        name: rpc.name,
-        properties: parsed.data,
-    };
-}
-export function isKnownRpcMessage(events, name) {
-    return name in events;
-}

package/lib/esm/utility/websocket.js

@@ -1,81 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { WebSocket as WebSocketClient, } from 'ws';
-import { failure, success } from './result';
-import { sleep } from './sleep';
-export { WebSocketClient, };
-export function webSocketConnect(url, connectIntervals, clientOptions, onFailure) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const start = performance.now();
-        let connection = failure('no connection was attempted');
-        let cancelled = false;
-        const cancel = () => {
-            cancelled = true;
-        };
-        const connect = () => __awaiter(this, void 0, void 0, function* () {
-            for (let failures = 0; failures < connectIntervals.length && !cancelled; failures++) {
-                const nextReconnectAt = start + whenToConnect(failures, connectIntervals);
-                yield sleep(nextReconnectAt - performance.now(), 'interval');
-                if (cancelled) {
-                    return failure('cancelled');
-                }
-                connection = yield webSocketConnectOnce(url, clientOptions);
-                if (connection.type === 'Success') {
-                    return connection;
-                }
-                else if (onFailure !== undefined) {
-                    onFailure(failures + 1, cancel);
-                }
-            }
-            return connection;
-        });
-        return { connect, cancel };
-    });
-}
-export function webSocketConnectOnce(url, clientOptions) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let webSocket;
-        try {
-            webSocket = new WebSocketClient(url, clientOptions);
-        }
-        catch (reason) {
-            return failure(`unable to create websocket; ${reason}`);
-        }
-        return new Promise((resolve) => {
-            const onOpen = () => {
-                cleanup();
-                resolve(success(webSocket));
-            };
-            const onError = (event) => {
-                cleanup();
-                resolve(failure(event.message));
-            };
-            const onClose = (event) => {
-                cleanup();
-                resolve(failure(event.reason));
-            };
-            const cleanup = () => {
-                webSocket.removeEventListener('open', onOpen);
-                webSocket.removeEventListener('error', onError);
-                webSocket.removeEventListener('close', onClose);
-            };
-            webSocket.addEventListener('open', onOpen);
-            webSocket.addEventListener('error', onError);
-            webSocket.addEventListener('close', onClose);
-        });
-    });
-}
-function whenToConnect(failures, connectIntervals) {
-    const past_connects = connectIntervals
-        .slice(0, failures)
-        .reduce((a, b) => a + b, 0);
-    const interval = connectIntervals[failures] * Math.random();
-    return past_connects + interval;
-}

package/lib/utility/rpc.d.ts

@@ -1,59 +0,0 @@
-/// <reference types="ws" />
-import * as z from 'zod';
-import { MessagePackRpc } from '../schema/serialization';
-import { Accept, Result } from './result';
-import { Commands } from '../rpc/commands';
-import { Notifications } from '../rpc/notifications';
-import { WebSocketClient } from './websocket';
-export declare function msgpackEncode(value: unknown): ArrayBuffer;
-export declare function msgpackDecode(buffer: ArrayBuffer): unknown;
-export interface RpcMessage {
-    name: string;
-    properties: unknown;
-}
-export interface RpcRequest {
-    resolve: Accept<Result<unknown> | 'closed' | 'timeout'>;
-    timeoutId: ReturnType<typeof setTimeout> | undefined;
-}
-export declare class RpcConnection {
-    readonly webSocket: WebSocketClient;
-    private readonly _SendQueue;
-    private readonly _RecvQueue;
-    private readonly _Requests;
-    private readonly _Close;
-    private _NextId;
-    get closed(): boolean;
-    get closeSignal(): AbortSignal;
-    constructor(webSocket: WebSocketClient);
-    request(name: string, properties: unknown): Promise<Result<unknown> | 'closed'>;
-    request(name: string, properties: unknown, timeout: number): Promise<Result<unknown> | 'closed' | 'timeout'>;
-    notify(name: string, properties: unknown): void;
-    recv(): Promise<RpcMessage | 'closed'>;
-    close(): void;
-    private _TimeoutRequest;
-    private _Send;
-    private _OnWebSocketOpen;
-    private _OnWebSocketMessage;
-    private _OnResponse;
-    private _OnEvent;
-    private _Cleanup;
-}
-export interface TypedRpcMessage<Name extends string, Properties> extends RpcMessage {
-    name: Name;
-    properties: Properties;
-}
-export type RealizedEvents<E extends Notifications> = {
-    [Name in Extract<keyof E, string>]: TypedRpcMessage<Name, z.infer<E[Name]>>;
-}[Extract<keyof E, string>];
-export declare class TypedRpcConnection<C extends Commands, E extends Notifications> extends RpcConnection {
-    readonly _Commands: C;
-    readonly _Events: E;
-    constructor(webSocket: WebSocketClient, _Commands: C, _Events: E);
-    request<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>): Promise<Result<z.infer<C[Name]['response']>> | 'closed'>;
-    request<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>, timeout: number): Promise<Result<z.infer<C[Name]['response']>> | 'closed' | 'timeout'>;
-    notify<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>): void;
-    recv(): Promise<RealizedEvents<E> | 'closed'>;
-}
-export declare function parseRpc(buffer: ArrayBuffer): Result<MessagePackRpc>;
-export declare function parseRpcMessage<E extends Notifications>(events: E, rpc: RpcMessage): RealizedEvents<E> | undefined;
-export declare function isKnownRpcMessage<E extends Notifications>(events: E, name: string): name is Extract<keyof E, string>;

package/lib/utility/websocket.d.ts

@@ -1,8 +0,0 @@
-import { WebSocket as WebSocketClient, ClientOptions as WebSocketClientOptions, CloseEvent as WebSocketCloseEvent, ErrorEvent as WebSocketErrorEvent, MessageEvent as WebSocketMessageEvent, EventListenerOptions as WebSocketEventListenerOptions, Event as WebSocketEvent } from 'ws';
-import { Result } from './result';
-export { WebSocketClient, WebSocketClientOptions, WebSocketCloseEvent, WebSocketErrorEvent, WebSocketMessageEvent, WebSocketEventListenerOptions, WebSocketEvent, };
-export declare function webSocketConnect(url: URL, connectIntervals: number[], clientOptions?: WebSocketClientOptions, onFailure?: (failures: number, cancel: () => void) => void): Promise<{
-    connect: () => Promise<Result<WebSocketClient>>;
-    cancel: () => void;
-}>;
-export declare function webSocketConnectOnce(url: URL, clientOptions?: WebSocketClientOptions): Promise<Result<WebSocketClient>>;