videomail-client 15.8.0 → 15.8.2

package/dist/esm/index.js

@@ -3620,7 +3620,7 @@ const constants = {
     }
 };
 var package_namespaceObject = {
-    rE: "15.8.0"
+    rE: "15.8.2"
 };
 function isAudioEnabled(options) {
     return Boolean(options.audio.enabled);
@@ -3991,6 +3991,7 @@ function createError(errorParams) {
     ].filter(Boolean).join(", ");
     options.logger.debug(`VideomailError: create(${args})`);
     const errData = {
+        cause: errorParams.cause,
         explanation,
         logLines,
         err
@@ -4118,12 +4119,12 @@ function showElement(element) {
     element.style.removeProperty("display");
 }
 const html_showElement = showElement;
-const REGEX = /[ ,]+/u;
+const EMAIL_SEPARATOR_REGEX = /[ ,]+/gu;
 function trimEmail(email) {
-    return email.replace(REGEX, "");
+    return email.replace(EMAIL_SEPARATOR_REGEX, "");
 }
 function trimEmails(emails) {
-    const trimmedEmails = emails.split(REGEX).map((item)=>item.trim()).filter(Boolean);
+    const trimmedEmails = emails.split(EMAIL_SEPARATOR_REGEX).map((item)=>item.trim()).filter(Boolean);
     return trimmedEmails;
 }
 function form_define_property(obj, key, value) {
@@ -4499,6 +4500,7 @@ class Resource {
             browser: err.browser,
             code: err.code,
             cookie: err.cookie,
+            cause: err.cause instanceof Error ? serializeError(err.cause) : err.cause,
             cpu: err.cpu,
             device: err.device,
             engine: err.engine,
@@ -6158,6 +6160,34 @@ function summarize(title, contents) {
     return line;
 }
 const util_summarize = summarize;
+function getFirstVideoTrack(localMediaStream) {
+    const videoTracks = localMediaStream.getVideoTracks();
+    let videoTrack;
+    if (videoTracks[0]) videoTrack = videoTracks[0];
+    return videoTrack;
+}
+const media_getFirstVideoTrack = getFirstVideoTrack;
+const MEDIA_EVENTS = [
+    "loadstart",
+    "suspend",
+    "progress",
+    "abort",
+    "emptied",
+    "stalled",
+    "pause",
+    "loadeddata",
+    "waiting",
+    "playing",
+    "canplay",
+    "canplaythrough",
+    "seeking",
+    "seeked",
+    "ended",
+    "ratechange",
+    "durationchange",
+    "volumechange"
+];
+const mediaEvents = MEDIA_EVENTS;
 function AudioRecorder_define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -6203,11 +6233,11 @@ class AudioRecorder {
         let { bufferSize } = this.options.audio;
         if ("auto" === bufferSize) bufferSize = util_getBrowser(this.options).isFirefox() ? 512 : 2048;
         if (!is_power_of_two(bufferSize)) throw error_createError({
-            message: "Audio buffer size must be a power of two.",
+            message: `Audio buffer size must be a power of two. The current buffer size is ${bufferSize}.`,
             options: this.options
         });
-        if (this.options.audio.volume < 0 || this.options.audio.volume > 1) throw error_createError({
-            message: "Audio volume must be between zero and one.",
+        if (!Number.isFinite(this.options.audio.volume) || this.options.audio.volume < 0 || this.options.audio.volume > 1) throw error_createError({
+            message: `Audio volume must be between zero and one. The current volume is ${this.options.audio.volume}.`,
             options: this.options
         });
         volume.gain.value = this.options.audio.volume;
@@ -6253,34 +6283,6 @@ class AudioRecorder {
     }
 }
 const media_AudioRecorder = AudioRecorder;
-function getFirstVideoTrack(localMediaStream) {
-    const videoTracks = localMediaStream.getVideoTracks();
-    let videoTrack;
-    if (videoTracks[0]) videoTrack = videoTracks[0];
-    return videoTrack;
-}
-const media_getFirstVideoTrack = getFirstVideoTrack;
-const MEDIA_EVENTS = [
-    "loadstart",
-    "suspend",
-    "progress",
-    "abort",
-    "emptied",
-    "stalled",
-    "pause",
-    "loadeddata",
-    "waiting",
-    "playing",
-    "canplay",
-    "canplaythrough",
-    "seeking",
-    "seeked",
-    "ended",
-    "ratechange",
-    "durationchange",
-    "volumechange"
-];
-const mediaEvents = MEDIA_EVENTS;
 const VIRTUAL_KEYWORDS = [
     "obs",
     "virtual",
@@ -6684,6 +6686,7 @@ class Recorder extends util_Despot {
             const switchingFacingMode = params?.switchingFacingMode;
             this.userMediaLoading = this.blocking = this.unloaded = this.submitting = false;
             this.userMediaLoaded = true;
+            this.clearUserMediaTimeout();
             if (!switchingFacingMode) this.loop = this.createLoop();
             this.show();
             if (params?.recordWhenReady) this.record();
@@ -6710,13 +6713,16 @@ class Recorder extends util_Despot {
         window.clearTimeout(this.connectionTimeout);
         this.connectionTimeout = void 0;
     }
+    isOnline() {
+        return navigator.onLine;
+    }
     failConnection(params) {
         if (this.connectionFailed || this.connected || this.unloaded) return;
         this.connectionFailed = true;
         this.connecting = false;
         this.clearConnectionTimeout();
         const { url2Connect, cause } = params;
-        const online = navigator.onLine;
+        const online = this.isOnline();
         const elapsedMs = this.connectingStartedAt ? Date.now() - this.connectingStartedAt : void 0;
         const closeEvent = this.lastCloseEvent;
         const socketError = this.lastSocketError;
@@ -6726,12 +6732,17 @@ class Recorder extends util_Despot {
             closeReason: closeEvent?.reason,
             elapsedMs,
             online,
+            secureContext: globalThis.isSecureContext,
+            socketReadyState: this.stream?.socket.readyState,
+            timeoutMs: this.options.timeouts.connection,
+            url: url2Connect,
             unloaded: this.unloaded,
             userMediaLoaded: this.userMediaLoaded,
             userMediaLoading: this.userMediaLoading,
             wasClean: closeEvent?.wasClean,
             socketError,
-            blocking: this.blocking
+            blocking: this.blocking,
+            visibilityState: document.visibilityState
         };
         const debugLine = util_summarize("Recorder: failConnection() diagnostic", contents);
         this.options.logger.debug(debugLine);
@@ -6751,6 +6762,7 @@ class Recorder extends util_Despot {
             message: "Unable to connect to the server",
             explanation,
             options: this.options,
+            cause: contents,
             exc: socketError ? new Error("WebSocket connection error", {
                 cause: socketError
             }) : void 0
@@ -6828,192 +6840,195 @@ class Recorder extends util_Despot {
         this.recordingStats.waitingTime = this.waitingTime;
     }
     initSocket(cb) {
-        if (!this.connected) {
-            if (util_isAutomatedUserAgent()) {
-                this.connecting = false;
-                this.options.logger.debug("Recorder: skipping web socket connection for an automated crawler");
-                return;
-            }
-            this.connecting = true;
-            this.connectionFailed = false;
-            this.connectingStartedAt = Date.now();
-            this.lastCloseEvent = void 0;
-            this.lastSocketError = void 0;
-            this.emit("CONNECTING");
-            let url2Connect;
-            try {
-                const socketUrlObj = new URL(this.options.socketUrl);
-                socketUrlObj.searchParams.set(constants.WHITELIST_KEY_LABEL, this.options.whitelistKey);
-                url2Connect = socketUrlObj.toString();
-            } catch (exc) {
-                this.connecting = this.connected = false;
-                const err = error_createError({
-                    message: "Invalid WebSocket URL",
-                    explanation: `The configured socketUrl "${this.options.socketUrl}" is not a valid URL. Please check your videomail-client configuration.`,
-                    options: this.options,
-                    exc
-                });
-                this.emit("ERROR", {
-                    err
-                });
-                return;
-            }
-            this.options.logger.debug(`Recorder: initializing web socket stream to ${url2Connect}`);
-            let nativeSocket;
-            try {
-                nativeSocket = new WebSocket(url2Connect);
-                nativeSocket.addEventListener("close", (event)=>{
-                    this.lastCloseEvent = {
-                        code: event.code,
-                        reason: event.reason,
-                        wasClean: event.wasClean
-                    };
-                });
-                nativeSocket.addEventListener("error", (event)=>{
-                    this.lastSocketError = error_getEventDetails(event);
-                });
-            } catch (exc) {
-                this.connecting = this.connected = false;
-                const diagnostic = error_getWebSocketDiagnostic(url2Connect);
-                const message = diagnostic.looksAutomated ? "Automated crawler: WebSocket not supported in this environment" : `Failed to construct WebSocket to ${url2Connect}`;
-                const explanation = diagnostic.looksAutomated ? "Headless crawlers cannot use Videomail's WebSocket. No action needed." : `Please check your connection and try again. If the problem persists, contact us. Diagnostic: ${diagnostic.text}`;
-                const err = error_createError({
-                    message,
-                    explanation,
-                    options: this.options,
-                    exc
-                });
-                this.emit("ERROR", {
-                    err
-                });
-                return;
-            }
-            try {
-                this.stream = websocket_stream(nativeSocket);
-            } catch (exc) {
-                this.connecting = this.connected = false;
-                const err = error_createError({
-                    message: `Failed to create a stream to ${url2Connect}`,
-                    explanation: "Please check your connection and try again. If the problem persists, contact us.",
-                    options: this.options,
-                    exc
+        if (this.connected) return void cb?.();
+        if (this.connecting) return;
+        if (util_isAutomatedUserAgent()) {
+            this.connecting = false;
+            this.options.logger.debug("Recorder: skipping web socket connection for an automated crawler");
+            return;
+        }
+        this.connecting = true;
+        this.connectionFailed = false;
+        this.connectingStartedAt = Date.now();
+        this.lastCloseEvent = void 0;
+        this.lastSocketError = void 0;
+        this.emit("CONNECTING");
+        let url2Connect;
+        try {
+            const socketUrlObj = new URL(this.options.socketUrl);
+            socketUrlObj.searchParams.set(constants.WHITELIST_KEY_LABEL, this.options.whitelistKey);
+            url2Connect = socketUrlObj.toString();
+        } catch (exc) {
+            this.connecting = this.connected = false;
+            const err = error_createError({
+                message: "Invalid WebSocket URL",
+                explanation: `The configured socketUrl "${this.options.socketUrl}" is not a valid URL. Please check your videomail-client configuration.`,
+                options: this.options,
+                exc
+            });
+            this.emit("ERROR", {
+                err
+            });
+            return;
+        }
+        this.options.logger.debug(`Recorder: initializing web socket stream to ${url2Connect}`);
+        let nativeSocket;
+        try {
+            nativeSocket = new WebSocket(url2Connect);
+            nativeSocket.addEventListener("close", (event)=>{
+                this.lastCloseEvent = {
+                    code: event.code,
+                    reason: event.reason,
+                    wasClean: event.wasClean
+                };
+            });
+            nativeSocket.addEventListener("error", (event)=>{
+                this.lastSocketError = error_getEventDetails(event);
+            });
+        } catch (exc) {
+            this.connecting = this.connected = false;
+            const diagnostic = error_getWebSocketDiagnostic(url2Connect);
+            const message = diagnostic.looksAutomated ? "Automated crawler: WebSocket not supported in this environment" : `Failed to construct WebSocket to ${url2Connect}`;
+            const explanation = diagnostic.looksAutomated ? "Headless crawlers cannot use Videomail's WebSocket. No action needed." : `Please check your connection and try again. If the problem persists, contact us. Diagnostic: ${diagnostic.text}`;
+            const err = error_createError({
+                message,
+                explanation,
+                options: this.options,
+                exc
+            });
+            this.emit("ERROR", {
+                err
+            });
+            return;
+        }
+        try {
+            this.stream = websocket_stream(nativeSocket);
+        } catch (exc) {
+            this.connecting = this.connected = false;
+            const err = error_createError({
+                message: `Failed to create a stream to ${url2Connect}`,
+                explanation: "Please check your connection and try again. If the problem persists, contact us.",
+                options: this.options,
+                exc
+            });
+            this.emit("ERROR", {
+                err
+            });
+        }
+        if (this.stream) {
+            const connectionTimeoutMs = this.options.timeouts.connection;
+            this.connectionTimeout = window.setTimeout(()=>{
+                if (this.isOnline() && this.isUserMediaLoaded()) {
+                    this.options.logger.debug(`${PIPE_SYMBOL}Reconnecting due to connection timeout.`);
+                    this.initSocket();
+                } else this.failConnection({
+                    url2Connect,
+                    cause: "timeout"
                 });
-                this.emit("ERROR", {
-                    err
+            }, connectionTimeoutMs);
+            this.stream.on("close", ()=>{
+                const debugLine = util_summarize(`${PIPE_SYMBOL}Stream has closed:`, {
+                    connecting: this.connecting,
+                    connected: this.connected,
+                    userMediaLoaded: this.userMediaLoaded,
+                    blocking: this.blocking
                 });
-            }
-            if (this.stream) {
-                const connectionTimeoutMs = this.options.timeouts.connection;
-                this.connectionTimeout = window.setTimeout(()=>{
+                this.options.logger.debug(debugLine);
+                const tryReconnect = this.connected && this.userMediaLoaded;
+                this.connected = false;
+                if (tryReconnect) this.initSocket();
+                else if (!this.connecting && !this.blocking) window.setTimeout(()=>{
                     this.failConnection({
                         url2Connect,
-                        cause: "timeout"
+                        cause: "closed"
                     });
-                }, connectionTimeoutMs);
-                this.stream.on("close", ()=>{
-                    const debugLine = util_summarize(`${PIPE_SYMBOL}Stream has closed:`, {
-                        connecting: this.connecting,
-                        connected: this.connected,
-                        userMediaLoaded: this.userMediaLoaded,
-                        blocking: this.blocking
-                    });
-                    this.options.logger.debug(debugLine);
-                    const tryReconnect = this.connected && this.userMediaLoaded;
-                    this.connected = false;
-                    if (tryReconnect) this.initSocket();
-                    else if (!this.connecting && !this.blocking) window.setTimeout(()=>{
-                        this.failConnection({
-                            url2Connect,
-                            cause: "closed"
-                        });
-                    }, 0);
-                });
-                this.stream.on("connect", (args)=>{
-                    this.options.logger.debug(`${PIPE_SYMBOL}Stream *connect* event emitted with args: ${util_pretty(args)}`);
-                    this.clearConnectionTimeout();
-                    const isClosing = this.stream?.socket.readyState === WebSocket.CLOSING;
-                    if (!this.connected && !isClosing && !this.unloaded) {
-                        this.connected = true;
-                        this.connecting = this.unloaded = false;
-                        this.emit("CONNECTED");
-                        cb?.();
-                    }
-                });
-                this.stream.on("data", (data)=>{
-                    this.options.logger.debug(`${PIPE_SYMBOL}Stream *data* event emitted`);
-                    try {
-                        const command = JSON.parse(data.toString());
-                        this.executeCommand(command);
-                    } catch (exc) {
-                        this.options.logger.error(`Failed to parse command: ${exc}`);
-                        const err = error_createError({
-                            message: "Invalid server command",
-                            explanation: `Contact us. The invalid command was: ${data.toString()}.`,
-                            options: this.options,
-                            exc
-                        });
-                        this.emit("ERROR", {
-                            err
-                        });
-                    }
-                });
-                this.stream.on("error", (err)=>{
-                    if ("u" > typeof Event && err instanceof Event) this.lastSocketError = error_getEventDetails(err);
-                    else this.lastSocketError = serializeError(err);
-                    const debugLine = util_summarize(`${PIPE_SYMBOL}Stream *error* event emitted:`, {
-                        error: serializeError(err)
-                    });
-                    this.options.logger.debug(debugLine);
-                    if (!this.connected) return void this.failConnection({
-                        url2Connect,
-                        cause: "error"
-                    });
-                    const streamError = err instanceof Error ? err : new Error("WebSocket stream emitted an error event", {
-                        cause: this.lastSocketError ?? err
+                }, 0);
+            });
+            this.stream.on("connect", (args)=>{
+                this.options.logger.debug(`${PIPE_SYMBOL}Stream *connect* event emitted with args: ${util_pretty(args)}`);
+                this.clearConnectionTimeout();
+                const isClosing = this.stream?.socket.readyState === WebSocket.CLOSING;
+                if (!this.connected && !isClosing && !this.unloaded) {
+                    this.connected = true;
+                    this.connecting = this.unloaded = false;
+                    this.emit("CONNECTED");
+                    cb?.();
+                }
+            });
+            this.stream.on("data", (data)=>{
+                this.options.logger.debug(`${PIPE_SYMBOL}Stream *data* event emitted`);
+                try {
+                    const command = JSON.parse(data.toString());
+                    this.executeCommand(command);
+                } catch (exc) {
+                    this.options.logger.error(`Failed to parse command: ${exc}`);
+                    const err = error_createError({
+                        message: "Invalid server command",
+                        explanation: `Contact us. The invalid command was: ${data.toString()}.`,
+                        options: this.options,
+                        exc
                     });
                     this.emit("ERROR", {
-                        err: error_createError({
-                            message: "WebSocket stream error",
-                            explanation: `The WebSocket stream emitted an error event. Details: ${util_pretty(err)}`,
-                            options: this.options,
-                            exc: streamError
-                        })
+                        err
                     });
+                }
+            });
+            this.stream.on("error", (err)=>{
+                if ("u" > typeof Event && err instanceof Event) this.lastSocketError = error_getEventDetails(err);
+                else this.lastSocketError = serializeError(err);
+                const debugLine = util_summarize(`${PIPE_SYMBOL}Stream *error* event emitted:`, {
+                    error: serializeError(err)
                 });
-                this.stream.on("drain", ()=>{
-                    this.options.logger.debug(`${PIPE_SYMBOL}Stream *drain* event emitted (should not happen!)`);
-                });
-                this.stream.on("preend", (args)=>{
-                    this.options.logger.debug(`${PIPE_SYMBOL}Stream *preend* event emitted with args: ${util_pretty(args)}`);
-                });
-                this.stream.on("end", ()=>{
-                    this.options.logger.debug(`${PIPE_SYMBOL}Stream *end* event emitted`);
-                });
-                this.stream.on("drain", (args)=>{
-                    this.options.logger.debug(`${PIPE_SYMBOL}Stream *drain* event emitted with args: ${util_pretty(args)}`);
-                });
-                this.stream.on("pipe", (src)=>{
-                    this.options.logger.debug(`${PIPE_SYMBOL}Stream *pipe* event emitted with src: ${util_pretty(src)}`);
-                });
-                this.stream.on("unpipe", (src)=>{
-                    this.options.logger.debug(`${PIPE_SYMBOL}Stream *unpipe* event emitted with src: ${util_pretty(src)}`);
-                });
-                this.stream.on("resume", (args)=>{
-                    this.options.logger.debug(`${PIPE_SYMBOL}Stream *resume* event emitted with args: ${util_pretty(args)}`);
-                });
-                this.stream.on("uncork", (args)=>{
-                    this.options.logger.debug(`${PIPE_SYMBOL}Stream *uncork* event emitted with args: ${util_pretty(args)}`);
-                });
-                this.stream.on("readable", (args)=>{
-                    this.options.logger.debug(`${PIPE_SYMBOL}Stream *readable* event emitted with args: ${util_pretty(args)}`);
+                this.options.logger.debug(debugLine);
+                if (!this.connected) return void this.failConnection({
+                    url2Connect,
+                    cause: "error"
                 });
-                this.stream.on("prefinish", (args)=>{
-                    this.options.logger.debug(`${PIPE_SYMBOL}Stream *prefinish* event emitted with args: ${util_pretty(args)}`);
+                const streamError = err instanceof Error ? err : new Error("WebSocket stream emitted an error event", {
+                    cause: this.lastSocketError ?? err
                 });
-                this.stream.on("finish", (args)=>{
-                    this.options.logger.debug(`${PIPE_SYMBOL}Stream *finish* event emitted with args: ${util_pretty(args)}`);
+                this.emit("ERROR", {
+                    err: error_createError({
+                        message: "WebSocket stream error",
+                        explanation: `The WebSocket stream emitted an error event. Details: ${util_pretty(err)}`,
+                        options: this.options,
+                        exc: streamError
+                    })
                 });
-            }
+            });
+            this.stream.on("drain", ()=>{
+                this.options.logger.debug(`${PIPE_SYMBOL}Stream *drain* event emitted (should not happen!)`);
+            });
+            this.stream.on("preend", (args)=>{
+                this.options.logger.debug(`${PIPE_SYMBOL}Stream *preend* event emitted with args: ${util_pretty(args)}`);
+            });
+            this.stream.on("end", ()=>{
+                this.options.logger.debug(`${PIPE_SYMBOL}Stream *end* event emitted`);
+            });
+            this.stream.on("drain", (args)=>{
+                this.options.logger.debug(`${PIPE_SYMBOL}Stream *drain* event emitted with args: ${util_pretty(args)}`);
+            });
+            this.stream.on("pipe", (src)=>{
+                this.options.logger.debug(`${PIPE_SYMBOL}Stream *pipe* event emitted with src: ${util_pretty(src)}`);
+            });
+            this.stream.on("unpipe", (src)=>{
+                this.options.logger.debug(`${PIPE_SYMBOL}Stream *unpipe* event emitted with src: ${util_pretty(src)}`);
+            });
+            this.stream.on("resume", (args)=>{
+                this.options.logger.debug(`${PIPE_SYMBOL}Stream *resume* event emitted with args: ${util_pretty(args)}`);
+            });
+            this.stream.on("uncork", (args)=>{
+                this.options.logger.debug(`${PIPE_SYMBOL}Stream *uncork* event emitted with args: ${util_pretty(args)}`);
+            });
+            this.stream.on("readable", (args)=>{
+                this.options.logger.debug(`${PIPE_SYMBOL}Stream *readable* event emitted with args: ${util_pretty(args)}`);
+            });
+            this.stream.on("prefinish", (args)=>{
+                this.options.logger.debug(`${PIPE_SYMBOL}Stream *prefinish* event emitted with args: ${util_pretty(args)}`);
+            });
+            this.stream.on("finish", (args)=>{
+                this.options.logger.debug(`${PIPE_SYMBOL}Stream *finish* event emitted with args: ${util_pretty(args)}`);
+            });
         }
     }
     showUserMedia() {
@@ -7103,8 +7118,8 @@ class Recorder extends util_Despot {
                 ideal: idealHeight
             };
         }
-        this.options.logger.debug(`Recorder: our webcam constraints are: ${util_pretty(constraints)}`);
-        this.options.logger.debug(`Recorder: available webcam constraints are: ${util_pretty(navigator.mediaDevices.getSupportedConstraints())}`);
+        this.options.logger.debug(util_summarize("Recorder: our webcam constraints are:", constraints));
+        this.options.logger.debug(util_summarize("Recorder: available webcam constraints are:", navigator.mediaDevices.getSupportedConstraints()));
         const streamPromise = navigator.mediaDevices.getUserMedia(constraints);
         streamPromise.then((localStream)=>{
             this.getUserMediaCallback(localStream, params);

package/dist/esm/{util/html/media → media}/canPlayType.d.ts

@@ -1,3 +1,3 @@
-import { VideoTypeType } from "./../../../types/VideoType.js";
+import { VideoTypeType } from "../types/VideoType.js";
 declare function canPlayType(video: HTMLVideoElement, type: VideoTypeType): false | "maybe" | "probably";
 export default canPlayType;

package/dist/esm/util/error/createError.d.ts

@@ -2,6 +2,7 @@ import { VideomailClientOptions } from "../../types/options.js";
 import HTTPVideomailError from "./HTTPVideomailError.js";
 import VideomailError from "./VideomailError.js";
 interface ErrorParams {
+    cause?: unknown;
     err?: HTTPVideomailError;
     exc?: unknown;
     message?: string;

package/dist/esm/wrappers/visuals/recorder.d.ts

@@ -60,6 +60,7 @@ declare class Recorder extends Despot {
     private onUserMediaReady;
     private clearRetryTimeout;
     private clearConnectionTimeout;
+    private isOnline;
     private failConnection;
     private calculateFrameProgress;
     private calculateSampleProgress;