@kokimoki/app 1.0.6 → 1.0.7

package/dist/kokimoki.min.d.ts

@@ -0,0 +1,348 @@
+import TypedEventEmitter from 'typed-emitter';
+import * as Y from 'yjs';
+
+interface Paginated<T> {
+    items: T[];
+    total: number;
+}
+
+type KokimokiClientEvents = {
+    connected: () => void;
+    disconnected: () => void;
+};
+
+interface Upload {
+    id: string;
+    appId: string;
+    clientId: string;
+    createdAt: Date;
+    name: string;
+    url: string;
+    size: number;
+    mimeType: string;
+    completed: boolean;
+    tags: string[];
+}
+
+interface FieldOptions {
+    label?: string;
+}
+declare abstract class Field<T> {
+    readonly options: FieldOptions;
+    constructor(options: FieldOptions);
+    abstract get value(): T;
+    abstract get schema(): any;
+}
+declare class BooleanField extends Field<boolean> {
+    value: boolean;
+    constructor(value: boolean, options?: FieldOptions);
+    get schema(): {
+        type: string;
+        default: boolean;
+    };
+}
+declare class ConstField<T extends string> extends Field<string extends T ? never : T> {
+    value: string extends T ? never : T;
+    constructor(value: string extends T ? never : T, options?: FieldOptions);
+    get schema(): {
+        const: string extends T ? never : T;
+    };
+}
+declare class ImageField extends Field<string> {
+    value: string;
+    constructor(value: string, options?: FieldOptions);
+    get schema(): {
+        type: string;
+        default: string;
+    };
+}
+declare class TextField extends Field<string> {
+    value: string;
+    constructor(value: string, options?: FieldOptions);
+    get schema(): {
+        type: string;
+        default: string;
+    };
+}
+declare class EnumField<T extends Record<string, string>> extends Field<keyof T> {
+    enumValues: T;
+    value: keyof T;
+    constructor(enumValues: T, value: keyof T, options?: FieldOptions);
+    get schema(): {
+        enum: string[];
+    };
+}
+declare class IntegerField extends Field<number> {
+    value: number;
+    constructor(value: number, options?: FieldOptions);
+    get schema(): {
+        type: string;
+        default: number;
+    };
+}
+declare class FloatField extends Field<number> {
+    value: number;
+    constructor(value: number, options?: FieldOptions);
+    get schema(): {
+        type: string;
+        default: number;
+    };
+}
+declare class FormGroup<T extends Record<string, Field<any>>, O extends Record<string, Field<any>>> extends Field<{
+    [key in keyof T]: T[key]["value"];
+} & Partial<{
+    [key in keyof O]: O[key]["value"];
+}>> {
+    requiredFields: T;
+    optionalFields: O;
+    constructor(requiredFields: T, optionalFields?: O, options?: FieldOptions);
+    get value(): {
+        [key in keyof T]: T[key]["value"];
+    } & Partial<{
+        [key in keyof O]: O[key]["value"];
+    }>;
+    get schema(): {
+        type: string;
+        properties: any;
+        required: string[];
+    };
+}
+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;
+        default: T[];
+    };
+}
+declare class Form<R extends Record<string, Field<any>>, O extends Record<string, Field<any>>> extends FormGroup<R, O> {
+}
+
+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>;
+}
+
+declare enum RoomSubscriptionMode {
+    Read = "r",
+    Write = "w",
+    ReadWrite = "b"
+}
+
+declare class KokimokiStore<T extends KokimokiSchema.Generic<unknown>> {
+    readonly roomName: string;
+    readonly mode: RoomSubscriptionMode;
+    readonly doc: Y.Doc;
+    readonly proxy: T["defaultValue"];
+    readonly root: T["defaultValue"];
+    readonly defaultValue: T["defaultValue"];
+    readonly docRoot: Y.Map<unknown>;
+    constructor(roomName: string, schema: T, mode?: RoomSubscriptionMode);
+}
+
+declare class KokimokiQueue<Req extends KokimokiSchema.Generic<unknown>> extends KokimokiStore<KokimokiSchema.Dict<KokimokiSchema.Struct<{
+    timestamp: KokimokiSchema.Number;
+    payload: 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;
+    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): void;
+    consumeMessage<T>(queue: KokimokiQueue<KokimokiSchema.Generic<T>>, messageId: string): void;
+    getUpdates(): Promise<{
+        updates: {
+            roomName: string;
+            update: Uint8Array;
+        }[];
+        consumedMessages: Set<string>;
+    }>;
+}
+
+declare const KokimokiClient_base: new () => TypedEventEmitter<KokimokiClientEvents>;
+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;
+    private _pingInterval;
+    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 KokimokiSchema.Generic<unknown>>(store: KokimokiStore<T>): Promise<void>;
+    transact(handler: (t: KokimokiTransaction) => void): Promise<void>;
+}
+
+declare class RoomSubscription {
+    private kmClient;
+    readonly store: KokimokiStore<any>;
+    private _joined;
+    private _roomHash?;
+    private _onDisconnect;
+    constructor(kmClient: KokimokiClient, store: KokimokiStore<any>);
+    get roomName(): string;
+    get roomHash(): number;
+    get joined(): boolean;
+    applyInitialResponse(roomHash: number, initialUpdate?: Uint8Array): Promise<void>;
+    close(): void;
+}
+
+export { BooleanField, ConstField, EnumField, Field, type FieldOptions, FloatField, Form, FormArray, FormGroup, ImageField, IntegerField, KokimokiClient, type KokimokiClientEvents, KokimokiQueue, KokimokiSchema, KokimokiStore, type Paginated, RoomSubscription, RoomSubscriptionMode, TextField, type Upload };