justrun-ws 0.1.0

package/README.md

@@ -0,0 +1,4 @@
+# justrun-ws
+[![justrun-ws npm version](https://img.shields.io/npm/v/justrun-ws.svg?style=popout&color=blue&label=justrun-ws)](https://www.npmjs.com/package/justrun-ws)
+
+Browser side network implementation with WebSocket for justrun.

package/lib/bundle.min.js

@@ -0,0 +1 @@
+(()=>{"use strict";new TextEncoder,new TextDecoder})();

package/lib/common/DataWrapper.js

@@ -0,0 +1,31 @@
+export class DataWrapper {
+    constructor(b, needParse) {
+        if (needParse) {
+            this.k = b;
+            this.l = undefined;
+        }
+        else {
+            this.k = undefined;
+            this.l = b;
+        }
+    }
+    get data() {
+        if (!this.l) {
+            this.l = this.decode(this.k);
+        }
+        return this.l;
+    }
+    set data(a) {
+        this.l = a;
+        this.k = undefined;
+    }
+    get buff() {
+        if (!this.k) {
+            this.k = this.encode(this.l);
+        }
+        return this.k;
+    }
+    k;
+    l;
+}
+//# sourceMappingURL=DataWrapper.js.map

package/lib/common/List.js

@@ -0,0 +1,52 @@
+export class ListNode {
+    constructor() {
+        this.e = this;
+        this.f = this;
+    }
+    getPrev() {
+        return this.e;
+    }
+    getNext() {
+        return this.f;
+    }
+    insertBefore(node) {
+        this.f = node;
+        this.e = node.e;
+        node.e = this;
+        this.e.f = this;
+    }
+    insertAfter(node) {
+        this.e = node;
+        this.f = node.f;
+        node.f = this;
+        this.f.e = this;
+    }
+    remove() {
+        this.e.f = this.f;
+        this.f.e = this.e;
+    }
+    e;
+    f;
+}
+export class c {
+    constructor() {
+        this.t = new ListNode();
+    }
+    get g() {
+        return this.t.getNext();
+    }
+    get a() {
+        return this.t.getPrev();
+    }
+    C(node) {
+        return node === this.t;
+    }
+    D(node) {
+        node.insertAfter(this.t);
+    }
+    U(node) {
+        node.insertBefore(this.t);
+    }
+    t;
+}
+//# sourceMappingURL=List.js.map

package/lib/common/utils.js

@@ -0,0 +1,30 @@
+export const j = (g) => {
+    return new Promise((f) => setTimeout(f, g));
+};
+export const i = () => { };
+export const k = (h = 0x100000000) => {
+    return (Math.random() * h) << 0;
+};
+export const m = (d) => {
+    let c = 5381, b = 0;
+    while (b < d.length) {
+        c = ((c << 5) + c) + d.charCodeAt(b++);
+    }
+    return c >>> 0;
+};
+export const l = (buffVector) => {
+    let b = 0;
+    let a = 0;
+    while (b < buffVector.length) {
+        a += buffVector[b++].length;
+    }
+    const e = new Uint8Array(a);
+    a = 0;
+    while (b > 0) {
+        const buff = buffVector[--b];
+        e.set(buff, a);
+        a += buff.length;
+    }
+    return e;
+};
+//# sourceMappingURL=utils.js.map

package/lib/common/varUintOps.js

@@ -0,0 +1,103 @@
+export const o = (a) => {
+    let e = 1;
+    while (a >>>= 7) {
+        e++;
+    }
+    return e;
+};
+export const j = (i) => {
+    let a;
+    let b = 0;
+    let e = 0;
+    while (b < i.length) {
+        e++;
+        a = i[b++];
+        while (a >>>= 7) {
+            e++;
+        }
+    }
+    return e;
+};
+export const p = (buffer, f = 0) => {
+    let c;
+    let d = f;
+    let a = 0;
+    let g = 0;
+    do {
+        c = buffer[d++];
+        a |= (c & 127) << g;
+        g += 7;
+    } while (c & 128);
+    if (c !== undefined && g <= 35) {
+        return {
+            a: a,
+            k: d - f,
+        };
+    }
+    else {
+        throw new Error('Parsing failed');
+    }
+};
+export const l = (n, buffer, f = 0) => {
+    let b;
+    let c;
+    let d = f;
+    let a = 0;
+    let g = 0;
+    const h = [];
+    for (b = 0; b < n; b++) {
+        do {
+            c = buffer[d++];
+            a |= (c & 127) << g;
+            g += 7;
+        } while (c & 128);
+        if (c !== undefined && g <= 35) {
+            h.push(a);
+            a = 0;
+            g = 0;
+        }
+        else {
+            throw new Error('Parsing failed');
+        }
+    }
+    return {
+        h,
+        k: d - f,
+    };
+};
+export const q = (a, buffer, f = 0) => {
+    let d = f;
+    let c = a & 127;
+    while (a >>>= 7) {
+        buffer[d++] = c | 128;
+        c = a & 127;
+    }
+    buffer[d++] = c;
+    if (d <= buffer.length) {
+        return d - f;
+    }
+    else {
+        throw new Error('Buffer overflow');
+    }
+};
+export const m = (h, buffer, f = 0) => {
+    let b;
+    let a;
+    let d = f;
+    for (b = 0; b < h.length; b++) {
+        a = h[b];
+        let c = a & 127;
+        while (a >>>= 7) {
+            buffer[d++] = c | 128;
+            c = a & 127;
+        }
+        buffer[d++] = c;
+    }
+    if (d <= buffer.length) {
+        return d - f;
+    }
+    else {
+        throw new Error('Buffer overflow');
+    }
+};
+//# sourceMappingURL=varUintOps.js.map

package/lib/handler/SimpleHandler.js

@@ -0,0 +1,128 @@
+import { a, c } from './common';
+export class SimpleMessageHandler {
+    constructor(wrapperCtor, d, e = true) {
+        this.g = wrapperCtor;
+        this.m = d;
+        this.n = e;
+    }
+    get pkgType() {
+        return this.g.pkgType;
+    }
+    get pkgName() {
+        return this.g.name;
+    }
+    async run(conn, parseResult) {
+        const { buff, bodyOffset } = parseResult;
+        const b = buff.subarray(bodyOffset);
+        const message = new this.g(b, true);
+        if (conn.context !== undefined || !this.n) {
+            try {
+                await this.m(conn, message);
+            }
+            catch (err) {
+                if (!err.isError) {
+                    this.wrapUncaughtError(conn, err);
+                }
+            }
+        }
+        else {
+            this.wrapUncaughtError(conn, a);
+        }
+        if (conn.context === undefined) {
+            await conn.close();
+        }
+    }
+    async runLocal(conn, message) {
+        if (conn.context !== undefined || !this.n) {
+            try {
+                return await this.m(conn, message);
+            }
+            catch (err) {
+                if (!err.isError) {
+                    this.wrapUncaughtError(conn, err);
+                }
+            }
+        }
+        else {
+            this.wrapUncaughtError(conn, a);
+        }
+    }
+    wrapUncaughtError(conn, err) {
+        return c(conn, err);
+    }
+    g;
+    m;
+    n;
+}
+export class h {
+    constructor(wrapperCtor, d, e = true) {
+        this.g = wrapperCtor;
+        this.m = d;
+        this.n = e;
+    }
+    get pkgType() {
+        return this.g.pkgType;
+    }
+    get pkgName() {
+        return this.g.name;
+    }
+    async run(conn, parseResult) {
+        const { buff, requestId, bodyOffset } = parseResult;
+        const b = buff.subarray(bodyOffset);
+        const request = new this.g(b, true);
+        let error;
+        if (conn.context !== undefined || !this.n) {
+            try {
+                await this.m(conn, request);
+            }
+            catch (err) {
+                if (err.isError) {
+                    error = err;
+                }
+                else {
+                    error = this.wrapUncaughtError(conn, err);
+                }
+            }
+        }
+        else {
+            error = this.wrapUncaughtError(conn, a);
+        }
+        try {
+            if (!error) {
+                await conn.sendResponse(request, requestId);
+            }
+            else {
+                await conn.sendErrorResponse(error, requestId);
+            }
+            if (conn.context === undefined) {
+                await conn.close();
+            }
+        }
+        catch (err) {
+            await conn.close(err);
+        }
+    }
+    async runLocal(conn, request) {
+        if (conn.context !== undefined || !this.n) {
+            try {
+                return await this.m(conn, request);
+            }
+            catch (err) {
+                if (err.isError) {
+                    throw err;
+                }
+                else {
+                    throw this.wrapUncaughtError(conn, err);
+                }
+            }
+        }
+        throw this.wrapUncaughtError(conn, a);
+    }
+    wrapUncaughtError(conn, err) {
+        return c(conn, err);
+    }
+    g;
+    m;
+    n;
+}
+//# sourceMappingURL=SimpleHandler.js.map

package/lib/handler/common.js

@@ -0,0 +1,14 @@
+import { JsonError } from '../net/JsonPackageWrapper';
+export class f extends JsonError {
+}
+export const a = { message: 'Connection is not authenticated' };
+let e = (b, err) => {
+    return new f(err.message);
+};
+export const c = (conn, err) => {
+    return e(conn, err);
+};
+export const h = (handler) => {
+    e = handler;
+};
+//# sourceMappingURL=common.js.map

package/lib/index.d.ts

@@ -0,0 +1,240 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export interface IWrapper<DataT> {
+	get buff(): Uint8Array;
+	get data(): DataT;
+}
+declare abstract class DataWrapper<DataT> implements IWrapper<DataT> {
+	constructor(input: DataT | Uint8Array, needParse?: true);
+	get data(): DataT;
+	set data(val: DataT);
+	get buff(): Uint8Array;
+	protected abstract encode(data: DataT): Uint8Array;
+	protected abstract decode(buffer: Uint8Array): DataT;
+	private _buff?;
+	private _data?;
+}
+declare abstract class PkgWrapper<DataT> extends DataWrapper<DataT> {
+	static context: unknown;
+	static registerPkgType(pkgType: number | string): void;
+	static get pkgType(): number | string;
+}
+export declare abstract class ErrorWrapper<ErrorT> extends PkgWrapper<ErrorT> {
+	isError(): boolean;
+}
+export declare abstract class MessageWrapper<MessageT> extends PkgWrapper<MessageT> {
+	isMessage(): boolean;
+}
+export declare abstract class EventWrapper<EventT> extends PkgWrapper<EventT> {
+	isEvent(): boolean;
+}
+export declare abstract class RequestWrapper<RequestT, ResponseT> extends PkgWrapper<RequestT> {
+	constructor(input: RequestT | Uint8Array, needParse?: true);
+	isRequest(): boolean;
+	get resp(): ResponseT;
+	set resp(val: ResponseT);
+	get respBuff(): Uint8Array;
+	set respBuff(val: Uint8Array);
+	protected abstract encodeResponse(response: ResponseT): Uint8Array;
+	protected abstract decodeResponse(buffer: Uint8Array): ResponseT;
+	private _resp?;
+	private _respBuff?;
+}
+export type ErrorWrapperCtor<ErrorT, WrapperT extends ErrorWrapper<ErrorT> = ErrorWrapper<ErrorT>> = new (error: ErrorT | Uint8Array, needParse?: true) => WrapperT;
+export type MessageWrapperCtor<MessageT, WrapperT extends MessageWrapper<MessageT> = MessageWrapper<MessageT>> = new (message: MessageT | Uint8Array, needParse?: true) => WrapperT;
+export type RequestWrapperCtor<RequestT, ResponseT, WrapperT extends RequestWrapper<RequestT, ResponseT> = RequestWrapper<RequestT, ResponseT>> = new (request: RequestT | Uint8Array, needParse?: true, _response?: ResponseT) => WrapperT;
+export interface AddressInfo {
+	address: string;
+	family: string;
+	port: number;
+}
+export interface IRawPkgConn {
+	readonly localAddress?: string;
+	readonly localPort?: number;
+	readonly remoteAddress?: string;
+	readonly remoteFamily?: string;
+	readonly remotePort?: number;
+	sendPkgBuff(buff: Uint8Array): Promise<void>;
+	sendPkgBuffV(buffVector: Uint8Array[]): Promise<void>;
+	close(err?: Error): Promise<void>;
+	hadClosed(): boolean;
+}
+export interface IPkgConnWrapper<ConnWrapperT> {
+	readonly conn: ConnWrapperT;
+	onPkgBuff: (buff: Uint8Array) => void;
+	onClose: (err?: Error) => void;
+}
+export interface INet<ConnWrapperT> {
+	address(): AddressInfo | null;
+	setConnWrapperMaker(makeWrapper: (conn: IRawPkgConn, isActive?: boolean) => IPkgConnWrapper<ConnWrapperT>): void;
+	startListen(connStr?: string): Promise<boolean>;
+	stopListen(): Promise<boolean>;
+	connect(connStr: string): Promise<ConnWrapperT>;
+}
+export interface IConn<ConnContextT = void> {
+	context?: ConnContextT | undefined;
+	readonly id: number;
+	readonly localAddress?: string;
+	readonly localPort?: number;
+	readonly remoteAddress?: string;
+	readonly remoteFamily?: string;
+	readonly remotePort?: number;
+	sendMessage<MessageT>(message: MessageWrapper<MessageT>): Promise<void>;
+	sendRequest<RequestT, ResponseT>(request: RequestWrapper<RequestT, ResponseT>): Promise<void>;
+	sendErrorResponse<ErrorT>(error: ErrorWrapper<ErrorT>, requestId: number): Promise<void>;
+	sendResponse<RequestT, ResponseT>(request: RequestWrapper<RequestT, ResponseT>, requestId: number): Promise<void>;
+	close(err?: Error): Promise<void>;
+}
+export interface IPkgHub<ConnContextT = void, HubContextT = void> {
+	context?: HubContextT | undefined;
+	address(): AddressInfo | null;
+	getConn(connId: number): IConn<ConnContextT> | undefined;
+	connect(connStr: string): Promise<IConn<ConnContextT>>;
+	connectLocal(): Promise<IConn<ConnContextT>>;
+	startServer(connStr?: string): Promise<boolean>;
+	stopServer(): Promise<boolean>;
+}
+export type ParseResult<PkgTypeT extends number | string> = {
+	buff: Uint8Array;
+	pkgType: PkgTypeT;
+	requestId: number;
+	bodyOffset: number;
+};
+export interface IPkgHandler<PkgTypeT extends number | string, ConnContextT = void> {
+	get pkgType(): PkgTypeT;
+	get pkgName(): string;
+	run(conn: IConn<ConnContextT>, parseResult: ParseResult<PkgTypeT>): void | Promise<void>;
+	wrapUncaughtError(conn: IConn<unknown>, err: Error): ErrorWrapper<unknown>;
+}
+export interface IMessageHandler<PkgTypeT extends number | string, MessageT, WrapperT extends MessageWrapper<MessageT>, ConnContextT = void> extends IPkgHandler<PkgTypeT, ConnContextT> {
+	runLocal(conn: IConn<ConnContextT>, message: WrapperT): void | Promise<void>;
+}
+export interface IRequestHandler<PkgTypeT extends number | string, RequestT, ResponseT, WrapperT extends RequestWrapper<RequestT, ResponseT>, ConnContextT = void> extends IPkgHandler<PkgTypeT, ConnContextT> {
+	runLocal(conn: IConn<ConnContextT>, request: WrapperT): void | Promise<void>;
+}
+export type HandleFunc<WrapperT, ConnContextT> = (conn: IConn<ConnContextT>, wrapper: WrapperT) => void | Promise<void>;
+export declare class SimpleMessageHandler<PkgTypeT extends number | string, MessageT, WrapperT extends MessageWrapper<MessageT>, ConnContextT> implements IMessageHandler<PkgTypeT, MessageT, WrapperT, ConnContextT> {
+	constructor(wrapperCtor: MessageWrapperCtor<MessageT, WrapperT>, handleFunc: HandleFunc<WrapperT, ConnContextT>, checkContext?: boolean);
+	get pkgType(): PkgTypeT;
+	get pkgName(): string;
+	run(conn: IConn<ConnContextT>, parseResult: ParseResult<PkgTypeT>): Promise<void>;
+	runLocal(conn: IConn<ConnContextT>, message: WrapperT): Promise<void>;
+	wrapUncaughtError(conn: IConn<unknown>, err: Error): ErrorWrapper<unknown>;
+	private _wrapperCtor;
+	private _handleFunc;
+	private _checkContext;
+}
+export declare class BrowserWsNet<ConnWrapperT> implements INet<ConnWrapperT> {
+	address(): AddressInfo | null;
+	setConnWrapperMaker(makeWrapper: (conn: IRawPkgConn, isActive?: boolean) => IPkgConnWrapper<ConnWrapperT>): void;
+	startListen(_connStr?: string): Promise<boolean>;
+	stopListen(): Promise<boolean>;
+	connect(connStr: string): Promise<ConnWrapperT>;
+	private setupConn;
+	private makeWrapper;
+}
+export declare const makeNumTypePkgBuff: (pkgType: number, requestId: number, encoded: Uint8Array[]) => void;
+export declare const parseNumTypePkgBuff: (buff: Uint8Array) => ParseResult<number>;
+export declare abstract class JsonError<ErrorT> extends ErrorWrapper<ErrorT> {
+	protected encode(data: ErrorT): Uint8Array;
+	protected decode(buffer: Uint8Array): ErrorT;
+}
+export declare abstract class JsonMessage<MessageT> extends MessageWrapper<MessageT> {
+	protected encode(data: MessageT): Uint8Array;
+	protected decode(buffer: Uint8Array): MessageT;
+}
+export declare abstract class JsonRequest<RequestT, ResponseT> extends RequestWrapper<RequestT, ResponseT> {
+	protected encode(data: RequestT): Uint8Array;
+	protected decode(buffer: Uint8Array): RequestT;
+	protected encodeResponse(response: ResponseT): Uint8Array;
+	protected decodeResponse(buffer: Uint8Array): ResponseT;
+}
+export declare class LazyConn<ConnContextT> implements IConn<ConnContextT> {
+	constructor(connectFunc: () => Promise<IConn<ConnContextT> | undefined>);
+	get id(): number;
+	get context(): ConnContextT | undefined;
+	set context(val: ConnContextT | undefined);
+	localAddress?: string | undefined;
+	localPort?: number | undefined;
+	remoteAddress?: string | undefined;
+	remoteFamily?: string | undefined;
+	remotePort?: number | undefined;
+	sendErrorResponse<ErrorT>(error: ErrorWrapper<ErrorT>, requestId: number): Promise<void>;
+	sendResponse<RequestT, ResponseT>(request: RequestWrapper<RequestT, ResponseT>, requestId: number): Promise<void>;
+	sendMessage<MessageT>(message: MessageWrapper<MessageT>): Promise<void>;
+	sendRequest<RequestT, ResponseT>(request: RequestWrapper<RequestT, ResponseT>): Promise<void>;
+	close(err?: Error): Promise<void>;
+	private connect;
+	private _connectFunc;
+	private _conn?;
+	private _waitingConn?;
+}
+declare class ListNode {
+	constructor();
+	getPrev<SelfT extends ListNode>(this: SelfT): SelfT;
+	getNext<SelfT extends ListNode>(this: SelfT): SelfT;
+	insertBefore<SelfT extends ListNode>(this: SelfT, node: SelfT): void;
+	insertAfter<SelfT extends ListNode>(this: SelfT, node: SelfT): void;
+	remove(): void;
+	private _prev;
+	private _next;
+}
+declare abstract class MonitorConn extends ListNode {
+	abstract keepAlive(): void;
+	abstract timeout(): void;
+}
+export declare class TimeoutMonitor {
+	constructor(tickMilSec: number, aliveTick: number, timeoutTick: number);
+	insert(conn: MonitorConn): void;
+	update(conn: MonitorConn): void;
+	remove(conn: MonitorConn): void;
+	private check;
+	private _tickMilSec;
+	private _aliveTick;
+	private _timeoutTick;
+	private _currentTick;
+	private _monitorCount;
+	private _interval?;
+	private _checkArr;
+}
+export type TypedPkgHubOpts<PkgTypeT extends number | string> = {
+	readonly responsePkgType: PkgTypeT;
+	readonly timeoutMonitor?: TimeoutMonitor;
+	makePkgBuff: (pkgType: PkgTypeT, requestId: number, encoded: Uint8Array[]) => void;
+	parsePkgBuff: (buff: Uint8Array) => ParseResult<PkgTypeT>;
+};
+export declare class TypedPkgHub<PkgTypeT extends number | string, ConnContextT = void, HubContextT = void> implements IPkgHub<ConnContextT, HubContextT> {
+	constructor(net: INet<IConn<ConnContextT>>, opts: TypedPkgHubOpts<PkgTypeT>);
+	readonly responsePkgType: PkgTypeT;
+	context?: HubContextT | undefined;
+	onConnOpen?: (pkgHub: IPkgHub<ConnContextT, HubContextT>, conn: IConn<ConnContextT>, activeOpen: boolean) => void;
+	onConnClose?: (pkgHub: IPkgHub<ConnContextT, HubContextT>, conn: IConn<ConnContextT>, activeClose: boolean, err?: Error) => void;
+	address(): AddressInfo | null;
+	getConn(connId: number): IConn<ConnContextT> | undefined;
+	connect(connStr: string): Promise<IConn<ConnContextT>>;
+	connectLocal(): Promise<IConn<ConnContextT>>;
+	startServer(connStr?: string): Promise<boolean>;
+	stopServer(): Promise<boolean>;
+	sendMessageLocal<MessageT>(conn: IConn<ConnContextT>, message: MessageWrapper<MessageT>): void | Promise<void>;
+	sendRequestLocal<RequestT, ResponseT>(conn: IConn<ConnContextT>, request: RequestWrapper<RequestT, ResponseT>): void | Promise<void>;
+	registerError<ErrorT>(pkgType: PkgTypeT, wrapperCtor: ErrorWrapperCtor<ErrorT>): void;
+	registerMessage<MessageT>(pkgType: PkgTypeT, wrapperCtor: MessageWrapperCtor<MessageT>): void;
+	registerRequest<RequestT, ResponseT>(pkgType: PkgTypeT, wrapperCtor: RequestWrapperCtor<RequestT, ResponseT>): void;
+	handleMessageWith<MessageT, WrapperT extends MessageWrapper<MessageT>>(handler: IMessageHandler<PkgTypeT, MessageT, WrapperT, ConnContextT>): IPkgHandler<PkgTypeT, ConnContextT>;
+	handleRequestWith<RequestT, ResponseT, WrapperT extends RequestWrapper<RequestT, ResponseT>>(handler: IRequestHandler<PkgTypeT, RequestT, ResponseT, WrapperT, ConnContextT>): IPkgHandler<PkgTypeT, ConnContextT>;
+	removeHandler(handler: IPkgHandler<PkgTypeT, ConnContextT>): boolean;
+	private connPkgBuffCallback;
+	private connClosedCallback;
+	private onResponse;
+	private _connOpts;
+	private _nextConnId;
+	private _makePkgBuff;
+	private _parsePkgBuff;
+	private _net;
+	private _connMap;
+	private _handlerMap;
+	private _errorWrapperMap;
+	private _timeoutMonitor?;
+}
+
+export {};

package/lib/index.js

@@ -0,0 +1,9 @@
+export { SimpleMessageHandler } from './handler/SimpleHandler';
+export { BrowserWsNet } from './net/BrowserWsNet';
+export { makeNumTypePkgBuff, parseNumTypePkgBuff } from './net/hubPkgSerializer';
+export { JsonError, JsonMessage, JsonRequest } from './net/JsonPackageWrapper';
+export { LazyConn } from './net/LazyConn';
+export { ErrorWrapper, EventWrapper, MessageWrapper, RequestWrapper } from './net/PackageWrapper';
+export { TimeoutMonitor } from './net/TimeoutMonitor';
+export { TypedPkgHub } from './net/TypedPkgHub';
+//# sourceMappingURL=index.js.map

package/lib/net/BrowserWsNet.js

@@ -0,0 +1,99 @@
+import { l } from '../common/utils';
+export class BrowserWsNet {
+    address() {
+        return null;
+    }
+    setConnWrapperMaker(makeWrapper) {
+        this.makeWrapper = makeWrapper;
+    }
+    async startListen(_connStr) {
+        return false;
+    }
+    async stopListen() {
+        return false;
+    }
+    async connect(connStr) {
+        const c = new WebSocket(connStr);
+        return new Promise((f, g) => {
+            c.onerror = (h) => {
+                g(new Error('WebSocket error'));
+            };
+            c.onopen = () => {
+                f(this.M(c, true));
+            };
+        });
+    }
+    M = (c, isActive) => {
+        const a = new i(c);
+        const { conn, onPkgBuff, onClose } = this.makeWrapper(a, isActive);
+        c.onmessage = (e) => {
+            e.data.arrayBuffer().then((buff) => {
+                onPkgBuff(new Uint8Array(buff));
+            });
+        };
+        c.onerror = (h) => {
+            onClose(new Error('WebSocket error'));
+        };
+        c.onclose = (e) => {
+            if (e.code === 1000) {
+                onClose();
+            }
+        };
+        return conn;
+    };
+    makeWrapper(b, j) {
+        throw new Error('Need to call "setConnWrapperMaker" before using');
+    }
+}
+class i {
+    constructor(c) {
+        this.d = c;
+    }
+    get localAddress() {
+        return;
+    }
+    get localPort() {
+        return;
+    }
+    get remoteAddress() {
+        return;
+    }
+    get remoteFamily() {
+        return;
+    }
+    get remotePort() {
+        return;
+    }
+    async sendPkgBuff(buff) {
+        if (this.d) {
+            return this.d.send(buff);
+        }
+        throw new Error('Invalid socket');
+    }
+    async sendPkgBuffV(buffVector) {
+        if (this.d) {
+            const buff = l(buffVector);
+            return this.d.send(buff);
+        }
+        throw new Error('Invalid socket');
+    }
+    async close(err) {
+        const { d } = this;
+        if (d) {
+            this.d = undefined;
+            if (!err) {
+                if (d.readyState === WebSocket.OPEN) {
+                    d.close(1000);
+                }
+            }
+            else {
+                d.close(3000, err.message);
+            }
+        }
+    }
+    hadClosed() {
+        return !this.d;
+    }
+    d;
+}
+//# sourceMappingURL=BrowserWsNet.js.map

package/lib/net/JsonPackageWrapper.js

@@ -0,0 +1,43 @@
+import { ErrorWrapper, MessageWrapper, RequestWrapper } from './PackageWrapper';
+export { JsonError, JsonMessage, JsonRequest, };
+const b = new TextEncoder();
+const c = new TextDecoder();
+class JsonError extends ErrorWrapper {
+    encode(data) {
+        const a = JSON.stringify(data);
+        return b.encode(a);
+    }
+    decode(buffer) {
+        const a = c.decode(buffer);
+        return JSON.parse(a);
+    }
+}
+class JsonMessage extends MessageWrapper {
+    encode(data) {
+        const a = JSON.stringify(data);
+        return b.encode(a);
+    }
+    decode(buffer) {
+        const a = c.decode(buffer);
+        return JSON.parse(a);
+    }
+}
+class JsonRequest extends RequestWrapper {
+    encode(data) {
+        const a = JSON.stringify(data);
+        return b.encode(a);
+    }
+    decode(buffer) {
+        const a = c.decode(buffer);
+        return JSON.parse(a);
+    }
+    encodeResponse(response) {
+        const a = JSON.stringify(response);
+        return b.encode(a);
+    }
+    decodeResponse(buffer) {
+        const a = c.decode(buffer);
+        return JSON.parse(a);
+    }
+}
+//# sourceMappingURL=JsonPackageWrapper.js.map

package/lib/net/LazyConn.js

@@ -0,0 +1,66 @@
+export class LazyConn {
+    constructor(c) {
+        this.B = c;
+    }
+    get id() {
+        return this.b?.id ?? -1;
+    }
+    get context() {
+        return this.b?.context;
+    }
+    set context(a) {
+        if (this.b) {
+            this.b.context = a;
+        }
+    }
+    localAddress;
+    localPort;
+    remoteAddress;
+    remoteFamily;
+    remotePort;
+    async sendErrorResponse(error, requestId) {
+        return (this.b ?? await this.connect()).sendErrorResponse(error, requestId);
+    }
+    async sendResponse(request, requestId) {
+        return (this.b ?? await this.connect()).sendResponse(request, requestId);
+    }
+    async sendMessage(message) {
+        return (this.b ?? await this.connect()).sendMessage(message);
+    }
+    async sendRequest(request) {
+        return (this.b ?? await this.connect()).sendRequest(request);
+    }
+    async close(err) {
+        const { b } = this;
+        if (b) {
+            this.b = undefined;
+            await b.close(err);
+            return;
+        }
+        if (this.i) {
+            await this.i.then((conn) => conn.close(err).then(() => this.b = undefined), () => this.b = undefined);
+        }
+    }
+    async connect() {
+        let { i } = this;
+        if (!i) {
+            i = this.i = new Promise((f, g) => {
+                this.B().then((conn) => {
+                    if (conn) {
+                        f(conn);
+                        this.b = conn;
+                        this.i = undefined;
+                    }
+                    else {
+                        g(new Error('Connect failed'));
+                    }
+                });
+            });
+        }
+        return await i;
+    }
+    B;
+    b;
+    i;
+}
+//# sourceMappingURL=LazyConn.js.map

package/lib/net/PackageWrapper.js

@@ -0,0 +1,71 @@
+import { DataWrapper } from '../common/DataWrapper';
+export { ErrorWrapper, MessageWrapper, EventWrapper, RequestWrapper, };
+class PkgWrapper extends DataWrapper {
+    static context;
+    static $(pkgType) {
+        let c;
+        try {
+            c = this.pkgType;
+        }
+        catch {
+            Object.defineProperty(this, 'pkgType', {
+                value: pkgType,
+                writable: false,
+                enumerable: false,
+            });
+            return;
+        }
+        if (c !== pkgType) {
+            throw new Error(`Wrapper ${this.name} is already registered with type ${c}`);
+        }
+    }
+    static get pkgType() {
+        throw new Error(`Wrapper ${this.name} need to be registered`);
+    }
+}
+class ErrorWrapper extends PkgWrapper {
+    isError() {
+        return true;
+    }
+}
+class MessageWrapper extends PkgWrapper {
+    isMessage() {
+        return true;
+    }
+}
+class EventWrapper extends PkgWrapper {
+    isEvent() {
+        return true;
+    }
+}
+class RequestWrapper extends PkgWrapper {
+    constructor(b, needParse) {
+        super(b, needParse);
+    }
+    isRequest() {
+        return true;
+    }
+    get resp() {
+        if (!this.r) {
+            this.r = this.decodeResponse(this.s);
+        }
+        return this.r;
+    }
+    set resp(a) {
+        this.r = a;
+        this.s = undefined;
+    }
+    get respBuff() {
+        if (!this.s) {
+            this.s = this.encodeResponse(this.r);
+        }
+        return this.s;
+    }
+    set respBuff(a) {
+        this.r = undefined;
+        this.s = a;
+    }
+    r;
+    s;
+}
+//# sourceMappingURL=PackageWrapper.js.map

package/lib/net/TimeoutMonitor.js

@@ -0,0 +1,70 @@
+import { ListNode, c } from '../common/List';
+import { i } from '../common/utils';
+export class MonitorConn extends ListNode {
+}
+export class TimeoutMonitor {
+    constructor(e, h, f) {
+        this.E = e;
+        this.y = h;
+        this.w = f;
+        this.j = 0;
+        this.x = 0;
+        this.o = [];
+        if (e === 0) {
+            this.insert = i;
+            this.update = i;
+            this.remove = i;
+            return;
+        }
+        for (let b = 0; b < f; b++) {
+            this.o.push(new c());
+        }
+    }
+    insert(conn) {
+        if (!this.x) {
+            this.F = setInterval(this.N, this.E);
+        }
+        this.x++;
+        this.o[this.j].D(conn);
+    }
+    update(conn) {
+        conn.remove();
+        this.o[this.j].D(conn);
+    }
+    remove(conn) {
+        conn.remove();
+        this.x--;
+        if (!this.x) {
+            clearInterval(this.F);
+        }
+    }
+    N = () => {
+        const { y, w, o } = this;
+        this.j++;
+        if (this.j === w) {
+            this.j = 0;
+        }
+        if (y) {
+            let d = this.j + y;
+            if (d >= w) {
+                d -= w;
+            }
+            const a = o[d];
+            for (let node = a.g; !a.C(node); node = node.getNext()) {
+                node.keepAlive();
+            }
+        }
+        const a = o[this.j];
+        for (let node = a.g; !a.C(node); node = node.getNext()) {
+            node.timeout();
+        }
+    };
+    E;
+    y;
+    w;
+    j;
+    x;
+    F;
+    o;
+}
+//# sourceMappingURL=TimeoutMonitor.js.map

package/lib/net/TypedPkgHub.js

@@ -0,0 +1,319 @@
+import { l, i } from '../common/utils';
+import { MonitorConn } from './TimeoutMonitor';
+export class TypedPkgHub {
+    constructor(s, m) {
+        const { responsePkgType, timeoutMonitor, makePkgBuff, parsePkgBuff } = m;
+        this.responsePkgType = responsePkgType;
+        this.context = undefined;
+        this.onConnOpen = undefined;
+        this.onConnClose = undefined;
+        this.p = 0;
+        this.q = new Map();
+        this.c = new Map();
+        this._ = new Map();
+        this.G = makePkgBuff;
+        this.H = parsePkgBuff;
+        this.u = s;
+        this.z = timeoutMonitor;
+        const o = this;
+        o.run = this.O;
+        const j = [];
+        this.G(responsePkgType, 0x200000, j);
+        this.I = {
+            makePkgBuff: makePkgBuff,
+            responsePkgType: responsePkgType,
+            j: l(j),
+        };
+        this.c.set(responsePkgType, o);
+        this.u.setConnWrapperMaker((a, isActive) => {
+            do {
+                this.p++;
+            } while (this.q.has(this.p & 0x1fffff));
+            const conn = new k(this.I, a, this.p & 0x1fffff);
+            this.q.set(conn.id, conn);
+            this.z?.insert(conn);
+            const e = {
+                conn,
+                onPkgBuff: (buff) => this.P(conn, buff),
+                onClose: (err) => this.Q(conn, err),
+            };
+            this.onConnOpen?.(this, conn, !!isActive);
+            return e;
+        });
+    }
+    responsePkgType;
+    context;
+    onConnOpen;
+    onConnClose;
+    address() {
+        return this.u.address();
+    }
+    getConn(connId) {
+        return this.q.get(connId);
+    }
+    connect(connStr) {
+        return this.u.connect(connStr);
+    }
+    async connectLocal() {
+        do {
+            this.p++;
+        } while (this.q.has(this.p & 0x1fffff));
+        const conn = new t(this.p & 0x1fffff, this);
+        this.q.set(conn.id, conn);
+        return conn;
+    }
+    async startServer(connStr) {
+        return this.u.startListen(connStr);
+    }
+    async stopServer() {
+        return this.u.stopListen();
+    }
+    sendMessageLocal(conn, message) {
+        const pkgType = message.constructor.pkgType;
+        const handler = this.c.get(pkgType);
+        if (handler) {
+            return handler?.runLocal(conn, message);
+        }
+        throw new Error('Invalid package');
+    }
+    sendRequestLocal(conn, request) {
+        const pkgType = request.constructor.pkgType;
+        const handler = this.c.get(pkgType);
+        if (handler) {
+            return handler?.runLocal(conn, request);
+        }
+        throw new Error('Invalid package');
+    }
+    registerError(pkgType, wrapperCtor) {
+        wrapperCtor.$(pkgType);
+        this._.set(pkgType, wrapperCtor);
+        const w = this.c.get(this.responsePkgType);
+        this.c.set(pkgType, w);
+    }
+    registerMessage(pkgType, wrapperCtor) {
+        wrapperCtor.$(pkgType);
+    }
+    registerRequest(pkgType, wrapperCtor) {
+        wrapperCtor.$(pkgType);
+    }
+    handleMessageWith(handler) {
+        const pkgType = handler.pkgType;
+        if (typeof pkgType !== typeof this.responsePkgType) {
+            throw new Error(`Wrapper ${handler.pkgName} has an incompatible pkgType ${typeof pkgType}`);
+        }
+        if (this.c.has(pkgType)) {
+            throw new Error(`Wrapper ${handler.pkgName} is already handled by another handler`);
+        }
+        this.c.set(pkgType, handler);
+        return handler;
+    }
+    handleRequestWith(handler) {
+        const pkgType = handler.pkgType;
+        if (typeof pkgType !== typeof this.responsePkgType) {
+            throw new Error(`Wrapper ${handler.pkgName} has an incompatible pkgType ${typeof pkgType}`);
+        }
+        if (this.c.has(pkgType)) {
+            throw new Error(`Wrapper ${handler.pkgName} is already handled by another handler`);
+        }
+        this.c.set(pkgType, handler);
+        return handler;
+    }
+    removeHandler(handler) {
+        const pkgType = handler.pkgType;
+        const x = this.c.get(pkgType);
+        if (x === handler) {
+            this.c.delete(pkgType);
+            return true;
+        }
+        return false;
+    }
+    P(conn, buff) {
+        this.z?.update(conn);
+        const parseResult = this.H(buff);
+        const handler = this.c.get(parseResult.pkgType);
+        if (handler) {
+            handler.run(conn, parseResult);
+            return;
+        }
+        conn.close(new Error('Invalid package'));
+    }
+    Q(conn, err) {
+        const connId = conn.id;
+        this.q.delete(connId);
+        this.z?.remove(conn);
+        conn.onClose(err);
+        this.onConnClose?.(this, conn, conn.a.hadClosed(), err);
+    }
+    O(conn, parseResult) {
+        const { buff, pkgType, requestId, bodyOffset } = parseResult;
+        if (pkgType === this.responsePkgType) {
+            const b = buff.subarray(bodyOffset);
+            conn.J(requestId, b);
+        }
+        else {
+            const r = this._.get(pkgType);
+            if (r) {
+                const b = buff.subarray(bodyOffset);
+                const y = new r(b, true);
+                conn.R(requestId, y);
+            }
+        }
+    }
+    I;
+    p;
+    G;
+    H;
+    u;
+    q;
+    c;
+    _;
+    z;
+}
+class k extends MonitorConn {
+    constructor(m, a, id) {
+        super();
+        this.context = undefined;
+        this.id = id;
+        this.a = a;
+        this.v = m;
+        this.h = undefined;
+        this.K = 0;
+    }
+    context;
+    id;
+    a;
+    get localAddress() {
+        return this.a.localAddress;
+    }
+    get localPort() {
+        return this.a.localPort;
+    }
+    get remoteAddress() {
+        return this.a.remoteAddress;
+    }
+    get remoteFamily() {
+        return this.a.remoteFamily;
+    }
+    get remotePort() {
+        return this.a.remotePort;
+    }
+    sendMessage(message) {
+        const pkgType = message.constructor.pkgType;
+        const encoded = [message.buff];
+        this.v.makePkgBuff(pkgType, 0, encoded);
+        return this.a.sendPkgBuffV(encoded);
+    }
+    sendRequest(request) {
+        this.h = new Map();
+        this.sendRequest = this.L;
+        this.J = this.S;
+        this.onClose = this.T;
+        return this.L(request);
+    }
+    sendErrorResponse(error, requestId) {
+        const pkgType = error.constructor.pkgType;
+        const encoded = [error.buff];
+        this.v.makePkgBuff(pkgType, requestId, encoded);
+        return this.a.sendPkgBuffV(encoded);
+    }
+    sendResponse(request, requestId) {
+        const encoded = [request.respBuff];
+        const { makePkgBuff, responsePkgType } = this.v;
+        makePkgBuff(responsePkgType, requestId, encoded);
+        return this.a.sendPkgBuffV(encoded);
+    }
+    async close(err) {
+        await this.a.close(err);
+    }
+    J(requestId, M) {
+        if (requestId === 0x200000 && this.context === undefined) {
+            this.close(new Error('Authenticating timeout'));
+        }
+    }
+    R(requestId, error) {
+        const d = this.h.get(requestId);
+        if (d) {
+            this.h.delete(requestId);
+            return d.g(error);
+        }
+    }
+    keepAlive() {
+        this.a.sendPkgBuff(this.v.j).catch(i);
+    }
+    timeout() {
+        this.close(new Error('Connection timeout'));
+    }
+    onClose(B) {
+    }
+    async L(request) {
+        const requestId = (this.K++) & 0x1fffff;
+        const C = new Promise((f, g) => {
+            const D = { f, g };
+            this.h.set(requestId, D);
+        });
+        const pkgType = request.constructor.pkgType;
+        const encoded = [request.buff];
+        this.v.makePkgBuff(pkgType, requestId, encoded);
+        this.a.sendPkgBuffV(encoded);
+        request.respBuff = await C;
+    }
+    S(requestId, b) {
+        const d = this.h.get(requestId);
+        if (d) {
+            this.h.delete(requestId);
+            d.f(b);
+            return;
+        }
+        if (requestId === 0x200000 && this.context === undefined) {
+            this.close(new Error('Authenticating timeout'));
+        }
+    }
+    T(err) {
+        const n = this.h;
+        if (n.size > 0) {
+            if (!err) {
+                err = new Error('Connection is closed');
+            }
+            for (const [requestId, d] of n) {
+                n.delete(requestId);
+                d.g(err);
+            }
+        }
+        this.h = undefined;
+    }
+    v;
+    h;
+    K;
+}
+class t {
+    constructor(id, E) {
+        this.context = undefined;
+        this.id = id;
+        this.A = E;
+    }
+    context;
+    id;
+    localAddress;
+    localPort;
+    remoteAddress;
+    remotePort;
+    get remoteFamily() {
+        return 'Local';
+    }
+    async sendMessage(message) {
+        return this.A.sendMessageLocal(this, message);
+    }
+    async sendRequest(request) {
+        return this.A.sendRequestLocal(this, request);
+    }
+    sendErrorResponse(N, F) {
+        throw null;
+    }
+    sendResponse(U, F) {
+        throw null;
+    }
+    async close(B) {
+    }
+    A;
+}
+//# sourceMappingURL=TypedPkgHub.js.map

package/lib/net/hubPkgSerializer.js

@@ -0,0 +1,14 @@
+import { j, l, m } from '../common/varUintOps';
+export const makeNumTypePkgBuff = (pkgType, requestId, encoded) => {
+    const i = [requestId, pkgType];
+    const b = j(i);
+    const a = new Uint8Array(b);
+    m(i, a);
+    encoded.push(a);
+};
+export const parseNumTypePkgBuff = (buff) => {
+    const { h: [requestId, pkgType], k: bodyOffset } = l(2, buff);
+    const d = { buff, pkgType, requestId, bodyOffset };
+    return d;
+};
+//# sourceMappingURL=hubPkgSerializer.js.map

package/lib/net/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=interfaces.js.map

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "justrun-ws",
+  "version": "0.1.0",
+  "scripts": {
+    "start": "webpack serve"
+  },
+  "files": [
+    "./lib/*"
+  ],
+  "module": "./lib/index.js",
+  "typings": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "default": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    }
+  },
+  "keywords": [
+    "justrun",
+    "justrun-ws"
+  ],
+  "author": "Andy Deng",
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.19.0",
+    "@types/jest": "^29.5.1",
+    "@typescript-eslint/eslint-plugin": "^8.25.0",
+    "@typescript-eslint/parser": "^8.25.0",
+    "dts-bundle-generator": "^9.5.1",
+    "eslint": "^9.21.0",
+    "eslint-plugin-import": "^2.31.0",
+    "globals": "^15.14.0",
+    "minify-ts": "^1.2.3",
+    "ts-loader": "^9.5.2",
+    "webpack": "^5.98.0",
+    "webpack-cli": "^6.0.1"
+  }
+}