@meshagent/meshagent 0.0.11 → 0.0.12

package/dist/node/utils.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefCount = exports.decoder = exports.encoder = void 0;
+exports.splitMessagePayload = splitMessagePayload;
+exports.splitMessageHeader = splitMessageHeader;
+exports.packMessage = packMessage;
+exports.mergeUint8Arrays = mergeUint8Arrays;
+exports.blobToArrayBuffer = blobToArrayBuffer;
+const text_encoding_1 = require("@kayahr/text-encoding");
+const encoder = new text_encoding_1.TextEncoder();
+exports.encoder = encoder;
+const decoder = new text_encoding_1.TextDecoder();
+exports.decoder = decoder;
+function splitMessagePayload(packet) {
+    const dataView = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+    const headerSize = dataView.getUint32(4, false) + dataView.getUint32(0, false) * Math.pow(2, 32);
+    return packet.subarray(8 + headerSize, packet.length);
+}
+function splitMessageHeader(packet) {
+    const dataView = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+    const headerSize = dataView.getUint32(4, false) + dataView.getUint32(0, false) * Math.pow(2, 32);
+    const payload = packet.subarray(8, 8 + headerSize);
+    return decoder.decode(payload);
+}
+function packMessage(request, data) {
+    const jsonMessage = encoder.encode(JSON.stringify(request));
+    const size = jsonMessage.length;
+    const header = new Uint8Array(4 * 2);
+    const dataView = new DataView(header.buffer);
+    dataView.setUint32(0, (size & 0x000fffff00000000) / Math.pow(2, 32), false);
+    dataView.setUint32(4, size & 0xffffffff, false);
+    return mergeUint8Arrays(header, jsonMessage, data ?? new Uint8Array(0));
+}
+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;
+}
+function blobToArrayBuffer(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = () => reject(reader.error);
+        reader.readAsArrayBuffer(blob);
+    });
+}
+class RefCount {
+    constructor(ref) {
+        this.ref = ref;
+        this.count = 1;
+    }
+}
+exports.RefCount = RefCount;

package/package.json

@@ -1,33 +1,47 @@
 {
     "name": "@meshagent/meshagent",
-    "version": "0.0.11",
+    "version": "0.0.12",
     "description": "Meshagent Client",
     "homepage": "https://www.meshagent.com",
-    "main": "index.js",
-    "type": "module",
     "scripts": {
-        "build": "esbuild entrypoint.js --sourcemap --tree-shaking=true --bundle --outdir=dist --target=esnext '--define:process={\"env\":\"production\",\"NODE_ENV\":\"production\"}' --define:global=window --analyze --format=cjs",
-        "test": "jest"
+        "test": "mocha dist/node/test/*.js",
+        "build": "./scripts/build.sh",
+        "build-browser-test": "node ./build-browser-test.js"
     },
-    "dependencies": {
-        "@babel/core": "^7.26.0",
-        "@babel/preset-env": "^7.26.0",
-        "@kayahr/text-encoding": "^1.3.0",
-        "base-64": "^1.0.0",
-        "uuid": "^11.0.3",
-        "ws": "^8.18.0",
-        "y-indexeddb": "^9.0.12",
-        "yjs": "^13.6.7"
+    "author": "Powerboards",
+    "license": "Apache-2.0",
+    "main": "./dist/node/index.js",
+    "exports": {
+        ".": {
+            "browser": "./dist/browser/index.js",
+            "default": "./dist/node/index.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "browser": {
+        "./dist/node/index.js": "./dist/browser/index.js"
     },
+    "files": [
+        "dist",
+        "!dist/**/test"
+    ],
     "devDependencies": {
-        "@eslint/js": "^9.14.0",
+        "@types/chai": "^5.0.1",
+        "@types/mocha": "^10.0.10",
+        "@types/node": "^22.13.9",
+        "@types/ws": "^8.18.0",
+        "chai": "^5.2.0",
         "esbuild": "^0.25.0",
-        "eslint": "^9.14.0",
-        "eslint-plugin-import": "^2.31.0",
-        "globals": "^15.12.0",
-        "jest": "^29.7.0",
-        "mocha": "^11.1.0"
+        "esm": "^3.2.25",
+        "mocha": "^11.1.0",
+        "typescript": "^5.8.2"
     },
-    "author": "",
-    "license": "Apache-2.0"
+    "dependencies": {
+        "@kayahr/text-encoding": "^2.0.0",
+        "isomorphic-ws": "^5.0.0",
+        "jose": "^6.0.8",
+        "@meshagent/meshagent-entrypoint": "^0.0.11",
+        "uuid": "^11.0.5",
+        "ws": "^8.18.0"
+    }
 }

package/babel.config.cjs

@@ -1,3 +0,0 @@
-module.exports = {
-  presets: [['@babel/preset-env', {targets: {node: 'current'}}]],
-};

package/client.js

@@ -1,422 +0,0 @@
-
-import { v4 } from "uuid";
-
-const uuid = v4;
-
-export class XmlElement {
-    constructor(
-        parent,
-        { tagName, attributes },
-        doc,
-    ) {
-        this._data = { 
-            tagName: tagName, 
-            attributes: attributes,
-            children: [],
-        };
-        this._parent = parent;
-        this._doc = doc;
-    }
-
-    get doc() {
-        return this._doc;
-    }
-
-    getNodeByID(id) {
-        if(id == this.id) {
-            return this;
-        }
-        for(let child of this.getChildren()) {
-            if(child instanceof XmlElement) {
-                let n = child.getNodeByID(id);
-                if(n != null) {
-                    return n;
-                } 
-            }
-        }
-        return null;
-    }
-
-    get id() {
-        return this.getAttribute("$id")
-    }
-
-    get tagName() {
-        return this._data["tagName"];
-    }
-
-    get parent() {
-        return this._parent;
-    }
-
-    getAttribute(name) {
-        return this._data["attributes"][name];
-    }
-
-    setAttribute(name, value) {
-        this.doc.sendChanges({"documentID" : this.doc.id,
-           "changes" : [{
-            "nodeID": this.id,
-            "setAttributes": {
-                [name] : value
-            }
-        }]});
-    }
-
-    removeAttribute(name) {
-        this.doc.sendChanges({"documentID" : this.doc.id, 
-           "changes" :  [{ 
-            "nodeID": this.id,
-            "removeAttributes": [name],
-        }]});
-    }
-
-    createChildElement(tagName, attributes) {
-        let elementData = {
-            "name" : tagName,
-            "attributes" : {
-                "$id" : uuid(),
-                ...attributes,
-            },
-            "children" : this._defaultChildren(tagName),
-        };
-        this.doc.sendChanges({"documentID" : this.doc.id,
-           "changes" : [{
-            "nodeID": this.id,
-            "insertChildren": {
-                "children": [
-                    {
-                        "element" : elementData
-                    }
-                ]
-            }
-        }]});
-        return this.getNodeByID(elementData.attributes.id);
-    }
-
-    createChildElementAt(index, tagName, attributes) {
-        let elementData = {
-            "name" : tagName,
-            "attributes" : {
-                "$id" : uuid(),
-                ...attributes,
-            },
-            "children" : this._defaultChildren(tagName),
-        };
-        this.doc.sendChanges({"documentID" : this.doc.id, 
-            "changes":[{
-                "nodeID": this.id,
-                "insertChildren": {
-                    "index" : index,
-                    "children": [
-                        {
-                            "element": elementData,
-                        }
-                    ]
-                }
-            }]});
-        return this.getNodeByID(elementData.attributes.id);
-    }
-
-    createChildElementAfter(element, tagName, attributes) {
-        if(element.parent?.id != this.id) {
-            throw Error("Element does not belong to this node");
-        }
-        let elementData = {
-            "name" : tagName,
-            "attributes" : {
-                "$id" : uuid(),
-                ...attributes,
-            },
-            "children" : this._defaultChildren(tagName),
-        }; 
-        this.doc.sendChanges({"documentID" : this.doc.id, 
-            "changes":[{
-            "nodeID": this.id,
-            "insertChildren": {
-                "after" : element.id,
-                "children": [
-                    {
-                        "element": elementData,
-                    }
-                ]
-            }
-        }]});
-        return this.getNodeByID(elementData.attributes.id);
-    }
-
-    _defaultChildren(tagName) {
-        if(tagName == "text") {
-            return [{
-                "text" : {
-                    "delta" : []
-                }
-            }];
-        }
-        return [];
-    }
-
-    delete() {
-        this.doc.sendChanges({"documentID" : this.doc.id, 
-            "changes":[{
-            "nodeID": this.id,
-            "delete": {
-            }
-        }]});
-    }
-
-    getChildren() {
-        return this._data["children"];
-    }
-}
-
-export class XmlText {
-    constructor(parent, data, doc) {
-        this._data = data;
-        this.parent = parent;
-        this.doc = doc;
-    }
-
-    get delta() {
-        return this._data.delta;
-    }
-
-    insert(index, text, attributes) {
-        this.doc.sendChanges({"documentID" : this.doc.id, 
-            "changes":[{
-            "nodeID" : this.parent.id,
-            "insertText" : {
-                "index" : index,
-                "text" : text,
-                "attributes" : attributes,
-            }
-        }]});
-    }
-
-    format(from, length, attributes) {
-        this.doc.sendChanges({"documentID" : this.doc.id, 
-            "changes":[{
-            "nodeID" :  this.parent.id,
-            "formatText" : {
-                "from" : from,
-                "length" : length,
-                "attributes" : attributes,
-            }
-        }]});
-    }
-
-    delete(index, length) {
-        this.doc.sendChanges({"documentID" : this.doc.id, 
-            "changes":[{
-            "nodeID" :  this.parent.id,
-            "deleteText" : {
-                "index" : index,
-                "length" : length,
-            }
-        }]});
-    }
-}
-
-export class ClientXmlDocument {    
-    constructor({ id, sendChanges }) {
-        this._root = new XmlElement(null, { tagName: "root", attributes: {}, children: [] }, this);
-        this.sendChanges = sendChanges;
-        this._id = id;
-    }
-
-    get id() {
-        return this._id;
-    }
-
-    get root() {
-        return this._root;
-    }
-
-    _createNode(parent, data) {
-       
-        if(data.element) {
-            const element = new XmlElement(parent, data.element, this);
-            if(data.element.children) {
-                for(let child of data.element.children) {
-                    element._data["children"].push(this._createNode(element, child));
-                }
-            }
-            return element;
-        } else if(data.text) {
-            return new XmlText(parent, data.text, this);
-        } else {
-            throw new Error("Unsupported "+JSON.stringify(data));
-        }
-    }
-
-    receiveChanges(message) {
-        const nodeID = message.target;
-        const target = message.root ? this.root : this.root.getNodeByID(nodeID);
-
-        // process element deltas
-        let retain = 0;
-        for(let delta of message.elements) {
-            if(delta.retain) {
-                retain += delta.retain;
-            }
-            if(delta.insert) {
-                for(let insert of delta.insert) {
-                    if(insert.element) {
-                        target._data["children"].splice(retain, 0, this._createNode(target, insert, this));
-                        retain++;
-                    } else if(insert.text) {
-                        target._data["children"].splice(retain, 0, this._createNode(target, insert, this));
-                        retain++;
-                    } else {
-                        throw new Error("Unsupported element delta");
-                    }
-                }
-            } else if(delta.delete) {
-                target._data["children"].splice(retain, delta.delete);
-                retain -= delta.delete;
-            }
-        }
-
-        // process text deltas
-        if(message.text.length != 0) {
-            
-            if(target.tagName != "text") {
-                throw new Error("Node is not a text node: "+target.tagName)     
-            }
-            const textNode = target._data["children"][0];
-            retain = 0;
-            let i = 0;
-            let offset = 0;
-            let targetDelta = textNode._data["delta"];
-            if(!targetDelta) {
-                throw new Error("Text node is missing delta")
-            }        
-
-            for(let delta of message.text) {
-               
-
-                if(delta.insert) {
-                    if(i == targetDelta.length) {
-                        targetDelta.push({ insert: delta.insert, attributes: delta.attributes ?? {} });
-                        i++;
-                        offset += delta.insert.length;
-                        retain += delta.insert.length;
-                    } else {
-                        let str = targetDelta[i].insert;
-                        targetDelta[i].insert = str.slice(0, retain - offset) + delta.insert + str.slice(retain - offset);
-                        retain += delta.insert.length;
-                    }
-                } else if(delta.delete) {
-                    let deleted = 0;
-                    while(delta.delete > deleted) {
-                        let remaining = delta.delete - deleted;
-                    
-                        // delete ends after item
-                        if(retain > offset) {
-                            // delete end
-                            let str = targetDelta[i].insert;
-                            let start = str.slice(0,retain - offset);
-                            let end =  str.slice(retain - offset);
-
-                            if(remaining >= end.length) {
-                                targetDelta[i].insert = start;
-                                deleted += end.length;
-                                i++;
-                                offset += str.length;
-                            } else {
-                                targetDelta[i].insert = start + end.slice(remaining);
-                                deleted += targetDelta[i].insert.length;
-                            }
-
-                            // TODO? increase retain?
-                        } else if(delta.delete - deleted >= targetDelta[i].insert.length) { 
-                            deleted += targetDelta[i].insert.length;
-                            offset += targetDelta.splice(i, 1);
-                        } else {
-                            // delete ends inside item, delete front
-                            let str = targetDelta[i].insert;
-                            let start = str.substr(0, remaining);
-                            let end = str.slice(remaining);
-                            targetDelta[i].insert = end;
-                            deleted += start.length;
-                        }
-                    }
-                } else if(delta.attributes) {
-
-                    let formatted = 0;
-                    while(delta.retain > formatted) {
-                        // format ends after item
-                        let remaining = delta.retain - formatted;
-
-                        if(retain > offset) {
-                            // format end
-                            let str = targetDelta[i].insert;
-                            let start = str.slice(0,retain - offset);
-                            let end =  str.slice(retain - offset);
-                            
-                            
-                            if(remaining >= end.length) {
-                                targetDelta[i].insert = start;
-                                targetDelta.splice(i+1, 0, { insert: end, attributes: {...targetDelta[i].attributes, ...delta.attributes} });
-
-                                formatted += end.length;
-                                // move to next item
-                                i++;
-                                i++;
-                                offset += str.length;
-                            } else {
-                                targetDelta[i].insert = start;
-                                targetDelta.splice(i+1, 0, { insert: end.slice(0, remaining), attributes: {...targetDelta[i].attributes, ...delta.attributes} });
-                                targetDelta.splice(i+2, 0, { insert: end.slice(remaining), attributes: {...targetDelta[i].attributes } });
-
-                                formatted += remaining;
-                                i++;
-                                i++;
-                                i++;
-                                offset += start.length + remaining;
-                            }
-                        } else if(delta.retain - formatted >= targetDelta[i].insert.length) { 
-                            formatted += targetDelta[i].insert.length;
-                            
-                            // format whole item
-                            for(let k of Object.keys(delta.attributes)) {
-                                targetDelta[i].attributes[k] = delta.attributes[k];
-                            }
-                            offset += targetDelta[i].insert.length;
-                            i++;
-                        } else {
-                            // format ends inside item, format front
-                            let str = targetDelta[i].insert;
-                            let start = str.substr(0, remaining);
-                            let end = str.slice(remaining);
-                            targetDelta[i].insert = start;
-                            targetDelta.push({ insert: end, attributes: { ...targetDelta[i].attributes,  }})
-                            for(let k of Object.keys(delta.attributes)) {
-                                targetDelta[i].attributes[k] = delta.attributes[k];
-                            }
-                            formatted += (delta.retain - formatted);
-                        }
-                    }
-                    retain += delta.retain;
-                } else if(delta.retain) {
-                    if(delta.retain) {
-                        retain += delta.retain;
-                    }
-                    
-                    while(retain > offset + targetDelta[i]?.insert.length ?? 0) {
-                        offset += targetDelta[i].insert.length;
-                        i++;
-                    }
-                }
-            }
-        }
-
-        message.attributes.set.forEach(change => {
-            target._data["attributes"][change.name] = change.value;
-        });
-
-        message.attributes.delete.forEach(name => {
-            delete target._data["attributes"][name];
-        });
-    }
-}