@kokimoki/app 1.15.2 → 1.16.0

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

@@ -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,16 +1,28 @@
 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 proxy: T & {
+        _km_connections?: {
+            [connectionId: string]: string;
+        };
+    };
     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;
+    get(): Snapshot<T & {
+        _km_connections?: {
+            [connectionId: string]: string;
+        } | undefined;
+    }>;
+    subscribe(set: (value: Snapshot<T>) => void): () => void;
     onJoin(client: KokimokiClient): 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 { proxy, snapshot, subscribe } from "valtio/vanilla";
 import { bind as yjsBind } from "valtio-yjs";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
 export class KokimokiStore {
@@ -9,6 +9,7 @@ export class KokimokiStore {
     doc;
     proxy;
     docRoot;
+    connections;
     constructor(roomName, defaultValue, mode = RoomSubscriptionMode.ReadWrite) {
         this.roomName = roomName;
         this.defaultValue = defaultValue;
@@ -17,38 +18,29 @@ export class KokimokiStore {
         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 _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();
+            }
+        });
     }
     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) { }

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,16 +31,27 @@ 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 proxy: T & {
+        _km_connections?: {
+            [connectionId: string]: string;
+        };
+    };
     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;
+    get(): Snapshot<T & {
+        _km_connections?: {
+            [connectionId: string]: string;
+        } | undefined;
+    }>;
+    subscribe(set: (value: Snapshot<T>) => void): () => void;
     onJoin(client: KokimokiClient): Promise<void>;
     onBeforeLeave(client: KokimokiClient): Promise<void>;
     onLeave(client: KokimokiClient): Promise<void>;
@@ -48,24 +60,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 +85,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 +154,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

package/dist/kokimoki.min.js

@@ -11200,9 +11200,76 @@ const getUntracked = (obj) => {
     }
     return null;
 };
+/**
+ * Mark object to be tracked.
+ *
+ * This function marks an object that will be passed into `createProxy`
+ * as marked to track or not. By default only Array and Object are marked to track,
+ * so this is useful for example to mark a class instance to track or to mark a object
+ * to be untracked when creating your proxy.
+ *
+ * @param obj - Object to mark as tracked or not.
+ * @param mark - Boolean indicating whether you want to track this object or not.
+ * @returns - No return.
+ *
+ * @example
+ * import { createProxy, markToTrack, isChanged } from 'proxy-compare';
+ *
+ * const nested = { e: "3" }
+ *
+ * markToTrack(nested, false)
+ *
+ * const original = { a: "1", c: "2", d: nested };
+ * const affected = new WeakMap();
+ *
+ * const proxy = createProxy(original, affected);
+ *
+ * proxy.d.e
+ *
+ * isChanged(original, { d: { e: "3" } }, affected) // true
+ */
+const markToTrack = (obj, mark = true) => {
+    objectsToTrack.set(obj, mark);
+};
 
 const isObject = (x) => typeof x === "object" && x !== null;
 const canProxyDefault = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer) && !(x instanceof Promise);
+const createSnapshotDefault = (target, version) => {
+  const cache = snapCache.get(target);
+  if ((cache == null ? void 0 : cache[0]) === version) {
+    return cache[1];
+  }
+  const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
+  markToTrack(snap, true);
+  snapCache.set(target, [version, snap]);
+  Reflect.ownKeys(target).forEach((key) => {
+    if (Object.getOwnPropertyDescriptor(snap, key)) {
+      return;
+    }
+    const value = Reflect.get(target, key);
+    const { enumerable } = Reflect.getOwnPropertyDescriptor(
+      target,
+      key
+    );
+    const desc = {
+      value,
+      enumerable,
+      // This is intentional to avoid copying with proxy-compare.
+      // It's still non-writable, so it avoids assigning a value.
+      configurable: true
+    };
+    if (refSet.has(value)) {
+      markToTrack(value, false);
+    } else if (proxyStateMap.has(value)) {
+      const [target2, ensureVersion] = proxyStateMap.get(
+        value
+      );
+      desc.value = createSnapshotDefault(target2, ensureVersion());
+    }
+    Object.defineProperty(snap, key, desc);
+  });
+  return Object.preventExtensions(snap);
+};
 const createHandlerDefault = (isInitializing, addPropListener, removePropListener, notifyUpdate) => ({
   deleteProperty(target, prop) {
     const prevValue = Reflect.get(target, prop);
@@ -11232,11 +11299,13 @@ const createHandlerDefault = (isInitializing, addPropListener, removePropListene
 });
 const proxyStateMap = /* @__PURE__ */ new WeakMap();
 const refSet = /* @__PURE__ */ new WeakSet();
+const snapCache = /* @__PURE__ */ new WeakMap();
 const versionHolder = [1, 1];
 const proxyCache = /* @__PURE__ */ new WeakMap();
 let objectIs = Object.is;
 let newProxy = (target, handler) => new Proxy(target, handler);
 let canProxy = canProxyDefault;
+let createSnapshot = createSnapshotDefault;
 let createHandler = createHandlerDefault;
 function proxy(baseObject = {}) {
   if (!isObject(baseObject)) {
@@ -11377,6 +11446,14 @@ function subscribe(proxyObject, callback, notifyInSync) {
     removeListener();
   };
 }
+function snapshot(proxyObject) {
+  const proxyState = proxyStateMap.get(proxyObject);
+  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !proxyState) {
+    console.warn("Please use proxy object");
+  }
+  const [target, ensureVersion] = proxyState;
+  return createSnapshot(target, ensureVersion());
+}
 
 // do not edit .js files directly - edit src/index.jst
 
@@ -11927,6 +12004,7 @@ class KokimokiStore {
     doc;
     proxy;
     docRoot;
+    connections;
     constructor(roomName, defaultValue, mode = RoomSubscriptionMode.ReadWrite) {
         this.roomName = roomName;
         this.defaultValue = defaultValue;
@@ -11935,38 +12013,29 @@ class KokimokiStore {
         this.doc = new Doc();
         this.docRoot = this.doc.getMap("root");
         // Construct proxy object
-        this.proxy = proxy(); //T["defaultValue"];
+        this.proxy = proxy();
         // @ts-ignore
         bind$1(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 _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();
+            }
+        });
     }
     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) { }
@@ -12120,64 +12189,29 @@ class RoomSubscription {
 
 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;
     }
@@ -15465,7 +15499,12 @@ class KokimokiClient extends EventEmitter$1 {
         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();