@meshagent/meshagent 0.3.1 → 0.4.1

package/dist/esm/schema.js

@@ -0,0 +1,312 @@
+export class MeshSchemaValidationException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MeshSchemaValidationException";
+    }
+}
+export var SimpleValue;
+(function (SimpleValue) {
+    SimpleValue["number"] = "number";
+    SimpleValue["string"] = "string";
+    SimpleValue["nullValue"] = "null";
+    SimpleValue["boolean"] = "boolean";
+})(SimpleValue || (SimpleValue = {}));
+(function (SimpleValue) {
+    function fromString(val) {
+        switch (val) {
+            case "number":
+                return SimpleValue.number;
+            case "string":
+                return SimpleValue.string;
+            case "null":
+                return SimpleValue.nullValue;
+            case "boolean":
+                return SimpleValue.boolean;
+            default:
+                return null;
+        }
+    }
+    SimpleValue.fromString = fromString;
+})(SimpleValue || (SimpleValue = {}));
+export class ElementProperty {
+    constructor({ name, description }) {
+        this.name = name;
+        this.description = description;
+    }
+}
+export class ValueProperty extends ElementProperty {
+    constructor({ name, description, type, enumValues }) {
+        super({ name, description });
+        this.type = type;
+        this.enumValues = enumValues;
+    }
+    validate(_) {
+    }
+    toJson() {
+        const obj = {
+            [this.name]: {
+                type: this.type,
+            },
+        };
+        if (this.description) {
+            obj[this.name].description = this.description;
+        }
+        if (this.enumValues) {
+            obj[this.name].enum = this.enumValues;
+        }
+        return obj;
+    }
+}
+export class ChildProperty extends ElementProperty {
+    constructor({ name, description, childTagNames, ordered = false }) {
+        super({ name, description });
+        this._childTagNames = childTagNames;
+        this.ordered = ordered;
+    }
+    validate(schema) {
+        for (const item of this._childTagNames) {
+            schema.element(item);
+        }
+    }
+    isTagAllowed(tagName) {
+        return this._childTagNames.includes(tagName);
+    }
+    get childTagNames() {
+        return this._childTagNames;
+    }
+    toJson() {
+        const base = {};
+        if (this.description) {
+            base["description"] = this.description;
+        }
+        if (this.ordered) {
+            return {
+                [this.name]: {
+                    ...base,
+                    type: "array",
+                    prefixItems: this._childTagNames.map((p) => ({ $ref: `#/$defs/${p}` })),
+                    items: false,
+                },
+            };
+        }
+        else {
+            return {
+                [this.name]: {
+                    ...base,
+                    type: "array",
+                    items: {
+                        anyOf: this._childTagNames.map((p) => ({ $ref: `#/$defs/${p}` })),
+                    },
+                },
+            };
+        }
+    }
+}
+export class ElementType {
+    constructor(params) {
+        this._propertyLookup = new Map();
+        this._tagName = params.tagName;
+        this._description = params.description;
+        this._properties = [...params.properties];
+        for (const p of this._properties) {
+            if (p instanceof ChildProperty) {
+                if (this._childPropertyName) {
+                    throw new MeshSchemaValidationException("Only one child property is allowed");
+                }
+                this._childPropertyName = p.name;
+            }
+            if (this._propertyLookup.has(p.name)) {
+                throw new MeshSchemaValidationException(`Duplicate property ${p.name}`);
+            }
+            this._propertyLookup.set(p.name, p);
+        }
+    }
+    static fromJson(json) {
+        const description = json["description"];
+        const propertiesMap = json["properties"];
+        if (!propertiesMap || Object.keys(propertiesMap).length === 0) {
+            throw new MeshSchemaValidationException("Invalid schema json: no properties found");
+        }
+        const [tagName, typeJson] = Object.entries(propertiesMap)[0];
+        if (!typeJson || typeof typeJson !== "object") {
+            throw new MeshSchemaValidationException("typeJson must be an object");
+        }
+        const innerProps = typeJson["properties"];
+        const resultProps = [];
+        for (const [propName, pVal] of Object.entries(innerProps)) {
+            const pMap = pVal;
+            const propDescription = pMap["description"];
+            const pType = pMap["type"];
+            if (pType === "array") {
+                if (pMap["prefixItems"]) {
+                    const prefixItems = pMap["prefixItems"];
+                    const childTagNames = [];
+                    for (const refObj of prefixItems) {
+                        const refStr = refObj["$ref"];
+                        const prefix = "#/$defs/";
+                        const childTagName = refStr.startsWith(prefix)
+                            ? refStr.substring(prefix.length)
+                            : refStr;
+                        childTagNames.push(childTagName);
+                    }
+                    resultProps.push(new ChildProperty({
+                        name: propName,
+                        description: propDescription,
+                        childTagNames,
+                        ordered: true,
+                    }));
+                }
+                else if (pMap["items"] &&
+                    typeof pMap["items"] === "object" &&
+                    pMap["items"]["anyOf"]) {
+                    const anyOf = pMap["items"]["anyOf"];
+                    const childTagNames = [];
+                    for (const refObj of anyOf) {
+                        const refStr = refObj["$ref"];
+                        const prefix = "#/$defs/";
+                        const childTagName = refStr.startsWith(prefix)
+                            ? refStr.substring(prefix.length)
+                            : refStr;
+                        childTagNames.push(childTagName);
+                    }
+                    resultProps.push(new ChildProperty({
+                        name: propName,
+                        description: propDescription,
+                        childTagNames,
+                        ordered: false,
+                    }));
+                }
+                else {
+                    throw new MeshSchemaValidationException("Invalid array type encountered");
+                }
+            }
+            else {
+                const valTypeStr = pType;
+                const valType = SimpleValue.fromString(valTypeStr);
+                if (!valType) {
+                    throw new MeshSchemaValidationException(`Invalid value type: ${valTypeStr}`);
+                }
+                const enumVal = pMap["enum"];
+                resultProps.push(new ValueProperty({
+                    name: propName,
+                    description: propDescription,
+                    type: valType,
+                    enumValues: enumVal,
+                }));
+            }
+        }
+        return new ElementType({ tagName, description, properties: resultProps });
+    }
+    toJson() {
+        const props = {};
+        const required = [];
+        for (const p of this._properties) {
+            required.push(p.name);
+            const pJson = p.toJson();
+            const propValue = pJson[p.name];
+            props[p.name] = propValue;
+        }
+        return {
+            type: "object",
+            additionalProperties: false,
+            description: this._description,
+            required: [this._tagName],
+            properties: {
+                [this._tagName]: {
+                    type: "object",
+                    additionalProperties: false,
+                    required,
+                    properties: props,
+                },
+            },
+        };
+    }
+    validate(schema) {
+        for (const p of this._properties) {
+            p.validate(schema);
+        }
+    }
+    get childPropertyName() {
+        return this._childPropertyName;
+    }
+    get tagName() {
+        return this._tagName;
+    }
+    get description() {
+        return this._description;
+    }
+    get properties() {
+        return this._properties;
+    }
+    property(name) {
+        const found = this._propertyLookup.get(name);
+        if (!found) {
+            throw new Error(`Property is not in schema: ${name}`);
+        }
+        return found;
+    }
+}
+export class MeshSchema {
+    constructor(params) {
+        this.elementsByTagName = {};
+        const { rootTagName, elements } = params;
+        this._rootTagName = rootTagName;
+        this._elements = elements;
+        for (const t of elements) {
+            if (this.elementsByTagName[t.tagName]) {
+                throw new MeshSchemaValidationException(`${t.tagName} was found more than once`);
+            }
+            this.elementsByTagName[t.tagName] = t;
+        }
+        if (!this.elementsByTagName[rootTagName]) {
+            throw new MeshSchemaValidationException(`${rootTagName} was not found in tags`);
+        }
+        this.validate();
+    }
+    static fromJson(json) {
+        const elements = [];
+        const rootTagRef = json["$root_tag_ref"];
+        const prefix = "#/$defs/";
+        const rootTagName = rootTagRef.startsWith(prefix)
+            ? rootTagRef.substring(prefix.length)
+            : rootTagRef;
+        const defs = json["$defs"];
+        for (const elementJson of Object.values(defs)) {
+            elements.push(ElementType.fromJson(elementJson));
+        }
+        return new MeshSchema({ rootTagName, elements });
+    }
+    toJson() {
+        const defs = {};
+        for (const t of this._elements) {
+            defs[t.tagName] = t.toJson();
+        }
+        const rootElementJson = this.root.toJson();
+        const result = {
+            "$root_tag_ref": `#/$defs/${this._rootTagName}`,
+            "$defs": defs,
+        };
+        for (const [k, v] of Object.entries(rootElementJson)) {
+            result[k] = v;
+        }
+        return result;
+    }
+    element(name) {
+        const el = this.elementsByTagName[name];
+        if (!el) {
+            throw new MeshSchemaValidationException(`Element not found: ${name}`);
+        }
+        return el;
+    }
+    validate() {
+        for (const e of this._elements) {
+            e.validate(this);
+        }
+    }
+    get root() {
+        return this.elementsByTagName[this._rootTagName];
+    }
+    get elements() {
+        return this._elements;
+    }
+}

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

@@ -0,0 +1,38 @@
+import { RoomClient } from "./room-client";
+import { RoomEvent } from "./room-event";
+import { FileResponse } from "./response";
+import { EventEmitter } from "./event-emitter";
+export declare class FileHandle {
+    id: number;
+    constructor({ id }: {
+        id: number;
+    });
+}
+declare class StorageEntry {
+    name: string;
+    isFolder: boolean;
+    constructor({ name, isFolder }: {
+        name: string;
+        isFolder: boolean;
+    });
+    nameWithoutExtension(): string;
+}
+export declare class StorageClient extends EventEmitter<RoomEvent> {
+    private client;
+    constructor({ room }: {
+        room: RoomClient;
+    });
+    private _handleFileUpdated;
+    private _handleFileDeleted;
+    list(path: string): Promise<StorageEntry[]>;
+    delete(path: string): Promise<void>;
+    open(path: string, { overwrite }: {
+        overwrite: boolean;
+    }): Promise<FileHandle>;
+    exists(path: string): Promise<boolean>;
+    write(handle: FileHandle, bytes: Uint8Array): Promise<void>;
+    close(handle: FileHandle): Promise<void>;
+    download(path: string): Promise<FileResponse>;
+    downloadUrl(path: string): Promise<string>;
+}
+export {};

package/dist/esm/storage-client.js

@@ -0,0 +1,79 @@
+import { FileDeletedEvent, FileUpdatedEvent } from "./room-event";
+import { unpackMessage } from "./utils";
+import { EventEmitter } from "./event-emitter";
+export class FileHandle {
+    constructor({ id }) {
+        this.id = id;
+    }
+}
+class StorageEntry {
+    constructor({ name, isFolder }) {
+        this.name = name;
+        this.isFolder = isFolder;
+    }
+    nameWithoutExtension() {
+        const segments = this.name
+            .replace(/^\/+/, '')
+            .replace(/\/+$/, '')
+            .split(/\/+/);
+        return (segments[segments.length - 1] || "")
+            .replace(/\.[^/.]+$/, "");
+    }
+}
+export class StorageClient extends EventEmitter {
+    constructor({ room }) {
+        super();
+        this.client = room;
+        this.client.protocol.addHandler("storage.file.deleted", this._handleFileDeleted.bind(this));
+        this.client.protocol.addHandler("storage.file.updated", this._handleFileUpdated.bind(this));
+    }
+    async _handleFileUpdated(protocol, messageId, type, bytes) {
+        const [data, _] = unpackMessage(bytes || new Uint8Array());
+        const event = new FileUpdatedEvent({ path: data["path"] });
+        this.client.emit(event);
+        this.emit('file.updated', event);
+    }
+    async _handleFileDeleted(protocol, messageId, type, bytes) {
+        const [data, _] = unpackMessage(bytes || new Uint8Array());
+        const event = new FileDeletedEvent({ path: data["path"] });
+        this.client.emit(event);
+        this.emit('file.deleted', event);
+    }
+    async list(path) {
+        const response = (await this.client.sendRequest("storage.list", { path }));
+        const files = response.json["files"];
+        const entries = files.map((f) => {
+            return new StorageEntry({
+                name: f["name"],
+                isFolder: f["is_folder"],
+            });
+        });
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        return entries;
+    }
+    async delete(path) {
+        await this.client.sendRequest("storage.delete", { path });
+    }
+    async open(path, { overwrite = false }) {
+        const response = (await this.client.sendRequest("storage.open", { path, overwrite }));
+        return new FileHandle({ id: response.json["handle"] });
+    }
+    async exists(path) {
+        const result = (await this.client.sendRequest("storage.exists", { path }));
+        return result.json["exists"];
+    }
+    async write(handle, bytes) {
+        await this.client.sendRequest("storage.write", { handle: handle.id }, bytes);
+    }
+    async close(handle) {
+        await this.client.sendRequest("storage.close", { handle: handle.id });
+    }
+    async download(path) {
+        const response = (await this.client.sendRequest("storage.download", { path }));
+        return response;
+    }
+    async downloadUrl(path) {
+        const response = (await this.client.sendRequest("storage.download_url", { path }));
+        return response.json["url"];
+    }
+}

package/dist/esm/stream-controller.d.ts

@@ -0,0 +1,8 @@
+export declare class StreamController<T> {
+    private closed;
+    get stream(): AsyncIterable<T>;
+    private queue;
+    private waiters;
+    add(value: T): void;
+    close(): void;
+}

package/dist/esm/stream-controller.js

@@ -0,0 +1,51 @@
+export class StreamController {
+    constructor() {
+        this.closed = false;
+        this.queue = [];
+        this.waiters = [];
+    }
+    get stream() {
+        const self = this;
+        return {
+            [Symbol.asyncIterator]() {
+                return {
+                    async next() {
+                        if (self.queue.length > 0) {
+                            return {
+                                done: false,
+                                value: self.queue.shift()
+                            };
+                        }
+                        if (self.closed) {
+                            return {
+                                done: true,
+                                value: undefined
+                            };
+                        }
+                        return new Promise((resolve) => {
+                            self.waiters.push(resolve);
+                        });
+                    },
+                };
+            },
+        };
+    }
+    add(value) {
+        if (this.closed)
+            return;
+        if (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            waiter({ done: false, value });
+        }
+        else {
+            this.queue.push(value);
+        }
+    }
+    close() {
+        this.closed = true;
+        while (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            waiter({ done: true, value: undefined });
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+import { EventEmitter } from "./event-emitter";
+import { RoomClient } from "./room-client";
+import { MeshDocument } from "./room-server-client";
+export interface SyncClientEvent {
+    type: string;
+    doc: MeshDocument;
+}
+export declare class QueuedSync {
+    path: string;
+    base64: string;
+    constructor({ path, base64 }: {
+        path: string;
+        base64: string;
+    });
+}
+export declare class SyncClient extends EventEmitter<SyncClientEvent> {
+    private client;
+    private _connectingDocuments;
+    private _changesToSync;
+    private _connectedDocuments;
+    constructor({ room }: {
+        room: RoomClient;
+    });
+    start({ onDone, onError }?: {
+        onDone?: () => void;
+        onError?: (error: Error) => void;
+    }): void;
+    dispose(): void;
+    private _handleSync;
+    private _handleStatus;
+    create(path: string, json?: Record<string, any>): Promise<void>;
+    open(path: string, { create }?: {
+        create?: boolean;
+    }): Promise<MeshDocument>;
+    close(path: string): Promise<void>;
+    sync(path: string, data: Uint8Array): Promise<void>;
+}

package/dist/esm/sync-client.js

@@ -0,0 +1,125 @@
+import { EventEmitter } from "./event-emitter";
+import { MeshSchema } from "./schema";
+import { StreamController } from "./stream-controller";
+import { MeshDocument, RoomServerException } from "./room-server-client";
+import { splitMessageHeader, splitMessagePayload, decoder, encoder, RefCount } from "./utils";
+import { unregisterDocument, applyBackendChanges } from "./runtime";
+import { Completer } from "./completer";
+;
+export class QueuedSync {
+    constructor({ path, base64 }) {
+        this.path = path;
+        this.base64 = base64;
+    }
+}
+export class SyncClient extends EventEmitter {
+    constructor({ room }) {
+        super();
+        this._connectingDocuments = {};
+        this._changesToSync = new StreamController();
+        this._connectedDocuments = {};
+        this.client = room;
+        this.client.protocol.addHandler("room.sync", this._handleSync.bind(this));
+        this.client.protocol.addHandler("room.status", this._handleStatus.bind(this));
+    }
+    start({ onDone, onError } = {}) {
+        this.client.protocol.start({ onDone, onError });
+        (async () => {
+            for await (const message of this._changesToSync.stream) {
+                await this.client.sendRequest("room.sync", { path: message.path }, encoder.encode(message.base64));
+            }
+        })();
+    }
+    dispose() {
+        super.dispose();
+        this._changesToSync.close();
+    }
+    async _handleSync(protocol, messageId, data, bytes) {
+        const headerStr = splitMessageHeader(bytes || new Uint8Array());
+        const payload = splitMessagePayload(bytes || new Uint8Array());
+        const header = JSON.parse(headerStr);
+        const path = header["path"];
+        const isConnecting = this._connectingDocuments[path];
+        if (isConnecting) {
+            await isConnecting;
+        }
+        if (this._connectedDocuments[path]) {
+            const rc = this._connectedDocuments[path];
+            const doc = rc.ref;
+            const base64 = decoder.decode(payload);
+            applyBackendChanges(doc.id, base64);
+            this.emit("synced", { type: "sync", doc });
+            if (!doc.isSynchronized) {
+                doc.setSynchronizedComplete();
+            }
+        }
+        else {
+            throw new RoomServerException(`received change for a document that is not connected: ${path}`);
+        }
+    }
+    async _handleStatus(protocol, messageId, data, bytes) {
+        const headerStr = splitMessageHeader(bytes || new Uint8Array());
+        const header = JSON.parse(headerStr);
+        this.emit("status", header.status);
+    }
+    async create(path, json) {
+        await this.client.sendRequest("room.create", { path, json });
+    }
+    async open(path, { create = true } = {}) {
+        const pending = this._connectingDocuments[path];
+        if (pending) {
+            await pending;
+        }
+        if (this._connectedDocuments[path]) {
+            const rc = this._connectedDocuments[path];
+            rc.count++;
+            return rc.ref;
+        }
+        const c = new Completer();
+        this._connectingDocuments[path] = c.fut;
+        try {
+            const result = (await this.client.sendRequest("room.connect", { path, create }));
+            const schema = MeshSchema.fromJson(result.json["schema"]);
+            const doc = new MeshDocument({
+                schema,
+                sendChangesToBackend: (base64Str) => {
+                    this._changesToSync.add({ path, base64: base64Str });
+                },
+            });
+            const rc = new RefCount(doc);
+            this._connectedDocuments[path] = rc;
+            this.emit("connected", { type: "connect", doc });
+            c.complete();
+            return doc;
+        }
+        catch (err) {
+            c.completeError(err);
+            throw err;
+        }
+        finally {
+            delete this._connectingDocuments[path];
+        }
+    }
+    async close(path) {
+        const pending = this._connectingDocuments[path];
+        if (pending) {
+            await pending;
+            await new Promise(resolve => setTimeout(resolve, 50));
+        }
+        const rc = this._connectedDocuments[path];
+        if (!rc) {
+            throw new RoomServerException(`Not connected to ${path}`);
+        }
+        const doc = rc.ref;
+        rc.count--;
+        if (rc.count === 0) {
+            delete this._connectedDocuments[path];
+            await this.client.sendRequest("room.disconnect", { path });
+            unregisterDocument(doc.id);
+        }
+        this.emit("closed", { type: "close", doc });
+    }
+    async sync(path, data) {
+        await this.client.sendRequest("room.sync", { path }, data);
+    }
+}

package/dist/esm/utils.d.ts

@@ -0,0 +1,14 @@
+import { TextDecoder, TextEncoder } from "@kayahr/text-encoding";
+declare const encoder: TextEncoder;
+declare const decoder: TextDecoder;
+export { encoder, decoder };
+export declare function splitMessagePayload(packet: Uint8Array): Uint8Array;
+export declare function splitMessageHeader(packet: Uint8Array): string;
+export declare function unpackMessage(packet: Uint8Array): [Record<string, any>, Uint8Array];
+export declare function packMessage(request: Record<string, any>, data?: Uint8Array): Uint8Array;
+export declare function mergeUint8Arrays(...arrays: Uint8Array[]): Uint8Array;
+export declare class RefCount<T> {
+    ref: T;
+    count: number;
+    constructor(ref: T);
+}