@meshagent/meshagent 0.3.1 → 0.4.0

package/dist/esm/document.js

@@ -0,0 +1,522 @@
+import { v4 as uuid } from "uuid";
+import { EventEmitter } from "./event-emitter";
+export class RuntimeDocument extends EventEmitter {
+    constructor({ id, schema, sendChanges, sendChangesToBackend }) {
+        super();
+        this._changeSubscribers = [];
+        this.id = id;
+        this.schema = schema;
+        this.sendChanges = sendChanges;
+        this.sendChangesToBackend = sendChangesToBackend;
+    }
+    listen(onData) {
+        this._changeSubscribers.push(onData);
+        return {
+            unsubscribe: () => {
+                const idx = this._changeSubscribers.indexOf(onData);
+                if (idx >= 0) {
+                    this._changeSubscribers.splice(idx, 1);
+                }
+            },
+        };
+    }
+    get root() {
+        if (!this._root) {
+            this._root = new Element({
+                parent: null,
+                tagName: this.schema.root.tagName,
+                attributes: {},
+                doc: this,
+                elementType: this.schema.root,
+            });
+        }
+        return this._root;
+    }
+    _createNode(parent, data) {
+        if (data["element"] != null) {
+            const elementData = data["element"];
+            const tagName = elementData["tagName"];
+            const elementType = this.schema.element(tagName);
+            const element = new Element({
+                parent,
+                tagName,
+                attributes: elementData["attributes"] || {},
+                doc: this,
+                elementType,
+            });
+            if (elementData["children"] != null) {
+                for (const child of elementData["children"]) {
+                    element.children.push(this._createNode(element, child));
+                }
+            }
+            return element;
+        }
+        else if (data["text"] != null) {
+            const delta = Array.isArray(data["text"]["delta"])
+                ? data["text"]["delta"]
+                : [];
+            return new TextElement({
+                parent: parent,
+                delta,
+                doc: this,
+            });
+        }
+        else {
+            throw new Error("Unsupported node type");
+        }
+    }
+    receiveChanges(message) {
+        for (const sub of this._changeSubscribers) {
+            sub(message);
+        }
+        console.log("Applying changes to doc:", JSON.stringify(message));
+        const nodeID = message["target"];
+        const target = message["root"] === true ? this.root : this.root.getNodeByID(nodeID);
+        if (!target) {
+            throw new Error(`Target node not found: ${nodeID}`);
+        }
+        let retain = 0;
+        const elements = message["elements"] || [];
+        for (const delta of elements) {
+            if (delta["retain"] != null) {
+                retain += delta["retain"];
+            }
+            if (delta["insert"] != null) {
+                for (const insert of delta["insert"]) {
+                    if (insert["element"] != null || insert["text"] != null) {
+                        target.children.splice(retain, 0, this._createNode(target, insert));
+                        retain++;
+                    }
+                    else {
+                        throw new Error("Unsupported element delta");
+                    }
+                }
+            }
+            else if (delta["delete"] != null) {
+                target.children.splice(retain, delta["delete"]);
+                retain -= delta["delete"];
+            }
+        }
+        const text = message["text"];
+        if (text && text.length > 0) {
+            if (target.tagName !== "text") {
+                throw new Error("Node is not a text node: " + target.tagName);
+            }
+            const textNode = target.children[0];
+            let retainInner = 0;
+            let i = 0;
+            let offset = 0;
+            const targetDelta = textNode.delta;
+            for (const delta of text) {
+                if (delta["insert"] != null) {
+                    const insStr = delta["insert"];
+                    if (i === targetDelta.length) {
+                        targetDelta.push({
+                            insert: insStr,
+                            attributes: delta["attributes"] ?? {},
+                        });
+                        i++;
+                        offset += insStr.length;
+                        retainInner += insStr.length;
+                    }
+                    else {
+                        const str = targetDelta[i]["insert"];
+                        const pos = (retainInner - offset) | 0;
+                        targetDelta[i]["insert"] = str.slice(0, pos) + insStr + str.slice(pos);
+                        retainInner += insStr.length;
+                    }
+                }
+                else if (delta["delete"] != null) {
+                    let deleted = 0;
+                    while (delta["delete"] > deleted) {
+                        const remaining = delta["delete"] - deleted;
+                        const str = targetDelta[i]?.["insert"];
+                        if (typeof str !== "string") {
+                            break;
+                        }
+                        if (retainInner > offset) {
+                            const startPos = (retainInner - offset) | 0;
+                            const start = str.slice(0, startPos);
+                            const end = str.slice(startPos);
+                            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 >= str.length) {
+                            deleted += str.length;
+                            targetDelta.splice(i, 1);
+                        }
+                        else {
+                            const start = str.slice(0, remaining);
+                            const end = str.slice(remaining);
+                            targetDelta[i]["insert"] = end;
+                            deleted += start.length;
+                        }
+                    }
+                }
+                else if (delta["attributes"] != null) {
+                    let formatted = 0;
+                    const retainVal = delta["retain"] ?? 0;
+                    while (retainVal > formatted) {
+                        const remaining = (retainVal - formatted) | 0;
+                        if (!targetDelta[i]["attributes"]) {
+                            targetDelta[i]["attributes"] = {};
+                        }
+                        const str = targetDelta[i]["insert"];
+                        const startPos = (retainInner - offset) | 0;
+                        const start = str.slice(0, startPos);
+                        const end = str.slice(startPos);
+                        if (retainInner > 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;
+                                const middle = end.slice(0, remaining);
+                                const tail = end.slice(remaining);
+                                targetDelta.splice(i + 1, 0, {
+                                    insert: middle,
+                                    attributes: {
+                                        ...targetDelta[i]["attributes"],
+                                        ...delta["attributes"],
+                                    },
+                                });
+                                targetDelta.splice(i + 2, 0, {
+                                    insert: tail,
+                                    attributes: { ...targetDelta[i]["attributes"] },
+                                });
+                                formatted += remaining;
+                                i += 3;
+                                offset += start.length + remaining;
+                            }
+                        }
+                        else if (remaining >= str.length) {
+                            formatted += str.length;
+                            Object.assign(targetDelta[i]["attributes"], delta["attributes"]);
+                            offset += str.length;
+                            i++;
+                        }
+                        else {
+                            const startChunk = str.slice(0, remaining);
+                            const endChunk = str.slice(remaining);
+                            targetDelta[i]["insert"] = startChunk;
+                            targetDelta.push({
+                                insert: endChunk,
+                                attributes: { ...targetDelta[i]["attributes"] },
+                            });
+                            Object.assign(targetDelta[i]["attributes"], delta["attributes"]);
+                            formatted += remaining;
+                        }
+                    }
+                    retainInner += retainVal;
+                }
+                else if (delta["retain"] != null) {
+                    retainInner += delta["retain"];
+                    while (i < targetDelta.length &&
+                        retainInner > offset + (targetDelta[i]["insert"]?.length ?? 0)) {
+                        offset += targetDelta[i]["insert"].length;
+                        i++;
+                    }
+                }
+            }
+        }
+        const attr = message["attributes"];
+        if (attr) {
+            const setList = attr["set"] || [];
+            for (const change of setList) {
+                target.attributes[change["name"]] = change["value"];
+                target.emit("updated", { type: "change", node: target });
+            }
+            const delList = attr["delete"] || [];
+            for (const name of delList) {
+                delete target.attributes[name];
+                target.emit("updated", { type: "change", node: target });
+            }
+        }
+        this.emit("updated", { type: "change", doc: this });
+    }
+}
+export class Node extends EventEmitter {
+    constructor({ parent, doc }) {
+        super();
+        this.parent = parent;
+        this.doc = doc;
+    }
+}
+export class Element extends Node {
+    constructor({ parent, tagName, attributes, doc, elementType }) {
+        super({ parent, doc });
+        this.children = [];
+        this.tagName = tagName;
+        this.attributes = attributes;
+        this.elementType = elementType;
+    }
+    getNodeByID(id) {
+        if (id === this.id) {
+            return this;
+        }
+        for (const child of this.getChildren()) {
+            if (child instanceof Element) {
+                const found = child.getNodeByID(id);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    }
+    get id() {
+        return this.getAttribute("$id");
+    }
+    getAttribute(name) {
+        return this.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],
+                },
+            ],
+        });
+    }
+    _ensureChildValid(tagName) {
+        const childName = this.elementType.childPropertyName;
+        if (!childName) {
+            throw new Error(`Children are not allowed on this element: ${this.tagName}`);
+        }
+        const childProp = this.elementType.property(childName);
+        if (!childProp.isTagAllowed(tagName)) {
+            throw new Error(`Cannot add ${tagName} to ${this.tagName}`);
+        }
+        return this.doc.schema.element(tagName);
+    }
+    _validateElementAttributes(elType, attributes) {
+        for (const k of Object.keys(attributes)) {
+            elType.property(k);
+        }
+    }
+    createChildElement(tagName, attributes, opts) {
+        const childElementType = this._ensureChildValid(tagName);
+        this._validateElementAttributes(childElementType, attributes);
+        const newId = opts?.id ?? uuid();
+        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, opts) {
+        const childElementType = this._ensureChildValid(tagName);
+        this._validateElementAttributes(childElementType, attributes);
+        const newId = opts?.id ?? uuid();
+        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,
+                        children: [{ element: elementData }],
+                    },
+                },
+            ],
+        });
+        return this.getNodeByID(newId);
+    }
+    createChildElementAfter(element, tagName, attributes, opts) {
+        const childElementType = this._ensureChildValid(tagName);
+        this._validateElementAttributes(childElementType, attributes);
+        if (element.parent?.id !== this.id) {
+            throw new Error("Element does not belong to this node");
+        }
+        const newId = opts?.id ?? uuid();
+        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.children;
+    }
+    appendJson(json) {
+        const name = tagNameFromJson(json);
+        const attrs = attributesFromJson(json);
+        const elType = this.doc.schema.element(name);
+        if (elType.childPropertyName && attrs.hasOwnProperty(elType.childPropertyName)) {
+            const childArr = attrs[elType.childPropertyName];
+            delete attrs[elType.childPropertyName];
+            const elem = this.createChildElement(name, attrs);
+            if (Array.isArray(childArr)) {
+                for (const c of childArr) {
+                    elem.appendJson(c);
+                }
+            }
+            return elem;
+        }
+        else {
+            return this.createChildElement(name, attrs);
+        }
+    }
+}
+export class TextElement extends Node {
+    constructor({ parent, delta, doc }) {
+        super({ parent, doc });
+        this.delta = delta;
+    }
+    insert(index, text, attributes) {
+        this.doc.sendChanges({
+            documentID: this.doc.id,
+            changes: [
+                {
+                    nodeID: this.parent?.id,
+                    insertText: {
+                        index,
+                        text,
+                        attributes: attributes ?? {},
+                    },
+                },
+            ],
+        });
+    }
+    format(from, length, attributes) {
+        this.doc.sendChanges({
+            documentID: this.doc.id,
+            changes: [
+                {
+                    nodeID: this.parent?.id,
+                    formatText: {
+                        from,
+                        length,
+                        attributes,
+                    },
+                },
+            ],
+        });
+    }
+    delete(index, length) {
+        this.doc.sendChanges({
+            documentID: this.doc.id,
+            changes: [
+                {
+                    nodeID: this.parent?.id,
+                    deleteText: {
+                        index,
+                        length,
+                    },
+                },
+            ],
+        });
+    }
+}
+export function tagNameFromJson(json) {
+    const keys = Object.keys(json);
+    if (keys.length !== 1) {
+        throw new Error("JSON element must have a single key");
+    }
+    return keys[0];
+}
+export function attributesFromJson(json) {
+    const keys = Object.keys(json);
+    if (keys.length !== 1) {
+        throw new Error("JSON element must have a single key");
+    }
+    const val = json[keys[0]];
+    if (typeof val === "object" && val !== null && !Array.isArray(val)) {
+        return { ...val };
+    }
+    else {
+        throw new Error("JSON element value must be an object");
+    }
+}