@kokimoki/app 1.9.0 → 1.10.0

package/dist/kokimoki.min.d.ts

@@ -1,5 +1,6 @@
-import TypedEventEmitter from 'typed-emitter';
+import TypedEmitter from 'typed-emitter';
 import * as Y from 'yjs';
+import { ZodType } from 'zod';
 
 interface Paginated<T> {
     items: T[];
@@ -24,216 +25,61 @@ interface Upload {
     tags: string[];
 }
 
-declare namespace KokimokiSchema {
-    abstract class Generic<T> {
-        abstract get defaultValue(): T;
-        abstract set defaultValue(value: T);
-    }
-    class Number extends Generic<number> {
-        defaultValue: number;
-        constructor(defaultValue?: number);
-    }
-    function number(defaultValue?: number): Number;
-    class String extends Generic<string> {
-        defaultValue: string;
-        constructor(defaultValue?: string);
-    }
-    function string(defaultValue?: string): String;
-    class Boolean extends Generic<boolean> {
-        defaultValue: boolean;
-        constructor(defaultValue?: boolean);
-    }
-    function boolean(defaultValue?: boolean): Boolean;
-    class Struct<Data extends Record<string, Generic<unknown>>> extends Generic<{
-        [key in keyof Data]: Data[key]["defaultValue"];
-    }> {
-        fields: Data;
-        constructor(fields: Data);
-        get defaultValue(): {
-            [key in keyof Data]: Data[key]["defaultValue"];
-        };
-        set defaultValue(value: {
-            [key in keyof Data]: Data[key]["defaultValue"];
-        });
-    }
-    function struct<Data extends Record<string, Generic<unknown>>>(schema: Data): Struct<Data>;
-    class Dict<T extends Generic<unknown>> {
-        schema: T;
-        defaultValue: {
-            [key: string]: T["defaultValue"];
-        };
-        constructor(schema: T, defaultValue?: {
-            [key: string]: T["defaultValue"];
-        });
-    }
-    function dict<T extends Generic<unknown>>(schema: T, defaultValue?: {
-        [key: string]: T["defaultValue"];
-    }): Dict<T>;
-    class List<T extends Generic<unknown>> extends Generic<T["defaultValue"][]> {
-        schema: T;
-        defaultValue: T["defaultValue"][];
-        constructor(schema: T, defaultValue?: T["defaultValue"][]);
-    }
-    function list<T extends Generic<unknown>>(schema: T, defaultValue?: T["defaultValue"][]): List<T>;
-    /**
-     * Nullable
-     */
-    class Nullable<T extends Generic<unknown>> extends Generic<T["defaultValue"] | null> {
-        schema: T;
-        defaultValue: T["defaultValue"] | null;
-        constructor(schema: T, defaultValue: T["defaultValue"] | null);
-    }
-    function nullable<T extends Generic<unknown>>(schema: T, defaultValue?: T["defaultValue"] | null): Nullable<T>;
-    class StringEnum<T extends readonly string[]> extends Generic<string> {
-        readonly options: T;
-        defaultValue: T[number];
-        constructor(options: T, defaultValue: T[number]);
-    }
-    function stringEnum<T extends readonly string[]>(options: T, defaultValue: T[number]): StringEnum<T>;
-    class StringConst<T extends string> extends Generic<string> {
-        readonly defaultValue: T;
-        constructor(defaultValue: T);
-    }
-    function stringConst<T extends string>(defaultValue: T): StringConst<T>;
-    class AnyOf<T extends readonly Generic<unknown>[]> extends Generic<T[number]["defaultValue"]> {
-        readonly schemas: T;
-        defaultValue: T[number]["defaultValue"];
-        constructor(schemas: T, defaultValue: T[number]["defaultValue"]);
-    }
-    function anyOf<T extends readonly Generic<unknown>[]>(schemas: T, defaultValue: T[number]["defaultValue"]): AnyOf<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>;
-}
-
 declare enum RoomSubscriptionMode {
     Read = "r",
     Write = "w",
     ReadWrite = "b"
 }
 
-declare class KokimokiStore<T extends KokimokiSchema.Generic<unknown>, SubscribeT = T["defaultValue"]> {
+declare class KokimokiStore<T> {
     readonly roomName: string;
     readonly mode: RoomSubscriptionMode;
     readonly doc: Y.Doc;
-    readonly proxy: T["defaultValue"];
-    readonly root: T["defaultValue"];
-    readonly defaultValue: T["defaultValue"];
+    readonly proxy: T;
+    readonly root: T;
+    readonly defaultValue: T;
     readonly docRoot: Y.Map<unknown>;
-    constructor(roomName: string, schema: T, mode?: RoomSubscriptionMode);
-    get(): T["defaultValue"];
-    subscribe(set: (value: SubscribeT) => void): () => void;
+    constructor(roomName: string, schema: ZodType<T>, mode?: RoomSubscriptionMode);
+    get(): T;
+    subscribe(set: (value: T) => void): () => void;
     onJoin(client: KokimokiClient): Promise<void>;
     onBeforeLeave(client: KokimokiClient): Promise<void>;
     onLeave(client: KokimokiClient): Promise<void>;
 }
 
-declare class KokimokiQueue<Req extends KokimokiSchema.Generic<unknown>> extends KokimokiStore<KokimokiSchema.Dict<Req>> {
-    readonly payloadSchema: Req;
-    private _emitter;
-    readonly on: <E extends "messages">(event: E, listener: {
-        messages: (messages: {
-            id: string;
-            payload: Req["defaultValue"];
-        }[]) => void;
-    }[E]) => TypedEventEmitter<{
-        messages: (messages: {
-            id: string;
-            payload: Req["defaultValue"];
-        }[]) => void;
-    }>;
-    readonly off: <E extends "messages">(event: E, listener: {
-        messages: (messages: {
-            id: string;
-            payload: Req["defaultValue"];
-        }[]) => void;
-    }[E]) => TypedEventEmitter<{
-        messages: (messages: {
-            id: string;
-            payload: Req["defaultValue"];
-        }[]) => void;
-    }>;
-    constructor(roomName: string, payloadSchema: Req, mode: RoomSubscriptionMode);
-}
-
-declare class KokimokiTransaction {
-    private kmClient;
-    private _clones;
-    private _updates;
-    private _consumeMessagesInRooms;
-    private _queueMessageCounter;
-    constructor(kmClient: KokimokiClient<any>);
-    private _parseTarget;
-    private _parsePath;
-    private _getClone;
-    get<T>(target: T): T;
-    set<T>(target: T, value: T): void;
-    delete<T>(target: T): void;
-    push<T>(target: T[], value: T): void;
-    queueMessage<T>(queue: KokimokiQueue<KokimokiSchema.Generic<T>>, payload: T): string;
-    consumeMessage<T>(queue: KokimokiQueue<KokimokiSchema.Generic<T>>, messageId: string): void;
-    getUpdates(): Promise<{
-        updates: {
-            roomName: string;
-            update: Uint8Array;
-        }[];
-        consumedMessages: Set<string>;
-    }>;
-}
-
-declare class KokimokiAwareness<Data extends KokimokiSchema.Generic<unknown>> extends KokimokiStore<KokimokiSchema.Dict<KokimokiSchema.Struct<{
-    clientId: KokimokiSchema.String;
-    lastPing: KokimokiSchema.Number;
-    data: Data;
-}>>> {
-    readonly dataSchema: Data;
+declare class KokimokiAwareness<DataT> extends KokimokiStore<{
+    [connectionId: string]: {
+        clientId: string;
+        lastPing: number;
+        data: DataT;
+    };
+}> {
+    readonly dataSchema: ZodType<DataT>;
     private _data;
     private _pingInterval;
     private _kmClients;
-    constructor(roomName: string, dataSchema: Data, _data: Data["defaultValue"], mode?: RoomSubscriptionMode, pingTimeout?: number);
+    constructor(roomName: string, dataSchema: ZodType<DataT>, _data: DataT, mode?: RoomSubscriptionMode, pingTimeout?: number);
     onJoin(client: KokimokiClient<any>): Promise<void>;
     onBeforeLeave(client: KokimokiClient<any>): Promise<void>;
     onLeave(client: KokimokiClient<any>): Promise<void>;
     getClients(): {
-        [clientId: string]: Data["defaultValue"];
+        [clientId: string]: DataT;
     };
-    setData(data: Data["defaultValue"]): Promise<void>;
-}
-
-declare class KokimokiReqRes<Req extends KokimokiSchema.Generic<unknown>, Res extends KokimokiSchema.Generic<unknown>> {
-    private kmClient;
-    readonly serviceName: string;
-    readonly reqSchema: Req;
-    readonly resSchema: Res;
-    private handleRequest;
-    private _reqQueueSchema;
-    private _resQueueSchema;
-    private _reqQueues;
-    private _resQueues;
-    private _reqPromises;
-    private _getReqQueue;
-    private _getResQueue;
-    constructor(kmClient: KokimokiClient, serviceName: string, reqSchema: Req, resSchema: Res, handleRequest: (payload: Req["defaultValue"]) => Promise<Res["defaultValue"]>);
-    private handleRequests;
-    private handleResponses;
-    send(toClientId: string, payload: Req["defaultValue"], timeout?: number): Promise<Res["defaultValue"]>;
+    setData(data: DataT): Promise<void>;
 }
 
-declare class KokimokiLocalStore<Data extends KokimokiSchema.Generic<unknown>> extends KokimokiStore<Data> {
+declare class KokimokiLocalStore<Data> extends KokimokiStore<Data> {
     private readonly localRoomName;
     private _stateKey?;
     private get stateKey();
-    constructor(localRoomName: string, schema: Data);
+    constructor(localRoomName: string, schema: ZodType<Data>);
     getInitialUpdate(appId: string, clientId: string): {
         roomHash: number;
         initialUpdate: Uint8Array | undefined;
     };
 }
 
-declare const KokimokiClient_base: new () => TypedEventEmitter<KokimokiClientEvents>;
+declare const KokimokiClient_base: new () => TypedEmitter<KokimokiClientEvents>;
 declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     readonly host: string;
     readonly appId: string;
@@ -298,17 +144,17 @@ declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
     exposeScriptingContext(context: any): Promise<void>;
     private sendSubscribeReq;
     private sendUnsubscribeReq;
-    join<T extends KokimokiSchema.Generic<unknown>>(store: KokimokiStore<T>): Promise<void>;
-    leave<T extends KokimokiSchema.Generic<unknown>>(store: KokimokiStore<T>): Promise<void>;
-    transact<ReturnT = void>(handler: (t: KokimokiTransaction) => ReturnT | Promise<ReturnT>): Promise<ReturnT>;
+    join<T>(store: KokimokiStore<T>): Promise<void>;
+    leave<T>(store: KokimokiStore<T>): Promise<void>;
+    transact<T extends unknown[], ReturnT = void>(stores: {
+        [K in keyof T]: KokimokiStore<T[K]>;
+    }, handler: (proxies: T) => ReturnT | Promise<ReturnT>): Promise<ReturnT>;
     close(): Promise<void>;
-    getRoomHash<T extends KokimokiSchema.Generic<unknown>>(store: KokimokiStore<T>): number;
+    getRoomHash<T extends ZodType>(store: KokimokiStore<T>): number;
     /** Initializers */
-    store<T extends KokimokiSchema.Generic<unknown>>(name: string, schema: T, autoJoin?: boolean): KokimokiStore<T, T["defaultValue"]>;
-    localStore<T extends KokimokiSchema.Generic<unknown>>(name: string, schema: T): KokimokiLocalStore<T>;
-    queue<T extends KokimokiSchema.Generic<unknown>>(name: string, schema: T, mode: RoomSubscriptionMode, autoJoin?: boolean): KokimokiQueue<T>;
-    awareness<T extends KokimokiSchema.Generic<unknown>>(name: string, dataSchema: T, initialData?: T["defaultValue"], autoJoin?: boolean): KokimokiAwareness<T>;
-    reqRes<Req extends KokimokiSchema.Generic<unknown>, Res extends KokimokiSchema.Generic<unknown>>(serviceName: string, reqSchema: Req, resSchema: Res, handleRequest: (payload: Req["defaultValue"]) => Promise<Res["defaultValue"]>): KokimokiReqRes<Req, Res>;
+    store<T extends ZodType>(name: string, schema: T, autoJoin?: boolean): KokimokiStore<T>;
+    localStore<T>(name: string, schema: ZodType<T>): KokimokiLocalStore<T>;
+    awareness<T>(name: string, dataSchema: ZodType<T>, initialData?: T, autoJoin?: boolean): KokimokiAwareness<T>;
     /**
      * Add a new entry to a leaderboard
      * @param leaderboardName
@@ -375,4 +221,4 @@ declare class RoomSubscription {
     close(): void;
 }
 
-export { KokimokiAwareness, KokimokiClient, type KokimokiClientEvents, KokimokiQueue, KokimokiSchema, KokimokiStore, type Paginated, RoomSubscription, RoomSubscriptionMode, type Upload };
+export { KokimokiAwareness, KokimokiClient, type KokimokiClientEvents, KokimokiStore, type Paginated, RoomSubscription, RoomSubscriptionMode, type Upload };