videomail-client 16.1.1 → 16.2.0

package/dist/esm/types/events/params.d.ts

@@ -40,10 +40,11 @@ export interface VideomailSubmittedParams {
     response: Response;
 }
 export interface VideomailValidatingParams {
-    targetName?: any;
-    event?: any;
+    targetName?: string | undefined;
+    event?: Event | undefined;
 }
 export interface VideomailInvalidParams {
     whyInvalid?: string | undefined;
-    invalidData?: Record<string, string>;
+    invalidData?: VideomailInvalidFormData | undefined;
 }
+export type VideomailInvalidFormData = Record<string, string | null | undefined>;

package/dist/esm/util/email/isRecipientSelectionValid.d.ts

@@ -0,0 +1,4 @@
+import type { PartialVideomail } from "../../types/Videomail.js";
+type Recipients = Pick<PartialVideomail, "bcc" | "cc" | "to">;
+declare function isRecipientSelectionValid(recipients: Recipients): boolean;
+export default isRecipientSelectionValid;

package/dist/esm/wrappers/container.d.ts

@@ -69,7 +69,7 @@ declare class Container extends Despot {
     }): void;
     suspend(): void;
     recoverCamera(): Promise<boolean>;
-    validate(event?: any, force?: boolean): boolean;
+    validate(event?: Event, force?: boolean): boolean;
     disableForm(buttonsToo: boolean): void;
     enableForm(buttonsToo: boolean): void;
     hasForm(): boolean;

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

@@ -0,0 +1,87 @@
+import type AudioSample from "audio-sample";
+import Frame from "canvas-to-buffer";
+import type { VideomailCommandArgs } from "../../../types/command.js";
+import type { Dimension } from "../../../types/dimension.js";
+import type { VideomailUserMediaReadyParams } from "../../../types/events/params.js";
+import type { VideomailClientOptions } from "../../../types/options.js";
+import type Visuals from "../../visuals.js";
+import type Replay from "../replay.js";
+import RecorderMedia from "./media.js";
+interface RecorderAnimationFrameApi {
+    requestAnimationFrame(callback: () => void): number;
+    cancelAnimationFrame(handle?: number): void;
+}
+export interface RecorderLoop {
+    complete?(): void;
+    dispose(): void;
+    getElapsedTime(): number;
+    getRequestAnimationFrameObject(): RecorderAnimationFrameApi;
+    isRunning(): boolean;
+    on(eventName: "update", listener: (deltaTime: number, elapsedTime: number) => void): void;
+    setRequestAnimationFrameObject(animationFrameApi: RecorderAnimationFrameApi): void;
+    start(): void;
+    stop(): void;
+}
+export interface StopParams {
+    limitReached?: boolean;
+}
+interface PauseParams {
+    event?: MouseEvent;
+}
+declare abstract class RecorderCapture extends RecorderMedia {
+    protected readonly replay: Replay;
+    protected loop?: RecorderLoop | undefined;
+    protected originalAnimationFrameObject?: RecorderAnimationFrameApi | undefined;
+    protected recordingAudioSampleRate?: number | undefined;
+    private frameProgress?;
+    private sampleProgress?;
+    protected canvas?: HTMLCanvasElement | undefined;
+    protected ctx?: CanvasRenderingContext2D | undefined | null;
+    protected stopTime?: number | undefined;
+    protected waitingTime?: number | undefined;
+    protected frame?: Frame;
+    protected recordingBuffer?: Buffer | undefined;
+    protected abstract getRecorderWidth(responsive: boolean): Dimension | undefined;
+    protected abstract getRecorderHeight(responsive: boolean, useBoundingClientRect?: boolean): Dimension | undefined;
+    protected constructor(visuals: Visuals, replay: Replay, options: VideomailClientOptions);
+    protected onAudioSample(audioSample: AudioSample): void;
+    protected onUserMediaReady(params?: VideomailUserMediaReadyParams): void;
+    private calculateFrameProgress;
+    private calculateSampleProgress;
+    private updateOverallProgress;
+    protected updateFrameProgress(args?: VideomailCommandArgs): void;
+    protected updateSampleProgress(args?: VideomailCommandArgs): void;
+    protected preview(args?: VideomailCommandArgs): void;
+    private cancelAnimationFrame;
+    private getIntervalSum;
+    private getAvgInterval;
+    private getAvgFps;
+    private hasValidInterval;
+    getRecordingStats(): import("../../../index.js").RecordingStats | undefined;
+    getAudioSampleRate(): number | undefined;
+    stop(params?: StopParams): void;
+    back(cb: () => void): void;
+    protected reInitializeAudio(): void;
+    reset(): void;
+    validate(): boolean;
+    pause(params?: PauseParams): void;
+    resume(): void;
+    private onFlushed;
+    private draw;
+    private createLoop;
+    record(): void;
+    private setAnimationFrameObject;
+    protected restoreAnimationFrameObject(): void;
+    protected loopWithTimeouts(): void;
+    isPaused(): boolean | undefined;
+    protected isUserMediaPaused(): boolean;
+    protected isCaptureLoopRunning(): boolean;
+    protected stopCaptureLoop(): void;
+    protected startCaptureLoop(): void;
+    isRecording(): boolean;
+    getRecordingDimensions(): {
+        height: number;
+        width: number;
+    } | undefined;
+}
+export default RecorderCapture;

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

@@ -0,0 +1,46 @@
+import type { VideomailCommand, VideomailCommandArgs } from "../../../types/command.js";
+import type { VideomailClientOptions } from "../../../types/options.js";
+import type { RecordingStats } from "../../../types/RecordingStats.js";
+import RecorderStreamWriter from "./streamWriter.js";
+type RecorderOutgoingCommandArgs = VideomailCommandArgs | RecordingStats;
+declare abstract class RecorderConnection extends RecorderStreamWriter {
+    protected reconnectTimeout?: number | undefined;
+    protected connectionTimeout?: number | undefined;
+    protected userMediaLoaded?: boolean | undefined;
+    protected userMediaLoading: boolean;
+    protected unloaded?: boolean;
+    protected connectionFailed: boolean;
+    protected reconnectAttempts: number;
+    protected blocking: boolean;
+    protected connectingStartedAt?: number | undefined;
+    protected lastCloseEvent?: {
+        code: number;
+        reason: string;
+        wasClean: boolean;
+    } | undefined;
+    protected lastSocketError?: Record<string, unknown> | undefined;
+    protected pingInterval?: number | undefined;
+    protected abstract executeCommand(command: VideomailCommand): void;
+    abstract isUserMediaLoaded(): boolean | undefined;
+    abstract validate(): boolean;
+    protected constructor(options: VideomailClientOptions);
+    private canReconnectAfterStreamClose;
+    private shouldReportStreamClose;
+    private handleStreamClose;
+    private shouldIgnoreStreamClose;
+    private handleStreamError;
+    protected sendPings(): void;
+    protected stopPings(): void;
+    protected clearConnectionTimeout(): void;
+    protected clearReconnectTimeout(): void;
+    private handleConnectionFailure;
+    private retryConnection;
+    private canRetryConnection;
+    private shouldContinueReconnect;
+    private isOnline;
+    private failConnection;
+    private shouldIgnoreConnectionFailure;
+    protected initSocket(cb?: () => void): void;
+    protected writeCommand(command: string, args?: RecorderOutgoingCommandArgs, cb?: () => void): void;
+}
+export default RecorderConnection;

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

@@ -0,0 +1,21 @@
+import type { Dimension } from "../../../types/dimension.js";
+import type { VideomailClientOptions } from "../../../types/options.js";
+import type Visuals from "../../visuals.js";
+import type UserMedia from "../userMedia.js";
+interface RecorderDimensionsContext {
+    options: VideomailClientOptions;
+    visuals: Pick<Visuals, "getRatio" | "limitWidth">;
+    getRecorderElement: () => HTMLVideoElement | null | undefined;
+    getUserMedia: () => UserMedia | undefined;
+}
+declare class RecorderDimensions {
+    private readonly context;
+    constructor(context: RecorderDimensionsContext);
+    correctDimensions(): void;
+    getRecorderWidth(responsive: boolean): Dimension | undefined;
+    getRecorderHeight(responsive: boolean, useBoundingClientRect?: boolean): Dimension | undefined;
+    getRatio(): number | undefined;
+    calculateWidth(responsive: boolean): Dimension;
+    calculateHeight(responsive: boolean): Dimension;
+}
+export default RecorderDimensions;

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

@@ -0,0 +1,51 @@
+import type AudioSample from "audio-sample";
+import type { VideomailUserMediaReadyParams } from "../../../types/events/params.js";
+import type { VideomailClientOptions } from "../../../types/options.js";
+import type Visuals from "../../visuals.js";
+import UserMedia from "../userMedia.js";
+import RecorderConnection from "./connection.js";
+declare abstract class RecorderMedia extends RecorderConnection {
+    protected readonly visuals: Visuals;
+    protected recorderElement?: HTMLVideoElement | undefined | null;
+    protected userMedia?: UserMedia;
+    protected userMediaTimeout?: number | undefined;
+    protected retryTimeout?: number | undefined;
+    protected stopTimeout?: number | undefined;
+    protected mediaRequestId: number;
+    protected cameraRecovery?: Promise<boolean> | undefined;
+    protected resolveCameraRecovery?: ((restored: boolean) => void) | undefined;
+    protected resumeAfterCameraRecovery: boolean;
+    protected submitting: boolean;
+    protected built: boolean;
+    protected key?: string | undefined;
+    protected facingMode: ConstrainDOMString;
+    protected abstract onUserMediaReady(params?: VideomailUserMediaReadyParams): void;
+    protected abstract onAudioSample(audioSample: AudioSample): void;
+    protected abstract record(): void;
+    protected abstract pause(): void;
+    protected abstract resume(): void;
+    protected abstract isPaused(): boolean | undefined;
+    protected abstract isRecording(): boolean;
+    protected constructor(visuals: Visuals, options: VideomailClientOptions);
+    show(): void;
+    protected clearRetryTimeout(): void;
+    private showUserMedia;
+    private userMediaErrorCallback;
+    private getUserMediaCallback;
+    private loadGenuineUserMedia;
+    protected loadUserMedia(params?: VideomailUserMediaReadyParams): void;
+    protected isNotifying(): boolean | null | undefined;
+    private isHidden;
+    protected clearUserMediaTimeout(): void;
+    protected clearStopTimeout(): void;
+    isReady(): boolean | undefined;
+    protected finishCameraRecovery(restored: boolean): void;
+    protected cancelCameraRecovery(): void;
+    protected failCameraRecovery(exc: unknown): void;
+    recoverCamera(): Promise<boolean>;
+    protected switchFacingMode(): void;
+    hide(): void;
+    isUnloaded(): boolean | undefined;
+    isUserMediaLoaded(): boolean | undefined;
+}
+export default RecorderMedia;

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

@@ -0,0 +1,14 @@
+import type { Dimension } from "../../../types/dimension.js";
+import type { VideomailUserMediaReadyParams } from "../../../types/events/params.js";
+import type { VideomailClientOptions } from "../../../types/options.js";
+interface UserMediaConstraintsParams {
+    options: VideomailClientOptions;
+    facingMode: ConstrainDOMString;
+    limitedWidth?: Dimension | undefined;
+    userMediaParams?: VideomailUserMediaReadyParams | undefined;
+}
+declare function createUserMediaConstraints({ options, facingMode, limitedWidth, userMediaParams, }: UserMediaConstraintsParams): {
+    audio: boolean;
+    video: MediaTrackConstraints;
+};
+export default createUserMediaConstraints;

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

@@ -0,0 +1,11 @@
+import type { VideomailCommandArgs } from "../../../types/command.js";
+import type { VideomailClientOptions } from "../../../types/options.js";
+type ProgressKind = "frame" | "sample";
+interface ConfirmedProgressParams {
+    args?: VideomailCommandArgs | undefined;
+    kind: ProgressKind;
+    options: VideomailClientOptions;
+}
+declare function calculateProgress(confirmedCount: number, totalCount: number): string;
+declare function getConfirmedProgressNumber({ args, kind, options }: ConfirmedProgressParams): number;
+export { calculateProgress, getConfirmedProgressNumber };

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

@@ -0,0 +1,56 @@
+import websocket from "websocket-stream";
+import type { VideomailClientOptions } from "../../../types/options.js";
+import type { RecordingStats } from "../../../types/RecordingStats.js";
+import BoundedWriteQueue from "../../../util/boundedWriteQueue.js";
+import Despot from "../../../util/Despot.js";
+export declare const PIPE_SYMBOL = "\u00B0\u00BA\u00A4\u00F8,\u00B8\u00B8,\u00F8\u00A4\u00BA\u00B0`\u00B0\u00BA\u00A4\u00F8,\u00B8,\u00F8\u00A4\u00B0\u00BA\u00A4\u00F8,\u00B8\u00B8,\u00F8\u00A4\u00BA\u00B0`\u00B0\u00BA\u00A4\u00F8,\u00B8 ";
+export interface WriteStreamParams {
+    frameNumber?: number;
+    onFlushedCallback?: (params: WriteStreamParams) => void;
+}
+declare abstract class RecorderStreamWriter extends Despot {
+    protected readonly pendingWrites: BoundedWriteQueue<WriteStreamParams>;
+    protected samplesCount: number;
+    protected framesCount: number;
+    protected recordingStats?: RecordingStats;
+    protected confirmedFrameNumber: number;
+    protected confirmedSampleNumber: number;
+    protected backpressureTimeout?: number | undefined;
+    protected recordingDimensions?: Pick<HTMLCanvasElement, "width" | "height"> | undefined;
+    protected stream?: websocket.WebSocketDuplex | undefined;
+    protected streamBackpressured: boolean;
+    protected resumeAfterDrain: boolean;
+    protected mediaTransmissionStarted: boolean;
+    protected recordingActive: boolean;
+    protected recordingTransportFailed: boolean;
+    protected connecting: boolean;
+    protected connected: boolean;
+    protected reconnecting: boolean;
+    protected abstract isUserMediaPaused(): boolean;
+    protected abstract isCaptureLoopRunning(): boolean;
+    protected abstract stopCaptureLoop(): void;
+    protected abstract startCaptureLoop(): void;
+    protected abstract stopPings(): void;
+    protected abstract clearReconnectTimeout(): void;
+    abstract reset(): void;
+    protected constructor(options: VideomailClientOptions);
+    private hasExceededWebSocketSendBuffer;
+    protected writeStream(buffer: Buffer, opts?: WriteStreamParams): void;
+    private writeToStream;
+    private flushPendingWrites;
+    private isStaleStream;
+    private canPauseForBackpressure;
+    private pauseForBackpressure;
+    private resumeRecordingAfterDrain;
+    private canResumeAfterDrain;
+    private handleWriteFailure;
+    private failMediaTransmission;
+    private startBackpressureTimeout;
+    private shouldStartBackpressureTimeout;
+    private shouldIgnoreBackpressureTimeout;
+    protected failInterruptedRecording(): void;
+    protected handleStreamDrain(stream: websocket.WebSocketDuplex): void;
+    private clearBackpressureTimeout;
+    protected discardSocket(): void;
+}
+export default RecorderStreamWriter;

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

@@ -1,180 +1,28 @@
-import { Dimension } from "../../types/dimension.js";
-import { VideomailClientOptions } from "../../types/options.js";
-import { RecordingStats } from "../../types/RecordingStats.js";
-import Despot from "../../util/Despot.js";
+import { VideomailCommand } from "../../types/command.js";
+import type { VideomailClientOptions } from "../../types/options.js";
 import { UnloadParams } from "../container.js";
 import Visuals from "../visuals.js";
+import RecorderCapture from "./recorder/capture.js";
 import Replay from "./replay.js";
-export interface StopParams {
-    limitReached?: boolean;
-}
-interface PauseParams {
-    event?: MouseEvent;
-}
-declare class Recorder extends Despot {
-    private readonly visuals;
-    private readonly replay;
-    private readonly pendingWrites;
-    private loop?;
-    private originalAnimationFrameObject;
-    private samplesCount;
-    private framesCount;
-    private recordingAudioSampleRate?;
-    private recordingStats?;
-    private confirmedFrameNumber;
-    private confirmedSampleNumber;
-    private recorderElement?;
-    private userMedia?;
-    private userMediaTimeout?;
-    private retryTimeout?;
-    private reconnectTimeout?;
-    private connectionTimeout?;
-    private backpressureTimeout?;
-    private stopTimeout?;
-    private frameProgress?;
-    private sampleProgress?;
-    private canvas?;
-    private recordingDimensions?;
-    private ctx?;
-    private userMediaLoaded?;
-    private userMediaLoading;
-    private mediaRequestId;
-    private cameraRecovery?;
-    private resolveCameraRecovery?;
-    private resumeAfterCameraRecovery;
-    private submitting;
-    private unloaded?;
-    private stopTime?;
-    private stream?;
-    private streamBackpressured;
-    private resumeAfterDrain;
-    private mediaTransmissionStarted;
-    private recordingActive;
-    private recordingTransportFailed;
-    private connecting;
-    private connected;
-    private connectionFailed;
-    private reconnecting;
-    private reconnectAttempts;
-    private blocking;
-    private built;
-    private key?;
-    private waitingTime?;
-    private connectingStartedAt?;
-    private lastCloseEvent?;
-    private lastSocketError?;
-    private pingInterval?;
-    private frame?;
-    private recordingBuffer?;
-    private facingMode;
+export type { StopParams } from "./recorder/capture.js";
+declare class Recorder extends RecorderCapture {
+    private readonly dimensions;
     constructor(visuals: Visuals, replay: Replay, options: VideomailClientOptions);
-    private hasExceededWebSocketSendBuffer;
-    private writeStream;
-    private writeToStream;
-    private flushPendingWrites;
-    private isStaleStream;
-    private canPauseForBackpressure;
-    private pauseForBackpressure;
-    private resumeRecordingAfterDrain;
-    private canResumeAfterDrain;
-    private handleWriteFailure;
-    private failMediaTransmission;
-    private startBackpressureTimeout;
-    private shouldStartBackpressureTimeout;
-    private shouldIgnoreBackpressureTimeout;
-    private failInterruptedRecording;
-    private handleStreamDrain;
-    private canReconnectAfterStreamClose;
-    private shouldReportStreamClose;
-    private handleStreamClose;
-    private shouldIgnoreStreamClose;
-    private handleStreamError;
-    private sendPings;
-    private stopPings;
-    private onAudioSample;
-    show(): void;
-    private onUserMediaReady;
-    private clearRetryTimeout;
-    private clearConnectionTimeout;
-    private clearBackpressureTimeout;
-    private clearReconnectTimeout;
-    private handleConnectionFailure;
-    private retryConnection;
-    private canRetryConnection;
-    private shouldContinueReconnect;
-    private discardSocket;
-    private isOnline;
-    private failConnection;
-    private shouldIgnoreConnectionFailure;
-    private calculateFrameProgress;
-    private calculateSampleProgress;
-    private updateOverallProgress;
-    private updateFrameProgress;
-    private updateSampleProgress;
-    private preview;
-    private initSocket;
-    private showUserMedia;
-    private userMediaErrorCallback;
-    private getUserMediaCallback;
-    private loadGenuineUserMedia;
-    private configureVideoConstraints;
-    private loadUserMedia;
-    private executeCommand;
-    private isNotifying;
-    private isHidden;
-    private writeCommand;
-    private cancelAnimationFrame;
-    private getIntervalSum;
-    private getAvgInterval;
-    private getAvgFps;
-    private hasValidInterval;
-    getRecordingStats(): RecordingStats | undefined;
-    getAudioSampleRate(): number | undefined;
-    stop(params?: StopParams): void;
-    back(cb: () => void): void;
-    private reInitializeAudio;
+    protected executeCommand(command: VideomailCommand): void;
     unload(params?: UnloadParams): void;
-    reset(): void;
-    private clearUserMediaTimeout;
-    private clearStopTimeout;
-    validate(): boolean;
-    isReady(): boolean | undefined;
-    private finishCameraRecovery;
-    private cancelCameraRecovery;
-    private failCameraRecovery;
-    recoverCamera(): Promise<boolean>;
-    pause(params?: PauseParams): void;
-    resume(): void;
-    private onFlushed;
-    private draw;
-    private createLoop;
-    record(): void;
-    private setAnimationFrameObject;
-    private restoreAnimationFrameObject;
-    private loopWithTimeouts;
     private correctDimensions;
-    private switchFacingMode;
     private initEvents;
     private buildElement;
     build(): void;
-    isPaused(): boolean | undefined;
-    isRecording(): boolean;
-    hide(): void;
-    isUnloaded(): boolean | undefined;
-    getRecorderWidth(responsive: boolean): Dimension | undefined;
-    getRecordingDimensions(): {
-        height: number;
-        width: number;
-    } | undefined;
-    getRecorderHeight(responsive: boolean, useBoundingClientRect?: boolean): Dimension | undefined;
+    getRecorderWidth(responsive: boolean): import("../../types/dimension.js").Dimension | undefined;
+    getRecorderHeight(responsive: boolean, useBoundingClientRect?: boolean): import("../../types/dimension.js").Dimension | undefined;
     getRatio(): number | undefined;
-    calculateWidth(responsive: boolean): Dimension;
-    calculateHeight(responsive: boolean): Dimension;
+    calculateWidth(responsive: boolean): import("../../types/dimension.js").Dimension;
+    calculateHeight(responsive: boolean): import("../../types/dimension.js").Dimension;
     getRawVisualUserMedia(): HTMLVideoElement | null | undefined;
     isConnected(): boolean;
     isConnecting(): boolean;
-    limitWidth(width?: number): Dimension | undefined;
-    limitHeight(height: number | undefined): Dimension;
-    isUserMediaLoaded(): boolean | undefined;
+    limitWidth(width?: number): import("../../types/dimension.js").Dimension | undefined;
+    limitHeight(height: number | undefined): import("../../types/dimension.js").Dimension;
 }
 export default Recorder;