@stacksjs/composables 0.70.87 → 0.70.90

package/dist/useMutationObserver.js

@@ -0,0 +1,27 @@
+import { onUnmounted, ref } from "@stacksjs/stx";
+import { unref, noop } from "./_shared";
+export function useMutationObserver(target, callback, options) {
+  const isSupported = ref(typeof window < "u" && "MutationObserver" in window);
+  let cleanup = noop;
+  (() => {
+    cleanup();
+    if (!isSupported.value)
+      return;
+    const el = unref(target);
+    if (!el)
+      return;
+    const observer = new MutationObserver(callback);
+    observer.observe(el, options ?? { childList: !0, subtree: !0 });
+    cleanup = () => {
+      observer.disconnect();
+      cleanup = noop;
+    };
+  })();
+  const stop = () => {
+    cleanup();
+  };
+  try {
+    onUnmounted(stop);
+  } catch {}
+  return { isSupported, stop };
+}

package/dist/useNavigatorLanguage.d.ts

@@ -0,0 +1,5 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Reactive navigator language.
+ */
+export declare function useNavigatorLanguage(): { language: Ref<string>, isSupported: Ref<boolean> };

package/dist/useNavigatorLanguage.js

@@ -0,0 +1,17 @@
+import { onUnmounted, ref } from "@stacksjs/stx";
+export function useNavigatorLanguage() {
+  const isSupported = ref(typeof navigator < "u" && "language" in navigator), language = ref(isSupported.value ? navigator.language : "");
+  if (typeof window < "u") {
+    const handler = () => {
+      if (isSupported.value)
+        language.value = navigator.language;
+    };
+    window.addEventListener("languagechange", handler, { passive: !0 });
+    try {
+      onUnmounted(() => {
+        window.removeEventListener("languagechange", handler);
+      });
+    } catch {}
+  }
+  return { language, isSupported };
+}

package/dist/useNetwork.d.ts

@@ -0,0 +1,18 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Reactive Network Information API.
+ */
+export declare function useNetwork(): UseNetworkReturn;
+export declare interface UseNetworkReturn {
+  isSupported: Ref<boolean>
+  isOnline: Ref<boolean>
+  offlineAt: Ref<number | undefined>
+  onlineAt: Ref<number | undefined>
+  downlink: Ref<number | undefined>
+  downlinkMax: Ref<number | undefined>
+  effectiveType: Ref<NetworkEffectiveType>
+  rtt: Ref<number | undefined>
+  saveData: Ref<boolean | undefined>
+  type: Ref<string | undefined>
+}
+export type NetworkEffectiveType = 'slow-2g' | '2g' | '3g' | '4g' | undefined;

package/dist/useNetwork.js

@@ -0,0 +1,58 @@
+import { onUnmounted, ref } from "@stacksjs/stx";
+export function useNetwork() {
+  const isSupported = ref(typeof navigator < "u" && "connection" in navigator), isOnline = ref(typeof navigator < "u" ? navigator.onLine : !0), offlineAt = ref(void 0), onlineAt = ref(void 0), downlink = ref(void 0), downlinkMax = ref(void 0), effectiveType = ref(void 0), rtt = ref(void 0), saveData = ref(void 0), type = ref(void 0);
+  function updateNetworkInfo() {
+    if (!isSupported.value)
+      return;
+    const conn = navigator.connection;
+    if (conn) {
+      downlink.value = conn.downlink;
+      downlinkMax.value = conn.downlinkMax;
+      effectiveType.value = conn.effectiveType;
+      rtt.value = conn.rtt;
+      saveData.value = conn.saveData;
+      type.value = conn.type;
+    }
+  }
+  updateNetworkInfo();
+  if (typeof window < "u") {
+    const onOnline = () => {
+      isOnline.value = !0;
+      onlineAt.value = Date.now();
+    }, onOffline = () => {
+      isOnline.value = !1;
+      offlineAt.value = Date.now();
+    };
+    window.addEventListener("online", onOnline);
+    window.addEventListener("offline", onOffline);
+    try {
+      onUnmounted(() => {
+        window.removeEventListener("online", onOnline);
+        window.removeEventListener("offline", onOffline);
+      });
+    } catch {}
+    if (isSupported.value) {
+      const conn = navigator.connection;
+      if (conn?.addEventListener) {
+        conn.addEventListener("change", updateNetworkInfo);
+        try {
+          onUnmounted(() => {
+            conn.removeEventListener("change", updateNetworkInfo);
+          });
+        } catch {}
+      }
+    }
+  }
+  return {
+    isSupported,
+    isOnline,
+    offlineAt,
+    onlineAt,
+    downlink,
+    downlinkMax,
+    effectiveType,
+    rtt,
+    saveData,
+    type
+  };
+}

package/dist/useNow.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Reactive current time.
+ * Returns a ref that updates every `interval` milliseconds.
+ *
+ * @param options - Configuration with interval (default 1000ms)
+ */
+export declare function useNow(options?: { interval?: number }): Ref<Date>;

package/dist/useNow.js

@@ -0,0 +1,10 @@
+import { onUnmounted, ref } from "@stacksjs/stx";
+export function useNow(options) {
+  const interval = options?.interval ?? 1000, now = ref(new Date), timer = setInterval(() => {
+    now.value = new Date;
+  }, interval);
+  try {
+    onUnmounted(() => clearInterval(timer));
+  } catch {}
+  return now;
+}

package/dist/useObjectUrl.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Reactive URL representing an object (Blob/File).
+ * The URL is automatically revoked when the source changes or on unmount.
+ *
+ * @param source - A ref containing a Blob, File, MediaSource, or null/undefined
+ */
+export declare function useObjectUrl(source: Ref<Blob | File | MediaSource | null | undefined>): Ref<string | undefined>;

package/dist/useObjectUrl.js

@@ -0,0 +1,23 @@
+import { onUnmounted, ref, watch } from "@stacksjs/stx";
+export function useObjectUrl(source) {
+  const url = ref(void 0);
+  function release() {
+    if (url.value) {
+      URL.revokeObjectURL(url.value);
+      url.value = void 0;
+    }
+  }
+  function update(val) {
+    release();
+    if (val)
+      url.value = URL.createObjectURL(val);
+  }
+  update(source.value);
+  watch(source, (val) => {
+    update(val);
+  });
+  try {
+    onUnmounted(() => release());
+  } catch {}
+  return url;
+}

package/dist/useOffsetPagination.d.ts

@@ -0,0 +1,21 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Reactive offset-based pagination.
+ */
+export declare function useOffsetPagination(options?: UseOffsetPaginationOptions): UseOffsetPaginationReturn;
+export declare interface UseOffsetPaginationOptions {
+  total?: Ref<number> | number
+  pageSize?: number
+  page?: number
+  onPageChange?: (returnValue: { currentPage: number, currentPageSize: number }) => void
+  onPageSizeChange?: (returnValue: { currentPage: number, currentPageSize: number }) => void
+}
+export declare interface UseOffsetPaginationReturn {
+  currentPage: Ref<number>
+  currentPageSize: Ref<number>
+  pageCount: Ref<number>
+  isFirstPage: Ref<boolean>
+  isLastPage: Ref<boolean>
+  prev: () => void
+  next: () => void
+}

package/dist/useOffsetPagination.js

@@ -0,0 +1,45 @@
+import { computed, ref, watch } from "@stacksjs/stx";
+export function useOffsetPagination(options = {}) {
+  const {
+    total: totalOption,
+    pageSize = 10,
+    page = 1,
+    onPageChange,
+    onPageSizeChange
+  } = options, currentPage = ref(page), currentPageSize = ref(pageSize), totalItems = typeof totalOption === "object" && totalOption && "value" in totalOption ? totalOption : ref(typeof totalOption === "number" ? totalOption : 0), pageCount = ref(Math.max(1, Math.ceil(totalItems.value / currentPageSize.value))), isFirstPage = ref(currentPage.value <= 1), isLastPage = ref(currentPage.value >= pageCount.value);
+  function updateComputed() {
+    pageCount.value = Math.max(1, Math.ceil(totalItems.value / currentPageSize.value));
+    isFirstPage.value = currentPage.value <= 1;
+    isLastPage.value = currentPage.value >= pageCount.value;
+  }
+  watch(currentPage, () => {
+    updateComputed();
+    onPageChange?.({ currentPage: currentPage.value, currentPageSize: currentPageSize.value });
+  });
+  watch(currentPageSize, () => {
+    currentPage.value = 1;
+    updateComputed();
+    onPageSizeChange?.({ currentPage: currentPage.value, currentPageSize: currentPageSize.value });
+  });
+  watch(totalItems, () => {
+    updateComputed();
+  });
+  function prev() {
+    if (currentPage.value > 1)
+      currentPage.value--;
+  }
+  function next() {
+    if (currentPage.value < pageCount.value)
+      currentPage.value++;
+  }
+  updateComputed();
+  return {
+    currentPage,
+    currentPageSize,
+    pageCount,
+    isFirstPage,
+    isLastPage,
+    prev,
+    next
+  };
+}

package/dist/useOnline.d.ts

@@ -0,0 +1,7 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Reactive online status.
+ * Tracks navigator.onLine and listens for online/offline events.
+ * In non-browser environments, defaults to true.
+ */
+export declare function useOnline(): Ref<boolean>;

package/dist/useOnline.js

@@ -0,0 +1,20 @@
+import { onUnmounted, ref } from "@stacksjs/stx";
+export function useOnline() {
+  const isOnline = ref(typeof navigator < "u" ? navigator.onLine : !0);
+  if (typeof window < "u") {
+    const onOnline = () => {
+      isOnline.value = !0;
+    }, onOffline = () => {
+      isOnline.value = !1;
+    };
+    window.addEventListener("online", onOnline);
+    window.addEventListener("offline", onOffline);
+    try {
+      onUnmounted(() => {
+        window.removeEventListener("online", onOnline);
+        window.removeEventListener("offline", onOffline);
+      });
+    } catch {}
+  }
+  return isOnline;
+}

package/dist/usePageLeave.d.ts

@@ -0,0 +1,9 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Page leave detection.
+ * Returns a ref that is true when the mouse has left the page (document).
+ * Uses mouseleave and mouseenter events on the document element.
+ *
+ * @returns A ref that is true when the mouse is outside the page
+ */
+export declare function usePageLeave(): Ref<boolean>;

package/dist/usePageLeave.js

@@ -0,0 +1,27 @@
+import { onUnmounted, ref } from "@stacksjs/stx";
+import { noop } from "./_shared";
+export function usePageLeave() {
+  const isLeft = ref(!1);
+  let cleanup = noop;
+  if (typeof document < "u") {
+    const cleanups = [], onLeave = (event) => {
+      if (event.clientY <= 0 || event.clientX <= 0 || event.clientX >= (typeof window < "u" ? window.innerWidth : 0) || event.clientY >= (typeof window < "u" ? window.innerHeight : 0))
+        isLeft.value = !0;
+    }, onEnter = () => {
+      isLeft.value = !1;
+    };
+    document.documentElement.addEventListener("mouseleave", onLeave);
+    document.documentElement.addEventListener("mouseenter", onEnter);
+    cleanups.push(() => document.documentElement.removeEventListener("mouseleave", onLeave), () => document.documentElement.removeEventListener("mouseenter", onEnter));
+    cleanup = () => {
+      for (const fn of cleanups)
+        fn();
+      cleanups.length = 0;
+      cleanup = noop;
+    };
+  }
+  try {
+    onUnmounted(() => cleanup());
+  } catch {}
+  return isLeft;
+}

package/dist/useParallax.d.ts

@@ -0,0 +1,15 @@
+import type { MaybeRef } from './_shared';
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Reactive parallax effect based on mouse position or device orientation.
+ */
+export declare function useParallax(target: MaybeRef<HTMLElement | null | undefined>, options?: UseParallaxOptions): UseParallaxReturn;
+export declare interface UseParallaxReturn {
+  tilt: Ref<number>
+  roll: Ref<number>
+  source: Ref<'mouse' | 'deviceOrientation'>
+}
+export declare interface UseParallaxOptions {
+  deviceOrientationTiltAdjust?: (value: number) => number
+  deviceOrientationRollAdjust?: (value: number) => number
+}

package/dist/useParallax.js

@@ -0,0 +1,33 @@
+import { onUnmounted, ref } from "@stacksjs/stx";
+import { unref } from "./_shared";
+export function useParallax(target, options = {}) {
+  const tilt = ref(0), roll = ref(0), source = ref("mouse");
+  if (typeof window > "u")
+    return { tilt, roll, source };
+  const mouseHandler = (e) => {
+    const el = unref(target);
+    if (!el)
+      return;
+    const rect = el.getBoundingClientRect(), centerX = rect.left + rect.width / 2, centerY = rect.top + rect.height / 2;
+    tilt.value = (e.clientX - centerX) / (rect.width / 2) * 0.5;
+    roll.value = (e.clientY - centerY) / (rect.height / 2) * 0.5;
+    source.value = "mouse";
+  };
+  window.addEventListener("mousemove", mouseHandler, { passive: !0 });
+  const orientationHandler = (e) => {
+    if (e.gamma !== null && e.beta !== null) {
+      const tiltVal = e.gamma / 90, rollVal = (e.beta - 45) / 90;
+      tilt.value = options.deviceOrientationTiltAdjust?.(tiltVal) ?? tiltVal * 0.5;
+      roll.value = options.deviceOrientationRollAdjust?.(rollVal) ?? rollVal * 0.5;
+      source.value = "deviceOrientation";
+    }
+  };
+  window.addEventListener("deviceorientation", orientationHandler, { passive: !0 });
+  try {
+    onUnmounted(() => {
+      window.removeEventListener("mousemove", mouseHandler);
+      window.removeEventListener("deviceorientation", orientationHandler);
+    });
+  } catch {}
+  return { tilt, roll, source };
+}

package/dist/useParentElement.d.ts

@@ -0,0 +1,6 @@
+import type { MaybeRef } from './_shared';
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Get the parent element of a given element.
+ */
+export declare function useParentElement(element?: MaybeRef<HTMLElement | null | undefined>): Ref<HTMLElement | null>;

package/dist/useParentElement.js

@@ -0,0 +1,8 @@
+import { ref } from "@stacksjs/stx";
+import { unref } from "./_shared";
+export function useParentElement(element) {
+  const parent = ref(null), el = unref(element);
+  if (el)
+    parent.value = el.parentElement;
+  return parent;
+}

package/dist/usePermission.d.ts

@@ -0,0 +1,7 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Reactive Permissions API.
+ *
+ * @param permissionName - Name of the permission to query
+ */
+export declare function usePermission(permissionName: PermissionName): { state: Ref<PermissionState>, isSupported: Ref<boolean> };

package/dist/usePermission.js

@@ -0,0 +1,21 @@
+import { onUnmounted, ref } from "@stacksjs/stx";
+export function usePermission(permissionName) {
+  const isSupported = ref(typeof navigator < "u" && "permissions" in navigator), state = ref("prompt");
+  if (!isSupported.value)
+    return { state, isSupported };
+  let permissionStatus = null;
+  navigator.permissions.query({ name: permissionName }).then((status) => {
+    permissionStatus = status;
+    state.value = status.state;
+    const handler = () => {
+      state.value = status.state;
+    };
+    status.addEventListener("change", handler);
+    try {
+      onUnmounted(() => {
+        status.removeEventListener("change", handler);
+      });
+    } catch {}
+  }).catch(() => {});
+  return { state, isSupported };
+}

package/dist/usePointer.d.ts

@@ -0,0 +1,15 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Reactive pointer position and state.
+ */
+export declare function usePointer(target?: HTMLElement | Window): UsePointerReturn;
+export declare interface UsePointerReturn {
+  isInside: Ref<boolean>
+  x: Ref<number>
+  y: Ref<number>
+  pointerId: Ref<number>
+  pressure: Ref<number>
+  tiltX: Ref<number>
+  tiltY: Ref<number>
+  pointerType: Ref<string>
+}

package/dist/usePointer.js

@@ -0,0 +1,32 @@
+import { onUnmounted, ref } from "@stacksjs/stx";
+export function usePointer(target) {
+  const x = ref(0), y = ref(0), pointerId = ref(0), pressure = ref(0), tiltX = ref(0), tiltY = ref(0), pointerType = ref(""), isInside = ref(!1);
+  if (typeof window > "u")
+    return { isInside, x, y, pointerId, pressure, tiltX, tiltY, pointerType };
+  const el = target ?? window, handler = (e) => {
+    x.value = e.pageX;
+    y.value = e.pageY;
+    pointerId.value = e.pointerId;
+    pressure.value = e.pressure;
+    tiltX.value = e.tiltX;
+    tiltY.value = e.tiltY;
+    pointerType.value = e.pointerType;
+  }, onEnter = () => {
+    isInside.value = !0;
+  }, onLeave = () => {
+    isInside.value = !1;
+  };
+  el.addEventListener("pointermove", handler, { passive: !0 });
+  el.addEventListener("pointerdown", handler, { passive: !0 });
+  el.addEventListener("pointerenter", onEnter, { passive: !0 });
+  el.addEventListener("pointerleave", onLeave, { passive: !0 });
+  try {
+    onUnmounted(() => {
+      el.removeEventListener("pointermove", handler);
+      el.removeEventListener("pointerdown", handler);
+      el.removeEventListener("pointerenter", onEnter);
+      el.removeEventListener("pointerleave", onLeave);
+    });
+  } catch {}
+  return { isInside, x, y, pointerId, pressure, tiltX, tiltY, pointerType };
+}

package/dist/usePointerLock.d.ts

@@ -0,0 +1,13 @@
+import type { MaybeRef } from './_shared';
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Reactive Pointer Lock API.
+ */
+export declare function usePointerLock(target?: MaybeRef<HTMLElement | null | undefined>): UsePointerLockReturn;
+export declare interface UsePointerLockReturn {
+  isSupported: Ref<boolean>
+  isLocked: Ref<boolean>
+  lock: (target?: HTMLElement) => Promise<void>
+  unlock: () => void
+  element: Ref<Element | null>
+}

package/dist/usePointerLock.js

@@ -0,0 +1,33 @@
+import { onUnmounted, ref } from "@stacksjs/stx";
+import { unref } from "./_shared";
+export function usePointerLock(target) {
+  const isSupported = ref(typeof document < "u" && "pointerLockElement" in document), isLocked = ref(!1), element = ref(null);
+  if (typeof document < "u") {
+    const handler = () => {
+      isLocked.value = !!document.pointerLockElement;
+      element.value = document.pointerLockElement;
+    };
+    document.addEventListener("pointerlockchange", handler);
+    document.addEventListener("pointerlockerror", handler);
+    try {
+      onUnmounted(() => {
+        document.removeEventListener("pointerlockchange", handler);
+        document.removeEventListener("pointerlockerror", handler);
+      });
+    } catch {}
+  }
+  async function lock(el) {
+    if (!isSupported.value)
+      return;
+    const targetEl = el ?? unref(target);
+    if (targetEl)
+      await targetEl.requestPointerLock();
+  }
+  function unlock() {
+    if (!isSupported.value)
+      return;
+    if (document.pointerLockElement)
+      document.exitPointerLock();
+  }
+  return { isSupported, isLocked, lock, unlock, element };
+}

package/dist/usePointerSwipe.d.ts

@@ -0,0 +1,20 @@
+import type { MaybeRef } from './_shared';
+import type { Ref } from '@stacksjs/stx';
+import type { SwipeDirection } from './useSwipe';
+/**
+ * Reactive pointer-based swipe detection.
+ */
+export declare function usePointerSwipe(target: MaybeRef<HTMLElement | null | undefined>, options?: UsePointerSwipeOptions): UsePointerSwipeReturn;
+export declare interface UsePointerSwipeOptions {
+  threshold?: number
+  onSwipe?: (direction: SwipeDirection) => void
+  onSwipeEnd?: (e: PointerEvent, direction: SwipeDirection) => void
+}
+export declare interface UsePointerSwipeReturn {
+  isSwiping: Ref<boolean>
+  direction: Ref<SwipeDirection>
+  distanceX: Ref<number>
+  distanceY: Ref<number>
+  posStart: Ref<{ x: number, y: number }>
+  posEnd: Ref<{ x: number, y: number }>
+}

package/dist/usePointerSwipe.js

@@ -0,0 +1,52 @@
+import { onUnmounted, ref } from "@stacksjs/stx";
+import { unref } from "./_shared";
+export function usePointerSwipe(target, options = {}) {
+  const { threshold = 50, onSwipe, onSwipeEnd } = options, isSwiping = ref(!1), direction = ref("none"), distanceX = ref(0), distanceY = ref(0), posStart = ref({ x: 0, y: 0 }), posEnd = ref({ x: 0, y: 0 });
+  if (typeof window > "u")
+    return { isSwiping, direction, distanceX, distanceY, posStart, posEnd };
+  const el = unref(target);
+  if (!el)
+    return { isSwiping, direction, distanceX, distanceY, posStart, posEnd };
+  const onPointerDown = (e) => {
+    isSwiping.value = !0;
+    direction.value = "none";
+    posStart.value = { x: e.clientX, y: e.clientY };
+    posEnd.value = { x: e.clientX, y: e.clientY };
+    distanceX.value = 0;
+    distanceY.value = 0;
+    el.setPointerCapture(e.pointerId);
+  }, onPointerMove = (e) => {
+    if (!isSwiping.value)
+      return;
+    posEnd.value = { x: e.clientX, y: e.clientY };
+    distanceX.value = posEnd.value.x - posStart.value.x;
+    distanceY.value = posEnd.value.y - posStart.value.y;
+    const absX = Math.abs(distanceX.value), absY = Math.abs(distanceY.value);
+    if (absX > absY)
+      direction.value = distanceX.value > 0 ? "right" : "left";
+    else if (absY > absX)
+      direction.value = distanceY.value > 0 ? "down" : "up";
+  }, onPointerUp = (e) => {
+    if (!isSwiping.value)
+      return;
+    isSwiping.value = !1;
+    if (Math.max(Math.abs(distanceX.value), Math.abs(distanceY.value)) >= threshold) {
+      onSwipe?.(direction.value);
+      onSwipeEnd?.(e, direction.value);
+    } else {
+      direction.value = "none";
+      onSwipeEnd?.(e, "none");
+    }
+  };
+  el.addEventListener("pointerdown", onPointerDown);
+  el.addEventListener("pointermove", onPointerMove);
+  el.addEventListener("pointerup", onPointerUp);
+  try {
+    onUnmounted(() => {
+      el.removeEventListener("pointerdown", onPointerDown);
+      el.removeEventListener("pointermove", onPointerMove);
+      el.removeEventListener("pointerup", onPointerUp);
+    });
+  } catch {}
+  return { isSwiping, direction, distanceX, distanceY, posStart, posEnd };
+}

package/dist/usePreferredColorScheme.d.ts

@@ -0,0 +1,6 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Reactive preferred color scheme.
+ */
+export declare function usePreferredColorScheme(): Ref<ColorSchemeType>;
+export type ColorSchemeType = 'dark' | 'light' | 'no-preference';

package/dist/usePreferredColorScheme.js

@@ -0,0 +1,25 @@
+import { onUnmounted, ref } from "@stacksjs/stx";
+export function usePreferredColorScheme() {
+  const scheme = ref("no-preference");
+  if (typeof window > "u" || !window.matchMedia)
+    return scheme;
+  const dark = window.matchMedia("(prefers-color-scheme: dark)"), light = window.matchMedia("(prefers-color-scheme: light)");
+  function update() {
+    if (dark.matches)
+      scheme.value = "dark";
+    else if (light.matches)
+      scheme.value = "light";
+    else
+      scheme.value = "no-preference";
+  }
+  update();
+  dark.addEventListener("change", update);
+  light.addEventListener("change", update);
+  try {
+    onUnmounted(() => {
+      dark.removeEventListener("change", update);
+      light.removeEventListener("change", update);
+    });
+  } catch {}
+  return scheme;
+}

package/dist/usePreferredContrast.d.ts

@@ -0,0 +1,6 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Reactive preferred contrast.
+ */
+export declare function usePreferredContrast(): Ref<ContrastType>;
+export type ContrastType = 'more' | 'less' | 'custom' | 'no-preference';