npm - @colyseus/sdk - Versions diffs - 0.17.0 - Mend

@colyseus/sdk 0.17.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (133) hide show

package/LICENSE +22 -0
package/README.md +27 -0
package/build/cjs/3rd_party/discord.js +56 -0
package/build/cjs/3rd_party/discord.js.map +1 -0
package/build/cjs/Auth.js +156 -0
package/build/cjs/Auth.js.map +1 -0
package/build/cjs/Client.js +282 -0
package/build/cjs/Client.js.map +1 -0
package/build/cjs/Connection.js +48 -0
package/build/cjs/Connection.js.map +1 -0
package/build/cjs/HTTP.js +156 -0
package/build/cjs/HTTP.js.map +1 -0
package/build/cjs/Protocol.js +34 -0
package/build/cjs/Protocol.js.map +1 -0
package/build/cjs/Room.js +357 -0
package/build/cjs/Room.js.map +1 -0
package/build/cjs/Storage.js +98 -0
package/build/cjs/Storage.js.map +1 -0
package/build/cjs/core/nanoevents.js +50 -0
package/build/cjs/core/nanoevents.js.map +1 -0
package/build/cjs/core/signal.js +53 -0
package/build/cjs/core/signal.js.map +1 -0
package/build/cjs/core/utils.js +14 -0
package/build/cjs/core/utils.js.map +1 -0
package/build/cjs/errors/Errors.js +29 -0
package/build/cjs/errors/Errors.js.map +1 -0
package/build/cjs/index.js +43 -0
package/build/cjs/index.js.map +1 -0
package/build/cjs/legacy.js +34 -0
package/build/cjs/legacy.js.map +1 -0
package/build/cjs/serializer/NoneSerializer.js +18 -0
package/build/cjs/serializer/NoneSerializer.js.map +1 -0
package/build/cjs/serializer/SchemaSerializer.js +61 -0
package/build/cjs/serializer/SchemaSerializer.js.map +1 -0
package/build/cjs/serializer/Serializer.js +23 -0
package/build/cjs/serializer/Serializer.js.map +1 -0
package/build/cjs/transport/H3Transport.js +171 -0
package/build/cjs/transport/H3Transport.js.map +1 -0
package/build/cjs/transport/WebSocketTransport.js +50 -0
package/build/cjs/transport/WebSocketTransport.js.map +1 -0
package/build/esm/3rd_party/discord.mjs +53 -0
package/build/esm/3rd_party/discord.mjs.map +1 -0
package/build/esm/Auth.mjs +137 -0
package/build/esm/Auth.mjs.map +1 -0
package/build/esm/Client.mjs +272 -0
package/build/esm/Client.mjs.map +1 -0
package/build/esm/Connection.mjs +49 -0
package/build/esm/Connection.mjs.map +1 -0
package/build/esm/HTTP.mjs +159 -0
package/build/esm/HTTP.mjs.map +1 -0
package/build/esm/Protocol.mjs +34 -0
package/build/esm/Protocol.mjs.map +1 -0
package/build/esm/Room.mjs +355 -0
package/build/esm/Room.mjs.map +1 -0
package/build/esm/Storage.mjs +86 -0
package/build/esm/Storage.mjs.map +1 -0
package/build/esm/core/nanoevents.mjs +46 -0
package/build/esm/core/nanoevents.mjs.map +1 -0
package/build/esm/core/signal.mjs +48 -0
package/build/esm/core/signal.mjs.map +1 -0
package/build/esm/core/utils.mjs +12 -0
package/build/esm/core/utils.mjs.map +1 -0
package/build/esm/errors/Errors.mjs +28 -0
package/build/esm/errors/Errors.mjs.map +1 -0
package/build/esm/index.mjs +22 -0
package/build/esm/index.mjs.map +1 -0
package/build/esm/legacy.mjs +32 -0
package/build/esm/legacy.mjs.map +1 -0
package/build/esm/serializer/NoneSerializer.mjs +16 -0
package/build/esm/serializer/NoneSerializer.mjs.map +1 -0
package/build/esm/serializer/SchemaSerializer.mjs +60 -0
package/build/esm/serializer/SchemaSerializer.mjs.map +1 -0
package/build/esm/serializer/Serializer.mjs +20 -0
package/build/esm/serializer/Serializer.mjs.map +1 -0
package/build/esm/transport/H3Transport.mjs +170 -0
package/build/esm/transport/H3Transport.mjs.map +1 -0
package/build/esm/transport/WebSocketTransport.mjs +51 -0
package/build/esm/transport/WebSocketTransport.mjs.map +1 -0
package/dist/colyseus-cocos-creator.js +9538 -0
package/dist/colyseus-cocos-creator.js.map +1 -0
package/dist/colyseus.js +9537 -0
package/dist/colyseus.js.map +1 -0
package/dist/debug.js +2460 -0
package/dist/debug.js.map +1 -0
package/lib/3rd_party/discord.d.ts +33 -0
package/lib/Auth.d.ts +31 -0
package/lib/Client.d.ts +92 -0
package/lib/Connection.d.ts +17 -0
package/lib/HTTP.d.ts +113 -0
package/lib/HTTP_bkp.d.ts +18 -0
package/lib/Protocol.d.ts +21 -0
package/lib/Room.d.ts +140 -0
package/lib/Storage.d.ts +3 -0
package/lib/core/http_bkp.d.ts +319 -0
package/lib/core/nanoevents.d.ts +27 -0
package/lib/core/signal.d.ts +17 -0
package/lib/core/utils.d.ts +1 -0
package/lib/debug.d.ts +1 -0
package/lib/errors/Errors.d.ts +17 -0
package/lib/index.d.ts +9 -0
package/lib/legacy.d.ts +0 -0
package/lib/serializer/FossilDeltaSerializer.d.ts +0 -0
package/lib/serializer/NoneSerializer.d.ts +8 -0
package/lib/serializer/SchemaSerializer.d.ts +14 -0
package/lib/serializer/Serializer.d.ts +10 -0
package/lib/src/3rd_party/discord.d.ts +33 -0
package/lib/src/Auth.d.ts +31 -0
package/lib/src/Client.d.ts +62 -0
package/lib/src/Connection.d.ts +17 -0
package/lib/src/HTTP.d.ts +113 -0
package/lib/src/HTTP_bkp.d.ts +18 -0
package/lib/src/Protocol.d.ts +28 -0
package/lib/src/Room.d.ts +132 -0
package/lib/src/Storage.d.ts +3 -0
package/lib/src/core/http_bkp.d.ts +319 -0
package/lib/src/core/nanoevents.d.ts +27 -0
package/lib/src/core/signal.d.ts +17 -0
package/lib/src/debug.d.ts +1 -0
package/lib/src/errors/Errors.d.ts +15 -0
package/lib/src/index.d.ts +9 -0
package/lib/src/legacy.d.ts +0 -0
package/lib/src/serializer/FossilDeltaSerializer.d.ts +0 -0
package/lib/src/serializer/NoneSerializer.d.ts +8 -0
package/lib/src/serializer/SchemaSerializer.d.ts +14 -0
package/lib/src/serializer/Serializer.d.ts +11 -0
package/lib/src/transport/H3Transport.d.ts +20 -0
package/lib/src/transport/ITransport.d.ts +16 -0
package/lib/src/transport/WebSocketTransport.d.ts +17 -0
package/lib/transport/H3Transport.d.ts +20 -0
package/lib/transport/ITransport.d.ts +16 -0
package/lib/transport/WebSocketTransport.d.ts +17 -0
package/lib/tsconfig.tsbuildinfo +1 -0
package/package.json +108 -0

package/lib/src/HTTP.d.ts ADDED Viewed

@@ -0,0 +1,113 @@
+import type { Router, HasRequiredKeys, Prettify, UnionToIntersection, Endpoint, HTTPMethod } from "@colyseus/better-call";
+import { ColyseusSDK } from "./Client.ts";
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type IsAnyOrAnyIndexed<T> = IsAny<T> extends true ? true : (string extends keyof T ? true : (number extends keyof T ? (symbol extends keyof T ? true : false) : false));
+type HasRequired<T extends {
+    body?: any;
+    query?: any;
+    params?: any;
+}> = T["body"] extends object ? HasRequiredKeys<T["body"]> extends true ? true : T["query"] extends object ? HasRequiredKeys<T["query"]> extends true ? true : T["params"] extends object ? HasRequiredKeys<T["params"]> : false : T["params"] extends object ? HasRequiredKeys<T["params"]> : false : T["query"] extends object ? HasRequiredKeys<T["query"]> extends true ? true : T["params"] extends object ? HasRequiredKeys<T["params"]> : false : T["params"] extends object ? HasRequiredKeys<T["params"]> : false;
+type InferContext<T> = T extends (ctx: infer Ctx) => any ? Ctx extends object ? Ctx : never : never;
+type WithRequired<T, K extends keyof any> = Prettify<T & {
+    [P in K & keyof T]-?: NonNullable<T[P]>;
+}>;
+type WithoutServerOnly<T extends Record<string, Endpoint>> = {
+    [K in keyof T]: T[K] extends Endpoint<any, infer O> ? O extends {
+        metadata: {
+            SERVER_ONLY: true;
+        };
+    } ? never : T[K] : T[K];
+};
+type MethodOptions<API, M extends HTTPMethod> = API extends {
+    [key: string]: infer T;
+} ? T extends Endpoint<any, infer O> ? O["method"] extends M ? {
+    [key in T["path"]]: T;
+} : O["method"] extends M[] ? M extends O["method"][number] ? {
+    [key in T["path"]]: T;
+} : {} : O["method"] extends "*" ? {
+    [key in T["path"]]: T;
+} : {} : {} : {};
+export type RequiredOptionKeys<C extends {
+    body?: any;
+    query?: any;
+    params?: any;
+}> = (C["body"] extends object ? HasRequiredKeys<C["body"]> extends true ? {
+    body: true;
+} : {} : {}) & (C["query"] extends object ? HasRequiredKeys<C["query"]> extends true ? {
+    query: true;
+} : {} : {}) & (C["params"] extends object ? HasRequiredKeys<C["params"]> extends true ? {
+    params: true;
+} : {} : {});
+type CommonHeaders = {
+    accept: "application/json" | "text/plain" | "application/octet-stream";
+    "content-type": "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+    authorization: "Bearer" | "Basic";
+};
+type FetchRequestOptions<Body = any, Query extends Record<string, any> = any, Params extends Record<string, any> | Array<string> | undefined = any, Res = any, ExtraOptions extends Record<string, any> = {}> = Prettify<ExtraOptions & Omit<RequestInit, "body"> & {
+    /**
+     * Headers
+     */
+    headers?: CommonHeaders | Headers | HeadersInit;
+    /**
+     * Body
+     */
+    body?: Body;
+    /**
+     * Query parameters (key-value pairs)
+     */
+    query?: Query;
+    /**
+     * Dynamic parameters.
+     *
+     * If url is defined as /path/:id, params will be { id: string }
+     */
+    params?: Params;
+}>;
+type ResponseData<T> = {
+    ok: true;
+    data: T;
+    error: null;
+    response: Response;
+    headers: Headers;
+    status: number;
+    statusText: string;
+};
+type ResponseError<E> = {
+    ok: false;
+    data: null;
+    error: Prettify<(E extends Record<string, any> ? E : {
+        message?: string;
+    }) & {
+        code?: string;
+    }>;
+    response: Response;
+    headers: Headers;
+    status: number;
+    statusText: string;
+};
+type FetchResponse<T, E extends Record<string, unknown> | unknown = unknown, Throw extends boolean = false> = Throw extends true ? T : ResponseData<T> | ResponseError<E>;
+export declare function isJSONSerializable(value: any): boolean;
+export type ResponseType = "json" | "text" | "blob";
+export declare function detectResponseType(request: Response): ResponseType;
+type InferredAPI<R> = R extends {
+    endpoints: Record<string, Endpoint>;
+} ? WithoutServerOnly<R["endpoints"]> : WithoutServerOnly<R & Record<string, Endpoint>>;
+export declare class HTTP<R extends Router | Router["endpoints"]> {
+    authToken: string | undefined;
+    options: FetchRequestOptions;
+    private sdk;
+    constructor(sdk: ColyseusSDK, baseOptions: FetchRequestOptions);
+    private request;
+    get<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "GET">>> = Prettify<UnionToIntersection<MethodOptions<API, "GET">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends true ? K : never), options: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : WithRequired<FetchRequestOptions<C["body"], C["query"], C["params"]>, keyof RequiredOptionKeys<C>>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    get<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "GET">>> = Prettify<UnionToIntersection<MethodOptions<API, "GET">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends false ? K : never), options?: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : FetchRequestOptions<C["body"], C["query"], C["params"]>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    post<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "POST">>> = Prettify<UnionToIntersection<MethodOptions<API, "POST">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: (IsAnyOrAnyIndexed<R> extends true ? string : never) | (IsAny<API> extends true ? string : never) | (HasRequired<C> extends true ? K : never), options: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : (IsAny<API> extends true ? FetchRequestOptions<any, any, any> : WithRequired<FetchRequestOptions<C["body"], C["query"], C["params"]>, keyof RequiredOptionKeys<C>>)): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    post<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "POST">>> = Prettify<UnionToIntersection<MethodOptions<API, "POST">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: (IsAnyOrAnyIndexed<R> extends true ? string : never) | (IsAny<API> extends true ? string : never) | (HasRequired<C> extends false ? K : never), options?: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : (IsAny<API> extends true ? FetchRequestOptions<any, any, any> : FetchRequestOptions<C["body"], C["query"], C["params"]>)): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    delete<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "DELETE">>> = Prettify<UnionToIntersection<MethodOptions<API, "DELETE">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends true ? K : never), options: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : WithRequired<FetchRequestOptions<C["body"], C["query"], C["params"]>, keyof RequiredOptionKeys<C>>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    delete<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "DELETE">>> = Prettify<UnionToIntersection<MethodOptions<API, "DELETE">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends false ? K : never), options?: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : FetchRequestOptions<C["body"], C["query"], C["params"]>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    patch<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "PATCH">>> = Prettify<UnionToIntersection<MethodOptions<API, "PATCH">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends true ? K : never), options: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : WithRequired<FetchRequestOptions<C["body"], C["query"], C["params"]>, keyof RequiredOptionKeys<C>>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    patch<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "PATCH">>> = Prettify<UnionToIntersection<MethodOptions<API, "PATCH">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends false ? K : never), options?: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : FetchRequestOptions<C["body"], C["query"], C["params"]>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    put<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "PUT">>> = Prettify<UnionToIntersection<MethodOptions<API, "PUT">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends true ? K : never), options: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : WithRequired<FetchRequestOptions<C["body"], C["query"], C["params"]>, keyof RequiredOptionKeys<C>>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    put<API extends InferredAPI<R> = InferredAPI<R>, OPT extends Prettify<UnionToIntersection<MethodOptions<API, "PUT">>> = Prettify<UnionToIntersection<MethodOptions<API, "PUT">>>, K extends keyof OPT = keyof OPT, C extends InferContext<OPT[K]> = InferContext<OPT[K]>>(path: IsAnyOrAnyIndexed<R> extends true ? string : (HasRequired<C> extends false ? K : never), options?: IsAnyOrAnyIndexed<R> extends true ? FetchRequestOptions<any, any, any> : FetchRequestOptions<C["body"], C["query"], C["params"]>): Promise<FetchResponse<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    protected executeRequest<M extends HTTPMethod>(method: M, path: any, requestOptions?: any): Promise<any>;
+}
+export {};

package/lib/src/HTTP_bkp.d.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import * as httpie from "@colyseus/httpie";
+import { ColyseusSDK } from "./Client.ts";
+export declare class HTTP {
+    protected sdk: ColyseusSDK;
+    headers: {
+        [id: string]: string;
+    };
+    authToken: string | undefined;
+    constructor(sdk: ColyseusSDK, headers?: {
+        [id: string]: string;
+    });
+    get<T = any>(path: string, options?: Partial<httpie.Options>): Promise<httpie.Response<T>>;
+    post<T = any>(path: string, options?: Partial<httpie.Options>): Promise<httpie.Response<T>>;
+    del<T = any>(path: string, options?: Partial<httpie.Options>): Promise<httpie.Response<T>>;
+    put<T = any>(path: string, options?: Partial<httpie.Options>): Promise<httpie.Response<T>>;
+    protected request(method: "get" | "post" | "put" | "del", path: string, options?: Partial<httpie.Options>): Promise<httpie.Response>;
+    protected getOptions(options: Partial<httpie.Options>): Partial<httpie.Options>;
+}

package/lib/src/Protocol.d.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import { RoomAvailable } from "./Room.ts";
+export interface SeatReservation {
+    room: RoomAvailable;
+    sessionId: string;
+    reconnectionToken?: string;
+    devMode?: boolean;
+    protocol?: string;
+}
+export declare enum Protocol {
+    HANDSHAKE = 9,
+    JOIN_ROOM = 10,
+    ERROR = 11,
+    LEAVE_ROOM = 12,
+    ROOM_DATA = 13,
+    ROOM_STATE = 14,
+    ROOM_STATE_PATCH = 15,
+    ROOM_DATA_SCHEMA = 16,
+    ROOM_DATA_BYTES = 17
+}
+export declare enum ErrorCode {
+    MATCHMAKE_NO_HANDLER = 4210,
+    MATCHMAKE_INVALID_CRITERIA = 4211,
+    MATCHMAKE_INVALID_ROOM_ID = 4212,
+    MATCHMAKE_UNHANDLED = 4213,
+    MATCHMAKE_EXPIRED = 4214,
+    AUTH_FAILED = 4215,
+    APPLICATION_ERROR = 4216
+}

package/lib/src/Room.d.ts ADDED Viewed

@@ -0,0 +1,132 @@
+import { type Room as ServerRoom, type ExtractMessageType } from '@colyseus/core';
+import { Packr } from '@colyseus/msgpackr';
+import { Connection } from './Connection.ts';
+import { Serializer } from './serializer/Serializer.ts';
+import { SchemaConstructor } from './serializer/SchemaSerializer.ts';
+export interface RoomAvailable<Metadata = any> {
+    name: string;
+    roomId: string;
+    clients: number;
+    maxClients: number;
+    metadata?: Metadata;
+}
+export interface ReconnectionOptions {
+    /**
+     * The maximum number of reconnection attempts.
+     */
+    maxRetries: number;
+    /**
+     * The minimum delay between reconnection attempts.
+     */
+    minDelay: number;
+    /**
+     * The maximum delay between reconnection attempts.
+     */
+    maxDelay: number;
+    /**
+     * The minimum uptime of the room before reconnection attempts can be made.
+     */
+    minUptime: number;
+    /**
+     * The current number of reconnection attempts.
+     */
+    retryCount: number;
+    /**
+     * The initial delay between reconnection attempts.
+     */
+    delay: number;
+    /**
+     * The function to calculate the delay between reconnection attempts.
+     * @param attempt - The current attempt number.
+     * @param delay - The initial delay between reconnection attempts.
+     * @returns The delay between reconnection attempts.
+     */
+    backoff: (attempt: number, delay: number) => number;
+    /**
+     * The maximum number of enqueued messages to buffer.
+     */
+    maxEnqueuedMessages: number;
+    /**
+     * Buffer for messages sent while connection is not open.
+     * These messages will be sent once the connection is re-established.
+     */
+    enqueuedMessages: Array<{
+        data: Uint8Array;
+    }>;
+}
+export declare class Room<RoomType extends typeof ServerRoom = any, State = RoomType['prototype']['state']> {
+    roomId: string;
+    sessionId: string;
+    reconnectionToken: string;
+    name: string;
+    connection: Connection;
+    onStateChange: {
+        once: (cb: (state: State) => void) => void;
+        remove: (cb: (state: State) => void) => void;
+        invoke: (state: State) => void;
+        invokeAsync: (state: State) => Promise<any[]>;
+        clear: () => void;
+    } & ((this: any, cb: (state: State) => void) => import("./core/signal.ts").EventEmitter<(state: State) => void>);
+    onError: {
+        once: (cb: (code: number, message?: string) => void) => void;
+        remove: (cb: (code: number, message?: string) => void) => void;
+        invoke: (code: number, message?: string) => void;
+        invokeAsync: (code: number, message?: string) => Promise<any[]>;
+        clear: () => void;
+    } & ((this: any, cb: (code: number, message?: string) => void) => import("./core/signal.ts").EventEmitter<(code: number, message?: string) => void>);
+    onLeave: {
+        once: (cb: (code: number, reason?: string) => void) => void;
+        remove: (cb: (code: number, reason?: string) => void) => void;
+        invoke: (code: number, reason?: string) => void;
+        invokeAsync: (code: number, reason?: string) => Promise<any[]>;
+        clear: () => void;
+    } & ((this: any, cb: (code: number, reason?: string) => void) => import("./core/signal.ts").EventEmitter<(code: number, reason?: string) => void>);
+    onReconnect: {
+        once: (cb: () => void) => void;
+        remove: (cb: () => void) => void;
+        invoke: () => void;
+        invokeAsync: () => Promise<any[]>;
+        clear: () => void;
+    } & ((this: any, cb: () => void) => import("./core/signal.ts").EventEmitter<() => void>);
+    onDrop: {
+        once: (cb: (code: number, reason?: string) => void) => void;
+        remove: (cb: (code: number, reason?: string) => void) => void;
+        invoke: (code: number, reason?: string) => void;
+        invokeAsync: (code: number, reason?: string) => Promise<any[]>;
+        clear: () => void;
+    } & ((this: any, cb: (code: number, reason?: string) => void) => import("./core/signal.ts").EventEmitter<(code: number, reason?: string) => void>);
+    protected onJoin: {
+        once: (cb: (...args: any[]) => void | Promise<any>) => void;
+        remove: (cb: (...args: any[]) => void | Promise<any>) => void;
+        invoke: (...args: any[]) => void;
+        invokeAsync: (...args: any[]) => Promise<any[]>;
+        clear: () => void;
+    } & ((this: any, cb: (...args: any[]) => void | Promise<any>) => import("./core/signal.ts").EventEmitter<(...args: any[]) => void | Promise<any>>);
+    serializerId: string;
+    serializer: Serializer<State>;
+    reconnection: ReconnectionOptions;
+    protected joinedAtTime: number;
+    protected onMessageHandlers: {
+        emit(event: string, ...args: any[]): void;
+        events: {};
+        on(event: string, cb: (...args: any[]) => void): () => void;
+    };
+    protected packr: Packr;
+    constructor(name: string, rootSchema?: SchemaConstructor<State>);
+    connect(endpoint: string, options?: any, headers?: any): void;
+    leave(consented?: boolean): Promise<number>;
+    onMessage<MessageType extends keyof RoomType['prototype']['~client']['~messages']>(message: MessageType, callback: (payload: RoomType['prototype']['~client']['~messages'][MessageType]) => void): any;
+    onMessage<T = any>(type: "*", callback: (messageType: string | number, payload: T) => void): any;
+    onMessage<T = any>(type: string | number, callback: (payload: T) => void): any;
+    send<MessageType extends keyof RoomType['prototype']['messages']>(messageType: MessageType, payload?: ExtractMessageType<RoomType['prototype']['messages'][MessageType]>): any;
+    sendUnreliable<T = any>(type: string | number, message?: T): void;
+    sendBytes(type: string | number, bytes: Uint8Array): void;
+    get state(): State;
+    removeAllListeners(): void;
+    protected onMessageCallback(event: MessageEvent): void;
+    private dispatchMessage;
+    private destroy;
+    private getMessageHandlerKey;
+    private handleReconnection;
+    private retryReconnection;
+}

package/lib/src/Storage.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export declare function setItem(key: string, value: string): void;
+export declare function removeItem(key: string): void;
+export declare function getItem(key: string, callback: Function): void;

package/lib/src/core/http_bkp.d.ts ADDED Viewed

@@ -0,0 +1,319 @@
+import type { Router, HasRequiredKeys, Prettify, UnionToIntersection, Endpoint, HTTPMethod } from "@colyseus/better-call";
+type HasRequired<T extends {
+    body?: any;
+    query?: any;
+    params?: any;
+}> = HasRequiredKeys<T["body"]> extends true ? true : HasRequiredKeys<T["query"]> extends true ? true : HasRequiredKeys<T["params"]> extends true ? true : false;
+type InferContext<T> = T extends (ctx: infer Ctx) => any ? Ctx extends object ? Ctx : never : never;
+type WithRequired<T, K> = T & {
+    [P in K extends string ? K : never]-?: T[P extends keyof T ? P : never];
+};
+type WithoutServerOnly<T extends Record<string, Endpoint>> = {
+    [K in keyof T]: T[K] extends Endpoint<any, infer O> ? O extends {
+        metadata: {
+            SERVER_ONLY: true;
+        };
+    } ? never : T[K] : T[K];
+};
+type MethodOptions<API, M extends HTTPMethod> = API extends {
+    [key: string]: infer T;
+} ? T extends Endpoint<any, infer O> ? O["method"] extends M ? {
+    [key in T["path"]]: T;
+} : O["method"] extends M[] ? M extends O["method"][number] ? {
+    [key in T["path"]]: T;
+} : {} : O["method"] extends "*" ? {
+    [key in T["path"]]: T;
+} : {} : {} : {};
+export type RequiredOptionKeys<C extends {
+    body?: any;
+    query?: any;
+    params?: any;
+}> = (undefined extends C["body"] ? {} : {
+    body: true;
+}) & (undefined extends C["query"] ? {} : {
+    query: true;
+}) & (undefined extends C["params"] ? {} : {
+    params: true;
+});
+export interface ClientOptions extends FetchRequestOptions {
+    baseURL: string;
+}
+type CommonHeaders = {
+    accept: "application/json" | "text/plain" | "application/octet-stream";
+    "content-type": "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+    authorization: "Bearer" | "Basic";
+};
+type FetchRequestOptions<Body = any, Query extends Record<string, any> = any, Params extends Record<string, any> | Array<string> | undefined = any, Res = any, ExtraOptions extends Record<string, any> = {}> = Prettify<ExtraOptions & Omit<RequestInit, "body"> & {
+    baseURL?: string;
+    /**
+     * Headers
+     */
+    headers?: CommonHeaders | Headers | HeadersInit;
+    /**
+     * Body
+     */
+    body?: Body;
+    /**
+     * Query parameters (key-value pairs)
+     */
+    query?: Query;
+    /**
+     * Dynamic parameters.
+     *
+     * If url is defined as /path/:id, params will be { id: string }
+     */
+    params?: Params;
+}>;
+type ResponseData<T> = {
+    ok: true;
+    data: T;
+    error: null;
+    response: Response;
+    headers: Headers;
+    status: number;
+    statusText: string;
+};
+type ResponseError<E> = {
+    ok: false;
+    data: null;
+    error: Prettify<(E extends Record<string, any> ? E : {
+        message?: string;
+    }) & {
+        code?: string;
+    }>;
+    response: Response;
+    headers: Headers;
+    status: number;
+    statusText: string;
+};
+export declare function isJSONSerializable(value: any): boolean;
+export type ResponseType = "json" | "text" | "blob";
+export declare function detectResponseType(request: Response): ResponseType;
+export declare const createClient: <R extends Router | Router["endpoints"]>(baseOptions: ClientOptions) => {
+    get: <OPT extends UnionToIntersection<MethodOptions<WithoutServerOnly<R extends {
+        endpoints: Record<string, Endpoint>;
+    } ? R["endpoints"] : R>, "GET">> extends infer T ? { [K_1 in keyof T]: T[K_1]; } : never, K extends keyof OPT, C extends InferContext<OPT[K]>>(path: K, ...options: HasRequired<C> extends true ? [WithRequired<{
+        cache?: RequestCache;
+        method?: string;
+        signal?: AbortSignal | null;
+        mode?: RequestMode;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        window?: null;
+        baseURL?: string;
+        body?: C["body"];
+        query?: C["query"];
+        params?: C["params"];
+    }, keyof (undefined extends C["body"] ? {} : {
+        body: true;
+    }) | keyof (undefined extends C["query"] ? {} : {
+        query: true;
+    }) | keyof (undefined extends C["params"] ? {} : {
+        params: true;
+    })>] : [{
+        cache?: RequestCache;
+        method?: string;
+        signal?: AbortSignal | null;
+        mode?: RequestMode;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        window?: null;
+        baseURL?: string;
+        body?: C["body"];
+        query?: C["query"];
+        params?: C["params"];
+    }?]) => Promise<ResponseError<unknown> | ResponseData<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    post: <OPT extends UnionToIntersection<MethodOptions<WithoutServerOnly<R extends {
+        endpoints: Record<string, Endpoint>;
+    } ? R["endpoints"] : R>, "POST">> extends infer T ? { [K_1 in keyof T]: T[K_1]; } : never, K extends keyof OPT, C extends InferContext<OPT[K]>>(path: K, ...options: HasRequired<C> extends true ? [WithRequired<{
+        cache?: RequestCache;
+        method?: string;
+        signal?: AbortSignal | null;
+        mode?: RequestMode;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        window?: null;
+        baseURL?: string;
+        body?: C["body"];
+        query?: C["query"];
+        params?: C["params"];
+    }, keyof (undefined extends C["body"] ? {} : {
+        body: true;
+    }) | keyof (undefined extends C["query"] ? {} : {
+        query: true;
+    }) | keyof (undefined extends C["params"] ? {} : {
+        params: true;
+    })>] : [{
+        cache?: RequestCache;
+        method?: string;
+        signal?: AbortSignal | null;
+        mode?: RequestMode;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        window?: null;
+        baseURL?: string;
+        body?: C["body"];
+        query?: C["query"];
+        params?: C["params"];
+    }?]) => Promise<ResponseError<unknown> | ResponseData<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    delete: <OPT extends UnionToIntersection<MethodOptions<WithoutServerOnly<R extends {
+        endpoints: Record<string, Endpoint>;
+    } ? R["endpoints"] : R>, "DELETE">> extends infer T ? { [K_1 in keyof T]: T[K_1]; } : never, K extends keyof OPT, C extends InferContext<OPT[K]>>(path: K, ...options: HasRequired<C> extends true ? [WithRequired<{
+        cache?: RequestCache;
+        method?: string;
+        signal?: AbortSignal | null;
+        mode?: RequestMode;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        window?: null;
+        baseURL?: string;
+        body?: C["body"];
+        query?: C["query"];
+        params?: C["params"];
+    }, keyof (undefined extends C["body"] ? {} : {
+        body: true;
+    }) | keyof (undefined extends C["query"] ? {} : {
+        query: true;
+    }) | keyof (undefined extends C["params"] ? {} : {
+        params: true;
+    })>] : [{
+        cache?: RequestCache;
+        method?: string;
+        signal?: AbortSignal | null;
+        mode?: RequestMode;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        window?: null;
+        baseURL?: string;
+        body?: C["body"];
+        query?: C["query"];
+        params?: C["params"];
+    }?]) => Promise<ResponseError<unknown> | ResponseData<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    patch: <OPT extends UnionToIntersection<MethodOptions<WithoutServerOnly<R extends {
+        endpoints: Record<string, Endpoint>;
+    } ? R["endpoints"] : R>, "PATCH">> extends infer T ? { [K_1 in keyof T]: T[K_1]; } : never, K extends keyof OPT, C extends InferContext<OPT[K]>>(path: K, ...options: HasRequired<C> extends true ? [WithRequired<{
+        cache?: RequestCache;
+        method?: string;
+        signal?: AbortSignal | null;
+        mode?: RequestMode;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        window?: null;
+        baseURL?: string;
+        body?: C["body"];
+        query?: C["query"];
+        params?: C["params"];
+    }, keyof (undefined extends C["body"] ? {} : {
+        body: true;
+    }) | keyof (undefined extends C["query"] ? {} : {
+        query: true;
+    }) | keyof (undefined extends C["params"] ? {} : {
+        params: true;
+    })>] : [{
+        cache?: RequestCache;
+        method?: string;
+        signal?: AbortSignal | null;
+        mode?: RequestMode;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        window?: null;
+        baseURL?: string;
+        body?: C["body"];
+        query?: C["query"];
+        params?: C["params"];
+    }?]) => Promise<ResponseError<unknown> | ResponseData<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+    put: <OPT extends UnionToIntersection<MethodOptions<WithoutServerOnly<R extends {
+        endpoints: Record<string, Endpoint>;
+    } ? R["endpoints"] : R>, "PUT">> extends infer T ? { [K_1 in keyof T]: T[K_1]; } : never, K extends keyof OPT, C extends InferContext<OPT[K]>>(path: K, ...options: HasRequired<C> extends true ? [WithRequired<{
+        cache?: RequestCache;
+        method?: string;
+        signal?: AbortSignal | null;
+        mode?: RequestMode;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        window?: null;
+        baseURL?: string;
+        body?: C["body"];
+        query?: C["query"];
+        params?: C["params"];
+    }, keyof (undefined extends C["body"] ? {} : {
+        body: true;
+    }) | keyof (undefined extends C["query"] ? {} : {
+        query: true;
+    }) | keyof (undefined extends C["params"] ? {} : {
+        params: true;
+    })>] : [{
+        cache?: RequestCache;
+        method?: string;
+        signal?: AbortSignal | null;
+        mode?: RequestMode;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        window?: null;
+        baseURL?: string;
+        body?: C["body"];
+        query?: C["query"];
+        params?: C["params"];
+    }?]) => Promise<ResponseError<unknown> | ResponseData<Awaited<ReturnType<OPT[K] extends Endpoint ? OPT[K] : never>>>>;
+};
+export {};

package/lib/src/core/nanoevents.d.ts ADDED Viewed

@@ -0,0 +1,27 @@
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright 2016 Andrey Sitnik <andrey@sitnik.ru>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+export declare const createNanoEvents: () => {
+    emit(event: string, ...args: any[]): void;
+    events: {};
+    on(event: string, cb: (...args: any[]) => void): () => void;
+};