@kokimoki/app 1.15.2 → 1.16.1

package/dist/kokimoki-awareness.d.ts

@@ -1,22 +1,20 @@
 import { KokimokiStore } from "./kokimoki-store";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
 import type { KokimokiClient } from "./kokimoki-client";
+import type { Snapshot } from "valtio/vanilla";
 export declare class KokimokiAwareness<DataT> extends KokimokiStore<{
     [connectionId: string]: {
         clientId: string;
-        lastPing: number;
         data: DataT;
     };
 }> {
     private _data;
-    private _pingInterval;
     private _kmClients;
-    constructor(roomName: string, _data: DataT, mode?: RoomSubscriptionMode, pingTimeout?: number);
+    constructor(roomName: string, _data: DataT, mode?: RoomSubscriptionMode);
     onJoin(client: KokimokiClient<any>): Promise<void>;
-    onBeforeLeave(client: KokimokiClient<any>): Promise<void>;
     onLeave(client: KokimokiClient<any>): Promise<void>;
     getClients(): {
-        [clientId: string]: DataT;
+        [clientId: string]: Snapshot<DataT>;
     };
     setData(data: DataT): Promise<void>;
 }

package/dist/kokimoki-awareness.js

@@ -2,64 +2,29 @@ import { KokimokiStore } from "./kokimoki-store";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
 export class KokimokiAwareness extends KokimokiStore {
     _data;
-    _pingInterval = null;
     _kmClients = new Set();
-    constructor(roomName, _data, mode = RoomSubscriptionMode.ReadWrite, pingTimeout = 3000) {
+    constructor(roomName, _data, mode = RoomSubscriptionMode.ReadWrite) {
         super(`/a/${roomName}`, {}, mode);
         this._data = _data;
-        this._pingInterval = setInterval(async () => {
-            const kmClients = Array.from(this._kmClients);
-            await Promise.all(kmClients.map(async (client) => {
-                try {
-                    await client.transact([this], ([state]) => {
-                        const timestamp = client.serverTimestamp();
-                        // Update self
-                        if (state[client.connectionId]) {
-                            state[client.connectionId].lastPing = timestamp;
-                        }
-                        else {
-                            state[client.connectionId] = {
-                                clientId: client.id,
-                                lastPing: timestamp,
-                                data: this._data,
-                            };
-                        }
-                        // Delete clients that haven't pinged in a while
-                        for (const connectionId in state) {
-                            const { lastPing } = state[connectionId];
-                            if (!lastPing || timestamp - lastPing > pingTimeout * 2) {
-                                delete state[connectionId];
-                            }
-                        }
-                    });
-                }
-                catch (e) { }
-            }));
-        }, pingTimeout);
     }
     async onJoin(client) {
         this._kmClients.add(client);
         await client.transact([this], ([state]) => {
             state[client.connectionId] = {
                 clientId: client.id,
-                lastPing: client.serverTimestamp(),
                 data: this._data,
             };
         });
     }
-    async onBeforeLeave(client) {
-        await client.transact([this], ([state]) => {
-            delete state[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;
+        const connections = this.get();
+        for (const connectionId in connections) {
+            clients[connections[connectionId].clientId] =
+                connections[connectionId].data;
         }
         return clients;
     }

package/dist/kokimoki-client.d.ts

@@ -5,7 +5,10 @@ import type { Paginated } from "./types/common";
 import { KokimokiStore } from "./kokimoki-store";
 import { KokimokiAwareness } from "./kokimoki-awareness";
 import { KokimokiLocalStore } from "./kokimoki-local-store";
-type StoreValue<S> = S extends KokimokiStore<infer U> ? U : never;
+type Mutable<T> = {
+    -readonly [K in keyof T]: T[K] extends object ? Mutable<T[K]> : T[K];
+};
+type StoreValue<S> = S extends KokimokiStore<infer U> ? Mutable<U> : never;
 declare const KokimokiClient_base: new () => TypedEmitter<KokimokiClientEvents>;
 export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     readonly host: string;
@@ -71,16 +74,16 @@ export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient
     exposeScriptingContext(context: any): Promise<void>;
     private sendSubscribeReq;
     private sendUnsubscribeReq;
-    join<T>(store: KokimokiStore<T>): Promise<void>;
-    leave<T>(store: KokimokiStore<T>): Promise<void>;
+    join<T extends object>(store: KokimokiStore<T>): Promise<void>;
+    leave<T extends object>(store: KokimokiStore<T>): Promise<void>;
     transact<TStores extends readonly KokimokiStore<any>[], ReturnT = void>(stores: [...TStores], handler: (proxies: {
         [K in keyof TStores]: StoreValue<TStores[K]>;
     }) => ReturnT | Promise<ReturnT>): Promise<ReturnT>;
     close(): Promise<void>;
-    getRoomHash<T>(store: KokimokiStore<T>): number;
+    getRoomHash<T extends object>(store: KokimokiStore<T>): number;
     /** Initializers */
-    store<T>(name: string, defaultState: T, autoJoin?: boolean): KokimokiStore<T>;
-    localStore<T>(name: string, defaultState: T): KokimokiLocalStore<T>;
+    store<T extends object>(name: string, defaultState: T, autoJoin?: boolean): KokimokiStore<T>;
+    localStore<T extends object>(name: string, defaultState: T): KokimokiLocalStore<T>;
     awareness<T>(name: string, initialData: T, autoJoin?: boolean): KokimokiAwareness<T>;
     /**
      * Add a new entry to a leaderboard

package/dist/kokimoki-client.js

@@ -461,7 +461,7 @@ export class KokimokiClient extends EventEmitter {
             this._subscriptionsByHash.set(res.roomHash, subscription);
             await subscription.applyInitialResponse(res.roomHash, res.initialUpdate);
             // Trigger onJoin event
-            store.onJoin(this);
+            await store.onJoin(this);
         }
     }
     async leave(store) {
@@ -718,7 +718,12 @@ export class KokimokiClient extends EventEmitter {
         const res = await fetch(`${this._apiUrl}/ai/chat`, {
             method: "POST",
             headers: this.apiHeaders,
-            body: JSON.stringify({ systemPrompt, userPrompt, temperature, maxTokens }),
+            body: JSON.stringify({
+                systemPrompt,
+                userPrompt,
+                temperature,
+                maxTokens,
+            }),
         });
         if (!res.ok) {
             throw await res.json();

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

@@ -1,5 +1,5 @@
 import { KokimokiStore } from "./kokimoki-store";
-export declare class KokimokiLocalStore<T> extends KokimokiStore<T> {
+export declare class KokimokiLocalStore<T extends object> extends KokimokiStore<T> {
     private readonly localRoomName;
     private _stateKey?;
     private get stateKey();

package/dist/kokimoki-store.d.ts

@@ -1,17 +1,21 @@
 import * as Y from "yjs";
+import { Snapshot } from "valtio/vanilla";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
 import type { KokimokiClient } from "./kokimoki-client";
-export declare class KokimokiStore<T> {
+export declare class KokimokiStore<T extends object> {
     readonly roomName: string;
     readonly defaultValue: T;
     readonly mode: RoomSubscriptionMode;
     readonly doc: Y.Doc;
     readonly proxy: T;
     readonly docRoot: Y.Map<unknown>;
+    readonly connections: {
+        clientIds: Set<string>;
+    };
     constructor(roomName: string, defaultValue: T, mode?: RoomSubscriptionMode);
-    get(): T;
-    subscribe(set: (value: T) => void): () => void;
-    onJoin(client: KokimokiClient): Promise<void>;
+    get(): Snapshot<T>;
+    subscribe(set: (value: Snapshot<T>) => void): () => void;
+    onJoin(client: KokimokiClient<any>): Promise<void>;
     onBeforeLeave(client: KokimokiClient): Promise<void>;
     onLeave(client: KokimokiClient): Promise<void>;
 }

package/dist/kokimoki-store.js

@@ -1,5 +1,5 @@
 import * as Y from "yjs";
-import { proxy as yjsProxy } from "valtio/vanilla";
+import { snapshot, proxy, subscribe } from "valtio/vanilla";
 import { bind as yjsBind } from "valtio-yjs";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
 export class KokimokiStore {
@@ -9,49 +9,72 @@ export class KokimokiStore {
     doc;
     proxy;
     docRoot;
+    connections;
     constructor(roomName, defaultValue, mode = RoomSubscriptionMode.ReadWrite) {
         this.roomName = roomName;
         this.defaultValue = defaultValue;
         this.mode = mode;
+        // "_connections" is a reserved key for tracking connections
+        if ("_connections" in defaultValue) {
+            throw new Error(`"_connections" is a reserved key in KokimokiStore`);
+        }
         // Construct Y doc
         this.doc = new Y.Doc();
         this.docRoot = this.doc.getMap("root");
         // Construct proxy object
-        this.proxy = yjsProxy(); //T["defaultValue"];
+        this.proxy = proxy();
         // @ts-ignore
         yjsBind(this.proxy, this.docRoot);
-        // // Create root proxy
-        // const store = this;
-        // // @ts-ignore
-        // this.root = new DeepProxy(this.proxy, {
-        //   get() {
-        //     return this.nest(function () {});
-        //   },
-        //   apply() {
-        //     let obj: any = store.proxy;
-        //     for (let i = 0; i < this.path.length - 1; i++) {
-        //       obj = obj[this.path[i]];
-        //     }
-        //     return {
-        //       roomName: store.roomName,
-        //       doc: store.doc,
-        //       path: this.path,
-        //       obj,
-        //       key: this.path[this.path.length - 1],
-        //     };
-        //   },
-        // });
+        // Construct connections proxy
+        this.connections = proxy({ clientIds: new Set() });
+        // Update connections.clientIds whenever _connections changes
+        let prevConnections = new Set();
+        subscribe(this.proxy, () => {
+            // @ts-ignore
+            const newConnections = new Set(
+            // @ts-ignore
+            Object.values(this.proxy._connections || {}));
+            // Update only if there are changes
+            let changed = false;
+            if (newConnections.size !== prevConnections.size) {
+                changed = true;
+            }
+            if (!changed) {
+                for (const id of newConnections) {
+                    if (!prevConnections.has(id)) {
+                        changed = true;
+                        break;
+                    }
+                }
+            }
+            if (!changed) {
+                for (const id of prevConnections) {
+                    if (!newConnections.has(id)) {
+                        changed = true;
+                        break;
+                    }
+                }
+            }
+            if (changed) {
+                this.connections.clientIds = newConnections;
+                prevConnections = new Set(newConnections);
+            }
+        });
     }
     get() {
-        return this.proxy;
+        return snapshot(this.proxy);
     }
     subscribe(set) {
-        const handler = () => set(this.proxy);
+        const handler = () => set(this.get());
         this.doc.on("update", handler);
-        set(this.proxy);
+        set(this.get());
         return () => this.doc.off("update", handler);
     }
-    async onJoin(client) { }
+    async onJoin(client) {
+        await client.transact([this], ([state]) => {
+            state._connections[client.connectionId] = client.id;
+        });
+    }
     async onBeforeLeave(client) { }
     async onLeave(client) { }
 }

package/dist/kokimoki-transaction.d.ts

@@ -1,5 +1,5 @@
 import { KokimokiStore } from "./kokimoki-store";
-export declare class KokimokiTransaction<T extends unknown[]> {
+export declare class KokimokiTransaction<T extends object[]> {
     private _updates;
     private _consumeMessagesInRooms;
     private _proxies;

package/dist/kokimoki.min.d.ts

@@ -1,5 +1,6 @@
 import TypedEmitter from 'typed-emitter';
 import * as Y from 'yjs';
+import { Snapshot } from 'valtio/vanilla';
 
 interface Paginated<T> {
     items: T[];
@@ -30,17 +31,20 @@ declare enum RoomSubscriptionMode {
     ReadWrite = "b"
 }
 
-declare class KokimokiStore<T> {
+declare class KokimokiStore<T extends object> {
     readonly roomName: string;
     readonly defaultValue: T;
     readonly mode: RoomSubscriptionMode;
     readonly doc: Y.Doc;
     readonly proxy: T;
     readonly docRoot: Y.Map<unknown>;
+    readonly connections: {
+        clientIds: Set<string>;
+    };
     constructor(roomName: string, defaultValue: T, mode?: RoomSubscriptionMode);
-    get(): T;
-    subscribe(set: (value: T) => void): () => void;
-    onJoin(client: KokimokiClient): Promise<void>;
+    get(): Snapshot<T>;
+    subscribe(set: (value: Snapshot<T>) => void): () => void;
+    onJoin(client: KokimokiClient<any>): Promise<void>;
     onBeforeLeave(client: KokimokiClient): Promise<void>;
     onLeave(client: KokimokiClient): Promise<void>;
 }
@@ -48,24 +52,21 @@ declare class KokimokiStore<T> {
 declare class KokimokiAwareness<DataT> extends KokimokiStore<{
     [connectionId: string]: {
         clientId: string;
-        lastPing: number;
         data: DataT;
     };
 }> {
     private _data;
-    private _pingInterval;
     private _kmClients;
-    constructor(roomName: string, _data: DataT, mode?: RoomSubscriptionMode, pingTimeout?: number);
+    constructor(roomName: string, _data: DataT, mode?: RoomSubscriptionMode);
     onJoin(client: KokimokiClient<any>): Promise<void>;
-    onBeforeLeave(client: KokimokiClient<any>): Promise<void>;
     onLeave(client: KokimokiClient<any>): Promise<void>;
     getClients(): {
-        [clientId: string]: DataT;
+        [clientId: string]: Snapshot<DataT>;
     };
     setData(data: DataT): Promise<void>;
 }
 
-declare class KokimokiLocalStore<T> extends KokimokiStore<T> {
+declare class KokimokiLocalStore<T extends object> extends KokimokiStore<T> {
     private readonly localRoomName;
     private _stateKey?;
     private get stateKey();
@@ -76,7 +77,10 @@ declare class KokimokiLocalStore<T> extends KokimokiStore<T> {
     };
 }
 
-type StoreValue<S> = S extends KokimokiStore<infer U> ? U : never;
+type Mutable<T> = {
+    -readonly [K in keyof T]: T[K] extends object ? Mutable<T[K]> : T[K];
+};
+type StoreValue<S> = S extends KokimokiStore<infer U> ? Mutable<U> : never;
 declare const KokimokiClient_base: new () => TypedEmitter<KokimokiClientEvents>;
 declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     readonly host: string;
@@ -142,16 +146,16 @@ declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     exposeScriptingContext(context: any): Promise<void>;
     private sendSubscribeReq;
     private sendUnsubscribeReq;
-    join<T>(store: KokimokiStore<T>): Promise<void>;
-    leave<T>(store: KokimokiStore<T>): Promise<void>;
+    join<T extends object>(store: KokimokiStore<T>): Promise<void>;
+    leave<T extends object>(store: KokimokiStore<T>): Promise<void>;
     transact<TStores extends readonly KokimokiStore<any>[], ReturnT = void>(stores: [...TStores], handler: (proxies: {
         [K in keyof TStores]: StoreValue<TStores[K]>;
     }) => ReturnT | Promise<ReturnT>): Promise<ReturnT>;
     close(): Promise<void>;
-    getRoomHash<T>(store: KokimokiStore<T>): number;
+    getRoomHash<T extends object>(store: KokimokiStore<T>): number;
     /** Initializers */
-    store<T>(name: string, defaultState: T, autoJoin?: boolean): KokimokiStore<T>;
-    localStore<T>(name: string, defaultState: T): KokimokiLocalStore<T>;
+    store<T extends object>(name: string, defaultState: T, autoJoin?: boolean): KokimokiStore<T>;
+    localStore<T extends object>(name: string, defaultState: T): KokimokiLocalStore<T>;
     awareness<T>(name: string, initialData: T, autoJoin?: boolean): KokimokiAwareness<T>;
     /**
      * Add a new entry to a leaderboard