@kokimoki/app 1.4.4 → 1.4.5

package/dist/kokimoki-awareness.js

@@ -34,7 +34,7 @@ export class KokimokiAwareness extends KokimokiStore {
                         // Delete clients that haven't pinged in a while
                         for (const connectionId in this.proxy) {
                             const { lastPing } = this.proxy[connectionId];
-                            if (timestamp - lastPing > pingTimeout * 2) {
+                            if (!lastPing || timestamp - lastPing > pingTimeout * 2) {
                                 t.delete(this.root[connectionId]);
                             }
                         }

package/dist/kokimoki-client-refactored.d.ts

@@ -0,0 +1,68 @@
+import type TypedEmitter from "typed-emitter";
+import type { KokimokiClientEventsRefactored } from "./types/events";
+import type { Upload } from "./types/upload";
+import type { Paginated } from "./types/common";
+import { KokimokiTransaction } from "./kokimoki-transaction";
+import type { KokimokiStore } from "./kokimoki-store";
+import type { SyncedGeneric } from "./synced-schema";
+import { RoomSubscriptionMode } from "./room-subscription-mode";
+declare const KokimokiClientRefactored_base: new () => TypedEmitter<KokimokiClientEventsRefactored>;
+export declare class KokimokiClientRefactored<ClientContextT = any> extends KokimokiClientRefactored_base {
+    readonly host: string;
+    readonly appId: string;
+    readonly code: string;
+    private _wsUrl;
+    private _apiUrl;
+    private _id?;
+    private _token?;
+    private _apiHeaders?;
+    private _serverTimeOffset;
+    private _clientContext?;
+    private _ws?;
+    private _subscriptions;
+    private _stores;
+    private _reqPromises;
+    private _transactionResolves;
+    private _roomHashes;
+    private _roomHashToDoc;
+    private _connected;
+    private _connectPromise?;
+    private _messageId;
+    constructor(host: string, appId: string, code?: string);
+    get id(): string;
+    get token(): string;
+    get apiUrl(): string;
+    get apiHeaders(): Headers;
+    get clientContext(): ClientContextT & ({} | null);
+    get connected(): boolean;
+    get ws(): WebSocket;
+    connect(): Promise<void>;
+    private handleInitMessage;
+    private handleBinaryMessage;
+    private handleErrorMessage;
+    private handleSubscribeResMessage;
+    private handleRoomUpdateMessage;
+    serverTimestamp(): number;
+    patchRoomState(room: string, update: Uint8Array): Promise<any>;
+    private createUpload;
+    private uploadChunks;
+    private completeUpload;
+    upload(name: string, blob: Blob, tags?: string[]): Promise<Upload>;
+    updateUpload(id: string, update: {
+        tags?: string[];
+    }): Promise<Upload>;
+    listUploads(filter?: {
+        clientId?: string;
+        mimeTypes?: string[];
+        tags?: string[];
+    }, skip?: number, limit?: number): Promise<Paginated<Upload>>;
+    deleteUpload(id: string): Promise<{
+        acknowledged: boolean;
+        deletedCount: number;
+    }>;
+    exposeScriptingContext(context: any): Promise<void>;
+    private sendSubscriptionReq;
+    join<T extends SyncedGeneric<unknown>>(store: KokimokiStore<T>, mode?: RoomSubscriptionMode): Promise<void>;
+    transact(handler: (t: KokimokiTransaction) => void): Promise<void>;
+}
+export {};

package/dist/kokimoki-client-refactored.js

@@ -0,0 +1,394 @@
+import EventEmitter from "events";
+import { KOKIMOKI_APP_VERSION } from "./version";
+import * as Y from "yjs";
+import { KokimokiTransaction } from "./kokimoki-transaction";
+import { WsMessageType } from "./ws-message-type";
+import { WsMessageWriter } from "./ws-message-writer";
+import { WsMessageReader } from "./ws-message-reader";
+import { RoomSubscriptionMode } from "./room-subscription-mode";
+export class KokimokiClientRefactored extends EventEmitter {
+    host;
+    appId;
+    code;
+    _wsUrl;
+    _apiUrl;
+    _id;
+    _token;
+    _apiHeaders;
+    _serverTimeOffset = 0;
+    _clientContext;
+    _ws;
+    _subscriptions = new Map();
+    _stores = new Map();
+    _reqPromises = new Map();
+    _transactionResolves = new Map();
+    _roomHashes = new Map();
+    _roomHashToDoc = new Map();
+    _connected = false;
+    _connectPromise;
+    _messageId = 0;
+    constructor(host, appId, code = "") {
+        super();
+        this.host = host;
+        this.appId = appId;
+        this.code = code;
+        // Set up the URLs
+        const secure = this.host.indexOf(":") === -1;
+        this._wsUrl = `ws${secure ? "s" : ""}://${this.host}`;
+        this._apiUrl = `http${secure ? "s" : ""}://${this.host}`;
+    }
+    get id() {
+        if (!this._id) {
+            throw new Error("Client not connected");
+        }
+        return this._id;
+    }
+    get token() {
+        if (!this._token) {
+            throw new Error("Client not connected");
+        }
+        return this._token;
+    }
+    get apiUrl() {
+        if (!this._apiUrl) {
+            throw new Error("Client not connected");
+        }
+        return this._apiUrl;
+    }
+    get apiHeaders() {
+        if (!this._apiHeaders) {
+            throw new Error("Client not connected");
+        }
+        return this._apiHeaders;
+    }
+    get clientContext() {
+        if (this._clientContext === undefined) {
+            throw new Error("Client not connected");
+        }
+        return this._clientContext;
+    }
+    get connected() {
+        return this._connected;
+    }
+    get ws() {
+        if (!this._ws) {
+            throw new Error("Not connected");
+        }
+        return this._ws;
+    }
+    async connect() {
+        if (this._connectPromise) {
+            return await this._connectPromise;
+        }
+        this._ws = new WebSocket(`${this._wsUrl}/apps/${this.appId}?clientVersion=${KOKIMOKI_APP_VERSION}`);
+        this._ws.binaryType = "arraybuffer";
+        this._connectPromise = new Promise((onInit) => {
+            // Fetch the auth token
+            let clientToken = localStorage.getItem("KM_TOKEN");
+            // Send the app token on first connect
+            this.ws.onopen = () => {
+                this.ws.send(JSON.stringify({ type: "auth", code: this.code, token: clientToken }));
+            };
+            this.ws.onclose = () => {
+                this._connected = false;
+                this._connectPromise = undefined;
+                this._ws = undefined;
+                // Clean up
+                this._reqPromises.clear();
+                this._transactionResolves.clear();
+                this._roomHashes.clear();
+                this._roomHashToDoc.clear();
+                this._subscriptions.clear();
+                // Emit disconnected event
+                this.emit("disconnected");
+                // Attempt to reconnect
+                // setTimeout(async () => await this.connect(), 2000);
+            };
+            this.ws.onmessage = (e) => {
+                console.log(`Received WS message: ${e.data}`);
+                // Handle JSON messages
+                if (typeof e.data === "string") {
+                    const message = JSON.parse(e.data);
+                    switch (message.type) {
+                        case "serverTime": {
+                            this._serverTimeOffset = Date.now() - message.serverTime;
+                            console.log(`Server time offset: ${this._serverTimeOffset}`);
+                            break;
+                        }
+                        case "init":
+                            this.handleInitMessage(message);
+                            onInit();
+                            break;
+                    }
+                    return;
+                }
+                // Handle binary messages
+                this.handleBinaryMessage(e.data);
+            };
+        });
+        await this._connectPromise;
+    }
+    handleInitMessage(message) {
+        localStorage.setItem("KM_TOKEN", message.clientToken);
+        this._id = message.clientId;
+        this._token = message.appToken;
+        this._clientContext = message.clientContext;
+        // Set up the auth headers
+        this._apiHeaders = new Headers({
+            Authorization: `Bearer ${this.token}`,
+            "Content-Type": "application/json",
+        });
+        this._connected = true;
+        this.emit("connected");
+    }
+    handleBinaryMessage(data) {
+        const reader = new WsMessageReader(data);
+        const type = reader.readInt32();
+        switch (type) {
+            case WsMessageType.SubscribeRes:
+                this.handleSubscribeResMessage(reader);
+                break;
+            case WsMessageType.RoomUpdate:
+                this.handleRoomUpdateMessage(reader);
+                break;
+            case WsMessageType.Error:
+                this.handleErrorMessage(reader);
+                break;
+        }
+    }
+    handleErrorMessage(msg) {
+        const reqId = msg.readInt32();
+        const error = msg.readString();
+        const promise = this._reqPromises.get(reqId);
+        if (promise) {
+            this._reqPromises.delete(reqId);
+            promise.reject(error);
+        }
+        else {
+            console.warn(`Received error for unknown request ${reqId}: ${error}`);
+        }
+    }
+    handleSubscribeResMessage(msg) {
+        const reqId = msg.readInt32();
+        const roomHash = msg.readUint32();
+        const promise = this._reqPromises.get(reqId);
+        if (promise) {
+            this._reqPromises.delete(reqId);
+            // In Write mode, no initial state is sent
+            if (!msg.end) {
+                promise.resolve(roomHash, msg.readUint8Array());
+            }
+            else {
+                promise.resolve(roomHash);
+            }
+        }
+    }
+    handleRoomUpdateMessage(msg) {
+        const appliedId = msg.readInt32();
+        const roomHash = msg.readUint32();
+        // Apply update if not in Write mode
+        if (!msg.end) {
+            const doc = this._roomHashToDoc.get(roomHash);
+            if (doc) {
+                Y.applyUpdate(doc, msg.readUint8Array(), this);
+            }
+            else {
+                console.warn(`Received update for unknown room ${roomHash}`);
+            }
+        }
+        // Check transaction resolves
+        for (const [transactionId, resolve,] of this._transactionResolves.entries()) {
+            if (appliedId >= transactionId) {
+                this._transactionResolves.delete(transactionId);
+                resolve();
+            }
+        }
+    }
+    serverTimestamp() {
+        return Date.now() - this._serverTimeOffset;
+    }
+    // Send Y update to room
+    async patchRoomState(room, update) {
+        const res = await fetch(`${this._apiUrl}/rooms/${room}`, {
+            method: "PATCH",
+            headers: this.apiHeaders,
+            body: update,
+        });
+        return await res.json();
+    }
+    // Storage
+    async createUpload(name, blob, tags) {
+        const res = await fetch(`${this._apiUrl}/uploads`, {
+            method: "POST",
+            headers: this.apiHeaders,
+            body: JSON.stringify({
+                name,
+                size: blob.size,
+                mimeType: blob.type,
+                tags,
+            }),
+        });
+        return await res.json();
+    }
+    async uploadChunks(blob, chunkSize, signedUrls) {
+        return await Promise.all(signedUrls.map(async (url, index) => {
+            const start = index * chunkSize;
+            const end = Math.min(start + chunkSize, blob.size);
+            const chunk = blob.slice(start, end);
+            const res = await fetch(url, { method: "PUT", body: chunk });
+            return JSON.parse(res.headers.get("ETag") || '""');
+        }));
+    }
+    async completeUpload(id, etags) {
+        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
+            method: "PUT",
+            headers: this.apiHeaders,
+            body: JSON.stringify({ etags }),
+        });
+        return await res.json();
+    }
+    async upload(name, blob, tags = []) {
+        const { id, chunkSize, urls } = await this.createUpload(name, blob, tags);
+        const etags = await this.uploadChunks(blob, chunkSize, urls);
+        return await this.completeUpload(id, etags);
+    }
+    async updateUpload(id, update) {
+        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
+            method: "PUT",
+            headers: this.apiHeaders,
+            body: JSON.stringify(update),
+        });
+        return await res.json();
+    }
+    async listUploads(filter = {}, skip = 0, limit = 100) {
+        const url = new URL("/uploads", this._apiUrl);
+        url.searchParams.set("skip", skip.toString());
+        url.searchParams.set("limit", limit.toString());
+        if (filter.clientId) {
+            url.searchParams.set("clientId", filter.clientId);
+        }
+        if (filter.mimeTypes) {
+            url.searchParams.set("mimeTypes", filter.mimeTypes.join());
+        }
+        if (filter.tags) {
+            url.searchParams.set("tags", filter.tags.join());
+        }
+        const res = await fetch(url.href, {
+            headers: this.apiHeaders,
+        });
+        return await res.json();
+    }
+    async deleteUpload(id) {
+        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
+            method: "DELETE",
+            headers: this.apiHeaders,
+        });
+        return await res.json();
+    }
+    async exposeScriptingContext(context) {
+        // @ts-ignore
+        window.KM_SCRIPTING_CONTEXT = context;
+        // @ts-ignore
+        window.dispatchEvent(new CustomEvent("km:scriptingContextExposed"));
+    }
+    async sendSubscriptionReq(roomName, mode) {
+        // Set up sync resolver
+        const reqId = ++this._messageId;
+        return await new Promise((resolve, reject) => {
+            this._reqPromises.set(reqId, {
+                resolve: (roomHash, initialUpdate) => {
+                    resolve({ roomHash, initialUpdate });
+                },
+                reject,
+            });
+            // Send subscription request
+            const msg = new WsMessageWriter();
+            msg.writeInt32(WsMessageType.SubscribeReq);
+            msg.writeInt32(reqId);
+            msg.writeString(roomName);
+            msg.writeChar(mode);
+            this.ws.send(msg.getBuffer());
+        });
+    }
+    async join(store, mode = RoomSubscriptionMode.ReadWrite) {
+        if (this._subscriptions.has(store.roomName)) {
+            throw new Error(`Already joined room "${store.roomName}"`);
+        }
+        this._subscriptions.set(store.roomName, mode);
+        // Send req
+        try {
+            const res = await this.sendSubscriptionReq(store.roomName, mode);
+            // Set room hash
+            this._roomHashes.set(store.roomName, res.roomHash);
+            this._roomHashToDoc.set(res.roomHash, store.doc);
+            this._stores.set(res.roomHash, store);
+            // Apply initial state
+            if (res.initialUpdate) {
+                Y.applyUpdate(store.doc, res.initialUpdate, this);
+            }
+            // Set defaults if doc is empty after sync (only possible in ReadWrite mode)
+            if (mode === RoomSubscriptionMode.ReadWrite) {
+                await this.transact((t) => {
+                    for (const key in store.defaultValue) {
+                        // @ts-ignore
+                        if (!store.proxy.hasOwnProperty(key)) {
+                            t.set(store.root[key], store.defaultValue[key]);
+                        }
+                    }
+                });
+            }
+        }
+        catch (err) {
+            this._subscriptions.delete(store.roomName);
+            throw err;
+        }
+    }
+    async transact(handler) {
+        const transaction = new KokimokiTransaction(this);
+        handler(transaction);
+        const updates = await transaction.getUpdates();
+        if (!updates.length) {
+            return;
+        }
+        // Construct buffer
+        const writer = new WsMessageWriter();
+        // Write message type
+        writer.writeInt32(WsMessageType.Transaction);
+        // Update and write transaction ID
+        const transactionId = ++this._messageId;
+        writer.writeInt32(transactionId);
+        // Write updates
+        for (const { roomName, update } of updates) {
+            const roomHash = this._roomHashes.get(roomName);
+            if (!roomHash) {
+                throw new Error(`Cannot send update to "${roomName}" because it hasn't been joined`);
+            }
+            writer.writeUint32(roomHash);
+            writer.writeUint8Array(update);
+        }
+        const buffer = writer.getBuffer();
+        // Wait for server to apply transaction
+        await new Promise((resolve) => {
+            this._transactionResolves.set(transactionId, resolve);
+            // Send update to server
+            try {
+                this.ws.send(buffer);
+            }
+            catch (e) {
+                // Not connected
+                console.log("Failed to send update to server:", e);
+                // TODO: merge updates or something
+                throw e;
+            }
+        });
+        /* // Reset doc in Write-only mode
+        for (const { roomName, update } of updates) {
+          const mode = this._subscriptions.get(roomName);
+    
+          if (mode === RoomSubscriptionMode.Write) {
+            // @ts-ignore
+            // this._stores.get(this._roomHashes.get(roomName)!)!.doc = new Y.Doc();
+          }
+        } */
+    }
+}

package/dist/kokimoki-client.d.ts

@@ -34,7 +34,6 @@ export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient
     private _autoReconnect;
     private _reconnectTimeout;
     private _pingInterval;
-    private _devMode;
     private _clientTokenKey;
     constructor(host: string, appId: string, code?: string);
     get id(): string;

package/dist/kokimoki-client.js

@@ -34,7 +34,6 @@ export class KokimokiClient extends EventEmitter {
     _autoReconnect = true;
     _reconnectTimeout = 0;
     _pingInterval;
-    _devMode = false;
     _clientTokenKey = "KM_TOKEN";
     constructor(host, appId, code = "") {
         super();

package/dist/kokimoki.min.d.ts

@@ -343,7 +343,6 @@ declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     private _autoReconnect;
     private _reconnectTimeout;
     private _pingInterval;
-    private _devMode;
     private _clientTokenKey;
     constructor(host: string, appId: string, code?: string);
     get id(): string;

package/dist/kokimoki.min.js

@@ -634,7 +634,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 var eventsExports = events.exports;
 var EventEmitter$1 = /*@__PURE__*/getDefaultExportFromCjs(eventsExports);
 
-const KOKIMOKI_APP_VERSION = "1.4.4";
+const KOKIMOKI_APP_VERSION = "1.4.5";
 
 /**
  * Utility module to work with key-value stores.
@@ -12034,7 +12034,7 @@ class KokimokiAwareness extends KokimokiStore {
                         // Delete clients that haven't pinged in a while
                         for (const connectionId in this.proxy) {
                             const { lastPing } = this.proxy[connectionId];
-                            if (timestamp - lastPing > pingTimeout * 2) {
+                            if (!lastPing || timestamp - lastPing > pingTimeout * 2) {
                                 t.delete(this.root[connectionId]);
                             }
                         }
@@ -12247,7 +12247,6 @@ class KokimokiClient extends EventEmitter$1 {
     _autoReconnect = true;
     _reconnectTimeout = 0;
     _pingInterval;
-    _devMode = false;
     _clientTokenKey = "KM_TOKEN";
     constructor(host, appId, code = "") {
         super();