@therealtinhtute/baroiplayer 1.1.0 → 1.2.0

package/src/core/providers/enhanced-hls-provider.ts

@@ -6,7 +6,7 @@
 import Hls, { HlsConfig } from "hls.js"
 import { MediaPlayerConfig } from "../../types"
 
-export interface EnhancedHLSConfig extends HlsConfig {
+export interface EnhancedHLSConfig extends Partial<HlsConfig> {
 	/** Enable machine learning-enhanced adaptive bitrate streaming */
 	enableAdvancedABR?: boolean
 	/** Optimize for low-latency streaming */
@@ -60,25 +60,6 @@ export const ENHANCED_HLS_DEFAULTS: EnhancedHLSConfig = {
 		}
 	},
 
-	// Progressive segment loading for better performance
-	segmentLoadPolicy: {
-		default: {
-			maxTimeToFirstByteMs: 9000,
-			maxLoadTimeMs: 20000,
-			timeoutRetry: {
-				maxNumRetry: 3,
-				retryDelayMs: 2000,
-				maxRetryDelayMs: 20000,
-				backoff: "linear"
-			},
-			errorRetry: {
-				maxNumRetry: 5,
-				retryDelayMs: 3000,
-				maxRetryDelayMs: 30000,
-				backoff: "linear"
-			}
-		}
-	},
 
 	// Enhanced manifest parsing
 	manifestLoadPolicy: {
@@ -102,7 +83,7 @@ export const ENHANCED_HLS_DEFAULTS: EnhancedHLSConfig = {
 
 	// Level selection optimization
 	startLevel: -1, // Auto-select start level
-	initialBitrate: 0, // Auto-detect
+	// initialBitrate: 0, // Auto-detect (not in HlsConfig)
 	preferManagedMediaSource: true,
 
 	// Debug and monitoring
@@ -172,11 +153,6 @@ export class EnhancedHLSProvider {
 		this.hls.on(Hls.Events.LEVEL_SWITCHED, (event, data) => {
 			this.performanceMonitor.onLevelSwitched(data)
 		})
-
-		// Quality optimization events
-		this.hls.on(Hls.Events.BITRATE_SWITCHING, (event, data) => {
-			this.performanceMonitor.onBitrateSwitch(data)
-		})
 	}
 
 	/**
@@ -202,16 +178,16 @@ export class EnhancedHLSProvider {
 
 			case Hls.ErrorDetails.FRAG_LOAD_TIMEOUT:
 				// Timeout - increase timeout and retry
-				if (this.hls) {
+				if (this.hls && this.hls.config.fragLoadPolicy?.default?.timeoutRetry) {
 					this.hls.config.fragLoadPolicy.default.timeoutRetry.maxNumRetry = 8
 					this.hls.config.fragLoadPolicy.default.timeoutRetry.retryDelayMs = 5000
 				}
 				break
 
 			case Hls.ErrorDetails.LEVEL_LOAD_ERROR:
-				// Manifest error - try recovery with alternative
-				if (options.hlsConfig?.fallbackUrl) {
-					this.hls?.loadSource(options.hlsConfig.fallbackUrl)
+				// Manifest error - try recovery
+				if (this.hls && data.fatal) {
+					this.hls.recoverMediaError()
 				}
 				break
 
@@ -229,11 +205,6 @@ export class EnhancedHLSProvider {
 				}
 				break
 		}
-
-		// Custom error handler if provided
-		if (options.onError) {
-			options.onError(data)
-		}
 	}
 
 	/**
@@ -242,7 +213,7 @@ export class EnhancedHLSProvider {
 	public updateConfig(newConfig: Partial<EnhancedHLSConfig>): void {
 		this.config = { ...this.config, ...newConfig }
 		if (this.hls) {
-			this.hls.config = this.config
+			Object.assign(this.hls.config, this.config)
 		}
 	}
 
@@ -289,11 +260,11 @@ class HLSPerformanceMonitor {
 
 	public attach(hls: Hls): void {
 		// Monitor video element for dropped frames
-		const video = hls.media
-		if (video) {
+		const video = hls.media as HTMLVideoElement | undefined
+		if (video && 'getVideoPlaybackQuality' in video) {
 			const checkDroppedFrames = () => {
-				if (video.getVideoPlaybackQuality) {
-					const quality = video.getVideoPlaybackQuality()
+				if (video && 'getVideoPlaybackQuality' in video) {
+					const quality = (video as any).getVideoPlaybackQuality()
 					this.metrics.droppedFrames = quality.droppedVideoFrames
 				}
 			}

package/src/core/providers/lazy-provider.tsx

@@ -1,46 +1,9 @@
-import { type ReactNode, Suspense, lazy } from 'react'
+import { type ReactNode, Suspense } from 'react'
 
-export const EnhancedHLSProvider = lazy(() =>
-	import(
-		/* webpackChunkName: "hls-provider" */
-		'./enhanced-hls-provider'
-	).then((module) => ({ default: module.EnhancedHLSProvider }))
-)
-
-export const SubtitleParser = lazy(() =>
-	import(
-		/* webpackChunkName: "subtitle-parser" */
-		'../features/subtitles/subtitle-parser'
-	).then((module) => ({ default: module.SubtitleParser }))
-)
-
-export const SubtitleManager = lazy(() =>
-	import(
-		/* webpackChunkName: "subtitle-manager" */
-		'../features/subtitles/subtitle-manager'
-	).then((module) => ({ default: module.SubtitleManager }))
-)
-
-export const BasePlugin = lazy(() =>
-	import(
-		/* webpackChunkName: "base-plugin" */
-		'../plugins/base-plugin'
-	).then((module) => ({ default: module.BasePlugin }))
-)
-
-export const PluginRegistry = lazy(() =>
-	import(
-		/* webpackChunkName: "plugin-registry" */
-		'../plugins/registry'
-	).then((module) => ({ default: module.PluginRegistry }))
-)
-
-export const AnalyticsPlugin = lazy(() =>
-	import(
-		/* webpackChunkName: "analytics-plugin" */
-		'../plugins/examples/analytics-plugin'
-	).then((module) => ({ default: module.AnalyticsPlugin }))
-)
+export async function loadEnhancedHLSProvider() {
+	const module = await import('./enhanced-hls-provider')
+	return module.EnhancedHLSProvider
+}
 
 export type LazyHLSProvider = Promise<{
 	default: new (config?: any) => { isSupported(): boolean; initialize(): any; destroy(): void }

package/src/features/media-session/media-session-manager.ts

@@ -1,4 +1,4 @@
-export interface MediaMetadata {
+export interface CustomMediaMetadata {
 	title?: string
 	artist?: string
 	album?: string
@@ -79,7 +79,7 @@ export class MediaSessionManager {
 	/**
 	 * Set media metadata
 	 */
-	setMetadata(metadata: MediaMetadata): void {
+	setMetadata(metadata: CustomMediaMetadata): void {
 		if (!this.isInitialized) return
 
 		try {
@@ -209,18 +209,6 @@ export class MediaSessionManager {
 				this.callbacks.onStop?.()
 				break
 
-			case "togglemicrophone":
-				this.callbacks.onToggleMicrophone?.()
-				break
-
-			case "togglecamera":
-				this.callbacks.onToggleCamera?.()
-				break
-
-			case "hangup":
-				this.callbacks.onHangup?.()
-				break
-
 			default:
 				console.warn(`Unhandled media session action: ${action}`)
 		}
@@ -339,9 +327,9 @@ export class MediaSessionManager {
 	 */
 	async updateFromMediaElement(
 		mediaElement: HTMLMediaElement,
-		additionalInfo?: Partial<MediaMetadata>
+		additionalInfo?: Partial<CustomMediaMetadata>
 	): Promise<void> {
-		const metadata: MediaMetadata = {
+		const metadata: CustomMediaMetadata = {
 			title: additionalInfo?.title || document.title || "Media Player",
 			artist: additionalInfo?.artist || "Unknown Artist",
 			album: additionalInfo?.album || "Unknown Album",
@@ -421,13 +409,3 @@ export class MediaSessionManager {
 export function createMediaSessionManager(config?: MediaSessionConfig): MediaSessionManager {
 	return new MediaSessionManager(config)
 }
-
-// Type definitions for better TypeScript support
-declare global {
-	interface Navigator {
-		mediaSession: MediaSession
-	}
-}
-
-// Export types for use in other modules
-export type { MediaSessionAction, MediaSessionActionDetails, MediaSessionPlaybackState }

package/src/features/picture-in-picture/pip-manager.ts

@@ -188,11 +188,11 @@ export class EnhancedPiPManager implements PiPManager {
 			this.emit("enter", { type: "document", window: this.pipWindow })
 
 			// Set up window event listeners
-			this.pipWindow.addEventListener("unload", () => {
+			if (this.pipWindow) this.pipWindow.addEventListener("unload", () => {
 				this.handleDocumentPiPClose()
 			})
 
-			this.pipWindow.addEventListener("pagehide", () => {
+			if (this.pipWindow) this.pipWindow.addEventListener("pagehide", () => {
 				this.handleDocumentPiPClose()
 			})
 		} catch (error) {

package/src/features/playlist/playlist-manager.ts

@@ -122,12 +122,14 @@ export class PlaylistManager {
 		indicesToRemove.forEach((index) => {
 			if (index >= 0 && index < this.items.length) {
 				const [removedItem] = this.items.splice(index, 1)
-				const [originalItem] = this.originalOrder.splice(
-					this.originalOrder.findIndex((item) => item.id === removedItem.id),
-					1
-				)
+				if (removedItem) {
+					const originalIndex = this.originalOrder.findIndex((item) => item.id === removedItem.id)
+					if (originalIndex >= 0) {
+						this.originalOrder.splice(originalIndex, 1)
+					}
 
-				removedItems.push(removedItem)
+					removedItems.push(removedItem)
+				}
 
 				// Adjust current index
 				if (index < this.currentIndex) {
@@ -171,6 +173,7 @@ export class PlaylistManager {
 		}
 
 		const [movedItem] = this.items.splice(fromIndex, 1)
+		if (!movedItem) return false
 		this.items.splice(toIndex, 0, movedItem)
 
 		// Update current index
@@ -202,7 +205,7 @@ export class PlaylistManager {
 	 */
 	getCurrentItem(): PlaylistItem | null {
 		return this.currentIndex >= 0 && this.currentIndex < this.items.length
-			? this.items[this.currentIndex]
+			? this.items[this.currentIndex] || null
 			: null
 	}
 
@@ -225,7 +228,7 @@ export class PlaylistManager {
 			this.emit("currentItemChanged", {
 				currentItem: this.items[index],
 				currentIndex: index,
-				previousItem: previousIndex >= 0 ? this.items[previousIndex] : undefined
+				previousItem: previousIndex >= 0 ? this.items[previousIndex] || undefined : undefined
 			})
 			return true
 		}
@@ -245,7 +248,7 @@ export class PlaylistManager {
 	 */
 	getNext(): PlaylistItem | null {
 		const nextIndex = this.getNextIndex()
-		return nextIndex >= 0 ? this.items[nextIndex] : null
+		return nextIndex >= 0 && nextIndex < this.items.length ? this.items[nextIndex] || null : null
 	}
 
 	/**
@@ -253,7 +256,7 @@ export class PlaylistManager {
 	 */
 	getPrevious(): PlaylistItem | null {
 		const prevIndex = this.getPreviousIndex()
-		return prevIndex >= 0 ? this.items[prevIndex] : null
+		return prevIndex >= 0 && prevIndex < this.items.length ? this.items[prevIndex] || null : null
 	}
 
 	/**
@@ -271,9 +274,9 @@ export class PlaylistManager {
 		// Check history first for better navigation
 		if (this.historyIndex > 0) {
 			this.historyIndex--
-			const historyIndex = this.history[this.historyIndex]
-			if (historyIndex >= 0 && historyIndex < this.items.length) {
-				this.currentIndex = historyIndex
+			const histIndex = this.history[this.historyIndex]
+			if (histIndex !== undefined && histIndex >= 0 && histIndex < this.items.length) {
+				this.currentIndex = histIndex
 				this.emit("currentItemChanged", {
 					currentItem: this.items[this.currentIndex],
 					currentIndex: this.currentIndex
@@ -297,7 +300,7 @@ export class PlaylistManager {
 	 * Get item by index
 	 */
 	getItem(index: number): PlaylistItem | null {
-		return index >= 0 && index < this.items.length ? this.items[index] : null
+		return index >= 0 && index < this.items.length ? this.items[index] || null : null
 	}
 
 	/**
@@ -440,17 +443,22 @@ export class PlaylistManager {
 		// Fisher-Yates shuffle
 		for (let i = this.items.length - 1; i > 0; i--) {
 			const j = Math.floor(Math.random() * (i + 1))
-			;[this.items[i], this.items[j]] = [this.items[j], this.items[i]]
+			const temp = this.items[i]
+			if (temp && this.items[j]) {
+				this.items[i] = this.items[j]
+				this.items[j] = temp
+			}
 		}
 
 		// Move current item to the beginning if it exists
 		if (currentItem) {
 			const currentItemIndex = this.items.findIndex((item) => item.id === currentItem.id)
 			if (currentItemIndex > 0) {
-				;[this.items[0], this.items[currentItemIndex]] = [
-					this.items[currentItemIndex],
-					this.items[0]
-				]
+				const temp = this.items[0]
+				if (temp && this.items[currentItemIndex]) {
+					this.items[0] = this.items[currentItemIndex]
+					this.items[currentItemIndex] = temp
+				}
 			}
 			this.currentIndex = 0
 		}

package/src/features/subtitles/subtitle-manager.ts

@@ -376,7 +376,7 @@ export class SubtitleManager {
 			output += `${startTime} --> ${endTime}`
 
 			if (cue.settings) {
-				const settings = []
+				const settings: string[] = []
 				Object.entries(cue.settings).forEach(([key, value]) => {
 					settings.push(`${key}:${value}`)
 				})

package/src/features/subtitles/subtitle-parser.ts

@@ -69,11 +69,13 @@ export class SubtitleParser {
 		if (lines[0]?.startsWith("WEBVTT")) {
 			i = 1
 			// Parse metadata in header
-			while (i < lines.length && lines[i].trim() !== "") {
-				const line = lines[i].trim()
+			while (i < lines.length && lines[i]?.trim() !== "") {
+				const line = lines[i]?.trim() || ""
 				if (line.includes(":")) {
 					const [key, value] = line.split(":").map((s) => s.trim())
-					metadata[key.toLowerCase()] = value
+					if (key && value) {
+						metadata[key.toLowerCase()] = value
+					}
 				}
 				i++
 			}
@@ -91,13 +93,13 @@ export class SubtitleParser {
 			let timingLine: string
 
 			// Check if this line is a timing line or cue identifier
-			const isTimingLine = lines[i].includes("-->")
+			const isTimingLine = lines[i]?.includes("-->")
 			if (isTimingLine) {
-				timingLine = lines[i]
+				timingLine = lines[i] || ""
 				i++
 			} else {
 				// This is a cue identifier
-				cueId = lines[i].trim()
+				cueId = lines[i]?.trim()
 				i++
 				timingLine = lines[i] || ""
 				i++
@@ -113,7 +115,8 @@ export class SubtitleParser {
 			// Collect cue text
 			const textLines: string[] = []
 			while (i < lines.length && lines[i]?.trim() !== "") {
-				textLines.push(lines[i])
+				const line = lines[i]
+				if (line) textLines.push(line)
 				i++
 			}
 
@@ -148,7 +151,7 @@ export class SubtitleParser {
 			if (lines.length < 3) continue
 
 			const id = lines[0]
-			const timingLine = lines[1]
+			const timingLine = lines[1] || ""
 			const textLines = lines.slice(2)
 
 			const timing = this.parseSRTTiming(timingLine)
@@ -180,8 +183,8 @@ export class SubtitleParser {
 			return null
 		}
 
-		const startTime = this.parseTimeString(parts[arrowIndex - 1])
-		const endTime = this.parseTimeString(parts[arrowIndex + 1])
+		const startTime = this.parseTimeString(parts[arrowIndex - 1] || "")
+		const endTime = this.parseTimeString(parts[arrowIndex + 1] || "")
 
 		if (startTime === null || endTime === null) {
 			return null
@@ -235,8 +238,8 @@ export class SubtitleParser {
 		const match = timingLine.match(/(\d{2}:\d{2}:\d{2},\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2},\d{3})/)
 		if (!match) return null
 
-		const startTime = this.parseTimeString(match[1].replace(",", "."))
-		const endTime = this.parseTimeString(match[2].replace(",", "."))
+		const startTime = this.parseTimeString(match[1]?.replace(",", ".") || "")
+		const endTime = this.parseTimeString(match[2]?.replace(",", ".") || "")
 
 		if (startTime === null || endTime === null) return null
 
@@ -250,10 +253,10 @@ export class SubtitleParser {
 		const match = timeStr.match(/(\d{2}):(\d{2}):(\d{2})\.(\d{3})/)
 		if (!match) return null
 
-		const hours = parseInt(match[1])
-		const minutes = parseInt(match[2])
-		const seconds = parseInt(match[3])
-		const milliseconds = parseInt(match[4])
+		const hours = parseInt(match[1] || "0", 10)
+		const minutes = parseInt(match[2] || "0", 10)
+		const seconds = parseInt(match[3] || "0", 10)
+		const milliseconds = parseInt(match[4] || "0", 10)
 
 		return hours * 3600 + minutes * 60 + seconds + milliseconds / 1000
 	}

package/src/features/thumbnails/thumbnail-generator.ts

@@ -393,6 +393,11 @@ export class ThumbnailGenerator {
 				reject(new Error("Seek timeout"))
 			}, 5000)
 
+			if (!this.videoElement) {
+				reject(new Error("Video element not initialized"))
+				return
+			}
+
 			this.videoElement.addEventListener("seeked", onSeeked)
 			this.videoElement.addEventListener("error", onError)
 			this.videoElement.currentTime = Math.max(0, Math.min(time, this.videoElement.duration))
@@ -436,12 +441,14 @@ export class ThumbnailGenerator {
 	private addToCache(key: string, thumbnail: GeneratedThumbnail): void {
 		// Remove oldest items if cache is full
 		if (this.cache.size >= this.config.maxCacheSize) {
-			const oldestKey = this.cache.keys().next().value
-			const oldThumbnail = this.cache.get(oldestKey)
-			if (oldThumbnail) {
-				URL.revokeObjectURL(oldThumbnail.objectUrl)
+			const oldestKey = this.cache.keys().next().value as string | undefined
+			if (oldestKey) {
+				const oldThumbnail = this.cache.get(oldestKey)
+				if (oldThumbnail) {
+					URL.revokeObjectURL(oldThumbnail.objectUrl)
+				}
+				this.cache.delete(oldestKey)
 			}
-			this.cache.delete(oldestKey)
 		}
 
 		this.cache.set(key, thumbnail)

package/src/hooks/__tests__/currentTime-fix.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect, beforeEach, vi } from "vitest"
+import { renderHook, act } from "@testing-library/react"
+import { useVideoPlayer } from "../useVideoPlayer"
+import React from "react"
+
+describe("currentTime non-finite value fix", () => {
+	let mockVideoElement: Partial<HTMLVideoElement>
+	let containerRef: React.RefObject<HTMLDivElement>
+
+	beforeEach(() => {
+		// Create a mock div element
+		const mockDiv = {
+			requestFullscreen: vi.fn()
+		} as unknown as HTMLDivElement
+
+		mockVideoElement = {
+			currentTime: NaN,
+			duration: NaN,
+			volume: 1,
+			muted: false,
+			play: vi.fn().mockResolvedValue(undefined),
+			pause: vi.fn(),
+			addEventListener: vi.fn(),
+			removeEventListener: vi.fn()
+		}
+
+		containerRef = {
+			current: mockDiv
+		}
+
+		vi.spyOn(global, "document" as any).mockReturnValue({
+			querySelector: vi.fn().mockReturnValue(mockVideoElement)
+		})
+	})
+
+	it("should handle NaN duration when seeking forward", () => {
+		const { result } = renderHook(() => useVideoPlayer(containerRef))
+
+		const videoRef = result.current.videoRef
+		if (videoRef.current) {
+			Object.assign(videoRef.current, mockVideoElement)
+		}
+
+		act(() => {
+			result.current.controls.seekForward(10)
+		})
+
+		// Should not throw error and should not set non-finite value
+		expect(mockVideoElement.currentTime).toBeNaN()
+	})
+
+	it("should handle NaN currentTime when seeking backward", () => {
+		mockVideoElement.currentTime = NaN
+
+		const { result } = renderHook(() => useVideoPlayer(containerRef))
+
+		const videoRef = result.current.videoRef
+		if (videoRef.current) {
+			Object.assign(videoRef.current, mockVideoElement)
+		}
+
+		act(() => {
+			result.current.controls.seekBackward(10)
+		})
+
+		// Should handle NaN gracefully - sets to 0
+		expect(() => result.current.controls.seekBackward(10)).not.toThrow()
+	})
+
+	it("should handle valid values correctly", () => {
+		mockVideoElement.currentTime = 50
+		mockVideoElement.duration = 100
+
+		const { result } = renderHook(() => useVideoPlayer(containerRef))
+
+		const videoRef = result.current.videoRef
+		if (videoRef.current) {
+			Object.assign(videoRef.current, mockVideoElement)
+
+			// Mock the currentTime setter to track calls
+			let setTimeValue: number | undefined
+			Object.defineProperty(videoRef.current, "currentTime", {
+				get: () => mockVideoElement.currentTime,
+				set: (value: number) => {
+					setTimeValue = value
+					mockVideoElement.currentTime = value
+				},
+				configurable: true
+			})
+
+			act(() => {
+				result.current.controls.seekForward(10)
+			})
+
+			// Should set valid time value
+			expect(setTimeValue).toBe(60)
+		}
+	})
+
+	it("should prevent seeking when duration is 0", () => {
+		mockVideoElement.currentTime = 10
+		mockVideoElement.duration = 0
+
+		const { result } = renderHook(() => useVideoPlayer(containerRef))
+
+		const videoRef = result.current.videoRef
+		if (videoRef.current) {
+			Object.assign(videoRef.current, mockVideoElement)
+
+			const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+
+			act(() => {
+				result.current.controls.seekForward(10)
+			})
+
+			expect(consoleSpy).toHaveBeenCalledWith("Cannot seek forward: duration is not available")
+			consoleSpy.mockRestore()
+		}
+	})
+
+	it("should clamp seek values to valid range", () => {
+		mockVideoElement.currentTime = 95
+		mockVideoElement.duration = 100
+
+		const { result } = renderHook(() => useVideoPlayer(containerRef))
+
+		const videoRef = result.current.videoRef
+		if (videoRef.current) {
+			Object.assign(videoRef.current, mockVideoElement)
+
+			let setTimeValue: number | undefined
+			Object.defineProperty(videoRef.current, "currentTime", {
+				get: () => mockVideoElement.currentTime,
+				set: (value: number) => {
+					setTimeValue = value
+					mockVideoElement.currentTime = value
+				},
+				configurable: true
+			})
+
+			act(() => {
+				result.current.controls.seekForward(10)
+			})
+
+			// Should clamp to duration (100, not 105)
+			expect(setTimeValue).toBe(100)
+		}
+	})
+})

package/src/hooks/accessibility/use-accessibility-preferences.ts

@@ -139,7 +139,7 @@ export function useFocusVisible() {
 		if (typeof window === "undefined") return
 
 		let hadKeyboardEvent = true
-		let keyboardThrottleTimeoutID: NodeJS.Timeout
+		let keyboardThrottleTimeoutID: NodeJS.Timeout | undefined
 
 		const handleKeyDown = (e: KeyboardEvent) => {
 			if (e.metaKey || e.altKey || e.ctrlKey) {

package/src/hooks/accessibility/use-focus-management.ts

@@ -92,13 +92,13 @@ export function useFocusManagement({
 				// Shift + Tab
 				if (document.activeElement === firstFocusable) {
 					event.preventDefault()
-					lastFocusable.focus()
+					lastFocusable?.focus()
 				}
 			} else {
 				// Tab
 				if (document.activeElement === lastFocusable) {
 					event.preventDefault()
-					firstFocusable.focus()
+					firstFocusable?.focus()
 				}
 			}
 		}

package/src/hooks/accessibility/use-keyboard-shortcuts.ts

@@ -57,10 +57,10 @@ export function useKeyboardShortcuts({
 
 	useEffect(() => {
 		const element = target || document
-		element.addEventListener("keydown", handleKeyDown)
+		element.addEventListener("keydown", handleKeyDown as EventListener)
 
 		return () => {
-			element.removeEventListener("keydown", handleKeyDown)
+			element.removeEventListener("keydown", handleKeyDown as EventListener)
 		}
 	}, [handleKeyDown, target])
 

package/src/hooks/accessibility/use-screen-reader.ts

@@ -12,7 +12,7 @@ export function useScreenReader({
 	debounceMs = 100
 }: UseScreenReaderOptions = {}) {
 	const liveRegionRef = useRef<HTMLDivElement | null>(null)
-	const timeoutRef = useRef<NodeJS.Timeout>()
+	const timeoutRef = useRef<NodeJS.Timeout | undefined>(undefined)
 
 	// Create or get the live region for announcements
 	const getLiveRegion = useCallback((priority: AnnouncementPriority) => {