@kokimoki/app 1.15.2 → 1.16.1

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.
@@ -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,49 +12004,72 @@ 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 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 _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) { }
 }
@@ -12104,6 +12204,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];
@@ -12120,64 +12223,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;
     }
@@ -15208,7 +15276,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) {
@@ -15465,7 +15533,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();