@kokimoki/app 0.2.5 → 0.3.0

package/dist/index.d.ts

@@ -5,5 +5,3 @@ export * from "./types/upload";
 export * from "./fields";
 export * from "./kokimoki-client";
 export * from "./synced-store";
-export * from "./user-media-handler";
-export * from "./kokimoki-storage";

package/dist/index.js

@@ -5,5 +5,3 @@ export * from "./types/upload";
 export * from "./fields";
 export * from "./kokimoki-client";
 export * from "./synced-store";
-export * from "./user-media-handler";
-export * from "./kokimoki-storage";

package/dist/kokimoki-client.d.ts

@@ -3,27 +3,38 @@ import type TypedEmitter from "typed-emitter";
 import type { SyncedStore } from "./synced-store";
 import type { DocTypeDescription } from "@syncedstore/core/types/doc";
 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> {
-    serverTimeOffset: number;
-    private _appId?;
-    private _wsUrl?;
-    private _apiUrl?;
+    readonly host: string;
+    readonly appId: string;
+    private _wsUrl;
+    private _apiUrl;
     private _id?;
     private _token?;
+    private _apiHeaders?;
     private _providers;
-    constructor();
+    private _serverTimeOffset;
+    constructor(host: string, appId: string);
     get id(): string;
-    get appId(): string;
     get token(): string;
     get apiUrl(): string;
-    connect(host: string, appId: string): Promise<void>;
+    get apiHeaders(): Headers;
+    connect(): Promise<void>;
+    serverTimestamp(): number;
     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;
+    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<Paginated<Upload>>;
 }
-export declare const kmClient: KokimokiClient<any>;
 export {};

package/dist/kokimoki-client.js

@@ -1,15 +1,23 @@
 import { HocuspocusProvider } from "@hocuspocus/provider";
 import EventEmitter from "events";
 export class KokimokiClient extends EventEmitter {
-    serverTimeOffset = 0;
-    _appId;
+    host;
+    appId;
     _wsUrl;
     _apiUrl;
     _id;
     _token;
+    _apiHeaders;
     _providers = new Map();
-    constructor() {
+    _serverTimeOffset = 0;
+    constructor(host, appId) {
         super();
+        this.host = host;
+        this.appId = appId;
+        // Set up the URLs
+        const secure = this.host.indexOf(":") === -1;
+        this._wsUrl = `ws${secure ? "s" : ""}://${this.host}`;
+        this._apiUrl = `http${secure ? "s" : ""}://${this.host}`;
     }
     get id() {
         if (!this._id) {
@@ -17,12 +25,6 @@ export class KokimokiClient extends EventEmitter {
         }
         return this._id;
     }
-    get appId() {
-        if (!this._appId) {
-            throw new Error("Client not connected");
-        }
-        return this._appId;
-    }
     get token() {
         if (!this._token) {
             throw new Error("Client not connected");
@@ -35,16 +37,17 @@ export class KokimokiClient extends EventEmitter {
         }
         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}`;
+    get apiHeaders() {
+        if (!this._apiHeaders) {
+            throw new Error("Client not connected");
+        }
+        return this._apiHeaders;
+    }
+    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=${appId}`, {
+        const res = await fetch(`${this.apiUrl}/auth/token?appId=${this.appId}`, {
             method: "GET",
             headers: new Headers({
                 "Content-Type": "application/json",
@@ -56,8 +59,13 @@ export class KokimokiClient extends EventEmitter {
         const ping = Math.round((endTime - startTime) / 2);
         this._id = clientId;
         this._token = appToken;
-        this.serverTimeOffset = Date.now() - serverTime - ping;
+        this._serverTimeOffset = Date.now() - serverTime - ping;
         localStorage.setItem("KM_TOKEN", token);
+        // Set up the auth headers
+        this._apiHeaders = new Headers({
+            Authorization: `Bearer ${this.token}`,
+            "Content-Type": "application/json",
+        });
         // Ping interval
         setInterval(() => {
             this._providers.forEach((provider) => {
@@ -65,13 +73,14 @@ export class KokimokiClient extends EventEmitter {
             });
         }, 30000);
     }
+    serverTimestamp() {
+        return Date.now() - this._serverTimeOffset;
+    }
+    // Realtime database
     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}`,
+            name: `${this.appId}/${name}`,
             document: store.doc,
             token: this.token,
         });
@@ -101,9 +110,6 @@ export class KokimokiClient extends EventEmitter {
     getProvider(name) {
         return this._providers.get(name);
     }
-    serverTimestamp() {
-        return Date.now() - this.serverTimeOffset;
-    }
     sendStatelessToClient(room, clientId, data) {
         const provider = this._providers.get(room);
         if (!provider) {
@@ -118,5 +124,55 @@ export class KokimokiClient extends EventEmitter {
         }
         provider.sendStateless(JSON.stringify({ data, self }));
     }
+    // Storage
+    async createUpload(name, blob, tags) {
+        const res = await fetch(`${this._apiUrl}/uploads`, {
+            method: "POST",
+            headers: this.apiHeaders,
+            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(`${this._apiUrl}/uploads/${id}`, {
+            method: "PUT",
+            headers: this.apiHeaders,
+            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", this._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: this.apiHeaders,
+        });
+        return await res.json();
+    }
 }
-export const kmClient = new KokimokiClient();

package/dist/types/common.d.ts

@@ -1,4 +1,3 @@
-export type FacingMode = "user" | "environment";
 export interface Paginated<T> {
     items: T[];
     total: number;

package/dist/types/events.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kokimoki/app",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "type": "module",
   "description": "Kokimoki app",
   "main": "dist/index.js",

package/dist/api/abortMediaUpload.d.ts

@@ -1,2 +0,0 @@
-import type { FetchParams } from "../types/api";
-export declare function abortMediaUpload(id: string, { apiUrl, appToken, signal }: FetchParams): Promise<void>;

package/dist/api/abortMediaUpload.js

@@ -1,12 +0,0 @@
-import { getHeaders } from "../utils";
-export async function abortMediaUpload(id, { apiUrl, appToken, signal }) {
-    const res = await fetch(`${apiUrl}/upload/${id}`, {
-        method: "DELETE",
-        headers: getHeaders(appToken),
-        signal,
-    });
-    // TODO: Improve error handling
-    if (res.status !== 200) {
-        throw await res.json();
-    }
-}

package/dist/api/fetchAuth.d.ts

@@ -1,2 +0,0 @@
-import type { AuthFetchParams, AuthResponse } from "../types/api";
-export declare function fetchAuth({ apiUrl, clientToken, appId, }: AuthFetchParams): Promise<AuthResponse>;

package/dist/api/fetchAuth.js

@@ -1,12 +0,0 @@
-import { getHeaders } from "../utils";
-export async function fetchAuth({ apiUrl, clientToken, appId, }) {
-    const res = await fetch(`${apiUrl}/auth/token?appId=${appId}`, {
-        method: "GET",
-        headers: getHeaders(clientToken),
-    });
-    // TODO: Improve error handling
-    if (res.status !== 200) {
-        throw await res.json();
-    }
-    return await res.json();
-}

package/dist/api/getETags.d.ts

@@ -1,2 +0,0 @@
-import type { SendUploadResponse } from "../types/api";
-export declare function getETags(blob: Blob, { urls, chunkSize }: SendUploadResponse): Promise<string[]>;

package/dist/api/getETags.js

@@ -1,18 +0,0 @@
-// TODO: Improve method below
-export async function getETags(blob, { urls, chunkSize }) {
-    const uploadData = [];
-    for (let index = 0; index < urls.length; ++index) {
-        const url = urls[index];
-        uploadData.push({
-            url,
-            body: index < urls.length - 1
-                ? blob.slice(index * chunkSize, (index + 1) * chunkSize)
-                : blob.slice(index * chunkSize),
-        });
-    }
-    const responses = await Promise.all(uploadData.map(({ url, body }) => fetch(url, {
-        method: "PUT",
-        body,
-    })));
-    return responses.map((response) => JSON.parse(response.headers.get("ETag") || '""'));
-}

package/dist/api/sendMediaUpload.d.ts

@@ -1,2 +0,0 @@
-import type { FetchParams, SendUploadResponse } from "../types/api";
-export declare function sendMediaUpload(blob: Blob, { apiUrl, appToken, signal }: FetchParams): Promise<SendUploadResponse>;

package/dist/api/sendMediaUpload.js

@@ -1,20 +0,0 @@
-import ObjectId from "bson-objectid";
-import { getHeaders } from "../utils";
-export async function sendMediaUpload(blob, { apiUrl, appToken, signal }) {
-    const objectId = new ObjectId().toHexString();
-    const res = await fetch(`${apiUrl}/upload`, {
-        method: "POST",
-        headers: getHeaders(appToken),
-        body: JSON.stringify({
-            name: objectId,
-            size: blob.size,
-            mimeType: blob.type,
-        }),
-        signal,
-    });
-    // TODO: Improve error handling
-    if (res.status !== 200) {
-        throw await res.json();
-    }
-    return await res.json();
-}

package/dist/api/uploadMedia.d.ts

@@ -1,2 +0,0 @@
-import type { FetchParams, UploadMediaRequest, UploadMediaResponse } from "../types/api";
-export declare function uploadMedia({ id, etags }: UploadMediaRequest, { apiUrl, appToken, signal }: FetchParams): Promise<UploadMediaResponse>;

package/dist/api/uploadMedia.js

@@ -1,14 +0,0 @@
-import { getHeaders } from "../utils";
-export async function uploadMedia({ id, etags }, { apiUrl, appToken, signal }) {
-    const res = await fetch(`${apiUrl}/upload/${id}`, {
-        method: "PUT",
-        headers: getHeaders(appToken),
-        body: JSON.stringify({ etags }),
-        signal,
-    });
-    // TODO: Improve error handling
-    if (res.status !== 200) {
-        throw await res.json();
-    }
-    return await res.json();
-}

package/dist/kokimoki-storage.d.ts

@@ -1,13 +0,0 @@
-import type { Paginated } from "./types/common";
-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<Paginated<Upload>>;
-}
-export declare const kmStorage: KokimokiStorage;

package/dist/kokimoki-storage.js

@@ -1,63 +0,0 @@
-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",
-            }),
-        });
-        return await res.json();
-    }
-}
-export const kmStorage = new KokimokiStorage();

package/dist/types/api.d.ts

@@ -1,36 +0,0 @@
-export interface SendUploadResponse {
-    id: string;
-    urls: string[];
-    chunkSize: number;
-}
-export interface UploadMediaResponse {
-    url: string;
-}
-export interface AuthResponse {
-    serverTime: number;
-    appToken: string;
-    token: string;
-    clientId: string;
-}
-export interface MediaUploadData {
-    url: string;
-    body: Blob;
-}
-export interface FetchParams {
-    apiUrl: string;
-    appToken: string;
-    signal?: AbortSignal;
-}
-export interface AuthFetchParams {
-    apiUrl: string;
-    clientToken: string | null;
-    appId: string;
-}
-export interface UploadMediaRequest {
-    etags: string[];
-    id: string;
-}
-export interface UploadedMedia {
-    id: string;
-    url: string;
-}

package/dist/types/api.js

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

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

@@ -1,16 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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,2 +0,0 @@
-export declare function getHeaders(token: string | null): Headers;
-export declare function errorMessage(error: unknown): string;

package/dist/utils.js

@@ -1,19 +0,0 @@
-export function getHeaders(token) {
-    return token
-        ? new Headers({
-            Authorization: `Bearer ${token}`,
-            "Content-Type": "application/json",
-        })
-        : new Headers();
-}
-export function errorMessage(error) {
-    if (typeof error === "string")
-        return error;
-    if (typeof error !== "object" && typeof error !== "function")
-        return "Unknown error";
-    // TODO: Extend errors check
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return "Unknown error";
-}