@meshagent/meshagent 0.3.1 → 0.4.1

package/dist/esm/utils.js

@@ -0,0 +1,44 @@
+import { TextDecoder, TextEncoder } from "@kayahr/text-encoding";
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+export { encoder, decoder };
+export 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);
+}
+export 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);
+}
+export function unpackMessage(packet) {
+    return [JSON.parse(splitMessageHeader(packet)), splitMessagePayload(packet)];
+}
+export 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));
+}
+export 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;
+}
+export class RefCount {
+    constructor(ref) {
+        this.ref = ref;
+        this.count = 1;
+    }
+}

package/dist/node/entrypoint.js

@@ -26,7 +26,7 @@ var __copyProps = (to, from2, except, desc) => {
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
 var require_base64 = __commonJS({
-    "node_modules/base-64/base64.js"(exports, module) {
+    "../node_modules/base-64/base64.js"(exports, module) {
         (function (root) {
             var freeExports = typeof exports == "object" && exports;
             var freeModule = typeof module == "object" && module && module.exports == freeExports && module;
@@ -1065,9 +1065,12 @@ var DeleteSet = class {
 };
 var iterateDeletedStructs = (transaction, ds, f) => ds.clients.forEach((deletes, clientid) => {
     const structs = (transaction.doc.store.clients.get(clientid));
-    for (let i = 0; i < deletes.length; i++) {
-        const del = deletes[i];
-        iterateStructs(transaction, structs, del.clock, del.len, f);
+    if (structs != null) {
+        const lastStruct = structs[structs.length - 1];
+        const clockState = lastStruct.id.clock + lastStruct.length;
+        for (let i = 0, del = deletes[i]; i < deletes.length && del.clock < clockState; del = deletes[++i]) {
+            iterateStructs(transaction, structs, del.clock, del.len, f);
+        }
     }
 });
 var findIndexDS = (dis, clock) => {
@@ -3392,6 +3395,8 @@ var typeMapSet = (transaction, parent, key, value) => {
             case Boolean:
             case Array:
             case String:
+            case Date:
+            case BigInt:
                 content = new ContentAny([value]);
                 break;
             case Uint8Array:

package/dist/node/helpers.d.ts

@@ -10,17 +10,23 @@ export declare function deploySchema({ room, schema, name, overwrite }: {
     overwrite?: boolean;
 }): Promise<void>;
 export declare function meshagentBaseUrl(baseUrl?: string): string;
-export declare function websocketRoomUrl({ roomName, baseUrl }: {
+export declare function websocketRoomUrl({ roomName, apiUrl }: {
     roomName: string;
-    baseUrl?: string;
+    apiUrl?: string;
 }): string;
-export declare function participantToken({ participantName, roomName, role }: {
+export declare function participantToken({ participantName, roomName, role, projectId, apiKeyId, }: {
     participantName: string;
     roomName: string;
     role?: string;
+    projectId: string;
+    apiKeyId: string;
 }): ParticipantToken;
-export declare function websocketProtocol({ participantName, roomName, role }: {
+export declare function websocketProtocol({ participantName, roomName, role, projectId, apiKeyId, secret, apiUrl }: {
     participantName: string;
     roomName: string;
     role?: string;
+    projectId: string;
+    apiKeyId: string;
+    secret: string;
+    apiUrl?: string;
 }): Promise<WebSocketClientProtocol>;

package/dist/node/helpers.js

@@ -25,41 +25,20 @@ function meshagentBaseUrl(baseUrl) {
     if (baseUrl) {
         return baseUrl;
     }
-    return process.env.MESHAGENT_API_URL || 'https://api.meshagent.com';
+    return 'https://api.meshagent.com';
 }
-function websocketRoomUrl({ roomName, baseUrl }) {
-    if (!baseUrl) {
-        const envApiUrl = process.env.MESHAGENT_API_URL;
-        if (!envApiUrl) {
-            baseUrl = 'wss://api.meshagent.com';
-        }
-        else {
-            if (envApiUrl.startsWith('https:')) {
-                baseUrl = 'wss:' + envApiUrl.substring('https:'.length);
-            }
-            else if (envApiUrl.startsWith('http:')) {
-                baseUrl = 'ws:' + envApiUrl.substring('http:'.length);
-            }
-            else {
-                baseUrl = envApiUrl;
-            }
-        }
+function websocketRoomUrl({ roomName, apiUrl }) {
+    const baseUrl = apiUrl || 'wss://api.meshagent.com';
+    let url = baseUrl;
+    if (baseUrl.startsWith('https:')) {
+        url = 'wss:' + baseUrl.substring('https:'.length);
     }
-    return `${baseUrl}/rooms/${roomName}`;
-}
-function participantToken({ participantName, roomName, role }) {
-    const projectId = process.env.MESHAGENT_PROJECT_ID;
-    const apiKeyId = process.env.MESHAGENT_KEY_ID;
-    const secret = process.env.MESHAGENT_SECRET;
-    if (!projectId) {
-        throw new Error('MESHAGENT_PROJECT_ID must be set. You can find this in the Meshagent Studio under API keys.');
-    }
-    if (!apiKeyId) {
-        throw new Error('MESHAGENT_KEY_ID must be set. You can find this in the Meshagent Studio under API keys.');
-    }
-    if (!secret) {
-        throw new Error('MESHAGENT_SECRET must be set. You can find this in the Meshagent Studio under API keys.');
+    else if (baseUrl.startsWith('http:')) {
+        url = 'ws:' + baseUrl.substring('http:'.length);
     }
+    return `${url}/rooms/${roomName}`;
+}
+function participantToken({ participantName, roomName, role, projectId, apiKeyId, }) {
     const token = new participant_token_1.ParticipantToken({ name: participantName, projectId, apiKeyId });
     token.addRoomGrant(roomName);
     if (role) {
@@ -67,13 +46,9 @@ function participantToken({ participantName, roomName, role }) {
     }
     return token;
 }
-async function websocketProtocol({ participantName, roomName, role }) {
-    const url = websocketRoomUrl({ roomName });
-    const token = participantToken({ participantName, roomName, role });
-    const secret = process.env.MESHAGENT_SECRET;
-    if (!secret) {
-        throw new Error('MESHAGENT_SECRET must be set in the environment.');
-    }
+async function websocketProtocol({ participantName, roomName, role, projectId, apiKeyId, secret, apiUrl }) {
+    const url = websocketRoomUrl({ roomName, apiUrl });
+    const token = participantToken({ participantName, roomName, role, projectId, apiKeyId });
     const jwt = await token.toJwt({ token: secret });
     return new protocol_1.WebSocketClientProtocol({ url, token: jwt });
 }

package/dist/node/index.d.ts

@@ -22,3 +22,4 @@ export * from './storage-client';
 export * from './stream-controller';
 export * from './sync-client';
 export * from './helpers';
+export * from './utils';

package/dist/node/index.js

@@ -38,3 +38,4 @@ __exportStar(require("./storage-client"), exports);
 __exportStar(require("./stream-controller"), exports);
 __exportStar(require("./sync-client"), exports);
 __exportStar(require("./helpers"), exports);
+__exportStar(require("./utils"), exports);

package/dist/node/participant-token.d.ts

@@ -25,12 +25,12 @@ export declare class ParticipantToken {
     addRoleGrant(role: string): void;
     addRoomGrant(roomName: string): void;
     toJson(): Record<string, any>;
-    toJwt({ token }?: {
-        token?: string;
+    toJwt({ token }: {
+        token: string;
     }): Promise<string>;
     static fromJson(json: Record<string, any>): ParticipantToken;
-    static fromJwt(jwtStr: string, options?: {
-        token?: string;
+    static fromJwt(jwtStr: string, options: {
+        token: string;
         verify?: boolean;
     }): Promise<ParticipantToken>;
 }

package/dist/node/participant-token.js

@@ -51,9 +51,8 @@ class ParticipantToken {
             grants: this.grants.map((g) => g.toJson()),
         };
     }
-    async toJwt({ token } = {}) {
-        const secret = token || process.env.MESHAGENT_SECRET;
-        const secretKey = new TextEncoder().encode(secret);
+    async toJwt({ token }) {
+        const secretKey = new TextEncoder().encode(token);
         const payload = {
             ...this.toJson(),
             ...this.extra,
@@ -75,13 +74,9 @@ class ParticipantToken {
         });
     }
     static async fromJwt(jwtStr, options) {
-        const { token, verify = true } = options || {};
+        const { token, verify = true } = options;
         if (verify) {
-            const secret = token || process.env.MESHAGENT_SECRET;
-            if (!secret) {
-                throw new Error("No secret provided to verify JWT. Provide `token` or set MESHAGENT_SECRET");
-            }
-            const secretKey = new TextEncoder().encode(secret);
+            const secretKey = new TextEncoder().encode(token);
             const { payload } = await (0, jose_1.jwtVerify)(jwtStr, secretKey, {
                 algorithms: ["HS256"],
             });

package/dist/node/protocol.d.ts

@@ -75,7 +75,11 @@ export declare class Protocol {
     getNextMessageId(): number;
     send(type: string, data: Uint8Array, id?: number): Promise<void>;
     sendJson(object: any): Promise<void>;
-    start(onMessage?: null): void;
+    start({ onMessage, onDone, onError }?: {
+        onMessage?: MessageHandler;
+        onDone?: () => void;
+        onError?: (error: any) => void;
+    }): void;
     dispose(): void;
     onDataReceived(dataPacket: Uint8Array): void;
 }

package/dist/node/protocol.js

@@ -168,6 +168,11 @@ class Protocol {
     }
     async handleMessage(messageId, type, data) {
         const handler = this.handlers[type] ?? this.handlers["*"];
+        if (!handler) {
+            const d = data ? (0, utils_1.unpackMessage)(data) : null;
+            console.warn(`No handler for message type ${type}; data: ${d}`);
+            return;
+        }
         await handler(this, messageId, type, data);
     }
     getNextMessageId() {
@@ -181,11 +186,11 @@ class Protocol {
     async sendJson(object) {
         return await this.send("application/json", utils_1.encoder.encode(JSON.stringify(object)));
     }
-    start(onMessage = null) {
+    start({ onMessage, onDone, onError } = {}) {
         if (onMessage != null) {
             this.addHandler("*", onMessage);
         }
-        this.channel.start(this.onDataReceived.bind(this), {});
+        this.channel.start(this.onDataReceived.bind(this), { onDone, onError });
         this._iterator?.return(null);
         (async () => {
             this._iterator = this._send.stream();

package/dist/node/room-client.d.ts

@@ -30,7 +30,10 @@ export declare class RoomClient {
     });
     get localParticipant(): LocalParticipant | null;
     get ready(): Promise<boolean>;
-    start(): Promise<void>;
+    start({ onDone, onError }?: {
+        onDone?: () => void;
+        onError?: (error: Error) => void;
+    }): Promise<void>;
     dispose(): void;
     sendRequest(type: string, request: RequestHeader, data?: Uint8Array): Promise<Response>;
     private _handleResponse;

package/dist/node/room-client.js

@@ -37,8 +37,8 @@ class RoomClient {
     get ready() {
         return this._ready.fut;
     }
-    async start() {
-        this.sync.start();
+    async start({ onDone, onError } = {}) {
+        this.sync.start({ onDone, onError });
         await this.ready;
     }
     dispose() {

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

@@ -21,9 +21,13 @@ export declare class SyncClient extends EventEmitter<SyncClientEvent> {
     constructor({ room }: {
         room: RoomClient;
     });
-    start(): void;
+    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;

package/dist/node/sync-client.js

@@ -24,9 +24,10 @@ class SyncClient extends event_emitter_1.EventEmitter {
         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() {
-        this.client.protocol.start();
+    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 }, utils_1.encoder.encode(message.base64));
@@ -60,6 +61,11 @@ class SyncClient extends event_emitter_1.EventEmitter {
             throw new room_server_client_1.RoomServerException(`received change for a document that is not connected: ${path}`);
         }
     }
+    async _handleStatus(protocol, messageId, data, bytes) {
+        const headerStr = (0, utils_1.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 });
     }
@@ -99,6 +105,11 @@ class SyncClient extends event_emitter_1.EventEmitter {
         }
     }
     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 room_server_client_1.RoomServerException(`Not connected to ${path}`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meshagent/meshagent",
-    "version": "0.3.1",
+    "version": "0.4.1",
     "description": "Meshagent Client",
     "homepage": "https://www.meshagent.com",
     "scripts": {
@@ -8,11 +8,12 @@
         "build": "mkdir -p dist && ./scripts/build.sh",
         "build-browser-test": "node ./build-browser-test.js"
     },
-    "author": "Powerboards",
+    "author": "Meshagent Software",
     "license": "Apache-2.0",
     "main": "./dist/node/index.js",
     "exports": {
         ".": {
+            "module": "./dist/esm/index.js",
             "browser": "./dist/browser/index.js",
             "default": "./dist/node/index.js"
         },
@@ -46,4 +47,4 @@
         "uuid": "^11.0.5",
         "ws": "^8.18.0"
     }
-}
+}