@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

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

@@ -0,0 +1,38 @@
+export interface KeyboardShortcut {
+    key: string;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    action: () => void;
+    description: string;
+    preventDefault?: boolean;
+}
+export interface UseKeyboardShortcutsOptions {
+    shortcuts: KeyboardShortcut[];
+    enabled?: boolean;
+    target?: HTMLElement | null;
+}
+export declare function useKeyboardShortcuts({ shortcuts, enabled, target }: UseKeyboardShortcutsOptions): {
+    shortcuts: {
+        key: string;
+        description: string;
+        modifiers: {
+            ctrl: boolean | undefined;
+            alt: boolean | undefined;
+            shift: boolean | undefined;
+        };
+    }[];
+};
+export declare const createMediaKeyboardShortcuts: (controls: {
+    play: () => void;
+    pause: () => void;
+    togglePlayPause: () => void;
+    seekForward: (seconds?: number) => void;
+    seekBackward: (seconds?: number) => void;
+    volumeUp: () => void;
+    volumeDown: () => void;
+    toggleMute: () => void;
+    toggleFullscreen: () => void;
+    showHelp?: () => void;
+}) => KeyboardShortcut[];
+//# sourceMappingURL=use-keyboard-shortcuts.d.ts.map

package/dist/src/hooks/accessibility/use-keyboard-shortcuts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-keyboard-shortcuts.d.ts","sourceRoot":"","sources":["use-keyboard-shortcuts.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAED,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,gBAAgB,EAAE,CAAA;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,CAAA;CAC5B;AAED,wBAAgB,oBAAoB,CAAC,EACnC,SAAS,EACT,OAAc,EACd,MAAM,EACP,EAAE,2BAA2B;;;;;;;;;;EAmD7B;AAGD,eAAO,MAAM,4BAA4B,GAAI,UAAU;IACrD,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,eAAe,EAAE,MAAM,IAAI,CAAA;IAC3B,WAAW,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IACvC,YAAY,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IACxC,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,gBAAgB,EAAE,MAAM,IAAI,CAAA;IAC5B,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;CACtB,KAAG,gBAAgB,EAwDnB,CAAA"}

package/dist/src/hooks/accessibility/use-keyboard-shortcuts.js

@@ -0,0 +1,101 @@
+import { useEffect, useCallback, useRef } from 'react';
+export function useKeyboardShortcuts({ shortcuts, enabled = true, target }) {
+    const shortcutsRef = useRef(shortcuts);
+    shortcutsRef.current = shortcuts;
+    const handleKeyDown = useCallback((event) => {
+        if (!enabled)
+            return;
+        // Don't trigger shortcuts when user is typing in inputs
+        if (event.target instanceof HTMLInputElement ||
+            event.target instanceof HTMLTextAreaElement ||
+            event.target?.contentEditable === 'true') {
+            return;
+        }
+        const shortcut = shortcutsRef.current.find(s => s.key.toLowerCase() === event.key.toLowerCase() &&
+            !!s.ctrlKey === event.ctrlKey &&
+            !!s.altKey === event.altKey &&
+            !!s.shiftKey === event.shiftKey);
+        if (shortcut) {
+            if (shortcut.preventDefault !== false) {
+                event.preventDefault();
+            }
+            shortcut.action();
+        }
+    }, [enabled]);
+    useEffect(() => {
+        const element = target || document;
+        element.addEventListener('keydown', handleKeyDown);
+        return () => {
+            element.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [handleKeyDown, target]);
+    return {
+        shortcuts: shortcuts.map(s => ({
+            key: s.key,
+            description: s.description,
+            modifiers: {
+                ctrl: s.ctrlKey,
+                alt: s.altKey,
+                shift: s.shiftKey
+            }
+        }))
+    };
+}
+// Pre-defined media player shortcuts
+export const createMediaKeyboardShortcuts = (controls) => [
+    {
+        key: ' ',
+        action: controls.togglePlayPause,
+        description: 'Play/Pause'
+    },
+    {
+        key: 'k',
+        action: controls.togglePlayPause,
+        description: 'Play/Pause (K)'
+    },
+    {
+        key: 'ArrowLeft',
+        action: () => controls.seekBackward(10),
+        description: 'Seek backward 10 seconds'
+    },
+    {
+        key: 'ArrowRight',
+        action: () => controls.seekForward(10),
+        description: 'Seek forward 10 seconds'
+    },
+    {
+        key: 'j',
+        action: () => controls.seekBackward(10),
+        description: 'Seek backward 10 seconds (J)'
+    },
+    {
+        key: 'l',
+        action: () => controls.seekForward(10),
+        description: 'Seek forward 10 seconds (L)'
+    },
+    {
+        key: 'ArrowUp',
+        action: controls.volumeUp,
+        description: 'Volume up'
+    },
+    {
+        key: 'ArrowDown',
+        action: controls.volumeDown,
+        description: 'Volume down'
+    },
+    {
+        key: 'm',
+        action: controls.toggleMute,
+        description: 'Toggle mute'
+    },
+    {
+        key: 'f',
+        action: controls.toggleFullscreen,
+        description: 'Toggle fullscreen'
+    },
+    ...(controls.showHelp ? [{
+            key: '?',
+            action: controls.showHelp,
+            description: 'Show keyboard shortcuts help'
+        }] : [])
+];

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

@@ -0,0 +1,144 @@
+import { useEffect, useCallback, useRef } from 'react'
+
+export interface KeyboardShortcut {
+  key: string
+  ctrlKey?: boolean
+  altKey?: boolean
+  shiftKey?: boolean
+  action: () => void
+  description: string
+  preventDefault?: boolean
+}
+
+export interface UseKeyboardShortcutsOptions {
+  shortcuts: KeyboardShortcut[]
+  enabled?: boolean
+  target?: HTMLElement | null
+}
+
+export function useKeyboardShortcuts({
+  shortcuts,
+  enabled = true,
+  target
+}: UseKeyboardShortcutsOptions) {
+  const shortcutsRef = useRef(shortcuts)
+  shortcutsRef.current = shortcuts
+
+  const handleKeyDown = useCallback((event: KeyboardEvent) => {
+    if (!enabled) return
+
+    // Don't trigger shortcuts when user is typing in inputs
+    if (
+      event.target instanceof HTMLInputElement ||
+      event.target instanceof HTMLTextAreaElement ||
+      (event.target as HTMLElement)?.contentEditable === 'true'
+    ) {
+      return
+    }
+
+    const shortcut = shortcutsRef.current.find(s => 
+      s.key.toLowerCase() === event.key.toLowerCase() &&
+      !!s.ctrlKey === event.ctrlKey &&
+      !!s.altKey === event.altKey &&
+      !!s.shiftKey === event.shiftKey
+    )
+
+    if (shortcut) {
+      if (shortcut.preventDefault !== false) {
+        event.preventDefault()
+      }
+      shortcut.action()
+    }
+  }, [enabled])
+
+  useEffect(() => {
+    const element = target || document
+    element.addEventListener('keydown', handleKeyDown)
+    
+    return () => {
+      element.removeEventListener('keydown', handleKeyDown)
+    }
+  }, [handleKeyDown, target])
+
+  return {
+    shortcuts: shortcuts.map(s => ({
+      key: s.key,
+      description: s.description,
+      modifiers: {
+        ctrl: s.ctrlKey,
+        alt: s.altKey,
+        shift: s.shiftKey
+      }
+    }))
+  }
+}
+
+// Pre-defined media player shortcuts
+export const createMediaKeyboardShortcuts = (controls: {
+  play: () => void
+  pause: () => void
+  togglePlayPause: () => void
+  seekForward: (seconds?: number) => void
+  seekBackward: (seconds?: number) => void
+  volumeUp: () => void
+  volumeDown: () => void
+  toggleMute: () => void
+  toggleFullscreen: () => void
+  showHelp?: () => void
+}): KeyboardShortcut[] => [
+  {
+    key: ' ',
+    action: controls.togglePlayPause,
+    description: 'Play/Pause'
+  },
+  {
+    key: 'k',
+    action: controls.togglePlayPause,
+    description: 'Play/Pause (K)'
+  },
+  {
+    key: 'ArrowLeft',
+    action: () => controls.seekBackward(10),
+    description: 'Seek backward 10 seconds'
+  },
+  {
+    key: 'ArrowRight',
+    action: () => controls.seekForward(10),
+    description: 'Seek forward 10 seconds'
+  },
+  {
+    key: 'j',
+    action: () => controls.seekBackward(10),
+    description: 'Seek backward 10 seconds (J)'
+  },
+  {
+    key: 'l',
+    action: () => controls.seekForward(10),
+    description: 'Seek forward 10 seconds (L)'
+  },
+  {
+    key: 'ArrowUp',
+    action: controls.volumeUp,
+    description: 'Volume up'
+  },
+  {
+    key: 'ArrowDown',
+    action: controls.volumeDown,
+    description: 'Volume down'
+  },
+  {
+    key: 'm',
+    action: controls.toggleMute,
+    description: 'Toggle mute'
+  },
+  {
+    key: 'f',
+    action: controls.toggleFullscreen,
+    description: 'Toggle fullscreen'
+  },
+  ...(controls.showHelp ? [{
+    key: '?',
+    action: controls.showHelp,
+    description: 'Show keyboard shortcuts help'
+  }] : [])
+]

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

@@ -0,0 +1,22 @@
+export type AnnouncementPriority = 'assertive' | 'polite' | 'off';
+export interface UseScreenReaderOptions {
+    defaultPriority?: AnnouncementPriority;
+    debounceMs?: number;
+}
+export declare function useScreenReader({ defaultPriority, debounceMs }?: UseScreenReaderOptions): {
+    announce: (message: string, priority?: AnnouncementPriority) => void;
+};
+export declare function useMediaScreenReader(): {
+    announce: (message: string, priority?: AnnouncementPriority) => void;
+    announcePlaybackState: (isPlaying: boolean) => void;
+    announceVolume: (volume: number, isMuted: boolean) => void;
+    announceTime: (currentTime: number, duration: number) => void;
+    announceFullscreen: (isFullscreen: boolean) => void;
+    announceSubtitles: (enabled: boolean, language?: string) => void;
+    announcePlaybackSpeed: (speed: number) => void;
+    announceQuality: (quality: string) => void;
+    announceLoading: (isLoading: boolean) => void;
+    announceError: (error: string) => void;
+    announceBuffering: (isBuffering: boolean) => void;
+};
+//# sourceMappingURL=use-screen-reader.d.ts.map

package/dist/src/hooks/accessibility/use-screen-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-screen-reader.d.ts","sourceRoot":"","sources":["use-screen-reader.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,oBAAoB,GAAG,WAAW,GAAG,QAAQ,GAAG,KAAK,CAAA;AAEjE,MAAM,WAAW,sBAAsB;IACrC,eAAe,CAAC,EAAE,oBAAoB,CAAA;IACtC,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,wBAAgB,eAAe,CAAC,EAC9B,eAA0B,EAC1B,UAAgB,EACjB,GAAE,sBAA2B;wBAoCjB,MAAM,aACL,oBAAoB;EAqCjC;AAGD,wBAAgB,oBAAoB;wBAzCvB,MAAM,aACL,oBAAoB;uCA4CsB,OAAO;6BAKjB,MAAM,WAAW,OAAO;gCAUrB,MAAM,YAAY,MAAM;uCAkBjB,OAAO;iCAKb,OAAO,aAAa,MAAM;mCASxB,MAAM;+BASV,MAAM;iCAKJ,OAAO;2BAKb,MAAM;qCAKI,OAAO;EAiB5D"}

package/dist/src/hooks/accessibility/use-screen-reader.js

@@ -0,0 +1,148 @@
+import { useRef, useCallback, useEffect } from 'react';
+export function useScreenReader({ defaultPriority = 'polite', debounceMs = 100 } = {}) {
+    const liveRegionRef = useRef(null);
+    const timeoutRef = useRef();
+    // Create or get the live region for announcements
+    const getLiveRegion = useCallback((priority) => {
+        if (!liveRegionRef.current) {
+            const liveRegion = document.createElement('div');
+            liveRegion.setAttribute('aria-live', priority);
+            liveRegion.setAttribute('aria-atomic', 'true');
+            liveRegion.setAttribute('class', 'sr-only');
+            liveRegion.style.cssText = `
+        position: absolute !important;
+        width: 1px !important;
+        height: 1px !important;
+        padding: 0 !important;
+        margin: -1px !important;
+        overflow: hidden !important;
+        clip: rect(0, 0, 0, 0) !important;
+        white-space: nowrap !important;
+        border: 0 !important;
+      `;
+            document.body.appendChild(liveRegion);
+            liveRegionRef.current = liveRegion;
+        }
+        // Update priority if needed
+        if (liveRegionRef.current.getAttribute('aria-live') !== priority) {
+            liveRegionRef.current.setAttribute('aria-live', priority);
+        }
+        return liveRegionRef.current;
+    }, []);
+    // Announce a message to screen readers
+    const announce = useCallback((message, priority = defaultPriority) => {
+        if (!message.trim() || priority === 'off')
+            return;
+        // Clear existing timeout
+        if (timeoutRef.current) {
+            clearTimeout(timeoutRef.current);
+        }
+        // Debounce announcements
+        timeoutRef.current = setTimeout(() => {
+            const liveRegion = getLiveRegion(priority);
+            // Clear and then set the message to ensure it's announced
+            liveRegion.textContent = '';
+            // Use requestAnimationFrame to ensure the clear happens first
+            requestAnimationFrame(() => {
+                liveRegion.textContent = message;
+            });
+        }, debounceMs);
+    }, [defaultPriority, debounceMs, getLiveRegion]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+            }
+            if (liveRegionRef.current) {
+                document.body.removeChild(liveRegionRef.current);
+                liveRegionRef.current = null;
+            }
+        };
+    }, []);
+    return { announce };
+}
+// Hook specifically for media player screen reader announcements
+export function useMediaScreenReader() {
+    const { announce } = useScreenReader({ defaultPriority: 'polite' });
+    // Announce playback state changes
+    const announcePlaybackState = useCallback((isPlaying) => {
+        announce(isPlaying ? 'Playing' : 'Paused', 'assertive');
+    }, [announce]);
+    // Announce volume changes
+    const announceVolume = useCallback((volume, isMuted) => {
+        if (isMuted) {
+            announce('Muted', 'assertive');
+        }
+        else {
+            const volumePercent = Math.round(volume * 100);
+            announce(`Volume ${volumePercent}%`, 'polite');
+        }
+    }, [announce]);
+    // Announce time position changes
+    const announceTime = useCallback((currentTime, duration) => {
+        const formatTime = (seconds) => {
+            const hours = Math.floor(seconds / 3600);
+            const minutes = Math.floor((seconds % 3600) / 60);
+            const secs = Math.floor(seconds % 60);
+            if (hours > 0) {
+                return `${hours}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+            }
+            return `${minutes}:${secs.toString().padStart(2, '0')}`;
+        };
+        const current = formatTime(currentTime);
+        const total = formatTime(duration);
+        announce(`${current} of ${total}`, 'polite');
+    }, [announce]);
+    // Announce fullscreen state changes
+    const announceFullscreen = useCallback((isFullscreen) => {
+        announce(isFullscreen ? 'Entered fullscreen' : 'Exited fullscreen', 'assertive');
+    }, [announce]);
+    // Announce subtitle state changes
+    const announceSubtitles = useCallback((enabled, language) => {
+        if (enabled) {
+            announce(language ? `Subtitles enabled in ${language}` : 'Subtitles enabled', 'assertive');
+        }
+        else {
+            announce('Subtitles disabled', 'assertive');
+        }
+    }, [announce]);
+    // Announce playback speed changes
+    const announcePlaybackSpeed = useCallback((speed) => {
+        if (speed === 1) {
+            announce('Normal playback speed', 'assertive');
+        }
+        else {
+            announce(`Playback speed ${speed}x`, 'assertive');
+        }
+    }, [announce]);
+    // Announce quality changes
+    const announceQuality = useCallback((quality) => {
+        announce(`Quality changed to ${quality}`, 'polite');
+    }, [announce]);
+    // Announce loading state
+    const announceLoading = useCallback((isLoading) => {
+        announce(isLoading ? 'Loading...' : 'Loading complete', 'polite');
+    }, [announce]);
+    // Announce errors
+    const announceError = useCallback((error) => {
+        announce(`Error: ${error}`, 'assertive');
+    }, [announce]);
+    // Announce buffering state
+    const announceBuffering = useCallback((isBuffering) => {
+        announce(isBuffering ? 'Buffering...' : 'Buffering complete', 'polite');
+    }, [announce]);
+    return {
+        announce,
+        announcePlaybackState,
+        announceVolume,
+        announceTime,
+        announceFullscreen,
+        announceSubtitles,
+        announcePlaybackSpeed,
+        announceQuality,
+        announceLoading,
+        announceError,
+        announceBuffering
+    };
+}

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

@@ -0,0 +1,182 @@
+import { useRef, useCallback, useEffect } from 'react'
+
+export type AnnouncementPriority = 'assertive' | 'polite' | 'off'
+
+export interface UseScreenReaderOptions {
+  defaultPriority?: AnnouncementPriority
+  debounceMs?: number
+}
+
+export function useScreenReader({
+  defaultPriority = 'polite',
+  debounceMs = 100
+}: UseScreenReaderOptions = {}) {
+  const liveRegionRef = useRef<HTMLDivElement | null>(null)
+  const timeoutRef = useRef<NodeJS.Timeout>()
+
+  // Create or get the live region for announcements
+  const getLiveRegion = useCallback((priority: AnnouncementPriority) => {
+    if (!liveRegionRef.current) {
+      const liveRegion = document.createElement('div')
+      liveRegion.setAttribute('aria-live', priority)
+      liveRegion.setAttribute('aria-atomic', 'true')
+      liveRegion.setAttribute('class', 'sr-only')
+      liveRegion.style.cssText = `
+        position: absolute !important;
+        width: 1px !important;
+        height: 1px !important;
+        padding: 0 !important;
+        margin: -1px !important;
+        overflow: hidden !important;
+        clip: rect(0, 0, 0, 0) !important;
+        white-space: nowrap !important;
+        border: 0 !important;
+      `
+      document.body.appendChild(liveRegion)
+      liveRegionRef.current = liveRegion
+    }
+
+    // Update priority if needed
+    if (liveRegionRef.current.getAttribute('aria-live') !== priority) {
+      liveRegionRef.current.setAttribute('aria-live', priority)
+    }
+
+    return liveRegionRef.current
+  }, [])
+
+  // Announce a message to screen readers
+  const announce = useCallback((
+    message: string,
+    priority: AnnouncementPriority = defaultPriority
+  ) => {
+    if (!message.trim() || priority === 'off') return
+
+    // Clear existing timeout
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current)
+    }
+
+    // Debounce announcements
+    timeoutRef.current = setTimeout(() => {
+      const liveRegion = getLiveRegion(priority)
+      
+      // Clear and then set the message to ensure it's announced
+      liveRegion.textContent = ''
+      
+      // Use requestAnimationFrame to ensure the clear happens first
+      requestAnimationFrame(() => {
+        liveRegion.textContent = message
+      })
+    }, debounceMs)
+  }, [defaultPriority, debounceMs, getLiveRegion])
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current)
+      }
+      if (liveRegionRef.current) {
+        document.body.removeChild(liveRegionRef.current)
+        liveRegionRef.current = null
+      }
+    }
+  }, [])
+
+  return { announce }
+}
+
+// Hook specifically for media player screen reader announcements
+export function useMediaScreenReader() {
+  const { announce } = useScreenReader({ defaultPriority: 'polite' })
+
+  // Announce playback state changes
+  const announcePlaybackState = useCallback((isPlaying: boolean) => {
+    announce(isPlaying ? 'Playing' : 'Paused', 'assertive')
+  }, [announce])
+
+  // Announce volume changes
+  const announceVolume = useCallback((volume: number, isMuted: boolean) => {
+    if (isMuted) {
+      announce('Muted', 'assertive')
+    } else {
+      const volumePercent = Math.round(volume * 100)
+      announce(`Volume ${volumePercent}%`, 'polite')
+    }
+  }, [announce])
+
+  // Announce time position changes
+  const announceTime = useCallback((currentTime: number, duration: number) => {
+    const formatTime = (seconds: number) => {
+      const hours = Math.floor(seconds / 3600)
+      const minutes = Math.floor((seconds % 3600) / 60)
+      const secs = Math.floor(seconds % 60)
+      
+      if (hours > 0) {
+        return `${hours}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`
+      }
+      return `${minutes}:${secs.toString().padStart(2, '0')}`
+    }
+
+    const current = formatTime(currentTime)
+    const total = formatTime(duration)
+    announce(`${current} of ${total}`, 'polite')
+  }, [announce])
+
+  // Announce fullscreen state changes
+  const announceFullscreen = useCallback((isFullscreen: boolean) => {
+    announce(isFullscreen ? 'Entered fullscreen' : 'Exited fullscreen', 'assertive')
+  }, [announce])
+
+  // Announce subtitle state changes
+  const announceSubtitles = useCallback((enabled: boolean, language?: string) => {
+    if (enabled) {
+      announce(language ? `Subtitles enabled in ${language}` : 'Subtitles enabled', 'assertive')
+    } else {
+      announce('Subtitles disabled', 'assertive')
+    }
+  }, [announce])
+
+  // Announce playback speed changes
+  const announcePlaybackSpeed = useCallback((speed: number) => {
+    if (speed === 1) {
+      announce('Normal playback speed', 'assertive')
+    } else {
+      announce(`Playback speed ${speed}x`, 'assertive')
+    }
+  }, [announce])
+
+  // Announce quality changes
+  const announceQuality = useCallback((quality: string) => {
+    announce(`Quality changed to ${quality}`, 'polite')
+  }, [announce])
+
+  // Announce loading state
+  const announceLoading = useCallback((isLoading: boolean) => {
+    announce(isLoading ? 'Loading...' : 'Loading complete', 'polite')
+  }, [announce])
+
+  // Announce errors
+  const announceError = useCallback((error: string) => {
+    announce(`Error: ${error}`, 'assertive')
+  }, [announce])
+
+  // Announce buffering state
+  const announceBuffering = useCallback((isBuffering: boolean) => {
+    announce(isBuffering ? 'Buffering...' : 'Buffering complete', 'polite')
+  }, [announce])
+
+  return {
+    announce,
+    announcePlaybackState,
+    announceVolume,
+    announceTime,
+    announceFullscreen,
+    announceSubtitles,
+    announcePlaybackSpeed,
+    announceQuality,
+    announceLoading,
+    announceError,
+    announceBuffering
+  }
+}

package/dist/src/hooks/core/index.d.ts

@@ -0,0 +1,18 @@
+export { useKeyboardControls } from "../use-keyboard-controls";
+export { useMediaPlayer } from "../use-media-player";
+export { useAdaptiveMediaState, useEnhancedMediaState, useMediaState } from "../use-media-state";
+export { useMediaActions, useMediaActionState } from "../use-media-actions";
+export type { MediaActionPayloads } from "../use-media-actions";
+export { useMediaOptimistic, useMediaStateComparison, useOptimisticUpdates } from "../use-media-optimistic";
+export { useMediaGestures, useTouchGestures } from "../use-touch-gestures";
+export type { GestureConfig, GestureEvent, GestureType } from "../use-touch-gestures";
+export { useVideoPlayer } from "../useVideoPlayer";
+export { useSubtitles } from "../useSubtitles";
+export { useEnhancedSubtitles } from "../useEnhancedSubtitles";
+export type { SubtitleTrack, UseEnhancedSubtitlesOptions } from "../useEnhancedSubtitles";
+export { useMediaControls } from "../useMediaControls";
+export { useScreenshot } from "../useScreenshot";
+export type { VideoState, VideoControls } from "../useVideoPlayer";
+export { useMediaMetadata } from "../use-media-metadata";
+export { useOptimisticControls } from "../use-optimistic-controls";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/hooks/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,aAAa,EACd,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,eAAe,EACf,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,aAAa,EACb,YAAY,EACZ,WAAW,EACZ,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC/D,YAAY,EAAE,aAAa,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAC1F,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/src/hooks/core/index.js

@@ -0,0 +1,19 @@
+// Core Media Player Hooks
+export { useKeyboardControls } from "../use-keyboard-controls";
+export { useMediaPlayer } from "../use-media-player";
+// Media State Hooks
+export { useAdaptiveMediaState, useEnhancedMediaState, useMediaState } from "../use-media-state";
+// React 19 Advanced Hooks
+export { useMediaActions, useMediaActionState } from "../use-media-actions";
+export { useMediaOptimistic, useMediaStateComparison, useOptimisticUpdates } from "../use-media-optimistic";
+// Mobile-First Touch Gestures
+export { useMediaGestures, useTouchGestures } from "../use-touch-gestures";
+// Refactored Hooks (React 19 optimized)
+export { useVideoPlayer } from "../useVideoPlayer";
+export { useSubtitles } from "../useSubtitles";
+export { useEnhancedSubtitles } from "../useEnhancedSubtitles";
+export { useMediaControls } from "../useMediaControls";
+export { useScreenshot } from "../useScreenshot";
+// Specialized hooks
+export { useMediaMetadata } from "../use-media-metadata";
+export { useOptimisticControls } from "../use-optimistic-controls";