@kokimoki/app 0.5.2 → 0.6.0

package/dist/fields.d.ts

@@ -54,6 +54,14 @@ export declare class IntegerField extends Field<number> {
         default: number;
     };
 }
+export declare class FloatField extends Field<number> {
+    value: number;
+    constructor(value: number, options?: FieldOptions);
+    get schema(): {
+        type: string;
+        default: number;
+    };
+}
 export declare class FormGroup<T extends Record<string, Field<any>>, O extends Record<string, Field<any>>> extends Field<{
     [key in keyof T]: T[key]["value"];
 } & Partial<{

package/dist/fields.js

@@ -83,6 +83,19 @@ export class IntegerField extends Field {
         };
     }
 }
+export class FloatField extends Field {
+    value;
+    constructor(value, options = defaultFieldOptions) {
+        super(options);
+        this.value = value;
+    }
+    get schema() {
+        return {
+            type: "number",
+            default: this.value,
+        };
+    }
+}
 export class FormGroup extends Field {
     requiredFields;
     optionalFields;

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,18 @@ export declare class KokimokiClient<StatelessDataT = any> extends KokimokiClient
     private _apiHeaders?;
     private _providers;
     private _serverTimeOffset;
-    constructor(host: string, appId: string);
+    private _clientContext?;
+    private _lastPong;
+    private _connected;
+    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 receivePong;
     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,14 @@ export class KokimokiClient extends EventEmitter {
     _apiHeaders;
     _providers = new Map();
     _serverTimeOffset = 0;
-    constructor(host, appId) {
+    _clientContext;
+    _lastPong = 0;
+    _connected = 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 +49,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({
@@ -71,11 +84,28 @@ export class KokimokiClient extends EventEmitter {
             this._providers.forEach((provider) => {
                 provider.sendStateless("ping");
             });
-        }, 30000);
+            // Emit disconnected event if no receiver has replied to the ping
+            if (this._connected &&
+                this._providers.size &&
+                this._lastPong < Date.now() - 10000) {
+                this.emit("disconnected");
+                this._connected = false;
+            }
+        }, 10000);
+        // Emit initial connected event
+        this.emit("connected");
+        this._connected = true;
     }
     serverTimestamp() {
         return Date.now() - this._serverTimeOffset;
     }
+    receivePong() {
+        this._lastPong = Date.now();
+        if (!this._connected) {
+            this.emit("connected");
+            this._connected = true;
+        }
+    }
     // Realtime database
     async setProvider(name, store) {
         const provider = new HocuspocusProvider({
@@ -83,10 +113,16 @@ 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") {
+                this.receivePong();
+                return;
+            }
             const payload = JSON.parse(e.payload);
             this.emit("stateless", name, payload.from, payload.data);
         });
@@ -98,6 +134,8 @@ export class KokimokiClient extends EventEmitter {
             };
             provider.on("synced", handler);
         });
+        this.receivePong();
+        this._providers.set(name, provider);
     }
     removeProvider(name) {
         const provider = 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.0";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kokimoki/app",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "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 {};