@kokimoki/app 0.0.9 → 0.2.0

package/dist/index.d.ts

@@ -1,6 +1,8 @@
-export * from "./types/api";
 export * from "./types/tasks";
+export * from "./types/common";
+export * from "./types/events";
+export * from "./types/upload";
 export * from "./fields";
 export * from "./kokimoki-client";
 export * from "./synced-store";
-export * from "@syncedstore/core";
+export * from "./user-media-handler";

package/dist/index.js

@@ -1,6 +1,8 @@
-export * from "./types/api";
 export * from "./types/tasks";
+export * from "./types/common";
+export * from "./types/events";
+export * from "./types/upload";
 export * from "./fields";
 export * from "./kokimoki-client";
 export * from "./synced-store";
-export * from "@syncedstore/core";
+export * from "./user-media-handler";

package/dist/kokimoki-client.d.ts

@@ -2,36 +2,28 @@ import { HocuspocusProvider } from "@hocuspocus/provider";
 import type TypedEmitter from "typed-emitter";
 import type { SyncedStore } from "./synced-store";
 import type { DocTypeDescription } from "@syncedstore/core/types/doc";
-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 _id;
-    private _token;
+    private _appId?;
+    private _wsUrl?;
+    private _apiUrl?;
+    private _clientId?;
+    private _token?;
     private _providers;
-    constructor(host: string, appId: string);
-    get id(): string;
+    constructor();
+    get clientId(): string;
+    get appId(): string;
     get token(): string;
-    connect(): Promise<void>;
+    get apiUrl(): string;
+    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;
     serverTimestamp(): number;
     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 declare const kmClient: KokimokiClient<any>;
 export {};

package/dist/kokimoki-client.js

@@ -1,30 +1,27 @@
 import { HocuspocusProvider } from "@hocuspocus/provider";
 import EventEmitter from "events";
-import { sendMediaUpload } from "./api/sendMediaUpload";
-import { getETags } from "./api/getETags";
-import { uploadMedia } from "./api/uploadMedia";
-import { errorMessage } from "./utils";
-import { fetchAuth } from "./api/fetchAuth";
 export class KokimokiClient extends EventEmitter {
-    appId;
     serverTimeOffset = 0;
-    wsUrl;
-    apiUrl;
-    _id = "";
-    _token = "";
+    _appId;
+    _wsUrl;
+    _apiUrl;
+    _clientId;
+    _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) {
+    get clientId() {
+        if (!this._clientId) {
+            throw new Error("Client not connected");
+        }
+        return this._clientId;
+    }
+    get appId() {
+        if (!this._appId) {
             throw new Error("Client not connected");
         }
-        return this._id;
+        return this._appId;
     }
     get token() {
         if (!this._token) {
@@ -32,25 +29,43 @@ export class KokimokiClient extends EventEmitter {
         }
         return this._token;
     }
-    async connect() {
+    get apiUrl() {
+        if (!this._apiUrl) {
+            throw new Error("Client not connected");
+        }
+        return this._apiUrl;
+    }
+    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,
-            clientToken,
-            apiUrl: this.apiUrl,
+        const res = await fetch(`${this.apiUrl}/auth/token?appId=${appId}`, {
+            method: "GET",
+            headers: new Headers({
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${clientToken}`,
+            }),
         });
+        const { clientId, appToken, serverTime, token } = await res.json();
         const endTime = Date.now();
         const ping = Math.round((endTime - startTime) / 2);
-        this._id = clientId;
+        this._clientId = clientId;
         this._token = appToken;
         this.serverTimeOffset = Date.now() - serverTime - ping;
         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,
         });
@@ -97,78 +112,5 @@ export class KokimokiClient extends EventEmitter {
         }
         provider.sendStateless(JSON.stringify({ data, self }));
     }
-    async mediaUpload(blob) {
-        try {
-            const uploadData = await sendMediaUpload(blob, {
-                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 });
-            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");
-    }
 }
+export const kmClient = new KokimokiClient();

package/dist/kokimoki-storage.d.ts

@@ -0,0 +1,15 @@
+import type { Upload } from "./types/upload";
+export declare class KokimokiStorage {
+    private createUpload;
+    private uploadChunks;
+    private completeUpload;
+    upload(name: string, blob: Blob, tags?: string[]): Promise<Upload>;
+    listUploads(filter?: {
+        clientId?: string;
+        mimeTypes?: string[];
+    }, skip?: number, limit?: number): Promise<{
+        total: any;
+        items: any;
+    }>;
+}
+export declare const kmStorage: KokimokiStorage;

package/dist/kokimoki-storage.js

@@ -0,0 +1,64 @@
+import { kmClient } from "./kokimoki-client";
+export class KokimokiStorage {
+    async createUpload(name, blob, tags) {
+        const res = await fetch(`${kmClient.apiUrl}/uploads`, {
+            method: "POST",
+            headers: new Headers({
+                Authorization: `Bearer ${kmClient.token}`,
+                "Content-Type": "application/json",
+            }),
+            body: JSON.stringify({
+                name,
+                size: blob.size,
+                mimeType: blob.type,
+                tags,
+            }),
+        });
+        return await res.json();
+    }
+    async uploadChunks(blob, chunkSize, signedUrls) {
+        return await Promise.all(signedUrls.map(async (url, index) => {
+            const start = index * chunkSize;
+            const end = Math.min(start + chunkSize, blob.size);
+            const chunk = blob.slice(start, end);
+            const res = await fetch(url, { method: "PUT", body: chunk });
+            return JSON.parse(res.headers.get("ETag") || '""');
+        }));
+    }
+    async completeUpload(id, etags) {
+        const res = await fetch(`${kmClient.apiUrl}/uploads/${id}`, {
+            method: "PUT",
+            headers: new Headers({
+                Authorization: `Bearer ${kmClient.token}`,
+                "Content-Type": "application/json",
+            }),
+            body: JSON.stringify({ etags }),
+        });
+        return await res.json();
+    }
+    async upload(name, blob, tags = []) {
+        const { id, chunkSize, urls } = await this.createUpload(name, blob, tags);
+        const etags = await this.uploadChunks(blob, chunkSize, urls);
+        return await this.completeUpload(id, etags);
+    }
+    async listUploads(filter = {}, skip = 0, limit = 100) {
+        const url = new URL("/uploads", kmClient.apiUrl);
+        url.searchParams.set("skip", skip.toString());
+        url.searchParams.set("limit", limit.toString());
+        if (filter.clientId) {
+            url.searchParams.set("clientId", filter.clientId);
+        }
+        if (filter.mimeTypes) {
+            url.searchParams.set("mimeTypes", filter.mimeTypes.join());
+        }
+        const res = await fetch(url.href, {
+            headers: new Headers({
+                Authorization: `Bearer ${kmClient.token}`,
+                "Content-Type": "application/json",
+            }),
+        });
+        const { total, items } = await res.json();
+        return { total, items };
+    }
+}
+export const kmStorage = new KokimokiStorage();

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/types/upload.d.ts

@@ -0,0 +1,12 @@
+export interface Upload {
+    id: string;
+    appId: string;
+    clientId: string;
+    createdAt: Date;
+    name: string;
+    url: string;
+    size: number;
+    mimeType: string;
+    completed: boolean;
+    tags: string[];
+}

package/dist/types/upload.js

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

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

@@ -0,0 +1,16 @@
+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 declare const userMediaHandler: UserMediaHandler;
+export {};

package/dist/user-media-handler.js

@@ -0,0 +1,62 @@
+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");
+    }
+}
+export const userMediaHandler = new UserMediaHandler();

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.2.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": {