@reause/integrations 0.1.2

package/dist/useFocusTrap.d.ts

@@ -0,0 +1,116 @@
+import { RefOrValue } from "@reause/shared";
+import * as FocusTrap from "focus-trap";
+//#region useFocusTrap/index.d.ts
+/**
+ * Activate options accepted by `useFocusTrap().activate()` — mirrors
+ * focus-trap's non-exported `ActivateOptions`.
+ */
+type ActivateOptions = NonNullable<Parameters<FocusTrap.FocusTrap['activate']>[0]>;
+/**
+ * Deactivate options accepted by `useFocusTrap().deactivate()` — mirrors
+ * focus-trap's non-exported `DeactivateOptions`.
+ */
+type DeactivateOptions = NonNullable<Parameters<FocusTrap.FocusTrap['deactivate']>[0]>;
+export interface UseFocusTrapOptions extends FocusTrap.Options {
+  /**
+   * Immediately activate the trap
+   */
+  immediate?: boolean;
+  /**
+   * Called when the trap is activated. Focus-trap's own `Options.onActivate` is
+   * typed (and, in the pinned version, invoked) without arguments; this port
+   * re-declares it with the optional activation params so they are forwarded
+   * exactly like upstream (`options.onActivate(params)`).
+   */
+  onActivate?: (params?: ActivateOptions) => void;
+  /**
+   * Called when the trap is deactivated, receiving the deactivation params.
+   * Focus-trap's own `Options.onDeactivate` is typed (and, in the pinned
+   * version, invoked) without arguments; this port re-declares it with the
+   * optional deactivation params so they are forwarded exactly like upstream
+   * (`options.onDeactivate(params)`).
+   */
+  onDeactivate?: (params?: DeactivateOptions) => void;
+}
+export interface UseFocusTrapReturn {
+  /**
+   * Indicates if the focus trap is currently active
+   */
+  hasFocus: boolean;
+  /**
+   * Indicates if the focus trap is currently paused
+   */
+  isPaused: boolean;
+  /**
+   * Activate the focus trap
+   *
+   * @see https://github.com/focus-trap/focus-trap#trapactivateactivateoptions
+   * @param opts Activate focus trap options
+   */
+  activate: (opts?: ActivateOptions) => void;
+  /**
+   * Deactivate the focus trap
+   *
+   * @see https://github.com/focus-trap/focus-trap#trapdeactivatedeactivateoptions
+   * @param opts Deactivate focus trap options
+   */
+  deactivate: (opts?: DeactivateOptions) => void;
+  /**
+   * Pause the focus trap
+   *
+   * @see https://github.com/focus-trap/focus-trap#trappause
+   */
+  pause: () => void;
+  /**
+   * Unpauses the focus trap
+   *
+   * @see https://github.com/focus-trap/focus-trap#trapunpause
+   */
+  unpause: () => void;
+}
+/** Accepted DOM target kinds — mirrors upstream's `MaybeElement`. */
+type MaybeElement = HTMLElement | SVGElement | null | undefined;
+/** A plain element or a React ref-like object (`{ current }`) — upstream `MaybeElementRef`. */
+type MaybeElementRef = MaybeElement | {
+  readonly current: MaybeElement;
+};
+/** One item of the focus-trap target list (upstream `MaybeComputedElementRef`, without its getter branch). */
+type FocusTrapTarget = RefOrValue<string> | MaybeElementRef;
+/**
+ * React port of VueUse's `useFocusTrap` — trap focus within one or more
+ * elements.
+ *
+ * Map from @vueuse/integrations `useFocusTrap`
+ * (`source/vueuse/packages/integrations/useFocusTrap/`), a reactive wrapper
+ * around the [`focus-trap`](https://github.com/focus-trap/focus-trap) library
+ * that keeps focus trapped inside the target element(s) while the trap is
+ * active.
+ *
+ * Adjustment for React: upstream creates the trap inside a `watch` over the
+ * resolved targets and exposes `ShallowRef`s for `hasFocus` / `isPaused`. The
+ * React port creates the `createFocusTrap` instance in an effect keyed on the
+ * resolved targets (mirroring the `watch`), keeps it for the lifetime of the
+ * component — target changes go through `updateContainerElements` — and
+ * deactivates it on unmount (`tryOnScopeDispose`). `hasFocus` / `isPaused`
+ * are plain booleans driven by focus-trap's `onActivate` / `onDeactivate`
+ * events plus the pause / unpause calls, and `activate` / `deactivate` /
+ * `pause` / `unpause` are stable callbacks delegating to the current trap
+ * instance. The `immediate` option activates the trap as soon as the target
+ * elements are available.
+ *
+ * SSR-safe: no `window` or DOM access at module scope — the trap is created
+ * lazily inside the effect.
+ *
+ * @param target - element, React ref object (`{ current }`), selector string,
+ *   or an array of them
+ * @param options - focus-trap options (see
+ *   https://github.com/focus-trap/focus-trap#createoptions) plus the
+ *   `immediate` shortcut
+ *
+ * @example
+ * const target = useRef<HTMLDivElement>(null)
+ * const { hasFocus, isPaused, activate, deactivate, pause, unpause } = useFocusTrap(target)
+ * activate() // traps focus inside target
+ */
+export declare function useFocusTrap(target: RefOrValue<FocusTrapTarget | FocusTrapTarget[]>, options?: UseFocusTrapOptions): UseFocusTrapReturn;
+//#endregion

package/dist/useFocusTrap.iife.js

@@ -0,0 +1,125 @@
+(function(exports, _reause_shared, focus_trap, react) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region useFocusTrap/index.tsx
+	/**
+	* Resolve one target item to a focus-trap container: a selector string, a DOM
+	* element, or `null` when it cannot be resolved. Upstream resolves elements
+	* with `unrefElement` (`@vueuse/core`); the React port composes the same
+	* unwrapping from `toValue` / `isRefLike` (`@reause/shared`) — one pass
+	* unwraps a ref-like object, a second one covers a ref-like object holding
+	* another ref-like (`{ current: { current: element } }`).
+	*/
+	function resolveElement(value) {
+		let el = (0, _reause_shared.toValue)(value);
+		if (typeof el !== "string" && (0, _reause_shared.isRefLike)(el)) el = (0, _reause_shared.toValue)(el);
+		if (typeof el === "string") return el;
+		if (typeof el === "object" && el !== null && (el instanceof HTMLElement || el instanceof SVGElement)) return el;
+		return null;
+	}
+	/**
+	* React port of VueUse's `useFocusTrap` — trap focus within one or more
+	* elements.
+	*
+	* Map from @vueuse/integrations `useFocusTrap`
+	* (`source/vueuse/packages/integrations/useFocusTrap/`), a reactive wrapper
+	* around the [`focus-trap`](https://github.com/focus-trap/focus-trap) library
+	* that keeps focus trapped inside the target element(s) while the trap is
+	* active.
+	*
+	* Adjustment for React: upstream creates the trap inside a `watch` over the
+	* resolved targets and exposes `ShallowRef`s for `hasFocus` / `isPaused`. The
+	* React port creates the `createFocusTrap` instance in an effect keyed on the
+	* resolved targets (mirroring the `watch`), keeps it for the lifetime of the
+	* component — target changes go through `updateContainerElements` — and
+	* deactivates it on unmount (`tryOnScopeDispose`). `hasFocus` / `isPaused`
+	* are plain booleans driven by focus-trap's `onActivate` / `onDeactivate`
+	* events plus the pause / unpause calls, and `activate` / `deactivate` /
+	* `pause` / `unpause` are stable callbacks delegating to the current trap
+	* instance. The `immediate` option activates the trap as soon as the target
+	* elements are available.
+	*
+	* SSR-safe: no `window` or DOM access at module scope — the trap is created
+	* lazily inside the effect.
+	*
+	* @param target - element, React ref object (`{ current }`), selector string,
+	*   or an array of them
+	* @param options - focus-trap options (see
+	*   https://github.com/focus-trap/focus-trap#createoptions) plus the
+	*   `immediate` shortcut
+	*
+	* @example
+	* const target = useRef<HTMLDivElement>(null)
+	* const { hasFocus, isPaused, activate, deactivate, pause, unpause } = useFocusTrap(target)
+	* activate() // traps focus inside target
+	*/
+	function useFocusTrap(target, options = {}) {
+		const [hasFocus, setHasFocus] = (0, react.useState)(false);
+		const [isPaused, setIsPaused] = (0, react.useState)(false);
+		const trapRef = (0, react.useRef)(null);
+		const targetRef = (0, react.useRef)(target);
+		targetRef.current = target;
+		const optionsRef = (0, react.useRef)(options);
+		optionsRef.current = options;
+		const resolvedTargetsRef = (0, react.useRef)(null);
+		(0, react.useEffect)(() => {
+			const targets = (0, _reause_shared.toArray)((0, _reause_shared.toValue)(targetRef.current)).map(resolveElement).filter((el) => el != null);
+			const previous = resolvedTargetsRef.current;
+			resolvedTargetsRef.current = targets;
+			if (previous && targets.length === previous.length && targets.every((el, index) => el === previous[index])) return;
+			if (!targets.length) return;
+			const trap = trapRef.current;
+			if (!trap) {
+				const { immediate, ...focusTrapOptions } = optionsRef.current;
+				trapRef.current = (0, focus_trap.createFocusTrap)(targets, {
+					...focusTrapOptions,
+					onActivate(params) {
+						var _optionsRef$current$o, _optionsRef$current;
+						setHasFocus(true);
+						(_optionsRef$current$o = (_optionsRef$current = optionsRef.current).onActivate) === null || _optionsRef$current$o === void 0 || _optionsRef$current$o.call(_optionsRef$current, params);
+					},
+					onDeactivate(params) {
+						var _optionsRef$current$o2, _optionsRef$current2;
+						setHasFocus(false);
+						(_optionsRef$current$o2 = (_optionsRef$current2 = optionsRef.current).onDeactivate) === null || _optionsRef$current$o2 === void 0 || _optionsRef$current$o2.call(_optionsRef$current2, params);
+					}
+				});
+				if (immediate) trapRef.current.activate();
+			} else {
+				const isActive = trap.active;
+				trap.updateContainerElements(targets);
+				if (!isActive && optionsRef.current.immediate) trap.activate();
+			}
+		});
+		(0, react.useEffect)(() => () => {
+			var _trapRef$current;
+			(_trapRef$current = trapRef.current) === null || _trapRef$current === void 0 || _trapRef$current.deactivate();
+			trapRef.current = null;
+		}, []);
+		return {
+			hasFocus,
+			isPaused,
+			activate: (0, react.useCallback)((opts) => {
+				var _trapRef$current2;
+				(_trapRef$current2 = trapRef.current) === null || _trapRef$current2 === void 0 || _trapRef$current2.activate(opts);
+			}, []),
+			deactivate: (0, react.useCallback)((opts) => {
+				var _trapRef$current3;
+				(_trapRef$current3 = trapRef.current) === null || _trapRef$current3 === void 0 || _trapRef$current3.deactivate(opts);
+			}, []),
+			pause: (0, react.useCallback)(() => {
+				if (trapRef.current) {
+					trapRef.current.pause();
+					setIsPaused(true);
+				}
+			}, []),
+			unpause: (0, react.useCallback)(() => {
+				if (trapRef.current) {
+					trapRef.current.unpause();
+					setIsPaused(false);
+				}
+			}, [])
+		};
+	}
+	//#endregion
+	exports.useFocusTrap = useFocusTrap;
+})(this.reause = this.reause || {}, reause, focusTrap, React);

package/dist/useFocusTrap.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});function i(e){let n=(0,t.toValue)(e);return typeof n!=`string`&&(0,t.isRefLike)(n)&&(n=(0,t.toValue)(n)),typeof n==`string`||typeof n==`object`&&n&&(n instanceof HTMLElement||n instanceof SVGElement)?n:null}function a(e,a={}){let[o,s]=(0,r.useState)(!1),[c,l]=(0,r.useState)(!1),u=(0,r.useRef)(null),d=(0,r.useRef)(e);d.current=e;let f=(0,r.useRef)(a);f.current=a;let p=(0,r.useRef)(null);return(0,r.useEffect)(()=>{let e=(0,t.toArray)((0,t.toValue)(d.current)).map(i).filter(e=>e!=null),r=p.current;if(p.current=e,r&&e.length===r.length&&e.every((e,t)=>e===r[t])||!e.length)return;let a=u.current;if(a){let t=a.active;a.updateContainerElements(e),!t&&f.current.immediate&&a.activate()}else{let{immediate:t,...r}=f.current;u.current=(0,n.createFocusTrap)(e,{...r,onActivate(e){var t,n;s(!0),(t=(n=f.current).onActivate)==null||t.call(n,e)},onDeactivate(e){var t,n;s(!1),(t=(n=f.current).onDeactivate)==null||t.call(n,e)}}),t&&u.current.activate()}}),(0,r.useEffect)(()=>()=>{var e;(e=u.current)==null||e.deactivate(),u.current=null},[]),{hasFocus:o,isPaused:c,activate:(0,r.useCallback)(e=>{var t;(t=u.current)==null||t.activate(e)},[]),deactivate:(0,r.useCallback)(e=>{var t;(t=u.current)==null||t.deactivate(e)},[]),pause:(0,r.useCallback)(()=>{u.current&&(u.current.pause(),l(!0))},[]),unpause:(0,r.useCallback)(()=>{u.current&&(u.current.unpause(),l(!1))},[])}}e.useFocusTrap=a})(this.reause=this.reause||{},reause,focusTrap,React);

package/dist/useFocusTrap.js

@@ -0,0 +1,125 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { isRefLike, toArray, toValue } from "@reause/shared";
+import { createFocusTrap } from "focus-trap";
+//#region useFocusTrap/index.tsx
+/**
+* Resolve one target item to a focus-trap container: a selector string, a DOM
+* element, or `null` when it cannot be resolved. Upstream resolves elements
+* with `unrefElement` (`@vueuse/core`); the React port composes the same
+* unwrapping from `toValue` / `isRefLike` (`@reause/shared`) — one pass
+* unwraps a ref-like object, a second one covers a ref-like object holding
+* another ref-like (`{ current: { current: element } }`).
+*/
+function resolveElement(value) {
+	let el = toValue(value);
+	if (typeof el !== "string" && isRefLike(el)) el = toValue(el);
+	if (typeof el === "string") return el;
+	if (typeof el === "object" && el !== null && (el instanceof HTMLElement || el instanceof SVGElement)) return el;
+	return null;
+}
+/**
+* React port of VueUse's `useFocusTrap` — trap focus within one or more
+* elements.
+*
+* Map from @vueuse/integrations `useFocusTrap`
+* (`source/vueuse/packages/integrations/useFocusTrap/`), a reactive wrapper
+* around the [`focus-trap`](https://github.com/focus-trap/focus-trap) library
+* that keeps focus trapped inside the target element(s) while the trap is
+* active.
+*
+* Adjustment for React: upstream creates the trap inside a `watch` over the
+* resolved targets and exposes `ShallowRef`s for `hasFocus` / `isPaused`. The
+* React port creates the `createFocusTrap` instance in an effect keyed on the
+* resolved targets (mirroring the `watch`), keeps it for the lifetime of the
+* component — target changes go through `updateContainerElements` — and
+* deactivates it on unmount (`tryOnScopeDispose`). `hasFocus` / `isPaused`
+* are plain booleans driven by focus-trap's `onActivate` / `onDeactivate`
+* events plus the pause / unpause calls, and `activate` / `deactivate` /
+* `pause` / `unpause` are stable callbacks delegating to the current trap
+* instance. The `immediate` option activates the trap as soon as the target
+* elements are available.
+*
+* SSR-safe: no `window` or DOM access at module scope — the trap is created
+* lazily inside the effect.
+*
+* @param target - element, React ref object (`{ current }`), selector string,
+*   or an array of them
+* @param options - focus-trap options (see
+*   https://github.com/focus-trap/focus-trap#createoptions) plus the
+*   `immediate` shortcut
+*
+* @example
+* const target = useRef<HTMLDivElement>(null)
+* const { hasFocus, isPaused, activate, deactivate, pause, unpause } = useFocusTrap(target)
+* activate() // traps focus inside target
+*/
+function useFocusTrap(target, options = {}) {
+	const [hasFocus, setHasFocus] = useState(false);
+	const [isPaused, setIsPaused] = useState(false);
+	const trapRef = useRef(null);
+	const targetRef = useRef(target);
+	targetRef.current = target;
+	const optionsRef = useRef(options);
+	optionsRef.current = options;
+	const resolvedTargetsRef = useRef(null);
+	useEffect(() => {
+		const targets = toArray(toValue(targetRef.current)).map(resolveElement).filter((el) => el != null);
+		const previous = resolvedTargetsRef.current;
+		resolvedTargetsRef.current = targets;
+		if (previous && targets.length === previous.length && targets.every((el, index) => el === previous[index])) return;
+		if (!targets.length) return;
+		const trap = trapRef.current;
+		if (!trap) {
+			const { immediate, ...focusTrapOptions } = optionsRef.current;
+			trapRef.current = createFocusTrap(targets, {
+				...focusTrapOptions,
+				onActivate(params) {
+					var _optionsRef$current$o, _optionsRef$current;
+					setHasFocus(true);
+					(_optionsRef$current$o = (_optionsRef$current = optionsRef.current).onActivate) === null || _optionsRef$current$o === void 0 || _optionsRef$current$o.call(_optionsRef$current, params);
+				},
+				onDeactivate(params) {
+					var _optionsRef$current$o2, _optionsRef$current2;
+					setHasFocus(false);
+					(_optionsRef$current$o2 = (_optionsRef$current2 = optionsRef.current).onDeactivate) === null || _optionsRef$current$o2 === void 0 || _optionsRef$current$o2.call(_optionsRef$current2, params);
+				}
+			});
+			if (immediate) trapRef.current.activate();
+		} else {
+			const isActive = trap.active;
+			trap.updateContainerElements(targets);
+			if (!isActive && optionsRef.current.immediate) trap.activate();
+		}
+	});
+	useEffect(() => () => {
+		var _trapRef$current;
+		(_trapRef$current = trapRef.current) === null || _trapRef$current === void 0 || _trapRef$current.deactivate();
+		trapRef.current = null;
+	}, []);
+	return {
+		hasFocus,
+		isPaused,
+		activate: useCallback((opts) => {
+			var _trapRef$current2;
+			(_trapRef$current2 = trapRef.current) === null || _trapRef$current2 === void 0 || _trapRef$current2.activate(opts);
+		}, []),
+		deactivate: useCallback((opts) => {
+			var _trapRef$current3;
+			(_trapRef$current3 = trapRef.current) === null || _trapRef$current3 === void 0 || _trapRef$current3.deactivate(opts);
+		}, []),
+		pause: useCallback(() => {
+			if (trapRef.current) {
+				trapRef.current.pause();
+				setIsPaused(true);
+			}
+		}, []),
+		unpause: useCallback(() => {
+			if (trapRef.current) {
+				trapRef.current.unpause();
+				setIsPaused(false);
+			}
+		}, [])
+	};
+}
+//#endregion
+export { useFocusTrap };

package/dist/useFuse.d.ts

@@ -0,0 +1,86 @@
+import { RefOrValue } from "@reause/shared";
+import Fuse, { FuseResult, IFuseOptions } from "fuse.js";
+//#region useFuse/index.d.ts
+/**
+ * Options passed straight through to the underlying `Fuse` instance — alias of
+ * fuse.js' `IFuseOptions<T>`.
+ */
+export type FuseOptions<T> = IFuseOptions<T>;
+export interface UseFuseOptions<T> {
+  /**
+   * Options for the underlying `Fuse` instance.
+   *
+   * Memoize this object (and the `keys` array inside it) between renders:
+   * the `Fuse` index is rebuilt whenever this reference changes. A fresh
+   * object literal on every render is still CORRECT, only slower.
+   */
+  fuseOptions?: FuseOptions<T>;
+  /**
+   * Maximum number of results returned by a search. Ignored when
+   * `matchAllWhenSearchEmpty` kicks in for an empty search.
+   */
+  resultLimit?: number;
+  /**
+   * Return every item (in its original order) while the search is empty,
+   * instead of an empty result list.
+   */
+  matchAllWhenSearchEmpty?: boolean;
+}
+/**
+ * React return type: a plain object, not a tuple — `fuse` and `results` are
+ * named, heterogeneous values (`fuse` is the live `Fuse` instance, `results`
+ * is a plain array), matching the object-return precedent of
+ * `packages/core/src/useBattery.ts` and `packages/core/src/useClipboard.ts`.
+ */
+export interface UseFuseReturn<DataItem> {
+  /** The live `Fuse` instance — call `fuse.setCollection()` / `fuse.search()` on it directly. */
+  fuse: Fuse<DataItem>;
+  /** Fuzzy search results, recomputed on every render. */
+  results: FuseResult<DataItem>[];
+}
+/**
+ * React port of VueUse's `useFuse` — easily implement fuzzy search with
+ * [Fuse.js](https://github.com/krisk/fuse).
+ *
+ * Map from @vueuse/integrations `useFuse`
+ * (`source/vueuse/packages/integrations/useFuse/`), a reactive wrapper around
+ * a `Fuse` instance. `search` and `data` are the hook's **read-only value
+ * sources** and take plain values (`string` and `readonly DataItem[]`; upstream:
+ * `MaybeRefOrGetter`). `options` stays `RefOrValue` (a config object, upstream
+ * `MaybeRefOrGetter`).
+ *
+ * Adjustment for React:
+ * - upstream returns `{ fuse: Ref<Fuse>, results: ComputedRef<FuseResult[]> }`;
+ *   here both are plain values read during render — `fuse` is the `Fuse`
+ *   instance itself (no `.value`), `results` is a plain array;
+ * - upstream rebuilds the index in `watch(() => toValue(options)?.fuseOptions,
+ *   …, { deep: true })` and refreshes the collection in `watch(() => toValue(data), …)`.
+ *   React has no deep watcher, and serializing `fuseOptions` to compare them by
+ *   value would break function-valued options (`sortFn`, `getFn`, `keys[].getFn`),
+ *   so the `Fuse` instance is memoized on the identity of the `data`
+ *   array and of `fuseOptions` instead: pass a NEW array reference when the data
+ *   changes, and a memoized `fuseOptions` object for best performance. Mutating
+ *   the data array in place is not detected (upstream's deep watch was);
+ * - `results` is memoized on the search string and the `data` identity, so a
+ *   changed `search`/`data` prop recomputes on the next render;
+ * - `options` is NOT widened: it is a config object (upstream
+ *   `MaybeRefOrGetter`, a maintainer decision), so a plain options object, a
+ *   ref-like `{ current }` object or a getter are the accepted forms.
+ *
+ * @param search - the search query
+ * @param data - the collection to search
+ * @param options - `fuseOptions` (forwarded to `new Fuse()`), `resultLimit`,
+ *   `matchAllWhenSearchEmpty`
+ *
+ * @__NO_SIDE_EFFECTS__
+ * @example
+ * const { fuse, results } = useFuse(input, data, {
+ *   fuseOptions: { keys: ['firstName', 'lastName'] },
+ *   resultLimit: 10,
+ *   matchAllWhenSearchEmpty: true,
+ * })
+ * results[0].item // the best match
+ * fuse.search('john') // search the same index directly
+ */
+export declare function useFuse<DataItem>(search: string, data: readonly DataItem[], options?: RefOrValue<UseFuseOptions<DataItem>>): UseFuseReturn<DataItem>;
+//#endregion

package/dist/useFuse.iife.js

@@ -0,0 +1,95 @@
+(function(exports, _reause_shared, fuse_js, react) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region \0rolldown/runtime.js
+	var __create = Object.create;
+	var __defProp = Object.defineProperty;
+	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+	var __getOwnPropNames = Object.getOwnPropertyNames;
+	var __getProtoOf = Object.getPrototypeOf;
+	var __hasOwnProp = Object.prototype.hasOwnProperty;
+	var __copyProps = (to, from, except, desc) => {
+		if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+				get: ((k) => from[k]).bind(null, key),
+				enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+			});
+		}
+		return to;
+	};
+	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+		value: mod,
+		enumerable: true
+	}) : target, mod));
+	//#endregion
+	fuse_js = __toESM(fuse_js, 1);
+	//#region useFuse/index.tsx
+	/**
+	* React port of VueUse's `useFuse` — easily implement fuzzy search with
+	* [Fuse.js](https://github.com/krisk/fuse).
+	*
+	* Map from @vueuse/integrations `useFuse`
+	* (`source/vueuse/packages/integrations/useFuse/`), a reactive wrapper around
+	* a `Fuse` instance. `search` and `data` are the hook's **read-only value
+	* sources** and take plain values (`string` and `readonly DataItem[]`; upstream:
+	* `MaybeRefOrGetter`). `options` stays `RefOrValue` (a config object, upstream
+	* `MaybeRefOrGetter`).
+	*
+	* Adjustment for React:
+	* - upstream returns `{ fuse: Ref<Fuse>, results: ComputedRef<FuseResult[]> }`;
+	*   here both are plain values read during render — `fuse` is the `Fuse`
+	*   instance itself (no `.value`), `results` is a plain array;
+	* - upstream rebuilds the index in `watch(() => toValue(options)?.fuseOptions,
+	*   …, { deep: true })` and refreshes the collection in `watch(() => toValue(data), …)`.
+	*   React has no deep watcher, and serializing `fuseOptions` to compare them by
+	*   value would break function-valued options (`sortFn`, `getFn`, `keys[].getFn`),
+	*   so the `Fuse` instance is memoized on the identity of the `data`
+	*   array and of `fuseOptions` instead: pass a NEW array reference when the data
+	*   changes, and a memoized `fuseOptions` object for best performance. Mutating
+	*   the data array in place is not detected (upstream's deep watch was);
+	* - `results` is memoized on the search string and the `data` identity, so a
+	*   changed `search`/`data` prop recomputes on the next render;
+	* - `options` is NOT widened: it is a config object (upstream
+	*   `MaybeRefOrGetter`, a maintainer decision), so a plain options object, a
+	*   ref-like `{ current }` object or a getter are the accepted forms.
+	*
+	* @param search - the search query
+	* @param data - the collection to search
+	* @param options - `fuseOptions` (forwarded to `new Fuse()`), `resultLimit`,
+	*   `matchAllWhenSearchEmpty`
+	*
+	* @__NO_SIDE_EFFECTS__
+	* @example
+	* const { fuse, results } = useFuse(input, data, {
+	*   fuseOptions: { keys: ['firstName', 'lastName'] },
+	*   resultLimit: 10,
+	*   matchAllWhenSearchEmpty: true,
+	* })
+	* results[0].item // the best match
+	* fuse.search('john') // search the same index directly
+	*/
+	function useFuse(search, data, options) {
+		const dataValue = data;
+		const optionsValue = (0, _reause_shared.toValue)(options);
+		const fuse = (0, react.useMemo)(() => new fuse_js.default(dataValue, optionsValue === null || optionsValue === void 0 ? void 0 : optionsValue.fuseOptions), [dataValue, optionsValue === null || optionsValue === void 0 ? void 0 : optionsValue.fuseOptions]);
+		const searchValue = search;
+		return {
+			fuse,
+			results: (0, react.useMemo)(() => {
+				if ((optionsValue === null || optionsValue === void 0 ? void 0 : optionsValue.matchAllWhenSearchEmpty) && !searchValue) return dataValue.map((item, index) => ({
+					item,
+					refIndex: index
+				}));
+				const limit = optionsValue === null || optionsValue === void 0 ? void 0 : optionsValue.resultLimit;
+				return fuse.search(searchValue, limit ? { limit } : void 0);
+			}, [
+				dataValue,
+				fuse,
+				optionsValue,
+				searchValue
+			])
+		};
+	}
+	//#endregion
+	exports.useFuse = useFuse;
+})(this.reause = this.reause || {}, reause, Fuse, React);

package/dist/useFuse.iife.min.js

@@ -0,0 +1 @@
+(function(e,t,n,r){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});var i=Object.create,a=Object.defineProperty,o=Object.getOwnPropertyDescriptor,s=Object.getOwnPropertyNames,c=Object.getPrototypeOf,l=Object.prototype.hasOwnProperty,u=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var i=s(t),c=0,u=i.length,d;c<u;c++)d=i[c],!l.call(e,d)&&d!==n&&a(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=o(t,d))||r.enumerable});return e};n=((e,t,n)=>(n=e==null?{}:i(c(e)),u(t||!e||!e.__esModule||!l.call(e,`default`)?a(n,`default`,{value:e,enumerable:!0}):n,e)))(n,1);function d(e,i,a){let o=i,s=(0,t.toValue)(a),c=(0,r.useMemo)(()=>new n.default(o,s==null?void 0:s.fuseOptions),[o,s==null?void 0:s.fuseOptions]),l=e;return{fuse:c,results:(0,r.useMemo)(()=>{if(s!=null&&s.matchAllWhenSearchEmpty&&!l)return o.map((e,t)=>({item:e,refIndex:t}));let e=s==null?void 0:s.resultLimit;return c.search(l,e?{limit:e}:void 0)},[o,c,s,l])}}e.useFuse=d})(this.reause=this.reause||{},reause,Fuse,React);

package/dist/useFuse.js

@@ -0,0 +1,72 @@
+import { useMemo } from "react";
+import { toValue } from "@reause/shared";
+import Fuse from "fuse.js";
+//#region useFuse/index.tsx
+/**
+* React port of VueUse's `useFuse` — easily implement fuzzy search with
+* [Fuse.js](https://github.com/krisk/fuse).
+*
+* Map from @vueuse/integrations `useFuse`
+* (`source/vueuse/packages/integrations/useFuse/`), a reactive wrapper around
+* a `Fuse` instance. `search` and `data` are the hook's **read-only value
+* sources** and take plain values (`string` and `readonly DataItem[]`; upstream:
+* `MaybeRefOrGetter`). `options` stays `RefOrValue` (a config object, upstream
+* `MaybeRefOrGetter`).
+*
+* Adjustment for React:
+* - upstream returns `{ fuse: Ref<Fuse>, results: ComputedRef<FuseResult[]> }`;
+*   here both are plain values read during render — `fuse` is the `Fuse`
+*   instance itself (no `.value`), `results` is a plain array;
+* - upstream rebuilds the index in `watch(() => toValue(options)?.fuseOptions,
+*   …, { deep: true })` and refreshes the collection in `watch(() => toValue(data), …)`.
+*   React has no deep watcher, and serializing `fuseOptions` to compare them by
+*   value would break function-valued options (`sortFn`, `getFn`, `keys[].getFn`),
+*   so the `Fuse` instance is memoized on the identity of the `data`
+*   array and of `fuseOptions` instead: pass a NEW array reference when the data
+*   changes, and a memoized `fuseOptions` object for best performance. Mutating
+*   the data array in place is not detected (upstream's deep watch was);
+* - `results` is memoized on the search string and the `data` identity, so a
+*   changed `search`/`data` prop recomputes on the next render;
+* - `options` is NOT widened: it is a config object (upstream
+*   `MaybeRefOrGetter`, a maintainer decision), so a plain options object, a
+*   ref-like `{ current }` object or a getter are the accepted forms.
+*
+* @param search - the search query
+* @param data - the collection to search
+* @param options - `fuseOptions` (forwarded to `new Fuse()`), `resultLimit`,
+*   `matchAllWhenSearchEmpty`
+*
+* @__NO_SIDE_EFFECTS__
+* @example
+* const { fuse, results } = useFuse(input, data, {
+*   fuseOptions: { keys: ['firstName', 'lastName'] },
+*   resultLimit: 10,
+*   matchAllWhenSearchEmpty: true,
+* })
+* results[0].item // the best match
+* fuse.search('john') // search the same index directly
+*/
+function useFuse(search, data, options) {
+	const dataValue = data;
+	const optionsValue = toValue(options);
+	const fuse = useMemo(() => new Fuse(dataValue, optionsValue === null || optionsValue === void 0 ? void 0 : optionsValue.fuseOptions), [dataValue, optionsValue === null || optionsValue === void 0 ? void 0 : optionsValue.fuseOptions]);
+	const searchValue = search;
+	return {
+		fuse,
+		results: useMemo(() => {
+			if ((optionsValue === null || optionsValue === void 0 ? void 0 : optionsValue.matchAllWhenSearchEmpty) && !searchValue) return dataValue.map((item, index) => ({
+				item,
+				refIndex: index
+			}));
+			const limit = optionsValue === null || optionsValue === void 0 ? void 0 : optionsValue.resultLimit;
+			return fuse.search(searchValue, limit ? { limit } : void 0);
+		}, [
+			dataValue,
+			fuse,
+			optionsValue,
+			searchValue
+		])
+	};
+}
+//#endregion
+export { useFuse };