@4players/odin-common 3.2.0 → 4.0.1

package/lib/esm/utility/bytearray.js

@@ -1,24 +0,0 @@
-import { assert, failure, success } from './result';
-export function toBytes(value) {
-    try {
-        assert(value !== undefined, 'undefined cannot be converted to byte array');
-        assert(value !== null, 'null cannot be converted to byte array');
-        const json = JSON.stringify(value);
-        const decoder = new TextEncoder();
-        return success(decoder.encode(json));
-    }
-    catch (error) {
-        return failure(String(error));
-    }
-}
-export function fromBytes(bytes) {
-    try {
-        assert(bytes.length > 0, 'empty byte array cannot be converted to value');
-        const json = new TextDecoder().decode(bytes);
-        const text = JSON.parse(json);
-        return success(text);
-    }
-    catch (error) {
-        return failure(String(error));
-    }
-}

package/lib/esm/utility/codec.js

@@ -1,85 +0,0 @@
-import { failure, success, unwrapOr } from './result';
-const validCodecs = ['VP8', 'VP9', 'AV1', 'H264'];
-export class VideoCodec {
-    constructor(codec) {
-        this.codec = codec;
-        this.channels = 0;
-        this.clockRate = 90000;
-    }
-    isValid() {
-        return validCodecs.includes(this.codec);
-    }
-    isSupported() {
-        if (typeof RTCRtpReceiver === 'undefined' ||
-            typeof RTCRtpReceiver.getCapabilities === 'undefined') {
-            return null;
-        }
-        const expectedMimeType = unwrapOr(this.getMimeType(), '').toLowerCase();
-        const expectedFmtpLine = new Set(unwrapOr(this.getSdpFmtpLine(), '')
-            .split(';')
-            .map((arg) => arg.trim().toLowerCase()));
-        return (RTCRtpReceiver.getCapabilities('video')?.codecs?.find((c) => {
-            const actualMimeType = c.mimeType.toLowerCase();
-            const actualFmtpLine = new Set((c.sdpFmtpLine ?? '')
-                .split(';')
-                .map((arg) => arg.trim().toLowerCase()));
-            if (expectedMimeType !== actualMimeType)
-                return false;
-            if (expectedFmtpLine.size !== actualFmtpLine.size)
-                return false;
-            for (let item of expectedFmtpLine) {
-                if (!actualFmtpLine.has(item))
-                    return false;
-            }
-            return true;
-        }) ?? null);
-    }
-    getPayloadType() {
-        switch (this.codec) {
-            case 'VP8':
-                return success(96);
-            case 'VP9':
-                return success(98);
-            case 'AV1':
-                return success(41);
-            case 'H264':
-                return success(102);
-            default:
-                return failure('invalid video codec');
-        }
-    }
-    getMimeType() {
-        switch (this.codec) {
-            case 'VP8':
-                return success('video/VP8');
-            case 'VP9':
-                return success('video/VP9');
-            case 'AV1':
-                return success('video/AV1');
-            case 'H264':
-                return success('video/H264');
-            default:
-                return failure('invalid video codec');
-        }
-    }
-    getSdpFmtpLine() {
-        switch (this.codec) {
-            case 'VP8':
-                return success('');
-            case 'VP9':
-                return success(
-                // using high-bit-depth variant profile
-                'profile-id=2');
-            case 'AV1':
-                return success(
-                // using baseline profile (https://aomediacodec.github.io/av1-rtp-spec/#72-sdp-parameters)
-                'level-idx=5;profile=0;tier=0');
-            case 'H264':
-                return success(
-                // using baseline profile
-                'level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f');
-            default:
-                return failure('invalid video codec');
-        }
-    }
-}

package/lib/esm/utility/environment.js

@@ -1,24 +0,0 @@
-export function isAudioCapable() {
-    return typeof AudioContext !== 'undefined' && typeof Worker !== 'undefined';
-}
-export function isSharedArrayBufferCapable() {
-    return typeof SharedArrayBuffer !== 'undefined';
-}
-export function isBlinkBrowser() {
-    const pattern = /(apple)?webkit\/537\.36/i;
-    return (typeof window !== 'undefined' && pattern.test(window.navigator.userAgent));
-}
-export function isElectronBrowser() {
-    const pattern = /electron/i;
-    return (typeof window !== 'undefined' && pattern.test(window.navigator.userAgent));
-}
-export function isFirefoxBrowser() {
-    const pattern = /firefox|iceweasel|fxios/i;
-    return (typeof window !== 'undefined' && pattern.test(window.navigator.userAgent));
-}
-export function isSafariBrowser() {
-    if (isBlinkBrowser())
-        return false;
-    const pattern = /safari|applewebkit/i;
-    return (typeof window !== 'undefined' && pattern.test(window.navigator.userAgent));
-}

package/lib/esm/utility/iterable.js

@@ -1,7 +0,0 @@
-export function find(entries, predicate) {
-    for (const entry of entries) {
-        if (predicate(entry))
-            return entry;
-    }
-    return undefined;
-}

package/lib/esm/utility/json.js

@@ -1,3 +0,0 @@
-export function toRaw(value) {
-    return JSON.parse(JSON.stringify(value));
-}

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';