@mohasinac/appkit 2.1.1 → 2.2.0

package/dist/react/index.cjs

@@ -1,1687 +0,0 @@
-"use client";
-'use strict';
-
-require('next/server.js');
-var react = require('react');
-var navigation = require('next/navigation');
-require('crypto');
-var jsxRuntime = require('react/jsx-runtime');
-
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-
-// src/errors/base-error.ts
-var init_base_error = __esm({
-  "src/errors/base-error.ts"() {
-  }
-});
-
-// src/errors/error-codes.ts
-var init_error_codes = __esm({
-  "src/errors/error-codes.ts"() {
-  }
-});
-
-// src/errors/api-error.ts
-var init_api_error = __esm({
-  "src/errors/api-error.ts"() {
-    init_base_error();
-  }
-});
-
-// src/errors/validation-error.ts
-var init_validation_error = __esm({
-  "src/errors/validation-error.ts"() {
-    init_base_error();
-  }
-});
-
-// src/errors/authentication-error.ts
-var init_authentication_error = __esm({
-  "src/errors/authentication-error.ts"() {
-    init_base_error();
-  }
-});
-
-// src/errors/authorization-error.ts
-var init_authorization_error = __esm({
-  "src/errors/authorization-error.ts"() {
-    init_base_error();
-  }
-});
-
-// src/errors/not-found-error.ts
-var init_not_found_error = __esm({
-  "src/errors/not-found-error.ts"() {
-    init_base_error();
-  }
-});
-
-// src/errors/database-error.ts
-var init_database_error = __esm({
-  "src/errors/database-error.ts"() {
-    init_base_error();
-  }
-});
-var init_error_handler = __esm({
-  "src/errors/error-handler.ts"() {
-    init_base_error();
-    init_error_codes();
-  }
-});
-
-// src/errors/index.ts
-var init_errors = __esm({
-  "src/errors/index.ts"() {
-    init_base_error();
-    init_error_codes();
-    init_api_error();
-    init_validation_error();
-    init_authentication_error();
-    init_authorization_error();
-    init_not_found_error();
-    init_database_error();
-    init_error_handler();
-  }
-});
-function useMediaQuery(query) {
-  const [matches, setMatches] = react.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
-  );
-  react.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/react/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
-  };
-}
-var EMPTY_REFS = [];
-function useClickOutside(ref, callback, options = {}) {
-  const {
-    enabled = true,
-    eventType = "mousedown",
-    additionalRefs = EMPTY_REFS
-  } = options;
-  const callbackRef = react.useRef(callback);
-  react.useEffect(() => {
-    callbackRef.current = callback;
-  }, [callback]);
-  react.useEffect(() => {
-    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]);
-}
-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 = react.useMemo(() => Array.isArray(key) ? key : [key], [key]);
-  const callbackRef = react.useRef(callback);
-  react.useEffect(() => {
-    callbackRef.current = callback;
-  }, [callback]);
-  const handleKeyPress = react.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]
-  );
-  react.useEffect(() => {
-    if (!enabled || !target) return;
-    target.addEventListener(eventType, handleKeyPress);
-    return () => {
-      target.removeEventListener(eventType, handleKeyPress);
-    };
-  }, [enabled, eventType, handleKeyPress, target]);
-}
-function useLongPress(callback, ms = 500) {
-  const timerRef = react.useRef(null);
-  const callbackRef = react.useRef(callback);
-  react.useEffect(() => {
-    callbackRef.current = callback;
-  }, [callback]);
-  const start = react.useCallback(() => {
-    timerRef.current = setTimeout(() => {
-      callbackRef.current();
-    }, ms);
-  }, [ms]);
-  const cancel = react.useCallback(() => {
-    if (timerRef.current !== null) {
-      clearTimeout(timerRef.current);
-      timerRef.current = null;
-    }
-  }, []);
-  react.useEffect(() => {
-    return () => {
-      if (timerRef.current !== null) {
-        clearTimeout(timerRef.current);
-      }
-    };
-  }, []);
-  return {
-    onMouseDown: start,
-    onMouseUp: cancel,
-    onMouseLeave: cancel,
-    onTouchStart: start,
-    onTouchEnd: cancel
-  };
-}
-function useGesture(ref, options = {}) {
-  const {
-    onTap,
-    onDoubleTap,
-    onPinch,
-    onPinching,
-    onRotate,
-    onRotating,
-    doubleTapDelay = 300,
-    tapMovementThreshold = 10,
-    preventDefault = false
-  } = options;
-  const touchStartRef = react.useRef(
-    null
-  );
-  const lastTapRef = react.useRef(0);
-  const initialPinchDistanceRef = react.useRef(0);
-  const initialRotationRef = react.useRef(0);
-  const onTapRef = react.useRef(onTap);
-  const onDoubleTapRef = react.useRef(onDoubleTap);
-  const onPinchRef = react.useRef(onPinch);
-  const onPinchingRef = react.useRef(onPinching);
-  const onRotateRef = react.useRef(onRotate);
-  const onRotatingRef = react.useRef(onRotating);
-  react.useEffect(() => {
-    onTapRef.current = onTap;
-  }, [onTap]);
-  react.useEffect(() => {
-    onDoubleTapRef.current = onDoubleTap;
-  }, [onDoubleTap]);
-  react.useEffect(() => {
-    onPinchRef.current = onPinch;
-  }, [onPinch]);
-  react.useEffect(() => {
-    onPinchingRef.current = onPinching;
-  }, [onPinching]);
-  react.useEffect(() => {
-    onRotateRef.current = onRotate;
-  }, [onRotate]);
-  react.useEffect(() => {
-    onRotatingRef.current = onRotating;
-  }, [onRotating]);
-  react.useEffect(() => {
-    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]);
-}
-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 = react.useRef(
-    null
-  );
-  const isSwiping = react.useRef(false);
-  const onSwipeRef = react.useRef(onSwipe);
-  const onSwipeLeftRef = react.useRef(onSwipeLeft);
-  const onSwipeRightRef = react.useRef(onSwipeRight);
-  const onSwipeUpRef = react.useRef(onSwipeUp);
-  const onSwipeDownRef = react.useRef(onSwipeDown);
-  const onSwipingRef = react.useRef(onSwiping);
-  const onSwipeStartRef = react.useRef(onSwipeStart);
-  const onSwipeEndRef = react.useRef(onSwipeEnd);
-  react.useEffect(() => {
-    onSwipeRef.current = onSwipe;
-  }, [onSwipe]);
-  react.useEffect(() => {
-    onSwipeLeftRef.current = onSwipeLeft;
-  }, [onSwipeLeft]);
-  react.useEffect(() => {
-    onSwipeRightRef.current = onSwipeRight;
-  }, [onSwipeRight]);
-  react.useEffect(() => {
-    onSwipeUpRef.current = onSwipeUp;
-  }, [onSwipeUp]);
-  react.useEffect(() => {
-    onSwipeDownRef.current = onSwipeDown;
-  }, [onSwipeDown]);
-  react.useEffect(() => {
-    onSwipingRef.current = onSwiping;
-  }, [onSwiping]);
-  react.useEffect(() => {
-    onSwipeStartRef.current = onSwipeStart;
-  }, [onSwipeStart]);
-  react.useEffect(() => {
-    onSwipeEndRef.current = onSwipeEnd;
-  }, [onSwipeEnd]);
-  react.useEffect(() => {
-    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]);
-}
-function usePullToRefresh(onRefresh, options = {}) {
-  const { threshold = 80 } = options;
-  const containerRef = react.useRef(null);
-  const [isPulling, setIsPulling] = react.useState(false);
-  const [progress, setProgress] = react.useState(0);
-  const startYRef = react.useRef(null);
-  const thresholdReachedRef = react.useRef(false);
-  const onRefreshRef = react.useRef(onRefresh);
-  react.useEffect(() => {
-    onRefreshRef.current = onRefresh;
-  }, [onRefresh]);
-  const handleTouchStart = react.useCallback((e) => {
-    const el = containerRef.current;
-    if (!el || el.scrollTop > 0) return;
-    startYRef.current = e.touches[0].clientY;
-    thresholdReachedRef.current = false;
-  }, []);
-  const handleTouchMove = react.useCallback(
-    (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 = react.useCallback(async () => {
-    setIsPulling(false);
-    setProgress(0);
-    startYRef.current = null;
-    if (thresholdReachedRef.current) {
-      thresholdReachedRef.current = false;
-      await onRefreshRef.current();
-    }
-  }, []);
-  react.useEffect(() => {
-    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 };
-}
-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] = react.useState(
-    getRemaining
-  );
-  react.useEffect(() => {
-    const id = setInterval(() => setRemaining(getRemaining()), 1e3);
-    return () => clearInterval(id);
-  }, [endDate]);
-  return remaining;
-}
-function useCamera() {
-  const isSupported = typeof navigator !== "undefined" && typeof navigator.mediaDevices !== "undefined" && typeof navigator.mediaDevices.getUserMedia === "function";
-  const videoRef = react.useRef(null);
-  const streamRef = react.useRef(null);
-  const mediaRecorderRef = react.useRef(null);
-  const chunksRef = react.useRef([]);
-  const currentFacingModeRef = react.useRef("environment");
-  const stopRecordingResolveRef = react.useRef(null);
-  const [stream, setStream] = react.useState(null);
-  const [isActive, setIsActive] = react.useState(false);
-  const [isCapturing, setIsCapturing] = react.useState(false);
-  const [error, setError] = react.useState(null);
-  const stopCamera = react.useCallback(() => {
-    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);
-  }, []);
-  react.useEffect(() => {
-    return () => {
-      stopCamera();
-    };
-  }, [stopCamera]);
-  const startCamera = react.useCallback(
-    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 = react.useCallback(() => {
-    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 = react.useCallback(() => {
-    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 = react.useCallback(() => {
-    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 = react.useCallback(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
-  };
-}
-var BULK_MAX_IDS = 100;
-function useBulkSelection({
-  items,
-  keyExtractor,
-  maxSelection = BULK_MAX_IDS
-}) {
-  const [selectedIds, setSelectedIds] = react.useState([]);
-  const allIds = react.useMemo(() => items.map(keyExtractor), [items, keyExtractor]);
-  const isSelected = react.useCallback(
-    (id) => selectedIds.includes(id),
-    [selectedIds]
-  );
-  const toggle = react.useCallback(
-    (id) => {
-      setSelectedIds((prev) => {
-        if (prev.includes(id)) return prev.filter((s) => s !== id);
-        if (prev.length >= maxSelection) return prev;
-        return [...prev, id];
-      });
-    },
-    [maxSelection]
-  );
-  const toggleAll = react.useCallback(() => {
-    setSelectedIds((prev) => {
-      const allSelected = prev.length === allIds.length && allIds.length > 0;
-      if (allSelected) return [];
-      return allIds.slice(0, maxSelection);
-    });
-  }, [allIds, maxSelection]);
-  const clearSelection = react.useCallback(() => setSelectedIds([]), []);
-  const isAllSelected = allIds.length > 0 && selectedIds.length === allIds.length;
-  const isIndeterminate = selectedIds.length > 0 && selectedIds.length < allIds.length;
-  return {
-    selectedIds,
-    selectedCount: selectedIds.length,
-    isSelected,
-    isAllSelected,
-    isIndeterminate,
-    toggle,
-    toggleAll,
-    clearSelection,
-    setSelectedIds
-  };
-}
-var NON_RESETTING_KEYS = ["page", "pageSize", "view"];
-function useUrlTable(options) {
-  var _a, _b, _c, _d;
-  const nativeRouter = navigation.useRouter();
-  const nativePathname = navigation.usePathname();
-  const nativeSearchParams = navigation.useSearchParams();
-  const router = (_a = options == null ? void 0 : options.router) != null ? _a : nativeRouter;
-  const pathname = (_b = options == null ? void 0 : options.pathname) != null ? _b : nativePathname;
-  const searchParams = (_c = options == null ? void 0 : options.searchParams) != null ? _c : nativeSearchParams;
-  const defaultsRef = react.useRef((_d = options == null ? void 0 : options.defaults) != null ? _d : {});
-  const defaults = defaultsRef.current;
-  const get = react.useCallback(
-    (key) => {
-      var _a2, _b2;
-      return (_b2 = (_a2 = searchParams.get(key)) != null ? _a2 : defaults[key]) != null ? _b2 : "";
-    },
-    [searchParams, defaults]
-  );
-  const getNumber = react.useCallback(
-    (key, fallback = 0) => {
-      const v = get(key);
-      if (!v) return fallback;
-      const n = Number(v);
-      return isNaN(n) ? fallback : n;
-    },
-    [get]
-  );
-  const buildParams = react.useCallback(
-    (updates) => {
-      const p = new URLSearchParams(searchParams.toString());
-      for (const [k, v] of Object.entries(updates)) {
-        if (v === "" || v === void 0) p.delete(k);
-        else p.set(k, v);
-      }
-      return p;
-    },
-    [searchParams]
-  );
-  const set = react.useCallback(
-    (key, value) => {
-      const p = buildParams({ [key]: value });
-      if (!NON_RESETTING_KEYS.includes(key)) {
-        p.set("page", "1");
-      }
-      router.replace(`${pathname}?${p.toString()}`);
-    },
-    [buildParams, pathname, router]
-  );
-  const setMany = react.useCallback(
-    (updates) => {
-      const p = buildParams(updates);
-      const keys = Object.keys(updates);
-      const allNonResetting = keys.every(
-        (k) => NON_RESETTING_KEYS.includes(k)
-      );
-      if (!allNonResetting && !keys.includes("page")) {
-        p.set("page", "1");
-      }
-      router.replace(`${pathname}?${p.toString()}`);
-    },
-    [buildParams, pathname, router]
-  );
-  const clear = react.useCallback(
-    (keys) => {
-      if (keys) {
-        const p = new URLSearchParams(searchParams.toString());
-        keys.forEach((k) => p.delete(k));
-        p.set("page", "1");
-        router.replace(`${pathname}?${p.toString()}`);
-      } else {
-        router.replace(pathname);
-      }
-    },
-    [searchParams, pathname, router]
-  );
-  const setPage = (page) => set("page", String(page));
-  const setPageSize = (size) => set("pageSize", String(size));
-  const setSort = (sort) => set("sort", sort);
-  const buildSieveParams = react.useCallback(
-    (sieveFilters) => {
-      const page = get("page") || "1";
-      const pageSize = get("pageSize") || defaults["pageSize"] || "25";
-      const sort = get("sort") || defaults["sort"] || "-createdAt";
-      const parts = new URLSearchParams();
-      if (sieveFilters) parts.set("filters", sieveFilters);
-      parts.set("sorts", sort);
-      parts.set("page", page);
-      parts.set("pageSize", pageSize);
-      return `?${parts.toString()}`;
-    },
-    [get, defaults]
-  );
-  const buildSearchParams = react.useCallback(() => {
-    const p = new URLSearchParams();
-    const addIfPresent = (k) => {
-      const v = get(k);
-      if (v) p.set(k, v);
-    };
-    ["q", "category", "minPrice", "maxPrice"].forEach(addIfPresent);
-    p.set("sort", get("sort") || defaults["sort"] || "-createdAt");
-    p.set("page", get("page") || "1");
-    p.set("pageSize", get("pageSize") || defaults["pageSize"] || "24");
-    return `?${p.toString()}`;
-  }, [get, defaults]);
-  return {
-    params: searchParams,
-    get,
-    getNumber,
-    set,
-    setMany,
-    clear,
-    setPage,
-    setPageSize,
-    setSort,
-    buildSieveParams,
-    buildSearchParams
-  };
-}
-function usePendingFilters({
-  table,
-  keys
-}) {
-  const parseValues = react.useCallback(
-    (key) => {
-      const raw = table.get(key);
-      return raw ? raw.split(",").filter(Boolean) : [];
-    },
-    [table]
-  );
-  const [pending, setPending] = react.useState(
-    () => Object.fromEntries(keys.map((k) => [k, parseValues(k)]))
-  );
-  const applied = react.useMemo(
-    () => Object.fromEntries(keys.map((k) => [k, parseValues(k)])),
-    [keys, parseValues]
-  );
-  const pendingCount = react.useMemo(
-    () => Object.values(pending).reduce((sum, arr) => sum + arr.length, 0),
-    [pending]
-  );
-  const appliedCount = react.useMemo(
-    () => Object.values(applied).reduce((sum, arr) => sum + arr.length, 0),
-    [applied]
-  );
-  const isDirty = react.useMemo(() => {
-    return keys.some((k) => {
-      var _a, _b;
-      const p = ((_a = pending[k]) != null ? _a : []).slice().sort();
-      const a = ((_b = applied[k]) != null ? _b : []).slice().sort();
-      return p.length !== a.length || p.some((v, i) => v !== a[i]);
-    });
-  }, [keys, pending, applied]);
-  const set = react.useCallback((key, values) => {
-    setPending((prev) => __spreadProps(__spreadValues({}, prev), { [key]: values }));
-  }, []);
-  const apply = react.useCallback(() => {
-    var _a;
-    const updates = { page: "1" };
-    for (const k of keys) {
-      updates[k] = ((_a = pending[k]) != null ? _a : []).join(",");
-    }
-    table.setMany(updates);
-  }, [keys, pending, table]);
-  const reset = react.useCallback(() => {
-    setPending(Object.fromEntries(keys.map((k) => [k, parseValues(k)])));
-  }, [keys, parseValues]);
-  const clear = react.useCallback(() => {
-    const empty = Object.fromEntries(keys.map((k) => [k, []]));
-    setPending(empty);
-    const updates = { page: "1" };
-    for (const k of keys) updates[k] = "";
-    table.setMany(updates);
-  }, [keys, table]);
-  return {
-    pending,
-    applied,
-    isDirty,
-    pendingCount,
-    appliedCount,
-    set,
-    apply,
-    reset,
-    clear
-  };
-}
-function usePendingTable(table, keys) {
-  const filters = usePendingFilters({ table, keys });
-  const pendingTable = react.useMemo(
-    () => ({
-      get: (key) => {
-        var _a, _b;
-        return (_b = (_a = filters.pending[key]) == null ? void 0 : _a[0]) != null ? _b : "";
-      },
-      set: (key, value) => {
-        filters.set(key, value ? [value] : []);
-      },
-      setMany: (updates) => {
-        for (const [k, v] of Object.entries(updates)) {
-          filters.set(k, v ? [v] : []);
-        }
-      }
-    }),
-    [filters.pending, filters.set]
-  );
-  return {
-    pendingTable,
-    filterActiveCount: filters.appliedCount,
-    onFilterApply: filters.apply,
-    onFilterClear: filters.clear,
-    onFilterReset: filters.reset
-  };
-}
-var UNSAVED_CHANGES_EVENT = "unsaved-changes:confirm";
-function useUnsavedChanges({
-  formValues,
-  initialValues,
-  extraDirty = false,
-  confirmFn,
-  beforeUnloadWarning = "You have unsaved changes. Leave?"
-}) {
-  const [savedSnapshot, setSavedSnapshot] = react.useState(initialValues);
-  const savedSnapshotRef = react.useRef(savedSnapshot);
-  savedSnapshotRef.current = savedSnapshot;
-  react.useEffect(() => {
-    if (initialValues && !savedSnapshotRef.current) {
-      setSavedSnapshot(initialValues);
-    }
-  }, [initialValues]);
-  const isFormDirty = (() => {
-    if (!savedSnapshot) return false;
-    return Object.keys(formValues).some(
-      (key) => {
-        var _a, _b;
-        return ((_a = formValues[key]) != null ? _a : "") !== ((_b = savedSnapshot[key]) != null ? _b : "");
-      }
-    );
-  })();
-  const isDirty = isFormDirty || extraDirty;
-  react.useEffect(() => {
-    if (!isDirty) return;
-    const handler = (e) => {
-      e.preventDefault();
-      e.returnValue = beforeUnloadWarning;
-      return beforeUnloadWarning;
-    };
-    window.addEventListener("beforeunload", handler);
-    return () => window.removeEventListener("beforeunload", handler);
-  }, [isDirty, beforeUnloadWarning]);
-  const markClean = react.useCallback(() => {
-    setSavedSnapshot(__spreadValues({}, formValues));
-  }, [formValues]);
-  const confirmLeave = react.useCallback(() => {
-    if (!isDirty) return Promise.resolve(true);
-    if (confirmFn) return confirmFn();
-    return Promise.resolve(
-      window.confirm("You have unsaved changes. Leave without saving?")
-    );
-  }, [isDirty, confirmFn]);
-  return { isDirty, isFormDirty, markClean, confirmLeave };
-}
-function useBulkAction(options) {
-  const [isLoading, setIsLoading] = react.useState(false);
-  const [result, setResult] = react.useState(null);
-  const [error, setError] = react.useState(null);
-  const [pendingPayload, setPendingPayload] = react.useState(null);
-  const optionsRef = react.useRef(options);
-  optionsRef.current = options;
-  const runMutation = react.useCallback(async (payload) => {
-    var _a, _b, _c, _d, _e;
-    setIsLoading(true);
-    setError(null);
-    try {
-      const res = await optionsRef.current.mutationFn(payload);
-      setResult(res);
-      await ((_b = (_a = optionsRef.current).onSuccess) == null ? void 0 : _b.call(_a, res, payload));
-    } catch (err) {
-      const error2 = err instanceof Error ? err : new Error((_c = err == null ? void 0 : err.message) != null ? _c : "Unexpected error");
-      setError(error2);
-      (_e = (_d = optionsRef.current).onError) == null ? void 0 : _e.call(_d, error2, payload);
-    } finally {
-      setIsLoading(false);
-    }
-  }, []);
-  const execute = react.useCallback(
-    async (payload) => {
-      if (optionsRef.current.requiresConfirm) {
-        setPendingPayload(payload);
-        return;
-      }
-      await runMutation(payload);
-    },
-    [runMutation]
-  );
-  const confirmAndExecute = react.useCallback(async () => {
-    if (!pendingPayload) return;
-    const payload = pendingPayload;
-    setPendingPayload(null);
-    await runMutation(payload);
-  }, [pendingPayload, runMutation]);
-  const cancelConfirm = react.useCallback(() => setPendingPayload(null), []);
-  const reset = react.useCallback(() => {
-    setResult(null);
-    setError(null);
-    setPendingPayload(null);
-  }, []);
-  return {
-    execute,
-    isLoading,
-    result,
-    error,
-    reset,
-    pendingPayload,
-    confirmAndExecute,
-    cancelConfirm
-  };
-}
-function useContainerGrid({
-  minItemWidth,
-  gap = 16,
-  minCols = 1,
-  maxCols = Infinity
-}) {
-  const containerRef = react.useRef(null);
-  const [cols, setCols] = react.useState(minCols);
-  react.useEffect(() => {
-    const el = containerRef.current;
-    if (!el) return;
-    const compute = (width) => {
-      const raw = Math.floor((width + gap) / (minItemWidth + gap));
-      const clamped = Math.min(
-        maxCols === Infinity ? raw : maxCols,
-        Math.max(minCols, raw)
-      );
-      setCols(clamped);
-    };
-    const ro = new ResizeObserver(([entry]) => {
-      if (entry) compute(entry.contentRect.width);
-    });
-    ro.observe(el);
-    compute(el.getBoundingClientRect().width);
-    return () => ro.disconnect();
-  }, [minItemWidth, gap, minCols, maxCols]);
-  return { containerRef, cols };
-}
-function useVisibleItems({
-  total,
-  minItemWidth,
-  arrowWidth = 36,
-  gap = 8
-}) {
-  const containerRef = react.useRef(null);
-  const [visibleCount, setVisibleCount] = react.useState(total);
-  const [scrollOffset, setScrollOffset] = react.useState(0);
-  react.useEffect(() => {
-    const el = containerRef.current;
-    if (!el) return;
-    const compute = (width) => {
-      const totalItemsWidth = total * minItemWidth + Math.max(0, total - 1) * gap;
-      if (totalItemsWidth <= width) {
-        setVisibleCount(total);
-        return;
-      }
-      const usable = width - 2 * (arrowWidth + gap);
-      const raw = Math.floor((usable + gap) / (minItemWidth + gap));
-      setVisibleCount(Math.max(1, raw));
-    };
-    const ro = new ResizeObserver(([entry]) => {
-      if (entry) compute(entry.contentRect.width);
-    });
-    ro.observe(el);
-    compute(el.getBoundingClientRect().width);
-    return () => ro.disconnect();
-  }, [total, minItemWidth, arrowWidth, gap]);
-  react.useEffect(() => {
-    setScrollOffset((o) => Math.min(o, Math.max(0, total - visibleCount)));
-  }, [visibleCount, total]);
-  const hasOverflow = visibleCount < total;
-  const scrollLeft = react.useCallback(
-    () => setScrollOffset((o) => Math.max(0, o - visibleCount)),
-    [visibleCount]
-  );
-  const scrollRight = react.useCallback(
-    () => setScrollOffset(
-      (o) => Math.min(total - visibleCount, o + visibleCount)
-    ),
-    [visibleCount, total]
-  );
-  return {
-    containerRef,
-    visibleCount,
-    hasOverflow,
-    scrollOffset,
-    setScrollOffset,
-    scrollLeft,
-    scrollRight,
-    canScrollLeft: scrollOffset > 0,
-    canScrollRight: scrollOffset + visibleCount < total
-  };
-}
-function useModalStack() {
-  const [stack, setStack] = react.useState([]);
-  const idCounter = react.useRef(0);
-  const open = react.useCallback((id, data) => {
-    setStack((prev) => [...prev, { id, data }]);
-  }, []);
-  const close = react.useCallback(() => {
-    setStack((prev) => prev.slice(0, -1));
-  }, []);
-  const closeAll = react.useCallback(() => {
-    setStack([]);
-  }, []);
-  const closeById = react.useCallback((id) => {
-    setStack((prev) => prev.filter((e) => e.id !== id));
-  }, []);
-  const peek = react.useCallback(() => {
-    return stack[stack.length - 1];
-  }, [stack]);
-  const isOpen = react.useCallback(
-    (id) => {
-      return stack.some((e) => e.id === id);
-    },
-    [stack]
-  );
-  const isTopmost = react.useCallback(
-    (id) => {
-      var _a;
-      return ((_a = stack[stack.length - 1]) == null ? void 0 : _a.id) === id;
-    },
-    [stack]
-  );
-  const nextId = react.useCallback(() => {
-    idCounter.current++;
-    return `modal-${idCounter.current}`;
-  }, []);
-  return {
-    stack,
-    open,
-    close,
-    closeAll,
-    closeById,
-    peek,
-    isOpen,
-    isTopmost,
-    nextId,
-    depth: stack.length
-  };
-}
-
-// src/core/Logger.ts
-var Logger = class _Logger {
-  constructor(options) {
-    this.logs = [];
-    this.levelPriority = {
-      debug: 0,
-      info: 1,
-      warn: 2,
-      error: 3
-    };
-    var _a, _b, _c, _d, _e;
-    const fileUrl = (_a = options == null ? void 0 : options.logFileUrl) != null ? _a : (options == null ? void 0 : options.enableFileLogging) ? "/api/logs/write" : void 0;
-    this.options = {
-      minLevel: (_b = options == null ? void 0 : options.minLevel) != null ? _b : "debug",
-      enableConsole: (_c = options == null ? void 0 : options.enableConsole) != null ? _c : true,
-      enableStorage: (_d = options == null ? void 0 : options.enableStorage) != null ? _d : false,
-      logFileUrl: fileUrl,
-      maxEntries: (_e = options == null ? void 0 : options.maxEntries) != null ? _e : 1e3,
-      sanitizer: options == null ? void 0 : options.sanitizer
-    };
-  }
-  /** Get singleton instance */
-  static getInstance(options) {
-    if (!_Logger.instance) {
-      _Logger.instance = new _Logger(options);
-    }
-    return _Logger.instance;
-  }
-  /** Set or update the data sanitizer (e.g., for PII redaction). */
-  static setSanitizer(fn) {
-    _Logger.getInstance().options.sanitizer = fn;
-  }
-  shouldLog(level) {
-    return this.levelPriority[level] >= this.levelPriority[this.options.minLevel];
-  }
-  addLog(level, message, data) {
-    if (!this.shouldLog(level)) return;
-    const sanitized = data && this.options.sanitizer ? this.options.sanitizer(data) : data;
-    const entry = {
-      level,
-      message,
-      timestamp: /* @__PURE__ */ new Date(),
-      data: sanitized
-    };
-    this.logs.push(entry);
-    if (this.logs.length > this.options.maxEntries) {
-      this.logs.shift();
-    }
-    if (this.options.enableConsole) {
-      this.logToConsole(entry);
-    }
-    if (this.options.enableStorage && typeof window !== "undefined") {
-      this.saveToStorage();
-    }
-    if (this.options.logFileUrl && level === "error") {
-      this.writeToFile(entry).catch(() => {
-      });
-    }
-  }
-  logToConsole(entry) {
-    const prefix = `[${entry.level.toUpperCase()}] ${entry.timestamp.toISOString()}`;
-    const message = `${prefix} ${entry.message}`;
-    switch (entry.level) {
-      case "debug":
-        console.debug(message, entry.data);
-        break;
-      case "info":
-        console.info(message, entry.data);
-        break;
-      case "warn":
-        console.warn(message, entry.data);
-        break;
-      case "error":
-        console.error(message, entry.data);
-        break;
-    }
-  }
-  saveToStorage() {
-    try {
-      localStorage.setItem("app_logs", JSON.stringify(this.logs));
-    } catch (e) {
-    }
-  }
-  async writeToFile(entry) {
-    if (typeof window === "undefined" || !this.options.logFileUrl) return;
-    try {
-      await fetch(this.options.logFileUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          level: entry.level,
-          message: entry.message,
-          timestamp: entry.timestamp.toISOString(),
-          data: entry.data
-        })
-      });
-    } catch (e) {
-    }
-  }
-  debug(message, data) {
-    this.addLog("debug", message, data);
-  }
-  info(message, data) {
-    this.addLog("info", message, data);
-  }
-  warn(message, data) {
-    this.addLog("warn", message, data);
-  }
-  error(message, data) {
-    this.addLog("error", message, data);
-  }
-  getLogs(level) {
-    if (level) return this.logs.filter((log) => log.level === level);
-    return [...this.logs];
-  }
-  clear() {
-    this.logs = [];
-    if (this.options.enableStorage && typeof window !== "undefined") {
-      localStorage.removeItem("app_logs");
-    }
-  }
-  export() {
-    return JSON.stringify(this.logs, null, 2);
-  }
-  getStats() {
-    return {
-      debug: this.logs.filter((l) => l.level === "debug").length,
-      info: this.logs.filter((l) => l.level === "info").length,
-      warn: this.logs.filter((l) => l.level === "warn").length,
-      error: this.logs.filter((l) => l.level === "error").length
-    };
-  }
-};
-Logger.getInstance();
-
-// src/core/Queue.ts
-Logger.getInstance();
-
-// src/core/StorageManager.ts
-var sLogger = Logger.getInstance();
-var _StorageManager = class _StorageManager {
-  constructor(prefix = "app_") {
-    this.prefix = prefix;
-  }
-  /**
-   * Get-or-create a StorageManager for the given prefix.
-   * Each prefix returns an independent instance.
-   */
-  static getInstance(prefix = "") {
-    if (!_StorageManager.instances.has(prefix)) {
-      _StorageManager.instances.set(prefix, new _StorageManager(prefix));
-    }
-    return _StorageManager.instances.get(prefix);
-  }
-  getStorage(type) {
-    try {
-      if (typeof window === "undefined") return null;
-      const storage = type === "local" ? window.localStorage : window.sessionStorage;
-      return storage != null ? storage : null;
-    } catch (e) {
-      return null;
-    }
-  }
-  generateKey(key) {
-    return `${this.prefix}${key}`;
-  }
-  set(key, value, options) {
-    var _a;
-    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
-    if (!storage) return false;
-    try {
-      storage.setItem(this.generateKey(key), JSON.stringify(value));
-      return true;
-    } catch (error) {
-      sLogger.error("StorageManager.set error", { error });
-      return false;
-    }
-  }
-  get(key, options) {
-    var _a;
-    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
-    if (!storage) return null;
-    try {
-      const item = storage.getItem(this.generateKey(key));
-      if (item === null) return null;
-      return JSON.parse(item);
-    } catch (error) {
-      sLogger.error("StorageManager.get error", { error });
-      return null;
-    }
-  }
-  remove(key, options) {
-    var _a;
-    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
-    if (!storage) return false;
-    try {
-      storage.removeItem(this.generateKey(key));
-      return true;
-    } catch (error) {
-      sLogger.error("StorageManager.remove error", { error });
-      return false;
-    }
-  }
-  clear(options) {
-    var _a;
-    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
-    if (!storage) return false;
-    try {
-      const keys = Object.keys(storage);
-      keys.forEach((k) => {
-        if (k.startsWith(this.prefix)) storage.removeItem(k);
-      });
-      return true;
-    } catch (error) {
-      sLogger.error("StorageManager.clear error", { error });
-      return false;
-    }
-  }
-  has(key, options) {
-    return this.get(key, options) !== null;
-  }
-  keys(options) {
-    var _a;
-    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
-    if (!storage) return [];
-    const result = [];
-    for (let i = 0; i < storage.length; i++) {
-      const k = storage.key(i);
-      if (k == null ? void 0 : k.startsWith(this.prefix)) {
-        result.push(k.slice(this.prefix.length));
-      }
-    }
-    return result;
-  }
-  size(options) {
-    var _a, _b;
-    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
-    if (!storage) return 0;
-    let bytes = 0;
-    for (let i = 0; i < storage.length; i++) {
-      const k = storage.key(i);
-      if (k == null ? void 0 : k.startsWith(this.prefix)) {
-        const v = storage.getItem(k);
-        bytes += k.length + ((_b = v == null ? void 0 : v.length) != null ? _b : 0);
-      }
-    }
-    return bytes;
-  }
-  isAvailable(type = "local") {
-    const storage = this.getStorage(type);
-    if (!storage) return false;
-    try {
-      const testKey = "__storage_test__";
-      storage.setItem(testKey, "1");
-      storage.removeItem(testKey);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-  getAll(options) {
-    var _a;
-    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
-    if (!storage) return {};
-    const result = {};
-    for (let i = 0; i < storage.length; i++) {
-      const k = storage.key(i);
-      if (k == null ? void 0 : k.startsWith(this.prefix)) {
-        const v = this.get(k.slice(this.prefix.length), options);
-        if (v !== null) result[k.slice(this.prefix.length)] = v;
-      }
-    }
-    return result;
-  }
-};
-/** Per-prefix instance map — prevents namespace collisions */
-_StorageManager.instances = /* @__PURE__ */ new Map();
-var StorageManager = _StorageManager;
-StorageManager.getInstance("");
-
-// src/core/EventBus.ts
-Logger.getInstance();
-
-// src/security/authorization.ts
-init_errors();
-
-// src/monitoring/error-tracking.ts
-function getTracker() {
-  var _a;
-  return (_a = globalThis.__mohasinac_error_tracker__) != null ? _a : ((error, category, severity, context) => {
-    const msg = error instanceof Error ? error.message : error;
-    console.error(`[${severity.toUpperCase()}][${category}] ${msg}`, context);
-  });
-}
-function trackError(error, category = "unknown" /* UNKNOWN */, severity = "medium" /* MEDIUM */, context) {
-  getTracker()(error, category, severity, context);
-}
-
-// src/monitoring/client-logger.ts
-init_errors();
-
-// src/monitoring/server-logger.ts
-init_errors();
-function DefaultFallback({
-  error,
-  onReset
-}) {
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    "div",
-    {
-      role: "alert",
-      style: {
-        display: "flex",
-        flexDirection: "column",
-        alignItems: "center",
-        justifyContent: "center",
-        minHeight: "100vh",
-        padding: "2rem",
-        textAlign: "center"
-      },
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx("h1", { style: { fontSize: "1.5rem", marginBottom: "0.5rem" }, children: "Something went wrong" }),
-        /* @__PURE__ */ jsxRuntime.jsx("p", { style: { marginBottom: "1.5rem", opacity: 0.7 }, children: "An unexpected error occurred. Please try again." }),
-        process.env.NODE_ENV === "development" && error && /* @__PURE__ */ jsxRuntime.jsx(
-          "pre",
-          {
-            style: {
-              fontSize: "0.75rem",
-              padding: "1rem",
-              background: "#f3f4f6",
-              borderRadius: "0.5rem",
-              textAlign: "left",
-              maxWidth: "40rem",
-              overflow: "auto",
-              marginBottom: "1.5rem"
-            },
-            children: error.message
-          }
-        ),
-        /* @__PURE__ */ jsxRuntime.jsx("button", { onClick: onReset, type: "button", children: "Try again" })
-      ]
-    }
-  );
-}
-var ErrorBoundary = class extends react.Component {
-  constructor(props) {
-    super(props);
-    this.log = Logger.getInstance({ enableConsole: true });
-    this.handleReset = () => {
-      this.setState({ hasError: false, error: null });
-    };
-    this.state = { hasError: false, error: null };
-  }
-  static getDerivedStateFromError(error) {
-    return { hasError: true, error };
-  }
-  componentDidCatch(error, errorInfo) {
-    var _a, _b;
-    this.log.error("ErrorBoundary caught an error", {
-      error: error.message,
-      stack: error.stack,
-      componentStack: errorInfo.componentStack,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    trackError(error, "ui" /* UI */, "high" /* HIGH */);
-    (_b = (_a = this.props).onError) == null ? void 0 : _b.call(_a, error, errorInfo);
-  }
-  render() {
-    if (!this.state.hasError) {
-      return this.props.children;
-    }
-    if (this.props.renderFallback) {
-      return this.props.renderFallback(this.state.error, this.handleReset);
-    }
-    if (this.props.fallback) {
-      return this.props.fallback;
-    }
-    return /* @__PURE__ */ jsxRuntime.jsx(DefaultFallback, { error: this.state.error, onReset: this.handleReset });
-  }
-};
-
-exports.ErrorBoundary = ErrorBoundary;
-exports.UNSAVED_CHANGES_EVENT = UNSAVED_CHANGES_EVENT;
-exports.useBreakpoint = useBreakpoint;
-exports.useBulkAction = useBulkAction;
-exports.useBulkSelection = useBulkSelection;
-exports.useCamera = useCamera;
-exports.useClickOutside = useClickOutside;
-exports.useContainerGrid = useContainerGrid;
-exports.useCountdown = useCountdown;
-exports.useGesture = useGesture;
-exports.useKeyPress = useKeyPress;
-exports.useLongPress = useLongPress;
-exports.useMediaQuery = useMediaQuery;
-exports.useModalStack = useModalStack;
-exports.usePendingFilters = usePendingFilters;
-exports.usePendingTable = usePendingTable;
-exports.usePullToRefresh = usePullToRefresh;
-exports.useSwipe = useSwipe;
-exports.useUnsavedChanges = useUnsavedChanges;
-exports.useUrlTable = useUrlTable;
-exports.useVisibleItems = useVisibleItems;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map