@kokimoki/app 1.4.7 → 1.6.0

package/dist/kokimoki-awareness copy.d.ts

@@ -0,0 +1,22 @@
+import { KokimokiStore } from "./kokimoki-store";
+import { KokimokiSchema as S } from "./kokimoki-schema";
+import { RoomSubscriptionMode } from "./room-subscription-mode";
+import type { KokimokiClient } from "./kokimoki-client";
+export declare class KokimokiAwareness<Data extends S.Generic<unknown>> extends KokimokiStore<S.Dict<S.Struct<{
+    clientId: S.String;
+    lastPing: S.Number;
+    data: Data;
+}>>> {
+    readonly dataSchema: Data;
+    private _data;
+    private _pingInterval;
+    private _kmClients;
+    constructor(roomName: string, dataSchema: Data, _data: Data["defaultValue"], mode?: RoomSubscriptionMode, pingTimeout?: number);
+    onJoin(client: KokimokiClient<any>): Promise<void>;
+    onBeforeLeave(client: KokimokiClient<any>): Promise<void>;
+    onLeave(client: KokimokiClient<any>): Promise<void>;
+    getClients(): {
+        [clientId: string]: Data["defaultValue"];
+    };
+    setData(data: Data["defaultValue"]): Promise<void>;
+}

package/dist/kokimoki-awareness copy.js

@@ -0,0 +1,82 @@
+import { KokimokiStore } from "./kokimoki-store";
+import { KokimokiSchema as S } from "./kokimoki-schema";
+import { RoomSubscriptionMode } from "./room-subscription-mode";
+export class KokimokiAwareness extends KokimokiStore {
+    dataSchema;
+    _data;
+    _pingInterval = null;
+    _kmClients = new Set();
+    constructor(roomName, dataSchema, _data, mode = RoomSubscriptionMode.ReadWrite, pingTimeout = 3000) {
+        super(`/a/${roomName}`, S.dict(S.struct({
+            clientId: S.string(),
+            lastPing: S.number(),
+            data: dataSchema,
+        })), mode);
+        this.dataSchema = dataSchema;
+        this._data = _data;
+        this._pingInterval = setInterval(async () => {
+            const kmClients = Array.from(this._kmClients);
+            await Promise.all(kmClients.map(async (client) => {
+                try {
+                    await client.transact((t) => {
+                        const timestamp = client.serverTimestamp();
+                        // Update self
+                        if (this.proxy[client.connectionId]) {
+                            t.set(this.root[client.connectionId].lastPing, timestamp);
+                        }
+                        else {
+                            t.set(this.root[client.connectionId], {
+                                clientId: client.id,
+                                lastPing: timestamp,
+                                data: this._data,
+                            });
+                        }
+                        // Delete clients that haven't pinged in a while
+                        for (const connectionId in this.proxy) {
+                            const { lastPing } = this.proxy[connectionId];
+                            if (!lastPing || timestamp - lastPing > pingTimeout * 2) {
+                                t.delete(this.root[connectionId]);
+                            }
+                        }
+                    });
+                }
+                catch (e) { }
+            }));
+        }, pingTimeout);
+    }
+    async onJoin(client) {
+        this._kmClients.add(client);
+        await client.transact((t) => {
+            t.set(this.root[client.connectionId], {
+                clientId: client.id,
+                lastPing: client.serverTimestamp(),
+                data: this._data,
+            });
+        });
+    }
+    async onBeforeLeave(client) {
+        await client.transact((t) => {
+            t.delete(this.root[client.connectionId]);
+        });
+    }
+    async onLeave(client) {
+        this._kmClients.delete(client);
+    }
+    getClients() {
+        const clients = {};
+        for (const connectionId in this.proxy) {
+            clients[this.proxy[connectionId].clientId] =
+                this.proxy[connectionId].data;
+        }
+        return clients;
+    }
+    async setData(data) {
+        this._data = data;
+        const kmClients = Array.from(this._kmClients);
+        await Promise.all(kmClients.map(async (client) => {
+            await client.transact((t) => {
+                t.set(this.root[client.connectionId].data, this._data);
+            });
+        }));
+    }
+}

package/dist/kokimoki-client.d.ts

@@ -9,6 +9,7 @@ import type { RoomSubscriptionMode } from "./room-subscription-mode";
 import { KokimokiQueue } from "./kokimoki-queue";
 import { KokimokiAwareness } from "./kokimoki-awareness";
 import { KokimokiReqRes } from "./kokimoki-req-res";
+import { KokimokiLocalStore } from "./kokimoki-local-store";
 declare const KokimokiClient_base: new () => TypedEmitter<KokimokiClientEvents>;
 export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     readonly host: string;
@@ -81,6 +82,7 @@ export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient
     getRoomHash<T extends S.Generic<unknown>>(store: KokimokiStore<T>): number;
     /** Initializers */
     store<T extends S.Generic<unknown>>(name: string, schema: T, autoJoin?: boolean): KokimokiStore<T, T["defaultValue"]>;
+    localStore<T extends S.Generic<unknown>>(name: string, schema: T): KokimokiLocalStore<T>;
     queue<T extends S.Generic<unknown>>(name: string, schema: T, mode: RoomSubscriptionMode, autoJoin?: boolean): KokimokiQueue<T>;
     awareness<T extends S.Generic<unknown>>(name: string, dataSchema: T, initialData?: T["defaultValue"], autoJoin?: boolean): KokimokiAwareness<T>;
     reqRes<Req extends S.Generic<unknown>, Res extends S.Generic<unknown>>(serviceName: string, reqSchema: Req, resSchema: Res, handleRequest: (payload: Req["defaultValue"]) => Promise<Res["defaultValue"]>): KokimokiReqRes<Req, Res>;

package/dist/kokimoki-client.js

@@ -10,6 +10,7 @@ import { RoomSubscription } from "./room-subscription";
 import { KokimokiQueue } from "./kokimoki-queue";
 import { KokimokiAwareness } from "./kokimoki-awareness";
 import { KokimokiReqRes } from "./kokimoki-req-res";
+import { KokimokiLocalStore } from "./kokimoki-local-store";
 export class KokimokiClient extends EventEmitter {
     host;
     appId;
@@ -450,7 +451,13 @@ export class KokimokiClient extends EventEmitter {
         }
         // Send subscription request if connected to server
         if (!subscription.joined) {
-            const res = await this.sendSubscribeReq(store.roomName, store.mode);
+            let res;
+            if (store instanceof KokimokiLocalStore) {
+                res = store.getInitialUpdate(this.appId, this.id);
+            }
+            else {
+                res = await this.sendSubscribeReq(store.roomName, store.mode);
+            }
             this._subscriptionsByHash.set(res.roomHash, subscription);
             await subscription.applyInitialResponse(res.roomHash, res.initialUpdate);
             // Trigger onJoin event
@@ -470,55 +477,76 @@ export class KokimokiClient extends EventEmitter {
         }
     }
     async transact(handler) {
-        if (!this._connected) {
-            throw new Error("Client not connected");
-        }
+        // if (!this._connected) {
+        //   throw new Error("Client not connected");
+        // }
         const transaction = new KokimokiTransaction(this);
         await handler(transaction);
         const { updates, consumedMessages } = await transaction.getUpdates();
         if (!updates.length) {
             return;
         }
-        // Construct buffer
-        const writer = new WsMessageWriter();
+        // Construct buffers
+        const remoteUpdateWriter = new WsMessageWriter();
+        const localUpdateWriter = new WsMessageWriter();
         // Write message type
-        writer.writeInt32(WsMessageType.Transaction);
+        remoteUpdateWriter.writeInt32(WsMessageType.Transaction);
         // Update and write transaction ID
         const transactionId = ++this._messageId;
-        writer.writeInt32(transactionId);
-        // Write room hashes where messages were consumed
-        writer.writeInt32(consumedMessages.size);
+        remoteUpdateWriter.writeInt32(transactionId);
+        localUpdateWriter.writeInt32(transactionId);
+        // Write room hashes where messages were consumed (remote only)
+        remoteUpdateWriter.writeInt32(consumedMessages.size);
         for (const roomName of consumedMessages) {
             const subscription = this._subscriptionsByName.get(roomName);
             if (!subscription) {
                 throw new Error(`Cannot consume message in "${roomName}" because it hasn't been joined`);
             }
-            writer.writeUint32(subscription.roomHash);
+            remoteUpdateWriter.writeUint32(subscription.roomHash);
         }
         // Write updates
+        let localUpdates = 0, remoteUpdates = 0;
         for (const { roomName, update } of updates) {
             const subscription = this._subscriptionsByName.get(roomName);
             if (!subscription) {
                 throw new Error(`Cannot send update to "${roomName}" because it hasn't been joined`);
             }
-            writer.writeUint32(subscription.roomHash);
-            writer.writeUint8Array(update);
-        }
-        const buffer = writer.getBuffer();
-        // Wait for server to apply transaction
-        await new Promise((resolve, reject) => {
-            this._transactionPromises.set(transactionId, { resolve, reject });
-            // Send update to server
-            try {
-                this.ws.send(buffer);
+            if (subscription.store instanceof KokimokiLocalStore) {
+                localUpdates++;
+                localUpdateWriter.writeUint32(subscription.roomHash);
+                localUpdateWriter.writeUint8Array(update);
             }
-            catch (e) {
-                // Not connected
-                console.log("Failed to send update to server:", e);
-                // TODO: merge updates or something
-                throw e;
+            else {
+                remoteUpdates++;
+                remoteUpdateWriter.writeUint32(subscription.roomHash);
+                remoteUpdateWriter.writeUint8Array(update);
             }
-        });
+        }
+        // Wait for server to apply transaction
+        if (remoteUpdates) {
+            const remoteBuffer = remoteUpdateWriter.getBuffer();
+            await new Promise((resolve, reject) => {
+                this._transactionPromises.set(transactionId, { resolve, reject });
+                // Send update to server
+                try {
+                    this.ws.send(remoteBuffer);
+                }
+                catch (e) {
+                    // Not connected
+                    console.log("Failed to send update to server:", e);
+                    // Delete transaction promise
+                    this._transactionPromises.delete(transactionId);
+                    // TODO: merge updates or something
+                    reject(e);
+                }
+            });
+        }
+        // Apply local updates
+        if (localUpdates) {
+            const localBuffer = localUpdateWriter.getBuffer();
+            const reader = new WsMessageReader(localBuffer);
+            this.handleRoomUpdateMessage(reader);
+        }
     }
     async close() {
         this._autoReconnect = false;
@@ -548,6 +576,14 @@ export class KokimokiClient extends EventEmitter {
         }
         return store;
     }
+    // local store
+    localStore(name, schema) {
+        const store = new KokimokiLocalStore(name, schema);
+        this.join(store)
+            .then(() => { })
+            .catch(() => { });
+        return store;
+    }
     // queue
     queue(name, schema, mode, autoJoin = true) {
         const queue = new KokimokiQueue(name, schema, mode);

package/dist/kokimoki-local-store.d.ts

@@ -0,0 +1,12 @@
+import { KokimokiStore } from "./kokimoki-store";
+import type { KokimokiSchema as S } from "./kokimoki-schema";
+export declare class KokimokiLocalStore<Data extends S.Generic<unknown>> extends KokimokiStore<Data> {
+    private readonly localRoomName;
+    private _stateKey?;
+    private get stateKey();
+    constructor(localRoomName: string, schema: Data);
+    getInitialUpdate(appId: string, clientId: string): {
+        roomHash: number;
+        initialUpdate: Uint8Array | undefined;
+    };
+}

package/dist/kokimoki-local-store.js

@@ -0,0 +1,40 @@
+import { KokimokiStore } from "./kokimoki-store";
+import { RoomSubscriptionMode } from "./room-subscription-mode";
+import { fingerprint32 } from "farmhash-modern";
+import * as Y from "yjs";
+export class KokimokiLocalStore extends KokimokiStore {
+    localRoomName;
+    _stateKey;
+    get stateKey() {
+        if (!this._stateKey) {
+            throw new Error("Not initialized");
+        }
+        return this._stateKey;
+    }
+    constructor(localRoomName, schema) {
+        super(`/l/${localRoomName}`, schema, RoomSubscriptionMode.ReadWrite);
+        this.localRoomName = localRoomName;
+        // Synchronize doc changes to local storage
+        // TODO: maybe do not serialize full state every time
+        this.doc.on("update", () => {
+            const value = Y.encodeStateAsUpdate(this.doc);
+            const valueString = String.fromCharCode(...value);
+            const valueBase64 = btoa(valueString);
+            localStorage.setItem(this.stateKey, valueBase64);
+        });
+    }
+    getInitialUpdate(appId, clientId) {
+        this._stateKey = `${appId}/${clientId}/${this.localRoomName}`;
+        // get initial update from local storage
+        let initialUpdate = undefined;
+        const state = localStorage.getItem(this.stateKey);
+        if (state) {
+            const valueString = atob(state);
+            initialUpdate = Uint8Array.from(valueString, (c) => c.charCodeAt(0));
+        }
+        return {
+            roomHash: fingerprint32(this.roomName),
+            initialUpdate,
+        };
+    }
+}

package/dist/kokimoki.min.d.ts

@@ -318,6 +318,17 @@ declare class KokimokiReqRes<Req extends KokimokiSchema.Generic<unknown>, Res ex
     send(toClientId: string, payload: Req["defaultValue"], timeout?: number): Promise<Res["defaultValue"]>;
 }
 
+declare class KokimokiLocalStore<Data extends KokimokiSchema.Generic<unknown>> extends KokimokiStore<Data> {
+    private readonly localRoomName;
+    private _stateKey?;
+    private get stateKey();
+    constructor(localRoomName: string, schema: Data);
+    getInitialUpdate(appId: string, clientId: string): {
+        roomHash: number;
+        initialUpdate: Uint8Array | undefined;
+    };
+}
+
 declare const KokimokiClient_base: new () => TypedEventEmitter<KokimokiClientEvents>;
 declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     readonly host: string;
@@ -390,6 +401,7 @@ declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     getRoomHash<T extends KokimokiSchema.Generic<unknown>>(store: KokimokiStore<T>): number;
     /** Initializers */
     store<T extends KokimokiSchema.Generic<unknown>>(name: string, schema: T, autoJoin?: boolean): KokimokiStore<T, T["defaultValue"]>;
+    localStore<T extends KokimokiSchema.Generic<unknown>>(name: string, schema: T): KokimokiLocalStore<T>;
     queue<T extends KokimokiSchema.Generic<unknown>>(name: string, schema: T, mode: RoomSubscriptionMode, autoJoin?: boolean): KokimokiQueue<T>;
     awareness<T extends KokimokiSchema.Generic<unknown>>(name: string, dataSchema: T, initialData?: T["defaultValue"], autoJoin?: boolean): KokimokiAwareness<T>;
     reqRes<Req extends KokimokiSchema.Generic<unknown>, Res extends KokimokiSchema.Generic<unknown>>(serviceName: string, reqSchema: Req, resSchema: Res, handleRequest: (payload: Req["defaultValue"]) => Promise<Res["defaultValue"]>): KokimokiReqRes<Req, Res>;