@gunkin/uiify 0.0.1-alpha

package/dist/hooks/use-chart-viewport.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-chart-viewport.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback, useRef, useState } from \"react\";\nimport type { RefObject } from \"react\";\nimport { useEventListener } from \"./use-event-listener.js\";\nimport { useResizeObserver } from \"./use-resize-observer.js\";\n\ninterface ChartWheelEvent {\n  readonly deltaX: number;\n  readonly deltaY: number;\n  readonly shiftKey: boolean;\n  preventDefault(): void;\n}\n\nexport interface UseChartViewportOptions {\n  readonly enabled?: boolean;\n  readonly itemCount: number;\n  readonly initialScale?: number;\n  readonly maxScale?: number;\n  readonly minScale?: number;\n  readonly minItemWidth?: number;\n  /**\n   * Chrome reserved outside the scrollable item track (e.g. a fixed-width\n   * axis column plus its grid gap) that `ref`'s measured element includes\n   * but that isn't available to the items themselves. Subtracted from the\n   * measured width before it's used to size `minItemWidth`.\n   */\n  readonly measuredWidthOffset?: number;\n}\n\nexport interface UseChartViewportResult {\n  readonly onWheel: (event: ChartWheelEvent) => void;\n  readonly ref: RefObject<HTMLElement | null>;\n  readonly reset: () => void;\n  readonly scale: number;\n  readonly itemWidth: number;\n}\n\nconst DEFAULT_INITIAL_SCALE = 3.2;\nconst DEFAULT_MIN_SCALE = 1;\nconst ZOOM_FACTOR = 1.2;\n\nfunction clamp(value: number, min: number, max: number): number {\n  return Math.min(max, Math.max(min, value));\n}\n\nexport function computeAnchoredScrollOffset(\n  index: number,\n  previousItemWidth: number,\n  nextItemWidth: number,\n  previousScrollOffset: number,\n): number {\n  const viewportOffset = (index + 0.5) * previousItemWidth - previousScrollOffset;\n  return (index + 0.5) * nextItemWidth - viewportOffset;\n}\n\nfunction maxScaleFor(itemCount: number): number {\n  return itemCount > 1 ? itemCount / 2 : 1;\n}\n\nfunction boundsFor(\n  options: UseChartViewportOptions,\n  measuredWidth: number,\n): {\n  readonly initial: number;\n  readonly max: number;\n  readonly min: number;\n} {\n  const ceiling = maxScaleFor(options.itemCount);\n  const measuredMin =\n    measuredWidth > 0 && options.minItemWidth !== undefined\n      ? (options.minItemWidth * options.itemCount) / measuredWidth\n      : DEFAULT_MIN_SCALE;\n  const min = Math.min(ceiling, Math.max(1, options.minScale ?? DEFAULT_MIN_SCALE, measuredMin));\n  const max = Math.max(min, Math.min(options.maxScale ?? ceiling, ceiling));\n  const initial = clamp(options.initialScale ?? DEFAULT_INITIAL_SCALE, min, max);\n  return { initial, max, min };\n}\n\nexport function useChartViewport(options: UseChartViewportOptions): UseChartViewportResult {\n  const ref = useRef<HTMLElement | null>(null);\n  const measuredSize = useResizeObserver(ref);\n  const measuredWidth = Math.max(\n    0,\n    (measuredSize?.width ?? 0) - (options.measuredWidthOffset ?? 0),\n  );\n  const enabled = options.enabled ?? true;\n  const { initial, max, min } = boundsFor(options, measuredWidth);\n  const [rawScale, setScale] = useState(initial);\n  // Clamp on every render instead of syncing `rawScale` to bounds through an\n  // effect: an effect-driven sync lands one commit after the ResizeObserver's\n  // width update, so a consumer that reads `scale` synchronously after mount\n  // (e.g. an accessibility scan) can observe the pre-measurement default.\n  const scale = clamp(rawScale, min, max);\n\n  const onWheel = useCallback<UseChartViewportResult[\"onWheel\"]>(\n    (event) => {\n      const horizontalDelta = event.shiftKey ? event.deltaY : event.deltaX;\n      const isHorizontal =\n        horizontalDelta !== 0 &&\n        (event.shiftKey || Math.abs(event.deltaX) > Math.abs(event.deltaY));\n\n      if (!enabled || isHorizontal) return;\n\n      if (event.deltaY === 0) return;\n      event.preventDefault();\n      const factor = event.deltaY < 0 ? ZOOM_FACTOR : 1 / ZOOM_FACTOR;\n      // Clamp `current` before scaling: a batch of wheel events (or a stale\n      // `rawScale` this render hasn't caught up to yet, e.g. right after a\n      // measurement changed the bounds) must zoom from the effective scale,\n      // not an out-of-range raw value.\n      setScale((current) => clamp(clamp(current, min, max) * factor, min, max));\n    },\n    [enabled, max, min],\n  );\n\n  useEventListener(\"wheel\", onWheel, enabled ? ref : null, { passive: false });\n\n  const reset = useCallback(() => {\n    setScale(initial);\n  }, [initial]);\n\n  const itemWidth =\n    measuredWidth > 0 && options.itemCount > 0\n      ? Math.max(options.minItemWidth ?? 0, (measuredWidth * scale) / options.itemCount)\n      : (options.minItemWidth ?? 0);\n\n  return { itemWidth, onWheel, ref, reset, scale };\n}\n"],"mappings":";AAEA,SAAS,aAAa,QAAQ,gBAAgB;AAE9C,SAAS,wBAAwB;AACjC,SAAS,yBAAyB;AAiClC,MAAM,wBAAwB;AAC9B,MAAM,oBAAoB;AAC1B,MAAM,cAAc;AAEpB,SAAS,MAAM,OAAe,KAAa,KAAqB;AAC9D,SAAO,KAAK,IAAI,KAAK,KAAK,IAAI,KAAK,KAAK,CAAC;AAC3C;AAEO,SAAS,4BACd,OACA,mBACA,eACA,sBACQ;AACR,QAAM,kBAAkB,QAAQ,OAAO,oBAAoB;AAC3D,UAAQ,QAAQ,OAAO,gBAAgB;AACzC;AAEA,SAAS,YAAY,WAA2B;AAC9C,SAAO,YAAY,IAAI,YAAY,IAAI;AACzC;AAEA,SAAS,UACP,SACA,eAKA;AACA,QAAM,UAAU,YAAY,QAAQ,SAAS;AAC7C,QAAM,cACJ,gBAAgB,KAAK,QAAQ,iBAAiB,SACzC,QAAQ,eAAe,QAAQ,YAAa,gBAC7C;AACN,QAAM,MAAM,KAAK,IAAI,SAAS,KAAK,IAAI,GAAG,QAAQ,YAAY,mBAAmB,WAAW,CAAC;AAC7F,QAAM,MAAM,KAAK,IAAI,KAAK,KAAK,IAAI,QAAQ,YAAY,SAAS,OAAO,CAAC;AACxE,QAAM,UAAU,MAAM,QAAQ,gBAAgB,uBAAuB,KAAK,GAAG;AAC7E,SAAO,EAAE,SAAS,KAAK,IAAI;AAC7B;AAEO,SAAS,iBAAiB,SAA0D;AACzF,QAAM,MAAM,OAA2B,IAAI;AAC3C,QAAM,eAAe,kBAAkB,GAAG;AAC1C,QAAM,gBAAgB,KAAK;AAAA,IACzB;AAAA,KACC,cAAc,SAAS,MAAM,QAAQ,uBAAuB;AAAA,EAC/D;AACA,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,EAAE,SAAS,KAAK,IAAI,IAAI,UAAU,SAAS,aAAa;AAC9D,QAAM,CAAC,UAAU,QAAQ,IAAI,SAAS,OAAO;AAK7C,QAAM,QAAQ,MAAM,UAAU,KAAK,GAAG;AAEtC,QAAM,UAAU;AAAA,IACd,CAAC,UAAU;AACT,YAAM,kBAAkB,MAAM,WAAW,MAAM,SAAS,MAAM;AAC9D,YAAM,eACJ,oBAAoB,MACnB,MAAM,YAAY,KAAK,IAAI,MAAM,MAAM,IAAI,KAAK,IAAI,MAAM,MAAM;AAEnE,UAAI,CAAC,WAAW,aAAc;AAE9B,UAAI,MAAM,WAAW,EAAG;AACxB,YAAM,eAAe;AACrB,YAAM,SAAS,MAAM,SAAS,IAAI,cAAc,IAAI;AAKpD,eAAS,CAAC,YAAY,MAAM,MAAM,SAAS,KAAK,GAAG,IAAI,QAAQ,KAAK,GAAG,CAAC;AAAA,IAC1E;AAAA,IACA,CAAC,SAAS,KAAK,GAAG;AAAA,EACpB;AAEA,mBAAiB,SAAS,SAAS,UAAU,MAAM,MAAM,EAAE,SAAS,MAAM,CAAC;AAE3E,QAAM,QAAQ,YAAY,MAAM;AAC9B,aAAS,OAAO;AAAA,EAClB,GAAG,CAAC,OAAO,CAAC;AAEZ,QAAM,YACJ,gBAAgB,KAAK,QAAQ,YAAY,IACrC,KAAK,IAAI,QAAQ,gBAAgB,GAAI,gBAAgB,QAAS,QAAQ,SAAS,IAC9E,QAAQ,gBAAgB;AAE/B,SAAO,EAAE,WAAW,SAAS,KAAK,OAAO,MAAM;AACjD;","names":[]}

package/dist/hooks/use-click-outside.d.ts

@@ -0,0 +1,4 @@
+import type { RefObject } from "react";
+/** Calls `handler` on a `pointerdown` outside `ref` (capture phase). */
+export declare function useClickOutside<T extends HTMLElement>(ref: RefObject<T | null>, handler: (event: Event) => void): void;
+//# sourceMappingURL=use-click-outside.d.ts.map

package/dist/hooks/use-click-outside.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-click-outside.d.ts","sourceRoot":"","sources":["../../src/hooks/use-click-outside.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,CAAC,SAAS,WAAW,EACnD,GAAG,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,EACxB,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAC9B,IAAI,CAWN"}

package/dist/hooks/use-click-outside.js

@@ -0,0 +1,20 @@
+"use client";
+import { useEffect } from "react";
+import { useEventCallback } from "./use-event-callback.js";
+import { subscribeClickOutside } from "./utils/click-outside-subscription.js";
+function useClickOutside(ref, handler) {
+  const onOutside = useEventCallback(handler);
+  useEffect(() => {
+    const listener = (event) => {
+      const node = ref.current;
+      const target = event.target;
+      if (!node || !(target instanceof Node) || node.contains(target)) return;
+      onOutside(event);
+    };
+    return subscribeClickOutside(listener);
+  }, [ref, onOutside]);
+}
+export {
+  useClickOutside
+};
+//# sourceMappingURL=use-click-outside.js.map

package/dist/hooks/use-click-outside.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-click-outside.ts"],"sourcesContent":["\"use client\";\n\nimport { useEffect } from \"react\";\nimport type { RefObject } from \"react\";\nimport { useEventCallback } from \"./use-event-callback.js\";\nimport { subscribeClickOutside } from \"./utils/click-outside-subscription.js\";\n\n/** Calls `handler` on a `pointerdown` outside `ref` (capture phase). */\nexport function useClickOutside<T extends HTMLElement>(\n  ref: RefObject<T | null>,\n  handler: (event: Event) => void,\n): void {\n  const onOutside = useEventCallback(handler);\n  useEffect(() => {\n    const listener = (event: Event) => {\n      const node = ref.current;\n      const target = event.target;\n      if (!node || !(target instanceof Node) || node.contains(target)) return;\n      onOutside(event);\n    };\n    return subscribeClickOutside(listener);\n  }, [ref, onOutside]);\n}\n"],"mappings":";AAEA,SAAS,iBAAiB;AAE1B,SAAS,wBAAwB;AACjC,SAAS,6BAA6B;AAG/B,SAAS,gBACd,KACA,SACM;AACN,QAAM,YAAY,iBAAiB,OAAO;AAC1C,YAAU,MAAM;AACd,UAAM,WAAW,CAAC,UAAiB;AACjC,YAAM,OAAO,IAAI;AACjB,YAAM,SAAS,MAAM;AACrB,UAAI,CAAC,QAAQ,EAAE,kBAAkB,SAAS,KAAK,SAAS,MAAM,EAAG;AACjE,gBAAU,KAAK;AAAA,IACjB;AACA,WAAO,sBAAsB,QAAQ;AAAA,EACvC,GAAG,CAAC,KAAK,SAAS,CAAC;AACrB;","names":[]}

package/dist/hooks/use-controllable-state.d.ts

@@ -0,0 +1,16 @@
+import { type SetStateAction } from "./utils/set-state-action.js";
+export interface UseControllableStateParams<T> {
+    /** Controlled value. When defined, the parent owns the state. */
+    value?: T | undefined;
+    /** Initial value for the uncontrolled case. */
+    defaultValue?: T | undefined;
+    /** Called with the next value on every change (controlled or not). */
+    onChange?: ((value: T) => void) | undefined;
+}
+/**
+ * Unifies controlled and uncontrolled state. Returns `[value, setValue]`.
+ * Controlled when `params.value !== undefined`; otherwise internal state
+ * seeded from `defaultValue`. `setValue` accepts a value or updater.
+ */
+export declare function useControllableState<T>(params: UseControllableStateParams<T>): [T, (next: SetStateAction<T>) => void];
+//# sourceMappingURL=use-controllable-state.d.ts.map

package/dist/hooks/use-controllable-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-controllable-state.d.ts","sourceRoot":"","sources":["../../src/hooks/use-controllable-state.ts"],"names":[],"mappings":"AAIA,OAAO,EAAyB,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAEzF,MAAM,WAAW,0BAA0B,CAAC,CAAC;IAC3C,iEAAiE;IACjE,KAAK,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IACtB,+CAA+C;IAC/C,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;CAC7C;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,MAAM,EAAE,0BAA0B,CAAC,CAAC,CAAC,GACpC,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CA4BxC"}

package/dist/hooks/use-controllable-state.js

@@ -0,0 +1,32 @@
+"use client";
+import { useCallback, useRef, useState } from "react";
+import { useEventCallback } from "./use-event-callback.js";
+import { resolveSetStateAction } from "./utils/set-state-action.js";
+function useControllableState(params) {
+  const { value: controlled, defaultValue, onChange } = params;
+  const [uncontrolled, setUncontrolled] = useState(defaultValue);
+  const isControlled = controlled !== void 0;
+  const value = isControlled ? controlled : uncontrolled;
+  const valueRef = useRef(value);
+  valueRef.current = value;
+  const isControlledRef = useRef(isControlled);
+  isControlledRef.current = isControlled;
+  const emitChange = useEventCallback((next) => onChange?.(next));
+  const setValue = useCallback(
+    (next) => {
+      const resolved = resolveSetStateAction(next, valueRef.current);
+      if (Object.is(resolved, valueRef.current)) return;
+      valueRef.current = resolved;
+      if (!isControlledRef.current) {
+        setUncontrolled(resolved);
+      }
+      emitChange(resolved);
+    },
+    [emitChange]
+  );
+  return [value, setValue];
+}
+export {
+  useControllableState
+};
+//# sourceMappingURL=use-controllable-state.js.map

package/dist/hooks/use-controllable-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-controllable-state.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback, useRef, useState } from \"react\";\nimport { useEventCallback } from \"./use-event-callback.js\";\nimport { resolveSetStateAction, type SetStateAction } from \"./utils/set-state-action.js\";\n\nexport interface UseControllableStateParams<T> {\n  /** Controlled value. When defined, the parent owns the state. */\n  value?: T | undefined;\n  /** Initial value for the uncontrolled case. */\n  defaultValue?: T | undefined;\n  /** Called with the next value on every change (controlled or not). */\n  onChange?: ((value: T) => void) | undefined;\n}\n\n/**\n * Unifies controlled and uncontrolled state. Returns `[value, setValue]`.\n * Controlled when `params.value !== undefined`; otherwise internal state\n * seeded from `defaultValue`. `setValue` accepts a value or updater.\n */\nexport function useControllableState<T>(\n  params: UseControllableStateParams<T>,\n): [T, (next: SetStateAction<T>) => void] {\n  const { value: controlled, defaultValue, onChange } = params;\n  const [uncontrolled, setUncontrolled] = useState<T>(defaultValue as T);\n  const isControlled = controlled !== undefined;\n  const value = (isControlled ? controlled : uncontrolled) as T;\n\n  const valueRef = useRef(value);\n  valueRef.current = value;\n  const isControlledRef = useRef(isControlled);\n  isControlledRef.current = isControlled;\n\n  const emitChange = useEventCallback((next: T) => onChange?.(next));\n\n  const setValue = useCallback(\n    (next: SetStateAction<T>) => {\n      const resolved = resolveSetStateAction(next, valueRef.current);\n      if (Object.is(resolved, valueRef.current)) return;\n\n      valueRef.current = resolved;\n      if (!isControlledRef.current) {\n        setUncontrolled(resolved);\n      }\n      emitChange(resolved);\n    },\n    [emitChange],\n  );\n\n  return [value, setValue];\n}\n"],"mappings":";AAEA,SAAS,aAAa,QAAQ,gBAAgB;AAC9C,SAAS,wBAAwB;AACjC,SAAS,6BAAkD;AAgBpD,SAAS,qBACd,QACwC;AACxC,QAAM,EAAE,OAAO,YAAY,cAAc,SAAS,IAAI;AACtD,QAAM,CAAC,cAAc,eAAe,IAAI,SAAY,YAAiB;AACrE,QAAM,eAAe,eAAe;AACpC,QAAM,QAAS,eAAe,aAAa;AAE3C,QAAM,WAAW,OAAO,KAAK;AAC7B,WAAS,UAAU;AACnB,QAAM,kBAAkB,OAAO,YAAY;AAC3C,kBAAgB,UAAU;AAE1B,QAAM,aAAa,iBAAiB,CAAC,SAAY,WAAW,IAAI,CAAC;AAEjE,QAAM,WAAW;AAAA,IACf,CAAC,SAA4B;AAC3B,YAAM,WAAW,sBAAsB,MAAM,SAAS,OAAO;AAC7D,UAAI,OAAO,GAAG,UAAU,SAAS,OAAO,EAAG;AAE3C,eAAS,UAAU;AACnB,UAAI,CAAC,gBAAgB,SAAS;AAC5B,wBAAgB,QAAQ;AAAA,MAC1B;AACA,iBAAW,QAAQ;AAAA,IACrB;AAAA,IACA,CAAC,UAAU;AAAA,EACb;AAEA,SAAO,CAAC,OAAO,QAAQ;AACzB;","names":[]}

package/dist/hooks/use-debounce.d.ts

@@ -0,0 +1,3 @@
+/** Returns a debounced copy of `value` that updates after `delay` ms of quiet. */
+export declare function useDebounce<T>(value: T, delay: number): T;
+//# sourceMappingURL=use-debounce.d.ts.map

package/dist/hooks/use-debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-debounce.d.ts","sourceRoot":"","sources":["../../src/hooks/use-debounce.ts"],"names":[],"mappings":"AAIA,kFAAkF;AAClF,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAOzD"}

package/dist/hooks/use-debounce.js

@@ -0,0 +1,14 @@
+"use client";
+import { useEffect, useState } from "react";
+function useDebounce(value, delay) {
+  const [debounced, setDebounced] = useState(value);
+  useEffect(() => {
+    const id = setTimeout(() => setDebounced(value), delay);
+    return () => clearTimeout(id);
+  }, [value, delay]);
+  return debounced;
+}
+export {
+  useDebounce
+};
+//# sourceMappingURL=use-debounce.js.map

package/dist/hooks/use-debounce.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-debounce.ts"],"sourcesContent":["\"use client\";\n\nimport { useEffect, useState } from \"react\";\n\n/** Returns a debounced copy of `value` that updates after `delay` ms of quiet. */\nexport function useDebounce<T>(value: T, delay: number): T {\n  const [debounced, setDebounced] = useState(value);\n  useEffect(() => {\n    const id = setTimeout(() => setDebounced(value), delay);\n    return () => clearTimeout(id);\n  }, [value, delay]);\n  return debounced;\n}\n"],"mappings":";AAEA,SAAS,WAAW,gBAAgB;AAG7B,SAAS,YAAe,OAAU,OAAkB;AACzD,QAAM,CAAC,WAAW,YAAY,IAAI,SAAS,KAAK;AAChD,YAAU,MAAM;AACd,UAAM,KAAK,WAAW,MAAM,aAAa,KAAK,GAAG,KAAK;AACtD,WAAO,MAAM,aAAa,EAAE;AAAA,EAC9B,GAAG,CAAC,OAAO,KAAK,CAAC;AACjB,SAAO;AACT;","names":[]}

package/dist/hooks/use-debounced-callback.d.ts

@@ -0,0 +1,5 @@
+import { type RateLimitedFn } from "./utils/rate-limit.js";
+export type DebouncedFn<Args extends unknown[]> = RateLimitedFn<Args>;
+/** Returns a stable debounced function (trailing edge) with `.cancel()`. */
+export declare function useDebouncedCallback<Args extends unknown[]>(callback: (...args: Args) => void, delay: number): DebouncedFn<Args>;
+//# sourceMappingURL=use-debounced-callback.d.ts.map

package/dist/hooks/use-debounced-callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-debounced-callback.d.ts","sourceRoot":"","sources":["../../src/hooks/use-debounced-callback.ts"],"names":[],"mappings":"AAIA,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE9E,MAAM,MAAM,WAAW,CAAC,IAAI,SAAS,OAAO,EAAE,IAAI,aAAa,CAAC,IAAI,CAAC,CAAC;AAEtE,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAAC,IAAI,SAAS,OAAO,EAAE,EACzD,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,IAAI,EACjC,KAAK,EAAE,MAAM,GACZ,WAAW,CAAC,IAAI,CAAC,CAKnB"}

package/dist/hooks/use-debounced-callback.js

@@ -0,0 +1,14 @@
+"use client";
+import { useEffect, useMemo } from "react";
+import { useEventCallback } from "./use-event-callback.js";
+import { createDebouncedFn } from "./utils/rate-limit.js";
+function useDebouncedCallback(callback, delay) {
+  const onCall = useEventCallback(callback);
+  const debounced = useMemo(() => createDebouncedFn(onCall, delay), [delay, onCall]);
+  useEffect(() => () => debounced.cancel(), [debounced]);
+  return debounced;
+}
+export {
+  useDebouncedCallback
+};
+//# sourceMappingURL=use-debounced-callback.js.map

package/dist/hooks/use-debounced-callback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-debounced-callback.ts"],"sourcesContent":["\"use client\";\n\nimport { useEffect, useMemo } from \"react\";\nimport { useEventCallback } from \"./use-event-callback.js\";\nimport { createDebouncedFn, type RateLimitedFn } from \"./utils/rate-limit.js\";\n\nexport type DebouncedFn<Args extends unknown[]> = RateLimitedFn<Args>;\n\n/** Returns a stable debounced function (trailing edge) with `.cancel()`. */\nexport function useDebouncedCallback<Args extends unknown[]>(\n  callback: (...args: Args) => void,\n  delay: number,\n): DebouncedFn<Args> {\n  const onCall = useEventCallback(callback);\n  const debounced = useMemo(() => createDebouncedFn(onCall, delay), [delay, onCall]);\n  useEffect(() => () => debounced.cancel(), [debounced]);\n  return debounced;\n}\n"],"mappings":";AAEA,SAAS,WAAW,eAAe;AACnC,SAAS,wBAAwB;AACjC,SAAS,yBAA6C;AAK/C,SAAS,qBACd,UACA,OACmB;AACnB,QAAM,SAAS,iBAAiB,QAAQ;AACxC,QAAM,YAAY,QAAQ,MAAM,kBAAkB,QAAQ,KAAK,GAAG,CAAC,OAAO,MAAM,CAAC;AACjF,YAAU,MAAM,MAAM,UAAU,OAAO,GAAG,CAAC,SAAS,CAAC;AACrD,SAAO;AACT;","names":[]}

package/dist/hooks/use-event-callback.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns a memoized function whose identity never changes but which always
+ * invokes the most recent `callback`. Use to pass event handlers into effects
+ * without re-running them on every render.
+ */
+export declare function useEventCallback<Args extends unknown[], R>(callback: (...args: Args) => R): (...args: Args) => R;
+//# sourceMappingURL=use-event-callback.d.ts.map

package/dist/hooks/use-event-callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-event-callback.d.ts","sourceRoot":"","sources":["../../src/hooks/use-event-callback.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,SAAS,OAAO,EAAE,EAAE,CAAC,EACxD,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,CAAC,GAC7B,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,CAAC,CAMtB"}

package/dist/hooks/use-event-callback.js

@@ -0,0 +1,14 @@
+"use client";
+import { useCallback, useRef } from "react";
+import { useIsomorphicLayoutEffect } from "./use-isomorphic-layout-effect.js";
+function useEventCallback(callback) {
+  const ref = useRef(callback);
+  useIsomorphicLayoutEffect(() => {
+    ref.current = callback;
+  });
+  return useCallback((...args) => ref.current(...args), []);
+}
+export {
+  useEventCallback
+};
+//# sourceMappingURL=use-event-callback.js.map

package/dist/hooks/use-event-callback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-event-callback.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback, useRef } from \"react\";\nimport { useIsomorphicLayoutEffect } from \"./use-isomorphic-layout-effect.js\";\n\n/**\n * Returns a memoized function whose identity never changes but which always\n * invokes the most recent `callback`. Use to pass event handlers into effects\n * without re-running them on every render.\n */\nexport function useEventCallback<Args extends unknown[], R>(\n  callback: (...args: Args) => R,\n): (...args: Args) => R {\n  const ref = useRef(callback);\n  useIsomorphicLayoutEffect(() => {\n    ref.current = callback;\n  });\n  return useCallback((...args: Args) => ref.current(...args), []);\n}\n"],"mappings":";AAEA,SAAS,aAAa,cAAc;AACpC,SAAS,iCAAiC;AAOnC,SAAS,iBACd,UACsB;AACtB,QAAM,MAAM,OAAO,QAAQ;AAC3B,4BAA0B,MAAM;AAC9B,QAAI,UAAU;AAAA,EAChB,CAAC;AACD,SAAO,YAAY,IAAI,SAAe,IAAI,QAAQ,GAAG,IAAI,GAAG,CAAC,CAAC;AAChE;","names":[]}

package/dist/hooks/use-event-listener.d.ts

@@ -0,0 +1,4 @@
+import type { RefObject } from "react";
+export declare function useEventListener<K extends keyof WindowEventMap>(type: K, listener: (event: WindowEventMap[K]) => void, target?: undefined, options?: boolean | AddEventListenerOptions): void;
+export declare function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement>(type: K, listener: (event: HTMLElementEventMap[K]) => void, target: RefObject<T | null> | T | null, options?: boolean | AddEventListenerOptions): void;
+//# sourceMappingURL=use-event-listener.d.ts.map

package/dist/hooks/use-event-listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-event-listener.d.ts","sourceRoot":"","sources":["../../src/hooks/use-event-listener.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAKvC,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,cAAc,EAC7D,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,IAAI,EAC5C,MAAM,CAAC,EAAE,SAAS,EAClB,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAC1C,IAAI,CAAC;AACR,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,mBAAmB,EAAE,CAAC,SAAS,WAAW,EACzF,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,KAAK,IAAI,EACjD,MAAM,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,EACtC,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAC1C,IAAI,CAAC"}

package/dist/hooks/use-event-listener.js

@@ -0,0 +1,27 @@
+"use client";
+import { useEffect } from "react";
+import { useEventCallback } from "./use-event-callback.js";
+import { useRefElement } from "./use-ref-element.js";
+import { isRefObject, resolveTarget } from "./utils/ref-target.js";
+function useEventListener(type, listener, target, options) {
+  const handler = useEventCallback(listener);
+  const refTarget = isRefObject(target) ? target : null;
+  const refElement = useRefElement(refTarget);
+  const capture = typeof options === "boolean" ? options : options?.capture ?? false;
+  const passive = typeof options === "object" ? options.passive ?? false : false;
+  const once = typeof options === "object" ? options.once ?? false : false;
+  const signal = typeof options === "object" ? options.signal : void 0;
+  useEffect(() => {
+    const node = refTarget ? refElement : resolveTarget(target);
+    if (!node) return;
+    const normalizedOptions = { capture, passive, once };
+    if (signal) normalizedOptions.signal = signal;
+    const onEvent = (event) => handler(event);
+    node.addEventListener(type, onEvent, normalizedOptions);
+    return () => node.removeEventListener(type, onEvent, capture);
+  }, [type, refTarget, refElement, target, handler, capture, passive, once, signal]);
+}
+export {
+  useEventListener
+};
+//# sourceMappingURL=use-event-listener.js.map

package/dist/hooks/use-event-listener.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-event-listener.ts"],"sourcesContent":["\"use client\";\n\nimport { useEffect } from \"react\";\nimport type { RefObject } from \"react\";\nimport { useEventCallback } from \"./use-event-callback.js\";\nimport { useRefElement } from \"./use-ref-element.js\";\nimport { isRefObject, resolveTarget } from \"./utils/ref-target.js\";\n\nexport function useEventListener<K extends keyof WindowEventMap>(\n  type: K,\n  listener: (event: WindowEventMap[K]) => void,\n  target?: undefined,\n  options?: boolean | AddEventListenerOptions,\n): void;\nexport function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement>(\n  type: K,\n  listener: (event: HTMLElementEventMap[K]) => void,\n  target: RefObject<T | null> | T | null,\n  options?: boolean | AddEventListenerOptions,\n): void;\nexport function useEventListener(\n  type: string,\n  listener: (event: Event) => void,\n  target?: RefObject<EventTarget | null> | EventTarget | null,\n  options?: boolean | AddEventListenerOptions,\n): void {\n  const handler = useEventCallback(listener);\n  const refTarget = isRefObject(target) ? target : null;\n  const refElement = useRefElement(refTarget);\n  const capture = typeof options === \"boolean\" ? options : (options?.capture ?? false);\n  const passive = typeof options === \"object\" ? (options.passive ?? false) : false;\n  const once = typeof options === \"object\" ? (options.once ?? false) : false;\n  const signal = typeof options === \"object\" ? options.signal : undefined;\n\n  useEffect(() => {\n    const node = refTarget ? refElement : resolveTarget(target);\n    if (!node) return;\n    const normalizedOptions: AddEventListenerOptions = { capture, passive, once };\n    if (signal) normalizedOptions.signal = signal;\n    const onEvent = (event: Event) => handler(event);\n    node.addEventListener(type, onEvent, normalizedOptions);\n    return () => node.removeEventListener(type, onEvent, capture);\n  }, [type, refTarget, refElement, target, handler, capture, passive, once, signal]);\n}\n"],"mappings":";AAEA,SAAS,iBAAiB;AAE1B,SAAS,wBAAwB;AACjC,SAAS,qBAAqB;AAC9B,SAAS,aAAa,qBAAqB;AAcpC,SAAS,iBACd,MACA,UACA,QACA,SACM;AACN,QAAM,UAAU,iBAAiB,QAAQ;AACzC,QAAM,YAAY,YAAY,MAAM,IAAI,SAAS;AACjD,QAAM,aAAa,cAAc,SAAS;AAC1C,QAAM,UAAU,OAAO,YAAY,YAAY,UAAW,SAAS,WAAW;AAC9E,QAAM,UAAU,OAAO,YAAY,WAAY,QAAQ,WAAW,QAAS;AAC3E,QAAM,OAAO,OAAO,YAAY,WAAY,QAAQ,QAAQ,QAAS;AACrE,QAAM,SAAS,OAAO,YAAY,WAAW,QAAQ,SAAS;AAE9D,YAAU,MAAM;AACd,UAAM,OAAO,YAAY,aAAa,cAAc,MAAM;AAC1D,QAAI,CAAC,KAAM;AACX,UAAM,oBAA6C,EAAE,SAAS,SAAS,KAAK;AAC5E,QAAI,OAAQ,mBAAkB,SAAS;AACvC,UAAM,UAAU,CAAC,UAAiB,QAAQ,KAAK;AAC/C,SAAK,iBAAiB,MAAM,SAAS,iBAAiB;AACtD,WAAO,MAAM,KAAK,oBAAoB,MAAM,SAAS,OAAO;AAAA,EAC9D,GAAG,CAAC,MAAM,WAAW,YAAY,QAAQ,SAAS,SAAS,SAAS,MAAM,MAAM,CAAC;AACnF;","names":[]}

package/dist/hooks/use-focus-within.d.ts

@@ -0,0 +1,15 @@
+import type { FocusEvent as ReactFocusEvent } from "react";
+export interface UseFocusWithinProps {
+    onFocusWithin?: (event: FocusEvent) => void;
+    onBlurWithin?: (event: FocusEvent) => void;
+}
+export interface UseFocusWithinResult {
+    isFocusWithin: boolean;
+    focusWithinProps: {
+        onFocus: (event: ReactFocusEvent) => void;
+        onBlur: (event: ReactFocusEvent) => void;
+    };
+}
+/** Tracks whether focus is within the element. Returns spreadable props. */
+export declare function useFocusWithin(props?: UseFocusWithinProps): UseFocusWithinResult;
+//# sourceMappingURL=use-focus-within.d.ts.map

package/dist/hooks/use-focus-within.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-focus-within.d.ts","sourceRoot":"","sources":["../../src/hooks/use-focus-within.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,IAAI,eAAe,EAAE,MAAM,OAAO,CAAC;AAG3D,MAAM,WAAW,mBAAmB;IAClC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC5C,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;CAC5C;AAED,MAAM,WAAW,oBAAoB;IACnC,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE;QAChB,OAAO,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;QAC1C,MAAM,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;KAC1C,CAAC;CACH;AAED,4EAA4E;AAC5E,wBAAgB,cAAc,CAAC,KAAK,GAAE,mBAAwB,GAAG,oBAAoB,CAoCpF"}

package/dist/hooks/use-focus-within.js

@@ -0,0 +1,39 @@
+"use client";
+import { useCallback, useMemo, useRef, useState } from "react";
+import { useEventCallback } from "./use-event-callback.js";
+function useFocusWithin(props = {}) {
+  const { onFocusWithin, onBlurWithin } = props;
+  const [isFocusWithin, setIsFocusWithin] = useState(false);
+  const stateRef = useRef(isFocusWithin);
+  stateRef.current = isFocusWithin;
+  const emitFocusWithin = useEventCallback((event) => {
+    onFocusWithin?.(event);
+  });
+  const emitBlurWithin = useEventCallback((event) => {
+    onBlurWithin?.(event);
+  });
+  const onFocus = useCallback(
+    (event) => {
+      if (!stateRef.current) {
+        setIsFocusWithin(true);
+        emitFocusWithin(event.nativeEvent);
+      }
+    },
+    [emitFocusWithin]
+  );
+  const onBlur = useCallback(
+    (event) => {
+      if (stateRef.current && !event.currentTarget.contains(event.relatedTarget)) {
+        setIsFocusWithin(false);
+        emitBlurWithin(event.nativeEvent);
+      }
+    },
+    [emitBlurWithin]
+  );
+  const focusWithinProps = useMemo(() => ({ onFocus, onBlur }), [onFocus, onBlur]);
+  return { isFocusWithin, focusWithinProps };
+}
+export {
+  useFocusWithin
+};
+//# sourceMappingURL=use-focus-within.js.map

package/dist/hooks/use-focus-within.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-focus-within.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback, useMemo, useRef, useState } from \"react\";\nimport type { FocusEvent as ReactFocusEvent } from \"react\";\nimport { useEventCallback } from \"./use-event-callback.js\";\n\nexport interface UseFocusWithinProps {\n  onFocusWithin?: (event: FocusEvent) => void;\n  onBlurWithin?: (event: FocusEvent) => void;\n}\n\nexport interface UseFocusWithinResult {\n  isFocusWithin: boolean;\n  focusWithinProps: {\n    onFocus: (event: ReactFocusEvent) => void;\n    onBlur: (event: ReactFocusEvent) => void;\n  };\n}\n\n/** Tracks whether focus is within the element. Returns spreadable props. */\nexport function useFocusWithin(props: UseFocusWithinProps = {}): UseFocusWithinResult {\n  const { onFocusWithin, onBlurWithin } = props;\n  const [isFocusWithin, setIsFocusWithin] = useState(false);\n  const stateRef = useRef(isFocusWithin);\n  stateRef.current = isFocusWithin;\n\n  const emitFocusWithin = useEventCallback((event: FocusEvent) => {\n    onFocusWithin?.(event);\n  });\n  const emitBlurWithin = useEventCallback((event: FocusEvent) => {\n    onBlurWithin?.(event);\n  });\n\n  const onFocus = useCallback(\n    (event: ReactFocusEvent) => {\n      if (!stateRef.current) {\n        setIsFocusWithin(true);\n        emitFocusWithin(event.nativeEvent);\n      }\n    },\n    [emitFocusWithin],\n  );\n\n  const onBlur = useCallback(\n    (event: ReactFocusEvent) => {\n      if (stateRef.current && !event.currentTarget.contains(event.relatedTarget as Node | null)) {\n        setIsFocusWithin(false);\n        emitBlurWithin(event.nativeEvent);\n      }\n    },\n    [emitBlurWithin],\n  );\n\n  const focusWithinProps = useMemo(() => ({ onFocus, onBlur }), [onFocus, onBlur]);\n\n  return { isFocusWithin, focusWithinProps };\n}\n"],"mappings":";AAEA,SAAS,aAAa,SAAS,QAAQ,gBAAgB;AAEvD,SAAS,wBAAwB;AAgB1B,SAAS,eAAe,QAA6B,CAAC,GAAyB;AACpF,QAAM,EAAE,eAAe,aAAa,IAAI;AACxC,QAAM,CAAC,eAAe,gBAAgB,IAAI,SAAS,KAAK;AACxD,QAAM,WAAW,OAAO,aAAa;AACrC,WAAS,UAAU;AAEnB,QAAM,kBAAkB,iBAAiB,CAAC,UAAsB;AAC9D,oBAAgB,KAAK;AAAA,EACvB,CAAC;AACD,QAAM,iBAAiB,iBAAiB,CAAC,UAAsB;AAC7D,mBAAe,KAAK;AAAA,EACtB,CAAC;AAED,QAAM,UAAU;AAAA,IACd,CAAC,UAA2B;AAC1B,UAAI,CAAC,SAAS,SAAS;AACrB,yBAAiB,IAAI;AACrB,wBAAgB,MAAM,WAAW;AAAA,MACnC;AAAA,IACF;AAAA,IACA,CAAC,eAAe;AAAA,EAClB;AAEA,QAAM,SAAS;AAAA,IACb,CAAC,UAA2B;AAC1B,UAAI,SAAS,WAAW,CAAC,MAAM,cAAc,SAAS,MAAM,aAA4B,GAAG;AACzF,yBAAiB,KAAK;AACtB,uBAAe,MAAM,WAAW;AAAA,MAClC;AAAA,IACF;AAAA,IACA,CAAC,cAAc;AAAA,EACjB;AAEA,QAAM,mBAAmB,QAAQ,OAAO,EAAE,SAAS,OAAO,IAAI,CAAC,SAAS,MAAM,CAAC;AAE/E,SAAO,EAAE,eAAe,iBAAiB;AAC3C;","names":[]}

package/dist/hooks/use-hover.d.ts

@@ -0,0 +1,11 @@
+import type { PointerEvent as ReactPointerEvent } from "react";
+export interface UseHoverResult {
+    isHovered: boolean;
+    hoverProps: {
+        onPointerEnter: (event: ReactPointerEvent) => void;
+        onPointerLeave: (event: ReactPointerEvent) => void;
+    };
+}
+/** Pointer-based hover state. Returns spreadable props. */
+export declare function useHover(): UseHoverResult;
+//# sourceMappingURL=use-hover.d.ts.map

package/dist/hooks/use-hover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hover.d.ts","sourceRoot":"","sources":["../../src/hooks/use-hover.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,IAAI,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAE/D,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE;QACV,cAAc,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;QACnD,cAAc,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;KACpD,CAAC;CACH;AAED,2DAA2D;AAC3D,wBAAgB,QAAQ,IAAI,cAAc,CAazC"}

package/dist/hooks/use-hover.js

@@ -0,0 +1,20 @@
+"use client";
+import { useCallback, useMemo, useState } from "react";
+function useHover() {
+  const [isHovered, setIsHovered] = useState(false);
+  const onPointerEnter = useCallback((event) => {
+    if (event.pointerType !== "touch") setIsHovered(true);
+  }, []);
+  const onPointerLeave = useCallback((event) => {
+    if (event.pointerType !== "touch") setIsHovered(false);
+  }, []);
+  const hoverProps = useMemo(
+    () => ({ onPointerEnter, onPointerLeave }),
+    [onPointerEnter, onPointerLeave]
+  );
+  return { isHovered, hoverProps };
+}
+export {
+  useHover
+};
+//# sourceMappingURL=use-hover.js.map

package/dist/hooks/use-hover.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-hover.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback, useMemo, useState } from \"react\";\nimport type { PointerEvent as ReactPointerEvent } from \"react\";\n\nexport interface UseHoverResult {\n  isHovered: boolean;\n  hoverProps: {\n    onPointerEnter: (event: ReactPointerEvent) => void;\n    onPointerLeave: (event: ReactPointerEvent) => void;\n  };\n}\n\n/** Pointer-based hover state. Returns spreadable props. */\nexport function useHover(): UseHoverResult {\n  const [isHovered, setIsHovered] = useState(false);\n  const onPointerEnter = useCallback((event: ReactPointerEvent) => {\n    if (event.pointerType !== \"touch\") setIsHovered(true);\n  }, []);\n  const onPointerLeave = useCallback((event: ReactPointerEvent) => {\n    if (event.pointerType !== \"touch\") setIsHovered(false);\n  }, []);\n  const hoverProps = useMemo(\n    () => ({ onPointerEnter, onPointerLeave }),\n    [onPointerEnter, onPointerLeave],\n  );\n  return { isHovered, hoverProps };\n}\n"],"mappings":";AAEA,SAAS,aAAa,SAAS,gBAAgB;AAYxC,SAAS,WAA2B;AACzC,QAAM,CAAC,WAAW,YAAY,IAAI,SAAS,KAAK;AAChD,QAAM,iBAAiB,YAAY,CAAC,UAA6B;AAC/D,QAAI,MAAM,gBAAgB,QAAS,cAAa,IAAI;AAAA,EACtD,GAAG,CAAC,CAAC;AACL,QAAM,iBAAiB,YAAY,CAAC,UAA6B;AAC/D,QAAI,MAAM,gBAAgB,QAAS,cAAa,KAAK;AAAA,EACvD,GAAG,CAAC,CAAC;AACL,QAAM,aAAa;AAAA,IACjB,OAAO,EAAE,gBAAgB,eAAe;AAAA,IACxC,CAAC,gBAAgB,cAAc;AAAA,EACjC;AACA,SAAO,EAAE,WAAW,WAAW;AACjC;","names":[]}

package/dist/hooks/use-id.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SSR-safe id. Returns `providedId` if given, otherwise a stable, prefixed,
+ * colon-free id derived from React's `useId`.
+ */
+export declare function useId(providedId?: string, prefix?: string): string;
+//# sourceMappingURL=use-id.d.ts.map

package/dist/hooks/use-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-id.d.ts","sourceRoot":"","sources":["../../src/hooks/use-id.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,wBAAgB,KAAK,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,MAAM,SAAU,GAAG,MAAM,CAGnE"}

package/dist/hooks/use-id.js

@@ -0,0 +1,11 @@
+"use client";
+import { useId as useReactId } from "react";
+import { sanitizeReactId } from "./utils/sanitize-react-id.js";
+function useId(providedId, prefix = "uiify") {
+  const reactId = useReactId();
+  return providedId ?? `${prefix}-${sanitizeReactId(reactId)}`;
+}
+export {
+  useId
+};
+//# sourceMappingURL=use-id.js.map

package/dist/hooks/use-id.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-id.ts"],"sourcesContent":["\"use client\";\n\nimport { useId as useReactId } from \"react\";\nimport { sanitizeReactId } from \"./utils/sanitize-react-id.js\";\n\n/**\n * SSR-safe id. Returns `providedId` if given, otherwise a stable, prefixed,\n * colon-free id derived from React's `useId`.\n */\nexport function useId(providedId?: string, prefix = \"uiify\"): string {\n  const reactId = useReactId();\n  return providedId ?? `${prefix}-${sanitizeReactId(reactId)}`;\n}\n"],"mappings":";AAEA,SAAS,SAAS,kBAAkB;AACpC,SAAS,uBAAuB;AAMzB,SAAS,MAAM,YAAqB,SAAS,SAAiB;AACnE,QAAM,UAAU,WAAW;AAC3B,SAAO,cAAc,GAAG,MAAM,IAAI,gBAAgB,OAAO,CAAC;AAC5D;","names":[]}

package/dist/hooks/use-intersection-observer.d.ts

@@ -0,0 +1,8 @@
+import type { RefObject } from "react";
+export interface UseIntersectionObserverOptions extends IntersectionObserverInit {
+    /** Once intersecting, stop observing and keep the last entry. */
+    freezeOnceVisible?: boolean;
+}
+/** Observes `ref`; returns the latest `IntersectionObserverEntry`. */
+export declare function useIntersectionObserver<T extends Element>(ref: RefObject<T | null>, options?: UseIntersectionObserverOptions): IntersectionObserverEntry | undefined;
+//# sourceMappingURL=use-intersection-observer.d.ts.map

package/dist/hooks/use-intersection-observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-intersection-observer.d.ts","sourceRoot":"","sources":["../../src/hooks/use-intersection-observer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,MAAM,WAAW,8BAA+B,SAAQ,wBAAwB;IAC9E,iEAAiE;IACjE,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,sEAAsE;AACtE,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,OAAO,EACvD,GAAG,EAAE,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,EACxB,OAAO,GAAE,8BAAmC,GAC3C,yBAAyB,GAAG,SAAS,CA4BvC"}

package/dist/hooks/use-intersection-observer.js

@@ -0,0 +1,33 @@
+"use client";
+import { useEffect, useState } from "react";
+import { useRefElement } from "./use-ref-element.js";
+import { intersectionEntryChanged, serializeThreshold } from "./utils/intersection.js";
+function useIntersectionObserver(ref, options = {}) {
+  const element = useRefElement(ref);
+  const { freezeOnceVisible = false, root, rootMargin, threshold } = options;
+  const [entry, setEntry] = useState(void 0);
+  const frozen = Boolean(entry?.isIntersecting) && freezeOnceVisible;
+  const thresholdKey = serializeThreshold(threshold);
+  useEffect(() => {
+    if (!element || frozen || typeof IntersectionObserver === "undefined") return;
+    const observer = new IntersectionObserver(
+      (entries) => {
+        const next = entries[0];
+        if (!next) return;
+        setEntry((previous) => intersectionEntryChanged(previous, next) ? next : previous);
+      },
+      {
+        root: root ?? null,
+        rootMargin: rootMargin ?? "0px",
+        threshold: threshold ?? 0
+      }
+    );
+    observer.observe(element);
+    return () => observer.disconnect();
+  }, [element, root, rootMargin, thresholdKey, frozen]);
+  return entry;
+}
+export {
+  useIntersectionObserver
+};
+//# sourceMappingURL=use-intersection-observer.js.map

package/dist/hooks/use-intersection-observer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-intersection-observer.ts"],"sourcesContent":["\"use client\";\n\nimport { useEffect, useState } from \"react\";\nimport type { RefObject } from \"react\";\nimport { useRefElement } from \"./use-ref-element.js\";\nimport { intersectionEntryChanged, serializeThreshold } from \"./utils/intersection.js\";\n\nexport interface UseIntersectionObserverOptions extends IntersectionObserverInit {\n  /** Once intersecting, stop observing and keep the last entry. */\n  freezeOnceVisible?: boolean;\n}\n\n/** Observes `ref`; returns the latest `IntersectionObserverEntry`. */\nexport function useIntersectionObserver<T extends Element>(\n  ref: RefObject<T | null>,\n  options: UseIntersectionObserverOptions = {},\n): IntersectionObserverEntry | undefined {\n  const element = useRefElement(ref);\n  const { freezeOnceVisible = false, root, rootMargin, threshold } = options;\n  const [entry, setEntry] = useState<IntersectionObserverEntry | undefined>(undefined);\n  const frozen = Boolean(entry?.isIntersecting) && freezeOnceVisible;\n  const thresholdKey = serializeThreshold(threshold);\n\n  useEffect(() => {\n    if (!element || frozen || typeof IntersectionObserver === \"undefined\") return;\n    const observer = new IntersectionObserver(\n      (entries) => {\n        const next = entries[0];\n        if (!next) return;\n        setEntry((previous) => (intersectionEntryChanged(previous, next) ? next : previous));\n      },\n      {\n        root: root ?? null,\n        rootMargin: rootMargin ?? \"0px\",\n        threshold: threshold ?? 0,\n      },\n    );\n    observer.observe(element);\n    return () => observer.disconnect();\n    // thresholdKey stands in for the (possibly array) threshold value.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [element, root, rootMargin, thresholdKey, frozen]);\n\n  return entry;\n}\n"],"mappings":";AAEA,SAAS,WAAW,gBAAgB;AAEpC,SAAS,qBAAqB;AAC9B,SAAS,0BAA0B,0BAA0B;AAQtD,SAAS,wBACd,KACA,UAA0C,CAAC,GACJ;AACvC,QAAM,UAAU,cAAc,GAAG;AACjC,QAAM,EAAE,oBAAoB,OAAO,MAAM,YAAY,UAAU,IAAI;AACnE,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAgD,MAAS;AACnF,QAAM,SAAS,QAAQ,OAAO,cAAc,KAAK;AACjD,QAAM,eAAe,mBAAmB,SAAS;AAEjD,YAAU,MAAM;AACd,QAAI,CAAC,WAAW,UAAU,OAAO,yBAAyB,YAAa;AACvE,UAAM,WAAW,IAAI;AAAA,MACnB,CAAC,YAAY;AACX,cAAM,OAAO,QAAQ,CAAC;AACtB,YAAI,CAAC,KAAM;AACX,iBAAS,CAAC,aAAc,yBAAyB,UAAU,IAAI,IAAI,OAAO,QAAS;AAAA,MACrF;AAAA,MACA;AAAA,QACE,MAAM,QAAQ;AAAA,QACd,YAAY,cAAc;AAAA,QAC1B,WAAW,aAAa;AAAA,MAC1B;AAAA,IACF;AACA,aAAS,QAAQ,OAAO;AACxB,WAAO,MAAM,SAAS,WAAW;AAAA,EAGnC,GAAG,CAAC,SAAS,MAAM,YAAY,cAAc,MAAM,CAAC;AAEpD,SAAO;AACT;","names":[]}

package/dist/hooks/use-interval.d.ts

@@ -0,0 +1,3 @@
+/** Declarative `setInterval`. Pass `delay = null` to pause. */
+export declare function useInterval(callback: () => void, delay: number | null): void;
+//# sourceMappingURL=use-interval.d.ts.map

package/dist/hooks/use-interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-interval.d.ts","sourceRoot":"","sources":["../../src/hooks/use-interval.ts"],"names":[],"mappings":"AAIA,+DAA+D;AAC/D,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAE5E"}

package/dist/hooks/use-interval.js

@@ -0,0 +1,9 @@
+"use client";
+import { useTimer } from "./use-timer.js";
+function useInterval(callback, delay) {
+  useTimer("interval", callback, delay);
+}
+export {
+  useInterval
+};
+//# sourceMappingURL=use-interval.js.map

package/dist/hooks/use-interval.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-interval.ts"],"sourcesContent":["\"use client\";\n\nimport { useTimer } from \"./use-timer.js\";\n\n/** Declarative `setInterval`. Pass `delay = null` to pause. */\nexport function useInterval(callback: () => void, delay: number | null): void {\n  useTimer(\"interval\", callback, delay);\n}\n"],"mappings":";AAEA,SAAS,gBAAgB;AAGlB,SAAS,YAAY,UAAsB,OAA4B;AAC5E,WAAS,YAAY,UAAU,KAAK;AACtC;","names":[]}

package/dist/hooks/use-is-mounted.d.ts

@@ -0,0 +1,3 @@
+/** Returns a getter that reports whether the component is currently mounted. */
+export declare function useIsMounted(): () => boolean;
+//# sourceMappingURL=use-is-mounted.d.ts.map

package/dist/hooks/use-is-mounted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-is-mounted.d.ts","sourceRoot":"","sources":["../../src/hooks/use-is-mounted.ts"],"names":[],"mappings":"AAIA,gFAAgF;AAChF,wBAAgB,YAAY,IAAI,MAAM,OAAO,CAS5C"}

package/dist/hooks/use-is-mounted.js

@@ -0,0 +1,16 @@
+"use client";
+import { useCallback, useEffect, useRef } from "react";
+function useIsMounted() {
+  const mounted = useRef(false);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  return useCallback(() => mounted.current, []);
+}
+export {
+  useIsMounted
+};
+//# sourceMappingURL=use-is-mounted.js.map

package/dist/hooks/use-is-mounted.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-is-mounted.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback, useEffect, useRef } from \"react\";\n\n/** Returns a getter that reports whether the component is currently mounted. */\nexport function useIsMounted(): () => boolean {\n  const mounted = useRef(false);\n  useEffect(() => {\n    mounted.current = true;\n    return () => {\n      mounted.current = false;\n    };\n  }, []);\n  return useCallback(() => mounted.current, []);\n}\n"],"mappings":";AAEA,SAAS,aAAa,WAAW,cAAc;AAGxC,SAAS,eAA8B;AAC5C,QAAM,UAAU,OAAO,KAAK;AAC5B,YAAU,MAAM;AACd,YAAQ,UAAU;AAClB,WAAO,MAAM;AACX,cAAQ,UAAU;AAAA,IACpB;AAAA,EACF,GAAG,CAAC,CAAC;AACL,SAAO,YAAY,MAAM,QAAQ,SAAS,CAAC,CAAC;AAC9C;","names":[]}

package/dist/hooks/use-isomorphic-layout-effect.d.ts

@@ -0,0 +1,7 @@
+import { useEffect } from "react";
+/**
+ * `useLayoutEffect` in the browser, `useEffect` on the server — avoids React's
+ * "useLayoutEffect does nothing on the server" warning during SSR.
+ */
+export declare const useIsomorphicLayoutEffect: typeof useEffect;
+//# sourceMappingURL=use-isomorphic-layout-effect.d.ts.map

package/dist/hooks/use-isomorphic-layout-effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-isomorphic-layout-effect.d.ts","sourceRoot":"","sources":["../../src/hooks/use-isomorphic-layout-effect.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAmB,MAAM,OAAO,CAAC;AAEnD;;;GAGG;AACH,eAAO,MAAM,yBAAyB,kBACuB,CAAC"}

package/dist/hooks/use-isomorphic-layout-effect.js

@@ -0,0 +1,7 @@
+"use client";
+import { useEffect, useLayoutEffect } from "react";
+const useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+export {
+  useIsomorphicLayoutEffect
+};
+//# sourceMappingURL=use-isomorphic-layout-effect.js.map

package/dist/hooks/use-isomorphic-layout-effect.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/use-isomorphic-layout-effect.ts"],"sourcesContent":["\"use client\";\n\nimport { useEffect, useLayoutEffect } from \"react\";\n\n/**\n * `useLayoutEffect` in the browser, `useEffect` on the server — avoids React's\n * \"useLayoutEffect does nothing on the server\" warning during SSR.\n */\nexport const useIsomorphicLayoutEffect =\n  typeof window !== \"undefined\" ? useLayoutEffect : useEffect;\n"],"mappings":";AAEA,SAAS,WAAW,uBAAuB;AAMpC,MAAM,4BACX,OAAO,WAAW,cAAc,kBAAkB;","names":[]}

package/dist/hooks/use-local-storage.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SSR-safe persisted state backed by `localStorage`. Returns the default on the
+ * server and on first client render, then hydrates the stored value after mount.
+ */
+export declare function useLocalStorage<T>(key: string, defaultValue: T): [T, (value: T | ((prev: T) => T)) => void];
+//# sourceMappingURL=use-local-storage.d.ts.map

package/dist/hooks/use-local-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-local-storage.d.ts","sourceRoot":"","sources":["../../src/hooks/use-local-storage.ts"],"names":[],"mappings":"AAiDA;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI,CAAC,CAoD5C"}