@4players/odin-common 3.2.0 → 4.0.0

package/lib/esm/utility/log.js

@@ -1,210 +0,0 @@
-import { failure, success, unwrap } from './result';
-import { isNumber } from './validation';
-export var LogVerbosity;
-(function (LogVerbosity) {
-    LogVerbosity[LogVerbosity["NONE"] = 0] = "NONE";
-    LogVerbosity[LogVerbosity["ERROR"] = 1] = "ERROR";
-    LogVerbosity[LogVerbosity["WARN"] = 2] = "WARN";
-    LogVerbosity[LogVerbosity["INFO"] = 3] = "INFO";
-    LogVerbosity[LogVerbosity["DEBUG"] = 4] = "DEBUG";
-})(LogVerbosity || (LogVerbosity = {}));
-export const LogLevels = Object.values(LogVerbosity).filter((key) => !isNaN(Number(key)));
-export const LogLevelNames = Object.keys(LogVerbosity).filter((key) => isNaN(Number(key)));
-export const LogSymbols = {
-    [LogVerbosity.NONE]: '⚫',
-    [LogVerbosity.ERROR]: '🔴',
-    [LogVerbosity.WARN]: '🟡',
-    [LogVerbosity.INFO]: '🔵',
-    [LogVerbosity.DEBUG]: '🟣',
-};
-export const LogFunctions = {
-    [LogVerbosity.NONE]: console.log,
-    [LogVerbosity.ERROR]: console.error,
-    [LogVerbosity.WARN]: console.warn,
-    [LogVerbosity.INFO]: console.info,
-    [LogVerbosity.DEBUG]: console.debug,
-};
-export function getLevelByName(name) {
-    const level = LogVerbosity[name];
-    if (level === undefined) {
-        return failure(`invalid log level name '${name}'; valid names are: ${LogLevelNames.join(', ')}`);
-    }
-    return success(level);
-}
-export function getLevelName(level) {
-    const name = LogVerbosity[level];
-    if (name === undefined) {
-        return failure(`invalid log level ${level}; valid levels are: ${LogLevels[0]}-${LogLevels[LogLevels.length - 1]}`);
-    }
-    return success(name);
-}
-const LOG_DEFAULT_ID = 'default';
-const LOG_COLLECTION = new Map();
-export function getLogger(name = LOG_DEFAULT_ID) {
-    let logger = LOG_COLLECTION.get(name);
-    if (!logger) {
-        logger = new Logger('WARN', name);
-    }
-    return logger;
-}
-export function error(msg, ...args) {
-    if (msg instanceof Function) {
-        return getLogger(LOG_DEFAULT_ID).error(msg, ...args);
-    }
-    return getLogger(LOG_DEFAULT_ID).error(msg, ...args);
-}
-export function warn(msg, ...args) {
-    if (msg instanceof Function) {
-        return getLogger(LOG_DEFAULT_ID).warn(msg, ...args);
-    }
-    return getLogger(LOG_DEFAULT_ID).warn(msg, ...args);
-}
-export function info(msg, ...args) {
-    if (msg instanceof Function) {
-        return getLogger(LOG_DEFAULT_ID).info(msg, ...args);
-    }
-    return getLogger(LOG_DEFAULT_ID).info(msg, ...args);
-}
-export function debug(msg, ...args) {
-    if (msg instanceof Function) {
-        return getLogger(LOG_DEFAULT_ID).debug(msg, ...args);
-    }
-    return getLogger(LOG_DEFAULT_ID).debug(msg, ...args);
-}
-export class Logger {
-    constructor(level, name, options) {
-        this.name = name ?? LOG_DEFAULT_ID;
-        if (isNumber(level)) {
-            this._Level = unwrap(getLevelByName(unwrap(getLevelName(level))));
-        }
-        else {
-            this._Level = unwrap(getLevelByName(level));
-        }
-        this._Handlers = options?.handlers || [new LogHandler(level)];
-        LOG_COLLECTION.set(this.name, this);
-    }
-    get level() {
-        return this._Level;
-    }
-    set level(value) {
-        this.levelName = unwrap(getLevelName(value));
-    }
-    get levelName() {
-        return unwrap(getLevelName(this._Level));
-    }
-    set levelName(value) {
-        this._Level = unwrap(getLevelByName(value));
-        this._Handlers.forEach((handler) => (handler.level = this._Level));
-    }
-    get handlers() {
-        return this._Handlers;
-    }
-    addHandler(handler) {
-        this._Handlers.push(handler);
-    }
-    removeHandler(handler) {
-        const index = this._Handlers.indexOf(handler);
-        if (index !== -1)
-            this._Handlers.splice(index, 1);
-    }
-    log(level, msg, ...args) {
-        if (this.level < level) {
-            return msg instanceof Function ? undefined : msg;
-        }
-        let fnResult;
-        let message;
-        if (msg instanceof Function) {
-            fnResult = msg();
-            message = this.asString(fnResult);
-        }
-        else {
-            message = this.asString(msg);
-        }
-        this._Handlers.forEach((handler) => {
-            handler.handle({
-                date: new Date(),
-                level,
-                levelName: unwrap(getLevelName(level)),
-                logger: this.name,
-                message,
-                args,
-            });
-        });
-        return msg instanceof Function ? fnResult : msg;
-    }
-    error(msg, ...args) {
-        return this.log(LogVerbosity.ERROR, msg, ...args);
-    }
-    warn(msg, ...args) {
-        return this.log(LogVerbosity.WARN, msg, ...args);
-    }
-    info(msg, ...args) {
-        return this.log(LogVerbosity.INFO, msg, ...args);
-    }
-    debug(msg, ...args) {
-        return this.log(LogVerbosity.DEBUG, msg, ...args);
-    }
-    asString(data, isProperty = false) {
-        if (typeof data === 'string') {
-            if (isProperty)
-                return `"${data}"`;
-            return data;
-        }
-        else if (data === null ||
-            typeof data === 'number' ||
-            typeof data === 'bigint' ||
-            typeof data === 'boolean' ||
-            typeof data === 'undefined' ||
-            typeof data === 'symbol') {
-            return String(data);
-        }
-        else if (data instanceof Error) {
-            return data.stack;
-        }
-        else if (typeof data === 'object') {
-            return `{${Object.entries(data)
-                .map(([k, v]) => `"${k}":${this.asString(v, true)}`)
-                .join(',')}}`;
-        }
-        return 'undefined';
-    }
-}
-export const DEFAULT_FORMATTER = ({ message }) => message;
-export const PRETTY_FORMATTER = (record) => {
-    const date = `[${record.date.toISOString()}]`;
-    const level = `[${record.levelName}]`;
-    const logger = record.logger !== LOG_DEFAULT_ID ? `[${record.logger}] ` : '';
-    const symbol = LogSymbols[record.level];
-    return `${date} ${symbol} ${level.padEnd(7, ' ')} ${logger}${record.message}`;
-};
-export class LogHandler {
-    constructor(level, formatter = DEFAULT_FORMATTER) {
-        if (isNumber(level)) {
-            this._Level = unwrap(getLevelByName(unwrap(getLevelName(level))));
-        }
-        else {
-            this._Level = unwrap(getLevelByName(level));
-        }
-        this._FormatterFn = formatter;
-    }
-    get level() {
-        return this._Level;
-    }
-    set level(value) {
-        this.levelName = unwrap(getLevelName(value));
-    }
-    get levelName() {
-        return unwrap(getLevelName(this._Level));
-    }
-    set levelName(value) {
-        this._Level = unwrap(getLevelByName(value));
-    }
-    handle(record) {
-        if (this._Level < record.level)
-            return;
-        this.log(this._FormatterFn(record), record);
-    }
-    log(formattedString, record) {
-        LogFunctions[record.level](formattedString, ...record.args);
-    }
-}

package/lib/esm/utility/msgpack.js

@@ -1,7 +0,0 @@
-import { encode, decode } from '@msgpack/msgpack';
-export function msgpackEncode(value) {
-    return encode(value, { forceFloat32: true, ignoreUndefined: true });
-}
-export function msgpackDecode(buffer) {
-    return decode(buffer);
-}

package/lib/esm/utility/result.js

@@ -1,23 +0,0 @@
-export function assert(condition, message) {
-    if (!condition) {
-        fail(message);
-    }
-}
-export function fail(message) {
-    throw new Error(message);
-}
-export function success(value) {
-    return { type: 'Success', value };
-}
-export function failure(reason) {
-    return { type: 'Failure', reason };
-}
-export function unwrap(result) {
-    if (result.type === 'Failure') {
-        fail(result.reason);
-    }
-    return result.value;
-}
-export function unwrapOr(result, fallback) {
-    return result.type === 'Success' ? result.value : fallback;
-}

package/lib/esm/utility/selector.js

@@ -1,14 +0,0 @@
-export class Selector {
-    constructor(_Generators) {
-        this._Generators = _Generators;
-        this._Futures = _Generators.map(Selector.addIndex);
-    }
-    async next() {
-        const [result, index] = await Promise.race(this._Futures);
-        this._Futures[index] = Selector.addIndex(this._Generators[index], index);
-        return result;
-    }
-    static async addIndex(generator, index) {
-        return [await generator(), index];
-    }
-}

package/lib/esm/utility/sleep.js

@@ -1,22 +0,0 @@
-export function sleep(ms, value) {
-    if (ms <= 0) {
-        return Promise.resolve(value);
-    }
-    return new Promise((resolve) => setTimeout(() => resolve(value), ms));
-}
-export function abortableSleep(ms, signal) {
-    if (signal.aborted) {
-        return Promise.resolve('aborted');
-    }
-    return new Promise((resolve) => {
-        const onAbort = () => resolve('aborted');
-        signal.addEventListener('abort', onAbort, { once: true });
-        setTimeout(() => {
-            signal.removeEventListener('abort', onAbort);
-            resolve(undefined);
-        }, ms);
-    });
-}
-export function nextTick() {
-    return new Promise((resolve) => setTimeout(resolve, 0));
-}

package/lib/esm/utility/strand.js

@@ -1,34 +0,0 @@
-export class Strand {
-    constructor(...values) {
-        this._Tasks = [];
-        this._Running = false;
-        this._Values = values;
-    }
-    enqueue(task) {
-        return new Promise((resolve, reject) => {
-            const wrapped = async () => {
-                try {
-                    const result = await task(...this._Values);
-                    resolve(result);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            };
-            this._Tasks.push(wrapped);
-            if (!this._Running) {
-                this.execute();
-            }
-        });
-    }
-    async execute() {
-        this._Running = true;
-        while (true) {
-            const task = this._Tasks.shift();
-            if (task === undefined)
-                break;
-            await task();
-        }
-        this._Running = false;
-    }
-}

package/lib/esm/utility/url.js

@@ -1,23 +0,0 @@
-import { failure, success } from './result';
-export function normalizeUrl(url) {
-    let normalized = url.trim();
-    if (url.indexOf('://') === -1)
-        normalized = `https://${normalized}`;
-    try {
-        return success(new URL(normalized));
-    }
-    catch (error) {
-        return failure(String(error));
-    }
-}
-export function extendUrl(base, path) {
-    let pathname = base.pathname;
-    if (pathname.endsWith('/') === false)
-        pathname += '/';
-    try {
-        return success(new URL(pathname + path, base));
-    }
-    catch (error) {
-        return failure(String(error));
-    }
-}

package/lib/esm/utility/uuid.js

@@ -1,7 +0,0 @@
-import { v4, validate } from 'uuid';
-export function generateUUID() {
-    return v4();
-}
-export function validateUUID(uuid) {
-    return validate(uuid);
-}

package/lib/esm/utility/validation.js

@@ -1,27 +0,0 @@
-export function isProperty(object, name) {
-    return name in object;
-}
-export function isFunction(value) {
-    return typeof value === 'function';
-}
-export function isNull(value) {
-    return typeof value === 'object' && value === null;
-}
-export function isNumber(value) {
-    return typeof value === 'number';
-}
-export function isObject(value) {
-    return typeof value === 'object';
-}
-export function isString(value) {
-    return typeof value === 'string';
-}
-export function isUndefined(value) {
-    return typeof value === 'undefined';
-}
-export function isFailure(result) {
-    return result.type === 'Failure';
-}
-export function isSuccess(result) {
-    return result.type === 'Success';
-}

package/lib/index.d.ts

@@ -1,27 +0,0 @@
-export * as zod from 'zod';
-export * from './schema/serialization';
-export * from './schema/token';
-export * from './schema/room';
-export * from './schema/peer';
-export * from './schema/media';
-export * from './schema/message';
-export * from './schema/webrtc';
-export * from './schema/channels';
-export * from './rpc/commands';
-export * from './rpc/notifications';
-export * from './utility/base64';
-export * from './utility/bytearray';
-export * from './utility/codec';
-export * from './utility/iterable';
-export * from './utility/environment';
-export * from './utility/json';
-export * from './utility/msgpack';
-export * from './utility/result';
-export * from './utility/selector';
-export * from './utility/sleep';
-export * from './utility/strand';
-export * from './utility/url';
-export * from './utility/uuid';
-export * from './utility/validation';
-export * from './utility/log';
-export * from './plugin/api';

package/lib/plugin/api.d.ts

@@ -1,159 +0,0 @@
-export declare const MinDBFS = -758.596;
-export declare namespace Backend {
-    type UID = string;
-    type OnStatusChanged = (status: 'started' | 'stopped') => void;
-    type OnEvent = (method: string, properties: unknown) => void;
-    type Version = '5';
-    enum Transport {
-        H3 = "h3",
-        WebRTC = "webrtc"
-    }
-    interface Plugin {
-        readonly version: Version;
-        readonly playbackVolume: PlaybackVolume;
-        readonly supportedTransports: (Transport.WebRTC | Transport.H3)[];
-        joinRoom(parameters: JoinRoomParameters): Room;
-        createAudioPlayback(parameters: CreateAudioPlaybackParameters): Promise<AudioPlayback>;
-        createAudioCapture(parameters: CreateAudioCaptureParameters): Promise<AudioCapture>;
-        createVideoCapture(ms: MediaStream, options?: VideoInputOptions): Promise<VideoCapture>;
-        createVideoPlayback(parameters: CreateVideoPlaybackParameters): Promise<VideoPlayback>;
-        enumerateDevices(): Promise<Array<Device>>;
-        setOutputVolume(volume: PlaybackVolume): void;
-        setOutputDevice(device: DeviceParameters): Promise<void>;
-        close(): void;
-    }
-    interface Device {
-        readonly type: 'AudioPlayback' | 'AudioCapture';
-        readonly name: string;
-        readonly id: string;
-        readonly isDefault: boolean;
-    }
-    interface DeviceParameters {
-        readonly device?: Device;
-        onStatusChanged?: OnStatusChanged;
-    }
-    interface Activity {
-        isSilent: boolean;
-        rmsDBFS: number;
-    }
-    interface JitterStats {
-        packetsSeen: number;
-        packetsProcessed: number;
-        packetsTooEarly: number;
-        packetsTooLate: number;
-        packetsDropped: number;
-        packetsInvalid: number;
-        packetsRepeated: number;
-        packetsLost: number;
-    }
-    interface ConnectionStats {
-        bytesSent: number;
-        bytesReceived: number;
-        packetsSent: number;
-        packetsReceived: number;
-        rtt: number;
-    }
-    interface JoinRoomParameters {
-        readonly gateway: string | undefined;
-        readonly token: string;
-        readonly roomId?: string;
-        readonly userData?: Uint8Array;
-        readonly position?: [number, number, number];
-        readonly cipher?: SetupCipherSettings;
-        readonly onEvent: OnEvent;
-        readonly transport?: Transport;
-    }
-    interface Room {
-        readonly token: string;
-        readonly cipher: Cipher | undefined;
-        connectionStats: ConnectionStats;
-        request(method: string, properties: unknown): Promise<unknown>;
-        link(media: Media): Promise<void>;
-        unlink(media: Media): void;
-        close(): void;
-    }
-    interface Media {
-        readonly customType?: string;
-        close(): void;
-    }
-    interface AudioMedia extends Media {
-        readonly activity: Activity;
-    }
-    interface CreateAudioPlaybackParameters {
-        readonly uid: UID;
-        readonly volume?: PlaybackVolume;
-        readonly customType?: string;
-    }
-    interface CreateVideoPlaybackParameters {
-        readonly uid: UID;
-        readonly customType?: string;
-    }
-    interface AudioPlayback extends AudioMedia {
-        readonly volume: PlaybackVolume;
-        readonly uid: UID;
-        jitterStats: JitterStats;
-        setVolume(value: PlaybackVolume): Promise<void>;
-    }
-    interface CreateAudioCaptureParameters extends Partial<DeviceParameters> {
-        readonly volume?: CaptureVolume;
-        readonly vad?: VadConfig;
-        readonly apm?: ApmConfig;
-    }
-    interface AudioCapture extends AudioMedia {
-        readonly volume: CaptureVolume;
-        readonly vad?: VadConfig;
-        readonly apm?: ApmConfig;
-        setVad(config: VadConfig): void;
-        setApm(config: ApmConfig): Promise<void>;
-        setDevice(device: DeviceParameters): Promise<void>;
-        setVolume(value: CaptureVolume): Promise<void>;
-    }
-    interface VideoCapture extends Media {
-        mediaStream?: MediaStream;
-        setDevice(ms: MediaStream): Promise<void>;
-    }
-    interface VideoPlayback extends Media {
-        readonly mediaStream?: MediaStream;
-        readonly uid: UID;
-    }
-    type PlaybackVolume = [number, number];
-    type CaptureVolume = 'muted' | number;
-    interface VadConfig {
-        voiceActivity?: SensitivityRange;
-        volumeGate?: SensitivityRange;
-    }
-    interface SensitivityRange {
-        attackThreshold: number;
-        releaseThreshold: number;
-    }
-    interface ApmConfig {
-        echoCanceller: boolean;
-        highPassFilter: boolean;
-        preAmplifier: boolean;
-        captureLevelAdjustment: boolean;
-        noiseSuppression: 'None' | 'Low' | 'Moderate' | 'High' | 'VeryHigh';
-        transientSuppressor: boolean;
-        gainController: boolean;
-    }
-    type SetupCipherSettings = {
-        type: 'OdinCrypto';
-    } & OdinCryptoSettings;
-    type CipherSettings = OdinCryptoSettings;
-    interface OdinCryptoSettings {
-        password: string | null;
-    }
-    enum PeerCipherStatus {
-        InvalidPassword = -1,
-        Unknown = 0,
-        Unencrypted = 1,
-        Encrypted = 2
-    }
-    interface Cipher {
-        configure(settings: CipherSettings): void;
-        getPeerStatus(peerId: number): PeerCipherStatus;
-    }
-    type VideoInputOptions = {
-        codec?: 'H264' | 'VP8' | 'VP9';
-        customType?: string;
-    };
-}