@kokimoki/app 0.5.3 → 0.6.1

package/dist/kokimoki-client.d.ts

@@ -6,9 +6,10 @@ import type { KokimokiClientEvents } from "./types/events";
 import type { Upload } from "./types/upload";
 import type { Paginated } from "./types/common";
 declare const KokimokiClient_base: new <T>() => TypedEmitter<KokimokiClientEvents<T>>;
-export declare class KokimokiClient<StatelessDataT = any> extends KokimokiClient_base<StatelessDataT> {
+export declare class KokimokiClient<StatelessDataT = any, ClientContextT = any> extends KokimokiClient_base<StatelessDataT> {
     readonly host: string;
     readonly appId: string;
+    readonly code: string;
     private _wsUrl;
     private _apiUrl;
     private _id?;
@@ -16,13 +17,17 @@ export declare class KokimokiClient<StatelessDataT = any> extends KokimokiClient
     private _apiHeaders?;
     private _providers;
     private _serverTimeOffset;
-    constructor(host: string, appId: string);
+    private _clientContext?;
+    private _synced;
+    constructor(host: string, appId: string, code?: string);
     get id(): string;
     get token(): string;
     get apiUrl(): string;
     get apiHeaders(): Headers;
+    get clientContext(): NonNullable<ClientContextT>;
     connect(): Promise<void>;
     serverTimestamp(): number;
+    private checkConnectionState;
     setProvider<T extends DocTypeDescription>(name: string, store: SyncedStore<T>): Promise<void>;
     removeProvider(name: string): void;
     getProvider(name: string): HocuspocusProvider | undefined;

package/dist/kokimoki-client.js

@@ -1,8 +1,10 @@
 import { HocuspocusProvider } from "@hocuspocus/provider";
 import EventEmitter from "events";
+import { KOKIMOKI_APP_VERSION } from "./version";
 export class KokimokiClient extends EventEmitter {
     host;
     appId;
+    code;
     _wsUrl;
     _apiUrl;
     _id;
@@ -10,10 +12,13 @@ export class KokimokiClient extends EventEmitter {
     _apiHeaders;
     _providers = new Map();
     _serverTimeOffset = 0;
-    constructor(host, appId) {
+    _clientContext;
+    _synced = false;
+    constructor(host, appId, code = "") {
         super();
         this.host = host;
         this.appId = appId;
+        this.code = code;
         // Set up the URLs
         const secure = this.host.indexOf(":") === -1;
         this._wsUrl = `ws${secure ? "s" : ""}://${this.host}`;
@@ -43,23 +48,30 @@ export class KokimokiClient extends EventEmitter {
         }
         return this._apiHeaders;
     }
+    get clientContext() {
+        if (!this._clientContext) {
+            throw new Error("Client not connected");
+        }
+        return this._clientContext;
+    }
     async connect() {
         // Fetch the auth token
         let clientToken = localStorage.getItem("KM_TOKEN");
         const startTime = Date.now();
-        const res = await fetch(`${this.apiUrl}/auth/token?appId=${this.appId}`, {
+        const res = await fetch(`${this.apiUrl}/auth/token?appId=${this.appId}&code=${this.code}`, {
             method: "GET",
             headers: new Headers({
                 "Content-Type": "application/json",
                 Authorization: `Bearer ${clientToken}`,
             }),
         });
-        const { clientId, appToken, serverTime, token } = await res.json();
+        const { clientId, appToken, serverTime, token, clientContext } = await res.json();
         const endTime = Date.now();
         const ping = Math.round((endTime - startTime) / 2);
         this._id = clientId;
         this._token = appToken;
         this._serverTimeOffset = Date.now() - serverTime - ping;
+        this._clientContext = clientContext;
         localStorage.setItem("KM_TOKEN", token);
         // Set up the auth headers
         this._apiHeaders = new Headers({
@@ -72,10 +84,24 @@ export class KokimokiClient extends EventEmitter {
                 provider.sendStateless("ping");
             });
         }, 30000);
+        // Initial connected state
+        this._synced = true;
+        this.emit("connected");
     }
     serverTimestamp() {
         return Date.now() - this._serverTimeOffset;
     }
+    checkConnectionState() {
+        const synced = !Array.from(this._providers.values()).some((provider) => provider.status !== "connected" || !provider.synced);
+        if (synced && !this._synced) {
+            this._synced = true;
+            this.emit("connected");
+        }
+        else if (!synced && this._synced) {
+            this._synced = false;
+            this.emit("disconnected");
+        }
+    }
     // Realtime database
     async setProvider(name, store) {
         const provider = new HocuspocusProvider({
@@ -83,10 +109,15 @@ export class KokimokiClient extends EventEmitter {
             name: `${this.appId}/${name}`,
             document: store.doc,
             token: this.token,
+            parameters: {
+                clientVersion: KOKIMOKI_APP_VERSION,
+            },
         });
-        this._providers.set(name, provider);
         // Handle incoming stateless messages
         provider.on("stateless", (e) => {
+            if (e.payload === "pong") {
+                return;
+            }
             const payload = JSON.parse(e.payload);
             this.emit("stateless", name, payload.from, payload.data);
         });
@@ -98,6 +129,20 @@ export class KokimokiClient extends EventEmitter {
             };
             provider.on("synced", handler);
         });
+        this._providers.set(name, provider);
+        this.checkConnectionState();
+        // Handle connection state changes
+        provider.on("disconnect", async () => {
+            // KokimokiClient is considered disconnected when any single provider is disconnected
+            this.checkConnectionState();
+            // Attempt to reconnect immediately with retries
+            await provider.connect();
+        });
+        provider.on("synced", () => {
+            if (provider.status === "connected") {
+                this.checkConnectionState();
+            }
+        });
     }
     removeProvider(name) {
         const provider = this._providers.get(name);
@@ -106,6 +151,8 @@ export class KokimokiClient extends EventEmitter {
         }
         provider.destroy();
         this._providers.delete(name);
+        // Connection state can change if the removed provider was not connected or synced
+        this.checkConnectionState();
     }
     getProvider(name) {
         return this._providers.get(name);

package/dist/types/events.d.ts

@@ -1,3 +1,5 @@
 export type KokimokiClientEvents<T> = {
     stateless: (room: string, from: string, data: T) => void;
+    connected: () => void;
+    disconnected: () => void;
 };

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const KOKIMOKI_APP_VERSION = "0.6.1";

package/dist/version.js

@@ -0,0 +1 @@
+export const KOKIMOKI_APP_VERSION = "0.6.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kokimoki/app",
-  "version": "0.5.3",
+  "version": "0.6.1",
   "type": "module",
   "description": "Kokimoki app",
   "main": "dist/index.js",
@@ -10,6 +10,7 @@
   ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
+    "prebuild": "node -p \"'export const KOKIMOKI_APP_VERSION = ' + JSON.stringify(require('./package.json').version) + ';'\" > src/version.ts",
     "build": "tsc",
     "dev": "tsc -w",
     "docs": "typedoc src/index.ts"

package/dist/types/tasks.d.ts

@@ -1,43 +0,0 @@
-export interface Answer<T = any> {
-    value?: T;
-    correct: boolean;
-}
-export interface TaskBase {
-    id: string;
-    text: string;
-    points: number;
-    metadata?: Record<string, any>;
-}
-export interface TaskOption {
-    text: string;
-    correct: boolean;
-}
-export interface MultipleChoiceTask extends TaskBase {
-    type: "multiple-choice";
-    answers: TaskOption[];
-}
-export interface SingleChoiceTask extends TaskBase {
-    type: "single-choice";
-    answers: TaskOption[];
-}
-export interface TextTask extends TaskBase {
-    type: "text";
-    answer: string;
-}
-export interface TextSurveyTask extends TaskBase {
-    type: "text-survey";
-}
-export interface NumericTask extends TaskBase {
-    type: "numeric";
-    answer: number;
-}
-export interface PhotoTask extends TaskBase {
-    type: "photo";
-}
-export interface VideoTask extends TaskBase {
-    type: "video";
-}
-export interface InfoTask extends TaskBase {
-    type: "info";
-}
-export type Task = MultipleChoiceTask | SingleChoiceTask | TextTask | NumericTask | TextSurveyTask | PhotoTask | VideoTask | InfoTask;

package/dist/types/tasks.js

@@ -1 +0,0 @@
-export {};