@kokimoki/app 1.0.9 → 1.1.0

package/dist/index.d.ts

@@ -8,3 +8,4 @@ export * from "./kokimoki-store";
 export * from "./kokimoki-queue";
 export * from "./room-subscription";
 export * from "./room-subscription-mode";
+export * from "./kokimoki-awareness";

package/dist/index.js

@@ -8,3 +8,4 @@ export * from "./kokimoki-store";
 export * from "./kokimoki-queue";
 export * from "./room-subscription";
 export * from "./room-subscription-mode";
+export * from "./kokimoki-awareness";

package/dist/kokimoki-awareness.d.ts

@@ -0,0 +1,15 @@
+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<{
+    clientId: S.String;
+    lastPing: S.Number;
+}>>> {
+    private _pingInterval;
+    private _kmClients;
+    constructor(roomName: string, mode?: RoomSubscriptionMode, pingTimeout?: number);
+    onJoin(client: KokimokiClient<any>): Promise<void>;
+    onBeforeLeave(client: KokimokiClient<any>): Promise<void>;
+    onLeave(client: KokimokiClient<any>): Promise<void>;
+}

package/dist/kokimoki-awareness.js

@@ -0,0 +1,64 @@
+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 {
+    _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}`, S.dict(S.struct({
+            clientId: S.string(),
+            lastPing: S.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);
+    }
+}

package/dist/kokimoki-client.d.ts

@@ -13,6 +13,7 @@ export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient
     private _wsUrl;
     private _apiUrl;
     private _id?;
+    private _connectionId?;
     private _token?;
     private _apiHeaders?;
     private _serverTimeOffset;
@@ -21,14 +22,17 @@ export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient
     private _subscriptionsByName;
     private _subscriptionsByHash;
     private _subscribeReqPromises;
+    private _unsubscribeReqPromises;
     private _transactionPromises;
     private _connected;
     private _connectPromise?;
     private _messageId;
+    private _autoReconnect;
     private _reconnectTimeout;
     private _pingInterval;
     constructor(host: string, appId: string, code?: string);
     get id(): string;
+    get connectionId(): string;
     get token(): string;
     get apiUrl(): string;
     get apiHeaders(): Headers;
@@ -40,6 +44,7 @@ export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient
     private handleBinaryMessage;
     private handleErrorMessage;
     private handleSubscribeResMessage;
+    private handleUnsubscribeResMessage;
     private handleRoomUpdateMessage;
     serverTimestamp(): number;
     patchRoomState(room: string, update: Uint8Array): Promise<any>;
@@ -60,8 +65,11 @@ export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient
         deletedCount: number;
     }>;
     exposeScriptingContext(context: any): Promise<void>;
-    private sendSubscriptionReq;
+    private sendSubscribeReq;
+    private sendUnsubscribeReq;
     join<T extends S.Generic<unknown>>(store: KokimokiStore<T>): Promise<void>;
+    leave<T extends S.Generic<unknown>>(store: KokimokiStore<T>): Promise<void>;
     transact(handler: (t: KokimokiTransaction) => void): Promise<void>;
+    close(): Promise<void>;
 }
 export {};

package/dist/kokimoki-client.js

@@ -13,6 +13,7 @@ export class KokimokiClient extends EventEmitter {
     _wsUrl;
     _apiUrl;
     _id;
+    _connectionId;
     _token;
     _apiHeaders;
     _serverTimeOffset = 0;
@@ -21,10 +22,12 @@ export class KokimokiClient extends EventEmitter {
     _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 = "") {
@@ -52,6 +55,12 @@ export class KokimokiClient extends EventEmitter {
         }
         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");
@@ -97,9 +106,10 @@ export class KokimokiClient extends EventEmitter {
                 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) => {
@@ -121,6 +131,9 @@ export class KokimokiClient extends EventEmitter {
                 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);
@@ -169,6 +182,7 @@ export class KokimokiClient extends EventEmitter {
     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
@@ -184,6 +198,9 @@ export class KokimokiClient extends EventEmitter {
             case WsMessageType.SubscribeRes:
                 this.handleSubscribeResMessage(reader);
                 break;
+            case WsMessageType.UnsubscribeRes:
+                this.handleUnsubscribeResMessage(reader);
+                break;
             case WsMessageType.RoomUpdate:
                 this.handleRoomUpdateMessage(reader);
                 break;
@@ -230,6 +247,14 @@ export class KokimokiClient extends EventEmitter {
             }
         }
     }
+    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();
@@ -338,7 +363,7 @@ export class KokimokiClient extends EventEmitter {
         // @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) => {
@@ -357,6 +382,21 @@ export class KokimokiClient extends EventEmitter {
             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) {
@@ -365,9 +405,22 @@ export class KokimokiClient extends EventEmitter {
         }
         // 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) {
@@ -430,4 +483,13 @@ export class KokimokiClient extends EventEmitter {
           }
         } */
     }
+    async close() {
+        this._autoReconnect = false;
+        if (this._ws) {
+            this._ws.close();
+        }
+        if (this._pingInterval) {
+            clearInterval(this._pingInterval);
+        }
+    }
 }

package/dist/kokimoki-schema.d.ts

@@ -75,4 +75,10 @@ export declare namespace KokimokiSchema {
         constructor(schemas: T, defaultValue: T[number]["defaultValue"]);
     }
     function anyOf<T extends readonly Generic<unknown>[]>(schemas: T, defaultValue: T[number]["defaultValue"]): AnyOf<T>;
+    class Optional<T extends Generic<unknown>> extends Generic<T["defaultValue"] | undefined> {
+        schema: T;
+        defaultValue: T["defaultValue"] | undefined;
+        constructor(schema: T, defaultValue?: T["defaultValue"] | undefined);
+    }
+    function optional<T extends Generic<unknown>>(schema: T, defaultValue?: T["defaultValue"] | undefined): Optional<T>;
 }

package/dist/kokimoki-schema.js

@@ -146,4 +146,18 @@ export 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 = {}));

package/dist/kokimoki-store.d.ts

@@ -1,7 +1,8 @@
 import * as Y from "yjs";
 import type { KokimokiSchema as S } from "./kokimoki-schema";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
-export declare class KokimokiStore<T extends S.Generic<unknown>> {
+import type { KokimokiClient } from "./kokimoki-client";
+export declare class KokimokiStore<T extends S.Generic<unknown>, SubscribeT = T["defaultValue"]> {
     readonly roomName: string;
     readonly mode: RoomSubscriptionMode;
     readonly doc: Y.Doc;
@@ -10,4 +11,8 @@ export declare class KokimokiStore<T extends S.Generic<unknown>> {
     readonly defaultValue: T["defaultValue"];
     readonly docRoot: Y.Map<unknown>;
     constructor(roomName: string, schema: T, mode?: RoomSubscriptionMode);
+    subscribe(set: (value: SubscribeT) => void): () => void;
+    onJoin(client: KokimokiClient): Promise<void>;
+    onBeforeLeave(client: KokimokiClient): Promise<void>;
+    onLeave(client: KokimokiClient): Promise<void>;
 }

package/dist/kokimoki-store.js

@@ -16,8 +16,8 @@ export class KokimokiStore {
         this.mode = mode;
         // Construct Y doc
         this.doc = new Y.Doc();
-        // Construct proxy object
         this.docRoot = this.doc.getMap("root");
+        // Construct proxy object
         this.proxy = yjsProxy();
         // @ts-ignore
         yjsBind(this.proxy, this.docRoot);
@@ -45,4 +45,15 @@ export class KokimokiStore {
         // Set default value
         this.defaultValue = schema.defaultValue;
     }
+    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) { }
 }

package/dist/kokimoki.min.d.ts

@@ -197,6 +197,12 @@ declare namespace KokimokiSchema {
         constructor(schemas: T, defaultValue: T[number]["defaultValue"]);
     }
     function anyOf<T extends readonly Generic<unknown>[]>(schemas: T, defaultValue: T[number]["defaultValue"]): AnyOf<T>;
+    class Optional<T extends Generic<unknown>> extends Generic<T["defaultValue"] | undefined> {
+        schema: T;
+        defaultValue: T["defaultValue"] | undefined;
+        constructor(schema: T, defaultValue?: T["defaultValue"] | undefined);
+    }
+    function optional<T extends Generic<unknown>>(schema: T, defaultValue?: T["defaultValue"] | undefined): Optional<T>;
 }
 
 declare enum RoomSubscriptionMode {
@@ -205,7 +211,7 @@ declare enum RoomSubscriptionMode {
     ReadWrite = "b"
 }
 
-declare class KokimokiStore<T extends KokimokiSchema.Generic<unknown>> {
+declare class KokimokiStore<T extends KokimokiSchema.Generic<unknown>, SubscribeT = T["defaultValue"]> {
     readonly roomName: string;
     readonly mode: RoomSubscriptionMode;
     readonly doc: Y.Doc;
@@ -214,6 +220,10 @@ declare class KokimokiStore<T extends KokimokiSchema.Generic<unknown>> {
     readonly defaultValue: T["defaultValue"];
     readonly docRoot: Y.Map<unknown>;
     constructor(roomName: string, schema: T, mode?: RoomSubscriptionMode);
+    subscribe(set: (value: SubscribeT) => void): () => void;
+    onJoin(client: KokimokiClient): Promise<void>;
+    onBeforeLeave(client: KokimokiClient): Promise<void>;
+    onLeave(client: KokimokiClient): Promise<void>;
 }
 
 declare class KokimokiQueue<Req extends KokimokiSchema.Generic<unknown>> extends KokimokiStore<KokimokiSchema.Dict<KokimokiSchema.Struct<{
@@ -279,6 +289,7 @@ declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     private _wsUrl;
     private _apiUrl;
     private _id?;
+    private _connectionId?;
     private _token?;
     private _apiHeaders?;
     private _serverTimeOffset;
@@ -287,14 +298,17 @@ declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     private _subscriptionsByName;
     private _subscriptionsByHash;
     private _subscribeReqPromises;
+    private _unsubscribeReqPromises;
     private _transactionPromises;
     private _connected;
     private _connectPromise?;
     private _messageId;
+    private _autoReconnect;
     private _reconnectTimeout;
     private _pingInterval;
     constructor(host: string, appId: string, code?: string);
     get id(): string;
+    get connectionId(): string;
     get token(): string;
     get apiUrl(): string;
     get apiHeaders(): Headers;
@@ -306,6 +320,7 @@ declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     private handleBinaryMessage;
     private handleErrorMessage;
     private handleSubscribeResMessage;
+    private handleUnsubscribeResMessage;
     private handleRoomUpdateMessage;
     serverTimestamp(): number;
     patchRoomState(room: string, update: Uint8Array): Promise<any>;
@@ -326,9 +341,12 @@ declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
         deletedCount: number;
     }>;
     exposeScriptingContext(context: any): Promise<void>;
-    private sendSubscriptionReq;
+    private sendSubscribeReq;
+    private sendUnsubscribeReq;
     join<T extends KokimokiSchema.Generic<unknown>>(store: KokimokiStore<T>): Promise<void>;
+    leave<T extends KokimokiSchema.Generic<unknown>>(store: KokimokiStore<T>): Promise<void>;
     transact(handler: (t: KokimokiTransaction) => void): Promise<void>;
+    close(): Promise<void>;
 }
 
 declare class RoomSubscription {
@@ -345,4 +363,16 @@ declare class RoomSubscription {
     close(): void;
 }
 
-export { BooleanField, ConstField, EnumField, Field, type FieldOptions, FloatField, Form, FormArray, FormGroup, ImageField, IntegerField, KokimokiClient, type KokimokiClientEvents, KokimokiQueue, KokimokiSchema, KokimokiStore, type Paginated, RoomSubscription, RoomSubscriptionMode, TextField, type Upload };
+declare class KokimokiAwareness extends KokimokiStore<KokimokiSchema.Dict<KokimokiSchema.Struct<{
+    clientId: KokimokiSchema.String;
+    lastPing: KokimokiSchema.Number;
+}>>> {
+    private _pingInterval;
+    private _kmClients;
+    constructor(roomName: string, mode?: RoomSubscriptionMode, pingTimeout?: number);
+    onJoin(client: KokimokiClient<any>): Promise<void>;
+    onBeforeLeave(client: KokimokiClient<any>): Promise<void>;
+    onLeave(client: KokimokiClient<any>): Promise<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 };