@mohasinac/react 0.1.0

package/dist/index.js

@@ -0,0 +1,722 @@
+// src/hooks/useMediaQuery.ts
+import { useState, useEffect } from "react";
+function useMediaQuery(query) {
+  const [matches, setMatches] = useState(
+    // Lazy initializer: use real value on first client render, suppressing the flash.
+    // Returns false on server (no window) — consistent with no-match default.
+    () => typeof window !== "undefined" && window.matchMedia(query).matches
+  );
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const media = window.matchMedia(query);
+    setMatches(media.matches);
+    const listener = (e) => setMatches(e.matches);
+    media.addEventListener("change", listener);
+    return () => media.removeEventListener("change", listener);
+  }, [query]);
+  return matches;
+}
+
+// src/hooks/useBreakpoint.ts
+function useBreakpoint() {
+  const isMobile = useMediaQuery("(max-width: 767px)");
+  const isTablet = useMediaQuery("(min-width: 768px) and (max-width: 1023px)");
+  const isDesktop = useMediaQuery("(min-width: 1024px)");
+  const breakpoint = isMobile ? "mobile" : isTablet ? "tablet" : "desktop";
+  return {
+    isMobile,
+    isTablet,
+    isDesktop,
+    breakpoint
+  };
+}
+
+// src/hooks/useClickOutside.ts
+import { useEffect as useEffect2, useRef } from "react";
+var EMPTY_REFS = [];
+function useClickOutside(ref, callback, options = {}) {
+  const {
+    enabled = true,
+    eventType = "mousedown",
+    additionalRefs = EMPTY_REFS
+  } = options;
+  const callbackRef = useRef(callback);
+  useEffect2(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  useEffect2(() => {
+    if (!enabled) return;
+    const handleClickOutside = (event) => {
+      if (ref.current && !ref.current.contains(event.target)) {
+        const isOutsideAll = additionalRefs.every(
+          (additionalRef) => !additionalRef.current || !additionalRef.current.contains(event.target)
+        );
+        if (isOutsideAll) {
+          callbackRef.current(event);
+        }
+      }
+    };
+    document.addEventListener(eventType, handleClickOutside);
+    document.addEventListener("touchstart", handleClickOutside);
+    return () => {
+      document.removeEventListener(eventType, handleClickOutside);
+      document.removeEventListener("touchstart", handleClickOutside);
+    };
+  }, [ref, enabled, eventType, additionalRefs]);
+}
+
+// src/hooks/useKeyPress.ts
+import { useEffect as useEffect3, useCallback, useRef as useRef2, useMemo } from "react";
+function useKeyPress(key, callback, options = {}) {
+  const {
+    enabled = true,
+    eventType = "keydown",
+    preventDefault = false,
+    ctrl = false,
+    shift = false,
+    alt = false,
+    meta = false,
+    target = typeof document !== "undefined" ? document : null
+  } = options;
+  const keys = useMemo(() => Array.isArray(key) ? key : [key], [key]);
+  const callbackRef = useRef2(callback);
+  useEffect3(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  const handleKeyPress = useCallback(
+    (event) => {
+      const isKeyMatch = keys.some((k) => event.key === k || event.code === k);
+      if (!isKeyMatch) return;
+      const modifiersMatch = event.ctrlKey === ctrl && event.shiftKey === shift && event.altKey === alt && event.metaKey === meta;
+      if (!modifiersMatch) return;
+      if (preventDefault) {
+        event.preventDefault();
+      }
+      callbackRef.current(event);
+    },
+    [keys, ctrl, shift, alt, meta, preventDefault]
+  );
+  useEffect3(() => {
+    if (!enabled || !target) return;
+    target.addEventListener(eventType, handleKeyPress);
+    return () => {
+      target.removeEventListener(eventType, handleKeyPress);
+    };
+  }, [enabled, eventType, handleKeyPress, target]);
+}
+
+// src/hooks/useLongPress.ts
+import { useRef as useRef3, useCallback as useCallback2, useEffect as useEffect4 } from "react";
+function useLongPress(callback, ms = 500) {
+  const timerRef = useRef3(null);
+  const callbackRef = useRef3(callback);
+  useEffect4(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  const start = useCallback2(() => {
+    timerRef.current = setTimeout(() => {
+      callbackRef.current();
+    }, ms);
+  }, [ms]);
+  const cancel = useCallback2(() => {
+    if (timerRef.current !== null) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+  }, []);
+  useEffect4(() => {
+    return () => {
+      if (timerRef.current !== null) {
+        clearTimeout(timerRef.current);
+      }
+    };
+  }, []);
+  return {
+    onMouseDown: start,
+    onMouseUp: cancel,
+    onMouseLeave: cancel,
+    onTouchStart: start,
+    onTouchEnd: cancel
+  };
+}
+
+// src/hooks/useGesture.ts
+import { useRef as useRef4, useEffect as useEffect5 } from "react";
+function useGesture(ref, options = {}) {
+  const {
+    onTap,
+    onDoubleTap,
+    onPinch,
+    onPinching,
+    onRotate,
+    onRotating,
+    doubleTapDelay = 300,
+    tapMovementThreshold = 10,
+    preventDefault = false
+  } = options;
+  const touchStartRef = useRef4(
+    null
+  );
+  const lastTapRef = useRef4(0);
+  const initialPinchDistanceRef = useRef4(0);
+  const initialRotationRef = useRef4(0);
+  const onTapRef = useRef4(onTap);
+  const onDoubleTapRef = useRef4(onDoubleTap);
+  const onPinchRef = useRef4(onPinch);
+  const onPinchingRef = useRef4(onPinching);
+  const onRotateRef = useRef4(onRotate);
+  const onRotatingRef = useRef4(onRotating);
+  useEffect5(() => {
+    onTapRef.current = onTap;
+  }, [onTap]);
+  useEffect5(() => {
+    onDoubleTapRef.current = onDoubleTap;
+  }, [onDoubleTap]);
+  useEffect5(() => {
+    onPinchRef.current = onPinch;
+  }, [onPinch]);
+  useEffect5(() => {
+    onPinchingRef.current = onPinching;
+  }, [onPinching]);
+  useEffect5(() => {
+    onRotateRef.current = onRotate;
+  }, [onRotate]);
+  useEffect5(() => {
+    onRotatingRef.current = onRotating;
+  }, [onRotating]);
+  useEffect5(() => {
+    const element = ref.current;
+    if (!element) return;
+    const getDistance = (touch1, touch2) => {
+      const dx = touch1.clientX - touch2.clientX;
+      const dy = touch1.clientY - touch2.clientY;
+      return Math.sqrt(dx * dx + dy * dy);
+    };
+    const getAngle = (touch1, touch2) => {
+      const dx = touch1.clientX - touch2.clientX;
+      const dy = touch1.clientY - touch2.clientY;
+      return Math.atan2(dy, dx) * (180 / Math.PI);
+    };
+    const handleTouchStart = (e) => {
+      if (preventDefault) e.preventDefault();
+      const touch = e.touches[0];
+      touchStartRef.current = {
+        x: touch.clientX,
+        y: touch.clientY,
+        time: Date.now()
+      };
+      if (e.touches.length === 2) {
+        initialPinchDistanceRef.current = getDistance(
+          e.touches[0],
+          e.touches[1]
+        );
+        initialRotationRef.current = getAngle(e.touches[0], e.touches[1]);
+      }
+    };
+    const handleTouchMove = (e) => {
+      var _a, _b;
+      if (!touchStartRef.current) return;
+      if (e.touches.length === 2 && (onPinchRef.current || onPinchingRef.current || onRotateRef.current || onRotatingRef.current)) {
+        if (preventDefault) e.preventDefault();
+        const currentDistance = getDistance(e.touches[0], e.touches[1]);
+        const currentAngle = getAngle(e.touches[0], e.touches[1]);
+        if (initialPinchDistanceRef.current > 0) {
+          (_a = onPinchingRef.current) == null ? void 0 : _a.call(
+            onPinchingRef,
+            currentDistance / initialPinchDistanceRef.current
+          );
+        }
+        if (initialRotationRef.current !== 0) {
+          (_b = onRotatingRef.current) == null ? void 0 : _b.call(onRotatingRef, currentAngle - initialRotationRef.current);
+        }
+      }
+    };
+    const handleTouchEnd = (e) => {
+      var _a, _b, _c;
+      if (!touchStartRef.current) return;
+      if (preventDefault) e.preventDefault();
+      const touch = e.changedTouches[0];
+      const deltaX = Math.abs(touch.clientX - touchStartRef.current.x);
+      const deltaY = Math.abs(touch.clientY - touchStartRef.current.y);
+      if (deltaX < tapMovementThreshold && deltaY < tapMovementThreshold) {
+        const now = Date.now();
+        const timeSinceLastTap = now - lastTapRef.current;
+        if (onDoubleTapRef.current && timeSinceLastTap < doubleTapDelay) {
+          onDoubleTapRef.current(
+            touchStartRef.current.x,
+            touchStartRef.current.y
+          );
+          lastTapRef.current = 0;
+        } else {
+          (_a = onTapRef.current) == null ? void 0 : _a.call(onTapRef, touchStartRef.current.x, touchStartRef.current.y);
+          lastTapRef.current = now;
+        }
+      }
+      if (e.touches.length === 0 && initialPinchDistanceRef.current > 0) {
+        const currentDistance = getDistance(
+          e.changedTouches[0],
+          e.changedTouches[1] || e.changedTouches[0]
+        );
+        (_b = onPinchRef.current) == null ? void 0 : _b.call(
+          onPinchRef,
+          currentDistance / initialPinchDistanceRef.current,
+          currentDistance
+        );
+        initialPinchDistanceRef.current = 0;
+      }
+      if (e.touches.length === 0 && initialRotationRef.current !== 0) {
+        const currentAngle = getAngle(
+          e.changedTouches[0],
+          e.changedTouches[1] || e.changedTouches[0]
+        );
+        (_c = onRotateRef.current) == null ? void 0 : _c.call(onRotateRef, currentAngle - initialRotationRef.current);
+        initialRotationRef.current = 0;
+      }
+      touchStartRef.current = null;
+    };
+    const handleMouseDown = (e) => {
+      if (preventDefault) e.preventDefault();
+      touchStartRef.current = { x: e.clientX, y: e.clientY, time: Date.now() };
+    };
+    const handleMouseUp = (e) => {
+      var _a;
+      if (!touchStartRef.current) return;
+      if (preventDefault) e.preventDefault();
+      const deltaX = Math.abs(e.clientX - touchStartRef.current.x);
+      const deltaY = Math.abs(e.clientY - touchStartRef.current.y);
+      if (deltaX < tapMovementThreshold && deltaY < tapMovementThreshold) {
+        const now = Date.now();
+        const timeSinceLastTap = now - lastTapRef.current;
+        if (onDoubleTapRef.current && timeSinceLastTap < doubleTapDelay) {
+          onDoubleTapRef.current(
+            touchStartRef.current.x,
+            touchStartRef.current.y
+          );
+          lastTapRef.current = 0;
+        } else {
+          (_a = onTapRef.current) == null ? void 0 : _a.call(onTapRef, touchStartRef.current.x, touchStartRef.current.y);
+          lastTapRef.current = now;
+        }
+      }
+      touchStartRef.current = null;
+    };
+    element.addEventListener("touchstart", handleTouchStart, {
+      passive: !preventDefault
+    });
+    element.addEventListener("touchmove", handleTouchMove, {
+      passive: !preventDefault
+    });
+    element.addEventListener("touchend", handleTouchEnd, {
+      passive: !preventDefault
+    });
+    element.addEventListener("mousedown", handleMouseDown);
+    element.addEventListener("mouseup", handleMouseUp);
+    return () => {
+      element.removeEventListener("touchstart", handleTouchStart);
+      element.removeEventListener("touchmove", handleTouchMove);
+      element.removeEventListener("touchend", handleTouchEnd);
+      element.removeEventListener("mousedown", handleMouseDown);
+      element.removeEventListener("mouseup", handleMouseUp);
+    };
+  }, [ref, doubleTapDelay, tapMovementThreshold, preventDefault]);
+}
+
+// src/hooks/useSwipe.ts
+import { useRef as useRef5, useEffect as useEffect6 } from "react";
+function useSwipe(ref, options = {}) {
+  const {
+    minSwipeDistance = 50,
+    maxSwipeTime = 300,
+    velocityThreshold = 0.3,
+    onSwipe,
+    onSwipeLeft,
+    onSwipeRight,
+    onSwipeUp,
+    onSwipeDown,
+    onSwiping,
+    onSwipeStart,
+    onSwipeEnd,
+    preventDefault = false
+  } = options;
+  const touchStartRef = useRef5(
+    null
+  );
+  const isSwiping = useRef5(false);
+  const onSwipeRef = useRef5(onSwipe);
+  const onSwipeLeftRef = useRef5(onSwipeLeft);
+  const onSwipeRightRef = useRef5(onSwipeRight);
+  const onSwipeUpRef = useRef5(onSwipeUp);
+  const onSwipeDownRef = useRef5(onSwipeDown);
+  const onSwipingRef = useRef5(onSwiping);
+  const onSwipeStartRef = useRef5(onSwipeStart);
+  const onSwipeEndRef = useRef5(onSwipeEnd);
+  useEffect6(() => {
+    onSwipeRef.current = onSwipe;
+  }, [onSwipe]);
+  useEffect6(() => {
+    onSwipeLeftRef.current = onSwipeLeft;
+  }, [onSwipeLeft]);
+  useEffect6(() => {
+    onSwipeRightRef.current = onSwipeRight;
+  }, [onSwipeRight]);
+  useEffect6(() => {
+    onSwipeUpRef.current = onSwipeUp;
+  }, [onSwipeUp]);
+  useEffect6(() => {
+    onSwipeDownRef.current = onSwipeDown;
+  }, [onSwipeDown]);
+  useEffect6(() => {
+    onSwipingRef.current = onSwiping;
+  }, [onSwiping]);
+  useEffect6(() => {
+    onSwipeStartRef.current = onSwipeStart;
+  }, [onSwipeStart]);
+  useEffect6(() => {
+    onSwipeEndRef.current = onSwipeEnd;
+  }, [onSwipeEnd]);
+  useEffect6(() => {
+    const element = ref.current;
+    if (!element) return;
+    const processSwipe = (deltaX, deltaY, deltaTime) => {
+      var _a, _b, _c, _d, _e;
+      const absX = Math.abs(deltaX);
+      const absY = Math.abs(deltaY);
+      const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+      const velocity = distance / deltaTime;
+      if (distance < minSwipeDistance || deltaTime > maxSwipeTime || velocity < velocityThreshold)
+        return;
+      let direction;
+      if (absX > absY) {
+        direction = deltaX > 0 ? "right" : "left";
+        if (direction === "left") (_a = onSwipeLeftRef.current) == null ? void 0 : _a.call(onSwipeLeftRef, distance, velocity);
+        else (_b = onSwipeRightRef.current) == null ? void 0 : _b.call(onSwipeRightRef, distance, velocity);
+      } else {
+        direction = deltaY > 0 ? "down" : "up";
+        if (direction === "up") (_c = onSwipeUpRef.current) == null ? void 0 : _c.call(onSwipeUpRef, distance, velocity);
+        else (_d = onSwipeDownRef.current) == null ? void 0 : _d.call(onSwipeDownRef, distance, velocity);
+      }
+      (_e = onSwipeRef.current) == null ? void 0 : _e.call(onSwipeRef, direction, distance, velocity);
+    };
+    const handleTouchStart = (e) => {
+      var _a;
+      if (preventDefault) e.preventDefault();
+      const touch = e.touches[0];
+      touchStartRef.current = {
+        x: touch.clientX,
+        y: touch.clientY,
+        time: Date.now()
+      };
+      isSwiping.current = true;
+      (_a = onSwipeStartRef.current) == null ? void 0 : _a.call(onSwipeStartRef);
+    };
+    const handleTouchMove = (e) => {
+      var _a;
+      if (!touchStartRef.current || !isSwiping.current) return;
+      if (preventDefault) e.preventDefault();
+      (_a = onSwipingRef.current) == null ? void 0 : _a.call(
+        onSwipingRef,
+        e.touches[0].clientX - touchStartRef.current.x,
+        e.touches[0].clientY - touchStartRef.current.y
+      );
+    };
+    const handleTouchEnd = (e) => {
+      var _a;
+      if (!touchStartRef.current || !isSwiping.current) return;
+      if (preventDefault) e.preventDefault();
+      const touch = e.changedTouches[0];
+      processSwipe(
+        touch.clientX - touchStartRef.current.x,
+        touch.clientY - touchStartRef.current.y,
+        Date.now() - touchStartRef.current.time
+      );
+      touchStartRef.current = null;
+      isSwiping.current = false;
+      (_a = onSwipeEndRef.current) == null ? void 0 : _a.call(onSwipeEndRef);
+    };
+    const handleMouseDown = (e) => {
+      var _a;
+      if (preventDefault) e.preventDefault();
+      touchStartRef.current = { x: e.clientX, y: e.clientY, time: Date.now() };
+      isSwiping.current = true;
+      (_a = onSwipeStartRef.current) == null ? void 0 : _a.call(onSwipeStartRef);
+    };
+    const handleMouseMove = (e) => {
+      var _a;
+      if (!touchStartRef.current || !isSwiping.current) return;
+      (_a = onSwipingRef.current) == null ? void 0 : _a.call(
+        onSwipingRef,
+        e.clientX - touchStartRef.current.x,
+        e.clientY - touchStartRef.current.y
+      );
+    };
+    const handleMouseUp = (e) => {
+      var _a;
+      if (!touchStartRef.current || !isSwiping.current) return;
+      if (preventDefault) e.preventDefault();
+      processSwipe(
+        e.clientX - touchStartRef.current.x,
+        e.clientY - touchStartRef.current.y,
+        Date.now() - touchStartRef.current.time
+      );
+      touchStartRef.current = null;
+      isSwiping.current = false;
+      (_a = onSwipeEndRef.current) == null ? void 0 : _a.call(onSwipeEndRef);
+    };
+    element.addEventListener("touchstart", handleTouchStart, {
+      passive: !preventDefault
+    });
+    element.addEventListener("touchmove", handleTouchMove, {
+      passive: !preventDefault
+    });
+    element.addEventListener("touchend", handleTouchEnd, {
+      passive: !preventDefault
+    });
+    element.addEventListener("mousedown", handleMouseDown);
+    document.addEventListener("mousemove", handleMouseMove);
+    document.addEventListener("mouseup", handleMouseUp);
+    return () => {
+      element.removeEventListener("touchstart", handleTouchStart);
+      element.removeEventListener("touchmove", handleTouchMove);
+      element.removeEventListener("touchend", handleTouchEnd);
+      element.removeEventListener("mousedown", handleMouseDown);
+      document.removeEventListener("mousemove", handleMouseMove);
+      document.removeEventListener("mouseup", handleMouseUp);
+    };
+  }, [ref, minSwipeDistance, maxSwipeTime, velocityThreshold, preventDefault]);
+}
+
+// src/hooks/usePullToRefresh.ts
+import { useRef as useRef6, useState as useState2, useCallback as useCallback3, useEffect as useEffect7 } from "react";
+function usePullToRefresh(onRefresh, options = {}) {
+  const { threshold = 80 } = options;
+  const containerRef = useRef6(null);
+  const [isPulling, setIsPulling] = useState2(false);
+  const [progress, setProgress] = useState2(0);
+  const startYRef = useRef6(null);
+  const thresholdReachedRef = useRef6(false);
+  const onRefreshRef = useRef6(onRefresh);
+  useEffect7(() => {
+    onRefreshRef.current = onRefresh;
+  }, [onRefresh]);
+  const handleTouchStart = useCallback3((e) => {
+    const el = containerRef.current;
+    if (!el || el.scrollTop > 0) return;
+    startYRef.current = e.touches[0].clientY;
+    thresholdReachedRef.current = false;
+  }, []);
+  const handleTouchMove = useCallback3(
+    (e) => {
+      if (startYRef.current === null) return;
+      const delta = e.touches[0].clientY - startYRef.current;
+      if (delta <= 0) {
+        setProgress(0);
+        setIsPulling(false);
+        return;
+      }
+      const prog = Math.min(delta / threshold, 1);
+      setProgress(prog);
+      setIsPulling(true);
+      thresholdReachedRef.current = prog >= 1;
+    },
+    [threshold]
+  );
+  const handleTouchEnd = useCallback3(async () => {
+    setIsPulling(false);
+    setProgress(0);
+    startYRef.current = null;
+    if (thresholdReachedRef.current) {
+      thresholdReachedRef.current = false;
+      await onRefreshRef.current();
+    }
+  }, []);
+  useEffect7(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    el.addEventListener("touchstart", handleTouchStart, { passive: true });
+    el.addEventListener("touchmove", handleTouchMove, { passive: true });
+    el.addEventListener("touchend", handleTouchEnd);
+    return () => {
+      el.removeEventListener("touchstart", handleTouchStart);
+      el.removeEventListener("touchmove", handleTouchMove);
+      el.removeEventListener("touchend", handleTouchEnd);
+    };
+  }, [handleTouchStart, handleTouchMove, handleTouchEnd]);
+  return { containerRef, isPulling, progress };
+}
+
+// src/hooks/useCountdown.ts
+import { useState as useState3, useEffect as useEffect8 } from "react";
+function resolveMs(endDate) {
+  if (!endDate) return NaN;
+  if (endDate instanceof Date) return endDate.getTime();
+  if (typeof endDate === "object" && endDate !== null && "_seconds" in endDate && typeof endDate._seconds === "number") {
+    return endDate._seconds * 1e3;
+  }
+  return new Date(endDate).getTime();
+}
+function useCountdown(endDate) {
+  const getRemaining = () => {
+    if (!endDate) return null;
+    const ms = resolveMs(endDate);
+    if (Number.isNaN(ms)) return null;
+    const diff = ms - Date.now();
+    if (diff <= 0) return null;
+    return {
+      days: Math.floor(diff / (1e3 * 60 * 60 * 24)),
+      hours: Math.floor(diff % (1e3 * 60 * 60 * 24) / (1e3 * 60 * 60)),
+      minutes: Math.floor(diff % (1e3 * 60 * 60) / (1e3 * 60)),
+      seconds: Math.floor(diff % (1e3 * 60) / 1e3)
+    };
+  };
+  const [remaining, setRemaining] = useState3(
+    getRemaining
+  );
+  useEffect8(() => {
+    const id = setInterval(() => setRemaining(getRemaining()), 1e3);
+    return () => clearInterval(id);
+  }, [endDate]);
+  return remaining;
+}
+
+// src/hooks/useCamera.ts
+import { useCallback as useCallback4, useEffect as useEffect9, useRef as useRef7, useState as useState4 } from "react";
+function useCamera() {
+  const isSupported = typeof navigator !== "undefined" && typeof navigator.mediaDevices !== "undefined" && typeof navigator.mediaDevices.getUserMedia === "function";
+  const videoRef = useRef7(null);
+  const streamRef = useRef7(null);
+  const mediaRecorderRef = useRef7(null);
+  const chunksRef = useRef7([]);
+  const currentFacingModeRef = useRef7("environment");
+  const stopRecordingResolveRef = useRef7(null);
+  const [stream, setStream] = useState4(null);
+  const [isActive, setIsActive] = useState4(false);
+  const [isCapturing, setIsCapturing] = useState4(false);
+  const [error, setError] = useState4(null);
+  const stopCamera = useCallback4(() => {
+    if (streamRef.current) {
+      streamRef.current.getTracks().forEach((t) => t.stop());
+      streamRef.current = null;
+    }
+    if (videoRef.current) {
+      videoRef.current.srcObject = null;
+    }
+    setStream(null);
+    setIsActive(false);
+    setIsCapturing(false);
+  }, []);
+  useEffect9(() => {
+    return () => {
+      stopCamera();
+    };
+  }, [stopCamera]);
+  const startCamera = useCallback4(
+    async (options) => {
+      var _a, _b;
+      if (!isSupported) {
+        setError("Camera is not supported on this device");
+        return;
+      }
+      setError(null);
+      stopCamera();
+      const facingMode = (_a = options == null ? void 0 : options.facingMode) != null ? _a : "environment";
+      currentFacingModeRef.current = facingMode;
+      const videoConstraints = (options == null ? void 0 : options.video) !== void 0 ? options.video : { facingMode };
+      try {
+        const mediaStream = await navigator.mediaDevices.getUserMedia({
+          video: videoConstraints,
+          audio: (_b = options == null ? void 0 : options.audio) != null ? _b : false
+        });
+        streamRef.current = mediaStream;
+        setStream(mediaStream);
+        setIsActive(true);
+        if (videoRef.current) {
+          videoRef.current.srcObject = mediaStream;
+        }
+      } catch (err) {
+        const message = err instanceof DOMException && err.name === "NotAllowedError" ? "Camera permission denied. Please allow access in your browser settings." : "Camera unavailable";
+        setError(message);
+      }
+    },
+    [isSupported, stopCamera]
+  );
+  const takePhoto = useCallback4(() => {
+    const video = videoRef.current;
+    if (!video || !isActive) return null;
+    const canvas = document.createElement("canvas");
+    canvas.width = video.videoWidth;
+    canvas.height = video.videoHeight;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return null;
+    ctx.drawImage(video, 0, 0);
+    let result = null;
+    canvas.toBlob(
+      (blob) => {
+        result = blob;
+      },
+      "image/webp",
+      0.92
+    );
+    return result;
+  }, [isActive]);
+  const startRecording = useCallback4(() => {
+    if (!streamRef.current || !isActive) return;
+    chunksRef.current = [];
+    const recorder = new MediaRecorder(streamRef.current, {
+      mimeType: "video/webm"
+    });
+    recorder.ondataavailable = (e) => {
+      if (e.data.size > 0) chunksRef.current.push(e.data);
+    };
+    recorder.onstop = () => {
+      const blob = new Blob(chunksRef.current, { type: "video/webm" });
+      setIsCapturing(false);
+      if (stopRecordingResolveRef.current) {
+        stopRecordingResolveRef.current(blob);
+        stopRecordingResolveRef.current = null;
+      }
+    };
+    mediaRecorderRef.current = recorder;
+    recorder.start();
+    setIsCapturing(true);
+  }, [isActive]);
+  const stopRecording = useCallback4(() => {
+    return new Promise((resolve) => {
+      stopRecordingResolveRef.current = resolve;
+      if (mediaRecorderRef.current && mediaRecorderRef.current.state !== "inactive") {
+        mediaRecorderRef.current.stop();
+      } else {
+        resolve(new Blob([], { type: "video/webm" }));
+      }
+    });
+  }, []);
+  const switchCamera = useCallback4(async () => {
+    const next = currentFacingModeRef.current === "environment" ? "user" : "environment";
+    await startCamera({ facingMode: next });
+  }, [startCamera]);
+  return {
+    isSupported,
+    isActive,
+    isCapturing,
+    stream,
+    error,
+    videoRef,
+    startCamera,
+    stopCamera,
+    takePhoto,
+    startRecording,
+    stopRecording,
+    switchCamera
+  };
+}
+export {
+  useBreakpoint,
+  useCamera,
+  useClickOutside,
+  useCountdown,
+  useGesture,
+  useKeyPress,
+  useLongPress,
+  useMediaQuery,
+  usePullToRefresh,
+  useSwipe
+};