@meshagent/meshagent 0.0.11 → 0.0.12

package/dist/node/client.d.ts

@@ -0,0 +1,90 @@
+interface ElementData {
+    tagName: string;
+    attributes: Record<string, any>;
+    children: Array<XmlElement | XmlText>;
+}
+interface TextData {
+    delta: any;
+}
+export declare class XmlElement {
+    private _data;
+    private _parent;
+    private _doc;
+    constructor(parent: XmlElement | null, { tagName, attributes }: {
+        tagName: string;
+        attributes: Record<string, any>;
+    }, doc: ClientXmlDocument);
+    getNodeByID(id: string): XmlElement | XmlText | null;
+    get id(): string | undefined;
+    get doc(): ClientXmlDocument;
+    get data(): ElementData;
+    get tagName(): string;
+    get parent(): XmlElement | null;
+    getAttribute(name: string): any;
+    setAttribute(name: string, value: any): void;
+    removeAttribute(name: string): void;
+    createChildElement(tagName: string, attributes: Record<string, any>): XmlElement | XmlText | null;
+    createChildElementAt(index: number, tagName: string, attributes: Record<string, any>): XmlElement | XmlText | null;
+    createChildElementAfter(element: XmlElement | XmlText, tagName: string, attributes: Record<string, any>): XmlElement | XmlText | null;
+    protected _defaultChildren(tagName: string): any[];
+    delete(): void;
+    getChildren(): Array<XmlElement | XmlText>;
+}
+export declare class XmlText {
+    private _data;
+    parent: XmlElement;
+    doc: ClientXmlDocument;
+    constructor(parent: XmlElement, data: TextData, doc: ClientXmlDocument);
+    get delta(): any;
+    insert(index: number, text: string, attributes?: Record<string, any>): void;
+    format(from: number, length: number, attributes: Record<string, any>): void;
+    delete(index: number, length: number): void;
+    get id(): string | undefined;
+}
+type SendChangesFn = (message: any) => void;
+interface InsertElementData {
+    element?: {
+        name: string;
+        attributes: Record<string, any>;
+        children: any[];
+    };
+    text?: {
+        delta: any;
+    };
+}
+interface ReceiveChangesMessage {
+    target: string;
+    root: boolean;
+    elements: Array<{
+        retain?: number;
+        insert?: InsertElementData[];
+        delete?: number;
+    }>;
+    text: Array<{
+        insert?: string;
+        delete?: number;
+        attributes?: Record<string, any>;
+        retain?: number;
+    }>;
+    attributes: {
+        set: Array<{
+            name: string;
+            value: any;
+        }>;
+        delete: string[];
+    };
+}
+export declare class ClientXmlDocument {
+    private _root;
+    private _id;
+    sendChanges: SendChangesFn;
+    constructor({ id, sendChanges, }: {
+        id: string;
+        sendChanges: SendChangesFn;
+    });
+    get id(): string;
+    get root(): XmlElement;
+    _createNode(parent: XmlElement, data: InsertElementData): XmlElement | XmlText;
+    receiveChanges(message: ReceiveChangesMessage): void;
+}
+export {};

package/dist/node/client.js

@@ -0,0 +1,449 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientXmlDocument = exports.XmlText = exports.XmlElement = void 0;
+const uuid_1 = require("uuid");
+class XmlElement {
+    constructor(parent, { tagName, attributes }, doc) {
+        this._data = {
+            tagName,
+            attributes,
+            children: [],
+        };
+        this._parent = parent;
+        this._doc = doc;
+    }
+    getNodeByID(id) {
+        if (id === this.id) {
+            return this;
+        }
+        for (const child of this.getChildren()) {
+            if (child instanceof XmlElement) {
+                const found = child.getNodeByID(id);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    }
+    get id() {
+        return this.getAttribute("$id");
+    }
+    get doc() {
+        return this._doc;
+    }
+    get data() {
+        return this._data;
+    }
+    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) {
+        const newId = (0, uuid_1.v4)();
+        const elementData = {
+            name: tagName,
+            attributes: {
+                $id: newId,
+                ...attributes,
+            },
+            children: this._defaultChildren(tagName),
+        };
+        this.doc.sendChanges({
+            documentID: this.doc.id,
+            changes: [
+                {
+                    nodeID: this.id,
+                    insertChildren: {
+                        children: [
+                            {
+                                element: elementData,
+                            },
+                        ],
+                    },
+                },
+            ],
+        });
+        return this.getNodeByID(newId);
+    }
+    createChildElementAt(index, tagName, attributes) {
+        const newId = (0, uuid_1.v4)();
+        const elementData = {
+            name: tagName,
+            attributes: {
+                $id: newId,
+                ...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(newId);
+    }
+    createChildElementAfter(element, tagName, attributes) {
+        if (element instanceof XmlElement) {
+            if (element.parent?.id !== this.id) {
+                throw new Error("Element does not belong to this node");
+            }
+        }
+        else {
+            if (element.parent?.id !== this.id) {
+                throw new Error("Text does not belong to this node");
+            }
+        }
+        const newId = (0, uuid_1.v4)();
+        const elementData = {
+            name: tagName,
+            attributes: {
+                $id: newId,
+                ...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(newId);
+    }
+    _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;
+    }
+}
+exports.XmlElement = XmlElement;
+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,
+                    },
+                },
+            ],
+        });
+    }
+    get id() {
+        return this.parent?.id;
+    }
+}
+exports.XmlText = XmlText;
+class ClientXmlDocument {
+    constructor({ id, sendChanges, }) {
+        this._root = new XmlElement(null, { tagName: "root", attributes: {} }, 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, {
+                tagName: data.element.name,
+                attributes: data.element.attributes,
+            }, this);
+            if (data.element.children) {
+                for (const 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);
+        if (!target) {
+            throw new Error(`Target node ${nodeID} not found in document`);
+        }
+        let retain = 0;
+        for (const delta of message.elements) {
+            if (delta.retain) {
+                retain += delta.retain;
+            }
+            if (delta.insert) {
+                for (const insertItem of delta.insert) {
+                    const newNode = this._createNode(target, insertItem);
+                    target.data.children.splice(retain, 0, newNode);
+                    retain++;
+                }
+            }
+            else if (typeof delta.delete === "number") {
+                target.data.children.splice(retain, delta.delete);
+                retain -= delta.delete;
+            }
+        }
+        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];
+            let i = 0;
+            let offset = 0;
+            const targetDelta = textNode.delta;
+            if (!targetDelta) {
+                throw new Error("Text node is missing delta");
+            }
+            for (const 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 {
+                        const str = targetDelta[i].insert;
+                        targetDelta[i].insert =
+                            str.slice(0, retain - offset) +
+                                delta.insert +
+                                str.slice(retain - offset);
+                        retain += delta.insert.length;
+                    }
+                }
+                else if (typeof delta.delete === "number") {
+                    let deleted = 0;
+                    while (delta.delete > deleted) {
+                        const remaining = delta.delete - deleted;
+                        if (retain > offset) {
+                            const str = targetDelta[i].insert;
+                            const start = str.slice(0, retain - offset);
+                            const 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 += remaining;
+                            }
+                        }
+                        else if (remaining >= targetDelta[i].insert.length) {
+                            deleted += targetDelta[i].insert.length;
+                            offset += targetDelta[i].insert.length;
+                            targetDelta.splice(i, 1);
+                        }
+                        else {
+                            const str = targetDelta[i].insert;
+                            const start = str.substr(0, remaining);
+                            const end = str.slice(remaining);
+                            targetDelta[i].insert = end;
+                            deleted += start.length;
+                        }
+                    }
+                }
+                else if (delta.attributes) {
+                    let formatted = 0;
+                    while (delta.retain && delta.retain > formatted) {
+                        const remaining = delta.retain - formatted;
+                        if (retain > offset) {
+                            const str = targetDelta[i].insert;
+                            const start = str.slice(0, retain - offset);
+                            const 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;
+                                i += 2;
+                                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 += 3;
+                                offset += start.length + remaining;
+                            }
+                        }
+                        else if (delta.retain - formatted >= targetDelta[i].insert.length) {
+                            formatted += targetDelta[i].insert.length;
+                            Object.assign(targetDelta[i].attributes, delta.attributes);
+                            offset += targetDelta[i].insert.length;
+                            i++;
+                        }
+                        else {
+                            const str = targetDelta[i].insert;
+                            const start = str.substr(0, remaining);
+                            const end = str.slice(remaining);
+                            targetDelta[i].insert = start;
+                            targetDelta.push({
+                                insert: end,
+                                attributes: { ...targetDelta[i].attributes },
+                            });
+                            Object.assign(targetDelta[i].attributes, delta.attributes);
+                            formatted += remaining;
+                        }
+                    }
+                    if (delta.retain) {
+                        retain += delta.retain;
+                    }
+                }
+                else if (typeof delta.retain === "number") {
+                    retain += delta.retain;
+                    while (i < targetDelta.length &&
+                        retain > offset + targetDelta[i]?.insert.length) {
+                        offset += targetDelta[i].insert.length;
+                        i++;
+                    }
+                }
+            }
+        }
+        for (const change of message.attributes.set) {
+            target.data.attributes[change.name] = change.value;
+        }
+        for (const name of message.attributes.delete) {
+            delete target.data.attributes[name];
+        }
+    }
+}
+exports.ClientXmlDocument = ClientXmlDocument;

package/dist/node/completer.d.ts

@@ -0,0 +1,9 @@
+export declare class Completer<T = any> {
+    completed: boolean;
+    fut: Promise<T>;
+    resolve: (value?: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    constructor();
+    complete(value?: T | PromiseLike<T>): void;
+    completeError(reason?: any): void;
+}

package/dist/node/completer.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Completer = void 0;
+class Completer {
+    constructor() {
+        this.completed = false;
+        this.fut = new Promise((resolve, reject) => {
+            this.resolve = (value) => {
+                this.completed = true;
+                resolve(value);
+            };
+            this.reject = (reason) => {
+                this.completed = true;
+                reject(reason);
+            };
+        });
+    }
+    complete(value) {
+        this.resolve(value);
+    }
+    completeError(reason) {
+        this.reject(reason);
+    }
+}
+exports.Completer = Completer;

package/dist/node/data-types.d.ts

@@ -0,0 +1,44 @@
+export declare const _dataTypes: Record<string, typeof DataType>;
+export declare abstract class DataType {
+    constructor(_?: any);
+    abstract toJson(): Record<string, unknown>;
+    static fromJson(data: any): DataType;
+    static int(): IntDataType;
+    static date(): DateDataType;
+    static float(): FloatDataType;
+    static vector({ size, elementType }: {
+        size: number;
+        elementType: DataType;
+    }): VectorDataType;
+    static text(): TextDataType;
+}
+export declare class IntDataType extends DataType {
+    constructor();
+    static fromJson(data: any): IntDataType;
+    toJson(): Record<string, unknown>;
+}
+export declare class DateDataType extends DataType {
+    constructor();
+    static fromJson(data: any): DateDataType;
+    toJson(): Record<string, unknown>;
+}
+export declare class FloatDataType extends DataType {
+    constructor();
+    static fromJson(data: any): FloatDataType;
+    toJson(): Record<string, unknown>;
+}
+export declare class VectorDataType extends DataType {
+    size: number;
+    elementType: DataType;
+    constructor({ size, elementType }: {
+        size: number;
+        elementType: DataType;
+    });
+    static fromJson(data: any): VectorDataType;
+    toJson(): Record<string, unknown>;
+}
+export declare class TextDataType extends DataType {
+    constructor();
+    static fromJson(data: any): TextDataType;
+    toJson(): Record<string, unknown>;
+}