react-media-manager 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1091 @@
+import { createContext, useContext, useState, useRef, useEffect, useMemo } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/context/MediaProvider.tsx
+var defaultConfig = {
+  autoRefreshOnDeviceChange: true,
+  cameraConstraints: {},
+  microphoneConstraints: {},
+  monitorMicrophoneVolume: true
+};
+var MediaConfigContext = createContext(defaultConfig);
+function MediaProvider({ children, value }) {
+  return /* @__PURE__ */ jsx(MediaConfigContext.Provider, { value: { ...defaultConfig, ...value }, children });
+}
+function useMediaProviderConfig() {
+  return useContext(MediaConfigContext);
+}
+
+// src/constants/index.ts
+var DEFAULT_PERMISSION_STATE = "unknown";
+var DEFAULT_STATUS = "idle";
+
+// src/utils/browser.ts
+function canUseDOM() {
+  return typeof window !== "undefined" && typeof navigator !== "undefined";
+}
+function getMediaDevices() {
+  if (!canUseDOM() || !navigator.mediaDevices) {
+    return null;
+  }
+  return navigator.mediaDevices;
+}
+function isMediaDevicesSupported() {
+  const mediaDevices = getMediaDevices();
+  return Boolean(mediaDevices && mediaDevices.enumerateDevices && mediaDevices.getUserMedia);
+}
+function isPermissionsSupported() {
+  return canUseDOM() && typeof navigator.permissions?.query === "function";
+}
+function isMediaRecorderSupported() {
+  return canUseDOM() && typeof window.MediaRecorder !== "undefined";
+}
+function isSetSinkIdSupported(target) {
+  return Boolean(target && typeof target.setSinkId === "function");
+}
+function getAudioContext() {
+  if (!canUseDOM()) {
+    return void 0;
+  }
+  return window.AudioContext || window.webkitAudioContext;
+}
+
+// src/utils/errors.ts
+var ERROR_MESSAGES = {
+  abort: "The media operation was aborted before it could complete.",
+  "browser-not-supported": "This browser does not support the required media APIs.",
+  "device-in-use": "The requested media device is already in use by another application.",
+  "device-not-found": "The requested media device could not be found.",
+  "invalid-state": "The media device is not in a valid state for this operation.",
+  "not-allowed": "Access to the requested media device was blocked.",
+  "not-readable": "The requested media device could not be read.",
+  overconstrained: "No device matched the requested media constraints.",
+  "permission-denied": "Permission to access the requested media device was denied.",
+  "permission-query-failed": "The browser could not report the current permission state.",
+  "recorder-not-supported": "This browser does not support media recording.",
+  "speaker-not-supported": "This browser does not support switching audio output devices.",
+  unknown: "An unexpected media error occurred."
+};
+var DOM_ERROR_CODE_MAP = {
+  AbortError: "abort",
+  InvalidStateError: "invalid-state",
+  NotAllowedError: "permission-denied",
+  NotFoundError: "device-not-found",
+  NotReadableError: "not-readable",
+  OverconstrainedError: "overconstrained",
+  SecurityError: "not-allowed",
+  TrackStartError: "device-in-use"
+};
+function createMediaError(code, cause, name) {
+  return {
+    code,
+    cause,
+    message: ERROR_MESSAGES[code],
+    name
+  };
+}
+function normalizeMediaError(error, fallbackCode = "unknown") {
+  if (typeof error === "object" && error && "code" in error && typeof error.code === "string" && "message" in error) {
+    return error;
+  }
+  if (error instanceof DOMException) {
+    const code = DOM_ERROR_CODE_MAP[error.name] ?? fallbackCode;
+    return createMediaError(code, error, error.name);
+  }
+  if (error instanceof Error) {
+    const code = DOM_ERROR_CODE_MAP[error.name] ?? fallbackCode;
+    return {
+      code,
+      cause: error,
+      message: error.message || ERROR_MESSAGES[code],
+      name: error.name
+    };
+  }
+  return createMediaError(fallbackCode, error);
+}
+
+// src/utils/device.ts
+function mapKind(kind) {
+  if (kind === "videoinput") {
+    return "camera";
+  }
+  if (kind === "audioinput") {
+    return "microphone";
+  }
+  if (kind === "audiooutput") {
+    return "speaker";
+  }
+  return null;
+}
+function inferFacingMode(label) {
+  const normalized = label.toLowerCase();
+  if (normalized.includes("front") || normalized.includes("user") || normalized.includes("facetime")) {
+    return "user";
+  }
+  if (normalized.includes("back") || normalized.includes("rear") || normalized.includes("environment")) {
+    return "environment";
+  }
+  return void 0;
+}
+function normalizeDevice(device) {
+  const kind = mapKind(device.kind);
+  if (!kind) {
+    return null;
+  }
+  const base = {
+    deviceId: device.deviceId,
+    groupId: device.groupId,
+    kind,
+    label: device.label,
+    raw: device
+  };
+  if (kind === "camera") {
+    return {
+      ...base,
+      facingMode: inferFacingMode(device.label)
+    };
+  }
+  return base;
+}
+function emptyDevices() {
+  return {
+    cameras: [],
+    microphones: [],
+    speakers: []
+  };
+}
+async function enumerateDevices() {
+  if (!isMediaDevicesSupported()) {
+    throw createMediaError("browser-not-supported");
+  }
+  const rawDevices = await getMediaDevices().enumerateDevices();
+  const grouped = emptyDevices();
+  rawDevices.forEach((rawDevice) => {
+    const device = normalizeDevice(rawDevice);
+    if (!device) {
+      return;
+    }
+    if (device.kind === "camera") {
+      grouped.cameras.push(device);
+      return;
+    }
+    if (device.kind === "microphone") {
+      grouped.microphones.push(device);
+      return;
+    }
+    grouped.speakers.push(device);
+  });
+  return grouped;
+}
+function flattenDevices(collection) {
+  return [...collection.cameras, ...collection.microphones, ...collection.speakers];
+}
+function findDeviceById(devices, deviceId) {
+  if (!deviceId) {
+    return devices[0] ?? null;
+  }
+  return devices.find((device) => device.deviceId === deviceId) ?? null;
+}
+
+// src/utils/permissions.ts
+async function queryPermissionState(name) {
+  if (!isPermissionsSupported()) {
+    return "unsupported";
+  }
+  try {
+    const status = await navigator.permissions.query({ name });
+    return status.state;
+  } catch {
+    return "unsupported";
+  }
+}
+async function watchPermissionState(name, onChange) {
+  if (!isPermissionsSupported()) {
+    return () => void 0;
+  }
+  try {
+    const status = await navigator.permissions.query({ name });
+    const listener = () => onChange(status.state);
+    status.addEventListener("change", listener);
+    return () => status.removeEventListener("change", listener);
+  } catch {
+    return () => void 0;
+  }
+}
+async function requestMediaPermission(constraints) {
+  if (!isMediaDevicesSupported()) {
+    throw new Error("MediaDevices API is unavailable.");
+  }
+  return navigator.mediaDevices.getUserMedia(constraints);
+}
+
+// src/utils/stream.ts
+function stopStream(stream) {
+  stream?.getTracks().forEach((track) => track.stop());
+}
+function setStreamEnabled(stream, enabled) {
+  stream?.getTracks().forEach((track) => {
+    track.enabled = enabled;
+  });
+}
+function buildVideoConstraints(deviceId, constraints = {}) {
+  return {
+    ...constraints,
+    ...deviceId ? { deviceId: { exact: deviceId } } : {}
+  };
+}
+function buildAudioConstraints(deviceId, constraints = {}) {
+  return {
+    ...constraints,
+    ...deviceId ? { deviceId: { exact: deviceId } } : {}
+  };
+}
+function getTrackDeviceId(stream, kind) {
+  const track = kind === "audio" ? stream?.getAudioTracks()[0] : stream?.getVideoTracks()[0];
+  const settings = track?.getSettings();
+  return settings?.deviceId;
+}
+
+// src/hooks/useCamera.ts
+function useCamera(options = {}) {
+  const config = useMediaProviderConfig();
+  const supported = isMediaDevicesSupported();
+  const [cameras, setCameras] = useState([]);
+  const [currentDeviceId, setCurrentDeviceId] = useState(options.deviceId ?? null);
+  const [stream, setStream] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [permission, setPermission] = useState(DEFAULT_PERMISSION_STATE);
+  const [status, setStatus] = useState(DEFAULT_STATUS);
+  const [isPaused, setIsPaused] = useState(false);
+  const destroyedRef = useRef(false);
+  const currentDeviceIdRef = useRef(options.deviceId ?? null);
+  const streamRef = useRef(null);
+  const mergedConstraints = {
+    ...config.cameraConstraints,
+    ...options.constraints
+  };
+  const currentCamera = findDeviceById(cameras, currentDeviceId);
+  async function refreshDevices() {
+    if (!supported || destroyedRef.current) {
+      return;
+    }
+    try {
+      const devices = await enumerateDevices();
+      if (destroyedRef.current) {
+        return;
+      }
+      setCameras(devices.cameras);
+      const matchingDevice = findDeviceById(devices.cameras, currentDeviceIdRef.current);
+      if (!matchingDevice && currentDeviceIdRef.current) {
+        stop();
+        setCurrentDeviceId(devices.cameras[0]?.deviceId ?? null);
+        currentDeviceIdRef.current = devices.cameras[0]?.deviceId ?? null;
+        setError(normalizeMediaError(new DOMException("Camera not found.", "NotFoundError"), "device-not-found"));
+        return;
+      }
+      if (!currentDeviceIdRef.current && devices.cameras[0]) {
+        setCurrentDeviceId(devices.cameras[0].deviceId);
+        currentDeviceIdRef.current = devices.cameras[0].deviceId;
+      }
+    } catch (nextError) {
+      setError(normalizeMediaError(nextError, "browser-not-supported"));
+      setCameras(emptyDevices().cameras);
+    }
+  }
+  async function updatePermission() {
+    if (!supported || destroyedRef.current) {
+      return;
+    }
+    const nextPermission = await queryPermissionState("camera");
+    if (!destroyedRef.current) {
+      setPermission(nextPermission);
+    }
+  }
+  function stop() {
+    stopStream(streamRef.current);
+    streamRef.current = null;
+    setStream(null);
+    setIsPaused(false);
+    setStatus("stopped");
+  }
+  async function startStream(deviceIdOverride, override = {}) {
+    if (!supported) {
+      const nextError = normalizeMediaError(new Error("MediaDevices API is unavailable."), "browser-not-supported");
+      setError(nextError);
+      setStatus("error");
+      return null;
+    }
+    setLoading(true);
+    setError(null);
+    setStatus("loading");
+    try {
+      const deviceId = deviceIdOverride ?? currentDeviceIdRef.current ?? options.deviceId;
+      const constraints = buildVideoConstraints(deviceId ?? void 0, {
+        ...mergedConstraints,
+        ...override,
+        ...options.facingMode ? { facingMode: options.facingMode } : {}
+      });
+      const nextStream = await navigator.mediaDevices.getUserMedia({ video: constraints, audio: false });
+      const detectedDeviceId = getTrackDeviceId(nextStream, "video") ?? deviceId ?? null;
+      stopStream(streamRef.current);
+      streamRef.current = nextStream;
+      setStream(nextStream);
+      setCurrentDeviceId(detectedDeviceId);
+      currentDeviceIdRef.current = detectedDeviceId;
+      setPermission("granted");
+      setIsPaused(false);
+      setStatus("active");
+      return nextStream;
+    } catch (nextError) {
+      const normalized = normalizeMediaError(nextError, "unknown");
+      setError(normalized);
+      setPermission(normalized.code === "permission-denied" ? "denied" : permission);
+      setStatus("error");
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }
+  async function start(override = {}) {
+    return startStream(void 0, override);
+  }
+  function pause() {
+    setStreamEnabled(streamRef.current, false);
+    setIsPaused(true);
+    setStatus("paused");
+  }
+  function resume() {
+    setStreamEnabled(streamRef.current, true);
+    setIsPaused(false);
+    setStatus(streamRef.current ? "active" : "idle");
+  }
+  async function switchCamera(deviceId, override = {}) {
+    setCurrentDeviceId(deviceId);
+    currentDeviceIdRef.current = deviceId;
+    if (!streamRef.current) {
+      return null;
+    }
+    return startStream(deviceId, override);
+  }
+  async function refresh() {
+    await Promise.all([refreshDevices(), updatePermission()]);
+  }
+  function destroy() {
+    destroyedRef.current = true;
+    stop();
+    setCameras([]);
+    setError(null);
+    setPermission(DEFAULT_PERMISSION_STATE);
+    setStatus(DEFAULT_STATUS);
+    currentDeviceIdRef.current = null;
+  }
+  useEffect(() => {
+    destroyedRef.current = false;
+    void refresh();
+    if (config.autoRefreshOnDeviceChange && supported) {
+      const handleDeviceChange = () => {
+        void refreshDevices();
+      };
+      navigator.mediaDevices.addEventListener("devicechange", handleDeviceChange);
+      return () => {
+        destroyedRef.current = true;
+        stopStream(streamRef.current);
+        navigator.mediaDevices.removeEventListener("devicechange", handleDeviceChange);
+      };
+    }
+    return () => {
+      destroyedRef.current = true;
+      stopStream(streamRef.current);
+    };
+  }, [config.autoRefreshOnDeviceChange, supported]);
+  useEffect(() => {
+    if (options.autoStart) {
+      void start();
+    }
+  }, []);
+  return {
+    cameras,
+    constraints: mergedConstraints,
+    currentCamera,
+    destroy,
+    error,
+    isActive: Boolean(stream),
+    isLoading: loading,
+    isPaused,
+    loading,
+    pause,
+    permission,
+    refresh,
+    refreshDevices,
+    resume,
+    start,
+    status,
+    stop,
+    stream,
+    supported,
+    switchCamera
+  };
+}
+function useMediaDevices(options = {}) {
+  const config = useMediaProviderConfig();
+  const shouldListen = options.listen ?? config.autoRefreshOnDeviceChange;
+  const supported = isMediaDevicesSupported();
+  const [devices, setDevices] = useState(emptyDevices);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const destroyedRef = useRef(false);
+  async function refresh() {
+    if (!supported || destroyedRef.current) {
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const nextDevices = await enumerateDevices();
+      if (!destroyedRef.current) {
+        setDevices(nextDevices);
+      }
+    } catch (nextError) {
+      if (!destroyedRef.current) {
+        setError(normalizeMediaError(nextError, "browser-not-supported"));
+        setDevices(emptyDevices());
+      }
+    } finally {
+      if (!destroyedRef.current) {
+        setLoading(false);
+      }
+    }
+  }
+  function destroy() {
+    destroyedRef.current = true;
+    setDevices(emptyDevices());
+    setError(null);
+    setLoading(false);
+  }
+  useEffect(() => {
+    destroyedRef.current = false;
+    void refresh();
+    if (!supported || !shouldListen) {
+      return () => {
+        destroyedRef.current = true;
+      };
+    }
+    const mediaDevices = navigator.mediaDevices;
+    const handleDeviceChange = () => {
+      void refresh();
+    };
+    mediaDevices.addEventListener("devicechange", handleDeviceChange);
+    return () => {
+      destroyedRef.current = true;
+      mediaDevices.removeEventListener("devicechange", handleDeviceChange);
+    };
+  }, [shouldListen, supported]);
+  return {
+    ...devices,
+    destroy,
+    devices: flattenDevices(devices),
+    error,
+    loading,
+    refresh,
+    supported
+  };
+}
+
+// src/hooks/useDeviceChange.ts
+function useDeviceChange() {
+  const deviceState = useMediaDevices({ listen: false });
+  const supported = isMediaDevicesSupported();
+  const [changeCount, setChangeCount] = useState(0);
+  const [lastChangeAt, setLastChangeAt] = useState(null);
+  useEffect(() => {
+    if (!supported) {
+      return void 0;
+    }
+    const handleDeviceChange = () => {
+      setChangeCount((current) => current + 1);
+      setLastChangeAt(Date.now());
+      void deviceState.refresh();
+    };
+    navigator.mediaDevices.addEventListener("devicechange", handleDeviceChange);
+    return () => {
+      navigator.mediaDevices.removeEventListener("devicechange", handleDeviceChange);
+    };
+  }, [deviceState, supported]);
+  return {
+    ...deviceState,
+    changeCount,
+    lastChangeAt,
+    supported
+  };
+}
+function useMediaRecorder() {
+  const supported = isMediaRecorderSupported();
+  const [status, setStatus] = useState("idle");
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [chunks, setChunks] = useState([]);
+  const [blob, setBlob] = useState(null);
+  const recorderRef = useRef(null);
+  const destroyedRef = useRef(false);
+  const url = useMemo(() => {
+    if (!blob || typeof URL === "undefined") {
+      return null;
+    }
+    return URL.createObjectURL(blob);
+  }, [blob]);
+  function reset() {
+    setChunks([]);
+    setBlob(null);
+    setError(null);
+    setStatus("idle");
+  }
+  function destroy() {
+    destroyedRef.current = true;
+    recorderRef.current?.stop();
+    recorderRef.current = null;
+    reset();
+  }
+  function refresh() {
+    return Promise.resolve();
+  }
+  function start(stream, options = {}) {
+    if (!supported || typeof window.MediaRecorder === "undefined") {
+      setError(normalizeMediaError(new Error("MediaRecorder is unavailable."), "recorder-not-supported"));
+      setStatus("error");
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    setChunks([]);
+    setBlob(null);
+    try {
+      const recorder = new window.MediaRecorder(stream, options);
+      recorder.ondataavailable = (event) => {
+        if (event.data && event.data.size > 0) {
+          setChunks((current) => [...current, event.data]);
+        }
+      };
+      recorder.onstop = () => {
+        setStatus("stopped");
+        setLoading(false);
+      };
+      recorder.onerror = (event) => {
+        setError(normalizeMediaError(event.error, "unknown"));
+        setStatus("error");
+        setLoading(false);
+      };
+      recorderRef.current = recorder;
+      recorder.start();
+      setStatus("active");
+    } catch (nextError) {
+      setError(normalizeMediaError(nextError, "unknown"));
+      setStatus("error");
+      setLoading(false);
+    }
+  }
+  function stop() {
+    recorderRef.current?.stop();
+  }
+  function pause() {
+    recorderRef.current?.pause();
+    setStatus("paused");
+  }
+  function resume() {
+    recorderRef.current?.resume();
+    setStatus("active");
+  }
+  function download(fileName = "recording.webm") {
+    const nextBlob = blob ?? (chunks.length ? new Blob(chunks, { type: chunks[0]?.type || "video/webm" }) : null);
+    if (!nextBlob || typeof document === "undefined" || typeof URL === "undefined") {
+      return null;
+    }
+    const nextUrl = URL.createObjectURL(nextBlob);
+    const anchor = document.createElement("a");
+    anchor.href = nextUrl;
+    anchor.download = fileName;
+    anchor.click();
+    return nextUrl;
+  }
+  useEffect(() => {
+    if (chunks.length) {
+      setBlob(new Blob(chunks, { type: chunks[0]?.type || "video/webm" }));
+    }
+  }, [chunks]);
+  useEffect(() => {
+    return () => {
+      if (url) {
+        URL.revokeObjectURL(url);
+      }
+    };
+  }, [url]);
+  useEffect(() => {
+    return () => {
+      destroyedRef.current = true;
+      if (url) {
+        URL.revokeObjectURL(url);
+      }
+      recorderRef.current = null;
+    };
+  }, [url]);
+  return {
+    blob,
+    chunks,
+    destroy,
+    download,
+    error,
+    isPaused: status === "paused",
+    isRecording: status === "active",
+    loading,
+    pause,
+    refresh,
+    reset,
+    resume,
+    start,
+    status,
+    stop,
+    supported,
+    url
+  };
+}
+function useMicrophone(options = {}) {
+  const config = useMediaProviderConfig();
+  const supported = isMediaDevicesSupported();
+  const [microphones, setMicrophones] = useState([]);
+  const [currentDeviceId, setCurrentDeviceId] = useState(options.deviceId ?? null);
+  const [stream, setStream] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [permission, setPermission] = useState(DEFAULT_PERMISSION_STATE);
+  const [status, setStatus] = useState(DEFAULT_STATUS);
+  const [muted, setMuted] = useState(false);
+  const [volume, setVolume] = useState(0);
+  const destroyedRef = useRef(false);
+  const currentDeviceIdRef = useRef(options.deviceId ?? null);
+  const streamRef = useRef(null);
+  const analyserContextRef = useRef(null);
+  const animationFrameRef = useRef(null);
+  const mergedConstraints = {
+    ...config.microphoneConstraints,
+    ...options.constraints
+  };
+  const currentMicrophone = findDeviceById(microphones, currentDeviceId);
+  function stopVolumeMonitor() {
+    if (animationFrameRef.current) {
+      cancelAnimationFrame(animationFrameRef.current);
+      animationFrameRef.current = null;
+    }
+    if (analyserContextRef.current) {
+      void analyserContextRef.current.close();
+      analyserContextRef.current = null;
+    }
+    setVolume(0);
+  }
+  function startVolumeMonitor(nextStream) {
+    if (!(options.monitorVolume ?? config.monitorMicrophoneVolume)) {
+      return;
+    }
+    const AudioContextCtor = getAudioContext();
+    if (!AudioContextCtor) {
+      return;
+    }
+    const audioContext = new AudioContextCtor();
+    const analyser = audioContext.createAnalyser();
+    const source = audioContext.createMediaStreamSource(nextStream);
+    const sample = new Uint8Array(analyser.fftSize);
+    analyser.smoothingTimeConstant = 0.8;
+    source.connect(analyser);
+    analyserContextRef.current = audioContext;
+    const readVolume = () => {
+      analyser.getByteTimeDomainData(sample);
+      let sum = 0;
+      sample.forEach((value) => {
+        const normalized = (value - 128) / 128;
+        sum += normalized * normalized;
+      });
+      setVolume(Number(Math.min(1, Math.sqrt(sum / sample.length)).toFixed(4)));
+      animationFrameRef.current = requestAnimationFrame(readVolume);
+    };
+    animationFrameRef.current = requestAnimationFrame(readVolume);
+  }
+  async function refreshDevices() {
+    if (!supported || destroyedRef.current) {
+      return;
+    }
+    try {
+      const devices = await enumerateDevices();
+      if (destroyedRef.current) {
+        return;
+      }
+      setMicrophones(devices.microphones);
+      const matchingDevice = findDeviceById(devices.microphones, currentDeviceIdRef.current);
+      if (!matchingDevice && currentDeviceIdRef.current) {
+        stop();
+        setCurrentDeviceId(devices.microphones[0]?.deviceId ?? null);
+        currentDeviceIdRef.current = devices.microphones[0]?.deviceId ?? null;
+        setError(normalizeMediaError(new DOMException("Microphone not found.", "NotFoundError"), "device-not-found"));
+        return;
+      }
+      if (!currentDeviceIdRef.current && devices.microphones[0]) {
+        setCurrentDeviceId(devices.microphones[0].deviceId);
+        currentDeviceIdRef.current = devices.microphones[0].deviceId;
+      }
+    } catch (nextError) {
+      setError(normalizeMediaError(nextError, "browser-not-supported"));
+      setMicrophones(emptyDevices().microphones);
+    }
+  }
+  async function updatePermission() {
+    if (!supported || destroyedRef.current) {
+      return;
+    }
+    const nextPermission = await queryPermissionState("microphone");
+    if (!destroyedRef.current) {
+      setPermission(nextPermission);
+    }
+  }
+  function stop() {
+    stopVolumeMonitor();
+    stopStream(streamRef.current);
+    streamRef.current = null;
+    setStream(null);
+    setMuted(false);
+    setStatus("stopped");
+  }
+  async function startStream(deviceIdOverride, override = {}) {
+    if (!supported) {
+      const nextError = normalizeMediaError(new Error("MediaDevices API is unavailable."), "browser-not-supported");
+      setError(nextError);
+      setStatus("error");
+      return null;
+    }
+    setLoading(true);
+    setError(null);
+    setStatus("loading");
+    try {
+      const deviceId = deviceIdOverride ?? currentDeviceIdRef.current ?? options.deviceId;
+      const constraints = buildAudioConstraints(deviceId ?? void 0, {
+        ...mergedConstraints,
+        ...override
+      });
+      const nextStream = await navigator.mediaDevices.getUserMedia({ video: false, audio: constraints });
+      const detectedDeviceId = getTrackDeviceId(nextStream, "audio") ?? deviceId ?? null;
+      stop();
+      streamRef.current = nextStream;
+      setStream(nextStream);
+      setCurrentDeviceId(detectedDeviceId);
+      currentDeviceIdRef.current = detectedDeviceId;
+      setPermission("granted");
+      setMuted(false);
+      setStatus("active");
+      startVolumeMonitor(nextStream);
+      return nextStream;
+    } catch (nextError) {
+      const normalized = normalizeMediaError(nextError, "unknown");
+      setError(normalized);
+      setPermission(normalized.code === "permission-denied" ? "denied" : permission);
+      setStatus("error");
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }
+  async function start(override = {}) {
+    return startStream(void 0, override);
+  }
+  function mute() {
+    setStreamEnabled(streamRef.current, false);
+    setMuted(true);
+  }
+  function unmute() {
+    setStreamEnabled(streamRef.current, true);
+    setMuted(false);
+  }
+  async function switchMicrophone(deviceId, override = {}) {
+    setCurrentDeviceId(deviceId);
+    currentDeviceIdRef.current = deviceId;
+    if (!streamRef.current) {
+      return null;
+    }
+    return startStream(deviceId, override);
+  }
+  async function refresh() {
+    await Promise.all([refreshDevices(), updatePermission()]);
+  }
+  function destroy() {
+    destroyedRef.current = true;
+    stop();
+    setMicrophones([]);
+    setError(null);
+    setPermission(DEFAULT_PERMISSION_STATE);
+    setStatus(DEFAULT_STATUS);
+    currentDeviceIdRef.current = null;
+  }
+  useEffect(() => {
+    destroyedRef.current = false;
+    void refresh();
+    if (config.autoRefreshOnDeviceChange && supported) {
+      const handleDeviceChange = () => {
+        void refreshDevices();
+      };
+      navigator.mediaDevices.addEventListener("devicechange", handleDeviceChange);
+      return () => {
+        destroyedRef.current = true;
+        stopVolumeMonitor();
+        stopStream(streamRef.current);
+        navigator.mediaDevices.removeEventListener("devicechange", handleDeviceChange);
+      };
+    }
+    return () => {
+      destroyedRef.current = true;
+      stopVolumeMonitor();
+      stopStream(streamRef.current);
+    };
+  }, [config.autoRefreshOnDeviceChange, supported]);
+  useEffect(() => {
+    if (options.autoStart) {
+      void start();
+    }
+  }, []);
+  return {
+    currentMicrophone,
+    destroy,
+    error,
+    isActive: Boolean(stream),
+    isLoading: loading,
+    loading,
+    microphones,
+    mute,
+    muted,
+    permission,
+    refresh,
+    refreshDevices,
+    start,
+    status,
+    stop,
+    stream,
+    supported,
+    switchMicrophone,
+    unmute,
+    volume
+  };
+}
+function usePermissions() {
+  const supported = isMediaDevicesSupported();
+  const permissionsSupported = isPermissionsSupported();
+  const [camera, setCamera] = useState(DEFAULT_PERMISSION_STATE);
+  const [microphone, setMicrophone] = useState(DEFAULT_PERMISSION_STATE);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const destroyedRef = useRef(false);
+  async function refresh() {
+    if (!supported || destroyedRef.current) {
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const [nextCamera, nextMicrophone] = await Promise.all([
+        queryPermissionState("camera"),
+        queryPermissionState("microphone")
+      ]);
+      if (!destroyedRef.current) {
+        setCamera(nextCamera);
+        setMicrophone(nextMicrophone);
+      }
+    } catch (nextError) {
+      if (!destroyedRef.current) {
+        setError(normalizeMediaError(nextError, "permission-query-failed"));
+      }
+    } finally {
+      if (!destroyedRef.current) {
+        setLoading(false);
+      }
+    }
+  }
+  async function requestCamera() {
+    try {
+      const stream = await requestMediaPermission({ video: true });
+      stopStream(stream);
+      await refresh();
+    } catch (nextError) {
+      setError(normalizeMediaError(nextError, "permission-denied"));
+      throw nextError;
+    }
+  }
+  async function requestMicrophone() {
+    try {
+      const stream = await requestMediaPermission({ audio: true });
+      stopStream(stream);
+      await refresh();
+    } catch (nextError) {
+      setError(normalizeMediaError(nextError, "permission-denied"));
+      throw nextError;
+    }
+  }
+  async function requestAll() {
+    try {
+      const stream = await requestMediaPermission({ audio: true, video: true });
+      stopStream(stream);
+      await refresh();
+    } catch (nextError) {
+      setError(normalizeMediaError(nextError, "permission-denied"));
+      throw nextError;
+    }
+  }
+  function destroy() {
+    destroyedRef.current = true;
+    setCamera(DEFAULT_PERMISSION_STATE);
+    setMicrophone(DEFAULT_PERMISSION_STATE);
+    setError(null);
+    setLoading(false);
+  }
+  useEffect(() => {
+    destroyedRef.current = false;
+    void refresh();
+    if (!permissionsSupported) {
+      setCamera("unsupported");
+      setMicrophone("unsupported");
+      return () => {
+        destroyedRef.current = true;
+      };
+    }
+    let cameraCleanup = () => void 0;
+    let microphoneCleanup = () => void 0;
+    void watchPermissionState("camera", (nextState) => {
+      if (!destroyedRef.current) {
+        setCamera(nextState);
+      }
+    }).then((cleanup) => {
+      cameraCleanup = cleanup;
+    });
+    void watchPermissionState("microphone", (nextState) => {
+      if (!destroyedRef.current) {
+        setMicrophone(nextState);
+      }
+    }).then((cleanup) => {
+      microphoneCleanup = cleanup;
+    });
+    return () => {
+      destroyedRef.current = true;
+      cameraCleanup();
+      microphoneCleanup();
+    };
+  }, [permissionsSupported, supported]);
+  return {
+    camera,
+    destroy,
+    error,
+    loading,
+    microphone,
+    refresh,
+    requestAll,
+    requestCamera,
+    requestMicrophone,
+    supported
+  };
+}
+function resolveTarget(target) {
+  if (!target) {
+    return null;
+  }
+  if ("current" in target) {
+    return target.current;
+  }
+  return target;
+}
+function useSpeaker(target) {
+  const supported = isMediaDevicesSupported();
+  const [speakers, setSpeakers] = useState([]);
+  const [currentSpeakerId, setCurrentSpeakerId] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const destroyedRef = useRef(false);
+  const permission = "unknown";
+  const currentSpeaker = findDeviceById(speakers, currentSpeakerId);
+  const mediaElement = resolveTarget(target);
+  const sinkSupported = isSetSinkIdSupported(mediaElement);
+  async function refresh() {
+    if (!supported || destroyedRef.current) {
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const devices = await enumerateDevices();
+      if (!destroyedRef.current) {
+        setSpeakers(devices.speakers);
+        if (!currentSpeakerId && devices.speakers[0]) {
+          setCurrentSpeakerId(devices.speakers[0].deviceId);
+        }
+      }
+    } catch (nextError) {
+      if (!destroyedRef.current) {
+        setError(normalizeMediaError(nextError, "browser-not-supported"));
+        setSpeakers(emptyDevices().speakers);
+      }
+    } finally {
+      if (!destroyedRef.current) {
+        setLoading(false);
+      }
+    }
+  }
+  async function switchSpeaker(deviceId) {
+    if (!mediaElement || !sinkSupported) {
+      setError(normalizeMediaError(new Error("setSinkId is unavailable."), "speaker-not-supported"));
+      return false;
+    }
+    try {
+      await mediaElement.setSinkId(deviceId);
+      setCurrentSpeakerId(deviceId);
+      setError(null);
+      return true;
+    } catch (nextError) {
+      setError(normalizeMediaError(nextError, "speaker-not-supported"));
+      return false;
+    }
+  }
+  function destroy() {
+    destroyedRef.current = true;
+    setSpeakers([]);
+    setCurrentSpeakerId(null);
+    setError(null);
+    setLoading(false);
+  }
+  useEffect(() => {
+    destroyedRef.current = false;
+    void refresh();
+    if (!supported) {
+      return () => {
+        destroyedRef.current = true;
+      };
+    }
+    const handleDeviceChange = () => {
+      void refresh();
+    };
+    navigator.mediaDevices.addEventListener("devicechange", handleDeviceChange);
+    return () => {
+      destroyedRef.current = true;
+      navigator.mediaDevices.removeEventListener("devicechange", handleDeviceChange);
+    };
+  }, [supported]);
+  return {
+    currentSpeaker,
+    destroy,
+    error,
+    isSupported: sinkSupported,
+    loading,
+    permission,
+    refresh,
+    speakers,
+    supported,
+    switchSpeaker
+  };
+}
+
+// src/version.ts
+var version = "0.1.0";
+
+export { MediaProvider, useCamera, useDeviceChange, useMediaDevices, useMediaProviderConfig, useMediaRecorder, useMicrophone, usePermissions, useSpeaker, version };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map