@kokimoki/app 0.0.0 → 0.0.1

package/dist/api/abortMediaUpload.d.ts

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

package/dist/api/abortMediaUpload.js

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

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

package/dist/api/fetchAuth.js

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

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

package/dist/api/getETags.js

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

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

package/dist/api/sendMediaUpload.js

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

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

package/dist/api/uploadMedia.js

@@ -0,0 +1,14 @@
+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/fields.d.ts

@@ -0,0 +1,67 @@
+import type { Task } from "./types/tasks";
+export interface FieldOptions {
+    label?: string;
+    optional: boolean;
+}
+export declare abstract class Field<T> {
+    readonly options: FieldOptions;
+    constructor(options: FieldOptions);
+    abstract get value(): T;
+    abstract get schema(): any;
+}
+export declare class ImageField extends Field<string> {
+    value: string;
+    constructor(value: string, options?: FieldOptions);
+    get schema(): {
+        type: string;
+        default: string;
+    };
+}
+export declare class TextField extends Field<string> {
+    value: string;
+    constructor(value: string, options?: FieldOptions);
+    get schema(): {
+        type: string;
+        default: string;
+    };
+}
+export declare class IntegerField extends Field<number> {
+    value: number;
+    constructor(value: number, options?: FieldOptions);
+    get schema(): {
+        type: string;
+        default: number;
+    };
+}
+export declare class FormGroup<T extends Record<string, any>> extends Field<{
+    [key in keyof T]: Field<T>["value"];
+}> {
+    fields: T;
+    constructor(fields: T, options?: FieldOptions);
+    get value(): {
+        [key in keyof T]: T[key]["value"];
+    };
+    get schema(): {
+        type: string;
+        properties: any;
+    };
+}
+export declare class FormArray<T> extends Field<T[]> {
+    private factory;
+    value: Field<T>["value"][];
+    constructor(factory: () => Field<T>, value: Field<T>["value"][], options?: FieldOptions);
+    get schema(): {
+        type: string;
+        items: any;
+    };
+}
+export declare class TaskField extends Field<Task> {
+    value: Task;
+    constructor(value: Task, options?: FieldOptions);
+    get schema(): {
+        type: string;
+        properties: {};
+    };
+}
+export declare class Form<T extends Record<string, Field<any>>> extends FormGroup<T> {
+}

package/dist/fields.js

@@ -0,0 +1,102 @@
+const defaultFieldOptions = {
+    optional: false,
+};
+export class Field {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+}
+export class ImageField extends Field {
+    value;
+    constructor(value, options = defaultFieldOptions) {
+        super(options);
+        this.value = value;
+    }
+    get schema() {
+        return {
+            type: "string",
+            default: this.value,
+        };
+    }
+}
+export class TextField extends Field {
+    value;
+    constructor(value, options = defaultFieldOptions) {
+        super(options);
+        this.value = value;
+    }
+    get schema() {
+        return {
+            type: "string",
+            default: this.value,
+        };
+    }
+}
+export class IntegerField extends Field {
+    value;
+    constructor(value, options = defaultFieldOptions) {
+        super(options);
+        this.value = value;
+    }
+    get schema() {
+        return {
+            type: "integer",
+            default: this.value,
+        };
+    }
+}
+export class FormGroup extends Field {
+    fields;
+    constructor(fields, options = defaultFieldOptions) {
+        super(options);
+        this.fields = fields;
+    }
+    get value() {
+        return Object.entries(this.fields).reduce((acc, [key, field]) => {
+            acc[key] = field.value;
+            return acc;
+        }, {});
+    }
+    get schema() {
+        return {
+            type: "object",
+            properties: Object.entries(this.fields).reduce((acc, [key, field]) => {
+                acc[key] = field.schema;
+                return acc;
+            }, {}),
+        };
+    }
+}
+export class FormArray extends Field {
+    factory;
+    value;
+    constructor(factory, value, options = defaultFieldOptions) {
+        super(options);
+        this.factory = factory;
+        this.value = value;
+    }
+    get schema() {
+        const field = this.factory();
+        return {
+            type: "array",
+            items: field.schema,
+        };
+    }
+}
+export class TaskField extends Field {
+    value;
+    constructor(value, options = defaultFieldOptions) {
+        super(options);
+        this.value = value;
+    }
+    get schema() {
+        // TODO: validate task interface, not important right now
+        return {
+            type: "object",
+            properties: {},
+        };
+    }
+}
+export class Form extends FormGroup {
+}

package/{src/index.ts → dist/index.d.ts}

@@ -1,4 +1,4 @@
-export * from "./tasks";
+export * from "./types";
 export * from "./fields";
 export * from "./kokimoki-client";
 export * from "./synced-store";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./fields";
+export * from "./kokimoki-client";
+export * from "./synced-store";
+export * from "@syncedstore/core";

package/dist/kokimoki-client-1.d.ts

@@ -0,0 +1,30 @@
+import { HocuspocusProvider } from "@hocuspocus/provider";
+import type TypedEmitter from "typed-emitter";
+import { SyncedStore } from "./synced-store";
+import type { DocTypeDescription } from "@syncedstore/core/types/doc";
+import { UploadedMedia } from "./types";
+export type KokimokiClientEvents<T> = {
+    stateless: (room: string, from: string, data: T) => void;
+};
+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 _providers;
+    constructor(host: string, appId: string);
+    get id(): string;
+    get token(): string;
+    connect(): Promise<void>;
+    setProvider<T extends DocTypeDescription>(name: string, store: SyncedStore<T>): Promise<void>;
+    removeProvider(name: string): void;
+    getProvider(name: string): HocuspocusProvider;
+    serverTimestamp(): number;
+    sendStatelessToClient(room: string, clientId: string, data: StatelessDataT): void;
+    sendStatelessToRoom(room: string, data: StatelessDataT, self?: boolean): void;
+    mediaUpload(blob: Blob): Promise<UploadedMedia>;
+}
+export {};

package/dist/kokimoki-client-1.js

@@ -0,0 +1,116 @@
+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 = "";
+    _providers = new Map();
+    constructor(host, appId) {
+        super();
+        this.appId = appId;
+        const secure = !host.match(/^localhost/);
+        this.wsUrl = `ws${secure ? "s" : ""}://${host}`;
+        this.apiUrl = `http${secure ? "s" : ""}://${host}`;
+    }
+    get id() {
+        if (!this._id) {
+            throw new Error("Client not connected");
+        }
+        return this._id;
+    }
+    get token() {
+        if (!this._token) {
+            throw new Error("Client not connected");
+        }
+        return this._token;
+    }
+    async connect() {
+        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 endTime = Date.now();
+        const ping = Math.round((endTime - startTime) / 2);
+        this._id = clientId;
+        this._token = appToken;
+        this.serverTimeOffset = Date.now() - serverTime - ping;
+        localStorage.setItem("KM_TOKEN", token);
+        console.log("READY", token);
+    }
+    async setProvider(name, store) {
+        const provider = new HocuspocusProvider({
+            url: `${this.wsUrl}/connection`,
+            name: `${this.appId}/${name}`,
+            document: store.doc,
+            token: this.token,
+        });
+        this._providers.set(name, provider);
+        // Handle incoming stateless messages
+        provider.on("stateless", (e) => {
+            const payload = JSON.parse(e.payload);
+            this.emit("stateless", name, payload.from, payload.data);
+        });
+        // Wait for initial sync
+        await new Promise((resolve) => {
+            const handler = () => {
+                provider.off("synced", handler);
+                resolve();
+            };
+            provider.on("synced", handler);
+        });
+    }
+    removeProvider(name) {
+        const provider = this._providers.get(name);
+        if (!provider) {
+            throw new Error(`No provider for room ${name}`);
+        }
+        provider.destroy();
+        this._providers.delete(name);
+    }
+    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) {
+            throw new Error(`No provider for room ${room}`);
+        }
+        provider.sendStateless(JSON.stringify({ to: clientId, data }));
+    }
+    sendStatelessToRoom(room, data, self = false) {
+        const provider = this._providers.get(room);
+        if (!provider) {
+            throw new Error(`No provider for room ${room}`);
+        }
+        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)}`);
+        }
+    }
+}

package/dist/kokimoki-client-2.d.ts

@@ -0,0 +1,29 @@
+import { HocuspocusProvider } from "@hocuspocus/provider";
+import type { Y } from "@syncedstore/core";
+import type TypedEmitter from "typed-emitter";
+import type { UploadedMedia } from "./types";
+type KokimokiClientEvents<T> = {
+    stateless: (room: string, from: string, data: T) => void;
+};
+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 _providers;
+    constructor(host: string, appId: string);
+    get id(): string;
+    get token(): string;
+    connect(): Promise<void>;
+    setProvider(name: string, document: Y.Doc): Promise<void>;
+    removeProvider(name: string): void;
+    getProvider(name: string): HocuspocusProvider;
+    serverTimestamp(): number;
+    sendStatelessToClient(room: string, clientId: string, data: StatelessDataT): void;
+    sendStatelessToRoom(room: string, data: StatelessDataT, self?: boolean): void;
+    mediaUpload(blob: Blob): Promise<UploadedMedia>;
+}
+export {};

package/dist/kokimoki-client-2.js

@@ -0,0 +1,116 @@
+import { HocuspocusProvider } from "@hocuspocus/provider";
+import EventEmitter from "events";
+import { errorMessage } from "./utils";
+import { fetchAuth } from "./api/fetchAuth";
+import { sendMediaUpload } from "./api/sendMediaUpload";
+import { getETags } from "./api/getETags";
+import { uploadMedia } from "./api/uploadMedia";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class KokimokiClient extends EventEmitter {
+    appId;
+    serverTimeOffset = 0;
+    wsUrl;
+    apiUrl;
+    _id = "";
+    _token = "";
+    _providers = new Map();
+    constructor(host, appId) {
+        super();
+        this.appId = appId;
+        const secure = !host.match(/^localhost/);
+        this.wsUrl = `ws${secure ? "s" : ""}://${host}`;
+        this.apiUrl = `http${secure ? "s" : ""}://${host}`;
+    }
+    get id() {
+        if (!this._id) {
+            throw new Error("Client not connected");
+        }
+        return this._id;
+    }
+    get token() {
+        if (!this._token) {
+            throw new Error("Client not connected");
+        }
+        return this._token;
+    }
+    async connect() {
+        const clientToken = localStorage.getItem("KM_TOKEN");
+        const startTime = Date.now();
+        const { clientId, appToken, serverTime, token } = await fetchAuth({
+            appId: this.appId,
+            clientToken,
+            apiUrl: this.apiUrl,
+        });
+        const endTime = Date.now();
+        const ping = Math.round((endTime - startTime) / 2);
+        this._id = clientId;
+        this._token = appToken;
+        this.serverTimeOffset = Date.now() - serverTime - ping;
+        localStorage.setItem("KM_TOKEN", token);
+    }
+    async setProvider(name, document) {
+        const provider = new HocuspocusProvider({
+            url: `${this.wsUrl}/connection`,
+            name: `${this.appId}/${name}`,
+            document,
+            token: this.token,
+        });
+        this._providers.set(name, provider);
+        // Handle incoming stateless messages
+        provider.on("stateless", (e) => {
+            const payload = JSON.parse(e.payload);
+            this.emit("stateless", name, payload.from, payload.data);
+        });
+        // Wait for initial sync
+        await new Promise((resolve) => {
+            const handler = () => {
+                provider.off("synced", handler);
+                resolve();
+            };
+            provider.on("synced", handler);
+        });
+    }
+    removeProvider(name) {
+        const provider = this._providers.get(name);
+        if (!provider) {
+            throw new Error(`No provider for room ${name}`);
+        }
+        provider.destroy();
+        this._providers.delete(name);
+    }
+    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) {
+            throw new Error(`No provider for room ${room}`);
+        }
+        provider.sendStateless(JSON.stringify({ to: clientId, data }));
+    }
+    sendStatelessToRoom(room, data, self = false) {
+        const provider = this._providers.get(room);
+        if (!provider) {
+            throw new Error(`No provider for room ${room}`);
+        }
+        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)}`);
+        }
+    }
+}

package/dist/kokimoki-client.d.ts

@@ -0,0 +1,30 @@
+import { HocuspocusProvider } from "@hocuspocus/provider";
+import type TypedEmitter from "typed-emitter";
+import { SyncedStore } from "./synced-store";
+import type { DocTypeDescription } from "@syncedstore/core/types/doc";
+import { UploadedMedia } from "./types";
+export type KokimokiClientEvents<T> = {
+    stateless: (room: string, from: string, data: T) => void;
+};
+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 _providers;
+    constructor(host: string, appId: string);
+    get id(): string;
+    get token(): string;
+    connect(): Promise<void>;
+    setProvider<T extends DocTypeDescription>(name: string, store: SyncedStore<T>): Promise<void>;
+    removeProvider(name: string): void;
+    getProvider(name: string): HocuspocusProvider;
+    serverTimestamp(): number;
+    sendStatelessToClient(room: string, clientId: string, data: StatelessDataT): void;
+    sendStatelessToRoom(room: string, data: StatelessDataT, self?: boolean): void;
+    mediaUpload(blob: Blob): Promise<UploadedMedia>;
+}
+export {};

package/dist/kokimoki-client.js

@@ -0,0 +1,116 @@
+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 = "";
+    _providers = new Map();
+    constructor(host, appId) {
+        super();
+        this.appId = appId;
+        const secure = !host.match(/^localhost/);
+        this.wsUrl = `ws${secure ? "s" : ""}://${host}`;
+        this.apiUrl = `http${secure ? "s" : ""}://${host}`;
+    }
+    get id() {
+        if (!this._id) {
+            throw new Error("Client not connected");
+        }
+        return this._id;
+    }
+    get token() {
+        if (!this._token) {
+            throw new Error("Client not connected");
+        }
+        return this._token;
+    }
+    async connect() {
+        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 endTime = Date.now();
+        const ping = Math.round((endTime - startTime) / 2);
+        this._id = clientId;
+        this._token = appToken;
+        this.serverTimeOffset = Date.now() - serverTime - ping;
+        localStorage.setItem("KM_TOKEN", token);
+        console.log("READY!", token);
+    }
+    async setProvider(name, store) {
+        const provider = new HocuspocusProvider({
+            url: `${this.wsUrl}/connection`,
+            name: `${this.appId}/${name}`,
+            document: store.doc,
+            token: this.token,
+        });
+        this._providers.set(name, provider);
+        // Handle incoming stateless messages
+        provider.on("stateless", (e) => {
+            const payload = JSON.parse(e.payload);
+            this.emit("stateless", name, payload.from, payload.data);
+        });
+        // Wait for initial sync
+        await new Promise((resolve) => {
+            const handler = () => {
+                provider.off("synced", handler);
+                resolve();
+            };
+            provider.on("synced", handler);
+        });
+    }
+    removeProvider(name) {
+        const provider = this._providers.get(name);
+        if (!provider) {
+            throw new Error(`No provider for room ${name}`);
+        }
+        provider.destroy();
+        this._providers.delete(name);
+    }
+    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) {
+            throw new Error(`No provider for room ${room}`);
+        }
+        provider.sendStateless(JSON.stringify({ to: clientId, data }));
+    }
+    sendStatelessToRoom(room, data, self = false) {
+        const provider = this._providers.get(room);
+        if (!provider) {
+            throw new Error(`No provider for room ${room}`);
+        }
+        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)}`);
+        }
+    }
+}

package/dist/synced-store.d.ts

@@ -0,0 +1,7 @@
+import * as Y from "yjs";
+import type { DocTypeDescription, MappedTypeDescription } from "@syncedstore/core/types/doc";
+export declare class SyncedStore<T extends DocTypeDescription> {
+    readonly data: MappedTypeDescription<T>;
+    readonly doc: Y.Doc;
+    constructor(initialState: T);
+}

package/dist/synced-store.js

@@ -0,0 +1,9 @@
+import { syncedStore, getYjsDoc } from "@syncedstore/core";
+export class SyncedStore {
+    data;
+    doc;
+    constructor(initialState) {
+        this.data = syncedStore(initialState);
+        this.doc = getYjsDoc(this.data);
+    }
+}

package/dist/tasks.d.ts

@@ -0,0 +1,43 @@
+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/tasks.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/api.d.ts

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

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

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./api";
+export * from "./tasks";

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export * from "./api";
+export * from "./tasks";

package/dist/types/tasks.d.ts

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

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

package/dist/utils.d.ts

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

@@ -0,0 +1,25 @@
+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({
+            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";
+}

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@kokimoki/app",
-  "version": "0.0.0",
+  "version": "0.0.1",
+  "type": "module",
   "description": "Kokimoki app",
-  "main": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc",

package/src/fields.ts

@@ -1,125 +0,0 @@
-import type { Task } from "./tasks";
-
-export interface FieldOptions {
-  label?: string;
-  optional: boolean;
-}
-
-const defaultFieldOptions: FieldOptions = {
-  optional: false,
-};
-
-export abstract class Field<T> {
-  constructor(public readonly options: FieldOptions) {}
-
-  abstract get value(): T;
-  abstract get schema(): any;
-}
-
-export class ImageField extends Field<string> {
-  constructor(
-    public value: string,
-    options: FieldOptions = defaultFieldOptions
-  ) {
-    super(options);
-  }
-
-  get schema() {
-    return {
-      type: "string",
-      default: this.value,
-    };
-  }
-}
-
-export class TextField extends Field<string> {
-  constructor(
-    public value: string,
-    options: FieldOptions = defaultFieldOptions
-  ) {
-    super(options);
-  }
-
-  get schema() {
-    return {
-      type: "string",
-      default: this.value,
-    };
-  }
-}
-
-export class IntegerField extends Field<number> {
-  constructor(
-    public value: number,
-    options: FieldOptions = defaultFieldOptions
-  ) {
-    super(options);
-  }
-
-  get schema() {
-    return {
-      type: "integer",
-      default: this.value,
-    };
-  }
-}
-
-export class FormGroup<T extends Record<string, any>> extends Field<{
-  [key in keyof T]: Field<T>["value"];
-}> {
-  constructor(public fields: T, options: FieldOptions = defaultFieldOptions) {
-    super(options);
-  }
-
-  get value(): { [key in keyof T]: T[key]["value"] } {
-    return Object.entries(this.fields).reduce((acc, [key, field]) => {
-      acc[key] = field.value;
-      return acc;
-    }, {} as any);
-  }
-
-  get schema() {
-    return {
-      type: "object",
-      properties: Object.entries(this.fields).reduce((acc, [key, field]) => {
-        acc[key] = field.schema;
-        return acc;
-      }, {} as any),
-    };
-  }
-}
-
-export class FormArray<T> extends Field<T[]> {
-  constructor(
-    private factory: () => Field<T>,
-    public value: Field<T>["value"][],
-    options: FieldOptions = defaultFieldOptions
-  ) {
-    super(options);
-  }
-
-  get schema() {
-    const field = this.factory();
-
-    return {
-      type: "array",
-      items: field.schema,
-    };
-  }
-}
-
-export class TaskField extends Field<Task> {
-  constructor(public value: Task, options: FieldOptions = defaultFieldOptions) {
-    super(options);
-  }
-
-  get schema() {
-    // TODO: validate task interface, not important right now
-    return {
-      type: "object",
-      properties: {},
-    };
-  }
-}
-
-export class Form<T extends Record<string, Field<any>>> extends FormGroup<T> {}

package/src/kokimoki-client.ts

@@ -1,134 +0,0 @@
-import { HocuspocusProvider } from "@hocuspocus/provider";
-import EventEmitter from "events";
-import type TypedEmitter from "typed-emitter";
-import { SyncedStore } from "./synced-store";
-import type { DocTypeDescription } from "@syncedstore/core/types/doc";
-
-type KokimokiClientEvents<T> = {
-  stateless: (room: string, from: string, data: T) => void;
-};
-
-export class KokimokiClient<StatelessDataT = any> extends (EventEmitter as {
-  new <T>(): TypedEmitter<KokimokiClientEvents<T>>;
-})<StatelessDataT> {
-  public serverTimeOffset = 0;
-  public wsUrl: string;
-  public apiUrl: string;
-
-  private _id = "";
-  private _token = "";
-  private _providers = new Map<string, HocuspocusProvider>();
-
-  constructor(host: string, public readonly appId: string) {
-    super();
-    const secure = !host.match(/^localhost/);
-    this.wsUrl = `ws${secure ? "s" : ""}://${host}`;
-    this.apiUrl = `http${secure ? "s" : ""}://${host}`;
-  }
-
-  get id() {
-    if (!this._id) {
-      throw new Error("Client not connected");
-    }
-
-    return this._id;
-  }
-
-  get token() {
-    if (!this._token) {
-      throw new Error("Client not connected");
-    }
-
-    return this._token;
-  }
-
-  async connect() {
-    let clientToken = localStorage.getItem("KM_TOKEN");
-
-    const startTime = Date.now();
-    const res = await fetch(`${this.apiUrl}/auth/token?appId=${this.appId}`, {
-      headers: clientToken
-        ? new Headers({ Authorization: `Bearer ${clientToken}` })
-        : new Headers(),
-    });
-    const body = await res.json();
-    const endTime = Date.now();
-    const ping = Math.round((endTime - startTime) / 2);
-
-    this._id = body.clientId;
-    this._token = body.appToken;
-    this.serverTimeOffset = Date.now() - body.serverTime - ping;
-    localStorage.setItem("KM_TOKEN", body.token);
-  }
-
-  async setProvider<T extends DocTypeDescription>(
-    name: string,
-    store: SyncedStore<T>
-  ) {
-    const provider = new HocuspocusProvider({
-      url: `${this.wsUrl}/connection`,
-      name: `${this.appId}/${name}`,
-      document: store.doc,
-      token: this.token,
-    });
-
-    this._providers.set(name, provider);
-
-    // Handle incoming stateless messages
-    provider.on("stateless", (e: { payload: string }) => {
-      const payload: { from: string; data: StatelessDataT } = JSON.parse(
-        e.payload
-      );
-      this.emit("stateless", name, payload.from, payload.data);
-    });
-
-    // Wait for initial sync
-    await new Promise<void>((resolve) => {
-      const handler = () => {
-        provider.off("synced", handler);
-        resolve();
-      };
-
-      provider.on("synced", handler);
-    });
-  }
-
-  removeProvider(name: string) {
-    const provider = this._providers.get(name);
-
-    if (!provider) {
-      throw new Error(`No provider for room ${name}`);
-    }
-
-    provider.destroy();
-    this._providers.delete(name);
-  }
-
-  getProvider(name: string) {
-    return this._providers.get(name);
-  }
-
-  serverTimestamp() {
-    return Date.now() - this.serverTimeOffset;
-  }
-
-  sendStatelessToClient(room: string, clientId: string, data: StatelessDataT) {
-    const provider = this._providers.get(room);
-
-    if (!provider) {
-      throw new Error(`No provider for room ${room}`);
-    }
-
-    provider.sendStateless(JSON.stringify({ to: clientId, data }));
-  }
-
-  sendStatelessToRoom(room: string, data: StatelessDataT, self = false) {
-    const provider = this._providers.get(room);
-
-    if (!provider) {
-      throw new Error(`No provider for room ${room}`);
-    }
-
-    provider.sendStateless(JSON.stringify({ data, self }));
-  }
-}

package/src/synced-store.ts

@@ -1,16 +0,0 @@
-import * as Y from "yjs";
-import { syncedStore, getYjsDoc } from "@syncedstore/core";
-import type {
-  DocTypeDescription,
-  MappedTypeDescription,
-} from "@syncedstore/core/types/doc";
-
-export class SyncedStore<T extends DocTypeDescription> {
-  public readonly data: MappedTypeDescription<T>;
-  public readonly doc: Y.Doc;
-
-  constructor(initialState: T) {
-    this.data = syncedStore(initialState);
-    this.doc = getYjsDoc(this.data);
-  }
-}

package/src/tasks.ts

@@ -1,62 +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
-  | TextSurveyTask
-  | NumericTask
-  | PhotoTask
-  | VideoTask
-  | InfoTask;

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "dist",
-    "esModuleInterop": true,
-    "declaration": true
-  },
-  "include": ["src/**/*.ts"]
-}