usethishook 0.1.0

package/dist/index.js

@@ -0,0 +1,824 @@
+import { useState, useCallback, useEffect, useRef, useSyncExternalStore, useMemo } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/hooks/useToggle.ts
+var useToggle = (initialValue = false) => {
+  const [value, setValue] = useState(initialValue);
+  const toggle = useCallback(() => {
+    setValue((previous) => !previous);
+  }, []);
+  const setTrue = useCallback(() => {
+    setValue(true);
+  }, []);
+  const setFalse = useCallback(() => {
+    setValue(false);
+  }, []);
+  return { value, toggle, setTrue, setFalse, setValue };
+};
+var useCounter = (initialValue = 0, step = 1) => {
+  const [count, setCount] = useState(initialValue);
+  const increment = useCallback(() => {
+    setCount((previous) => previous + step);
+  }, [step]);
+  const decrement = useCallback(() => {
+    setCount((previous) => previous - step);
+  }, [step]);
+  const reset = useCallback(() => {
+    setCount(initialValue);
+  }, [initialValue]);
+  return { count, increment, decrement, reset, setCount };
+};
+var useDisclosure = (initialOpen = false) => {
+  const [isOpen, setIsOpen] = useState(initialOpen);
+  const open = useCallback(() => {
+    setIsOpen(true);
+  }, []);
+  const close = useCallback(() => {
+    setIsOpen(false);
+  }, []);
+  const toggle = useCallback(() => {
+    setIsOpen((previous) => !previous);
+  }, []);
+  return { isOpen, open, close, toggle };
+};
+var useDebounce = (value, delayMs = 300) => {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const timeoutId = window.setTimeout(() => {
+      setDebouncedValue(value);
+    }, delayMs);
+    return () => {
+      window.clearTimeout(timeoutId);
+    };
+  }, [value, delayMs]);
+  return debouncedValue;
+};
+var usePrevious = (value) => {
+  const currentRef = useRef(value);
+  const previousRef = useRef(void 0);
+  if (currentRef.current !== value) {
+    previousRef.current = currentRef.current;
+    currentRef.current = value;
+  }
+  return previousRef.current;
+};
+var useInterval = (callback, delayMs) => {
+  const savedCallback = useRef(callback);
+  useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    if (delayMs === null) return;
+    const intervalId = window.setInterval(() => {
+      savedCallback.current();
+    }, delayMs);
+    return () => {
+      window.clearInterval(intervalId);
+    };
+  }, [delayMs]);
+};
+function subscribe(onStoreChange) {
+  window.addEventListener("online", onStoreChange);
+  window.addEventListener("offline", onStoreChange);
+  return () => {
+    window.removeEventListener("online", onStoreChange);
+    window.removeEventListener("offline", onStoreChange);
+  };
+}
+function getSnapshot() {
+  return navigator.onLine;
+}
+function getServerSnapshot() {
+  return true;
+}
+var useOnlineStatus = () => useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+var useMediaQuery = (query) => {
+  const [matches, setMatches] = useState(() => {
+    if (typeof window === "undefined") return false;
+    return window.matchMedia(query).matches;
+  });
+  useEffect(() => {
+    const mediaQueryList = window.matchMedia(query);
+    const handleChange = (event) => {
+      setMatches(event.matches);
+    };
+    setMatches(mediaQueryList.matches);
+    mediaQueryList.addEventListener("change", handleChange);
+    return () => {
+      mediaQueryList.removeEventListener("change", handleChange);
+    };
+  }, [query]);
+  return matches;
+};
+var useWindowSize = () => {
+  const [size, setSize] = useState(() => {
+    if (typeof window === "undefined") return { width: 0, height: 0 };
+    return { width: window.innerWidth, height: window.innerHeight };
+  });
+  useEffect(() => {
+    const handleResize = () => {
+      setSize({ width: window.innerWidth, height: window.innerHeight });
+    };
+    window.addEventListener("resize", handleResize);
+    return () => {
+      window.removeEventListener("resize", handleResize);
+    };
+  }, []);
+  return size;
+};
+var useOnClickOutside = (ref, handler) => {
+  useEffect(() => {
+    const listener = (event) => {
+      const element = ref.current;
+      if (!element || element.contains(event.target)) return;
+      handler(event);
+    };
+    document.addEventListener("mousedown", listener);
+    document.addEventListener("touchstart", listener);
+    return () => {
+      document.removeEventListener("mousedown", listener);
+      document.removeEventListener("touchstart", listener);
+    };
+  }, [handler, ref]);
+};
+var useCopyToClipboard = () => {
+  const [copiedText, setCopiedText] = useState(null);
+  const copy = useCallback(async (text) => {
+    if (!navigator.clipboard) return false;
+    try {
+      await navigator.clipboard.writeText(text);
+      setCopiedText(text);
+      return true;
+    } catch {
+      setCopiedText(null);
+      return false;
+    }
+  }, []);
+  const reset = useCallback(() => {
+    setCopiedText(null);
+  }, []);
+  return { copiedText, copy, reset };
+};
+function readValue(key, fallback) {
+  if (typeof window === "undefined") return fallback;
+  try {
+    const item = window.localStorage.getItem(key);
+    return item === null ? fallback : JSON.parse(item);
+  } catch {
+    return fallback;
+  }
+}
+var useLocalStorage = (key, initialValue) => {
+  const initialValueRef = useRef(initialValue);
+  initialValueRef.current = initialValue;
+  const [storedValue, setStoredValue] = useState(() => readValue(key, initialValue));
+  const setValue = useCallback(
+    (value) => {
+      setStoredValue((previous) => {
+        const nextValue = value instanceof Function ? value(previous) : value;
+        try {
+          window.localStorage.setItem(key, JSON.stringify(nextValue));
+        } catch {
+        }
+        return nextValue;
+      });
+    },
+    [key]
+  );
+  useEffect(() => {
+    setStoredValue(readValue(key, initialValueRef.current));
+  }, [key]);
+  return [storedValue, setValue];
+};
+var useDocumentTitle = (title) => {
+  useEffect(() => {
+    const previousTitle = document.title;
+    document.title = title;
+    return () => {
+      document.title = previousTitle;
+    };
+  }, [title]);
+};
+var useOverlay = (Overlay) => {
+  const [isOpen, setIsOpen] = useState(false);
+  const [props, setProps] = useState(null);
+  const resolverRef = useRef(null);
+  const previousOverflowRef = useRef("");
+  const open = useCallback((data) => {
+    setProps(data ?? {});
+    setIsOpen(true);
+    previousOverflowRef.current = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    return new Promise((resolve) => {
+      resolverRef.current = resolve;
+    });
+  }, []);
+  const close = useCallback((result) => {
+    setIsOpen(false);
+    document.body.style.overflow = previousOverflowRef.current;
+    if (!resolverRef.current) return;
+    resolverRef.current(result);
+    resolverRef.current = null;
+  }, []);
+  const render = () => {
+    if (!isOpen && !props) return null;
+    const overlayProps = props ?? {};
+    return /* @__PURE__ */ jsx(Overlay, { ...overlayProps, isOpen, close });
+  };
+  return { open, close, render };
+};
+var useStepFlow = (steps) => {
+  const [currentStepIndex, setCurrentStepIndex] = useState(0);
+  const [isActive, setIsActive] = useState(false);
+  const resultsRef = useRef([]);
+  const resolverRef = useRef(
+    null
+  );
+  const next = useCallback(() => {
+    setIsActive(true);
+    setCurrentStepIndex(0);
+    resultsRef.current = [];
+    return new Promise((resolve) => {
+      resolverRef.current = resolve;
+    });
+  }, []);
+  const completeStep = useCallback(
+    (stepData) => {
+      resultsRef.current = [...resultsRef.current, stepData];
+      setCurrentStepIndex((previous) => {
+        if (previous + 1 < steps.length) return previous + 1;
+        if (resolverRef.current) {
+          resolverRef.current(resultsRef.current);
+          resolverRef.current = null;
+        }
+        setIsActive(false);
+        return 0;
+      });
+    },
+    [steps.length]
+  );
+  const cancel = useCallback(() => {
+    if (resolverRef.current) {
+      resolverRef.current(null);
+      resolverRef.current = null;
+    }
+    setIsActive(false);
+    setCurrentStepIndex(0);
+    resultsRef.current = [];
+  }, []);
+  const renderCurrentStep = useCallback(
+    (extraProps = {}) => {
+      if (!isActive) return null;
+      const StepComponent = steps[currentStepIndex];
+      if (!StepComponent) return null;
+      return /* @__PURE__ */ jsx(
+        StepComponent,
+        {
+          ...extraProps,
+          stepIndex: currentStepIndex,
+          isLastStep: currentStepIndex === steps.length - 1,
+          onNext: completeStep,
+          onCancel: cancel
+        }
+      );
+    },
+    [cancel, completeStep, currentStepIndex, isActive, steps]
+  );
+  return { next, cancel, completeStep, renderCurrentStep, currentStepIndex, isActive };
+};
+var useAsyncSelect = () => {
+  const selectFile = useCallback((options = {}) => {
+    const { accept = "*", multiple = false } = options;
+    return new Promise((resolve) => {
+      const input = document.createElement("input");
+      input.type = "file";
+      input.accept = accept;
+      input.multiple = multiple;
+      input.style.display = "none";
+      let isSettled = false;
+      const settle = (value) => {
+        if (isSettled) return;
+        isSettled = true;
+        window.removeEventListener("focus", handleCancel);
+        input.remove();
+        resolve(value);
+      };
+      const handleChange = (event) => {
+        const files = event.target.files;
+        if (!files || files.length === 0) {
+          settle(null);
+          return;
+        }
+        settle(multiple ? Array.from(files) : files[0] ?? null);
+      };
+      const handleCancel = () => {
+        window.setTimeout(() => {
+          if (!input.files || input.files.length === 0) settle(null);
+        }, 300);
+      };
+      input.addEventListener("change", handleChange);
+      input.addEventListener("cancel", () => settle(null));
+      window.addEventListener("focus", handleCancel);
+      document.body.appendChild(input);
+      input.click();
+    });
+  }, []);
+  return selectFile;
+};
+var useStableCallback = (fn) => {
+  const fnRef = useRef(fn);
+  fnRef.current = fn;
+  const stable = useCallback((...args) => fnRef.current(...args), []);
+  return stable;
+};
+var useOnChange = (value, callback) => {
+  const callbackRef = useStableCallback(callback);
+  const previousRef = useRef(value);
+  const isFirstRender = useRef(true);
+  useEffect(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+      previousRef.current = value;
+      return;
+    }
+    if (Object.is(previousRef.current, value)) return;
+    const previous = previousRef.current;
+    previousRef.current = value;
+    callbackRef(value, previous);
+  }, [callbackRef, value]);
+};
+var useResetState = (source, initialValue) => {
+  const [state, setState] = useState(initialValue);
+  const [trackedSource, setTrackedSource] = useState(source);
+  if (trackedSource !== source) {
+    setTrackedSource(source);
+    setState(initialValue);
+  }
+  return [state, setState];
+};
+var useAsyncAction = (action) => {
+  const [isPending, setIsPending] = useState(false);
+  const [error, setError] = useState(null);
+  const [data, setData] = useState(void 0);
+  const runIdRef = useRef(0);
+  const stableAction = useStableCallback(action);
+  const run = useCallback(
+    async (...args) => {
+      const runId = ++runIdRef.current;
+      setIsPending(true);
+      setError(null);
+      try {
+        const result = await stableAction(...args);
+        if (runId !== runIdRef.current) return result;
+        setData(result);
+        setIsPending(false);
+        return result;
+      } catch (caught) {
+        if (runId !== runIdRef.current) throw caught;
+        setError(caught);
+        setIsPending(false);
+        throw caught;
+      }
+    },
+    [stableAction]
+  );
+  const reset = useCallback(() => {
+    runIdRef.current += 1;
+    setIsPending(false);
+    setError(null);
+    setData(void 0);
+  }, []);
+  return { run, isPending, error, data, reset };
+};
+var useDebouncedCallback = (callback, delayMs) => {
+  const stableCallback = useStableCallback(callback);
+  const timeoutRef = useRef(0);
+  const cancel = useCallback(() => {
+    window.clearTimeout(timeoutRef.current);
+  }, []);
+  const run = useCallback(
+    (...args) => {
+      cancel();
+      timeoutRef.current = window.setTimeout(() => {
+        stableCallback(...args);
+      }, delayMs);
+    },
+    [cancel, delayMs, stableCallback]
+  );
+  useEffect(() => cancel, [cancel]);
+  return [run, cancel];
+};
+function collectErrors(issues) {
+  const errors = {};
+  for (const issue of issues) {
+    const key = issue.path[0];
+    if (typeof key !== "string" && typeof key !== "number") continue;
+    const field = key;
+    if (errors[field]) continue;
+    errors[field] = issue.message;
+  }
+  return errors;
+}
+function isShallowEqual(left, right) {
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) return false;
+  return leftKeys.every((key) => Object.is(left[key], right[key]));
+}
+var useFields = (initialValues, schema) => {
+  const [values, setValues] = useState(initialValues);
+  const [errors, setErrors] = useState({});
+  const setField = useCallback((key, value) => {
+    setValues((previous) => ({ ...previous, [key]: value }));
+    setErrors((previous) => {
+      if (!previous[key]) return previous;
+      const next = { ...previous };
+      delete next[key];
+      return next;
+    });
+  }, []);
+  const reset = useCallback(() => {
+    setValues(initialValues);
+    setErrors({});
+  }, [initialValues]);
+  const isDirty = useMemo(() => !isShallowEqual(values, initialValues), [initialValues, values]);
+  const validate = useCallback(() => {
+    if (!schema) {
+      setErrors({});
+      return { ok: true, values };
+    }
+    const parsed = schema.safeParse(values);
+    if (parsed.success) {
+      setErrors({});
+      return { ok: true, values: parsed.data };
+    }
+    const nextErrors = collectErrors(parsed.error.issues);
+    setErrors(nextErrors);
+    return { ok: false, errors: nextErrors };
+  }, [schema, values]);
+  const submit = useCallback(
+    (onValid) => {
+      const result = validate();
+      if (!result.ok) return result;
+      void onValid(result.values);
+      return result;
+    },
+    [validate]
+  );
+  return { values, setField, setValues, reset, isDirty, errors, validate, submit };
+};
+var useList = (initialItems = []) => {
+  const [items, setItems] = useState(initialItems);
+  const insert = useCallback((item, index) => {
+    setItems((previous) => {
+      if (index === void 0 || index >= previous.length) return [...previous, item];
+      const next = [...previous];
+      next.splice(Math.max(0, index), 0, item);
+      return next;
+    });
+  }, []);
+  const update = useCallback((id, patch) => {
+    setItems(
+      (previous) => previous.map((item) => {
+        if (item.id !== id) return item;
+        return typeof patch === "function" ? patch(item) : { ...item, ...patch };
+      })
+    );
+  }, []);
+  const remove = useCallback((id) => {
+    setItems((previous) => previous.filter((item) => item.id !== id));
+  }, []);
+  const move = useCallback((fromIndex, toIndex) => {
+    setItems((previous) => {
+      if (fromIndex < 0 || toIndex < 0 || fromIndex >= previous.length || toIndex >= previous.length) {
+        return previous;
+      }
+      const next = [...previous];
+      const [moved] = next.splice(fromIndex, 1);
+      if (!moved) return previous;
+      next.splice(toIndex, 0, moved);
+      return next;
+    });
+  }, []);
+  const replace = useCallback((nextItems) => {
+    setItems(nextItems);
+  }, []);
+  return { items, insert, update, remove, move, replace, setItems };
+};
+var useSelection = ({ mode = "multiple", initial = [] } = {}) => {
+  const [selected, setSelected] = useState(initial);
+  const isSelected = useCallback((id) => selected.includes(id), [selected]);
+  const toggle = useCallback(
+    (id) => {
+      setSelected((previous) => {
+        if (mode === "single") return previous[0] === id ? [] : [id];
+        return previous.includes(id) ? previous.filter((item) => item !== id) : [...previous, id];
+      });
+    },
+    [mode]
+  );
+  const selectOnly = useCallback((id) => {
+    setSelected([id]);
+  }, []);
+  const selectAll = useCallback((ids) => {
+    setSelected(mode === "single" ? ids.slice(0, 1) : [...new Set(ids)]);
+  }, [mode]);
+  const clear = useCallback(() => {
+    setSelected([]);
+  }, []);
+  return { selected, isSelected, toggle, selectOnly, selectAll, clear, setSelected };
+};
+var SEARCH_EVENT = "usethishook:search";
+function subscribe2(onStoreChange) {
+  window.addEventListener("popstate", onStoreChange);
+  window.addEventListener(SEARCH_EVENT, onStoreChange);
+  return () => {
+    window.removeEventListener("popstate", onStoreChange);
+    window.removeEventListener(SEARCH_EVENT, onStoreChange);
+  };
+}
+function getSnapshot2() {
+  return window.location.search;
+}
+function getServerSnapshot2() {
+  return "";
+}
+function writeSearch(params) {
+  const query = params.toString();
+  const url = `${window.location.pathname}${query ? `?${query}` : ""}${window.location.hash}`;
+  window.history.replaceState(window.history.state, "", url);
+  window.dispatchEvent(new Event(SEARCH_EVENT));
+}
+function readParams(defaults, search) {
+  const params = new URLSearchParams(search);
+  const next = { ...defaults };
+  for (const key of Object.keys(defaults)) {
+    const value = params.get(String(key));
+    if (value !== null) next[key] = value;
+  }
+  return next;
+}
+var useSearchState = (defaults) => {
+  const search = useSyncExternalStore(subscribe2, getSnapshot2, getServerSnapshot2);
+  const values = useMemo(() => readParams(defaults, search), [defaults, search]);
+  const setValues = useCallback(
+    (update) => {
+      const current = readParams(defaults, window.location.search);
+      const next = typeof update === "function" ? update(current) : { ...current, ...update };
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(next)) {
+        if (value === "") continue;
+        params.set(key, value);
+      }
+      writeSearch(params);
+    },
+    [defaults]
+  );
+  return [values, setValues];
+};
+var backdropStyle = {
+  position: "fixed",
+  inset: 0,
+  zIndex: 40,
+  display: "grid",
+  placeItems: "center",
+  background: "rgba(0, 0, 0, 0.6)"
+};
+var panelStyle = {
+  width: "min(24rem, calc(100vw - 2rem))",
+  borderRadius: "1rem",
+  background: "#18181b",
+  color: "#fafafa",
+  padding: "1.25rem",
+  boxShadow: "0 24px 80px rgba(0,0,0,0.45)"
+};
+var DialogFrame = ({ title, children }) => /* @__PURE__ */ jsx("div", { style: backdropStyle, children: /* @__PURE__ */ jsxs("div", { role: "dialog", "aria-modal": "true", "aria-labelledby": "usethishook-dialog-title", style: panelStyle, children: [
+  /* @__PURE__ */ jsx("h2", { id: "usethishook-dialog-title", style: { margin: "0 0 0.75rem", fontSize: "1.05rem" }, children: title }),
+  children
+] }) });
+var buttonRowStyle = { display: "flex", gap: "0.5rem", marginTop: "1rem" };
+var dialogButtonRowStyle = buttonRowStyle;
+var primaryButtonStyle = {
+  border: "none",
+  borderRadius: "999px",
+  padding: "0.45rem 0.9rem",
+  background: "#7c3aed",
+  color: "white",
+  cursor: "pointer"
+};
+var ghostButtonStyle = {
+  border: "1px solid #3f3f46",
+  borderRadius: "999px",
+  padding: "0.45rem 0.9rem",
+  background: "transparent",
+  color: "white",
+  cursor: "pointer"
+};
+var ConfirmDialog = ({
+  title,
+  message,
+  confirmLabel = "Confirm",
+  cancelLabel = "Cancel",
+  danger,
+  isOpen,
+  close
+}) => {
+  if (!isOpen) return null;
+  return /* @__PURE__ */ jsxs(DialogFrame, { title, children: [
+    message && /* @__PURE__ */ jsx("p", { style: { margin: 0, color: "#d4d4d8", lineHeight: 1.5 }, children: message }),
+    /* @__PURE__ */ jsxs("div", { style: dialogButtonRowStyle, children: [
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          style: { ...primaryButtonStyle, background: danger ? "#e11d48" : primaryButtonStyle.background },
+          onClick: () => close(true),
+          children: confirmLabel
+        }
+      ),
+      /* @__PURE__ */ jsx("button", { type: "button", style: ghostButtonStyle, onClick: () => close(false), children: cancelLabel })
+    ] })
+  ] });
+};
+var useConfirm = () => {
+  const overlay = useOverlay(ConfirmDialog);
+  const confirm = (options) => overlay.open(options).then((result) => Boolean(result));
+  return { confirm, render: overlay.render };
+};
+var PromptDialog = ({
+  title,
+  message,
+  label = "Value",
+  initialValue = "",
+  confirmLabel = "Save",
+  cancelLabel = "Cancel",
+  isOpen,
+  close
+}) => {
+  const [value, setValue] = useState(initialValue);
+  useEffect(() => {
+    if (isOpen) setValue(initialValue);
+  }, [initialValue, isOpen]);
+  if (!isOpen) return null;
+  return /* @__PURE__ */ jsxs(DialogFrame, { title, children: [
+    message && /* @__PURE__ */ jsx("p", { style: { margin: "0 0 0.75rem", color: "#d4d4d8", lineHeight: 1.5 }, children: message }),
+    /* @__PURE__ */ jsxs("label", { style: { display: "grid", gap: "0.35rem", fontSize: "0.85rem" }, children: [
+      label,
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          value,
+          onChange: (event) => setValue(event.target.value),
+          style: {
+            borderRadius: "0.6rem",
+            border: "1px solid #3f3f46",
+            background: "#09090b",
+            color: "white",
+            padding: "0.5rem 0.7rem"
+          }
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("div", { style: dialogButtonRowStyle, children: [
+      /* @__PURE__ */ jsx("button", { type: "button", style: primaryButtonStyle, onClick: () => close(value), children: confirmLabel }),
+      /* @__PURE__ */ jsx("button", { type: "button", style: ghostButtonStyle, onClick: () => close(null), children: cancelLabel })
+    ] })
+  ] });
+};
+var usePrompt = () => {
+  const overlay = useOverlay(PromptDialog);
+  const prompt = (options) => overlay.open(options).then((result) => result ?? null);
+  return { prompt, render: overlay.render };
+};
+var useControllableState = ({
+  value,
+  defaultValue,
+  onChange
+}) => {
+  const [uncontrolled, setUncontrolled] = useState(defaultValue);
+  const isControlled = value !== void 0;
+  const current = isControlled ? value : uncontrolled;
+  const setValue = useCallback(
+    (update) => {
+      const next = typeof update === "function" ? update(current) : update;
+      if (!isControlled) setUncontrolled(next);
+      onChange?.(next);
+    },
+    [current, isControlled, onChange]
+  );
+  return [current, setValue];
+};
+var useUnsavedChanges = (isDirty, confirmLeave) => {
+  useEffect(() => {
+    if (!isDirty) return;
+    const handleBeforeUnload = (event) => {
+      event.preventDefault();
+      event.returnValue = "";
+    };
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    return () => window.removeEventListener("beforeunload", handleBeforeUnload);
+  }, [isDirty]);
+  const requestLeave = useCallback(
+    async (message = "Leave without saving?") => {
+      if (!isDirty) return true;
+      if (confirmLeave) return confirmLeave(message);
+      return window.confirm(message);
+    },
+    [confirmLeave, isDirty]
+  );
+  return { confirmLeave: requestLeave };
+};
+var useElementSize = () => {
+  const [node, setNode] = useState(null);
+  const [size, setSize] = useState({ width: 0, height: 0 });
+  const ref = useCallback((element) => {
+    setNode(element);
+  }, []);
+  useEffect(() => {
+    if (!node || typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (!entry) return;
+      const { width, height } = entry.contentRect;
+      setSize({ width, height });
+    });
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, [node]);
+  return { ref, width: size.width, height: size.height };
+};
+var useInView = (options = {}) => {
+  const { root = null, rootMargin = "0px", threshold = 0, once = false } = options;
+  const [node, setNode] = useState(null);
+  const [isInView, setIsInView] = useState(false);
+  const ref = useCallback((element) => {
+    setNode(element);
+  }, []);
+  useEffect(() => {
+    if (!node || typeof IntersectionObserver === "undefined") return;
+    const observer = new IntersectionObserver(
+      (entries) => {
+        const entry = entries[0];
+        if (!entry) return;
+        if (entry.isIntersecting) {
+          setIsInView(true);
+          if (once) observer.disconnect();
+          return;
+        }
+        if (!once) setIsInView(false);
+      },
+      { root, rootMargin, threshold }
+    );
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, [node, once, root, rootMargin, threshold]);
+  return { ref, isInView };
+};
+function pageCountOf(total, pageSize) {
+  if (pageSize <= 0) return 1;
+  return Math.max(1, Math.ceil(Math.max(0, total) / pageSize));
+}
+var usePagination = ({
+  total,
+  pageSize: initialPageSize = 10,
+  initialPage = 1
+}) => {
+  const [pageSize, setPageSizeState] = useState(initialPageSize);
+  const pageCount = pageCountOf(total, pageSize);
+  const [page, setPageState] = useState(initialPage);
+  const safePage = Math.min(page, pageCount);
+  if (safePage !== page) setPageState(safePage);
+  const setPage = useCallback(
+    (nextPage) => {
+      setPageState(Math.min(pageCount, Math.max(1, nextPage)));
+    },
+    [pageCount]
+  );
+  const setPageSize = useCallback((nextSize) => {
+    setPageSizeState(Math.max(1, nextSize));
+    setPageState(1);
+  }, []);
+  const next = useCallback(() => {
+    setPage(safePage + 1);
+  }, [safePage, setPage]);
+  const prev = useCallback(() => {
+    setPage(safePage - 1);
+  }, [safePage, setPage]);
+  return {
+    page: safePage,
+    pageSize,
+    total,
+    pageCount,
+    offset: (safePage - 1) * pageSize,
+    canNext: safePage < pageCount,
+    canPrev: safePage > 1,
+    setPage,
+    setPageSize,
+    next,
+    prev
+  };
+};
+
+export { useAsyncAction, useAsyncSelect, useConfirm, useControllableState, useCopyToClipboard, useCounter, useDebounce, useDebouncedCallback, useDisclosure, useDocumentTitle, useElementSize, useFields, useInView, useInterval, useList, useLocalStorage, useMediaQuery, useOnChange, useOnClickOutside, useOnlineStatus, useOverlay, usePagination, usePrevious, usePrompt, useResetState, useSearchState, useSelection, useStableCallback, useStepFlow, useToggle, useUnsavedChanges, useWindowSize };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map