@meshagent/meshagent 0.0.11 → 0.0.13

package/dist/browser/participant.d.ts

@@ -0,0 +1,18 @@
+import { RoomClient } from "./room-client";
+export declare abstract class Participant {
+    readonly id: string;
+    protected readonly client: RoomClient;
+    protected _attributes: Record<string, any>;
+    protected _connections: string[];
+    constructor(client: RoomClient, id: string);
+    get connections(): ReadonlyArray<string>;
+    getAttribute(name: string): any;
+}
+export declare class RemoteParticipant extends Participant {
+    readonly role: string;
+    constructor(client: RoomClient, id: string, role: string);
+}
+export declare class LocalParticipant extends Participant {
+    constructor(client: RoomClient, id: string);
+    setAttribute(name: string, value: any): Promise<void>;
+}

package/dist/browser/participant.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalParticipant = exports.RemoteParticipant = exports.Participant = void 0;
+const utils_1 = require("./utils");
+class Participant {
+    constructor(client, id) {
+        this._attributes = {};
+        this._connections = [];
+        this.client = client;
+        this.id = id;
+    }
+    get connections() {
+        return this._connections;
+    }
+    getAttribute(name) {
+        return this._attributes[name];
+    }
+}
+exports.Participant = Participant;
+class RemoteParticipant extends Participant {
+    constructor(client, id, role) {
+        super(client, id);
+        this.role = role;
+    }
+}
+exports.RemoteParticipant = RemoteParticipant;
+class LocalParticipant extends Participant {
+    constructor(client, id) {
+        super(client, id);
+    }
+    async setAttribute(name, value) {
+        this._attributes[name] = value;
+        try {
+            const payload = utils_1.encoder.encode(JSON.stringify({ [name]: value }));
+            await this.client.protocol.send("set_attributes", payload);
+        }
+        catch (err) {
+            console.warn("Unable to send attribute changes", err);
+        }
+    }
+}
+exports.LocalParticipant = LocalParticipant;

package/dist/browser/protocol.d.ts

@@ -0,0 +1,87 @@
+import WebSocket from "isomorphic-ws";
+export type UpdateCallback = (update: Uint8Array, origin?: any) => void;
+export interface ProtocolChannel {
+    start(onDataReceived: (data: Uint8Array) => void, { onDone, onError }: {
+        onDone?: () => void;
+        onError?: (error: any) => void;
+    }): void;
+    dispose(): void;
+    sendData(data: Uint8Array): Promise<void>;
+}
+export declare class StreamProtocolChannel implements ProtocolChannel {
+    input: ProtocolMessageStream<Uint8Array>;
+    output: ProtocolMessageStream<Uint8Array>;
+    started: boolean;
+    private _iterator;
+    constructor({ input, output }: {
+        input: ProtocolMessageStream<Uint8Array>;
+        output: ProtocolMessageStream<Uint8Array>;
+    });
+    start(onDataReceived: (data: Uint8Array) => void, { onDone, onError }: {
+        onDone?: () => void;
+        onError?: (error: any) => void;
+    }): void;
+    dispose(): void;
+    sendData(data: Uint8Array): Promise<void>;
+}
+export declare class WebSocketProtocolChannel implements ProtocolChannel {
+    url: string;
+    jwt: string;
+    webSocket: WebSocket | null;
+    onDataReceived?: (data: Uint8Array) => void;
+    private _opened;
+    constructor({ url, jwt }: {
+        url: string;
+        jwt: string;
+    });
+    start(onDataReceived: (data: Uint8Array) => void, { onDone, onError }: {
+        onDone?: () => void;
+        onError?: (error: any) => void;
+    }): void;
+    private _onOpen;
+    private _onData;
+    dispose(): void;
+    sendData(data: Uint8Array): Promise<void>;
+}
+export declare class ProtocolMessageStream<T> {
+    private _messages;
+    private _messageAdded;
+    private _closed;
+    add(message: T): Promise<void>;
+    close(): void;
+    stream(): AsyncGenerator<T>;
+}
+export type MessageHandler = (protocol: Protocol, messageId: number, type: string, data?: Uint8Array) => Promise<void> | void;
+export declare class Protocol {
+    channel: ProtocolChannel;
+    handlers: {
+        [type: string]: MessageHandler;
+    };
+    private _id;
+    private _send;
+    private _recvPacketId;
+    private _recvState;
+    private _recvPacketTotal;
+    private _recvMessageId;
+    private _recvType;
+    private _recvPackets;
+    private _iterator;
+    constructor({ channel }: {
+        channel: ProtocolChannel;
+    });
+    addHandler(type: string, handler: MessageHandler): void;
+    removeHandler(type: string): void;
+    handleMessage(messageId: number, type: string, data?: Uint8Array): Promise<void>;
+    getNextMessageId(): number;
+    send(type: string, data: Uint8Array, id?: number): Promise<void>;
+    sendJson(object: any): Promise<void>;
+    start(onMessage?: null): void;
+    dispose(): void;
+    onDataReceived(dataPacket: Uint8Array): void;
+}
+export declare class WebSocketClientProtocol extends Protocol {
+    constructor({ url, token }: {
+        url: string;
+        token: string;
+    });
+}

package/dist/browser/protocol.js

@@ -0,0 +1,305 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClientProtocol = exports.Protocol = exports.ProtocolMessageStream = exports.WebSocketProtocolChannel = exports.StreamProtocolChannel = void 0;
+const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
+const utils_1 = require("./utils");
+const completer_1 = require("./completer");
+class ProtocolMessage {
+    constructor({ id, type, data }) {
+        this.id = id;
+        this.type = type;
+        this.data = data;
+        this.sent = new completer_1.Completer();
+    }
+}
+class StreamProtocolChannel {
+    constructor({ input, output }) {
+        this.started = false;
+        this._iterator = null;
+        this.input = input;
+        this.output = output;
+    }
+    start(onDataReceived, { onDone, onError }) {
+        if (this.started) {
+            throw new Error("Already started");
+        }
+        this.started = true;
+        (async () => {
+            this._iterator?.return(null);
+            try {
+                this._iterator = this.input.stream();
+                for await (const message of this._iterator) {
+                    if (message) {
+                        onDataReceived(message);
+                    }
+                }
+            }
+            catch (error) {
+                if (onError) {
+                    onError(error);
+                }
+            }
+            finally {
+                if (onDone) {
+                    onDone();
+                }
+            }
+        })();
+    }
+    dispose() {
+        this._iterator?.return(null);
+        this._iterator = null;
+        this.input.close();
+    }
+    async sendData(data) {
+        this.output.add(data);
+    }
+}
+exports.StreamProtocolChannel = StreamProtocolChannel;
+class WebSocketProtocolChannel {
+    constructor({ url, jwt }) {
+        this.webSocket = null;
+        this._opened = new completer_1.Completer();
+        this._onOpen = () => this._opened.resolve();
+        this._onData = (event) => {
+            const data = event.data;
+            if (data instanceof Blob) {
+                (0, utils_1.blobToArrayBuffer)(data).then((buffer) => {
+                    if (this.onDataReceived) {
+                        this.onDataReceived(new Uint8Array(buffer));
+                    }
+                });
+            }
+            else if (typeof (data) == "string") {
+                if (this.onDataReceived) {
+                    this.onDataReceived(new Uint8Array(utils_1.encoder.encode(data)));
+                }
+            }
+            else if (data instanceof ArrayBuffer || data instanceof Buffer) {
+                if (this.onDataReceived) {
+                    this.onDataReceived(new Uint8Array(data));
+                }
+            }
+        };
+        this.url = url;
+        this.jwt = jwt;
+    }
+    start(onDataReceived, { onDone, onError }) {
+        if (typeof (onDataReceived) != "function") {
+            throw new Error("onDataReceived must be a function");
+        }
+        const url = new URL(this.url);
+        url.searchParams.set("token", this.jwt);
+        this.onDataReceived = onDataReceived;
+        this.webSocket = new isomorphic_ws_1.default(url.toString());
+        this.webSocket.addEventListener("open", this._onOpen);
+        this.webSocket.addEventListener("message", this._onData);
+        if (onDone) {
+            this.webSocket.addEventListener("close", onDone);
+        }
+        if (onError) {
+            this.webSocket.addEventListener("error", onError);
+        }
+    }
+    dispose() {
+        this.webSocket?.close();
+        this.webSocket = null;
+    }
+    async sendData(data) {
+        await this._opened.fut;
+        this.webSocket?.send(data);
+    }
+}
+exports.WebSocketProtocolChannel = WebSocketProtocolChannel;
+class ProtocolMessageStream {
+    constructor() {
+        this._messages = [];
+        this._messageAdded = new completer_1.Completer();
+        this._closed = false;
+    }
+    async add(message) {
+        this._messages.push(message);
+        if (!this._messageAdded.completed) {
+            this._messageAdded.complete();
+        }
+    }
+    close() {
+        if (!this._messageAdded.completed) {
+            this._closed = true;
+            this._messageAdded.complete();
+        }
+    }
+    async *stream() {
+        while (!this._closed) {
+            await this._messageAdded.fut;
+            this._messageAdded = new completer_1.Completer();
+            while (this._messages.length > 0 && !this._closed) {
+                const msg = this._messages.shift();
+                if (msg) {
+                    yield msg;
+                }
+            }
+        }
+    }
+}
+exports.ProtocolMessageStream = ProtocolMessageStream;
+class Protocol {
+    constructor({ channel }) {
+        this.handlers = {};
+        this._id = 0;
+        this._send = new ProtocolMessageStream();
+        this._recvPacketId = 0;
+        this._recvState = "ready";
+        this._recvPacketTotal = 0;
+        this._recvMessageId = -1;
+        this._recvType = "";
+        this._recvPackets = [];
+        this._iterator = null;
+        this.channel = channel;
+    }
+    addHandler(type, handler) {
+        this.handlers[type] = handler;
+    }
+    removeHandler(type) {
+        delete this.handlers[type];
+    }
+    async handleMessage(messageId, type, data) {
+        console.log(this.handlers, Object.keys(this.handlers));
+        const handler = this.handlers[type] ?? this.handlers["*"];
+        await handler(this, messageId, type, data);
+    }
+    getNextMessageId() {
+        return this._id++;
+    }
+    async send(type, data, id) {
+        const msg = new ProtocolMessage({ id: id ?? this.getNextMessageId(), type: type, data: data });
+        this._send.add(msg);
+        await msg.sent.fut;
+    }
+    async sendJson(object) {
+        return await this.send("application/json", utils_1.encoder.encode(JSON.stringify(object)));
+    }
+    start(onMessage = null) {
+        if (onMessage != null) {
+            this.addHandler("*", onMessage);
+        }
+        this.channel.start(this.onDataReceived.bind(this), {});
+        this._iterator?.return(null);
+        (async () => {
+            this._iterator = this._send.stream();
+            for await (const message of this._iterator) {
+                if (message) {
+                    console.log(`message recv on protocol ${message.id} ${message.type}`);
+                    const packets = Math.ceil((message.data.length / 1024));
+                    const header = new Uint8Array(4 * 4);
+                    const dataView = new DataView(header.buffer);
+                    dataView.setUint32(0, (message.id & 0x000fffff00000000) / Math.pow(2, 32), false);
+                    dataView.setUint32(4, message.id & 0xffffffff, false);
+                    dataView.setUint32(8, 0, false);
+                    dataView.setUint32(12, packets, false);
+                    const headerPacket = (0, utils_1.mergeUint8Arrays)(header, utils_1.encoder.encode(message.type));
+                    await this.channel.sendData(headerPacket);
+                    for (var i = 0; i < packets; i++) {
+                        const packetHeader = new Uint8Array(3 * 4);
+                        const dataView = new DataView(packetHeader.buffer);
+                        dataView.setUint32(0, (message.id & 0x000fffff00000000) / Math.pow(2, 32), false);
+                        dataView.setUint32(4, message.id & 0xffffffff, false);
+                        dataView.setUint32(8, i + 1, false);
+                        const packet = (0, utils_1.mergeUint8Arrays)(packetHeader, message.data.subarray(i * 1024, Math.min((i + 1) * 1024, message.data.length)));
+                        await this.channel.sendData(packet);
+                    }
+                    message.sent.resolve();
+                    console.log(`message sent on protocol ${message.id} ${message.type}`);
+                }
+            }
+            console.log("protocol done");
+        })();
+    }
+    dispose() {
+        this.channel.dispose();
+        this._iterator?.return(null);
+        this._iterator = null;
+    }
+    onDataReceived(dataPacket) {
+        const dataView = new DataView(dataPacket.buffer);
+        const messageId = dataView.getUint32(4, false) + dataView.getUint32(0, false) * Math.pow(2, 32);
+        const packet = dataView.getUint32(8, false);
+        if (packet != this._recvPacketId) {
+            this._recvState = "error";
+            console.log(dataPacket);
+            console.log(`received out of order packet got ${packet} expected ${this._recvPacketId}, total ${this._recvPacketTotal} message ID: ${messageId}`);
+        }
+        if (packet == 0) {
+            if (this._recvState == "ready" || this._recvState == "error") {
+                this._recvPacketTotal = dataView.getUint32(12, false);
+                this._recvMessageId = messageId;
+                this._recvType = utils_1.decoder.decode(dataPacket.subarray(16));
+                console.log(`recieved packet ${this._recvType}`);
+                if (this._recvPacketTotal == 0) {
+                    try {
+                        const merged = (0, utils_1.mergeUint8Arrays)(...this._recvPackets);
+                        this._recvPackets.length = 0;
+                        this.handleMessage(messageId, this._recvType, merged);
+                    }
+                    finally {
+                        console.log("expecting packet reset to 0");
+                        this._recvState = "ready";
+                        this._recvPacketId = 0;
+                        this._recvType = "";
+                        this._recvMessageId = -1;
+                    }
+                }
+                else {
+                    this._recvPacketId += 1;
+                    console.log(`expecting packet ${this._recvPacketId}`);
+                    this._recvState = "processing";
+                }
+            }
+            else {
+                this._recvState = "error";
+                this._recvPacketId = 0;
+                console.log("received packet 0 in invalid state");
+            }
+        }
+        else if (this._recvState != "processing") {
+            this._recvState = "error";
+            this._recvPacketId = 0;
+            console.log("received datapacket in invalid state");
+        }
+        else {
+            if (messageId != this._recvMessageId) {
+                this._recvState = "error";
+                this._recvPacketId = 0;
+                console.log("received packet from incorrect message");
+            }
+            this._recvPackets.push(dataPacket.subarray(12));
+            if (this._recvPacketTotal == this._recvPacketId) {
+                try {
+                    const merged = (0, utils_1.mergeUint8Arrays)(...this._recvPackets);
+                    this._recvPackets.length = 0;
+                    this.handleMessage(messageId, this._recvType, merged);
+                }
+                finally {
+                    this._recvState = "ready";
+                    this._recvPacketId = 0;
+                    this._recvType = "";
+                    this._recvMessageId = -1;
+                }
+            }
+            else {
+                this._recvPacketId += 1;
+            }
+        }
+    }
+}
+exports.Protocol = Protocol;
+class WebSocketClientProtocol extends Protocol {
+    constructor({ url, token }) {
+        const channel = new WebSocketProtocolChannel({ url, jwt: token });
+        super({ channel });
+    }
+}
+exports.WebSocketClientProtocol = WebSocketClientProtocol;

package/dist/browser/queues-client.d.ts

@@ -0,0 +1,26 @@
+import { RoomClient } from "./room-client";
+export declare class Queue {
+    name: string;
+    size: number;
+    constructor({ name, size }: {
+        name: string;
+        size: number;
+    });
+}
+export declare class QueuesClient {
+    private client;
+    constructor({ room }: {
+        room: RoomClient;
+    });
+    list(): Promise<Queue[]>;
+    open(name: string): Promise<void>;
+    drain(name: string): Promise<void>;
+    close(name: string): Promise<void>;
+    send(name: string, message: Record<string, any>, { create }: {
+        create?: boolean;
+    }): Promise<void>;
+    receive(name: string, { create, wait }: {
+        create?: boolean;
+        wait?: boolean;
+    }): Promise<Record<string, any> | null>;
+}

package/dist/browser/queues-client.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueuesClient = exports.Queue = void 0;
+const response_1 = require("./response");
+class Queue {
+    constructor({ name, size }) {
+        this.name = name;
+        this.size = size;
+    }
+}
+exports.Queue = Queue;
+class QueuesClient {
+    constructor({ room }) {
+        this.client = room;
+    }
+    async list() {
+        const response = (await this.client.sendRequest("queues.list", {}));
+        const queues = response.json["queues"];
+        return queues.map((q) => new Queue({ name: q["name"], size: q["size"] }));
+    }
+    async open(name) {
+        await this.client.sendRequest("queues.open", { name });
+    }
+    async drain(name) {
+        await this.client.sendRequest("queues.drain", { name });
+    }
+    async close(name) {
+        await this.client.sendRequest("queues.close", { name });
+    }
+    async send(name, message, { create = true }) {
+        await this.client.sendRequest("queues.send", { name, create, message });
+    }
+    async receive(name, { create = true, wait = true }) {
+        const response = await this.client.sendRequest("queues.receive", {
+            name,
+            create,
+            wait,
+        });
+        if (response instanceof response_1.EmptyResponse) {
+            return null;
+        }
+        else {
+            return response.json;
+        }
+    }
+}
+exports.QueuesClient = QueuesClient;

package/dist/browser/requirement.d.ts

@@ -0,0 +1,25 @@
+export declare class RoomException extends Error {
+    constructor(message: string);
+}
+export declare abstract class Requirement {
+    readonly name: string;
+    constructor({ name }: {
+        name: string;
+    });
+    static fromJson(r: Record<string, any>): Requirement;
+    abstract toJson(): Record<string, any>;
+}
+export declare class RequiredToolkit extends Requirement {
+    readonly tools?: string[];
+    constructor({ name, tools }: {
+        name: string;
+        tools?: string[];
+    });
+    toJson(): Record<string, any>;
+}
+export declare class RequiredSchema extends Requirement {
+    constructor({ name }: {
+        name: string;
+    });
+    toJson(): Record<string, any>;
+}

package/dist/browser/requirement.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredSchema = exports.RequiredToolkit = exports.Requirement = exports.RoomException = void 0;
+class RoomException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RoomException";
+    }
+}
+exports.RoomException = RoomException;
+class Requirement {
+    constructor({ name }) {
+        this.name = name;
+    }
+    static fromJson(r) {
+        if ("toolkit" in r) {
+            return new RequiredToolkit({ name: r["toolkit"], tools: r["tools"] });
+        }
+        if ("schema" in r) {
+            return new RequiredSchema({ name: r["schema"] });
+        }
+        throw new RoomException("invalid requirement json");
+    }
+}
+exports.Requirement = Requirement;
+class RequiredToolkit extends Requirement {
+    constructor({ name, tools }) {
+        super({ name });
+        this.tools = tools;
+    }
+    toJson() {
+        return {
+            toolkit: this.name,
+            tools: this.tools,
+        };
+    }
+}
+exports.RequiredToolkit = RequiredToolkit;
+class RequiredSchema extends Requirement {
+    constructor({ name }) {
+        super({ name });
+    }
+    toJson() {
+        return {
+            schema: this.name,
+        };
+    }
+}
+exports.RequiredSchema = RequiredSchema;

package/dist/browser/response.d.ts

@@ -0,0 +1,60 @@
+export interface Response {
+    pack(): Uint8Array;
+}
+export declare class LinkResponse implements Response {
+    url: string;
+    name: string;
+    constructor({ url, name }: {
+        url: string;
+        name: string;
+    });
+    static unpack(header: Record<string, any>, payload: Uint8Array): LinkResponse;
+    pack(): Uint8Array;
+    toString(): string;
+}
+export declare class FileResponse implements Response {
+    data: Uint8Array;
+    name: string;
+    mimeType: string;
+    constructor({ data, name, mimeType }: {
+        data: Uint8Array;
+        name: string;
+        mimeType: string;
+    });
+    static unpack(header: Record<string, any>, payload: Uint8Array): FileResponse;
+    pack(): Uint8Array;
+    toString(): string;
+}
+export declare class TextResponse implements Response {
+    text: string;
+    constructor({ text }: {
+        text: string;
+    });
+    static unpack(header: Record<string, any>, payload: Uint8Array): TextResponse;
+    pack(): Uint8Array;
+    toString(): string;
+}
+export declare class JsonResponse implements Response {
+    json: Record<string, any>;
+    constructor({ json }: {
+        json: Record<string, any>;
+    });
+    static unpack(header: Record<string, any>, payload: Uint8Array): JsonResponse;
+    pack(): Uint8Array;
+    toString(): string;
+}
+export declare class ErrorResponse implements Response {
+    text: string;
+    constructor({ text }: {
+        text: string;
+    });
+    static unpack(header: Record<string, any>, payload: Uint8Array): ErrorResponse;
+    pack(): Uint8Array;
+    toString(): string;
+}
+export declare class EmptyResponse implements Response {
+    static unpack(header: Record<string, any>, payload: Uint8Array): EmptyResponse;
+    pack(): Uint8Array;
+    toString(): string;
+}
+export declare function unpackResponse(data: Uint8Array): Response;