@fictjs/hooks 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2548 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  useAsyncState: () => useAsyncState,
+  useClickOutside: () => useClickOutside,
+  useClipboard: () => useClipboard,
+  useCounter: () => useCounter,
+  useDebounceFn: () => useDebounceFn,
+  useDocumentVisibility: () => useDocumentVisibility,
+  useEventListener: () => useEventListener,
+  useFetch: () => useFetch,
+  useFocusWithin: () => useFocusWithin,
+  useFullscreen: () => useFullscreen,
+  useGeolocation: () => useGeolocation,
+  useHover: () => useHover,
+  useIdle: () => useIdle,
+  useIntersectionObserver: () => useIntersectionObserver,
+  useIntervalFn: () => useIntervalFn,
+  useKeyPress: () => useKeyPress,
+  useLocalStorage: () => useLocalStorage,
+  useMediaQuery: () => useMediaQuery,
+  useMount: () => useMount,
+  useMutationObserver: () => useMutationObserver,
+  useNetwork: () => useNetwork,
+  usePermission: () => usePermission,
+  usePrevious: () => usePrevious,
+  useRafFn: () => useRafFn,
+  useRequest: () => useRequest,
+  useResizeObserver: () => useResizeObserver,
+  useScroll: () => useScroll,
+  useSessionStorage: () => useSessionStorage,
+  useSize: () => useSize,
+  useStorage: () => useStorage,
+  useThrottleFn: () => useThrottleFn,
+  useTimeoutFn: () => useTimeoutFn,
+  useTitle: () => useTitle,
+  useToggle: () => useToggle,
+  useUnmount: () => useUnmount,
+  useVirtualList: () => useVirtualList,
+  useWebSocket: () => useWebSocket,
+  useWindowScroll: () => useWindowScroll,
+  useWindowSize: () => useWindowSize
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lifecycle/useMount.ts
+var import_runtime = require("@fictjs/runtime");
+function useMount(callback) {
+  (0, import_runtime.onMount)(callback);
+}
+
+// src/lifecycle/useUnmount.ts
+var import_runtime2 = require("@fictjs/runtime");
+function useUnmount(callback) {
+  (0, import_runtime2.onDestroy)(callback);
+}
+
+// src/async/useAsyncState.ts
+var import_advanced = require("@fictjs/runtime/advanced");
+function useAsyncState(executor, initialState, options = {}) {
+  const state = (0, import_advanced.createSignal)(initialState);
+  const isLoading = (0, import_advanced.createSignal)(false);
+  const error = (0, import_advanced.createSignal)(null);
+  let callId = 0;
+  const execute = async (...args) => {
+    const id = ++callId;
+    if (options.resetOnExecute) {
+      state(initialState);
+    }
+    isLoading(true);
+    error(null);
+    try {
+      const result = await executor(...args);
+      if (id === callId) {
+        state(result);
+      }
+      return result;
+    } catch (err) {
+      if (id === callId) {
+        error(err);
+      }
+      options.onError?.(err);
+      throw err;
+    } finally {
+      if (id === callId) {
+        isLoading(false);
+      }
+    }
+  };
+  if (options.immediate) {
+    void execute(...[]).catch(() => {
+    });
+  }
+  return {
+    state,
+    isLoading,
+    error,
+    execute
+  };
+}
+
+// src/async/useFetch.ts
+var import_advanced2 = require("@fictjs/runtime/advanced");
+
+// src/internal/value.ts
+function toValue(value) {
+  return typeof value === "function" ? value() : value;
+}
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+// src/async/useFetch.ts
+async function defaultParse(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return await response.json();
+  }
+  return await response.text();
+}
+function useFetch(input, options = {}) {
+  const data = (0, import_advanced2.createSignal)(options.initialData ?? null);
+  const error = (0, import_advanced2.createSignal)(null);
+  const isLoading = (0, import_advanced2.createSignal)(false);
+  const status = (0, import_advanced2.createSignal)(null);
+  const aborted = (0, import_advanced2.createSignal)(false);
+  const fetcher = options.fetch ?? fetch;
+  const parse = options.parse ?? defaultParse;
+  let requestId = 0;
+  let controller;
+  const abort = () => {
+    if (controller) {
+      controller.abort();
+      controller = void 0;
+      aborted(true);
+      isLoading(false);
+    }
+  };
+  const execute = async (init) => {
+    const id = ++requestId;
+    abort();
+    error(null);
+    isLoading(true);
+    aborted(false);
+    controller = typeof AbortController !== "undefined" ? new AbortController() : void 0;
+    try {
+      const response = await fetcher(toValue(input), {
+        ...options.init,
+        ...init,
+        signal: controller?.signal
+      });
+      if (id !== requestId) {
+        return data();
+      }
+      status(response.status);
+      if (!response.ok) {
+        throw new Error(`Fetch failed with status ${response.status}`);
+      }
+      const parsed = await parse(response);
+      data(parsed);
+      return parsed;
+    } catch (err) {
+      if (id !== requestId) {
+        return data();
+      }
+      if (err instanceof DOMException && err.name === "AbortError") {
+        aborted(true);
+        return data();
+      }
+      error(err);
+      options.onError?.(err);
+      return data();
+    } finally {
+      if (id === requestId) {
+        isLoading(false);
+      }
+    }
+  };
+  if (options.immediate ?? true) {
+    void execute();
+  }
+  return {
+    data,
+    error,
+    isLoading,
+    status,
+    aborted,
+    execute,
+    abort
+  };
+}
+
+// src/async/useRequest.ts
+var import_runtime3 = require("@fictjs/runtime");
+var import_advanced3 = require("@fictjs/runtime/advanced");
+var requestCache = /* @__PURE__ */ new Map();
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function useRequest(service, options = {}) {
+  const data = (0, import_advanced3.createSignal)(void 0);
+  const error = (0, import_advanced3.createSignal)(null);
+  const loading = (0, import_advanced3.createSignal)(false);
+  const params = (0, import_advanced3.createSignal)(options.defaultParams);
+  let callId = 0;
+  let pollingTimer;
+  const applyCache = () => {
+    if (!options.cacheKey) {
+      return;
+    }
+    const entry = requestCache.get(options.cacheKey);
+    if (!entry) {
+      return;
+    }
+    const staleTime = options.staleTime ?? 0;
+    if (staleTime > 0 && Date.now() - entry.timestamp > staleTime) {
+      requestCache.delete(options.cacheKey);
+      return;
+    }
+    data(entry.data);
+  };
+  const saveCache = (value) => {
+    if (!options.cacheKey) {
+      return;
+    }
+    requestCache.set(options.cacheKey, {
+      data: value,
+      timestamp: Date.now()
+    });
+  };
+  const stopPolling = () => {
+    if (pollingTimer) {
+      clearTimeout(pollingTimer);
+      pollingTimer = void 0;
+    }
+  };
+  const schedulePolling = (currentParams) => {
+    stopPolling();
+    if (!options.pollingInterval || options.pollingInterval <= 0) {
+      return;
+    }
+    pollingTimer = setTimeout(() => {
+      void runAsync(...currentParams);
+    }, options.pollingInterval);
+  };
+  const runWithRetry = async (currentParams, currentId) => {
+    const retryCount = options.retryCount ?? 0;
+    const retryInterval = options.retryInterval ?? 1e3;
+    let attempt = 0;
+    while (true) {
+      try {
+        return await service(...currentParams);
+      } catch (err) {
+        if (currentId !== callId) {
+          throw err;
+        }
+        if (attempt >= retryCount) {
+          throw err;
+        }
+        attempt += 1;
+        await delay(retryInterval);
+      }
+    }
+  };
+  const runAsync = async (...currentParams) => {
+    const id = ++callId;
+    stopPolling();
+    loading(true);
+    error(null);
+    params(currentParams);
+    try {
+      const result = await runWithRetry(currentParams, id);
+      if (id !== callId) {
+        return data();
+      }
+      data(result);
+      saveCache(result);
+      options.onSuccess?.(result, currentParams);
+      schedulePolling(currentParams);
+      return result;
+    } catch (err) {
+      if (id !== callId) {
+        return data();
+      }
+      error(err);
+      options.onError?.(err, currentParams);
+      schedulePolling(currentParams);
+      return data();
+    } finally {
+      if (id === callId) {
+        loading(false);
+      }
+      options.onFinally?.(currentParams, data(), error());
+    }
+  };
+  const run = (...currentParams) => {
+    void runAsync(...currentParams);
+  };
+  const cancel = () => {
+    callId += 1;
+    loading(false);
+    stopPolling();
+  };
+  const refresh = async () => {
+    const currentParams = params() ?? options.defaultParams;
+    if (!currentParams) {
+      return data();
+    }
+    return runAsync(...currentParams);
+  };
+  const mutate = (value) => {
+    const next = typeof value === "function" ? value(data()) : value;
+    data(next);
+    saveCache(next);
+  };
+  applyCache();
+  if (!options.manual && options.defaultParams) {
+    void runAsync(...options.defaultParams);
+  }
+  (0, import_runtime3.onDestroy)(cancel);
+  return {
+    data,
+    error,
+    loading,
+    params,
+    run,
+    runAsync,
+    cancel,
+    refresh,
+    mutate
+  };
+}
+
+// src/clipboard/useClipboard.ts
+var import_runtime4 = require("@fictjs/runtime");
+var import_advanced4 = require("@fictjs/runtime/advanced");
+
+// src/internal/env.ts
+var isClient = typeof window !== "undefined" && typeof document !== "undefined";
+var defaultWindow = isClient ? window : void 0;
+var defaultDocument = isClient ? document : void 0;
+var defaultNavigator = typeof navigator !== "undefined" ? navigator : void 0;
+
+// src/clipboard/useClipboard.ts
+function fallbackCopy(value, documentRef) {
+  const textarea = documentRef.createElement("textarea");
+  textarea.value = value;
+  textarea.setAttribute("readonly", "true");
+  textarea.style.position = "absolute";
+  textarea.style.left = "-9999px";
+  documentRef.body.appendChild(textarea);
+  textarea.select();
+  let ok = false;
+  try {
+    ok = documentRef.execCommand("copy");
+  } catch {
+    ok = false;
+  }
+  documentRef.body.removeChild(textarea);
+  return ok;
+}
+function useClipboard(options = {}) {
+  const navigatorRef = options.navigator === void 0 ? defaultNavigator : options.navigator;
+  const documentRef = options.document === void 0 ? defaultDocument : options.document;
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  const text = (0, import_advanced4.createSignal)("");
+  const copied = (0, import_advanced4.createSignal)(false);
+  const isSupported = (0, import_advanced4.createSignal)(
+    !!navigatorRef?.clipboard?.writeText || !!documentRef?.execCommand
+  );
+  const copiedDuring = options.copiedDuring ?? 1500;
+  let timer;
+  const resetCopiedLater = () => {
+    if (!windowRef) {
+      copied(false);
+      return;
+    }
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = windowRef.setTimeout(() => {
+      copied(false);
+      timer = void 0;
+    }, copiedDuring);
+  };
+  const copy = async (value) => {
+    text(value);
+    if (navigatorRef?.clipboard?.writeText) {
+      try {
+        await navigatorRef.clipboard.writeText(value);
+        copied(true);
+        resetCopiedLater();
+        return true;
+      } catch {
+        copied(false);
+        return false;
+      }
+    }
+    if (documentRef) {
+      const ok = fallbackCopy(value, documentRef);
+      copied(ok);
+      if (ok) {
+        resetCopiedLater();
+      }
+      return ok;
+    }
+    copied(false);
+    return false;
+  };
+  (0, import_runtime4.onDestroy)(() => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  });
+  return {
+    text,
+    copied,
+    isSupported,
+    copy
+  };
+}
+
+// src/event/useEventListener.ts
+var import_runtime5 = require("@fictjs/runtime");
+var import_advanced5 = require("@fictjs/runtime/advanced");
+
+// src/internal/target.ts
+function resolveTarget(target) {
+  if (target == null) {
+    return void 0;
+  }
+  if (typeof target === "function") {
+    return target() ?? void 0;
+  }
+  if (typeof target === "object" && "current" in target) {
+    return target.current ?? void 0;
+  }
+  return target;
+}
+function resolveMaybeTarget(target) {
+  const resolved = toValue(target);
+  return resolveTarget(resolved);
+}
+function resolveTargetList(target) {
+  return toArray(target).map((item) => resolveMaybeTarget(item)).filter((item) => item != null);
+}
+function resolveIgnoreElement(ignore, doc) {
+  if (typeof ignore === "string") {
+    return Array.from(doc.querySelectorAll(ignore));
+  }
+  return resolveMaybeTarget(ignore);
+}
+
+// src/internal/event.ts
+function addEventListeners(targets, events, listener, options) {
+  const resolvedTargets = resolveTargetList(targets);
+  const names = toArray(events);
+  for (const target of resolvedTargets) {
+    for (const name of names) {
+      target.addEventListener(name, listener, options);
+    }
+  }
+  let active = true;
+  return {
+    stop() {
+      if (!active) {
+        return;
+      }
+      active = false;
+      for (const target of resolvedTargets) {
+        for (const name of names) {
+          target.removeEventListener(name, listener, options);
+        }
+      }
+    }
+  };
+}
+
+// src/event/useEventListener.ts
+function useEventListener(target, event, handler, options = {}) {
+  const active = (0, import_advanced5.createSignal)(options.immediate ?? true);
+  let stopCurrent = () => {
+  };
+  const bind = () => {
+    const targets = resolveTargetList(target);
+    const eventNames = toArray(toValue(event));
+    if (targets.length === 0 || eventNames.length === 0) {
+      return void 0;
+    }
+    const listener = (eventObject) => {
+      handler(eventObject);
+    };
+    const listenerOptions = {
+      capture: options.capture,
+      once: options.once,
+      passive: options.passive
+    };
+    const controller = addEventListeners(targets, eventNames, listener, listenerOptions);
+    return () => controller.stop();
+  };
+  (0, import_runtime5.createEffect)(() => {
+    stopCurrent();
+    stopCurrent = () => {
+    };
+    if (!active()) {
+      return;
+    }
+    const stop = bind();
+    if (!stop) {
+      return;
+    }
+    stopCurrent = () => {
+      stop();
+      stopCurrent = () => {
+      };
+    };
+    (0, import_runtime5.onCleanup)(() => {
+      stopCurrent();
+    });
+  });
+  return {
+    start() {
+      if (!active()) {
+        active(true);
+        const stop = bind();
+        if (stop) {
+          stopCurrent = () => {
+            stop();
+            stopCurrent = () => {
+            };
+          };
+        }
+      }
+    },
+    stop() {
+      if (!active()) {
+        return;
+      }
+      active(false);
+      stopCurrent();
+    },
+    active
+  };
+}
+
+// src/event/useClickOutside.ts
+function isNodeInside(elements, node) {
+  return elements.some((element) => element.contains(node));
+}
+function useClickOutside(target, handler, options = {}) {
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  const documentRef = options.document === void 0 ? defaultDocument : options.document;
+  const ignoreTargets = options.ignore ? toArray(options.ignore) : [];
+  let pointerDownOutside = false;
+  const isOutside = (event) => {
+    const node = event.target;
+    if (!node || !documentRef) {
+      return false;
+    }
+    const targetElements = resolveTargetList(target);
+    if (targetElements.length === 0) {
+      return false;
+    }
+    const ignoreElements = ignoreTargets.flatMap((item) => {
+      const resolved = resolveIgnoreElement(item, documentRef);
+      if (!resolved) {
+        return [];
+      }
+      return Array.isArray(resolved) ? resolved : [resolved];
+    });
+    if (isNodeInside(targetElements, node) || isNodeInside(ignoreElements, node)) {
+      return false;
+    }
+    return true;
+  };
+  const onPointerDown = (event) => {
+    pointerDownOutside = isOutside(event);
+  };
+  const onClick = (event) => {
+    if (pointerDownOutside && isOutside(event)) {
+      handler(event);
+    }
+    pointerDownOutside = false;
+  };
+  const downControls = useEventListener(windowRef, "pointerdown", onPointerDown, {
+    capture: options.capture ?? true,
+    passive: true
+  });
+  const clickControls = useEventListener(windowRef, "click", onClick, {
+    capture: options.capture ?? true,
+    passive: true
+  });
+  return {
+    start() {
+      downControls.start();
+      clickControls.start();
+    },
+    stop() {
+      downControls.stop();
+      clickControls.stop();
+    },
+    active() {
+      return downControls.active() && clickControls.active();
+    },
+    trigger(event) {
+      handler(event ?? new Event("click"));
+    }
+  };
+}
+
+// src/event/useFocusWithin.ts
+var import_runtime6 = require("@fictjs/runtime");
+var import_advanced6 = require("@fictjs/runtime/advanced");
+function useFocusWithin(target, options = {}) {
+  const initialValue = options.initialValue ?? false;
+  const focused = (0, import_advanced6.createSignal)(initialValue);
+  let previousTarget;
+  useEventListener(target, "focusin", () => {
+    focused(true);
+  });
+  useEventListener(target, "focusout", (event) => {
+    const targetElement = resolveMaybeTarget(target);
+    if (!targetElement) {
+      focused(false);
+      return;
+    }
+    const relatedTarget = event.relatedTarget;
+    if (relatedTarget && targetElement.contains(relatedTarget)) {
+      return;
+    }
+    focused(false);
+  });
+  (0, import_runtime6.createEffect)(() => {
+    const currentTarget = resolveMaybeTarget(target);
+    if (currentTarget !== previousTarget) {
+      previousTarget = currentTarget;
+      focused(initialValue);
+    }
+  });
+  return { focused };
+}
+
+// src/event/useHover.ts
+var import_runtime7 = require("@fictjs/runtime");
+var import_advanced7 = require("@fictjs/runtime/advanced");
+function useHover(target, options = {}) {
+  const initialValue = options.initialValue ?? false;
+  const hovered = (0, import_advanced7.createSignal)(initialValue);
+  let previousTarget;
+  useEventListener(target, "pointerenter", () => {
+    hovered(true);
+  });
+  useEventListener(target, "pointerleave", () => {
+    hovered(false);
+  });
+  (0, import_runtime7.createEffect)(() => {
+    const currentTarget = resolveMaybeTarget(target);
+    if (currentTarget !== previousTarget) {
+      previousTarget = currentTarget;
+      hovered(initialValue);
+    }
+  });
+  return { hovered };
+}
+
+// src/event/useKeyPress.ts
+var modifierAliases = {
+  ctrl: "ctrl",
+  control: "ctrl",
+  alt: "alt",
+  option: "alt",
+  shift: "shift",
+  meta: "meta",
+  cmd: "meta",
+  command: "meta"
+};
+var keyAliases = {
+  esc: "escape",
+  return: "enter",
+  del: "delete",
+  space: " ",
+  spacebar: " "
+};
+function normalizeToken(token) {
+  return token.trim().toLowerCase();
+}
+function normalizeKey(key) {
+  const normalized = normalizeToken(key);
+  return keyAliases[normalized] ?? normalized;
+}
+function parseCombo(combo) {
+  return combo.split(/[.+]/g).map((part) => normalizeToken(part)).filter(Boolean);
+}
+function isModifierToken(token) {
+  return token in modifierAliases;
+}
+function isModifierActive(modifier, event) {
+  if (modifier === "ctrl") return event.ctrlKey;
+  if (modifier === "alt") return event.altKey;
+  if (modifier === "shift") return event.shiftKey;
+  return event.metaKey;
+}
+function activeModifierCount(event) {
+  return Number(event.ctrlKey) + Number(event.altKey) + Number(event.shiftKey) + Number(event.metaKey);
+}
+function matchesCombo(event, combo, exactMatch) {
+  const tokens = parseCombo(combo);
+  if (tokens.length === 0) {
+    return false;
+  }
+  const modifiers = tokens.filter(isModifierToken).map((token) => modifierAliases[token]);
+  const nonModifiers = tokens.filter((token) => !isModifierToken(token));
+  for (const modifier of modifiers) {
+    if (!isModifierActive(modifier, event)) {
+      return false;
+    }
+  }
+  const keyMatched = nonModifiers.length === 0 || nonModifiers.some((token) => normalizeKey(token) === normalizeKey(event.key));
+  if (!keyMatched) {
+    return false;
+  }
+  if (!exactMatch) {
+    return true;
+  }
+  const expectedModifierCount = new Set(modifiers).size;
+  return activeModifierCount(event) === expectedModifierCount;
+}
+function matchesFilter(event, filter, exactMatch) {
+  if (typeof filter === "function") {
+    return filter(event);
+  }
+  const combos = toArray(filter);
+  return combos.some((combo) => matchesCombo(event, combo, exactMatch));
+}
+function useKeyPress(filter, handler, options = {}) {
+  const events = toArray(options.events ?? "keydown");
+  const exactMatch = options.exactMatch ?? false;
+  const target = options.target === void 0 ? defaultWindow : options.target;
+  const passive = options.preventDefault ? false : options.passive;
+  return useEventListener(
+    target,
+    events,
+    (event) => {
+      const keyboardEvent = event;
+      if (!matchesFilter(keyboardEvent, filter, exactMatch)) {
+        return;
+      }
+      if (options.preventDefault) {
+        keyboardEvent.preventDefault();
+      }
+      handler(keyboardEvent);
+    },
+    {
+      passive,
+      capture: options.capture,
+      immediate: options.immediate
+    }
+  );
+}
+
+// src/internal/timing.ts
+var import_runtime8 = require("@fictjs/runtime");
+function createDebouncedFn(fn, wait, options = {}) {
+  const leading = options.leading ?? false;
+  const trailing = options.trailing ?? true;
+  const maxWait = options.maxWait;
+  let timer;
+  let maxTimer;
+  let lastArgs;
+  let pending = false;
+  const clearTimers = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    if (maxTimer) {
+      clearTimeout(maxTimer);
+      maxTimer = void 0;
+    }
+  };
+  const invoke = () => {
+    if (!lastArgs) {
+      pending = false;
+      clearTimers();
+      return;
+    }
+    const args = lastArgs;
+    lastArgs = void 0;
+    pending = false;
+    clearTimers();
+    fn(...args);
+  };
+  const scheduleTimers = () => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      if (trailing) {
+        invoke();
+      } else {
+        pending = false;
+        clearTimers();
+      }
+    }, wait);
+    if (maxWait != null && maxWait >= 0 && !maxTimer) {
+      maxTimer = setTimeout(() => {
+        invoke();
+      }, maxWait);
+    }
+  };
+  const run = (...args) => {
+    const shouldCallLeading = leading && !timer;
+    lastArgs = args;
+    pending = true;
+    if (shouldCallLeading) {
+      fn(...args);
+      if (!trailing) {
+        lastArgs = void 0;
+        pending = false;
+      }
+    }
+    scheduleTimers();
+  };
+  const cancel = () => {
+    pending = false;
+    lastArgs = void 0;
+    clearTimers();
+  };
+  const flush = () => {
+    if (pending) {
+      invoke();
+    }
+  };
+  (0, import_runtime8.onDestroy)(cancel);
+  return {
+    run,
+    cancel,
+    flush,
+    pending: () => pending
+  };
+}
+function createThrottledFn(fn, wait, options = {}) {
+  const leading = options.leading ?? true;
+  const trailing = options.trailing ?? true;
+  let timer;
+  let lastArgs;
+  let pending = false;
+  const invoke = (args) => {
+    fn(...args);
+  };
+  const tick = () => {
+    if (trailing && lastArgs) {
+      const args = lastArgs;
+      lastArgs = void 0;
+      pending = false;
+      invoke(args);
+      timer = setTimeout(tick, wait);
+      return;
+    }
+    timer = void 0;
+    pending = false;
+  };
+  const run = (...args) => {
+    if (!timer) {
+      if (leading) {
+        invoke(args);
+      } else if (trailing) {
+        lastArgs = args;
+        pending = true;
+      }
+      timer = setTimeout(tick, wait);
+      return;
+    }
+    if (trailing) {
+      lastArgs = args;
+      pending = true;
+    }
+  };
+  const cancel = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    lastArgs = void 0;
+    pending = false;
+  };
+  const flush = () => {
+    if (lastArgs) {
+      const args = lastArgs;
+      lastArgs = void 0;
+      pending = false;
+      invoke(args);
+    }
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+  (0, import_runtime8.onDestroy)(cancel);
+  return {
+    run,
+    cancel,
+    flush,
+    pending: () => pending
+  };
+}
+
+// src/timing/useDebounceFn.ts
+function useDebounceFn(fn, wait, options = {}) {
+  return createDebouncedFn(fn, wait, options);
+}
+
+// src/timing/useIntervalFn.ts
+var import_runtime9 = require("@fictjs/runtime");
+var import_advanced8 = require("@fictjs/runtime/advanced");
+function useIntervalFn(callback, interval) {
+  const pending = (0, import_advanced8.createSignal)(false);
+  let timer;
+  const cancel = () => {
+    if (timer) {
+      clearInterval(timer);
+      timer = void 0;
+    }
+    pending(false);
+  };
+  const run = () => {
+    cancel();
+    const wait = Math.max(0, toValue(interval));
+    pending(true);
+    timer = setInterval(() => {
+      callback();
+    }, wait);
+  };
+  const flush = () => {
+    callback();
+  };
+  (0, import_runtime9.onDestroy)(cancel);
+  run();
+  return {
+    run,
+    cancel,
+    flush,
+    pending
+  };
+}
+
+// src/timing/useRafFn.ts
+var import_runtime10 = require("@fictjs/runtime");
+var import_advanced9 = require("@fictjs/runtime/advanced");
+function useRafFn(callback, options = {}) {
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  const active = (0, import_advanced9.createSignal)(options.immediate ?? true);
+  let rafId = 0;
+  let lastTimestamp;
+  const loop = (timestamp) => {
+    if (!active()) {
+      return;
+    }
+    const delta = lastTimestamp == null ? 0 : timestamp - lastTimestamp;
+    lastTimestamp = timestamp;
+    callback(delta, timestamp);
+    if (windowRef?.requestAnimationFrame) {
+      rafId = windowRef.requestAnimationFrame(loop);
+    }
+  };
+  const start = () => {
+    if (active()) {
+      return;
+    }
+    active(true);
+    if (windowRef?.requestAnimationFrame) {
+      rafId = windowRef.requestAnimationFrame(loop);
+    }
+  };
+  const stop = () => {
+    active(false);
+    lastTimestamp = void 0;
+    if (rafId && windowRef?.cancelAnimationFrame) {
+      windowRef.cancelAnimationFrame(rafId);
+      rafId = 0;
+    }
+  };
+  if (active() && windowRef?.requestAnimationFrame) {
+    rafId = windowRef.requestAnimationFrame(loop);
+  }
+  (0, import_runtime10.onDestroy)(stop);
+  return {
+    active,
+    start,
+    stop
+  };
+}
+
+// src/timing/useThrottleFn.ts
+function useThrottleFn(fn, wait, options = {}) {
+  return createThrottledFn(fn, wait, options);
+}
+
+// src/timing/useTimeoutFn.ts
+var import_advanced10 = require("@fictjs/runtime/advanced");
+var import_runtime11 = require("@fictjs/runtime");
+function useTimeoutFn(callback, delay2) {
+  const pending = (0, import_advanced10.createSignal)(false);
+  let timer;
+  const cancel = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    pending(false);
+  };
+  const run = () => {
+    cancel();
+    const wait = Math.max(0, toValue(delay2));
+    pending(true);
+    timer = setTimeout(() => {
+      timer = void 0;
+      pending(false);
+      callback();
+    }, wait);
+  };
+  const flush = () => {
+    if (!pending()) {
+      return;
+    }
+    cancel();
+    callback();
+  };
+  (0, import_runtime11.onDestroy)(cancel);
+  run();
+  return {
+    run,
+    cancel,
+    flush,
+    pending
+  };
+}
+
+// src/internal/storage.ts
+var import_advanced11 = require("@fictjs/runtime/advanced");
+var import_runtime12 = require("@fictjs/runtime");
+var syncEvent = "fict-storage-sync";
+var jsonSerializer = {
+  read: (raw) => JSON.parse(raw),
+  write: (value) => JSON.stringify(value)
+};
+function inferSerializer(initial) {
+  const kind = typeof initial;
+  if (kind === "string") {
+    return {
+      read: (raw) => raw,
+      write: (value) => String(value)
+    };
+  }
+  if (kind === "number") {
+    return {
+      read: (raw) => Number(raw),
+      write: (value) => String(value)
+    };
+  }
+  if (kind === "boolean") {
+    return {
+      read: (raw) => raw === "true",
+      write: (value) => String(value)
+    };
+  }
+  if (initial instanceof Date) {
+    return {
+      read: (raw) => new Date(raw),
+      write: (value) => value.toISOString()
+    };
+  }
+  if (initial instanceof Map) {
+    return {
+      read: (raw) => new Map(JSON.parse(raw)),
+      write: (value) => JSON.stringify(Array.from(value.entries()))
+    };
+  }
+  if (initial instanceof Set) {
+    return {
+      read: (raw) => new Set(JSON.parse(raw)),
+      write: (value) => JSON.stringify(Array.from(value.values()))
+    };
+  }
+  return jsonSerializer;
+}
+function safeCall(onError, error) {
+  if (!onError) {
+    return;
+  }
+  onError(error);
+}
+function resolveNextValue(next, prev) {
+  if (typeof next === "function") {
+    return next(prev);
+  }
+  return next;
+}
+function createStorageHook(storage, key, initial, options = {}) {
+  const windowRef = options.window ?? defaultWindow;
+  const serializer = options.serializer ?? inferSerializer(initial);
+  const emitSync = windowRef != null;
+  const readStorage = () => {
+    if (!storage) {
+      return initial;
+    }
+    try {
+      const raw = storage.getItem(key);
+      if (raw == null) {
+        if (options.writeDefaults ?? true) {
+          storage.setItem(key, serializer.write(initial));
+        }
+        return initial;
+      }
+      return serializer.read(raw);
+    } catch (error) {
+      safeCall(options.onError, error);
+      return initial;
+    }
+  };
+  const state = (0, import_advanced11.createSignal)(readStorage());
+  let paused = false;
+  const writeState = (next) => {
+    state(next);
+  };
+  const set = (next) => {
+    const prev = state();
+    const value = resolveNextValue(next, prev);
+    if (!storage) {
+      writeState(value);
+      return;
+    }
+    try {
+      const serialized = serializer.write(value);
+      const current = storage.getItem(key);
+      if (current === serialized) {
+        writeState(value);
+        return;
+      }
+      paused = true;
+      storage.setItem(key, serialized);
+      writeState(value);
+      if (emitSync) {
+        windowRef.dispatchEvent(
+          new CustomEvent(syncEvent, {
+            detail: {
+              key,
+              value: serialized
+            }
+          })
+        );
+      }
+    } catch (error) {
+      safeCall(options.onError, error);
+    } finally {
+      paused = false;
+    }
+  };
+  const remove = () => {
+    if (!storage) {
+      writeState(initial);
+      return;
+    }
+    try {
+      paused = true;
+      storage.removeItem(key);
+      writeState(initial);
+      if (emitSync) {
+        windowRef.dispatchEvent(
+          new CustomEvent(syncEvent, {
+            detail: {
+              key,
+              value: null
+            }
+          })
+        );
+      }
+    } catch (error) {
+      safeCall(options.onError, error);
+    } finally {
+      paused = false;
+    }
+  };
+  const syncFromRaw = (raw) => {
+    if (paused) {
+      return;
+    }
+    if (raw == null) {
+      state(initial);
+      return;
+    }
+    try {
+      state(serializer.read(raw));
+    } catch (error) {
+      safeCall(options.onError, error);
+    }
+  };
+  const listenToStorageChanges = options.listenToStorageChanges ?? true;
+  if (windowRef && storage && listenToStorageChanges) {
+    const storageListener = (event) => {
+      if (event.storageArea !== storage || event.key !== key) {
+        return;
+      }
+      syncFromRaw(event.newValue);
+    };
+    const customListener = (event) => {
+      const custom = event;
+      if (custom.detail?.key !== key) {
+        return;
+      }
+      syncFromRaw(custom.detail.value);
+    };
+    windowRef.addEventListener("storage", storageListener);
+    windowRef.addEventListener(syncEvent, customListener);
+    (0, import_runtime12.onDestroy)(() => {
+      windowRef.removeEventListener("storage", storageListener);
+      windowRef.removeEventListener(syncEvent, customListener);
+    });
+  }
+  return {
+    value: state,
+    set,
+    remove
+  };
+}
+
+// src/storage/useLocalStorage.ts
+function useLocalStorage(key, initial, options = {}) {
+  const windowRef = options.window ?? defaultWindow;
+  return createStorageHook(windowRef?.localStorage, key, initial, {
+    ...options,
+    window: windowRef
+  });
+}
+
+// src/storage/useSessionStorage.ts
+function useSessionStorage(key, initial, options = {}) {
+  const windowRef = options.window ?? defaultWindow;
+  return createStorageHook(windowRef?.sessionStorage, key, initial, {
+    ...options,
+    window: windowRef
+  });
+}
+
+// src/storage/useStorage.ts
+function useStorage(key, initial, options = {}) {
+  const windowRef = options.window ?? defaultWindow;
+  const storage = options.storage === void 0 ? windowRef?.localStorage : options.storage;
+  return createStorageHook(storage ?? void 0, key, initial, {
+    window: windowRef,
+    serializer: options.serializer,
+    onError: options.onError,
+    listenToStorageChanges: options.listenToStorageChanges,
+    writeDefaults: options.writeDefaults
+  });
+}
+
+// src/observer/useIntersectionObserver.ts
+var import_runtime13 = require("@fictjs/runtime");
+var import_advanced12 = require("@fictjs/runtime/advanced");
+function useIntersectionObserver(target, callback, options = {}) {
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  const observerCtor = windowRef?.IntersectionObserver ?? globalThis.IntersectionObserver;
+  const entries = (0, import_advanced12.createSignal)([]);
+  const isSupported = (0, import_advanced12.createSignal)(!!observerCtor);
+  const active = (0, import_advanced12.createSignal)(true);
+  let cleanup = () => {
+  };
+  const setup = () => {
+    const Observer = observerCtor;
+    if (!Observer) {
+      isSupported(false);
+      return;
+    }
+    isSupported(true);
+    const rootElement = options.root ? resolveMaybeTarget(options.root) : void 0;
+    const observer = new Observer(
+      (nextEntries, currentObserver) => {
+        entries(nextEntries);
+        callback?.(nextEntries, currentObserver);
+      },
+      {
+        root: rootElement ?? null,
+        rootMargin: options.rootMargin,
+        threshold: options.threshold
+      }
+    );
+    const targets = resolveTargetList(target);
+    for (const element of targets) {
+      observer.observe(element);
+    }
+    cleanup = () => {
+      observer.disconnect();
+      cleanup = () => {
+      };
+    };
+  };
+  (0, import_runtime13.createEffect)(() => {
+    cleanup();
+    if (!active()) {
+      return;
+    }
+    setup();
+    (0, import_runtime13.onCleanup)(() => {
+      cleanup();
+    });
+  });
+  return {
+    entries,
+    isSupported,
+    start() {
+      active(true);
+    },
+    stop() {
+      active(false);
+      cleanup();
+    },
+    active
+  };
+}
+
+// src/observer/useMutationObserver.ts
+var import_runtime14 = require("@fictjs/runtime");
+var import_advanced13 = require("@fictjs/runtime/advanced");
+function useMutationObserver(target, callback, options = {}) {
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  const observerCtor = windowRef?.MutationObserver ?? globalThis.MutationObserver;
+  const records = (0, import_advanced13.createSignal)([]);
+  const isSupported = (0, import_advanced13.createSignal)(!!observerCtor);
+  const active = (0, import_advanced13.createSignal)(true);
+  let cleanup = () => {
+  };
+  (0, import_runtime14.createEffect)(() => {
+    cleanup();
+    if (!active()) {
+      return;
+    }
+    const Observer = observerCtor;
+    if (!Observer) {
+      isSupported(false);
+      return;
+    }
+    isSupported(true);
+    const observer = new Observer(
+      (nextRecords, currentObserver) => {
+        records(nextRecords);
+        callback?.(nextRecords, currentObserver);
+      }
+    );
+    const targets = resolveTargetList(target);
+    const observeOptions = {
+      subtree: options.subtree ?? true,
+      childList: options.childList ?? true,
+      attributes: options.attributes,
+      characterData: options.characterData,
+      attributeFilter: options.attributeFilter,
+      attributeOldValue: options.attributeOldValue,
+      characterDataOldValue: options.characterDataOldValue
+    };
+    for (const element of targets) {
+      observer.observe(element, observeOptions);
+    }
+    cleanup = () => {
+      observer.disconnect();
+      cleanup = () => {
+      };
+    };
+    (0, import_runtime14.onCleanup)(() => {
+      cleanup();
+    });
+  });
+  return {
+    records,
+    isSupported,
+    active,
+    start() {
+      active(true);
+    },
+    stop() {
+      active(false);
+      cleanup();
+    }
+  };
+}
+
+// src/observer/useResizeObserver.ts
+var import_runtime15 = require("@fictjs/runtime");
+var import_advanced14 = require("@fictjs/runtime/advanced");
+function useResizeObserver(target, callback, options = {}) {
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  const observerCtor = windowRef?.ResizeObserver ?? globalThis.ResizeObserver;
+  const entries = (0, import_advanced14.createSignal)([]);
+  const isSupported = (0, import_advanced14.createSignal)(!!observerCtor);
+  const active = (0, import_advanced14.createSignal)(true);
+  let cleanup = () => {
+  };
+  (0, import_runtime15.createEffect)(() => {
+    cleanup();
+    if (!active()) {
+      return;
+    }
+    const Observer = observerCtor;
+    if (!Observer) {
+      isSupported(false);
+      return;
+    }
+    isSupported(true);
+    const observer = new Observer(
+      (nextEntries, currentObserver) => {
+        entries(nextEntries);
+        callback?.(nextEntries, currentObserver);
+      }
+    );
+    const targets = resolveTargetList(target);
+    for (const element of targets) {
+      observer.observe(element, options.box ? { box: options.box } : void 0);
+    }
+    cleanup = () => {
+      observer.disconnect();
+      cleanup = () => {
+      };
+    };
+    (0, import_runtime15.onCleanup)(() => {
+      cleanup();
+    });
+  });
+  return {
+    entries,
+    isSupported,
+    active,
+    start() {
+      active(true);
+    },
+    stop() {
+      active(false);
+      cleanup();
+    }
+  };
+}
+
+// src/state/useCounter.ts
+var import_advanced15 = require("@fictjs/runtime/advanced");
+function clamp(value, min, max) {
+  let next = value;
+  if (min != null) {
+    next = Math.max(min, next);
+  }
+  if (max != null) {
+    next = Math.min(max, next);
+  }
+  return next;
+}
+function useCounter(initial = 0, options = {}) {
+  const start = clamp(initial, options.min, options.max);
+  const count = (0, import_advanced15.createSignal)(start);
+  return {
+    count,
+    set(next) {
+      count(clamp(next, options.min, options.max));
+    },
+    inc(delta = 1) {
+      count(clamp(count() + delta, options.min, options.max));
+    },
+    dec(delta = 1) {
+      count(clamp(count() - delta, options.min, options.max));
+    },
+    reset() {
+      count(start);
+    }
+  };
+}
+
+// src/state/usePrevious.ts
+var import_runtime16 = require("@fictjs/runtime");
+var import_advanced16 = require("@fictjs/runtime/advanced");
+function usePrevious(value) {
+  const previous = (0, import_advanced16.createSignal)(void 0);
+  let lastValue;
+  let initialized = false;
+  (0, import_runtime16.createEffect)(() => {
+    const current = toValue(value);
+    if (initialized) {
+      previous(lastValue);
+    }
+    lastValue = current;
+    initialized = true;
+  });
+  return previous;
+}
+
+// src/state/useToggle.ts
+var import_advanced17 = require("@fictjs/runtime/advanced");
+function useToggle(initial = false) {
+  const value = (0, import_advanced17.createSignal)(initial);
+  return {
+    value,
+    toggle() {
+      value(!value());
+    },
+    set(next) {
+      value(next);
+    },
+    setTrue() {
+      value(true);
+    },
+    setFalse() {
+      value(false);
+    }
+  };
+}
+
+// src/state/useVirtualList.ts
+var import_runtime17 = require("@fictjs/runtime");
+var import_advanced18 = require("@fictjs/runtime/advanced");
+function useVirtualList(source, options) {
+  const overscan = options.overscan ?? 2;
+  const itemHeight = options.itemHeight;
+  const scrollTop = (0, import_advanced18.createSignal)(options.initialScrollTop ?? 0);
+  const totalHeight = (0, import_runtime17.createMemo)(() => toValue(source).length * itemHeight);
+  const start = (0, import_runtime17.createMemo)(() => {
+    const base = Math.floor(scrollTop() / itemHeight) - overscan;
+    return Math.max(0, base);
+  });
+  const end = (0, import_runtime17.createMemo)(() => {
+    const items = toValue(source);
+    const containerHeight = toValue(options.containerHeight);
+    const visibleCount = Math.ceil(containerHeight / itemHeight) + overscan * 2;
+    return Math.min(items.length, start() + visibleCount);
+  });
+  const list = (0, import_runtime17.createMemo)(() => {
+    const items = toValue(source);
+    const from = start();
+    const to = end();
+    const result = [];
+    for (let index = from; index < to; index += 1) {
+      result.push({
+        index,
+        data: items[index],
+        start: index * itemHeight,
+        end: (index + 1) * itemHeight
+      });
+    }
+    return result;
+  });
+  const setScrollTop = (value) => {
+    scrollTop(Math.max(0, value));
+  };
+  const scrollTo = (index) => {
+    setScrollTop(index * itemHeight);
+  };
+  const onScroll = (event) => {
+    const element = event.target;
+    if (!element) {
+      return;
+    }
+    setScrollTop(element.scrollTop);
+  };
+  return {
+    list,
+    totalHeight,
+    start,
+    end,
+    scrollTop,
+    setScrollTop,
+    scrollTo,
+    onScroll
+  };
+}
+
+// src/browser/useDocumentVisibility.ts
+var import_runtime18 = require("@fictjs/runtime");
+var import_advanced19 = require("@fictjs/runtime/advanced");
+function useDocumentVisibility(options = {}) {
+  const documentRef = options.document === void 0 ? defaultDocument : options.document;
+  const fallback = options.initialVisibility ?? "visible";
+  const visibility = (0, import_advanced19.createSignal)(documentRef?.visibilityState ?? fallback);
+  const update = () => {
+    visibility(documentRef?.visibilityState ?? fallback);
+  };
+  useEventListener(documentRef, "visibilitychange", update, { passive: true });
+  const hidden = (0, import_runtime18.createMemo)(() => visibility() !== "visible");
+  return {
+    visibility,
+    hidden
+  };
+}
+
+// src/browser/useMediaQuery.ts
+var import_runtime19 = require("@fictjs/runtime");
+var import_advanced20 = require("@fictjs/runtime/advanced");
+function useMediaQuery(mediaQuery, options = {}) {
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  const fallback = options.initialValue ?? false;
+  const matches = (0, import_advanced20.createSignal)(fallback);
+  const query = (0, import_advanced20.createSignal)(typeof mediaQuery === "string" ? mediaQuery : "");
+  const isSupported = (0, import_advanced20.createSignal)(!!windowRef?.matchMedia);
+  (0, import_runtime19.createEffect)(() => {
+    const nextQuery = toValue(mediaQuery);
+    query(nextQuery);
+    if (!windowRef?.matchMedia) {
+      isSupported(false);
+      matches(fallback);
+      return;
+    }
+    isSupported(true);
+    const mql = windowRef.matchMedia(nextQuery);
+    matches(mql.matches);
+    const listener = (event) => {
+      matches(event.matches);
+    };
+    mql.addEventListener("change", listener);
+    (0, import_runtime19.onCleanup)(() => {
+      mql.removeEventListener("change", listener);
+    });
+  });
+  return {
+    matches,
+    query,
+    isSupported
+  };
+}
+
+// src/browser/useNetwork.ts
+var import_advanced21 = require("@fictjs/runtime/advanced");
+function resolveConnection(navigatorRef) {
+  return navigatorRef?.connection ?? navigatorRef?.mozConnection ?? navigatorRef?.webkitConnection;
+}
+function useNetwork(options = {}) {
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  const navigatorRef = options.navigator === void 0 ? defaultNavigator : options.navigator;
+  const connection = resolveConnection(navigatorRef);
+  const online = (0, import_advanced21.createSignal)(navigatorRef?.onLine ?? true);
+  const downlink = (0, import_advanced21.createSignal)(connection?.downlink ?? null);
+  const effectiveType = (0, import_advanced21.createSignal)(connection?.effectiveType ?? null);
+  const rtt = (0, import_advanced21.createSignal)(connection?.rtt ?? null);
+  const saveData = (0, import_advanced21.createSignal)(connection?.saveData ?? false);
+  const type = (0, import_advanced21.createSignal)(connection?.type ?? null);
+  const isSupported = (0, import_advanced21.createSignal)(navigatorRef != null);
+  const update = () => {
+    const nextConnection = resolveConnection(navigatorRef);
+    online(navigatorRef?.onLine ?? true);
+    downlink(nextConnection?.downlink ?? null);
+    effectiveType(nextConnection?.effectiveType ?? null);
+    rtt(nextConnection?.rtt ?? null);
+    saveData(nextConnection?.saveData ?? false);
+    type(nextConnection?.type ?? null);
+  };
+  useEventListener(windowRef, "online", update, { passive: true });
+  useEventListener(windowRef, "offline", update, { passive: true });
+  if (connection) {
+    useEventListener(connection, "change", update, { passive: true });
+  }
+  update();
+  return {
+    online,
+    downlink,
+    effectiveType,
+    rtt,
+    saveData,
+    type,
+    isSupported
+  };
+}
+
+// src/browser/useScroll.ts
+var import_runtime20 = require("@fictjs/runtime");
+var import_advanced22 = require("@fictjs/runtime/advanced");
+function isWindowLike(target) {
+  if (!target || typeof target !== "object") {
+    return false;
+  }
+  return ("pageXOffset" in target || "scrollX" in target) && ("pageYOffset" in target || "scrollY" in target);
+}
+function readDocumentScrollPosition(documentRef, windowRef) {
+  const view = documentRef.defaultView ?? windowRef;
+  if (view) {
+    return {
+      x: view.pageXOffset ?? view.scrollX ?? 0,
+      y: view.pageYOffset ?? view.scrollY ?? 0
+    };
+  }
+  const scrolling = documentRef.scrollingElement ?? documentRef.documentElement ?? documentRef.body;
+  return {
+    x: scrolling?.scrollLeft ?? 0,
+    y: scrolling?.scrollTop ?? 0
+  };
+}
+function readScrollPosition(target, windowRef, fallback) {
+  if (!target) {
+    return fallback;
+  }
+  if ("documentElement" in target) {
+    return readDocumentScrollPosition(target, windowRef ?? void 0);
+  }
+  if (isWindowLike(target)) {
+    return {
+      x: target.pageXOffset ?? target.scrollX ?? 0,
+      y: target.pageYOffset ?? target.scrollY ?? 0
+    };
+  }
+  return {
+    x: target.scrollLeft ?? 0,
+    y: target.scrollTop ?? 0
+  };
+}
+function useScroll(options = {}) {
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  const fallback = {
+    x: options.initialX ?? 0,
+    y: options.initialY ?? 0
+  };
+  const x = (0, import_advanced22.createSignal)(fallback.x);
+  const y = (0, import_advanced22.createSignal)(fallback.y);
+  let previous = { ...fallback };
+  const resolveScrollTarget = () => {
+    if (options.target === null) {
+      return void 0;
+    }
+    if (options.target === void 0) {
+      return windowRef ?? void 0;
+    }
+    return resolveMaybeTarget(options.target);
+  };
+  const update = () => {
+    const next = readScrollPosition(resolveScrollTarget(), windowRef, fallback);
+    const shouldUpdate = options.shouldUpdate?.(next, previous) ?? true;
+    if (!shouldUpdate) {
+      return;
+    }
+    if (next.x === previous.x && next.y === previous.y) {
+      return;
+    }
+    previous = next;
+    x(next.x);
+    y(next.y);
+  };
+  useEventListener(() => resolveScrollTarget(), "scroll", update, {
+    passive: options.passive ?? true,
+    capture: options.capture
+  });
+  (0, import_runtime20.createEffect)(() => {
+    update();
+  });
+  return {
+    x,
+    y
+  };
+}
+
+// src/browser/usePermission.ts
+var import_runtime21 = require("@fictjs/runtime");
+var import_advanced23 = require("@fictjs/runtime/advanced");
+function normalizePermission(input) {
+  if (typeof input === "string") {
+    return { name: input };
+  }
+  return input;
+}
+function usePermission(permission, options = {}) {
+  const navigatorRef = options.navigator === void 0 ? defaultNavigator : options.navigator;
+  const initialState = options.initialState ?? "prompt";
+  const isSupported = (0, import_advanced23.createSignal)(!!navigatorRef?.permissions?.query);
+  const state = (0, import_advanced23.createSignal)(initialState);
+  let activePermission = normalizePermission(toValue(permission));
+  let cleanup = () => {
+  };
+  const bindStatus = (nextStatus) => {
+    cleanup();
+    state(nextStatus.state);
+    const onChange = () => {
+      state(nextStatus.state);
+    };
+    nextStatus.addEventListener("change", onChange);
+    cleanup = () => {
+      nextStatus.removeEventListener("change", onChange);
+      cleanup = () => {
+      };
+    };
+  };
+  const query = async () => {
+    if (!navigatorRef?.permissions?.query) {
+      isSupported(false);
+      return null;
+    }
+    isSupported(true);
+    try {
+      const nextStatus = await navigatorRef.permissions.query(activePermission);
+      bindStatus(nextStatus);
+      return nextStatus;
+    } catch {
+      state(initialState);
+      return null;
+    }
+  };
+  (0, import_runtime21.createEffect)(() => {
+    activePermission = normalizePermission(toValue(permission));
+    if (options.immediate ?? true) {
+      void query();
+    }
+  });
+  (0, import_runtime21.onDestroy)(() => {
+    cleanup();
+  });
+  return {
+    state,
+    isSupported,
+    query
+  };
+}
+
+// src/browser/useGeolocation.ts
+var import_runtime22 = require("@fictjs/runtime");
+var import_advanced24 = require("@fictjs/runtime/advanced");
+function createInitialCoords() {
+  return {
+    accuracy: 0,
+    latitude: Number.POSITIVE_INFINITY,
+    longitude: Number.POSITIVE_INFINITY,
+    altitude: null,
+    altitudeAccuracy: null,
+    heading: null,
+    speed: null
+  };
+}
+function useGeolocation(options = {}) {
+  const navigatorRef = options.navigator === void 0 ? defaultNavigator : options.navigator;
+  const geolocationRef = navigatorRef?.geolocation;
+  const isSupported = (0, import_advanced24.createSignal)(!!geolocationRef);
+  const coords = (0, import_advanced24.createSignal)(createInitialCoords());
+  const locatedAt = (0, import_advanced24.createSignal)(null);
+  const error = (0, import_advanced24.createSignal)(null);
+  const active = (0, import_advanced24.createSignal)(false);
+  let watchId = null;
+  const resume = () => {
+    if (!geolocationRef || active()) {
+      if (!geolocationRef) {
+        isSupported(false);
+      }
+      return;
+    }
+    watchId = geolocationRef.watchPosition(
+      (position) => {
+        coords({
+          accuracy: position.coords.accuracy,
+          latitude: position.coords.latitude,
+          longitude: position.coords.longitude,
+          altitude: position.coords.altitude,
+          altitudeAccuracy: position.coords.altitudeAccuracy,
+          heading: position.coords.heading,
+          speed: position.coords.speed
+        });
+        locatedAt(position.timestamp);
+        error(null);
+      },
+      (nextError) => {
+        error(nextError);
+      },
+      {
+        enableHighAccuracy: options.enableHighAccuracy,
+        timeout: options.timeout,
+        maximumAge: options.maximumAge
+      }
+    );
+    active(true);
+  };
+  const pause = () => {
+    if (!geolocationRef || watchId == null) {
+      active(false);
+      return;
+    }
+    geolocationRef.clearWatch(watchId);
+    watchId = null;
+    active(false);
+  };
+  if (options.immediate ?? true) {
+    resume();
+  }
+  (0, import_runtime22.onDestroy)(() => {
+    pause();
+  });
+  return {
+    isSupported,
+    coords,
+    locatedAt,
+    error,
+    active,
+    resume,
+    pause
+  };
+}
+
+// src/browser/useIdle.ts
+var import_runtime23 = require("@fictjs/runtime");
+var import_advanced25 = require("@fictjs/runtime/advanced");
+var DEFAULT_IDLE_EVENTS = [
+  "mousemove",
+  "mousedown",
+  "resize",
+  "keydown",
+  "touchstart",
+  "wheel",
+  "pointerdown"
+];
+function useIdle(options = {}) {
+  const timeout = options.timeout ?? 6e4;
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  const documentRef = options.document === void 0 ? defaultDocument : options.document;
+  const events = options.events ?? [...DEFAULT_IDLE_EVENTS];
+  const listenForVisibilityChange = options.listenForVisibilityChange ?? true;
+  const idle = (0, import_advanced25.createSignal)(options.initialState ?? false);
+  const lastActive = (0, import_advanced25.createSignal)(null);
+  const isSupported = (0, import_advanced25.createSignal)(!!windowRef);
+  const active = (0, import_advanced25.createSignal)(false);
+  let timer = null;
+  const clearTimer = () => {
+    if (timer == null) {
+      return;
+    }
+    clearTimeout(timer);
+    timer = null;
+  };
+  const scheduleIdle = () => {
+    clearTimer();
+    if (!active() || !isSupported()) {
+      return;
+    }
+    timer = setTimeout(() => {
+      idle(true);
+    }, timeout);
+  };
+  const markActive = () => {
+    idle(false);
+    lastActive(Date.now());
+    scheduleIdle();
+  };
+  const activityListener = useEventListener(windowRef, events, markActive, {
+    passive: true,
+    immediate: false
+  });
+  const visibilityListener = useEventListener(
+    documentRef,
+    "visibilitychange",
+    () => {
+      if (!documentRef || documentRef.visibilityState !== "visible") {
+        return;
+      }
+      markActive();
+    },
+    {
+      passive: true,
+      immediate: false
+    }
+  );
+  const pause = () => {
+    if (!active()) {
+      return;
+    }
+    active(false);
+    activityListener.stop();
+    visibilityListener.stop();
+    clearTimer();
+  };
+  const resume = () => {
+    if (!windowRef || active()) {
+      if (!windowRef) {
+        isSupported(false);
+      }
+      return;
+    }
+    isSupported(true);
+    active(true);
+    activityListener.start();
+    if (listenForVisibilityChange) {
+      visibilityListener.start();
+    }
+    markActive();
+  };
+  const reset = () => {
+    markActive();
+  };
+  if (options.immediate ?? true) {
+    resume();
+  }
+  (0, import_runtime23.onDestroy)(() => {
+    pause();
+  });
+  return {
+    idle,
+    lastActive,
+    isSupported,
+    active,
+    reset,
+    pause,
+    resume
+  };
+}
+
+// src/browser/useSize.ts
+var import_runtime24 = require("@fictjs/runtime");
+var import_advanced26 = require("@fictjs/runtime/advanced");
+function readRect(target) {
+  const rect = target.getBoundingClientRect();
+  return {
+    width: rect.width,
+    height: rect.height,
+    top: rect.top,
+    left: rect.left,
+    x: rect.x ?? rect.left,
+    y: rect.y ?? rect.top
+  };
+}
+function useSize(target, options = {}) {
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  const observerCtor = windowRef?.ResizeObserver ?? globalThis.ResizeObserver;
+  const width = (0, import_advanced26.createSignal)(options.initialWidth ?? 0);
+  const height = (0, import_advanced26.createSignal)(options.initialHeight ?? 0);
+  const top = (0, import_advanced26.createSignal)(options.initialTop ?? 0);
+  const left = (0, import_advanced26.createSignal)(options.initialLeft ?? 0);
+  const x = (0, import_advanced26.createSignal)(options.initialX ?? options.initialLeft ?? 0);
+  const y = (0, import_advanced26.createSignal)(options.initialY ?? options.initialTop ?? 0);
+  const isSupported = (0, import_advanced26.createSignal)(!!observerCtor);
+  const active = (0, import_advanced26.createSignal)(options.immediate ?? true);
+  let observer = null;
+  const applyRect = (nextTarget) => {
+    const rect = readRect(nextTarget);
+    width(rect.width);
+    height(rect.height);
+    top(rect.top);
+    left(rect.left);
+    x(rect.x);
+    y(rect.y);
+  };
+  const update = () => {
+    const nextTarget = resolveMaybeTarget(target);
+    if (!nextTarget) {
+      return;
+    }
+    applyRect(nextTarget);
+  };
+  const resizeListener = useEventListener(windowRef, "resize", update, {
+    passive: true,
+    immediate: false
+  });
+  const stopObserver = () => {
+    if (!observer) {
+      return;
+    }
+    observer.disconnect();
+    observer = null;
+  };
+  (0, import_runtime24.createEffect)(() => {
+    stopObserver();
+    const nextTarget = target ? resolveMaybeTarget(target) : void 0;
+    if (!active() || !nextTarget) {
+      resizeListener.stop();
+      return;
+    }
+    applyRect(nextTarget);
+    if (windowRef) {
+      resizeListener.start();
+    }
+    const Observer = observerCtor;
+    if (!Observer) {
+      isSupported(false);
+      return;
+    }
+    isSupported(true);
+    observer = new Observer((entries) => {
+      const entry = entries[0];
+      if (entry?.contentRect) {
+        width(entry.contentRect.width);
+        height(entry.contentRect.height);
+        applyRect(nextTarget);
+        return;
+      }
+      applyRect(nextTarget);
+    });
+    observer.observe(nextTarget, options.box ? { box: options.box } : void 0);
+    (0, import_runtime24.onCleanup)(() => {
+      stopObserver();
+    });
+  });
+  return {
+    width,
+    height,
+    top,
+    left,
+    x,
+    y,
+    isSupported,
+    active,
+    update,
+    start() {
+      active(true);
+    },
+    stop() {
+      active(false);
+      resizeListener.stop();
+      stopObserver();
+    }
+  };
+}
+
+// src/browser/useWebSocket.ts
+var import_runtime25 = require("@fictjs/runtime");
+var import_advanced27 = require("@fictjs/runtime/advanced");
+function normalizeReconnectOptions(value) {
+  if (!value) {
+    return null;
+  }
+  if (value === true) {
+    return { retries: Infinity, delay: 1e3 };
+  }
+  return {
+    retries: value.retries ?? Infinity,
+    delay: value.delay ?? 1e3
+  };
+}
+function toStatus(value, socket) {
+  switch (value) {
+    case socket.CONNECTING:
+      return "CONNECTING";
+    case socket.OPEN:
+      return "OPEN";
+    case socket.CLOSING:
+      return "CLOSING";
+    default:
+      return "CLOSED";
+  }
+}
+function useWebSocket(url, options = {}) {
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  const windowSocketCtor = windowRef?.WebSocket;
+  const webSocketCtor = options.webSocket === void 0 ? windowSocketCtor ?? globalThis.WebSocket : options.webSocket;
+  const reconnectOptions = normalizeReconnectOptions(options.autoReconnect);
+  const data = (0, import_advanced27.createSignal)(options.initialData ?? null);
+  const error = (0, import_advanced27.createSignal)(null);
+  const status = (0, import_advanced27.createSignal)("CLOSED");
+  const isSupported = (0, import_advanced27.createSignal)(!!webSocketCtor);
+  const reconnectCount = (0, import_advanced27.createSignal)(0);
+  const serialize = options.serialize ?? ((payload) => payload);
+  const deserialize = options.deserialize ?? ((event) => event.data);
+  let socket = null;
+  let manuallyClosed = false;
+  let reconnectTimer = null;
+  let reconnectAttempts = 0;
+  let cleanupSocket = () => {
+  };
+  const stopReconnectTimer = () => {
+    if (reconnectTimer == null) {
+      return;
+    }
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+  };
+  const resetReconnectAttempts = () => {
+    reconnectAttempts = 0;
+    reconnectCount(0);
+  };
+  const scheduleReconnect = () => {
+    if (!reconnectOptions) {
+      return;
+    }
+    const retries = reconnectOptions.retries ?? Infinity;
+    if (reconnectAttempts >= retries) {
+      return;
+    }
+    reconnectAttempts += 1;
+    reconnectCount(reconnectAttempts);
+    const delayValue = reconnectOptions.delay ?? 1e3;
+    const delay2 = typeof delayValue === "function" ? delayValue(reconnectAttempts) : delayValue;
+    stopReconnectTimer();
+    reconnectTimer = setTimeout(
+      () => {
+        reconnectTimer = null;
+        open();
+      },
+      Math.max(0, delay2)
+    );
+  };
+  const open = () => {
+    const resolvedUrl = toValue(url);
+    if (!webSocketCtor || !resolvedUrl) {
+      isSupported(false);
+      return false;
+    }
+    if (socket && (socket.readyState === socket.CONNECTING || socket.readyState === socket.OPEN)) {
+      return true;
+    }
+    stopReconnectTimer();
+    manuallyClosed = false;
+    error(null);
+    let currentSocket;
+    try {
+      currentSocket = new webSocketCtor(resolvedUrl, options.protocols);
+    } catch (nextError) {
+      error(nextError);
+      status("CLOSED");
+      scheduleReconnect();
+      return false;
+    }
+    socket = currentSocket;
+    status(toStatus(currentSocket.readyState, currentSocket));
+    if (options.binaryType) {
+      currentSocket.binaryType = options.binaryType;
+    }
+    const onOpen = (event) => {
+      if (socket !== currentSocket) {
+        return;
+      }
+      status("OPEN");
+      resetReconnectAttempts();
+      options.onOpen?.(event);
+    };
+    const onMessage = (event) => {
+      if (socket !== currentSocket) {
+        return;
+      }
+      const messageEvent = event;
+      const nextData = deserialize(messageEvent);
+      data(nextData);
+      options.onMessage?.(nextData, messageEvent);
+    };
+    const onError = (event) => {
+      if (socket !== currentSocket) {
+        return;
+      }
+      error(event);
+      options.onError?.(event);
+    };
+    const onClose = (event) => {
+      if (socket !== currentSocket) {
+        return;
+      }
+      socket = null;
+      cleanupSocket();
+      status("CLOSED");
+      options.onClose?.(event);
+      if (!manuallyClosed) {
+        scheduleReconnect();
+      }
+    };
+    currentSocket.addEventListener("open", onOpen);
+    currentSocket.addEventListener("message", onMessage);
+    currentSocket.addEventListener("error", onError);
+    currentSocket.addEventListener("close", onClose);
+    cleanupSocket = () => {
+      currentSocket.removeEventListener("open", onOpen);
+      currentSocket.removeEventListener("message", onMessage);
+      currentSocket.removeEventListener("error", onError);
+      currentSocket.removeEventListener("close", onClose);
+      cleanupSocket = () => {
+      };
+    };
+    return true;
+  };
+  const close = (code, reason) => {
+    stopReconnectTimer();
+    resetReconnectAttempts();
+    manuallyClosed = true;
+    const currentSocket = socket;
+    if (!currentSocket) {
+      status("CLOSED");
+      return;
+    }
+    socket = null;
+    cleanupSocket();
+    status("CLOSING");
+    currentSocket.close(code, reason);
+    status("CLOSED");
+  };
+  const reconnect = () => {
+    stopReconnectTimer();
+    if (socket) {
+      const currentSocket = socket;
+      socket = null;
+      cleanupSocket();
+      manuallyClosed = true;
+      currentSocket.close();
+    }
+    manuallyClosed = false;
+    return open();
+  };
+  const send = (payload) => {
+    const currentSocket = socket;
+    if (!currentSocket || currentSocket.readyState !== currentSocket.OPEN) {
+      return false;
+    }
+    try {
+      currentSocket.send(serialize(payload));
+      return true;
+    } catch (nextError) {
+      error(nextError);
+      return false;
+    }
+  };
+  if (options.immediate ?? true) {
+    open();
+  }
+  (0, import_runtime25.onDestroy)(() => {
+    stopReconnectTimer();
+    close();
+  });
+  return {
+    data,
+    error,
+    status,
+    isSupported,
+    reconnectCount,
+    open,
+    close,
+    reconnect,
+    send
+  };
+}
+
+// src/browser/useWindowSize.ts
+var import_advanced28 = require("@fictjs/runtime/advanced");
+function useWindowSize(options = {}) {
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  const width = (0, import_advanced28.createSignal)(windowRef?.innerWidth ?? options.initialWidth ?? 0);
+  const height = (0, import_advanced28.createSignal)(windowRef?.innerHeight ?? options.initialHeight ?? 0);
+  const update = () => {
+    if (!windowRef) {
+      return;
+    }
+    width(windowRef.innerWidth);
+    height(windowRef.innerHeight);
+  };
+  useEventListener(windowRef, "resize", update, { passive: true });
+  if (windowRef) {
+    update();
+  }
+  return {
+    width,
+    height
+  };
+}
+
+// src/browser/useWindowScroll.ts
+function useWindowScroll(options = {}) {
+  const windowRef = options.window === void 0 ? defaultWindow : options.window;
+  return useScroll({
+    ...options,
+    window: windowRef,
+    target: windowRef
+  });
+}
+
+// src/browser/useTitle.ts
+var import_runtime26 = require("@fictjs/runtime");
+var import_advanced29 = require("@fictjs/runtime/advanced");
+function useTitle(value, options = {}) {
+  const documentRef = options.document === void 0 ? defaultDocument : options.document;
+  const initialTitle = documentRef?.title ?? "";
+  const title = (0, import_advanced29.createSignal)(documentRef?.title ?? toValue(value));
+  (0, import_runtime26.createEffect)(() => {
+    const nextTitle = toValue(value);
+    title(nextTitle);
+    if (documentRef) {
+      documentRef.title = nextTitle;
+    }
+  });
+  if (options.restoreOnUnmount) {
+    (0, import_runtime26.onDestroy)(() => {
+      if (documentRef) {
+        documentRef.title = initialTitle;
+      }
+    });
+  }
+  return { title };
+}
+
+// src/browser/useFullscreen.ts
+var import_runtime27 = require("@fictjs/runtime");
+var import_advanced30 = require("@fictjs/runtime/advanced");
+function getFullscreenElement(documentRef) {
+  return documentRef.fullscreenElement ?? documentRef.webkitFullscreenElement ?? documentRef.mozFullScreenElement ?? documentRef.msFullscreenElement ?? null;
+}
+function isFullscreenSupported(documentRef) {
+  if (!documentRef) {
+    return false;
+  }
+  if (documentRef.fullscreenEnabled || documentRef.webkitFullscreenEnabled || documentRef.mozFullScreenEnabled || documentRef.msFullscreenEnabled) {
+    return true;
+  }
+  return typeof documentRef.exitFullscreen === "function" || typeof documentRef.webkitExitFullscreen === "function" || typeof documentRef.mozCancelFullScreen === "function" || typeof documentRef.msExitFullscreen === "function";
+}
+function resolveRequestMethod(target) {
+  return target.requestFullscreen ?? target.webkitRequestFullscreen ?? target.webkitRequestFullScreen ?? target.mozRequestFullScreen ?? target.msRequestFullscreen;
+}
+function resolveExitMethod(documentRef) {
+  return documentRef.exitFullscreen ?? documentRef.webkitExitFullscreen ?? documentRef.mozCancelFullScreen ?? documentRef.msExitFullscreen;
+}
+function resolveTargetElement(options, documentRef) {
+  if (!documentRef) {
+    return void 0;
+  }
+  if (options.target === null) {
+    return void 0;
+  }
+  if (options.target === void 0) {
+    return documentRef.documentElement ?? void 0;
+  }
+  return resolveMaybeTarget(options.target);
+}
+function useFullscreen(options = {}) {
+  const documentRef = options.document === void 0 ? defaultDocument : options.document;
+  const isSupported = (0, import_advanced30.createSignal)(isFullscreenSupported(documentRef));
+  const isFullscreen = (0, import_advanced30.createSignal)(false);
+  const update = () => {
+    if (!documentRef) {
+      isFullscreen(false);
+      isSupported(false);
+      return;
+    }
+    isSupported(isFullscreenSupported(documentRef));
+    const target = resolveTargetElement(options, documentRef);
+    const fullscreenElement = getFullscreenElement(documentRef);
+    isFullscreen(!!target && !!fullscreenElement && fullscreenElement === target);
+  };
+  useEventListener(
+    documentRef,
+    ["fullscreenchange", "webkitfullscreenchange", "mozfullscreenchange", "MSFullscreenChange"],
+    update,
+    { passive: true }
+  );
+  (0, import_runtime27.createEffect)(() => {
+    resolveTargetElement(options, documentRef);
+    update();
+  });
+  const enter = async () => {
+    if (!documentRef || !isSupported()) {
+      return false;
+    }
+    const target = resolveTargetElement(options, documentRef);
+    if (!target) {
+      return false;
+    }
+    const request = resolveRequestMethod(target);
+    if (!request) {
+      return false;
+    }
+    try {
+      await request.call(target);
+      update();
+      return true;
+    } catch {
+      update();
+      return false;
+    }
+  };
+  const exit = async () => {
+    if (!documentRef || !isSupported()) {
+      return false;
+    }
+    const exitMethod = resolveExitMethod(documentRef);
+    if (!exitMethod) {
+      return false;
+    }
+    try {
+      await exitMethod.call(documentRef);
+      update();
+      return true;
+    } catch {
+      update();
+      return false;
+    }
+  };
+  const toggle = async () => {
+    return isFullscreen() ? exit() : enter();
+  };
+  if (options.autoExit) {
+    (0, import_runtime27.onDestroy)(() => {
+      void exit();
+    });
+  }
+  return {
+    isSupported,
+    isFullscreen,
+    enter,
+    exit,
+    toggle
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useAsyncState,
+  useClickOutside,
+  useClipboard,
+  useCounter,
+  useDebounceFn,
+  useDocumentVisibility,
+  useEventListener,
+  useFetch,
+  useFocusWithin,
+  useFullscreen,
+  useGeolocation,
+  useHover,
+  useIdle,
+  useIntersectionObserver,
+  useIntervalFn,
+  useKeyPress,
+  useLocalStorage,
+  useMediaQuery,
+  useMount,
+  useMutationObserver,
+  useNetwork,
+  usePermission,
+  usePrevious,
+  useRafFn,
+  useRequest,
+  useResizeObserver,
+  useScroll,
+  useSessionStorage,
+  useSize,
+  useStorage,
+  useThrottleFn,
+  useTimeoutFn,
+  useTitle,
+  useToggle,
+  useUnmount,
+  useVirtualList,
+  useWebSocket,
+  useWindowScroll,
+  useWindowSize
+});
+//# sourceMappingURL=index.cjs.map