@meshagent/meshagent 0.3.1 → 0.4.0

package/dist/esm/client.js

@@ -0,0 +1,443 @@
+import { v4 as uuid } from "uuid";
+export 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 = 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) {
+        const newId = 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: 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 = 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._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,
+                    },
+                },
+            ],
+        });
+    }
+    get id() {
+        return this.parent?.id;
+    }
+}
+export 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];
+        }
+    }
+}

package/dist/esm/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/esm/completer.js

@@ -0,0 +1,21 @@
+export 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);
+    }
+}

package/dist/esm/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>;
+}

package/dist/esm/data-types.js

@@ -0,0 +1,110 @@
+export const _dataTypes = {};
+export class DataType {
+    constructor(_) { }
+    static fromJson(data) {
+        const ctor = _dataTypes[data.type];
+        if (!ctor) {
+            throw new Error(`Unknown data type: ${data.type}`);
+        }
+        return ctor.fromJson(data);
+    }
+    static int() {
+        return new IntDataType();
+    }
+    static date() {
+        return new DateDataType();
+    }
+    static float() {
+        return new FloatDataType();
+    }
+    static vector({ size, elementType }) {
+        return new VectorDataType({ size, elementType });
+    }
+    static text() {
+        return new TextDataType();
+    }
+}
+export class IntDataType extends DataType {
+    constructor() {
+        super();
+    }
+    static fromJson(data) {
+        if (data.type !== "int") {
+            throw new Error(`Expected type 'int', got '${data.type}'`);
+        }
+        return new IntDataType();
+    }
+    toJson() {
+        return { type: "int" };
+    }
+}
+_dataTypes["int"] = IntDataType;
+export class DateDataType extends DataType {
+    constructor() {
+        super();
+    }
+    static fromJson(data) {
+        if (data.type !== "date") {
+            throw new Error(`Expected type 'date', got '${data.type}'`);
+        }
+        return new DateDataType();
+    }
+    toJson() {
+        return { type: "date" };
+    }
+}
+_dataTypes["date"] = DateDataType;
+export class FloatDataType extends DataType {
+    constructor() {
+        super();
+    }
+    static fromJson(data) {
+        if (data.type !== "float") {
+            throw new Error(`Expected type 'float', got '${data.type}'`);
+        }
+        return new FloatDataType();
+    }
+    toJson() {
+        return { type: "float" };
+    }
+}
+_dataTypes["float"] = FloatDataType;
+export class VectorDataType extends DataType {
+    constructor({ size, elementType }) {
+        super();
+        this.size = size;
+        this.elementType = elementType;
+    }
+    static fromJson(data) {
+        if (data.type !== "vector") {
+            throw new Error(`Expected type 'vector', got '${data.type}'`);
+        }
+        return new VectorDataType({
+            size: data.size,
+            elementType: DataType.fromJson(data.element_type),
+        });
+    }
+    toJson() {
+        return {
+            type: "vector",
+            size: this.size,
+            element_type: this.elementType.toJson(),
+        };
+    }
+}
+_dataTypes["vector"] = VectorDataType;
+export class TextDataType extends DataType {
+    constructor() {
+        super();
+    }
+    static fromJson(data) {
+        if (data.type !== "text") {
+            throw new Error(`Expected type 'text', got '${data.type}'`);
+        }
+        return new TextDataType();
+    }
+    toJson() {
+        return { type: "text" };
+    }
+}
+_dataTypes["text"] = TextDataType;

package/dist/esm/database-client.d.ts

@@ -0,0 +1,77 @@
+import { RoomClient } from "./room-client";
+import { DataType } from "./data-types";
+export type CreateMode = "create" | "overwrite" | "create_if_not_exists";
+export declare class DatabaseClient {
+    private room;
+    constructor({ room }: {
+        room: RoomClient;
+    });
+    listTables(): Promise<string[]>;
+    private createTable;
+    createTableWithSchema({ name, schema, data, mode }: {
+        name: string;
+        schema?: Record<string, DataType>;
+        data?: Array<Record<string, any>>;
+        mode?: CreateMode;
+    }): Promise<void>;
+    createTableFromData({ name, data, mode }: {
+        name: string;
+        data?: Array<Record<string, any>>;
+        mode?: CreateMode;
+    }): Promise<void>;
+    dropTable({ name, ignoreMissing }: {
+        name: string;
+        ignoreMissing?: boolean;
+    }): Promise<void>;
+    addColumns({ table, newColumns }: {
+        table: string;
+        newColumns: Record<string, string>;
+    }): Promise<void>;
+    dropColumns({ table, columns }: {
+        table: string;
+        columns: string[];
+    }): Promise<void>;
+    insert({ table, records }: {
+        table: string;
+        records: Array<Record<string, any>>;
+    }): Promise<void>;
+    update({ table, where, values, valuesSql }: {
+        table: string;
+        where: string;
+        values?: Record<string, any>;
+        valuesSql?: Record<string, string>;
+    }): Promise<void>;
+    delete({ table, where }: {
+        table: string;
+        where: string;
+    }): Promise<void>;
+    merge({ table, on, records }: {
+        table: string;
+        on: string;
+        records: any;
+    }): Promise<void>;
+    search({ table, text, vector, where, limit, select }: {
+        table: string;
+        text?: string;
+        vector?: number[];
+        where?: string | Record<string, any>;
+        limit?: number;
+        select?: string[];
+    }): Promise<Array<Record<string, any>>>;
+    optimize(table: string): Promise<void>;
+    createVectorIndex({ table, column }: {
+        table: string;
+        column: string;
+    }): Promise<void>;
+    createScalarIndex({ table, column }: {
+        table: string;
+        column: string;
+    }): Promise<void>;
+    createFullTextSearchIndex({ table, column }: {
+        table: string;
+        column: string;
+    }): Promise<void>;
+    listIndexes({ table }: {
+        table: string;
+    }): Promise<Record<string, any>>;
+}