@kokimoki/app 1.16.0 → 1.16.2

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) {

package/dist/kokimoki-store.d.ts

@@ -7,23 +7,17 @@ export declare class KokimokiStore<T extends object> {
     readonly defaultValue: T;
     readonly mode: RoomSubscriptionMode;
     readonly doc: Y.Doc;
-    readonly proxy: T & {
-        _km_connections?: {
-            [connectionId: string]: string;
-        };
-    };
+    readonly proxy: T;
     readonly docRoot: Y.Map<unknown>;
     readonly connections: {
+        connectionIds: Set<string>;
         clientIds: Set<string>;
     };
+    private _unsubscribeConnectionsHandler;
     constructor(roomName: string, defaultValue: T, mode?: RoomSubscriptionMode);
-    get(): Snapshot<T & {
-        _km_connections?: {
-            [connectionId: string]: string;
-        } | undefined;
-    }>;
+    get(): Snapshot<T>;
     subscribe(set: (value: Snapshot<T>) => void): () => void;
-    onJoin(client: KokimokiClient): Promise<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, snapshot, subscribe } 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 {
@@ -10,10 +10,15 @@ export class KokimokiStore {
     proxy;
     docRoot;
     connections;
+    _unsubscribeConnectionsHandler = () => { };
     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");
@@ -22,16 +27,9 @@ export class KokimokiStore {
         // @ts-ignore
         yjsBind(this.proxy, this.docRoot);
         // Construct connections proxy
-        this.connections = proxy({ clientIds: new Set() });
-        // Update connections.clientIds whenever _km_connections changes
-        subscribe(this.proxy, () => {
-            const kmConnections = this.proxy._km_connections;
-            if (kmConnections) {
-                this.connections.clientIds = new Set(Object.values(kmConnections));
-            }
-            else {
-                this.connections.clientIds = new Set();
-            }
+        this.connections = proxy({
+            connectionIds: new Set(),
+            clientIds: new Set(),
         });
     }
     get() {
@@ -43,7 +41,77 @@ export class KokimokiStore {
         set(this.get());
         return () => this.doc.off("update", handler);
     }
-    async onJoin(client) { }
+    async onJoin(client) {
+        // Update connections whenever _connections changes
+        let prevConnectionIds = new Set();
+        let prevClientIds = new Set();
+        this._unsubscribeConnectionsHandler = subscribe(this.proxy, () => {
+            // @ts-ignore
+            const newConnectionIds = new Set(
+            // @ts-ignore
+            Object.keys(this.proxy._connections || {}));
+            // Update only if there are changes
+            let connectionIdsChanged = false;
+            if (newConnectionIds.size !== prevConnectionIds.size) {
+                connectionIdsChanged = true;
+            }
+            if (!connectionIdsChanged) {
+                for (const id of newConnectionIds) {
+                    if (!prevConnectionIds.has(id)) {
+                        connectionIdsChanged = true;
+                        break;
+                    }
+                }
+            }
+            if (!connectionIdsChanged) {
+                for (const id of prevConnectionIds) {
+                    if (!newConnectionIds.has(id)) {
+                        connectionIdsChanged = true;
+                        break;
+                    }
+                }
+            }
+            if (connectionIdsChanged) {
+                this.connections.connectionIds = newConnectionIds;
+                prevConnectionIds = new Set(newConnectionIds);
+            }
+            // @ts-ignore
+            const newClientIds = new Set(
+            // @ts-ignore
+            Object.values(this.proxy._connections || {}));
+            // Update only if there are changes
+            let clientIdsChanged = false;
+            if (newClientIds.size !== prevClientIds.size) {
+                clientIdsChanged = true;
+            }
+            if (!clientIdsChanged) {
+                for (const id of newClientIds) {
+                    if (!prevClientIds.has(id)) {
+                        clientIdsChanged = true;
+                        break;
+                    }
+                }
+            }
+            if (!clientIdsChanged) {
+                for (const id of prevClientIds) {
+                    if (!newClientIds.has(id)) {
+                        clientIdsChanged = true;
+                        break;
+                    }
+                }
+            }
+            if (clientIdsChanged) {
+                this.connections.clientIds = newClientIds;
+                prevClientIds = new Set(newClientIds);
+            }
+        });
+        // Add client to _connections map
+        await client.transact([this], ([state]) => {
+            state._connections[client.connectionId] = client.id;
+        });
+    }
     async onBeforeLeave(client) { }
-    async onLeave(client) { }
+    async onLeave(client) {
+        this._unsubscribeConnectionsHandler();
+    }
 }

package/dist/kokimoki.min.d.ts

@@ -36,23 +36,17 @@ declare class KokimokiStore<T extends object> {
     readonly defaultValue: T;
     readonly mode: RoomSubscriptionMode;
     readonly doc: Y.Doc;
-    readonly proxy: T & {
-        _km_connections?: {
-            [connectionId: string]: string;
-        };
-    };
+    readonly proxy: T;
     readonly docRoot: Y.Map<unknown>;
     readonly connections: {
+        connectionIds: Set<string>;
         clientIds: Set<string>;
     };
+    private _unsubscribeConnectionsHandler;
     constructor(roomName: string, defaultValue: T, mode?: RoomSubscriptionMode);
-    get(): Snapshot<T & {
-        _km_connections?: {
-            [connectionId: string]: string;
-        } | undefined;
-    }>;
+    get(): Snapshot<T>;
     subscribe(set: (value: Snapshot<T>) => void): () => void;
-    onJoin(client: KokimokiClient): Promise<void>;
+    onJoin(client: KokimokiClient<any>): Promise<void>;
     onBeforeLeave(client: KokimokiClient): Promise<void>;
     onLeave(client: KokimokiClient): Promise<void>;
 }

package/dist/kokimoki.min.js

@@ -486,7 +486,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 var eventsExports = events.exports;
 var EventEmitter$1 = /*@__PURE__*/getDefaultExportFromCjs(eventsExports);
 
-const KOKIMOKI_APP_VERSION = "1.15.2";
+const KOKIMOKI_APP_VERSION = "1.16.1";
 
 /**
  * Utility module to work with key-value stores.
@@ -12005,10 +12005,15 @@ class KokimokiStore {
     proxy;
     docRoot;
     connections;
+    _unsubscribeConnectionsHandler = () => { };
     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 Doc();
         this.docRoot = this.doc.getMap("root");
@@ -12017,16 +12022,9 @@ class KokimokiStore {
         // @ts-ignore
         bind$1(this.proxy, this.docRoot);
         // Construct connections proxy
-        this.connections = proxy({ clientIds: new Set() });
-        // Update connections.clientIds whenever _km_connections changes
-        subscribe(this.proxy, () => {
-            const kmConnections = this.proxy._km_connections;
-            if (kmConnections) {
-                this.connections.clientIds = new Set(Object.values(kmConnections));
-            }
-            else {
-                this.connections.clientIds = new Set();
-            }
+        this.connections = proxy({
+            connectionIds: new Set(),
+            clientIds: new Set(),
         });
     }
     get() {
@@ -12038,9 +12036,79 @@ class KokimokiStore {
         set(this.get());
         return () => this.doc.off("update", handler);
     }
-    async onJoin(client) { }
+    async onJoin(client) {
+        // Update connections whenever _connections changes
+        let prevConnectionIds = new Set();
+        let prevClientIds = new Set();
+        this._unsubscribeConnectionsHandler = subscribe(this.proxy, () => {
+            // @ts-ignore
+            const newConnectionIds = new Set(
+            // @ts-ignore
+            Object.keys(this.proxy._connections || {}));
+            // Update only if there are changes
+            let connectionIdsChanged = false;
+            if (newConnectionIds.size !== prevConnectionIds.size) {
+                connectionIdsChanged = true;
+            }
+            if (!connectionIdsChanged) {
+                for (const id of newConnectionIds) {
+                    if (!prevConnectionIds.has(id)) {
+                        connectionIdsChanged = true;
+                        break;
+                    }
+                }
+            }
+            if (!connectionIdsChanged) {
+                for (const id of prevConnectionIds) {
+                    if (!newConnectionIds.has(id)) {
+                        connectionIdsChanged = true;
+                        break;
+                    }
+                }
+            }
+            if (connectionIdsChanged) {
+                this.connections.connectionIds = newConnectionIds;
+                prevConnectionIds = new Set(newConnectionIds);
+            }
+            // @ts-ignore
+            const newClientIds = new Set(
+            // @ts-ignore
+            Object.values(this.proxy._connections || {}));
+            // Update only if there are changes
+            let clientIdsChanged = false;
+            if (newClientIds.size !== prevClientIds.size) {
+                clientIdsChanged = true;
+            }
+            if (!clientIdsChanged) {
+                for (const id of newClientIds) {
+                    if (!prevClientIds.has(id)) {
+                        clientIdsChanged = true;
+                        break;
+                    }
+                }
+            }
+            if (!clientIdsChanged) {
+                for (const id of prevClientIds) {
+                    if (!newClientIds.has(id)) {
+                        clientIdsChanged = true;
+                        break;
+                    }
+                }
+            }
+            if (clientIdsChanged) {
+                this.connections.clientIds = newClientIds;
+                prevClientIds = new Set(newClientIds);
+            }
+        });
+        // Add client to _connections map
+        await client.transact([this], ([state]) => {
+            state._connections[client.connectionId] = client.id;
+        });
+    }
     async onBeforeLeave(client) { }
-    async onLeave(client) { }
+    async onLeave(client) {
+        this._unsubscribeConnectionsHandler();
+    }
 }
 
 var WsMessageType;
@@ -12173,6 +12241,9 @@ class RoomSubscription {
         // Set defaults if doc is empty after sync (only possible in ReadWrite mode)
         if (this.store.mode === RoomSubscriptionMode.ReadWrite) {
             await this.kmClient.transact([this.store], ([state]) => {
+                if (!("_connections" in state)) {
+                    state._connections = {};
+                }
                 for (const key in this.store.defaultValue) {
                     if (!state.hasOwnProperty(key)) {
                         state[key] = this.store.defaultValue[key];
@@ -15242,7 +15313,7 @@ class KokimokiClient extends EventEmitter$1 {
             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) {