@ceeblue/web-utils 2.4.1 → 2.6.0

package/dist/web-utils.d.ts

@@ -184,6 +184,55 @@ declare namespace Connect {
  * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
  * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
  */
+/**
+ * Log interface to deal with log everywhere:
+ * - subscribe logs: listen logs to effectuate some specific job related logs
+ * - intercept logs: intercept logs to change the default behavior
+ * - redirect logs: redirect logs to one other logger engine
+ * - redefine logs: change log text like adding a prefix
+ *
+ * You have 4 {@link LogType} 'error', 'warn', 'info', and 'debug', as commonly managed by browsers.
+ *
+ * @example
+ * // Intercept and redirect all the logs to the console (default behavior)
+ * import { log } from '@ceeblue/web-utils';
+ * log.on(type:LogType, args:uknown[]) => {
+ *    console[type](...args.splice(0)); // args is empty after this call = final interception
+ * }
+ *
+ * // Intercept and redirect the logs from Player compoment to the console
+ * player.log.on(type:LogType, args:uknown[]) => {
+ *    console[type](...args.splice(0)); // args is empty after this call = final interception
+ * }
+ *
+ * // Subscribe and redirect all the logs to a file logger
+ * log.on(type:LogType, args:uknown[]) => {
+ *    fileLogger[type](...args); // args stays unchanged to let's continue the default behavior
+ * }
+ *
+ * // Redefine the log to add some prefix indication
+ * class Player {
+ *    connector = new Connector();
+ *    constructor() {
+ *       connector.log = this.log.bind(this, "Connector log:");
+ *    }
+ * }
+ *
+ */
+interface ILog {
+    /**
+     * Build a log
+     */
+    (...args: unknown[]): Log;
+    /**
+     * Intercept, redefine or redirect any log
+     * If you clear args you intercept the log and nothing happen more after this call.
+     * @param type log level
+     * @param args args
+     * @returns
+     */
+    on: (type: LogType, args: unknown[]) => void;
+}
 /**
  * Log types
  */
@@ -207,22 +256,6 @@ declare class Log {
     constructor(onLog: Function, ...args: unknown[]);
     private _bind;
 }
-/**
- * ILog interface used by log methods
- */
-interface ILog {
-    /**
-     * Build a log
-     */
-    (...args: unknown[]): Log;
-    /**
-     * Intercept or redefine any log
-     * @param type log level
-     * @param args args
-     * @returns
-     */
-    on: (type: LogType, args: unknown[]) => void;
-}
 /**
  * Inherits from this class to use logs
  */
@@ -731,6 +764,12 @@ declare function getExtension(path: string): string;
  * @returns the file name
  */
 declare function getFile(path: string): string;
+/**
+ * Get Base File part from path, without extension
+ * @param path path to parse
+ * @returns the base file name
+ */
+declare function getBaseFile(path: string): string;
 /**
  * String Trim function with customizable chars
  * @param value string to trim
@@ -756,6 +795,7 @@ declare function trimEnd(value: string, chars?: string): string;
 declare const Util_EMPTY_FUNCTION: typeof EMPTY_FUNCTION;
 declare const Util_equal: typeof equal;
 declare const Util_fetch: typeof fetch;
+declare const Util_getBaseFile: typeof getBaseFile;
 declare const Util_getExtension: typeof getExtension;
 declare const Util_getFile: typeof getFile;
 declare const Util_objectEntries: typeof objectEntries;
@@ -771,7 +811,7 @@ declare const Util_trim: typeof trim;
 declare const Util_trimEnd: typeof trimEnd;
 declare const Util_trimStart: typeof trimStart;
 declare namespace Util {
-  export { Util_EMPTY_FUNCTION as EMPTY_FUNCTION, Util_equal as equal, Util_fetch as fetch, Util_getExtension as getExtension, Util_getFile as getFile, Util_objectEntries as objectEntries, Util_objectFrom as objectFrom, Util_options as options, Util_safePromise as safePromise, Util_sleep as sleep, Util_stringify as stringify, Util_time as time, Util_timeOrigin as timeOrigin, Util_toBin as toBin, Util_trim as trim, Util_trimEnd as trimEnd, Util_trimStart as trimStart };
+  export { Util_EMPTY_FUNCTION as EMPTY_FUNCTION, Util_equal as equal, Util_fetch as fetch, Util_getBaseFile as getBaseFile, Util_getExtension as getExtension, Util_getFile as getFile, Util_objectEntries as objectEntries, Util_objectFrom as objectFrom, Util_options as options, Util_safePromise as safePromise, Util_sleep as sleep, Util_stringify as stringify, Util_time as time, Util_timeOrigin as timeOrigin, Util_toBin as toBin, Util_trim as trim, Util_trimEnd as trimEnd, Util_trimStart as trimStart };
 }
 
 /**
@@ -927,6 +967,51 @@ declare class WebSocketReliable extends EventEmitter {
     private _send;
 }
 
+/**
+ * Copyright 2024 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * Decode the timestamp from a video element and compute the latency between the timestamp and the current date.
+ *
+ * @param {HTMLVideoElement} sourceEl the video element to get the image from
+ * @param {HTMLCanvasElement} canvas
+ * @param {CanvasRenderingContext2D} context
+ * @param {Date} now current date, new Date() by default
+ * @param {Number} blocksPerRow number of blocks in the line, 32 by default
+ * @param {Number} tolerance percentage of tolerance for the black and white threshold, 0.2 by default
+ * @returns {Number} The latency in millisecond between 'now' and the decoded timestamp, 0 if the timestamp cannot be decoded
+ */
+declare function getLatency(sourceEl: HTMLVideoElement, canvas: HTMLCanvasElement, context: CanvasRenderingContext2D, now?: Date, blocksPerRow?: number, tolerance?: number): number;
+/**
+ * Decode a previously encoded timestamp from a canvas
+ *
+ * @param {CanvasRenderingContext2D} context
+ * @param {Number} lineWidth width of the line in pixels
+ * @param {Number} blocksPerRow number of blocks in the line, 32 by default
+ * @param {Number} tolerance percentage of tolerance for the black and white threshold, 0.2 by default
+ * @returns {Date|null} The Date object representing the timestamp or null if the timestamp cannot be decoded
+ */
+declare function decodeTimestamp(context: CanvasRenderingContext2D, lineWidth: number, blocksPerRow?: number, tolerance?: number): Date | undefined;
+/**
+ * Encode the current timestamp into a line composed of blocks of black and white pixels
+ * written on the top of the canvas.
+ *
+ * @param {CanvasRenderingContext2D} context
+ * @param {Number} lineWidth width of the line in pixels
+ * @param {Number} blocksPerRow number of blocks in the line, 32 by default
+ * @param {Date} now current date, new Date() by default
+ */
+declare function encodeTimestamp(context: CanvasRenderingContext2D, lineWidth: number, blocksPerRow?: number, now?: Date): void;
+
+declare const EpochTime_decodeTimestamp: typeof decodeTimestamp;
+declare const EpochTime_encodeTimestamp: typeof encodeTimestamp;
+declare const EpochTime_getLatency: typeof getLatency;
+declare namespace EpochTime {
+  export { EpochTime_decodeTimestamp as decodeTimestamp, EpochTime_encodeTimestamp as encodeTimestamp, EpochTime_getLatency as getLatency };
+}
+
 /**
  * Copyright 2024 Ceeblue B.V.
  * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
@@ -935,4 +1020,4 @@ declare class WebSocketReliable extends EventEmitter {
 
 declare const VERSION: string;
 
-export { BinaryReader, BinaryWriter, BitReader, ByteRate, Connect, EventEmitter, FixMap, type ILog, Log, LogType, Loggable, NetAddress, Numbers, Queue, SDP, Util, VERSION, WebSocketReliable, type WebSocketReliableError, log };
+export { BinaryReader, BinaryWriter, BitReader, ByteRate, Connect, EpochTime, EventEmitter, FixMap, type ILog, Log, LogType, Loggable, NetAddress, Numbers, Queue, SDP, Util, VERSION, WebSocketReliable, type WebSocketReliableError, log };

package/dist/web-utils.js

@@ -633,10 +633,11 @@ function fetch(input, init) {
     return __awaiter(this, void 0, void 0, function* () {
         const response = yield self.fetch(input, init);
         if (response.status >= 300) {
+            let error;
             if (response.body) {
-                throw (yield response.text()) || response.statusText;
+                error = yield response.text();
             }
-            throw response.statusText;
+            throw (error || response.statusText || response.status).toString();
         }
         return response;
     });
@@ -659,6 +660,16 @@ function getExtension(path) {
 function getFile(path) {
     return path.substring(path.lastIndexOf('/') + 1);
 }
+/**
+ * Get Base File part from path, without extension
+ * @param path path to parse
+ * @returns the base file name
+ */
+function getBaseFile(path) {
+    const dot = path.lastIndexOf('.');
+    const file = path.lastIndexOf('/') + 1;
+    return dot >= 0 && dot >= file ? path.substring(file, dot) : path.substring(file);
+}
 function codesFromString(value) {
     const codes = [];
     for (let i = 0; i < value.length; ++i) {
@@ -711,7 +722,7 @@ function trimEnd(value, chars = ' ') {
         --i;
     }
     return value.substring(0, i);
-}var Util=/*#__PURE__*/Object.freeze({__proto__:null,EMPTY_FUNCTION:EMPTY_FUNCTION,equal:equal,fetch:fetch,getExtension:getExtension,getFile:getFile,objectEntries:objectEntries,objectFrom:objectFrom,options:options,safePromise:safePromise,sleep:sleep,stringify:stringify,time:time,timeOrigin:timeOrigin,toBin:toBin,trim:trim,trimEnd:trimEnd,trimStart:trimStart});/**
+}var Util=/*#__PURE__*/Object.freeze({__proto__:null,EMPTY_FUNCTION:EMPTY_FUNCTION,equal:equal,fetch:fetch,getBaseFile:getBaseFile,getExtension:getExtension,getFile:getFile,objectEntries:objectEntries,objectFrom:objectFrom,options:options,safePromise:safePromise,sleep:sleep,stringify:stringify,time:time,timeOrigin:timeOrigin,toBin:toBin,trim:trim,trimEnd:trimEnd,trimStart:trimStart});/**
  * Copyright 2024 Ceeblue B.V.
  * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
  * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
@@ -900,10 +911,6 @@ var Type;
  * @param params The parameters for which the media extension is to be defined
  */
 function defineMediaExt(type, params) {
-    // Fix mediaExt in removing the possible '.' prefix
-    if (params.mediaExt) {
-        params.mediaExt = trimStart(params.mediaExt, '.');
-    }
     // Compute appropriate mediaExt out parameter
     switch (type) {
         case Type.HESP:
@@ -917,7 +924,7 @@ function defineMediaExt(type, params) {
                 const url = new URL(params.endPoint);
                 const ext = getExtension(getFile(url.pathname));
                 // set extension just if not json, json means a manifest file endPoint
-                if (ext && ext !== 'json') {
+                if (ext && ext.toLowerCase() !== '.json') {
                     params.mediaExt = ext;
                 }
             }
@@ -941,6 +948,8 @@ function defineMediaExt(type, params) {
             console.warn('Unknown params type ' + type);
             break;
     }
+    // Fix mediaExt in removing the possible '.' prefix
+    trimStart(params.mediaExt, '.');
 }
 /**
  * Build an URL from {@link Type | type} and {@link Params | params}
@@ -962,7 +971,7 @@ function buildURL(type, params, protocol = 'wss') {
                 url.pathname = '/webrtc/' + params.streamName;
                 break;
             case Type.WRTS:
-                url.pathname = '/wrts/' + params.streamName;
+                url.pathname = '/wrts/' + params.streamName + '.' + params.mediaExt;
                 break;
             case Type.META:
                 url.pathname = '/json_' + params.streamName + '.js';
@@ -1919,4 +1928,100 @@ class WebSocketReliable extends EventEmitter {
  * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
  * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
  */
-const VERSION = '2.4.1';export{BinaryReader,BinaryWriter,BitReader,ByteRate,Connect,EventEmitter,FixMap,Log,LogType,Loggable,NetAddress,Numbers,Queue,SDP,Util,VERSION,WebSocketReliable,log};//# sourceMappingURL=web-utils.js.map
+/**
+ * Decode the timestamp from a video element and compute the latency between the timestamp and the current date.
+ *
+ * @param {HTMLVideoElement} sourceEl the video element to get the image from
+ * @param {HTMLCanvasElement} canvas
+ * @param {CanvasRenderingContext2D} context
+ * @param {Date} now current date, new Date() by default
+ * @param {Number} blocksPerRow number of blocks in the line, 32 by default
+ * @param {Number} tolerance percentage of tolerance for the black and white threshold, 0.2 by default
+ * @returns {Number} The latency in millisecond between 'now' and the decoded timestamp, 0 if the timestamp cannot be decoded
+ */
+function getLatency(sourceEl, canvas, context, now = new Date(), blocksPerRow = 32, tolerance = 0.2) {
+    canvas.width = sourceEl.videoWidth;
+    canvas.height = Math.floor(canvas.width / blocksPerRow);
+    if (!canvas.width || !canvas.height) {
+        // No pixel to parse!
+        return 0;
+    }
+    context.drawImage(sourceEl, 0, 0, canvas.width, canvas.height, 0, 0, canvas.width, canvas.height);
+    const timestamp = decodeTimestamp(context, canvas.width, blocksPerRow, tolerance);
+    return timestamp == null ? 0 : now.getTime() - timestamp.getTime();
+}
+/**
+ * Decode a previously encoded timestamp from a canvas
+ *
+ * @param {CanvasRenderingContext2D} context
+ * @param {Number} lineWidth width of the line in pixels
+ * @param {Number} blocksPerRow number of blocks in the line, 32 by default
+ * @param {Number} tolerance percentage of tolerance for the black and white threshold, 0.2 by default
+ * @returns {Date|null} The Date object representing the timestamp or null if the timestamp cannot be decoded
+ */
+function decodeTimestamp(context, lineWidth, blocksPerRow = 32, tolerance = 0.2) {
+    const blockSize = lineWidth / blocksPerRow;
+    let binaryTime = '';
+    let i = blockSize / 2;
+    const data = context.getImageData(0, Math.round(i), lineWidth, 1).data;
+    const pixels = new Uint32Array(data.buffer);
+    const blackThreshold = 0xffffff * tolerance;
+    const whiteThreshold = 0xffffff * (1 - tolerance);
+    while (i < pixels.length) {
+        const pixel = pixels[Math.round(i)] & 0xffffff;
+        pixels[Math.round(i)] = pixel;
+        if (pixel < blackThreshold) {
+            // Black
+            binaryTime += '1';
+        }
+        else if (pixel > whiteThreshold) {
+            // White
+            binaryTime += '0';
+        }
+        else {
+            return;
+        }
+        i += blockSize;
+    }
+    const day = parseInt(binaryTime.slice(0, 5), 2);
+    const hour = parseInt(binaryTime.slice(5, 10), 2);
+    const minute = parseInt(binaryTime.slice(10, 16), 2);
+    const second = parseInt(binaryTime.slice(16, 22), 2);
+    const millisecond = parseInt(binaryTime.slice(22, 32), 2);
+    const now = new Date();
+    return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), day, hour, minute, second, millisecond));
+}
+/**
+ * Encode the current timestamp into a line composed of blocks of black and white pixels
+ * written on the top of the canvas.
+ *
+ * @param {CanvasRenderingContext2D} context
+ * @param {Number} lineWidth width of the line in pixels
+ * @param {Number} blocksPerRow number of blocks in the line, 32 by default
+ * @param {Date} now current date, new Date() by default
+ */
+function encodeTimestamp(context, lineWidth, blocksPerRow = 32, now = new Date()) {
+    const blockSize = Math.floor(lineWidth / blocksPerRow);
+    const day = now.getUTCDate();
+    const hour = now.getUTCHours();
+    const minute = now.getUTCMinutes();
+    const second = now.getUTCSeconds();
+    const millisecond = now.getUTCMilliseconds();
+    const binaryDay = day.toString(2).padStart(5, '0');
+    const binaryHour = hour.toString(2).padStart(5, '0');
+    const binaryMinute = minute.toString(2).padStart(6, '0');
+    const binarySecond = second.toString(2).padStart(6, '0');
+    const binaryMillisecond = millisecond.toString(2).padStart(10, '0');
+    const binaryTime = binaryDay + binaryHour + binaryMinute + binarySecond + binaryMillisecond;
+    for (let i = 0; i < binaryTime.length; i++) {
+        const x = (i % blocksPerRow) * blockSize;
+        const y = Math.floor(i / blocksPerRow) * blockSize;
+        context.fillStyle = binaryTime[i] === '1' ? 'black' : 'white';
+        context.fillRect(x, y, blockSize, blockSize);
+    }
+}var EpochTime=/*#__PURE__*/Object.freeze({__proto__:null,decodeTimestamp:decodeTimestamp,encodeTimestamp:encodeTimestamp,getLatency:getLatency});/**
+ * Copyright 2024 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+const VERSION = '2.6.0';export{BinaryReader,BinaryWriter,BitReader,ByteRate,Connect,EpochTime,EventEmitter,FixMap,Log,LogType,Loggable,NetAddress,Numbers,Queue,SDP,Util,VERSION,WebSocketReliable,log};//# sourceMappingURL=web-utils.js.map