@pelatform/ui.hook 0.1.0

package/dist/index.js

@@ -0,0 +1,876 @@
+"use client";
+
+// src/use-analytics.ts
+import { useCallback } from "react";
+var useAnalytics = () => {
+  const trackEvent = useCallback(
+    ({
+      event_name,
+      module,
+      submodule,
+      item_type,
+      item_id,
+      action,
+      delete_type
+    }) => {
+      if (typeof window !== "undefined" && window.gtag) {
+        window.gtag("event", event_name, {
+          module,
+          submodule,
+          module_path: `${module}/${submodule}`,
+          item_type,
+          item_id,
+          action,
+          delete_type,
+          category: "crud",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    },
+    []
+  );
+  const trackCreate = useCallback(
+    (module, submodule, itemType, itemId) => {
+      trackEvent({
+        event_name: "crud_create",
+        module,
+        submodule,
+        item_type: itemType,
+        item_id: itemId,
+        action: "create"
+      });
+    },
+    [trackEvent]
+  );
+  const trackUpdate = useCallback(
+    (module, submodule, itemType, itemId) => {
+      trackEvent({
+        event_name: "crud_update",
+        module,
+        submodule,
+        item_type: itemType,
+        item_id: itemId,
+        action: "update"
+      });
+    },
+    [trackEvent]
+  );
+  const trackDelete = useCallback(
+    (module, submodule, itemType, itemId, isHardDelete = false) => {
+      trackEvent({
+        event_name: "crud_delete",
+        module,
+        submodule,
+        item_type: itemType,
+        item_id: itemId,
+        action: "delete",
+        delete_type: isHardDelete ? "hard" : "soft"
+      });
+    },
+    [trackEvent]
+  );
+  return {
+    trackCreate,
+    trackUpdate,
+    trackDelete
+  };
+};
+
+// src/use-body-class.ts
+import { useEffect } from "react";
+var useBodyClasses = (className) => {
+  useEffect(() => {
+    if (!className.trim()) {
+      return;
+    }
+    const classList = className.split(/\s+/).filter(Boolean);
+    classList.forEach((cls) => {
+      document.body.classList.add(cls);
+    });
+    return () => {
+      classList.forEach((cls) => {
+        document.body.classList.remove(cls);
+      });
+    };
+  }, [className]);
+};
+
+// src/use-copy-to-clipboard.ts
+import * as React from "react";
+function useCopyToClipboard({
+  timeout = 2e3,
+  onCopy
+} = {}) {
+  const [copied, setCopied] = React.useState(false);
+  const copy = React.useCallback(
+    (value) => {
+      if (typeof window === "undefined" || !navigator.clipboard?.writeText) {
+        console.warn("Clipboard API not supported in this environment");
+        return;
+      }
+      if (!value) {
+        console.warn("Cannot copy empty value to clipboard");
+        return;
+      }
+      navigator.clipboard.writeText(value).then(
+        () => {
+          setCopied(true);
+          if (onCopy) {
+            onCopy();
+          }
+          setTimeout(() => {
+            setCopied(false);
+          }, timeout);
+        },
+        (error) => {
+          console.error("Failed to copy text to clipboard:", error);
+        }
+      );
+    },
+    [timeout, onCopy]
+  );
+  return {
+    /** Whether text was recently copied (true for timeout duration) */
+    copied,
+    /** Function to copy text to clipboard */
+    copy
+  };
+}
+
+// src/use-file-upload.ts
+import { useCallback as useCallback3, useRef, useState as useState2 } from "react";
+var useFileUpload = (options = {}) => {
+  const {
+    maxFiles = Number.POSITIVE_INFINITY,
+    maxSize = Number.POSITIVE_INFINITY,
+    accept = "*",
+    multiple = false,
+    initialFiles = [],
+    onFilesChange,
+    onFilesAdded,
+    onError
+  } = options;
+  const [state, setState] = useState2({
+    files: initialFiles.map((file) => ({
+      file,
+      id: file.id,
+      preview: file.url
+    })),
+    isDragging: false,
+    errors: []
+  });
+  const inputRef = useRef(null);
+  const validateFile = useCallback3(
+    (file) => {
+      if (file instanceof File) {
+        if (file.size > maxSize) {
+          return `File "${file.name}" exceeds the maximum size of ${formatBytes(maxSize)}.`;
+        }
+      } else if (file.size > maxSize) {
+        return `File "${file.name}" exceeds the maximum size of ${formatBytes(maxSize)}.`;
+      }
+      if (accept !== "*") {
+        const acceptedTypes = accept.split(",").map((type) => type.trim());
+        const fileType = file instanceof File ? file.type || "" : file.type;
+        const fileExtension = `.${file instanceof File ? file.name.split(".").pop() : file.name.split(".").pop()}`;
+        const isAccepted = acceptedTypes.some((type) => {
+          if (type.startsWith(".")) {
+            return fileExtension.toLowerCase() === type.toLowerCase();
+          }
+          if (type.endsWith("/*")) {
+            const baseType = type.split("/")[0];
+            return fileType.startsWith(`${baseType}/`);
+          }
+          return fileType === type;
+        });
+        if (!isAccepted) {
+          return `File "${file instanceof File ? file.name : file.name}" is not an accepted file type.`;
+        }
+      }
+      return null;
+    },
+    [accept, maxSize]
+  );
+  const createPreview = useCallback3(
+    (file) => {
+      if (file instanceof File) {
+        return URL.createObjectURL(file);
+      }
+      return file.url;
+    },
+    []
+  );
+  const generateUniqueId = useCallback3((file) => {
+    if (file instanceof File) {
+      return `${file.name}-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    }
+    return file.id;
+  }, []);
+  const clearFiles = useCallback3(() => {
+    setState((prev) => {
+      for (const file of prev.files) {
+        if (file.preview && file.file instanceof File && file.file.type.startsWith("image/")) {
+          URL.revokeObjectURL(file.preview);
+        }
+      }
+      if (inputRef.current) {
+        inputRef.current.value = "";
+      }
+      const newState = {
+        ...prev,
+        files: [],
+        errors: []
+      };
+      onFilesChange?.(newState.files);
+      return newState;
+    });
+  }, [onFilesChange]);
+  const addFiles = useCallback3(
+    (newFiles) => {
+      if (!newFiles || newFiles.length === 0) {
+        return;
+      }
+      const newFilesArray = Array.from(newFiles);
+      const errors = [];
+      setState((prev) => ({ ...prev, errors: [] }));
+      if (!multiple) {
+        clearFiles();
+      }
+      if (multiple && maxFiles !== Number.POSITIVE_INFINITY && state.files.length + newFilesArray.length > maxFiles) {
+        errors.push(`You can only upload a maximum of ${maxFiles} files.`);
+        onError?.(errors);
+        setState((prev) => ({ ...prev, errors }));
+        return;
+      }
+      const validFiles = [];
+      for (const file of newFilesArray) {
+        if (multiple) {
+          const isDuplicate = state.files.some(
+            (existingFile) => existingFile.file.name === file.name && existingFile.file.size === file.size
+          );
+          if (isDuplicate) {
+            return;
+          }
+        }
+        if (file.size > maxSize) {
+          errors.push(
+            multiple ? `Some files exceed the maximum size of ${formatBytes(maxSize)}.` : `File exceeds the maximum size of ${formatBytes(maxSize)}.`
+          );
+          continue;
+        }
+        const error = validateFile(file);
+        if (error) {
+          errors.push(error);
+        } else {
+          validFiles.push({
+            file,
+            id: generateUniqueId(file),
+            preview: createPreview(file)
+          });
+        }
+      }
+      if (validFiles.length > 0) {
+        onFilesAdded?.(validFiles);
+        setState((prev) => {
+          const newFiles2 = !multiple ? validFiles : [...prev.files, ...validFiles];
+          onFilesChange?.(newFiles2);
+          return {
+            ...prev,
+            files: newFiles2,
+            errors
+          };
+        });
+      } else if (errors.length > 0) {
+        onError?.(errors);
+        setState((prev) => ({
+          ...prev,
+          errors
+        }));
+      }
+      if (inputRef.current) {
+        inputRef.current.value = "";
+      }
+    },
+    [
+      state.files,
+      maxFiles,
+      multiple,
+      maxSize,
+      validateFile,
+      createPreview,
+      generateUniqueId,
+      clearFiles,
+      onFilesChange,
+      onFilesAdded,
+      onError
+    ]
+  );
+  const removeFile = useCallback3(
+    (id) => {
+      setState((prev) => {
+        const fileToRemove = prev.files.find((file) => file.id === id);
+        if (fileToRemove?.preview && fileToRemove.file instanceof File && fileToRemove.file.type.startsWith("image/")) {
+          URL.revokeObjectURL(fileToRemove.preview);
+        }
+        const newFiles = prev.files.filter((file) => file.id !== id);
+        onFilesChange?.(newFiles);
+        return {
+          ...prev,
+          files: newFiles,
+          errors: []
+        };
+      });
+    },
+    [onFilesChange]
+  );
+  const clearErrors = useCallback3(() => {
+    setState((prev) => ({
+      ...prev,
+      errors: []
+    }));
+  }, []);
+  const handleDragEnter = useCallback3((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setState((prev) => ({ ...prev, isDragging: true }));
+  }, []);
+  const handleDragLeave = useCallback3((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    if (e.currentTarget.contains(e.relatedTarget)) {
+      return;
+    }
+    setState((prev) => ({ ...prev, isDragging: false }));
+  }, []);
+  const handleDragOver = useCallback3((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+  }, []);
+  const handleDrop = useCallback3(
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      setState((prev) => ({ ...prev, isDragging: false }));
+      if (inputRef.current?.disabled) {
+        return;
+      }
+      if (e.dataTransfer.files && e.dataTransfer.files.length > 0) {
+        if (!multiple) {
+          const file = e.dataTransfer.files[0];
+          addFiles([file]);
+        } else {
+          addFiles(e.dataTransfer.files);
+        }
+      }
+    },
+    [addFiles, multiple]
+  );
+  const handleFileChange = useCallback3(
+    (e) => {
+      if (e.target.files && e.target.files.length > 0) {
+        addFiles(e.target.files);
+      }
+    },
+    [addFiles]
+  );
+  const openFileDialog = useCallback3(() => {
+    if (inputRef.current) {
+      inputRef.current.click();
+    }
+  }, []);
+  const getInputProps = useCallback3(
+    (props = {}) => {
+      return {
+        ...props,
+        type: "file",
+        onChange: handleFileChange,
+        accept: props.accept || accept,
+        multiple: props.multiple !== void 0 ? props.multiple : multiple,
+        ref: inputRef
+      };
+    },
+    [accept, multiple, handleFileChange]
+  );
+  return [
+    state,
+    {
+      addFiles,
+      removeFile,
+      clearFiles,
+      clearErrors,
+      handleDragEnter,
+      handleDragLeave,
+      handleDragOver,
+      handleDrop,
+      handleFileChange,
+      openFileDialog,
+      getInputProps
+    }
+  ];
+};
+var formatBytes = (bytes, decimals = 2) => {
+  if (bytes === 0) {
+    return "0 Bytes";
+  }
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const idx = Math.min(i, sizes.length - 1);
+  return `${Number.parseFloat((bytes / k ** idx).toFixed(dm))} ${sizes[idx]}`;
+};
+
+// src/use-hydrated.tsx
+import { useSyncExternalStore } from "react";
+function useHydrated() {
+  return useSyncExternalStore(
+    subscribe,
+    () => true,
+    () => false
+  );
+}
+function subscribe() {
+  return () => {
+  };
+}
+
+// src/use-media-query.ts
+import { useEffect as useEffect2, useState as useState3 } from "react";
+var getMatches = (query) => {
+  if (typeof window !== "undefined") {
+    return window.matchMedia(query).matches;
+  }
+  return false;
+};
+var useMediaQuery = (query) => {
+  const [matches, setMatches] = useState3(getMatches(query));
+  useEffect2(() => {
+    function handleChange() {
+      setMatches(getMatches(query));
+    }
+    const matchMedia = window.matchMedia(query);
+    handleChange();
+    matchMedia.addEventListener("change", handleChange);
+    return () => {
+      matchMedia.removeEventListener("change", handleChange);
+    };
+  }, [query]);
+  return matches;
+};
+
+// src/use-menu.ts
+var useMenu = (pathname) => {
+  const isActive = (path) => {
+    if (path && path === "/") {
+      return path === pathname;
+    }
+    return !!path && pathname.startsWith(path);
+  };
+  const hasActiveChild = (children) => {
+    if (!(children && Array.isArray(children))) {
+      return false;
+    }
+    return children.some(
+      (child) => child.path && isActive(child.path) || child.children && hasActiveChild(child.children)
+    );
+  };
+  const isItemActive = (item) => {
+    return (item.path ? isActive(item.path) : false) || (item.children ? hasActiveChild(item.children) : false);
+  };
+  const getCurrentItem = (items) => {
+    for (const item of items) {
+      if (item.path && isActive(item.path)) {
+        if (item.children && item.children.length > 0) {
+          const childMatch = getCurrentItem(item.children);
+          return childMatch || item;
+        }
+        return item;
+      }
+      if (item.children && item.children.length > 0) {
+        const childMatch = getCurrentItem(item.children);
+        if (childMatch) {
+          return childMatch;
+        }
+      }
+    }
+    return void 0;
+  };
+  const getBreadcrumb = (items) => {
+    const findBreadcrumb = (nodes, breadcrumb2 = []) => {
+      for (const item of nodes) {
+        const currentBreadcrumb = [...breadcrumb2, item];
+        if (item.path && isActive(item.path)) {
+          return currentBreadcrumb;
+        }
+        if (item.children && item.children.length > 0) {
+          const childBreadcrumb = findBreadcrumb(
+            item.children,
+            currentBreadcrumb
+          );
+          if (childBreadcrumb.length > currentBreadcrumb.length) {
+            return childBreadcrumb;
+          }
+        }
+      }
+      return breadcrumb2;
+    };
+    const breadcrumb = findBreadcrumb(items);
+    return breadcrumb.length > 0 ? breadcrumb : [];
+  };
+  const getChildren = (items, level) => {
+    const hasActiveChildAtLevel = (items2) => {
+      for (const item of items2) {
+        if (item.path && (item.path === pathname || item.path !== "/" && item.path !== "" && pathname.startsWith(item.path)) || item.children && hasActiveChildAtLevel(item.children)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    const findChildren = (items2, targetLevel, currentLevel = 0) => {
+      for (const item of items2) {
+        if (item.children) {
+          if (targetLevel === currentLevel && hasActiveChildAtLevel(item.children)) {
+            return item.children;
+          }
+          const children = findChildren(
+            item.children,
+            targetLevel,
+            currentLevel + 1
+          );
+          if (children) {
+            return children;
+          }
+        } else if (targetLevel === currentLevel && item.path && (item.path === pathname || item.path !== "/" && item.path !== "" && pathname.startsWith(item.path))) {
+          return items2;
+        }
+      }
+      return null;
+    };
+    return findChildren(items, level);
+  };
+  return {
+    isActive,
+    hasActiveChild,
+    isItemActive,
+    getCurrentItem,
+    getBreadcrumb,
+    getChildren
+  };
+};
+
+// src/use-mobile.ts
+import * as React2 from "react";
+var DEFAULT_MOBILE_BREAKPOINT = 1024;
+function useIsMobile(breakpoint = DEFAULT_MOBILE_BREAKPOINT) {
+  const [isMobile, setIsMobile] = React2.useState(
+    void 0
+  );
+  React2.useEffect(() => {
+    const mql = window.matchMedia(`(max-width: ${breakpoint - 1}px)`);
+    const onChange = () => {
+      setIsMobile(window.innerWidth < breakpoint);
+    };
+    mql.addEventListener("change", onChange);
+    setIsMobile(window.innerWidth < breakpoint);
+    return () => mql.removeEventListener("change", onChange);
+  }, [breakpoint]);
+  return !!isMobile;
+}
+
+// src/use-mounted.ts
+import * as React3 from "react";
+function useMounted() {
+  const [mounted, setMounted] = React3.useState(false);
+  React3.useEffect(() => {
+    setMounted(true);
+  }, []);
+  return mounted;
+}
+
+// src/use-mutation-observer.ts
+import * as React4 from "react";
+var DEFAULT_OPTIONS = {
+  /** Watch for attribute changes */
+  attributes: true,
+  /** Watch for text content changes */
+  characterData: true,
+  /** Watch for child element additions/removals */
+  childList: true,
+  /** Watch for changes in descendant elements */
+  subtree: true
+};
+var useMutationObserver = (ref, callback, options = DEFAULT_OPTIONS) => {
+  React4.useEffect(() => {
+    if (ref.current) {
+      const observer = new MutationObserver(callback);
+      observer.observe(ref.current, options);
+      return () => {
+        observer.disconnect();
+      };
+    }
+  }, [ref, callback, options]);
+};
+
+// src/use-recaptcha-v2.ts
+import { useCallback as useCallback4, useEffect as useEffect6, useRef as useRef2 } from "react";
+var RECAPTCHA_SCRIPT_ID = "recaptcha-v2-script";
+var scriptLoadPromise = null;
+function loadRecaptchaScript() {
+  if (scriptLoadPromise) {
+    return scriptLoadPromise;
+  }
+  scriptLoadPromise = new Promise((resolve) => {
+    if (document.getElementById(RECAPTCHA_SCRIPT_ID) && window.grecaptcha) {
+      resolve();
+      return;
+    }
+    window.onRecaptchaLoaded = () => {
+      resolve();
+    };
+    const script = document.createElement("script");
+    script.id = RECAPTCHA_SCRIPT_ID;
+    script.src = "https://www.google.com/recaptcha/api.js?onload=onRecaptchaLoaded&render=explicit";
+    script.async = true;
+    script.defer = true;
+    script.onerror = () => {
+      console.error("Failed to load reCAPTCHA script");
+      scriptLoadPromise = null;
+    };
+    document.head.appendChild(script);
+  });
+  return scriptLoadPromise;
+}
+function useRecaptchaV2(siteKey) {
+  const widgetId = useRef2(null);
+  const containerRef = useRef2(null);
+  const isRendered = useRef2(false);
+  const isInitializing = useRef2(false);
+  const initializeRecaptcha = useCallback4(async () => {
+    if (isInitializing.current) {
+      return;
+    }
+    if (!(containerRef.current && siteKey)) {
+      return;
+    }
+    isInitializing.current = true;
+    try {
+      if (widgetId.current !== null) {
+        const grecaptcha2 = window.grecaptcha;
+        if (grecaptcha2) {
+          try {
+            grecaptcha2.reset(widgetId.current);
+          } catch (error) {
+            console.error("Error resetting reCAPTCHA:", error);
+          }
+        }
+        widgetId.current = null;
+        isRendered.current = false;
+      }
+      await loadRecaptchaScript();
+      const grecaptcha = window.grecaptcha;
+      if (!grecaptcha) {
+        throw new Error("reCAPTCHA failed to load");
+      }
+      await new Promise((resolve) => {
+        grecaptcha.ready(() => resolve());
+      });
+      if (containerRef.current && !isRendered.current) {
+        widgetId.current = grecaptcha.render(containerRef.current, {
+          sitekey: siteKey,
+          size: "normal",
+          // Can be 'normal', 'compact', or 'invisible'
+          theme: "light"
+          // Can be 'light' or 'dark'
+        });
+        isRendered.current = true;
+      }
+    } catch (error) {
+      console.error("Error initializing reCAPTCHA:", error);
+    } finally {
+      isInitializing.current = false;
+    }
+  }, [siteKey]);
+  useEffect6(() => {
+    if (containerRef.current) {
+      void initializeRecaptcha();
+    }
+    return () => {
+      if (widgetId.current !== null) {
+        const grecaptcha = window.grecaptcha;
+        if (grecaptcha) {
+          try {
+            grecaptcha.reset(widgetId.current);
+          } catch (error) {
+            console.error("Error resetting reCAPTCHA on cleanup:", error);
+          }
+        }
+        widgetId.current = null;
+        isRendered.current = false;
+      }
+    };
+  }, [initializeRecaptcha]);
+  const getToken = () => {
+    const grecaptcha = window.grecaptcha;
+    if (!grecaptcha || widgetId.current === null) {
+      throw new Error("reCAPTCHA not initialized");
+    }
+    const token = grecaptcha.getResponse(widgetId.current);
+    if (!token) {
+      throw new Error("reCAPTCHA not completed");
+    }
+    return token;
+  };
+  const resetCaptcha = () => {
+    const grecaptcha = window.grecaptcha;
+    if (!grecaptcha || widgetId.current === null) {
+      return;
+    }
+    try {
+      grecaptcha.reset(widgetId.current);
+    } catch (error) {
+      console.error("Error resetting reCAPTCHA:", error);
+    }
+  };
+  return {
+    /** Ref to attach to the container div where reCAPTCHA will be rendered */
+    containerRef,
+    /** Function to get the reCAPTCHA response token */
+    getToken,
+    /** Function to reset the reCAPTCHA widget */
+    resetCaptcha,
+    /** Function to manually initialize reCAPTCHA (usually not needed) */
+    initializeRecaptcha
+  };
+}
+
+// src/use-remove-ga-params.ts
+import { useEffect as useEffect7 } from "react";
+function useRemoveGAParams() {
+  useEffect7(() => {
+    const url = new URL(window.location.href);
+    if (url.searchParams.has("_gl")) {
+      const timer = setTimeout(() => {
+        url.searchParams.delete("_gl");
+        window.history.replaceState({}, "", url.toString());
+      }, 2e3);
+      return () => clearTimeout(timer);
+    }
+  }, []);
+}
+
+// src/use-scroll-position.ts
+import { useEffect as useEffect8, useState as useState6 } from "react";
+var useScrollPosition = ({
+  targetRef
+} = {}) => {
+  const [scrollPosition, setScrollPosition] = useState6(0);
+  useEffect8(() => {
+    const target = targetRef?.current || document;
+    const scrollable = target === document ? window : target;
+    const updatePosition = () => {
+      const scrollY = target === document ? window.scrollY || window.pageYOffset : target.scrollTop;
+      setScrollPosition(scrollY);
+    };
+    scrollable.addEventListener("scroll", updatePosition, { passive: true });
+    updatePosition();
+    return () => {
+      scrollable.removeEventListener("scroll", updatePosition);
+    };
+  }, [targetRef]);
+  return scrollPosition;
+};
+
+// src/use-slider-input.ts
+import { useCallback as useCallback5, useState as useState7 } from "react";
+function useSliderInput({
+  minValue,
+  maxValue,
+  initialValue
+}) {
+  const [sliderValues, setSliderValues] = useState7(initialValue);
+  const [inputValues, setInputValues] = useState7(initialValue);
+  const handleSliderChange = useCallback5((values) => {
+    setSliderValues(values);
+    setInputValues(values);
+  }, []);
+  const handleInputChange = useCallback5(
+    (e, index) => {
+      const newValue = Number.parseFloat(e.target.value);
+      if (!Number.isNaN(newValue)) {
+        const updatedInputs = [...inputValues];
+        updatedInputs[index] = newValue;
+        setInputValues(updatedInputs);
+      }
+    },
+    [inputValues]
+  );
+  const validateAndUpdateValue = useCallback5(
+    (value, index) => {
+      const updatedSlider = [...sliderValues];
+      if (index === 0) {
+        updatedSlider[0] = Math.max(minValue, Math.min(value, sliderValues[1]));
+      } else {
+        updatedSlider[1] = Math.min(maxValue, Math.max(value, sliderValues[0]));
+      }
+      setSliderValues(updatedSlider);
+      setInputValues(updatedSlider);
+    },
+    [sliderValues, minValue, maxValue]
+  );
+  return {
+    /** Function to manually set slider values */
+    setSliderValues,
+    /** Function to manually set input values */
+    setInputValues,
+    /** Current slider values [min, max] */
+    sliderValues,
+    /** Current input values [min, max] */
+    inputValues,
+    /** Handler for slider value changes */
+    handleSliderChange,
+    /** Handler for input field changes */
+    handleInputChange,
+    /** Function to validate and update values from inputs */
+    validateAndUpdateValue
+  };
+}
+
+// src/use-viewport.ts
+import { useEffect as useEffect9, useState as useState8 } from "react";
+var useViewport = () => {
+  const [dimensions, setDimensions] = useState8(() => {
+    if (typeof window !== "undefined") {
+      return [window.innerHeight, window.innerWidth];
+    }
+    return [0, 0];
+  });
+  useEffect9(() => {
+    const handleResize = () => {
+      setDimensions([window.innerHeight, window.innerWidth]);
+    };
+    handleResize();
+    window.addEventListener("resize", handleResize, { passive: true });
+    return () => {
+      window.removeEventListener("resize", handleResize);
+    };
+  }, []);
+  return dimensions;
+};
+export {
+  formatBytes,
+  useAnalytics,
+  useBodyClasses,
+  useCopyToClipboard,
+  useFileUpload,
+  useHydrated,
+  useIsMobile,
+  useMediaQuery,
+  useMenu,
+  useMounted,
+  useMutationObserver,
+  useRecaptchaV2,
+  useRemoveGAParams,
+  useScrollPosition,
+  useSliderInput,
+  useViewport
+};