@omerdlw/base-framework 1.0.0

package/dist/hooks/index.js

@@ -0,0 +1,804 @@
+"use client";
+import { useLayoutEffect, useEffect, use, useRef, useCallback, useSyncExternalStore, useState, useTransition } from 'react';
+import 'clsx';
+import 'tailwind-merge';
+
+function useRequiredContext(context, hookName, providerName) {
+  const value = use(context);
+  if (value === null) {
+    throw new Error(`${hookName} must be used within ${providerName}`);
+  }
+  return value;
+}
+function useStore(store, selector = (state) => state, isEqual = Object.is) {
+  const cacheRef = useRef({
+    isEqual: null,
+    selected: void 0,
+    selector: null,
+    snapshot: null
+  });
+  const getSelectedSnapshot = useCallback(() => {
+    const snapshot = store.getSnapshot();
+    const cache = cacheRef.current;
+    if (cache.snapshot === snapshot && cache.selector === selector && cache.isEqual === isEqual) {
+      return cache.selected;
+    }
+    const selected = selector(snapshot);
+    if (cache.snapshot !== null && cache.isEqual === isEqual && isEqual(cache.selected, selected)) {
+      cache.snapshot = snapshot;
+      cache.selector = selector;
+      return cache.selected;
+    }
+    cacheRef.current = {
+      isEqual,
+      selected,
+      selector,
+      snapshot
+    };
+    return selected;
+  }, [isEqual, selector, store]);
+  return useSyncExternalStore(
+    store.subscribe,
+    getSelectedSnapshot,
+    getSelectedSnapshot
+  );
+}
+function useClickOutside(ref, callback) {
+  const handlePointer = useCallback(
+    (event) => {
+      if (ref?.current && !ref.current.contains(event.target)) {
+        callback?.(event);
+      }
+    },
+    [callback, ref]
+  );
+  useEffect(() => {
+    document.addEventListener("pointerdown", handlePointer);
+    return () => document.removeEventListener("pointerdown", handlePointer);
+  }, [handlePointer]);
+}
+
+// src/utils/dom.ts
+var isBrowser = typeof window !== "undefined";
+function report(scope, error, level = "error") {
+  if (process.env.NODE_ENV === "production" && typeof window !== "undefined") {
+    return;
+  }
+  console[level](`[${scope}]`, error);
+}
+
+// src/utils/user-message.ts
+var USER_MESSAGES = Object.freeze({
+  generic: "Something went wrong. Please try again",
+  network: "You appear to be offline. Check your connection and try again",
+  timeout: "That took too long. Please try again",
+  unauthorized: "Your session has expired. Please sign in again",
+  forbidden: "You don't have permission to do that",
+  notFound: "We couldn't find what you were looking for",
+  rateLimited: "Too many attempts. Please wait a moment and try again",
+  server: "We're having trouble on our end. Please try again in a moment"
+});
+var UserError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "UserError";
+    this.status = status;
+  }
+};
+var NETWORK_FAILURE = /failed to fetch|network|load failed|fetch failed/i;
+function readField(source, field, type) {
+  const value = source?.[field];
+  return typeof value === type ? value : void 0;
+}
+function readPayloadMessage(error) {
+  const payload = error?.payload;
+  const message = readField(payload, "error", "string")?.trim();
+  return message || void 0;
+}
+function toUserMessage(error, { codes, fallback = USER_MESSAGES.generic } = {}) {
+  if (typeof error === "string") return error.trim() || fallback;
+  if (!error || typeof error !== "object") return fallback;
+  if (error instanceof UserError) {
+    if (error.status === 401) return USER_MESSAGES.unauthorized;
+    return error.message || fallback;
+  }
+  if (error.name === "AbortError") return fallback;
+  const code = readField(error, "code", "string");
+  if (code && codes?.[code]) return codes[code];
+  const status = readField(error, "status", "number");
+  if (status === 401) return USER_MESSAGES.unauthorized;
+  if (status === 429) return USER_MESSAGES.rateLimited;
+  if (status === 408 || status === 504) return USER_MESSAGES.timeout;
+  if (status !== void 0 && status >= 500) return USER_MESSAGES.server;
+  if (status !== void 0 && status >= 400) {
+    const authored = readPayloadMessage(error);
+    if (authored) return authored;
+    if (status === 403) return USER_MESSAGES.forbidden;
+    if (status === 404) return USER_MESSAGES.notFound;
+    return fallback;
+  }
+  const isOffline = typeof navigator !== "undefined" && navigator.onLine === false;
+  if (isOffline || NETWORK_FAILURE.test(error.message ?? "") && (error instanceof TypeError || /fetch/i.test(error.name))) {
+    return USER_MESSAGES.network;
+  }
+  return fallback;
+}
+
+// src/hooks/use-isomorphic-layout-effect.ts
+var useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;
+function useDebounce(value, delay = 300) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const timer = setTimeout(() => setDebouncedValue(value), delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+  return debouncedValue;
+}
+var emptySubscribe = () => () => {
+};
+function useMounted() {
+  return useSyncExternalStore(
+    emptySubscribe,
+    () => true,
+    () => false
+  );
+}
+function useMediaQuery(query, serverFallback = false) {
+  const subscribe2 = useCallback(
+    (onStoreChange) => {
+      if (!isBrowser || !query || typeof window.matchMedia !== "function") {
+        return () => {
+        };
+      }
+      const mediaQueryList = window.matchMedia(query);
+      mediaQueryList.addEventListener("change", onStoreChange);
+      return () => mediaQueryList.removeEventListener("change", onStoreChange);
+    },
+    [query]
+  );
+  const getSnapshot2 = useCallback(() => {
+    if (!isBrowser || !query || typeof window.matchMedia !== "function") {
+      return serverFallback;
+    }
+    return window.matchMedia(query).matches;
+  }, [query, serverFallback]);
+  const getServerSnapshot = useCallback(() => serverFallback, [serverFallback]);
+  return useSyncExternalStore(subscribe2, getSnapshot2, getServerSnapshot);
+}
+function useControllableState({
+  defaultValue,
+  onChange,
+  value
+}) {
+  const [uncontrolledValue, setUncontrolledValue] = useState(defaultValue);
+  const isControlled = value !== void 0;
+  const currentValue = isControlled ? value : uncontrolledValue;
+  const valueRef = useRef(currentValue);
+  const onChangeRef = useRef(onChange);
+  useIsomorphicLayoutEffect(() => {
+    valueRef.current = currentValue;
+    onChangeRef.current = onChange;
+  });
+  const setValue = useCallback(
+    (next) => {
+      const resolvedNext = typeof next === "function" ? next(valueRef.current) : next;
+      if (!Object.is(valueRef.current, resolvedNext)) {
+        if (!isControlled) {
+          setUncontrolledValue(resolvedNext);
+        }
+        onChangeRef.current?.(resolvedNext);
+      }
+    },
+    [isControlled]
+  );
+  return [currentValue, setValue];
+}
+function isEditableElement(target) {
+  if (!target || typeof target.tagName !== "string") {
+    return false;
+  }
+  const element = target;
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "input" || tagName === "textarea" || tagName === "select") {
+    return true;
+  }
+  return Boolean(element.isContentEditable);
+}
+function matchesKeyCombo(event, combo) {
+  const parts = combo.toLowerCase().split("+").map((p) => p.trim()).filter(Boolean);
+  if (parts.length === 0) return false;
+  const keyPart = parts[parts.length - 1];
+  const modifiers = new Set(parts.slice(0, -1));
+  const wantsMod = modifiers.has("mod") || modifiers.has("cmd") || modifiers.has("meta");
+  const wantsCtrl = modifiers.has("ctrl") || modifiers.has("control");
+  const wantsAlt = modifiers.has("alt") || modifiers.has("option");
+  const wantsShift = modifiers.has("shift");
+  const isModPressed = event.metaKey || event.ctrlKey;
+  if (wantsMod && !isModPressed) return false;
+  if (!wantsMod && !wantsCtrl && (event.metaKey || event.ctrlKey)) return false;
+  if (wantsCtrl && !event.ctrlKey) return false;
+  if (wantsAlt !== event.altKey) return false;
+  if (wantsShift !== event.shiftKey) return false;
+  const pressedKey = event.key.toLowerCase();
+  if (keyPart === "esc" || keyPart === "escape") {
+    return pressedKey === "escape" || pressedKey === "esc";
+  }
+  if (keyPart === "space") {
+    return pressedKey === " " || pressedKey === "spacebar";
+  }
+  return pressedKey === keyPart;
+}
+function useHotkey(combo, callback, options) {
+  const callbackRef = useRef(callback);
+  useIsomorphicLayoutEffect(() => {
+    callbackRef.current = callback;
+  });
+  const enabled = options?.enabled ?? true;
+  const enableOnFormTags = options?.enableOnFormTags ?? false;
+  const preventDefault = options?.preventDefault ?? true;
+  const stopPropagation = options?.stopPropagation ?? false;
+  useEffect(() => {
+    if (!isBrowser || !enabled || !combo) return;
+    const combos = (Array.isArray(combo) ? combo : [combo]).filter(Boolean);
+    if (combos.length === 0) return;
+    const handleKeyDown = (event) => {
+      if (!enableOnFormTags && isEditableElement(event.target)) return;
+      const matched = combos.some((c) => matchesKeyCombo(event, c));
+      if (!matched) return;
+      if (preventDefault) event.preventDefault();
+      if (stopPropagation) event.stopPropagation();
+      callbackRef.current?.(event);
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [combo, enabled, enableOnFormTags, preventDefault, stopPropagation]);
+}
+function useEscapeKey(callback, enabled = true) {
+  useHotkey("escape", callback, {
+    enabled,
+    enableOnFormTags: true,
+    preventDefault: false
+  });
+}
+
+// src/events.ts
+var EVENT_TYPES = Object.freeze({
+  API_UNAUTHORIZED: "API_UNAUTHORIZED",
+  STATE_CHANGE: "STATE_CHANGE",
+  API_ERROR: "API_ERROR",
+  APP_ERROR: "APP_ERROR"
+});
+var EventEmitter = class {
+  events = /* @__PURE__ */ new Map();
+  debounceTimers = /* @__PURE__ */ new Map();
+  subscribe(event, callback) {
+    if (typeof event !== "string" || !event || typeof callback !== "function") {
+      return () => {
+      };
+    }
+    const listeners2 = this.events.get(event) || /* @__PURE__ */ new Set();
+    listeners2.add(callback);
+    this.events.set(event, listeners2);
+    return () => {
+      listeners2.delete(callback);
+      if (listeners2.size === 0) this.events.delete(event);
+    };
+  }
+  emit(event, payload) {
+    const listeners2 = this.events.get(event);
+    if (!listeners2 || listeners2.size === 0) return;
+    const snapshot = Array.from(listeners2);
+    for (const callback of snapshot) {
+      try {
+        callback(payload);
+      } catch (error) {
+        report(`Event listener (${String(event)})`, error);
+      }
+    }
+  }
+  emitDebounced(event, payload, waitMs = 100) {
+    const existing = this.debounceTimers.get(event);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(() => {
+      this.debounceTimers.delete(event);
+      this.emit(event, payload);
+    }, waitMs);
+    this.debounceTimers.set(event, timer);
+  }
+  cancelDebounced(event) {
+    if (event) {
+      const timer = this.debounceTimers.get(event);
+      if (timer) {
+        clearTimeout(timer);
+        this.debounceTimers.delete(event);
+      }
+    } else {
+      for (const timer of this.debounceTimers.values()) {
+        clearTimeout(timer);
+      }
+      this.debounceTimers.clear();
+    }
+  }
+  unsubscribeAll(event) {
+    this.cancelDebounced(event);
+    if (event) this.events.delete(event);
+    else this.events.clear();
+  }
+  hasListeners(event) {
+    return Boolean(this.events.get(event)?.size);
+  }
+  getListenerCount(event) {
+    return this.events.get(event)?.size || 0;
+  }
+  getAllEvents() {
+    return [...this.events.keys()];
+  }
+};
+var GLOBAL_EVENTS_KEY = /* @__PURE__ */ Symbol.for("__base_framework_global_events__");
+var _global = globalThis;
+var globalEvents = _global[GLOBAL_EVENTS_KEY] ?? (_global[GLOBAL_EVENTS_KEY] = new EventEmitter());
+
+// src/hooks/use-global-event.ts
+function useGlobalEvent(event, callback, options) {
+  const callbackRef = useRef(callback);
+  const debounceTimerRef = useRef(null);
+  const lastThrottleTimeRef = useRef(0);
+  const throttleTimerRef = useRef(null);
+  useIsomorphicLayoutEffect(() => {
+    callbackRef.current = callback;
+  });
+  const debounceMs = options?.debounceMs;
+  const throttleMs = options?.throttleMs;
+  useEffect(() => {
+    if (!event) return;
+    const events = Array.isArray(event) ? event.filter(Boolean) : [event];
+    if (events.length === 0) return;
+    const handler = (payload) => {
+      if (debounceMs != null && debounceMs > 0) {
+        if (debounceTimerRef.current !== null) {
+          clearTimeout(debounceTimerRef.current);
+        }
+        debounceTimerRef.current = setTimeout(() => {
+          debounceTimerRef.current = null;
+          callbackRef.current?.(payload);
+        }, debounceMs);
+        return;
+      }
+      if (throttleMs != null && throttleMs > 0) {
+        const now = Date.now();
+        const remaining = throttleMs - (now - lastThrottleTimeRef.current);
+        if (remaining <= 0) {
+          if (throttleTimerRef.current !== null) {
+            clearTimeout(throttleTimerRef.current);
+            throttleTimerRef.current = null;
+          }
+          lastThrottleTimeRef.current = now;
+          callbackRef.current?.(payload);
+        } else if (throttleTimerRef.current === null) {
+          throttleTimerRef.current = setTimeout(() => {
+            lastThrottleTimeRef.current = Date.now();
+            throttleTimerRef.current = null;
+            callbackRef.current?.(payload);
+          }, remaining);
+        }
+        return;
+      }
+      callbackRef.current?.(payload);
+    };
+    const unsubs = events.map((ev) => globalEvents.subscribe(ev, handler));
+    return () => {
+      unsubs.forEach((unsub) => unsub());
+      if (debounceTimerRef.current !== null) {
+        clearTimeout(debounceTimerRef.current);
+        debounceTimerRef.current = null;
+      }
+      if (throttleTimerRef.current !== null) {
+        clearTimeout(throttleTimerRef.current);
+        throttleTimerRef.current = null;
+      }
+    };
+  }, [event, debounceMs, throttleMs]);
+}
+function useEventState(event, initialValue, reducer) {
+  const storeRef = useRef(null);
+  if (storeRef.current == null) {
+    storeRef.current = {
+      value: initialValue,
+      listeners: /* @__PURE__ */ new Set(),
+      reducer
+    };
+  }
+  useIsomorphicLayoutEffect(() => {
+    if (storeRef.current != null) {
+      storeRef.current.reducer = reducer;
+    }
+  });
+  const subscribe2 = useCallback(
+    (onStoreChange) => {
+      if (!event || !storeRef.current) return () => {
+      };
+      storeRef.current.listeners.add(onStoreChange);
+      const unsub = globalEvents.subscribe(event, (payload) => {
+        if (!storeRef.current) return;
+        const next = storeRef.current.reducer(storeRef.current.value, payload);
+        if (!Object.is(storeRef.current.value, next)) {
+          storeRef.current.value = next;
+          storeRef.current.listeners.forEach((listener) => listener());
+        }
+      });
+      return () => {
+        storeRef.current?.listeners.delete(onStoreChange);
+        unsub();
+      };
+    },
+    [event]
+  );
+  const getSnapshot2 = useCallback(() => {
+    return storeRef.current?.value ?? initialValue;
+  }, [initialValue]);
+  const getServerSnapshot = useCallback(() => {
+    return initialValue;
+  }, [initialValue]);
+  return useSyncExternalStore(subscribe2, getSnapshot2, getServerSnapshot);
+}
+
+// src/result.ts
+function err(error, code) {
+  return { error, success: false, ...{} };
+}
+function isResult(value) {
+  return typeof value === "object" && value !== null && "success" in value && typeof value.success === "boolean" && ("data" in value && value.success === true || "error" in value && value.success === false);
+}
+function isErr(result) {
+  return result.success === false;
+}
+
+// src/hooks/use-async-action.ts
+function useAsyncAction(actionFn, options = {}) {
+  const {
+    errorMessage = null,
+    onError = null,
+    onSuccess = null,
+    successMessage = null,
+    toast = null
+  } = options;
+  const [isPending, setIsPending] = useState(false);
+  const [error, setError] = useState(null);
+  const execute = useCallback(
+    async (...args) => {
+      setIsPending(true);
+      setError(null);
+      try {
+        const result = await actionFn(...args);
+        if (isResult(result) && isErr(result)) {
+          setError(result.error);
+          const resolvedMessage = errorMessage || toUserMessage(result.error);
+          if (typeof toast === "function") {
+            toast(resolvedMessage);
+          }
+          globalEvents.emit(EVENT_TYPES.APP_ERROR, {
+            error: result.error,
+            message: resolvedMessage,
+            notify: toast === true
+          });
+          await onError?.(result.error);
+          return result;
+        }
+        if (successMessage) {
+          if (typeof toast === "function") {
+            toast(successMessage);
+          }
+          globalEvents.emit(EVENT_TYPES.STATE_CHANGE, {
+            message: successMessage,
+            notify: toast === true,
+            status: "success"
+          });
+        }
+        await onSuccess?.(result);
+        return result;
+      } catch (err2) {
+        setError(err2);
+        const resolvedMessage = errorMessage || toUserMessage(err2);
+        if (typeof toast === "function") {
+          toast(resolvedMessage);
+        }
+        globalEvents.emit(EVENT_TYPES.APP_ERROR, {
+          error: err2,
+          message: resolvedMessage,
+          notify: toast === true
+        });
+        await onError?.(err2);
+        throw err2;
+      } finally {
+        setIsPending(false);
+      }
+    },
+    [actionFn, errorMessage, onError, onSuccess, successMessage, toast]
+  );
+  return { error, execute, isPending };
+}
+function useServerAction(actionFn, options = {}) {
+  const {
+    errorMessage = null,
+    onError = null,
+    onSuccess = null,
+    successMessage = null,
+    toast = null
+  } = options;
+  const [isPending, startTransition] = useTransition();
+  const [data, setData] = useState(null);
+  const [error, setError] = useState(null);
+  const reset = useCallback(() => {
+    setData(null);
+    setError(null);
+  }, []);
+  const execute = useCallback(
+    (...args) => {
+      return new Promise((resolve) => {
+        startTransition(async () => {
+          setError(null);
+          try {
+            const result = await actionFn(...args);
+            if (isErr(result)) {
+              setError(result.error);
+              const resolvedMessage = errorMessage || toUserMessage(result.error);
+              if (typeof toast === "function") {
+                toast(resolvedMessage);
+              }
+              globalEvents.emit(EVENT_TYPES.APP_ERROR, {
+                error: result.error,
+                message: resolvedMessage,
+                notify: toast === true
+              });
+              await onError?.(result.error);
+              resolve(result);
+              return;
+            }
+            setData(result.data);
+            if (successMessage) {
+              if (typeof toast === "function") {
+                toast(successMessage);
+              }
+              globalEvents.emit(EVENT_TYPES.STATE_CHANGE, {
+                message: successMessage,
+                notify: toast === true,
+                status: "success"
+              });
+            }
+            await onSuccess?.(result.data);
+            resolve(result);
+          } catch (err2) {
+            const mappedError = toUserMessage(err2);
+            setError(mappedError);
+            const resolvedMessage = errorMessage || mappedError;
+            if (typeof toast === "function") {
+              toast(resolvedMessage);
+            }
+            globalEvents.emit(EVENT_TYPES.APP_ERROR, {
+              error: err2,
+              message: resolvedMessage,
+              notify: toast === true
+            });
+            await onError?.(mappedError);
+            resolve(err(mappedError));
+          }
+        });
+      });
+    },
+    [actionFn, errorMessage, onError, onSuccess, successMessage, toast]
+  );
+  return { data, error, execute, isPending, reset };
+}
+function getStorageInstance(type) {
+  if (!isBrowser) return null;
+  try {
+    return type === "session" ? window.sessionStorage : window.localStorage;
+  } catch {
+    return null;
+  }
+}
+var STORAGE_SYNC_EVENT = "base-framework:storage-sync";
+function useStorageState(key, initialValue, options = {}) {
+  const storageType = options.storage ?? "local";
+  const serialize = options.serialize ?? JSON.stringify;
+  const deserialize = options.deserialize ?? JSON.parse;
+  const cacheRef = useRef({
+    parsed: initialValue,
+    raw: null
+  });
+  const getSnapshot2 = useCallback(() => {
+    const storage = getStorageInstance(storageType);
+    if (!storage) return initialValue;
+    try {
+      const raw = storage.getItem(key);
+      if (raw === null) {
+        cacheRef.current = { parsed: initialValue, raw: null };
+        return initialValue;
+      }
+      if (cacheRef.current.raw === raw) {
+        return cacheRef.current.parsed;
+      }
+      const parsed = deserialize(raw);
+      cacheRef.current = { parsed, raw };
+      return parsed;
+    } catch {
+      return initialValue;
+    }
+  }, [deserialize, initialValue, key, storageType]);
+  const getServerSnapshot = useCallback(() => initialValue, [initialValue]);
+  const subscribe2 = useCallback(
+    (onStoreChange) => {
+      if (!isBrowser) return () => {
+      };
+      const handleStorage = (event) => {
+        if (event.key === key && event.storageArea === getStorageInstance(storageType)) {
+          onStoreChange();
+        }
+      };
+      const handleCustomSync = (event) => {
+        const detail = event.detail;
+        if (detail?.key === key && detail?.storageType === storageType) {
+          onStoreChange();
+        }
+      };
+      window.addEventListener("storage", handleStorage);
+      window.addEventListener(STORAGE_SYNC_EVENT, handleCustomSync);
+      return () => {
+        window.removeEventListener("storage", handleStorage);
+        window.removeEventListener(STORAGE_SYNC_EVENT, handleCustomSync);
+      };
+    },
+    [key, storageType]
+  );
+  const state = useSyncExternalStore(subscribe2, getSnapshot2, getServerSnapshot);
+  const stateRef = useRef(state);
+  useIsomorphicLayoutEffect(() => {
+    stateRef.current = state;
+  });
+  const setValue = useCallback(
+    (next) => {
+      const resolvedNext = typeof next === "function" ? next(stateRef.current) : next;
+      stateRef.current = resolvedNext;
+      const storage = getStorageInstance(storageType);
+      if (!storage) return;
+      try {
+        const raw = serialize(resolvedNext);
+        cacheRef.current = { parsed: resolvedNext, raw };
+        storage.setItem(key, raw);
+        window.dispatchEvent(
+          new CustomEvent(STORAGE_SYNC_EVENT, {
+            detail: { key, storageType }
+          })
+        );
+      } catch {
+      }
+    },
+    [key, serialize, storageType]
+  );
+  const removeValue = useCallback(() => {
+    stateRef.current = initialValue;
+    cacheRef.current = { parsed: initialValue, raw: null };
+    const storage = getStorageInstance(storageType);
+    if (!storage) return;
+    try {
+      storage.removeItem(key);
+      window.dispatchEvent(
+        new CustomEvent(STORAGE_SYNC_EVENT, {
+          detail: { key, storageType }
+        })
+      );
+    } catch {
+    }
+  }, [initialValue, key, storageType]);
+  return [state, setValue, removeValue];
+}
+function useLocalStorage(key, initialValue, options) {
+  return useStorageState(key, initialValue, { ...options, storage: "local" });
+}
+function useSessionStorage(key, initialValue, options) {
+  return useStorageState(key, initialValue, { ...options, storage: "session" });
+}
+function useIntersectionObserver(targetRef, options = {}) {
+  const {
+    enabled = true,
+    freezeOnceVisible = false,
+    onChange,
+    root = null,
+    rootMargin = "0px",
+    threshold = 0
+  } = options;
+  const [entry, setEntry] = useState(null);
+  const onChangeRef = useRef(onChange);
+  useIsomorphicLayoutEffect(() => {
+    onChangeRef.current = onChange;
+  });
+  const frozen = Boolean(entry?.isIntersecting && freezeOnceVisible);
+  useEffect(() => {
+    if (!isBrowser || !enabled || frozen || typeof IntersectionObserver === "undefined") {
+      return;
+    }
+    const node = targetRef?.current;
+    if (!node) return;
+    const observer = new IntersectionObserver(
+      ([nextEntry]) => {
+        if (!nextEntry) return;
+        setEntry(nextEntry);
+        onChangeRef.current?.(nextEntry);
+      },
+      { root, rootMargin, threshold }
+    );
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, [enabled, frozen, root, rootMargin, targetRef, threshold]);
+  return {
+    entry,
+    isIntersecting: Boolean(entry?.isIntersecting)
+  };
+}
+var listeners = /* @__PURE__ */ new Set();
+var activeFullscreenStateIds = /* @__PURE__ */ new Set();
+var ACTIVE_FULLSCREEN_ROOT_SELECTOR = '[data-fullscreen-state-root="true"][data-affect-global-state="true"]';
+var domObserver = null;
+var lastSnapshot = false;
+function getDomSnapshot() {
+  if (typeof document === "undefined") {
+    return activeFullscreenStateIds.size > 0;
+  }
+  return document.querySelector(ACTIVE_FULLSCREEN_ROOT_SELECTOR) !== null;
+}
+function emitChange() {
+  listeners.forEach((listener) => listener());
+}
+function emitIfSnapshotChanged() {
+  const nextSnapshot = getDomSnapshot();
+  if (nextSnapshot === lastSnapshot) {
+    return;
+  }
+  lastSnapshot = nextSnapshot;
+  emitChange();
+}
+function ensureDomObserver() {
+  if (typeof document === "undefined" || domObserver || listeners.size === 0) {
+    return;
+  }
+  domObserver = new MutationObserver(() => {
+    emitIfSnapshotChanged();
+  });
+  domObserver.observe(document.documentElement, {
+    attributes: true,
+    childList: true,
+    subtree: true,
+    attributeFilter: [
+      "data-fullscreen-state",
+      "data-fullscreen-state-root",
+      "data-affect-global-state"
+    ]
+  });
+}
+function releaseDomObserver() {
+  if (listeners.size > 0 || !domObserver) {
+    return;
+  }
+  domObserver.disconnect();
+  domObserver = null;
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  ensureDomObserver();
+  emitIfSnapshotChanged();
+  return () => {
+    listeners.delete(listener);
+    releaseDomObserver();
+  };
+}
+function getSnapshot() {
+  return getDomSnapshot();
+}
+function useIsFullscreenStateActive() {
+  return useSyncExternalStore(subscribe, getSnapshot, () => false);
+}
+
+export { useAsyncAction, useClickOutside, useControllableState, useDebounce, useEscapeKey, useEventState, useGlobalEvent, useHotkey, useIntersectionObserver, useIsFullscreenStateActive, useIsomorphicLayoutEffect, useLocalStorage, useMediaQuery, useMounted, useRequiredContext, useServerAction, useSessionStorage, useStorageState, useStore };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map