@kokimoki/app 0.0.9 → 0.1.0

package/dist/index.d.ts

@@ -1,6 +1,11 @@
+import { KokimokiClient } from "./kokimoki-client";
+import { UserMediaHandler } from "./user-media-handler";
 export * from "./types/api";
 export * from "./types/tasks";
+export * from "./types/common";
+export * from "./types/events";
 export * from "./fields";
 export * from "./kokimoki-client";
 export * from "./synced-store";
-export * from "@syncedstore/core";
+export declare const kmClient: KokimokiClient<any>;
+export declare const userMediaHandler: UserMediaHandler;

package/dist/index.js

@@ -1,6 +1,11 @@
+import { KokimokiClient } from "./kokimoki-client";
+import { UserMediaHandler } from "./user-media-handler";
 export * from "./types/api";
 export * from "./types/tasks";
+export * from "./types/common";
+export * from "./types/events";
 export * from "./fields";
 export * from "./kokimoki-client";
 export * from "./synced-store";
-export * from "@syncedstore/core";
+export const kmClient = new KokimokiClient();
+export const userMediaHandler = new UserMediaHandler();

package/dist/kokimoki-client.d.ts

@@ -6,17 +6,17 @@ import type { UploadedMedia } from "./types/api";
 import type { KokimokiClientEvents } from "./types/events";
 declare const KokimokiClient_base: new <T>() => TypedEmitter<KokimokiClientEvents<T>>;
 export declare class KokimokiClient<StatelessDataT = any> extends KokimokiClient_base<StatelessDataT> {
-    readonly appId: string;
     serverTimeOffset: number;
-    wsUrl: string;
-    apiUrl: string;
+    private _appId?;
+    private _wsUrl?;
+    private _apiUrl?;
     private _id;
     private _token;
     private _providers;
-    constructor(host: string, appId: string);
+    constructor();
     get id(): string;
     get token(): string;
-    connect(): Promise<void>;
+    connect(host: string, appId: string): Promise<void>;
     setProvider<T extends DocTypeDescription>(name: string, store: SyncedStore<T>): Promise<void>;
     removeProvider(name: string): void;
     getProvider(name: string): HocuspocusProvider | undefined;
@@ -24,14 +24,5 @@ export declare class KokimokiClient<StatelessDataT = any> extends KokimokiClient
     sendStatelessToClient(room: string, clientId: string, data: StatelessDataT): void;
     sendStatelessToRoom(room: string, data: StatelessDataT, self?: boolean): void;
     mediaUpload(blob: Blob): Promise<UploadedMedia>;
-    private _facingMode;
-    private _stream;
-    private _mediaRequests;
-    requestMediaStream(): void;
-    releaseMediaStream(): void;
-    private closeMediaStream;
-    private updateMediaStream;
-    setFacingMode(facingMode: "user" | "environment"): void;
-    toggleFacingMode(): void;
 }
 export {};

package/dist/kokimoki-client.js

@@ -6,19 +6,15 @@ import { uploadMedia } from "./api/uploadMedia";
 import { errorMessage } from "./utils";
 import { fetchAuth } from "./api/fetchAuth";
 export class KokimokiClient extends EventEmitter {
-    appId;
     serverTimeOffset = 0;
-    wsUrl;
-    apiUrl;
+    _appId;
+    _wsUrl;
+    _apiUrl;
     _id = "";
     _token = "";
     _providers = new Map();
-    constructor(host, appId) {
+    constructor() {
         super();
-        this.appId = appId;
-        const secure = host.indexOf(":") === -1;
-        this.wsUrl = `ws${secure ? "s" : ""}://${host}`;
-        this.apiUrl = `http${secure ? "s" : ""}://${host}`;
     }
     get id() {
         if (!this._id) {
@@ -32,13 +28,19 @@ export class KokimokiClient extends EventEmitter {
         }
         return this._token;
     }
-    async connect() {
+    async connect(host, appId) {
+        this._appId = appId;
+        // Set up the URLs
+        const secure = host.indexOf(":") === -1;
+        this._wsUrl = `ws${secure ? "s" : ""}://${host}`;
+        this._apiUrl = `http${secure ? "s" : ""}://${host}`;
+        // Fetch the auth token
         let clientToken = localStorage.getItem("KM_TOKEN");
         const startTime = Date.now();
         const { clientId, appToken, serverTime, token } = await fetchAuth({
-            appId: this.appId,
+            appId,
             clientToken,
-            apiUrl: this.apiUrl,
+            apiUrl: this._apiUrl,
         });
         const endTime = Date.now();
         const ping = Math.round((endTime - startTime) / 2);
@@ -48,9 +50,12 @@ export class KokimokiClient extends EventEmitter {
         localStorage.setItem("KM_TOKEN", token);
     }
     async setProvider(name, store) {
+        if (!this._wsUrl || !this._appId) {
+            throw new Error("Client not connected");
+        }
         const provider = new HocuspocusProvider({
-            url: `${this.wsUrl}/connection`,
-            name: `${this.appId}/${name}`,
+            url: `${this._wsUrl}/connection`,
+            name: `${this._appId}/${name}`,
             document: store.doc,
             token: this.token,
         });
@@ -98,77 +103,21 @@ export class KokimokiClient extends EventEmitter {
         provider.sendStateless(JSON.stringify({ data, self }));
     }
     async mediaUpload(blob) {
+        if (!this._apiUrl) {
+            throw new Error("Client not connected");
+        }
         try {
             const uploadData = await sendMediaUpload(blob, {
-                apiUrl: this.apiUrl,
+                apiUrl: this._apiUrl,
                 appToken: this.token,
             });
             const { id } = uploadData;
             const etags = await getETags(blob, uploadData);
-            const { url } = await uploadMedia({ id, etags }, { apiUrl: this.apiUrl, appToken: this.token });
+            const { url } = await uploadMedia({ id, etags }, { apiUrl: this._apiUrl, appToken: this.token });
             return { url, id };
         }
         catch (error) {
             throw new Error(`Error while uploading media: ${errorMessage(error)}`);
         }
     }
-    // User media
-    _facingMode = "environment";
-    _stream = null;
-    _mediaRequests = 0;
-    requestMediaStream() {
-        this._mediaRequests++;
-        this.updateMediaStream();
-    }
-    releaseMediaStream() {
-        this._mediaRequests--;
-        if (this._mediaRequests <= 0) {
-            this.closeMediaStream();
-            this._mediaRequests = 0;
-        }
-    }
-    closeMediaStream() {
-        if (!this._stream) {
-            return;
-        }
-        this.emit("media-stream", null, this._facingMode, null);
-        this._stream.getTracks().forEach((track) => track.stop());
-        this._stream = null;
-    }
-    async updateMediaStream() {
-        this.closeMediaStream();
-        try {
-            this._stream = await navigator.mediaDevices.getUserMedia({
-                video: {
-                    facingMode: this._facingMode,
-                    frameRate: { ideal: 24, max: 30 },
-                },
-                audio: true,
-            });
-            this.emit("media-stream", null, this._facingMode, this._stream);
-        }
-        catch (err) {
-            this._stream = null;
-            if ((err + "").match(/^NotReadableError/)) {
-                await new Promise((resolve) => {
-                    setTimeout(async () => {
-                        await this.updateMediaStream();
-                        resolve();
-                    }, 1000);
-                });
-                return;
-            }
-            this.emit("media-stream", err + "", this._facingMode, null);
-        }
-    }
-    setFacingMode(facingMode) {
-        if (this._facingMode === facingMode) {
-            return;
-        }
-        this._facingMode = facingMode;
-        this.updateMediaStream();
-    }
-    toggleFacingMode() {
-        this.setFacingMode(this._facingMode === "user" ? "environment" : "user");
-    }
 }

package/dist/types/common.d.ts

@@ -0,0 +1 @@
+export type FacingMode = "user" | "environment";

package/dist/types/common.js

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

package/dist/types/events.d.ts

@@ -1,4 +1,6 @@
 export type KokimokiClientEvents<T> = {
     stateless: (room: string, from: string, data: T) => void;
-    "media-stream": (error: string | null, facingMode: "user" | "environment", stream: MediaStream | null) => void;
+};
+export type UserMediaHandlerEvents = {
+    stream: (error: string | null, facingMode: "user" | "environment", stream: MediaStream | null) => void;
 };

package/dist/user-media-handler.d.ts

@@ -0,0 +1,15 @@
+import type TypedEmitter from "typed-emitter";
+import type { UserMediaHandlerEvents } from "./types/events";
+declare const UserMediaHandler_base: new () => TypedEmitter<UserMediaHandlerEvents>;
+export declare class UserMediaHandler extends UserMediaHandler_base {
+    private _facingMode;
+    private _stream;
+    private _mediaRequests;
+    requestMediaStream(): void;
+    releaseMediaStream(): void;
+    private closeMediaStream;
+    private updateMediaStream;
+    setFacingMode(facingMode: "user" | "environment"): void;
+    toggleFacingMode(): void;
+}
+export {};

package/dist/user-media-handler.js

@@ -0,0 +1,61 @@
+import EventEmitter from "events";
+export class UserMediaHandler extends EventEmitter {
+    _facingMode = "environment";
+    _stream = null;
+    _mediaRequests = 0;
+    requestMediaStream() {
+        this._mediaRequests++;
+        this.updateMediaStream();
+    }
+    releaseMediaStream() {
+        this._mediaRequests--;
+        if (this._mediaRequests <= 0) {
+            this.closeMediaStream();
+            this._mediaRequests = 0;
+        }
+    }
+    closeMediaStream() {
+        if (!this._stream) {
+            return;
+        }
+        this.emit("stream", null, this._facingMode, null);
+        this._stream.getTracks().forEach((track) => track.stop());
+        this._stream = null;
+    }
+    async updateMediaStream() {
+        this.closeMediaStream();
+        try {
+            this._stream = await navigator.mediaDevices.getUserMedia({
+                video: {
+                    facingMode: this._facingMode,
+                    frameRate: { ideal: 24, max: 30 },
+                },
+                audio: true,
+            });
+            this.emit("stream", null, this._facingMode, this._stream);
+        }
+        catch (err) {
+            this._stream = null;
+            if ((err + "").match(/^NotReadableError/)) {
+                await new Promise((resolve) => {
+                    setTimeout(async () => {
+                        await this.updateMediaStream();
+                        resolve();
+                    }, 1000);
+                });
+                return;
+            }
+            this.emit("stream", err + "", this._facingMode, null);
+        }
+    }
+    setFacingMode(facingMode) {
+        if (this._facingMode === facingMode) {
+            return;
+        }
+        this._facingMode = facingMode;
+        this.updateMediaStream();
+    }
+    toggleFacingMode() {
+        this.setFacingMode(this._facingMode === "user" ? "environment" : "user");
+    }
+}

package/dist/utils.d.ts

@@ -1,6 +1,2 @@
-export declare function wait(msDelay: number): Promise<unknown>;
-export declare function hasOwnProperty<P extends PropertyKey>(obj: object, property: P): obj is {
-    [p in P]: unknown;
-};
 export declare function getHeaders(token: string | null): Headers;
 export declare function errorMessage(error: unknown): string;

package/dist/utils.js

@@ -1,9 +1,3 @@
-export function wait(msDelay) {
-    return new Promise((resolve) => setTimeout(resolve, msDelay));
-}
-export function hasOwnProperty(obj, property) {
-    return Object.prototype.hasOwnProperty.call(obj, property);
-}
 export function getHeaders(token) {
     return token
         ? new Headers({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kokimoki/app",
-  "version": "0.0.9",
+  "version": "0.1.0",
   "type": "module",
   "description": "Kokimoki app",
   "main": "dist/index.js",
@@ -11,12 +11,14 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc",
-    "dev": "tsc -w"
+    "dev": "tsc -w",
+    "docs": "typedoc src/index.ts"
   },
   "author": "Loquiz OÜ",
   "license": "Apache-2.0",
   "devDependencies": {
     "@types/ws": "^8.5.5",
+    "typedoc": "^0.24.8",
     "typescript": "^5.1.6"
   },
   "dependencies": {