@kokimoki/app 1.0.2 → 1.0.5

package/dist/kokimoki-schema.d.ts

@@ -55,4 +55,10 @@ export declare namespace KokimokiSchema {
         constructor(schema: T, defaultValue: T["defaultValue"] | null);
     }
     function nullable<T extends Generic<unknown>>(schema: T, defaultValue?: T["defaultValue"] | null): Nullable<T>;
+    class Optional<T extends Generic<unknown>> extends Generic<T["defaultValue"] | undefined> {
+        schema: T;
+        defaultValue: T["defaultValue"] | undefined;
+        constructor(schema: T, defaultValue?: T["defaultValue"] | undefined);
+    }
+    function optional<T extends Generic<unknown>>(schema: T, defaultValue?: T["defaultValue"] | undefined): Optional<T>;
 }

package/dist/kokimoki-schema.js

@@ -103,4 +103,18 @@ export var KokimokiSchema;
         return new Nullable(schema, defaultValue);
     }
     KokimokiSchema.nullable = nullable;
+    class Optional extends Generic {
+        schema;
+        defaultValue;
+        constructor(schema, defaultValue = undefined) {
+            super();
+            this.schema = schema;
+            this.defaultValue = defaultValue;
+        }
+    }
+    KokimokiSchema.Optional = Optional;
+    function optional(schema, defaultValue = undefined) {
+        return new Optional(schema, defaultValue);
+    }
+    KokimokiSchema.optional = optional;
 })(KokimokiSchema || (KokimokiSchema = {}));

package/dist/kokimoki-transaction.d.ts

@@ -10,7 +10,7 @@ export declare class KokimokiTransaction {
     private _parseTarget;
     private _parsePath;
     private _getClone;
-    get<T>(target: T): any;
+    get<T>(target: T): T;
     set<T>(target: T, value: T): void;
     delete<T>(target: T): void;
     push<T>(target: T[], value: T): void;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const KOKIMOKI_APP_VERSION = "1.0.2";
+export declare const KOKIMOKI_APP_VERSION = "1.0.5";

package/dist/version.js

@@ -1 +1 @@
-export const KOKIMOKI_APP_VERSION = "1.0.2";
+export const KOKIMOKI_APP_VERSION = "1.0.5";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kokimoki/app",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "type": "module",
   "description": "Kokimoki app",
   "main": "dist/index.js",
@@ -24,6 +24,7 @@
   },
   "dependencies": {
     "events": "^3.3.0",
+    "proxy-deep": "^4.0.1",
     "typed-emitter": "^2.1.0",
     "valtio": "^1.13.1",
     "valtio-yjs": "^0.5.1"

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

@@ -1,57 +0,0 @@
-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 { 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, ClientContextT = any> extends KokimokiClient_base<StatelessDataT> {
-    readonly host: string;
-    readonly appId: string;
-    readonly code: string;
-    private _wsUrl;
-    private _apiUrl;
-    private _id?;
-    private _token?;
-    private _apiHeaders?;
-    private _providers;
-    private _serverTimeOffset;
-    private _clientContext?;
-    private _connected;
-    private _lastPongAt;
-    constructor(host: string, appId: string, code?: string);
-    get id(): string;
-    get token(): string;
-    get apiUrl(): string;
-    get apiHeaders(): Headers;
-    get clientContext(): ClientContextT & ({} | null);
-    connect(): Promise<void>;
-    serverTimestamp(): number;
-    private receivePong;
-    private checkConnectionState;
-    setProvider<T extends DocTypeDescription>(name: string, store: SyncedStore<T>): Promise<void>;
-    removeProvider(name: string): void;
-    getProvider(name: string): HocuspocusProvider | undefined;
-    sendStatelessToClient(room: string, clientId: string, data: StatelessDataT): void;
-    sendStatelessToRoom(room: string, data: StatelessDataT, self?: boolean): void;
-    patchRoomState(room: string, update: Uint8Array): Promise<any>;
-    private createUpload;
-    private uploadChunks;
-    private completeUpload;
-    upload(name: string, blob: Blob, tags?: string[]): Promise<Upload>;
-    updateUpload(id: string, update: {
-        tags?: string[];
-    }): Promise<Upload>;
-    listUploads(filter?: {
-        clientId?: string;
-        mimeTypes?: string[];
-        tags?: string[];
-    }, skip?: number, limit?: number): Promise<Paginated<Upload>>;
-    deleteUpload(id: string): Promise<{
-        acknowledged: boolean;
-        deletedCount: number;
-    }>;
-    exposeScriptingContext(context: any): Promise<void>;
-}
-export {};

package/dist/kokimoki-client copy.js

@@ -1,259 +0,0 @@
-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;
-    _token;
-    _apiHeaders;
-    _providers = new Map();
-    _serverTimeOffset = 0;
-    _clientContext;
-    _connected = false;
-    _lastPongAt = 0;
-    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}`;
-        this._apiUrl = `http${secure ? "s" : ""}://${this.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;
-    }
-    get apiUrl() {
-        if (!this._apiUrl) {
-            throw new Error("Client not connected");
-        }
-        return this._apiUrl;
-    }
-    get apiHeaders() {
-        if (!this._apiHeaders) {
-            throw new Error("Client not connected");
-        }
-        return this._apiHeaders;
-    }
-    get clientContext() {
-        if (this._clientContext === undefined) {
-            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}&code=${this.code}&clientVersion=${KOKIMOKI_APP_VERSION}`, {
-            method: "GET",
-            headers: new Headers({
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${clientToken}`,
-            }),
-        });
-        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({
-            Authorization: `Bearer ${this.token}`,
-            "Content-Type": "application/json",
-        });
-        // Ping interval
-        setInterval(() => {
-            this._providers.forEach((provider) => provider.sendStateless("ping"));
-        }, 5000);
-        // Connection state interval
-        setInterval(() => {
-            this.checkConnectionState();
-        }, 1000);
-        // Check initial connected state
-        this.receivePong();
-    }
-    serverTimestamp() {
-        return Date.now() - this._serverTimeOffset;
-    }
-    receivePong() {
-        this._lastPongAt = Date.now();
-        this.checkConnectionState();
-    }
-    checkConnectionState() {
-        const connected = this._providers.size === 0 || Date.now() - this._lastPongAt < 6000;
-        if (connected && !this._connected) {
-            this._connected = true;
-            this.emit("connected");
-        }
-        else if (!connected && this._connected) {
-            this._connected = false;
-            this.emit("disconnected");
-            // Reset connections to providers
-            this._providers.forEach(async (provider) => {
-                provider.disconnect();
-                await provider.connect();
-            });
-        }
-    }
-    // Realtime database
-    async setProvider(name, store) {
-        const provider = new HocuspocusProvider({
-            url: `${this._wsUrl}/connection`,
-            name: `${this.appId}/${name}`,
-            document: store.doc,
-            token: this.token,
-            parameters: {
-                clientVersion: KOKIMOKI_APP_VERSION,
-            },
-        });
-        // 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);
-        });
-        // Wait for initial sync
-        await new Promise((resolve) => {
-            const handler = () => {
-                provider.off("synced", handler);
-                resolve();
-            };
-            provider.on("synced", handler);
-        });
-        this._lastPongAt = Date.now();
-        this._providers.set(name, provider);
-        this.checkConnectionState();
-    }
-    removeProvider(name) {
-        const provider = this._providers.get(name);
-        if (!provider) {
-            throw new Error(`No provider for room ${name}`);
-        }
-        provider.destroy();
-        this._providers.delete(name);
-        // Connection state can change if the removed provider was not connected or synced
-        this.checkConnectionState();
-    }
-    getProvider(name) {
-        return this._providers.get(name);
-    }
-    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 }));
-    }
-    // Send Y update to room
-    async patchRoomState(room, update) {
-        const res = await fetch(`${this._apiUrl}/rooms/${room}`, {
-            method: "PATCH",
-            headers: this.apiHeaders,
-            body: update,
-        });
-        return await res.json();
-    }
-    // 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 updateUpload(id, update) {
-        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
-            method: "PUT",
-            headers: this.apiHeaders,
-            body: JSON.stringify(update),
-        });
-        return await res.json();
-    }
-    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());
-        }
-        if (filter.tags) {
-            url.searchParams.set("tags", filter.tags.join());
-        }
-        const res = await fetch(url.href, {
-            headers: this.apiHeaders,
-        });
-        return await res.json();
-    }
-    async deleteUpload(id) {
-        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
-            method: "DELETE",
-            headers: this.apiHeaders,
-        });
-        return await res.json();
-    }
-    async exposeScriptingContext(context) {
-        // @ts-ignore
-        window.KM_SCRIPTING_CONTEXT = context;
-        // @ts-ignore
-        window.dispatchEvent(new CustomEvent("km:scriptingContextExposed"));
-    }
-}

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

@@ -1,67 +0,0 @@
-import type TypedEmitter from "typed-emitter";
-import type { KokimokiClientEventsRefactored } from "./types/events";
-import type { Upload } from "./types/upload";
-import type { Paginated } from "./types/common";
-import { KokimokiTransaction } from "./kokimoki-transaction";
-import type { KokimokiStore } from "./kokimoki-store";
-import type { KokimokiSchema as S } from "./kokimoki-schema";
-import { RoomSubscriptionMode } from "./room-subscription-mode";
-declare const KokimokiClient_base: new () => TypedEmitter<KokimokiClientEventsRefactored>;
-export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
-    readonly host: string;
-    readonly appId: string;
-    readonly code: string;
-    private _wsUrl;
-    private _apiUrl;
-    private _id?;
-    private _token?;
-    private _apiHeaders?;
-    private _serverTimeOffset;
-    private _clientContext?;
-    private _ws?;
-    private _subscriptionsByName;
-    private _subscriptionsByHash;
-    private _subscribeReqPromises;
-    private _transactionPromises;
-    private _connected;
-    private _connectPromise?;
-    private _messageId;
-    private _reconnectTimeout;
-    constructor(host: string, appId: string, code?: string);
-    get id(): string;
-    get token(): string;
-    get apiUrl(): string;
-    get apiHeaders(): Headers;
-    get clientContext(): ClientContextT & ({} | null);
-    get connected(): boolean;
-    get ws(): WebSocket;
-    connect(): Promise<void>;
-    private handleInitMessage;
-    private handleBinaryMessage;
-    private handleErrorMessage;
-    private handleSubscribeResMessage;
-    private handleRoomUpdateMessage;
-    serverTimestamp(): number;
-    patchRoomState(room: string, update: Uint8Array): Promise<any>;
-    private createUpload;
-    private uploadChunks;
-    private completeUpload;
-    upload(name: string, blob: Blob, tags?: string[]): Promise<Upload>;
-    updateUpload(id: string, update: {
-        tags?: string[];
-    }): Promise<Upload>;
-    listUploads(filter?: {
-        clientId?: string;
-        mimeTypes?: string[];
-        tags?: string[];
-    }, skip?: number, limit?: number): Promise<Paginated<Upload>>;
-    deleteUpload(id: string): Promise<{
-        acknowledged: boolean;
-        deletedCount: number;
-    }>;
-    exposeScriptingContext(context: any): Promise<void>;
-    private sendSubscriptionReq;
-    join<T extends S.Generic<unknown>>(store: KokimokiStore<T>, mode?: RoomSubscriptionMode): Promise<void>;
-    transact(handler: (t: KokimokiTransaction) => void): Promise<void>;
-}
-export {};