@meshagent/meshagent 0.0.11 → 0.0.13

package/index.js

@@ -1,2 +0,0 @@
-export { ServerXmlDocument } from "./server.js";
-export { ClientXmlDocument } from "./client.js";

package/protocol.js

@@ -1,459 +0,0 @@
-import { decode } from "base-64";
-import * as Y from "yjs";
-import { TextEncoder, TextDecoder } from "@kayahr/text-encoding";
-
-export class ServerProtocol {
-    constructor(onServerUpdate) {
-        this.doc = new Y.Doc();
-        this.doc.on('update', onServerUpdate);
-    }
-
-   update(update) {
-        Y.applyUpdate(this.doc, update);
-    }
-}
-
-export class ClientProtocol {
-    constructor(onClientUpdate) {
-        this.doc = new Y.Doc();
-        this.doc.on('update', onClientUpdate);
-    }
-
-   update(update) {
-        Y.applyUpdate(this.doc, update);
-    }
-}
-
-export class Completer {
-    constructor() {
-        const self = this;
-        this.fut = new Promise((resolve, reject) => {
-            self.resolve = () => {
-                this.completed = true;
-                resolve();
-            }
-            self.reject = () => {
-                this.completed = true;
-                reject();
-            };
-        });
-        this.completed = false;
-    }
-    
-}
-
-class ProtocolMessage {
-
-    /**
-     * @param {Object} message - the message
-     * @param {number} id - the message id
-     * @param {Uint8List} data - the data of the message
-     * @param {string} type - the type of the message
-    */
-    constructor({ id, data, type}) {
-        this.sent = new Completer()
-        this.id = id;
-        this.data = data;
-        this.type = type;
-    }
-}
-
-class ProtocolChannel {
-  
-  /* void Function(Uint8List data) */
-  start(onDataReceived) {
-    this.onDataReceived = onDataReceived;
-  }
-
-  dispose() {
-
-  }
-
-   /**
-     * @param {Uint8List} data - the data of the message
-   */
-  async sendData(data) {
-
-  }
-}
-
-
-export class StreamProtocolChannel extends ProtocolChannel {
-    /**
-     * 
-     * @param {Object} options
-     * @param {ProtocolMessageStream} options.input 
-     * @param {ProtocolMessageStream} options.output 
-     */
-    constructor({input, output}) {
-        super();
-        this.input = input;
-        this.output = output;
-    }
-
-    start(onDataReceived) {
-        if (this.started) {
-            throw new Error("Already started");
-        }
-        this.started = true;
-        (async () => {
-            for await (let message of this.input.stream()) {
-                onDataReceived(message);
-            }
-        })();
-    }
-
-    dispose() {
-        this.input.close();
-    }
-
-    async sendData(data)  {
-        this.output.add(data);
-    }
-}
-
-
-export class WebSocketProtocolChannel extends ProtocolChannel {
-    /**
-     * @param {Object} params - the params
-     * @param {string} url - the url to connect to
-    */
-    constructor({ url }) {
-        super();
-        this.url = url;
-        this._opened = new Completer();
-    }
-
-    /**
-     * 
-     * @param {A callback that will be called every time data is received} onDataReceived 
-     */
-    start(onDataReceived) {
-        if(typeof(onDataReceived) != "function") {
-            throw new Error("onDataReceived must be a function")
-        }
-        this.onDataReceived = onDataReceived;
-        this.webSocket = new WebSocket(this.url);
-        this.webSocket.onopen = () => {
-            this._opened.resolve();
-        };
-        this.webSocket.addEventListener("message", this.onData.bind(this))
-    }
-
-
-    onData(event) {
-        this.onDataReceived(new Uint8Array(event.data));
-    }
-
-
-    dispose() {
-        this.webSocket.close()
-    }
-
-    /**
-    * @param {Uint8Array} data - the data to send
-    */
-    async sendData(data) {
-        await this._opened.fut;
-        this.webSocket.send(data);
-    }
-}
-
-/*
-class LivekitProtocolChannel extends ProtocolChannel {
-  LivekitProtocolChannel(
-      {required this.room, required this.topic, required this.remote});
-
-  final lk.RemoteParticipant remote;
-  final lk.Room room;
-  final String topic;
-
-  lk.EventsListener<lk.RoomEvent>? listener;
-
-  void Function(Uint8List data)? onDataReceived;
-
-  @override
-  void start(void Function(Uint8List data) onDataReceived) {
-    this.onDataReceived = onDataReceived;
-    listener = room.createListener();
-    listener!.on<lk.DataReceivedEvent>(onDataPacket);
-  }
-
-  @override
-  void dispose() {
-    listener?.dispose();
-    onDataReceived = null;
-  }
-
-  @override
-  Future<void> sendData(Uint8List data) async {
-    await room.localParticipant!.publishData(data,
-        reliable: true, topic: topic, destinationIdentities: [remote.identity]);
-  }
-
-  void onDataPacket(lk.DataReceivedEvent evt) {
-    debugPrint(
-        "Message on topic $topic ${evt.participant?.identity} vs ${remote.identity}");
-    if (evt.topic == topic && evt.participant == remote) {
-      debugPrint("Processing message on topic $topic");
-
-      onDataReceived!(evt.data as Uint8List);
-    }
-  }
-}
-*/
-
-export class ProtocolMessageStream {
-    constructor() {
-        this._messages = [];
-        this._messageAdded = new Completer();
-        this._closed = false;
-    }
-
-    /**
-     * @param {ProtocolMessage} message 
-     */
-    async add(message) {
-        this._messages.push(message); 
-        if(!this._messageAdded.completed) {
-            this._messageAdded.resolve();
-        }
-    }
-
-    close() {
-        if(!this._messageAdded.completed) {
-            this._closed = true;
-            this._messageAdded.resolve();
-        }
-    }
-
-    async *stream() {
-        while(!this._closed) {
-            await this._messageAdded.fut;
-            this._messageAdded = new Completer();
-            while(this._messages.length > 0) {
-                if(this._closed) {
-                    break;
-                }
-                const msg = this._messages.shift();
-                yield msg;
-            }
-        }
-    }
-}
-
-const encoder = new TextEncoder("utf-8");
-const decoder = new TextDecoder("utf-8");
-
-export function mergeUint8Arrays(...arrays) {
-    const totalSize = arrays.reduce((acc, e) => acc + e.length, 0);
-    const merged = new Uint8Array(totalSize);
-  
-    arrays.forEach((array, i, arrays) => {
-      const offset = arrays.slice(0, i).reduce((acc, e) => acc + e.length, 0);
-      merged.set(array, offset);
-    });
-  
-    return merged;
-}
-
-export class Protocol {
-    /**
-     * @param {Object} params - the params
-     * @param {ProtocolChannel} params.channel - the protocol channel to use
-    */ 
-    constructor({channel}) {
-        this.channel = 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 = [];
-    }
-
-
-     /**
-     * @param {string} type - the type of message to handle
-     * @param {Function} handler - the message handler
-    */ 
-    addHandler(type, handler) {
-        this.handlers[type] = handler;
-    }
-
-    /**
-     * @param {string} type - the type of message to handle
-     * @param {Function} handler - the message handler
-    */ 
-    removeHandler(type, handler) {
-        delete this.handlers[type];
-    }
-
-    /**
-     * @param {number} messageId - the id of the message
-     * @param {string} type - the type of the message
-     * @param {Uint8Array?} data - the data for the message
-    */ 
-    async handleMessage(messageId, type, data) {
-        const handler = this.handlers[type] ?? this.handlers["*"];
-        await handler(this, messageId, type, data);    
-    }
-
-    
-    /**
-     * @returns {number} the next message id
-    */ 
-    getNextMessageId() {
-        return this._id++;
-    }
-
-    /**
-     * @param {string} type - the type of the message
-     * @param {Uint8Array} data - the data for the message
-     * @param {number?} messageId - the id of the message
-    */ 
-    async send(type, data, id) {
-        const msg = new ProtocolMessage({ id: id ?? this.getNextMessageId(), type: type, data: data });
-        this._send.add(msg);
-        await msg.sent.future;
-    }
-
-    /**
-     * @param {Object} object - the type of the message
-    */
-    async sendJson(object) {
-        return await send("application/json", encoder.encode(JSON.stringify(object)));
-    }
-
-    
-    start(onMessage = null) {
-        
-        if(onMessage != null) {
-            this.addHandler("*", onMessage);
-        }
-        this.channel.start(this.onDataReceived.bind(this));
-
-        (async () => {
-            for await (let message of this._send.stream()) {
-                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 = mergeUint8Arrays(
-                    header,
-                    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 = 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();
-    }
-
-    /**
-     * 
-     * @param {Uint8List} dataPacket
-     */
-    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 = decoder.decode(dataPacket.subarray(16));
-            console.log(`recieved packet ${this._recvType}`);
-
-            if (this._recvPacketTotal == 0) {
-                try {
-                    const merged = 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 = 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;
-            }
-        }
-    }
-}