@4players/odin-common 4.0.0 → 4.0.1

package/schema/serialization.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export declare const ByteArraySchema: z.ZodType<Uint8Array<ArrayBufferLike>, z.ZodTypeDef, Uint8Array<ArrayBufferLike>>;
+export type ByteArray = z.infer<typeof ByteArraySchema>;
+declare const LiteralSchema: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+type Literal = z.infer<typeof LiteralSchema>;
+export type Json = Literal | {
+    [key: string]: Json;
+} | Json[];
+export declare const JsonSchema: z.ZodType<Json>;
+export declare const MessagePackRpcSchema: z.ZodUnion<[z.ZodTuple<[z.ZodLiteral<0>, z.ZodNumber, z.ZodString, z.ZodUnknown], null>, z.ZodTuple<[z.ZodLiteral<1>, z.ZodNumber, z.ZodNullable<z.ZodString>, z.ZodUnknown], null>, z.ZodTuple<[z.ZodLiteral<2>, z.ZodString, z.ZodUnknown], null>]>;
+export type MessagePackRpc = z.infer<typeof MessagePackRpcSchema>;
+export {};

package/schema/token.d.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+export declare const TokenAudienceSchema: z.ZodEnum<["sfu", "gateway"]>;
+export declare const TokenSubjectSchema: z.ZodEnum<["connect", "roomclose", "roomupdate", "roombanclient", "roomsendmessage"]>;
+export declare const TokenClaimsSchema: z.ZodObject<{
+    uid: z.ZodString;
+    cid: z.ZodOptional<z.ZodString>;
+    rid: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    nsp: z.ZodOptional<z.ZodString>;
+    adr: z.ZodOptional<z.ZodString>;
+    aud: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["sfu", "gateway"]>, z.ZodArray<z.ZodEnum<["sfu", "gateway"]>, "many">]>>;
+    sub: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["connect", "roomclose", "roomupdate", "roombanclient", "roomsendmessage"]>, z.ZodArray<z.ZodEnum<["connect", "roomclose", "roomupdate", "roombanclient", "roomsendmessage"]>, "many">]>>;
+    exp: z.ZodOptional<z.ZodNumber>;
+    nbf: z.ZodOptional<z.ZodNumber>;
+    ups: z.ZodOptional<z.ZodString>;
+    tgs: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    tsp: z.ZodOptional<z.ZodNumber>;
+    internal: z.ZodOptional<z.ZodObject<{
+        server: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        server?: string;
+    }, {
+        server?: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    sub?: "connect" | "roomclose" | "roomupdate" | "roombanclient" | "roomsendmessage" | ("connect" | "roomclose" | "roomupdate" | "roombanclient" | "roomsendmessage")[];
+    internal?: {
+        server?: string;
+    };
+    uid?: string;
+    cid?: string;
+    rid?: string | string[];
+    nsp?: string;
+    adr?: string;
+    aud?: "sfu" | "gateway" | ("sfu" | "gateway")[];
+    exp?: number;
+    nbf?: number;
+    ups?: string;
+    tgs?: string | string[];
+    tsp?: number;
+}, {
+    sub?: "connect" | "roomclose" | "roomupdate" | "roombanclient" | "roomsendmessage" | ("connect" | "roomclose" | "roomupdate" | "roombanclient" | "roomsendmessage")[];
+    internal?: {
+        server?: string;
+    };
+    uid?: string;
+    cid?: string;
+    rid?: string | string[];
+    nsp?: string;
+    adr?: string;
+    aud?: "sfu" | "gateway" | ("sfu" | "gateway")[];
+    exp?: number;
+    nbf?: number;
+    ups?: string;
+    tgs?: string | string[];
+    tsp?: number;
+}>;
+export type TokenClaims = z.infer<typeof TokenClaimsSchema>;
+export declare function oneOrMany<T extends z.ZodTypeAny>(type: T): z.ZodUnion<[T, z.ZodArray<T, "many">]>;

package/schema/webrtc.d.ts

@@ -0,0 +1,42 @@
+import * as z from "zod";
+export declare const WebRtcUpdateSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"Sdp">;
+    type: z.ZodEnum<["Answer", "Offer"]>;
+    sdp: z.ZodString;
+    media_map: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodString], null>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type?: "Answer" | "Offer";
+    kind?: "Sdp";
+    sdp?: string;
+    media_map?: [number, string, ...unknown[]][];
+}, {
+    type?: "Answer" | "Offer";
+    kind?: "Sdp";
+    sdp?: string;
+    media_map?: [number, string, ...unknown[]][];
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"Trickle">;
+    candidate: z.ZodString;
+    spd_mid: z.ZodOptional<z.ZodString>;
+    spd_mline_index: z.ZodOptional<z.ZodNumber>;
+    username_fragment: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+}, "strip", z.ZodTypeAny, {
+    candidate?: string;
+    kind?: "Trickle";
+    spd_mid?: string;
+    spd_mline_index?: number;
+    username_fragment?: string;
+}, {
+    candidate?: string;
+    kind?: "Trickle";
+    spd_mid?: string;
+    spd_mline_index?: number;
+    username_fragment?: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"TrickleFinished">;
+}, "strip", z.ZodTypeAny, {
+    kind?: "TrickleFinished";
+}, {
+    kind?: "TrickleFinished";
+}>]>;
+export type WebRtcUpdate = z.infer<typeof WebRtcUpdateSchema>;

package/utility/base64.d.ts

@@ -0,0 +1,3 @@
+import { type Result } from "./result.ts";
+export declare function fromBase64(base64: string): Result<string>;
+export declare function fromBase64Url(base64uri: string): Result<string>;

package/utility/bytearray.d.ts

@@ -0,0 +1,4 @@
+import type { ByteArray, Json } from "../schema/serialization.ts";
+import { type Result } from "./result.ts";
+export declare function toBytes(value: Json): Result<ByteArray>;
+export declare function fromBytes(bytes: ByteArray): Result<Json>;

package/utility/codec.d.ts

@@ -0,0 +1,15 @@
+import { type Result } from "./result.ts";
+declare const validCodecs: readonly ["VP8", "VP9", "AV1", "H264"];
+export type Codec = (typeof validCodecs)[number];
+export declare class VideoCodec {
+    readonly codec: Codec;
+    readonly channels = 0;
+    readonly clockRate = 90000;
+    constructor(codec: Codec);
+    isValid(): boolean;
+    isSupported(): RTCRtpCodec | null;
+    getPayloadType(): Result<number>;
+    getMimeType(): Result<string>;
+    getSdpFmtpLine(): Result<string>;
+}
+export {};

package/utility/environment.d.ts

@@ -0,0 +1,6 @@
+export declare function isAudioCapable(): boolean;
+export declare function isSharedArrayBufferCapable(): boolean;
+export declare function isBlinkBrowser(): boolean;
+export declare function isElectronBrowser(): boolean;
+export declare function isFirefoxBrowser(): boolean;
+export declare function isSafariBrowser(): boolean;

package/utility/iterable.d.ts

@@ -0,0 +1 @@
+export declare function find<T>(entries: Iterable<T>, predicate: (entry: T) => boolean): T | undefined;

package/utility/json.d.ts

@@ -0,0 +1,2 @@
+import type { Json } from "../schema/serialization.ts";
+export declare function toRaw<T extends Json>(value: T): Json;

package/utility/log.d.ts

@@ -0,0 +1,79 @@
+import { type Result } from "./result.ts";
+export declare enum LogVerbosity {
+    NONE = 0,
+    ERROR = 1,
+    WARN = 2,
+    INFO = 3,
+    DEBUG = 4
+}
+export type LogLevel = (typeof LogVerbosity)[LogLevelName];
+export type LogLevelName = Exclude<keyof typeof LogVerbosity, number>;
+export declare const LogLevels: LogLevel[];
+export declare const LogLevelNames: LogLevelName[];
+export declare const LogSymbols: {
+    [Level in LogLevel]: string;
+};
+export declare const LogFunctions: {
+    [Level in LogLevel]: (...data: unknown[]) => void;
+};
+export declare function getLevelByName(name: LogLevelName): Result<LogLevel>;
+export declare function getLevelName(level: LogLevel): Result<LogLevelName>;
+export interface LoggerOptions {
+    handlers?: LogHandler[];
+}
+export declare function getLogger(name?: string): Logger;
+export declare function error<T>(msg: () => T, ...args: unknown[]): T | undefined;
+export declare function error<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+export declare function warn<T>(msg: () => T, ...args: unknown[]): T | undefined;
+export declare function warn<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+export declare function info<T>(msg: () => T, ...args: unknown[]): T | undefined;
+export declare function info<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+export declare function debug<T>(msg: () => T, ...args: unknown[]): T | undefined;
+export declare function debug<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+export declare class Logger {
+    readonly name: string;
+    private _Level;
+    private _Handlers;
+    constructor(level: LogLevel | LogLevelName, name?: string, options?: LoggerOptions);
+    get level(): LogLevel;
+    set level(value: LogLevel);
+    get levelName(): LogLevelName;
+    set levelName(value: LogLevelName);
+    get handlers(): LogHandler[];
+    addHandler(handler: LogHandler): void;
+    removeHandler(handler: LogHandler): void;
+    log<T>(level: LogLevel, msg: (T extends GenericFunction ? never : T) | (() => T), ...args: unknown[]): T | undefined;
+    error<T>(msg: () => T, ...args: unknown[]): T | undefined;
+    error<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+    warn<T>(msg: () => T, ...args: unknown[]): T | undefined;
+    warn<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+    info<T>(msg: () => T, ...args: unknown[]): T | undefined;
+    info<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+    debug<T>(msg: () => T, ...args: unknown[]): T | undefined;
+    debug<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+    private asString;
+}
+type GenericFunction = (...args: unknown[]) => unknown;
+type FormatterFunction = (record: LogRecord) => string;
+export interface LogRecord {
+    readonly date: Date;
+    readonly level: LogLevel;
+    readonly levelName: LogLevelName;
+    readonly logger: string;
+    readonly message: string;
+    readonly args: unknown[];
+}
+export declare const DEFAULT_FORMATTER: FormatterFunction;
+export declare const PRETTY_FORMATTER: FormatterFunction;
+export declare class LogHandler {
+    private _Level;
+    private _FormatterFn;
+    constructor(level: LogLevel | LogLevelName, formatter?: FormatterFunction);
+    get level(): LogLevel;
+    set level(value: LogLevel);
+    get levelName(): LogLevelName;
+    set levelName(value: LogLevelName);
+    handle(record: LogRecord): void;
+    log(formattedString: string, record: LogRecord): void;
+}
+export {};

package/utility/result.d.ts

@@ -0,0 +1,18 @@
+export declare function assert(condition: unknown, message: string): asserts condition;
+export declare function fail(message: string): never;
+export type Failure = {
+    type: "Failure";
+    reason: string;
+};
+export type Success<T> = {
+    type: "Success";
+    value: T;
+};
+export type Result<T> = Success<T> | Failure;
+export declare function success<T>(value: T): Success<T>;
+export declare function success(value: void): Success<void>;
+export declare function failure(reason: string): Failure;
+export declare function unwrap<T>(result: Result<T>): T;
+export declare function unwrapOr<T>(result: Result<T>, fallback: T): T;
+export type Accept<T> = (result: T) => void;
+export type Reject = (reason: Error) => void;

package/utility/selector.d.ts

@@ -0,0 +1,7 @@
+export declare class Selector<T extends Array<() => PromiseLike<U>>, U> {
+    private readonly _Generators;
+    private readonly _Futures;
+    constructor(_Generators: T);
+    next(): Promise<Awaited<ReturnType<T[number]>>>;
+    static addIndex<T>(generator: () => PromiseLike<T>, index: number): Promise<[T, number]>;
+}

package/utility/sleep.d.ts

@@ -0,0 +1,4 @@
+export declare function sleep(ms: number, value: void): Promise<void>;
+export declare function sleep<T extends string>(ms: number, value: T): Promise<T>;
+export declare function abortableSleep(ms: number, signal: AbortSignal): Promise<void | "aborted">;
+export declare function nextTick(): Promise<void>;

package/utility/strand.d.ts

@@ -0,0 +1,8 @@
+export declare class Strand<T extends unknown[] = []> {
+    private readonly _Tasks;
+    private _Running;
+    private _Values;
+    constructor(...values: T);
+    enqueue<U>(task: (...values: T) => Promise<U>): Promise<U>;
+    private execute;
+}

package/utility/url.d.ts

@@ -0,0 +1,3 @@
+import { type Result } from "./result.ts";
+export declare function normalizeUrl(url: string): Result<URL>;
+export declare function extendUrl(base: URL, path: string): Result<URL>;

package/utility/uuid.d.ts

@@ -0,0 +1,2 @@
+export declare function generateUUID(): string;
+export declare function validateUUID(uuid: string): boolean;

package/utility/validation.d.ts

@@ -0,0 +1,10 @@
+import type { Failure, Result, Success } from "./result.ts";
+export declare function isProperty<T extends object>(object: T, name: string): name is Extract<keyof T, string>;
+export declare function isFunction(value: unknown): value is (...args: [unknown]) => unknown;
+export declare function isNull(value: unknown): boolean;
+export declare function isNumber(value: unknown): value is number;
+export declare function isObject(value: unknown): value is object;
+export declare function isString(value: unknown): value is string;
+export declare function isUndefined(value: unknown): value is undefined;
+export declare function isFailure<T>(result: Result<T>): result is Failure;
+export declare function isSuccess<T>(result: Result<T>): result is Success<T>;