@fraku/video 0.1.58 → 0.1.59

package/dist/providers/VideoProvider/constants.d.ts

@@ -0,0 +1,13 @@
+import { MediaDevice, MobileVideoFacingMode } from '@zoom/videosdk';
+
+export declare const VALID_IMAGE_TYPES: readonly ["image/jpeg", "image/png", "image/jpg", "image/webp"];
+export declare const MAX_IMAGE_SIZE_BYTES: number;
+export declare const VIDEO_QUALITY_LEVEL = 3;
+export declare const DEFAULT_VIDEO_OPTIONS: {
+    readonly hd: true;
+    readonly fullHd: false;
+    readonly ptz: false;
+    readonly originalRatio: true;
+};
+export declare const DEFAULT_MOBILE_CAMERA_LIST: MediaDevice[];
+export declare const MOBILE_CAMERA_FACING_MODES: readonly [MobileVideoFacingMode.User, MobileVideoFacingMode.Environment];

package/dist/providers/VideoProvider/context.d.ts

@@ -1,6 +1,16 @@
 import { MutableRefObject } from 'react';
 import { MediaDevice, VideoPlayer } from '@zoom/videosdk';
 
+export type VirtualBackgroundMode = 'none' | 'blur' | 'image';
+export type CustomBackgroundImage = {
+    id: string;
+    url: string;
+};
+export type VirtualBackgroundState = {
+    mode: VirtualBackgroundMode;
+    customImages: CustomBackgroundImage[];
+    activeCustomImageId: string | null;
+};
 export type VideoContextType = {
     activeCameraId: string;
     attachSharedVideo: ({ userId, videoPlayer }: {
@@ -13,18 +23,20 @@ export type VideoContextType = {
     detachSharedVideo: (userId: number) => Promise<void>;
     detachUserVideo: (userId: number) => Promise<void>;
     finishScreenSharing: () => Promise<void>;
-    isBlurred: boolean;
     localVideoRef: MutableRefObject<HTMLVideoElement | null>;
     localVideoStarted: boolean;
     selfVideoStarted: boolean;
+    setVirtualBackgroundMode: (mode: VirtualBackgroundMode, imageId?: string) => Promise<void>;
+    removeBackgroundImage: (imageId: string) => Promise<void>;
     startScreenSharing: (params: {
         selfShareCanvas: HTMLVideoElement | null;
     }) => Promise<void>;
     startVideo: () => Promise<void>;
     stopLocalVideo: () => Promise<void>;
     stopVideo: () => Promise<void>;
-    switchBlurred: (blurred: boolean) => Promise<void>;
     switchCamera: (deviceId: string) => Promise<void>;
+    uploadBackgroundImage: (file: File) => Promise<void>;
+    virtualBackground: VirtualBackgroundState;
 };
 export declare const VideoContext: import('react').Context<VideoContextType>;
 export declare const useVideoContext: () => VideoContextType;

package/dist/providers/VideoProvider/tests/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/providers/VideoProvider/useLocalVideo.d.ts

@@ -0,0 +1,9 @@
+export type LocalVideoTrack = {
+    ref: React.MutableRefObject<HTMLVideoElement | null>;
+    started: boolean;
+    start: (cameraId: string, virtualBackgroundImageUrl?: string) => Promise<void>;
+    stop: () => Promise<void>;
+    switch: (cameraId: string) => Promise<void>;
+    updateVirtualBackground: (imageUrl: string) => Promise<void>;
+};
+export declare const useLocalVideo: () => LocalVideoTrack;

package/dist/providers/VideoProvider/useVideoDevices.d.ts

@@ -0,0 +1,12 @@
+import { MediaDevice } from '@zoom/videosdk';
+
+/**
+ * Custom hook to manage video device state (camera list and active camera)
+ */
+export declare const useVideoDevices: () => {
+    cameraList: MediaDevice[];
+    activeCameraId: string;
+    setActiveCameraId: import('react').Dispatch<import('react').SetStateAction<string>>;
+    handleDeviceChange: () => void;
+    isMobile: boolean;
+};

package/dist/providers/VideoProvider/useVideoEventHandlers.d.ts

@@ -0,0 +1,15 @@
+import { default as ZoomVideo } from '@zoom/videosdk';
+
+type UseVideoEventHandlersParams = {
+    zmClient: ReturnType<typeof ZoomVideo.createClient>;
+    sessionStarted: boolean;
+    onVideoStarted: () => void;
+    onVideoStopped: () => void;
+    onDeviceChange: () => void;
+    onScreenShareStopped: () => void;
+};
+/**
+ * Custom hook to manage Zoom video event subscriptions
+ */
+export declare const useVideoEventHandlers: ({ zmClient, sessionStarted, onVideoStarted, onVideoStopped, onDeviceChange, onScreenShareStopped }: UseVideoEventHandlersParams) => void;
+export {};

package/dist/providers/VideoProvider/useVirtualBackground.d.ts

@@ -0,0 +1,21 @@
+import { default as ZoomVideo } from '@zoom/videosdk';
+import { VirtualBackgroundMode, VirtualBackgroundState } from './context';
+import { LocalVideoTrack } from './useLocalVideo';
+import { NotifyProps } from '../DialogsProvider/context';
+
+type UseVirtualBackgroundParams = {
+    zmClient: ReturnType<typeof ZoomVideo.createClient>;
+    sessionStarted: boolean;
+    isSessionStarted: () => boolean;
+    localVideo: LocalVideoTrack;
+    activeCameraId: string;
+    notify: (props: NotifyProps) => void;
+    t: (key: string) => string;
+};
+export declare const useVirtualBackground: ({ zmClient, sessionStarted, isSessionStarted, localVideo, activeCameraId, notify, t }: UseVirtualBackgroundParams) => {
+    virtualBackground: VirtualBackgroundState;
+    setVirtualBackgroundMode: (mode: VirtualBackgroundMode, imageId?: string) => Promise<void>;
+    uploadBackgroundImage: (file: File) => Promise<void>;
+    removeBackgroundImage: (imageId: string) => Promise<void>;
+};
+export {};

package/dist/providers/VideoProvider/utils.d.ts

@@ -0,0 +1,67 @@
+import { VirtualBackgroundMode, VirtualBackgroundState, CustomBackgroundImage } from './context';
+
+/**
+ * Converts virtual background state to Zoom SDK image URL format
+ * @param mode - The virtual background mode
+ * @param customImages - Array of custom background images
+ * @param activeCustomImageId - ID of the active custom image
+ * @returns SDK-compatible image URL string ('', 'blur', or data URL)
+ */
+export declare const getVirtualBackgroundImageUrl: (mode: VirtualBackgroundMode, customImages: CustomBackgroundImage[], activeCustomImageId: string | null) => string;
+/**
+ * Validates background image file type
+ * @param file - The file to validate
+ * @returns true if valid, false otherwise
+ */
+export declare const isValidImageType: (file: File) => boolean;
+/**
+ * Validates background image file size
+ * @param file - The file to validate
+ * @returns true if valid, false otherwise
+ */
+export declare const isValidImageSize: (file: File) => boolean;
+/**
+ * Validation result for background image files
+ */
+export type FileValidationResult = {
+    valid: true;
+} | {
+    valid: false;
+    reason: 'invalid-type' | 'too-large';
+};
+/**
+ * Validates a background image file
+ * @param file - The file to validate
+ * @returns Validation result with reason if invalid
+ */
+export declare const validateBackgroundImageFile: (file: File) => FileValidationResult;
+/**
+ * Reads a file as a data URL (Base64)
+ * @param file - The file to read
+ * @returns Promise resolving to data URL string
+ * @throws Error if file reading fails
+ */
+export declare const readFileAsDataURL: (file: File) => Promise<string>;
+/**
+ * Gets the virtual background state from mode and image ID
+ * @param mode - The virtual background mode
+ * @param imageId - Optional image ID for custom backgrounds
+ * @param currentState - Current virtual background state
+ * @returns New virtual background state
+ */
+export declare const getVirtualBackgroundState: (mode: VirtualBackgroundMode, imageId: string | undefined, currentState: VirtualBackgroundState) => VirtualBackgroundState;
+/**
+ * Saves custom background images to localStorage
+ * @param images - Array of custom background images
+ * @returns true if saved successfully, false otherwise
+ */
+export declare const saveCustomImagesToLocalStorage: (images: CustomBackgroundImage[]) => boolean;
+/**
+ * Loads custom background images from localStorage
+ * @returns Array of custom background images, or empty array if none found
+ */
+export declare const loadCustomImagesFromLocalStorage: () => CustomBackgroundImage[];
+/**
+ * Clears all custom background images from localStorage
+ */
+export declare const clearCustomImagesFromLocalStorage: () => void;