@stacksjs/composables 0.70.88 → 0.70.91

package/dist/index.js

@@ -0,0 +1,210 @@
+export { defaultDocument, defaultNavigator, defaultWindow, isRef, noop, toValue, unref } from "./_shared";
+export { getSSRHandler, setSSRHandler, customStorageEventName } from "./ssrHandlers";
+export { useStorage } from "./useStorage";
+export { useLocalStorage } from "./useLocalStorage";
+export { useSessionStorage } from "./useSessionStorage";
+export { useDark, usePreferredDark } from "./useDark";
+export { useColorMode } from "./useColorMode";
+export { usePreferredColorScheme } from "./usePreferredColorScheme";
+export { usePreferredContrast } from "./usePreferredContrast";
+export { usePreferredReducedMotion } from "./usePreferredReducedMotion";
+export { useOnline } from "./useOnline";
+export { useNetwork } from "./useNetwork";
+export { useToggle } from "./useToggle";
+export { useFetch } from "./useFetch";
+export { createFetch } from "./createFetch";
+export { createQueryClient, queryClient, useMutation, useQuery } from "./useQuery";
+export { useForm } from "./useForm";
+export { useDateFormat } from "./useDateFormat";
+export { useNow } from "./useNow";
+export { useTimestamp } from "./useTimestamp";
+export { useTimeAgo } from "./useTimeAgo";
+export { useEventListener } from "./useEventListener";
+export { useEventBus } from "./useEventBus";
+export { createEventHook } from "./createEventHook";
+export { useDebounceFn } from "./useDebounceFn";
+export { useThrottleFn } from "./useThrottleFn";
+export { useDebouncedRef } from "./useDebouncedRef";
+export { useThrottledRef } from "./useThrottledRef";
+export { useDebounce } from "./useDebounce";
+export { useThrottle } from "./useThrottle";
+export { useInterval } from "./useInterval";
+export { useIntervalFn } from "./useIntervalFn";
+export { useTimeout } from "./useTimeout";
+export { useTimeoutFn } from "./useTimeoutFn";
+export { useTimeoutPoll } from "./useTimeoutPoll";
+export { useRafFn } from "./useRafFn";
+export { useFps } from "./useFps";
+export { useClipboard } from "./useClipboard";
+export { useClipboardItems } from "./useClipboardItems";
+export { useMediaQuery } from "./useMediaQuery";
+export {
+  breakpointsAntDesign,
+  breakpointsBootstrap,
+  breakpointsBootstrapV5,
+  breakpointsMasterCss,
+  breakpointsQuasar,
+  breakpointsSematic,
+  breakpointsTailwind,
+  breakpointsVuetify,
+  useBreakpoints
+} from "./useBreakpoints";
+export { useTitle } from "./useTitle";
+export { useFavicon } from "./useFavicon";
+export { useDocumentVisibility } from "./useDocumentVisibility";
+export { useTextDirection } from "./useTextDirection";
+export { useTextSelection } from "./useTextSelection";
+export { useUrlSearchParams } from "./useUrlSearchParams";
+export { useBrowserLocation } from "./useBrowserLocation";
+export { useWindowSize } from "./useWindowSize";
+export { useWindowFocus } from "./useWindowFocus";
+export { useWindowScroll } from "./useWindowScroll";
+export { useScroll } from "./useScroll";
+export { useScrollLock } from "./useScrollLock";
+export { useInfiniteScroll } from "./useInfiniteScroll";
+export { useFullscreen } from "./useFullscreen";
+export { onClickOutside } from "./onClickOutside";
+export { onKeyStroke, onKeyDown, onKeyUp } from "./onKeyStroke";
+export { onLongPress } from "./onLongPress";
+export { onStartTyping } from "./onStartTyping";
+export { useKeyModifier } from "./useKeyModifier";
+export { useMagicKeys } from "./useMagicKeys";
+export {
+  and,
+  logicNot,
+  logicOr,
+  or,
+  useAbs,
+  useAverage,
+  useCeil,
+  useClamp,
+  useFloor,
+  useMax,
+  useMin,
+  usePrecision,
+  useRound,
+  useSum,
+  useTrunc
+} from "./useMath";
+export { useCounter } from "./useCounter";
+export { usePrevious } from "./usePrevious";
+export { useLastChanged } from "./useLastChanged";
+export { useStepper } from "./useStepper";
+export { useCycleList } from "./useCycleList";
+export { useSorted } from "./useSorted";
+export { useCloned } from "./useCloned";
+export { useManualRefHistory } from "./useManualRefHistory";
+export { useRefHistory } from "./useRefHistory";
+export { useDebouncedRefHistory } from "./useDebouncedRefHistory";
+export { useThrottledRefHistory } from "./useThrottledRefHistory";
+export { useAsyncState } from "./useAsyncState";
+export { useAsyncQueue } from "./useAsyncQueue";
+export { whenever } from "./whenever";
+export { watchOnce } from "./watchOnce";
+export { watchDebounced } from "./watchDebounced";
+export { watchThrottled } from "./watchThrottled";
+export { watchPausable, pausableWatch } from "./watchPausable";
+export { watchIgnorable, ignorableWatch } from "./watchIgnorable";
+export { watchArray } from "./watchArray";
+export { watchAtMost } from "./watchAtMost";
+export { watchDeep } from "./watchDeep";
+export { watchImmediate } from "./watchImmediate";
+export { watchTriggerable } from "./watchTriggerable";
+export { watchWithFilter } from "./watchWithFilter";
+export { useWebSocket } from "./useWebSocket";
+export { useEventSource } from "./useEventSource";
+export { useBroadcastChannel } from "./useBroadcastChannel";
+export { computedAsync } from "./computedAsync";
+export { computedEager } from "./computedEager";
+export { useIntersectionObserver } from "./useIntersectionObserver";
+export { useResizeObserver } from "./useResizeObserver";
+export { useMutationObserver } from "./useMutationObserver";
+export { useElementSize } from "./useElementSize";
+export { useElementBounding } from "./useElementBounding";
+export { useElementVisibility } from "./useElementVisibility";
+export { useElementHover } from "./useElementHover";
+export { useElementByPoint } from "./useElementByPoint";
+export { useCssVar } from "./useCssVar";
+export { unrefElement } from "./unrefElement";
+export { useMouse } from "./useMouse";
+export { useMouseInElement } from "./useMouseInElement";
+export { useMousePressed } from "./useMousePressed";
+export { usePointer } from "./usePointer";
+export { useSwipe } from "./useSwipe";
+export { usePointerSwipe } from "./usePointerSwipe";
+export { usePointerLock } from "./usePointerLock";
+export { useParallax } from "./useParallax";
+export { useGeolocation } from "./useGeolocation";
+export { useDeviceMotion } from "./useDeviceMotion";
+export { useDeviceOrientation } from "./useDeviceOrientation";
+export { useDevicePixelRatio } from "./useDevicePixelRatio";
+export { useBattery } from "./useBattery";
+export { useFocus } from "./useFocus";
+export { useFocusWithin } from "./useFocusWithin";
+export { useActiveElement } from "./useActiveElement";
+export { useIdle } from "./useIdle";
+export { usePageLeave } from "./usePageLeave";
+export { useMounted } from "./useMounted";
+export { useDraggable } from "./useDraggable";
+export { useDropZone } from "./useDropZone";
+export { useNavigatorLanguage } from "./useNavigatorLanguage";
+export { usePreferredLanguages } from "./usePreferredLanguages";
+export { useScreenOrientation } from "./useScreenOrientation";
+export { useScreenSafeArea } from "./useScreenSafeArea";
+export { useParentElement } from "./useParentElement";
+export { usePermission } from "./usePermission";
+export { useShare } from "./useShare";
+export { useObjectUrl } from "./useObjectUrl";
+export { useImage } from "./useImage";
+export { useBase64 } from "./useBase64";
+export { useAnimate } from "./useAnimate";
+export { useTransition, executeTransition, TransitionPresets } from "./useTransition";
+export { useScriptTag } from "./useScriptTag";
+export { useStyleTag } from "./useStyleTag";
+export { useConfirmDialog } from "./useConfirmDialog";
+export { useFileDialog } from "./useFileDialog";
+export { useEyeDropper } from "./useEyeDropper";
+export { useTextareaAutosize } from "./useTextareaAutosize";
+export { useWebNotification } from "./useWebNotification";
+export { useVibrate } from "./useVibrate";
+export { useWakeLock } from "./useWakeLock";
+export { useWebWorker, useWebWorkerFn } from "./useWebWorker";
+export { useVirtualList } from "./useVirtualList";
+export { useOffsetPagination } from "./useOffsetPagination";
+export { isDefined } from "./isDefined";
+export { useSupported } from "./useSupported";
+export { useToNumber } from "./useToNumber";
+export { useToString } from "./useToString";
+export { refDefault } from "./refDefault";
+export { refAutoReset, autoResetRef } from "./refAutoReset";
+export { cloneFnJSON } from "./cloneFnJSON";
+export { formatTimeAgo } from "./formatTimeAgo";
+export { until } from "./until";
+export { resolveRef } from "./resolveRef";
+export { extendRef } from "./extendRef";
+export { useMemoize } from "./useMemoize";
+export { makeDestructurable } from "./makeDestructurable";
+export { syncRef, syncRefs } from "./syncRef";
+export { createGlobalState } from "./createGlobalState";
+export { createSharedComposable } from "./createSharedComposable";
+export { tryOnMounted, tryOnBeforeMount, tryOnUnmounted, tryOnBeforeUnmount, tryOnScopeDispose } from "./tryOnMounted";
+export {
+  useArrayDifference,
+  useArrayEvery,
+  useArrayFilter,
+  useArrayFind,
+  useArrayFindIndex,
+  useArrayIncludes,
+  useArrayMap,
+  useArrayReduce,
+  useArraySome,
+  useArrayUnique
+} from "./useArrayUtils";
+export { computedAsync as asyncComputed } from "./computedAsync";
+export { computedEager as eagerComputed } from "./computedEager";
+export { useDebouncedRef as debouncedRef } from "./useDebouncedRef";
+export { useDebouncedRef as refDebounced } from "./useDebouncedRef";
+export { useThrottledRef as throttledRef } from "./useThrottledRef";
+export { useThrottledRef as refThrottled } from "./useThrottledRef";
+export { watchDebounced as debouncedWatch } from "./watchDebounced";
+export { watchThrottled as throttledWatch } from "./watchThrottled";

package/dist/isDefined.d.ts

@@ -0,0 +1,5 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Check if a ref value is defined (not null or undefined).
+ */
+export declare function isDefined<T>(v: Ref<T>): v is Ref<Exclude<T, null | undefined>>;

package/dist/isDefined.js

@@ -0,0 +1,3 @@
+export function isDefined(v) {
+  return v.value !== null && v.value !== void 0;
+}

package/dist/makeDestructurable.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Make an object that can be destructured as both an object and an array.
+ *
+ * @param obj - The object with named properties
+ * @param arr - The array with positional values
+ * @returns A value that supports both object and array destructuring
+ *
+ * @example
+ * ```ts
+ * const result = makeDestructurable(
+ *   { x: 1, y: 2 } as const,
+ *   [1, 2] as const,
+ * )
+ * const { x, y } = result     // object destructuring
+ * const [a, b] = result        // array destructuring
+ * ```
+ */
+export declare function makeDestructurable<T extends Record<string, unknown>, A extends readonly unknown[],>(obj: T, arr: A): T & A;

package/dist/makeDestructurable.js

@@ -0,0 +1,16 @@
+export function makeDestructurable(obj, arr) {
+  const clone = { ...obj };
+  Object.defineProperty(clone, Symbol.iterator, {
+    enumerable: !1,
+    value() {
+      let index = 0;
+      return {
+        next: () => ({
+          value: arr[index++],
+          done: index > arr.length
+        })
+      };
+    }
+  });
+  return clone;
+}

package/dist/onClickOutside.d.ts

@@ -0,0 +1,14 @@
+import type { MaybeRef } from './_shared';
+/**
+ * Listen for clicks outside a target element.
+ * Calls the handler when a click occurs outside the target element.
+ *
+ * @param target - Element to detect clicks outside of
+ * @param handler - Callback when click outside is detected
+ * @param options - Configuration options
+ * @returns Cleanup function to remove the listener
+ */
+export declare function onClickOutside(target: MaybeRef<HTMLElement | null>, handler: (event: MouseEvent) => void, options?: OnClickOutsideOptions): () => void;
+export declare interface OnClickOutsideOptions {
+  ignore?: MaybeRef<HTMLElement | null>[]
+}

package/dist/onClickOutside.js

@@ -0,0 +1,25 @@
+import { defaultWindow, unref } from "./_shared";
+export function onClickOutside(target, handler, options) {
+  const win = defaultWindow();
+  if (!win)
+    return () => {};
+  const { ignore = [] } = options ?? {};
+  function listener(event) {
+    const el = unref(target);
+    if (!el)
+      return;
+    const mouseEvent = event, composedPath = mouseEvent.composedPath?.() ?? [];
+    if (el === mouseEvent.target || composedPath.includes(el) || el.contains(mouseEvent.target))
+      return;
+    for (const ignored of ignore) {
+      const ignoredEl = unref(ignored);
+      if (ignoredEl && (ignoredEl === mouseEvent.target || composedPath.includes(ignoredEl) || ignoredEl.contains(mouseEvent.target)))
+        return;
+    }
+    handler(mouseEvent);
+  }
+  win.addEventListener("pointerdown", listener, { passive: !0 });
+  return () => {
+    win.removeEventListener("pointerdown", listener);
+  };
+}

package/dist/onKeyStroke.d.ts

@@ -0,0 +1,26 @@
+import type { MaybeRef } from './_shared';
+/**
+ * Listen for specific key strokes.
+ * Calls the handler when the specified key is pressed.
+ *
+ * @param key - Key(s) to listen for, or a filter function
+ * @param handler - Callback when key is pressed
+ * @param options - Configuration options
+ * @returns Cleanup function to remove the listener
+ */
+export declare function onKeyStroke(key: KeyFilter, handler: (event: KeyboardEvent) => void, options?: OnKeyStrokeOptions): () => void;
+/**
+ * Listen for keydown events on specific keys.
+ * Alias for onKeyStroke with eventName: 'keydown'.
+ */
+export declare function onKeyDown(key: KeyFilter, handler: (event: KeyboardEvent) => void, options?: Omit<OnKeyStrokeOptions, 'eventName'>): () => void;
+/**
+ * Listen for keyup events on specific keys.
+ * Alias for onKeyStroke with eventName: 'keyup'.
+ */
+export declare function onKeyUp(key: KeyFilter, handler: (event: KeyboardEvent) => void, options?: Omit<OnKeyStrokeOptions, 'eventName'>): () => void;
+export declare interface OnKeyStrokeOptions {
+  eventName?: 'keydown' | 'keyup' | 'keypress'
+  target?: MaybeRef<EventTarget | null>
+}
+declare type KeyFilter = string | string[] | ((_event: KeyboardEvent) => boolean);

package/dist/onKeyStroke.js

@@ -0,0 +1,31 @@
+import { defaultWindow, unref } from "./_shared";
+export function onKeyStroke(key, handler, options) {
+  const { eventName = "keydown", target } = options ?? {}, win = defaultWindow(), eventTarget = target ? unref(target) : win;
+  if (!eventTarget)
+    return () => {};
+  function createKeyFilter(keyDef) {
+    if (typeof keyDef === "function")
+      return keyDef;
+    if (typeof keyDef === "string")
+      return (event) => event.key === keyDef;
+    if (Array.isArray(keyDef))
+      return (event) => keyDef.includes(event.key);
+    return () => !0;
+  }
+  const filter = createKeyFilter(key);
+  function listener(event) {
+    const keyEvent = event;
+    if (filter(keyEvent))
+      handler(keyEvent);
+  }
+  eventTarget.addEventListener(eventName, listener);
+  return () => {
+    eventTarget.removeEventListener(eventName, listener);
+  };
+}
+export function onKeyDown(key, handler, options) {
+  return onKeyStroke(key, handler, { ...options, eventName: "keydown" });
+}
+export function onKeyUp(key, handler, options) {
+  return onKeyStroke(key, handler, { ...options, eventName: "keyup" });
+}

package/dist/onLongPress.d.ts

@@ -0,0 +1,14 @@
+import type { MaybeRef } from './_shared';
+/**
+ * Listen for long press events on an element.
+ *
+ * @param target - The target element
+ * @param handler - The callback to invoke on long press
+ * @param options - Configuration options
+ * @returns A cleanup function
+ */
+export declare function onLongPress(target: MaybeRef<HTMLElement | null | undefined>, handler: (e: PointerEvent) => void, options?: OnLongPressOptions): () => void;
+export declare interface OnLongPressOptions {
+  delay?: number
+  distanceThreshold?: number
+}

package/dist/onLongPress.js

@@ -0,0 +1,43 @@
+import { onUnmounted } from "@stacksjs/stx";
+import { unref } from "./_shared";
+export function onLongPress(target, handler, options = {}) {
+  const { delay = 500, distanceThreshold = 10 } = options;
+  let timer = null, startX = 0, startY = 0;
+  const el = unref(target);
+  if (!el)
+    return () => {};
+  const clear = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }, onDown = (e) => {
+    startX = e.clientX;
+    startY = e.clientY;
+    clear();
+    timer = setTimeout(() => handler(e), delay);
+  }, onMove = (e) => {
+    if (timer === null)
+      return;
+    const dx = Math.abs(e.clientX - startX), dy = Math.abs(e.clientY - startY);
+    if (dx > distanceThreshold || dy > distanceThreshold)
+      clear();
+  }, onUp = () => {
+    clear();
+  };
+  el.addEventListener("pointerdown", onDown);
+  el.addEventListener("pointermove", onMove);
+  el.addEventListener("pointerup", onUp);
+  el.addEventListener("pointercancel", onUp);
+  const cleanup = () => {
+    clear();
+    el.removeEventListener("pointerdown", onDown);
+    el.removeEventListener("pointermove", onMove);
+    el.removeEventListener("pointerup", onUp);
+    el.removeEventListener("pointercancel", onUp);
+  };
+  try {
+    onUnmounted(cleanup);
+  } catch {}
+  return cleanup;
+}

package/dist/onStartTyping.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Detect when the user starts typing.
+ * Fires when a keydown event produces a printable character and the active element is not an input.
+ *
+ * @param callback - Called when typing starts
+ * @returns A cleanup function
+ */
+export declare function onStartTyping(callback: (event: KeyboardEvent) => void): () => void;

package/dist/onStartTyping.js

@@ -0,0 +1,23 @@
+import { onUnmounted } from "@stacksjs/stx";
+export function onStartTyping(callback) {
+  if (typeof document > "u")
+    return () => {};
+  const handler = (e) => {
+    const active = document.activeElement;
+    if (active) {
+      const tag = active.tagName.toLowerCase();
+      if (tag === "input" || tag === "textarea" || active.isContentEditable)
+        return;
+    }
+    if (e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey)
+      callback(e);
+  };
+  document.addEventListener("keydown", handler);
+  const cleanup = () => {
+    document.removeEventListener("keydown", handler);
+  };
+  try {
+    onUnmounted(cleanup);
+  } catch {}
+  return cleanup;
+}

package/dist/refAutoReset.d.ts

@@ -0,0 +1,11 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Create a ref that automatically resets to a default value after a delay.
+ *
+ * @param defaultValue - The default value to reset to
+ * @param afterMs - Delay in milliseconds before resetting (default 1000)
+ * @returns A ref that auto-resets
+ */
+export declare function refAutoReset<T>(defaultValue: T, afterMs?: number): Ref<T>;
+/** Alias for refAutoReset */
+export declare const autoResetRef: unknown;

package/dist/refAutoReset.js

@@ -0,0 +1,15 @@
+import { ref, watch } from "@stacksjs/stx";
+export function refAutoReset(defaultValue, afterMs = 1000) {
+  const value = ref(defaultValue);
+  let timer = null;
+  watch(value, () => {
+    if (timer !== null)
+      clearTimeout(timer);
+    timer = setTimeout(() => {
+      value.value = defaultValue;
+      timer = null;
+    }, afterMs);
+  });
+  return value;
+}
+export const autoResetRef = refAutoReset;

package/dist/refDefault.d.ts

@@ -0,0 +1,9 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Apply a default value to a ref when it becomes null or undefined.
+ *
+ * @param source - The source ref
+ * @param defaultValue - The default value to use when source is null/undefined
+ * @returns A ref that always has a defined value
+ */
+export declare function refDefault<T>(source: Ref<T | null | undefined>, defaultValue: T): Ref<T>;

package/dist/refDefault.js

@@ -0,0 +1,8 @@
+import { ref, watch } from "@stacksjs/stx";
+export function refDefault(source, defaultValue) {
+  const result = ref(source.value ?? defaultValue);
+  watch(source, (val) => {
+    result.value = val ?? defaultValue;
+  });
+  return result;
+}

package/dist/resolveRef.d.ts

@@ -0,0 +1,7 @@
+import type { MaybeRef } from './_shared';
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Normalize a value/ref/getter to a ref.
+ * If already a ref, returns it as-is. Otherwise wraps in a new ref.
+ */
+export declare function resolveRef<T>(value: MaybeRef<T>): Ref<T>;

package/dist/resolveRef.js

@@ -0,0 +1,7 @@
+import { ref } from "@stacksjs/stx";
+import { isRef } from "./_shared";
+export function resolveRef(value) {
+  if (isRef(value))
+    return value;
+  return ref(value);
+}

package/dist/ssrHandlers.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Get an SSR handler by key.
+ */
+export declare function getSSRHandler(key: string): SSRHandler | undefined;
+/**
+ * Set an SSR handler by key.
+ */
+export declare function setSSRHandler(key: string, handler: SSRHandler): void;
+/**
+ * Custom event name for storage events.
+ */
+export declare const customStorageEventName: 'stx-storage';
+declare type SSRHandler = (..._args: any[]) => any;

package/dist/ssrHandlers.js

@@ -0,0 +1,8 @@
+const handlers = new Map;
+export function getSSRHandler(key) {
+  return handlers.get(key);
+}
+export function setSSRHandler(key, handler) {
+  handlers.set(key, handler);
+}
+export const customStorageEventName = "stx-storage";

package/dist/syncRef.d.ts

@@ -0,0 +1,21 @@
+import type { Ref } from '@stacksjs/stx';
+/**
+ * Two-way sync between two refs.
+ *
+ * @param left - First ref
+ * @param right - Second ref
+ * @param options - Sync direction options
+ * @returns A stop function to cancel the sync
+ */
+export declare function syncRef<T>(left: Ref<T>, right: Ref<T>, options?: SyncRefOptions): () => void;
+/**
+ * Sync multiple source refs to a target ref.
+ *
+ * @param sources - Array of source refs
+ * @param target - Target ref that will be updated when any source changes
+ * @returns A stop function to cancel all watches
+ */
+export declare function syncRefs<T>(sources: Ref<T>[], target: Ref<T>): () => void;
+export declare interface SyncRefOptions {
+  direction?: 'ltr' | 'rtl' | 'both'
+}

package/dist/syncRef.js

@@ -0,0 +1,35 @@
+import { watch } from "@stacksjs/stx";
+export function syncRef(left, right, options = {}) {
+  const { direction = "both" } = options;
+  let syncing = !1;
+  const unwatchers = [];
+  if (direction === "both" || direction === "ltr")
+    unwatchers.push(watch(left, (val) => {
+      if (syncing)
+        return;
+      syncing = !0;
+      right.value = val;
+      syncing = !1;
+    }));
+  if (direction === "both" || direction === "rtl")
+    unwatchers.push(watch(right, (val) => {
+      if (syncing)
+        return;
+      syncing = !0;
+      left.value = val;
+      syncing = !1;
+    }));
+  return () => {
+    for (const unwatch of unwatchers)
+      unwatch();
+  };
+}
+export function syncRefs(sources, target) {
+  const unwatchers = sources.map((source) => watch(source, (val) => {
+    target.value = val;
+  }));
+  return () => {
+    for (const unwatch of unwatchers)
+      unwatch();
+  };
+}

package/dist/tryOnMounted.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Try to execute a function when mounted (in a component context).
+ * If not in a component context, the function is still called.
+ */
+export declare function tryOnMounted(fn: () => void): void;
+/**
+ * Try to execute a function before mount.
+ * Runs the function immediately.
+ */
+export declare function tryOnBeforeMount(fn: () => void): void;
+/**
+ * Try to register an unmount callback. Fails silently outside component context.
+ */
+export declare function tryOnUnmounted(fn: () => void): void;
+/**
+ * Try to register a before-unmount callback.
+ */
+export declare function tryOnBeforeUnmount(fn: () => void): void;
+/**
+ * Try to run a function when the current scope is disposed.
+ */
+export declare function tryOnScopeDispose(fn: () => void): void;

package/dist/tryOnMounted.js

@@ -0,0 +1,22 @@
+import { onUnmounted } from "@stacksjs/stx";
+export function tryOnMounted(fn) {
+  fn();
+}
+export function tryOnBeforeMount(fn) {
+  fn();
+}
+export function tryOnUnmounted(fn) {
+  try {
+    onUnmounted(fn);
+  } catch {}
+}
+export function tryOnBeforeUnmount(fn) {
+  try {
+    onUnmounted(fn);
+  } catch {}
+}
+export function tryOnScopeDispose(fn) {
+  try {
+    onUnmounted(fn);
+  } catch {}
+}

package/dist/unrefElement.d.ts

@@ -0,0 +1,6 @@
+import type { MaybeRef } from './_shared';
+/**
+ * Unref a value that may be a ref to an HTML element.
+ * Handles the case where the ref value may have an `$el` property (component instance).
+ */
+export declare function unrefElement(elRef: MaybeRef<HTMLElement | { $el: HTMLElement } | null | undefined>): HTMLElement | null | undefined;