@kokimoki/app 1.1.0 → 1.2.0

package/dist/kokimoki-awareness.d.ts

@@ -2,14 +2,23 @@ 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 extends KokimokiStore<S.Dict<S.Struct<{
+export declare class KokimokiAwareness<Data extends S.Generic<unknown>> extends KokimokiStore<S.Dict<S.Struct<{
     clientId: S.String;
     lastPing: S.Number;
-}>>> {
+    data: Data;
+}>>, {
+    [clientId: string]: Data["defaultValue"];
+}> {
+    readonly dataSchema: Data;
+    readonly data: Data["defaultValue"];
     private _pingInterval;
     private _kmClients;
-    constructor(roomName: string, mode?: RoomSubscriptionMode, pingTimeout?: number);
+    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>;
+    private getConnectedClients;
+    subscribe(set: (value: {
+        [clientId: string]: Data["defaultValue"];
+    }) => void): () => void;
 }

package/dist/kokimoki-awareness.js

@@ -1,35 +1,36 @@
 import { KokimokiStore } from "./kokimoki-store";
 import { KokimokiSchema as S } from "./kokimoki-schema";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
-export class KokimokiAwareness
-// <Data extends S.Generic<unknown>>
- extends KokimokiStore {
+export class KokimokiAwareness extends KokimokiStore {
+    dataSchema;
+    data;
     _pingInterval = null;
     _kmClients = new Set();
-    //   private _data: Data["defaultValue"];
-    constructor(roomName, 
-    // public readonly dataSchema: Data,
-    // initialData: Data["defaultValue"],
-    mode = RoomSubscriptionMode.ReadWrite, pingTimeout = 2500) {
+    constructor(roomName, dataSchema, data, mode = RoomSubscriptionMode.ReadWrite, pingTimeout = 2500) {
         super(`/a/${roomName}`, S.dict(S.struct({
             clientId: S.string(),
             lastPing: S.number(),
-            //   data: dataSchema,
+            data: dataSchema,
         })), mode);
-        // this._data = initialData;
+        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 last ping
-                        t.set(this.root[client.connectionId].lastPing, timestamp);
-                        /* if (!this.proxy[client.connectionId]) {
-                          t.set(this.root[client.connectionId].data, this._data);
-                        } else {
-                          this._data = this.proxy[client.connectionId].data;
-                        } */
+                        // 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];
@@ -49,7 +50,7 @@ export class KokimokiAwareness
             t.set(this.root[client.connectionId], {
                 clientId: client.id,
                 lastPing: client.serverTimestamp(),
-                // data: this._data,
+                data: this.data,
             });
         });
     }
@@ -61,4 +62,37 @@ export class KokimokiAwareness
     async onLeave(client) {
         this._kmClients.delete(client);
     }
+    getConnectedClients() {
+        const clients = {};
+        for (const clientId in this.proxy) {
+            clients[clientId] = this.proxy[clientId].data;
+        }
+        return clients;
+    }
+    subscribe(set) {
+        let prevConnectionIds = {};
+        const handler = () => {
+            // Do nothing if only pings have changed
+            let changed = false;
+            const newConnectionIds = {};
+            for (const connectionId in this.proxy) {
+                newConnectionIds[connectionId] = true;
+                if (!prevConnectionIds[connectionId]) {
+                    changed = true;
+                }
+            }
+            for (const connectionId in prevConnectionIds) {
+                if (!newConnectionIds[connectionId]) {
+                    changed = true;
+                }
+            }
+            if (changed) {
+                set(this.getConnectedClients());
+                prevConnectionIds = newConnectionIds;
+            }
+        };
+        this.doc.on("update", handler);
+        set(this.getConnectedClients());
+        return () => this.doc.off("update", handler);
+    }
 }

package/dist/kokimoki-store.d.ts

@@ -11,6 +11,7 @@ export declare class KokimokiStore<T extends S.Generic<unknown>, SubscribeT = T[
     readonly defaultValue: T["defaultValue"];
     readonly docRoot: Y.Map<unknown>;
     constructor(roomName: string, schema: T, mode?: RoomSubscriptionMode);
+    get(): T["defaultValue"];
     subscribe(set: (value: SubscribeT) => void): () => void;
     onJoin(client: KokimokiClient): Promise<void>;
     onBeforeLeave(client: KokimokiClient): Promise<void>;

package/dist/kokimoki-store.js

@@ -45,6 +45,9 @@ export class KokimokiStore {
         // Set default value
         this.defaultValue = schema.defaultValue;
     }
+    get() {
+        return this.proxy;
+    }
     subscribe(set) {
         // @ts-ignore
         const handler = () => set(this.proxy);

package/dist/kokimoki.min.d.ts

@@ -220,6 +220,7 @@ declare class KokimokiStore<T extends KokimokiSchema.Generic<unknown>, Subscribe
     readonly defaultValue: T["defaultValue"];
     readonly docRoot: Y.Map<unknown>;
     constructor(roomName: string, schema: T, mode?: RoomSubscriptionMode);
+    get(): T["defaultValue"];
     subscribe(set: (value: SubscribeT) => void): () => void;
     onJoin(client: KokimokiClient): Promise<void>;
     onBeforeLeave(client: KokimokiClient): Promise<void>;
@@ -363,16 +364,25 @@ declare class RoomSubscription {
     close(): void;
 }
 
-declare class KokimokiAwareness extends KokimokiStore<KokimokiSchema.Dict<KokimokiSchema.Struct<{
+declare class KokimokiAwareness<Data extends KokimokiSchema.Generic<unknown>> extends KokimokiStore<KokimokiSchema.Dict<KokimokiSchema.Struct<{
     clientId: KokimokiSchema.String;
     lastPing: KokimokiSchema.Number;
-}>>> {
+    data: Data;
+}>>, {
+    [clientId: string]: Data["defaultValue"];
+}> {
+    readonly dataSchema: Data;
+    readonly data: Data["defaultValue"];
     private _pingInterval;
     private _kmClients;
-    constructor(roomName: string, mode?: RoomSubscriptionMode, pingTimeout?: number);
+    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>;
+    private getConnectedClients;
+    subscribe(set: (value: {
+        [clientId: string]: Data["defaultValue"];
+    }) => void): () => void;
 }
 
 export { BooleanField, ConstField, EnumField, Field, type FieldOptions, FloatField, Form, FormArray, FormGroup, ImageField, IntegerField, KokimokiAwareness, KokimokiClient, type KokimokiClientEvents, KokimokiQueue, KokimokiSchema, KokimokiStore, type Paginated, RoomSubscription, RoomSubscriptionMode, TextField, type Upload };

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.1.0";
+const KOKIMOKI_APP_VERSION = "1.2.0";
 
 /**
  * Utility module to work with key-value stores.
@@ -12448,6 +12448,9 @@ class KokimokiStore {
         // Set default value
         this.defaultValue = schema.defaultValue;
     }
+    get() {
+        return this.proxy;
+    }
     subscribe(set) {
         // @ts-ignore
         const handler = () => set(this.proxy);
@@ -12489,35 +12492,36 @@ class KokimokiQueue extends KokimokiStore {
     }
 }
 
-class KokimokiAwareness
-// <Data extends S.Generic<unknown>>
- extends KokimokiStore {
+class KokimokiAwareness extends KokimokiStore {
+    dataSchema;
+    data;
     _pingInterval = null;
     _kmClients = new Set();
-    //   private _data: Data["defaultValue"];
-    constructor(roomName, 
-    // public readonly dataSchema: Data,
-    // initialData: Data["defaultValue"],
-    mode = RoomSubscriptionMode.ReadWrite, pingTimeout = 2500) {
+    constructor(roomName, dataSchema, data, mode = RoomSubscriptionMode.ReadWrite, pingTimeout = 2500) {
         super(`/a/${roomName}`, KokimokiSchema.dict(KokimokiSchema.struct({
             clientId: KokimokiSchema.string(),
             lastPing: KokimokiSchema.number(),
-            //   data: dataSchema,
+            data: dataSchema,
         })), mode);
-        // this._data = initialData;
+        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 last ping
-                        t.set(this.root[client.connectionId].lastPing, timestamp);
-                        /* if (!this.proxy[client.connectionId]) {
-                          t.set(this.root[client.connectionId].data, this._data);
-                        } else {
-                          this._data = this.proxy[client.connectionId].data;
-                        } */
+                        // 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];
@@ -12537,7 +12541,7 @@ class KokimokiAwareness
             t.set(this.root[client.connectionId], {
                 clientId: client.id,
                 lastPing: client.serverTimestamp(),
-                // data: this._data,
+                data: this.data,
             });
         });
     }
@@ -12549,6 +12553,39 @@ class KokimokiAwareness
     async onLeave(client) {
         this._kmClients.delete(client);
     }
+    getConnectedClients() {
+        const clients = {};
+        for (const clientId in this.proxy) {
+            clients[clientId] = this.proxy[clientId].data;
+        }
+        return clients;
+    }
+    subscribe(set) {
+        let prevConnectionIds = {};
+        const handler = () => {
+            // Do nothing if only pings have changed
+            let changed = false;
+            const newConnectionIds = {};
+            for (const connectionId in this.proxy) {
+                newConnectionIds[connectionId] = true;
+                if (!prevConnectionIds[connectionId]) {
+                    changed = true;
+                }
+            }
+            for (const connectionId in prevConnectionIds) {
+                if (!newConnectionIds[connectionId]) {
+                    changed = true;
+                }
+            }
+            if (changed) {
+                set(this.getConnectedClients());
+                prevConnectionIds = newConnectionIds;
+            }
+        };
+        this.doc.on("update", handler);
+        set(this.getConnectedClients());
+        return () => this.doc.off("update", handler);
+    }
 }
 
 export { BooleanField, ConstField, EnumField, Field, FloatField, Form, FormArray, FormGroup, ImageField, IntegerField, KokimokiAwareness, KokimokiClient, KokimokiQueue, KokimokiSchema, KokimokiStore, RoomSubscription, RoomSubscriptionMode, TextField };