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/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;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        mode?: RequestMode;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        signal?: AbortSignal | null;
+        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;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        mode?: RequestMode;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        signal?: AbortSignal | null;
+        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;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        mode?: RequestMode;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        signal?: AbortSignal | null;
+        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;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        mode?: RequestMode;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        signal?: AbortSignal | null;
+        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;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        mode?: RequestMode;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        signal?: AbortSignal | null;
+        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;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        mode?: RequestMode;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        signal?: AbortSignal | null;
+        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;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        mode?: RequestMode;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        signal?: AbortSignal | null;
+        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;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        mode?: RequestMode;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        signal?: AbortSignal | null;
+        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;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        mode?: RequestMode;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        signal?: AbortSignal | null;
+        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;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit & (HeadersInit | CommonHeaders);
+        integrity?: string;
+        keepalive?: boolean;
+        mode?: RequestMode;
+        priority?: RequestPriority;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: ReferrerPolicy;
+        signal?: AbortSignal | null;
+        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/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;
+};

package/lib/core/signal.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+type FunctionParameters<T extends (...args: any[]) => any> = T extends (...args: infer P) => any ? P : never;
+export declare class EventEmitter<CallbackSignature extends (...args: any[]) => any> {
+    handlers: Array<CallbackSignature>;
+    register(cb: CallbackSignature, once?: boolean): this;
+    invoke(...args: FunctionParameters<CallbackSignature>): void;
+    invokeAsync(...args: FunctionParameters<CallbackSignature>): Promise<any[]>;
+    remove(cb: CallbackSignature): void;
+    clear(): void;
+}
+export declare function createSignal<CallbackSignature extends (...args: any[]) => void | Promise<any>>(): {
+    once: (cb: CallbackSignature) => void;
+    remove: (cb: CallbackSignature) => void;
+    invoke: (...args: FunctionParameters<CallbackSignature>) => void;
+    invokeAsync: (...args: FunctionParameters<CallbackSignature>) => Promise<any[]>;
+    clear: () => void;
+} & ((this: any, cb: CallbackSignature) => EventEmitter<CallbackSignature>);
+export {};

package/lib/core/utils.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export declare function now(): number;

package/lib/debug.d.ts ADDED Viewed

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

package/lib/errors/Errors.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+export declare enum CloseCode {
+    NORMAL_CLOSURE = 1000,
+    GOING_AWAY = 1001,
+    NO_STATUS_RECEIVED = 1005,
+    ABNORMAL_CLOSURE = 1006,
+    CONSENTED = 4000,
+    SERVER_SHUTDOWN = 4001,
+    WITH_ERROR = 4002,
+    DEVMODE_RESTART = 4010
+}
+export declare class ServerError extends Error {
+    code: number;
+    constructor(code: number, message: string);
+}
+export declare class AbortError extends Error {
+    constructor(message: string);
+}

package/lib/index.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import './legacy';
+export { ColyseusSDK, Client, MatchMakeError, type JoinOptions, type EndpointSettings, type ClientOptions, type ISeatReservation as SeatReservation } from './Client.ts';
+export { Protocol, ErrorCode } from './Protocol.ts';
+export { Room, type RoomAvailable } from './Room.ts';
+export { Auth, type AuthSettings, type PopupSettings } from "./Auth.ts";
+export { ServerError, CloseCode } from './errors/Errors.ts';
+import { SchemaSerializer, getStateCallbacks } from "./serializer/SchemaSerializer.ts";
+import { registerSerializer } from './serializer/Serializer.ts';
+export { registerSerializer, SchemaSerializer, getStateCallbacks };

package/lib/legacy.d.ts ADDED Viewed

File without changes

package/lib/serializer/FossilDeltaSerializer.d.ts ADDED Viewed

File without changes

package/lib/serializer/NoneSerializer.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import type { Serializer } from "./Serializer.ts";
+export declare class NoneSerializer<T = any> implements Serializer<T> {
+    setState(rawState: any): void;
+    getState(): any;
+    patch(patches: any): void;
+    teardown(): void;
+    handshake(bytes: Uint8Array): void;
+}

package/lib/serializer/SchemaSerializer.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import { Schema, Decoder, Iterator } from "@colyseus/schema";
+import type { Serializer } from "./Serializer.ts";
+import type { Room } from "../Room.ts";
+export type SchemaConstructor<T = Schema> = new (...args: any[]) => T;
+export declare function getStateCallbacks<T>(room: Room<any, T>): import("@colyseus/schema").SchemaCallbackProxy<T>;
+export declare class SchemaSerializer<T extends Schema = any> implements Serializer<T> {
+    state: T;
+    decoder: Decoder<T>;
+    setState(encodedState: Uint8Array, it?: Iterator): void;
+    getState(): T;
+    patch(patches: Uint8Array, it?: Iterator): import("@colyseus/schema").DataChange<any, string>[];
+    teardown(): void;
+    handshake(bytes: Uint8Array, it?: Iterator): void;
+}

package/lib/serializer/Serializer.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import type { Iterator } from "@colyseus/schema";
+export interface Serializer<State> {
+    setState(data: Uint8Array, it?: Iterator): void;
+    getState(): State;
+    patch(data: Uint8Array, it?: Iterator): void;
+    teardown(): void;
+    handshake?(bytes: Uint8Array, it?: any): void;
+}
+export declare function registerSerializer(id: string, serializer: any): void;
+export declare function getSerializer(id: string): any;

package/lib/src/3rd_party/discord.d.ts ADDED Viewed

@@ -0,0 +1,33 @@
+/**
+ * Discord Embedded App SDK
+ * https://github.com/colyseus/colyseus/issues/707
+ *
+ * All URLs must go through the local proxy from
+ * https://<app_id>.discordsays.com/.proxy/<mapped_url>/...
+ *
+ * URL Mapping Examples:
+ *
+ * 1. Using Colyseus Cloud:
+ *   - /colyseus/{subdomain} -> {subdomain}.colyseus.cloud
+ *
+ *   Example:
+ *     const client = new Client("https://xxxx.colyseus.cloud");
+ *
+ * -------------------------------------------------------------
+ *
+ * 2. Using `cloudflared` tunnel:
+ *   - /colyseus/ -> <your-cloudflared-url>.trycloudflare.com
+ *
+ *   Example:
+ *     const client = new Client("https://<your-cloudflared-url>.trycloudflare.com");
+ *
+ * -------------------------------------------------------------
+ *
+ * 3. Providing a manual /.proxy/your-mapping:
+ *   - /your-mapping/ -> your-endpoint.com
+ *
+ *   Example:
+ *     const client = new Client("/.proxy/your-mapping");
+ *
+ */
+export declare function discordURLBuilder(url: URL): string;

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

@@ -0,0 +1,31 @@
+import { HTTP } from "./HTTP.ts";
+export interface AuthSettings {
+    path: string;
+    key: string;
+}
+export interface PopupSettings {
+    prefix: string;
+    width: number;
+    height: number;
+}
+export interface AuthData {
+    user: any;
+    token: string;
+}
+export declare class Auth {
+    #private;
+    settings: AuthSettings;
+    protected http: HTTP<any>;
+    constructor(http: HTTP<any>);
+    set token(token: string);
+    get token(): string | undefined;
+    onChange(callback: (response: AuthData) => void): () => void;
+    getUserData(): Promise<null>;
+    registerWithEmailAndPassword(email: string, password: string, options?: any): Promise<null>;
+    signInWithEmailAndPassword(email: string, password: string): Promise<null>;
+    signInAnonymously(options?: any): Promise<null>;
+    sendPasswordResetEmail(email: string): Promise<null>;
+    signInWithProvider(providerName: string, settings?: Partial<PopupSettings>): Promise<unknown>;
+    signOut(): Promise<void>;
+    private emitChange;
+}

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

@@ -0,0 +1,62 @@
+import type { SDKTypes, Room as ServerRoom } from '@colyseus/core';
+import { Room } from './Room.ts';
+import { SchemaConstructor } from './serializer/SchemaSerializer.ts';
+import { HTTP } from './HTTP.ts';
+import { Auth } from './Auth.ts';
+import { SeatReservation } from './Protocol.ts';
+export type JoinOptions = any;
+export declare class MatchMakeError extends Error {
+    code: number;
+    constructor(message: string, code: number);
+}
+export interface EndpointSettings {
+    hostname: string;
+    secure: boolean;
+    port?: number;
+    pathname?: string;
+    searchParams?: string;
+}
+export interface ClientOptions {
+    headers?: {
+        [id: string]: string;
+    };
+    urlBuilder?: (url: URL) => string;
+}
+export declare class ColyseusSDK<ServerType extends SDKTypes = any> {
+    static VERSION: string;
+    http: HTTP<ServerType['~routes']>;
+    auth: Auth;
+    protected settings: EndpointSettings;
+    protected urlBuilder: (url: URL) => string;
+    constructor(settings?: string | EndpointSettings, options?: ClientOptions);
+    joinOrCreate<R extends keyof ServerType['~rooms']>(roomName: R, options?: Parameters<ServerType['~rooms'][R]['~room']['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<ServerType>): Promise<Room<ServerType['~rooms'][R]['~room']>>;
+    joinOrCreate<RoomType extends typeof ServerRoom>(roomName: string, options?: Parameters<RoomType['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<RoomType['prototype']['state']>): Promise<Room<RoomType>>;
+    joinOrCreate<State = any>(roomName: string, options?: JoinOptions, rootSchema?: SchemaConstructor<State>): Promise<Room<any, State>>;
+    create<R extends keyof ServerType['~rooms']>(roomName: R, options?: Parameters<ServerType['~rooms'][R]['~room']['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<ServerType>): Promise<Room<ServerType['~rooms'][R]['~room']>>;
+    create<RoomType extends typeof ServerRoom>(roomName: string, options?: Parameters<RoomType['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<RoomType['prototype']['state']>): Promise<Room<RoomType>>;
+    create<State = any>(roomName: string, options?: JoinOptions, rootSchema?: SchemaConstructor<State>): Promise<Room<any, State>>;
+    join<R extends keyof ServerType['~rooms']>(roomName: R, options?: Parameters<ServerType['~rooms'][R]['~room']['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<ServerType>): Promise<Room<ServerType['~rooms'][R]['~room']>>;
+    join<RoomType extends typeof ServerRoom>(roomName: string, options?: Parameters<RoomType['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<RoomType['prototype']['state']>): Promise<Room<RoomType>>;
+    join<State = any>(roomName: string, options?: JoinOptions, rootSchema?: SchemaConstructor<State>): Promise<Room<any, State>>;
+    joinById<R extends keyof ServerType['~rooms']>(roomName: R, options?: Parameters<ServerType['~rooms'][R]['~room']['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<ServerType>): Promise<Room<ServerType['~rooms'][R]['~room']>>;
+    joinById<RoomType extends typeof ServerRoom>(roomId: string, options?: Parameters<RoomType['prototype']['onJoin']>[1], rootSchema?: SchemaConstructor<RoomType['prototype']['state']>): Promise<Room<RoomType>>;
+    joinById<State = any>(roomId: string, options?: JoinOptions, rootSchema?: SchemaConstructor<State>): Promise<Room<any, State>>;
+    /**
+     * Re-establish connection with a room this client was previously connected to.
+     *
+     * @param reconnectionToken The `room.reconnectionToken` from previously connected room.
+     * @param rootSchema (optional) Concrete root schema definition
+     * @returns Promise<Room>
+     */
+    reconnect<R extends keyof ServerType['~rooms']>(reconnectionToken: string, roomName?: R): Promise<Room<ServerType['~rooms'][R]['~room']>>;
+    reconnect<RoomType extends typeof ServerRoom>(reconnectionToken: string, rootSchema?: SchemaConstructor<RoomType['prototype']['state']>): Promise<Room<RoomType>>;
+    reconnect<State = any>(reconnectionToken: string, rootSchema?: SchemaConstructor<State>): Promise<Room<any, State>>;
+    consumeSeatReservation<T>(response: SeatReservation, rootSchema?: SchemaConstructor<T>): Promise<Room<any, T>>;
+    protected createMatchMakeRequest<T>(method: string, roomName: string, options?: JoinOptions, rootSchema?: SchemaConstructor<T>): Promise<Room<any, T>>;
+    protected createRoom<T>(roomName: string, rootSchema?: SchemaConstructor<T>): Room<any, T>;
+    protected buildEndpoint(room: any, options?: any, protocol?: string): string;
+    protected getHttpEndpoint(segments?: string): string;
+    protected getEndpointPort(): string;
+}
+export declare const Client: typeof ColyseusSDK;
+export type Client = InstanceType<typeof ColyseusSDK>;

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

@@ -0,0 +1,17 @@
+import type { ITransport, ITransportEventMap } from "./transport/ITransport.ts";
+export declare class Connection implements ITransport {
+    transport: ITransport;
+    events: ITransportEventMap;
+    url?: string;
+    options?: any;
+    constructor(protocol?: string);
+    connect(url: string, options?: any): void;
+    send(data: Buffer | Uint8Array): void;
+    sendUnreliable(data: Buffer | Uint8Array): void;
+    reconnect(queryParams: {
+        reconnectionToken: string;
+        skipHandshake?: boolean;
+    }): void;
+    close(code?: number, reason?: string): void;
+    get isOpen(): boolean;
+}