@kokimoki/app 1.0.10 → 1.1.0

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.0.10";
+const KOKIMOKI_APP_VERSION = "1.1.0";
 
 /**
  * Utility module to work with key-value stores.
@@ -11508,6 +11508,8 @@ var WsMessageType;
     WsMessageType[WsMessageType["Error"] = 5] = "Error";
     WsMessageType[WsMessageType["Ping"] = 6] = "Ping";
     WsMessageType[WsMessageType["Pong"] = 7] = "Pong";
+    WsMessageType[WsMessageType["UnsubscribeReq"] = 8] = "UnsubscribeReq";
+    WsMessageType[WsMessageType["UnsubscribeRes"] = 9] = "UnsubscribeRes";
 })(WsMessageType || (WsMessageType = {}));
 
 class WsMessageWriter {
@@ -11655,6 +11657,7 @@ class KokimokiClient extends EventEmitter$1 {
     _wsUrl;
     _apiUrl;
     _id;
+    _connectionId;
     _token;
     _apiHeaders;
     _serverTimeOffset = 0;
@@ -11663,10 +11666,12 @@ class KokimokiClient extends EventEmitter$1 {
     _subscriptionsByName = new Map();
     _subscriptionsByHash = new Map();
     _subscribeReqPromises = new Map();
+    _unsubscribeReqPromises = new Map();
     _transactionPromises = new Map();
     _connected = false;
     _connectPromise;
     _messageId = 0;
+    _autoReconnect = true;
     _reconnectTimeout = 0;
     _pingInterval;
     constructor(host, appId, code = "") {
@@ -11694,6 +11699,12 @@ class KokimokiClient extends EventEmitter$1 {
         }
         return this._id;
     }
+    get connectionId() {
+        if (!this._connectionId) {
+            throw new Error("Client not connected");
+        }
+        return this._connectionId;
+    }
     get token() {
         if (!this._token) {
             throw new Error("Client not connected");
@@ -11739,9 +11750,10 @@ class KokimokiClient extends EventEmitter$1 {
                 window.__KOKIMOKI_WS__ = {};
             }
             if (this.appId in window.__KOKIMOKI_WS__) {
+                console.log(`[Kokimoki] Closing previous connection for ${this.appId}`);
                 window.__KOKIMOKI_WS__[this.appId].close();
             }
-            window.__KOKIMOKI_WS__[this.appId] = this._ws;
+            window.__KOKIMOKI_WS__[this.appId] = this;
         }
         // Wait for connection
         this._connectPromise = new Promise((onInit) => {
@@ -11763,6 +11775,9 @@ class KokimokiClient extends EventEmitter$1 {
                 this._subscribeReqPromises.clear();
                 this._transactionPromises.clear();
                 // Attempt to reconnect
+                if (!this._autoReconnect) {
+                    return;
+                }
                 console.log(`[Kokimoki] Connection lost, attempting to reconnect in ${this._reconnectTimeout} seconds...`);
                 setTimeout(async () => await this.connect(), this._reconnectTimeout * 1000);
                 this._reconnectTimeout = Math.min(3, this._reconnectTimeout + 1);
@@ -11811,6 +11826,7 @@ class KokimokiClient extends EventEmitter$1 {
     handleInitMessage(message) {
         localStorage.setItem("KM_TOKEN", message.clientToken);
         this._id = message.clientId;
+        this._connectionId = message.id;
         this._token = message.appToken;
         this._clientContext = message.clientContext;
         // Set up the auth headers
@@ -11826,6 +11842,9 @@ class KokimokiClient extends EventEmitter$1 {
             case WsMessageType.SubscribeRes:
                 this.handleSubscribeResMessage(reader);
                 break;
+            case WsMessageType.UnsubscribeRes:
+                this.handleUnsubscribeResMessage(reader);
+                break;
             case WsMessageType.RoomUpdate:
                 this.handleRoomUpdateMessage(reader);
                 break;
@@ -11872,6 +11891,14 @@ class KokimokiClient extends EventEmitter$1 {
             }
         }
     }
+    handleUnsubscribeResMessage(msg) {
+        const reqId = msg.readInt32();
+        const promise = this._unsubscribeReqPromises.get(reqId);
+        if (promise) {
+            this._unsubscribeReqPromises.delete(reqId);
+            promise.resolve();
+        }
+    }
     handleRoomUpdateMessage(msg) {
         const appliedId = msg.readInt32();
         const roomHash = msg.readUint32();
@@ -11980,7 +12007,7 @@ class KokimokiClient extends EventEmitter$1 {
         // @ts-ignore
         window.dispatchEvent(new CustomEvent("km:scriptingContextExposed"));
     }
-    async sendSubscriptionReq(roomName, mode) {
+    async sendSubscribeReq(roomName, mode) {
         // Set up sync resolver
         const reqId = ++this._messageId;
         return await new Promise((resolve, reject) => {
@@ -11999,6 +12026,21 @@ class KokimokiClient extends EventEmitter$1 {
             this.ws.send(msg.getBuffer());
         });
     }
+    async sendUnsubscribeReq(roomHash) {
+        const reqId = ++this._messageId;
+        return await new Promise((resolve, reject) => {
+            this._unsubscribeReqPromises.set(reqId, {
+                resolve,
+                reject,
+            });
+            // Send unsubscribe request
+            const msg = new WsMessageWriter();
+            msg.writeInt32(WsMessageType.UnsubscribeReq);
+            msg.writeInt32(reqId);
+            msg.writeUint32(roomHash);
+            this.ws.send(msg.getBuffer());
+        });
+    }
     async join(store) {
         let subscription = this._subscriptionsByName.get(store.roomName);
         if (!subscription) {
@@ -12007,9 +12049,22 @@ class KokimokiClient extends EventEmitter$1 {
         }
         // Send subscription request if connected to server
         if (!subscription.joined) {
-            const res = await this.sendSubscriptionReq(store.roomName, store.mode);
+            const res = await this.sendSubscribeReq(store.roomName, store.mode);
             this._subscriptionsByHash.set(res.roomHash, subscription);
             await subscription.applyInitialResponse(res.roomHash, res.initialUpdate);
+            // Trigger onJoin event
+            store.onJoin(this);
+        }
+    }
+    async leave(store) {
+        const subscription = this._subscriptionsByName.get(store.roomName);
+        if (subscription) {
+            await store.onBeforeLeave(this);
+            await this.sendUnsubscribeReq(subscription.roomHash);
+            this._subscriptionsByName.delete(store.roomName);
+            this._subscriptionsByHash.delete(subscription.roomHash);
+            // Trigger onLeave event
+            store.onLeave(this);
         }
     }
     async transact(handler) {
@@ -12072,6 +12127,15 @@ class KokimokiClient extends EventEmitter$1 {
           }
         } */
     }
+    async close() {
+        this._autoReconnect = false;
+        if (this._ws) {
+            this._ws.close();
+        }
+        if (this._pingInterval) {
+            clearInterval(this._pingInterval);
+        }
+    }
 }
 
 var KokimokiSchema;
@@ -12222,6 +12286,20 @@ var KokimokiSchema;
         return new AnyOf(schemas, defaultValue);
     }
     KokimokiSchema.anyOf = anyOf;
+    class Optional extends Generic {
+        schema;
+        defaultValue;
+        constructor(schema, defaultValue = undefined) {
+            super();
+            this.schema = schema;
+            this.defaultValue = defaultValue;
+        }
+    }
+    KokimokiSchema.Optional = Optional;
+    function optional(schema, defaultValue = undefined) {
+        return new Optional(schema, defaultValue);
+    }
+    KokimokiSchema.optional = optional;
 })(KokimokiSchema || (KokimokiSchema = {}));
 
 function parsePath(text) {
@@ -12341,8 +12419,8 @@ class KokimokiStore {
         this.mode = mode;
         // Construct Y doc
         this.doc = new Doc();
-        // Construct proxy object
         this.docRoot = this.doc.getMap("root");
+        // Construct proxy object
         this.proxy = proxy();
         // @ts-ignore
         f(this.proxy, this.docRoot);
@@ -12370,11 +12448,17 @@ class KokimokiStore {
         // Set default value
         this.defaultValue = schema.defaultValue;
     }
-    subscribe(callback) {
-        const handler = () => callback(this.proxy);
+    subscribe(set) {
+        // @ts-ignore
+        const handler = () => set(this.proxy);
         this.doc.on("update", handler);
+        // @ts-ignore
+        set(this.proxy);
         return () => this.doc.off("update", handler);
     }
+    async onJoin(client) { }
+    async onBeforeLeave(client) { }
+    async onLeave(client) { }
 }
 
 class KokimokiQueue extends KokimokiStore {
@@ -12405,5 +12489,67 @@ class KokimokiQueue extends KokimokiStore {
     }
 }
 
-export { BooleanField, ConstField, EnumField, Field, FloatField, Form, FormArray, FormGroup, ImageField, IntegerField, KokimokiClient, KokimokiQueue, KokimokiSchema, KokimokiStore, RoomSubscription, RoomSubscriptionMode, TextField };
+class KokimokiAwareness
+// <Data extends S.Generic<unknown>>
+ extends KokimokiStore {
+    _pingInterval = null;
+    _kmClients = new Set();
+    //   private _data: Data["defaultValue"];
+    constructor(roomName, 
+    // public readonly dataSchema: Data,
+    // initialData: Data["defaultValue"],
+    mode = RoomSubscriptionMode.ReadWrite, pingTimeout = 2500) {
+        super(`/a/${roomName}`, KokimokiSchema.dict(KokimokiSchema.struct({
+            clientId: KokimokiSchema.string(),
+            lastPing: KokimokiSchema.number(),
+            //   data: dataSchema,
+        })), mode);
+        // this._data = initialData;
+        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;
+                        } */
+                        // Delete clients that haven't pinged in a while
+                        for (const connectionId in this.proxy) {
+                            const { lastPing } = this.proxy[connectionId];
+                            if (timestamp - lastPing > pingTimeout * 2) {
+                                t.delete(this.root[connectionId]);
+                            }
+                        }
+                    });
+                }
+                catch (e) { }
+            }));
+        }, pingTimeout);
+    }
+    async onJoin(client) {
+        this._kmClients.add(client);
+        await client.transact((t) => {
+            t.set(this.root[client.connectionId], {
+                clientId: client.id,
+                lastPing: client.serverTimestamp(),
+                // data: this._data,
+            });
+        });
+    }
+    async onBeforeLeave(client) {
+        await client.transact((t) => {
+            t.delete(this.root[client.connectionId]);
+        });
+    }
+    async onLeave(client) {
+        this._kmClients.delete(client);
+    }
+}
+
+export { BooleanField, ConstField, EnumField, Field, FloatField, Form, FormArray, FormGroup, ImageField, IntegerField, KokimokiAwareness, KokimokiClient, KokimokiQueue, KokimokiSchema, KokimokiStore, RoomSubscription, RoomSubscriptionMode, TextField };
 //# sourceMappingURL=kokimoki.min.js.map