@maanlamp/react-web-ui 0.0.0-stage → 0.1.1

package/dist/lib/unsaved-changes/leave-guard.d.ts

@@ -0,0 +1,81 @@
+import { type ReactNode } from "react";
+import { type ConfirmDialogProps } from "../../components/confirm-dialog/confirm-dialog.tsx";
+/** A guard against leaving: whether it blocks, the leave it holds, and the answers to it. */
+export type LeaveGuard = Readonly<{
+    /** Whether leaving is blocked now: `when`, except while a leave that was agreed to goes through. */
+    blocking: boolean;
+    /** Whether a held leave is waiting for an answer. */
+    asking: boolean;
+    /** Hands the guard a leave that was blocked, with what lets it through. */
+    hold: (proceed: () => void) => void;
+    /** Agrees to the held leave, which goes through once the question has gone. */
+    agree: () => void;
+    /** Lets the held leave through if it was agreed to, and otherwise stays. */
+    settle: () => void;
+}>;
+/** A held leave's two answers. */
+export type HeldLeave = Readonly<{
+    proceed: () => void;
+    stay: () => void;
+}>;
+/** A guard's state before it knows which leave it answers for. */
+export type LeaveGuardCore = Readonly<{
+    blocking: boolean;
+    /** The leave handed to `hold`, if any. */
+    held: HeldLeave | undefined;
+    hold: (proceed: () => void) => void;
+    agree: () => void;
+    /** Answers `leave` as agreed, and forgets the held one. */
+    settle: (leave: HeldLeave | undefined) => void;
+}>;
+/**
+ * The state every leave guard shares. `when` defaults to whether anything
+ * reports unsaved changes.
+ *
+ * @example
+ * const guard = leaveGuardOf(useLeaveGuardCore(isDirty));
+ */
+export declare const useLeaveGuardCore: (when: boolean | undefined) => LeaveGuardCore;
+/**
+ * The guard over `core`, answering for `routed` — a leave a router holds — or
+ * else the one handed to `hold`.
+ *
+ * @example
+ * const guard = leaveGuardOf(core, blocker.status === "blocked" ? { proceed: blocker.proceed, stay: blocker.reset } : undefined);
+ */
+export declare const leaveGuardOf: (core: LeaveGuardCore, routed?: HeldLeave) => LeaveGuard;
+/**
+ * Guards against leaving while `when`, such as a form with unsaved changes,
+ * without knowing the router: the browser asks before a reload or a close, and
+ * whatever blocks an in-app leave hands it to `hold`. `when` defaults to
+ * whether anything reports unsaved changes, which every `Form.Root` does.
+ * `@maanlamp/react-web-ui/unsaved-changes/tanstack-router` wires it to
+ * TanStack Router.
+ *
+ * @example
+ * const guard = useLeaveGuard();
+ * const close = () => (guard.blocking ? guard.hold(() => setOpen(false)) : setOpen(false));
+ * <LeaveGuardDialog guard={guard} title="Discard your changes?" confirmLabel="Discard" cancelLabel="Keep editing" />
+ */
+export declare const useLeaveGuard: (when?: boolean) => LeaveGuard;
+/**
+ * What a `LeaveGuardDialog` takes: the guard it answers for and the question's
+ * copy. `destructive` defaults to true, since leaving loses the changes.
+ */
+export type LeaveGuardDialogProps = Pick<ConfirmDialogProps, "title" | "description" | "confirmLabel" | "cancelLabel" | "destructive"> & Readonly<{
+    guard: LeaveGuard;
+}>;
+/**
+ * The question a guarded page asks when it is left: a `ConfirmDialog` that
+ * lets the held leave through or stays.
+ *
+ * @example
+ * <LeaveGuardDialog
+ * 	guard={guard}
+ * 	title="Discard your changes?"
+ * 	confirmLabel="Discard"
+ * 	cancelLabel="Keep editing"
+ * />
+ */
+export declare const LeaveGuardDialog: ({ guard, destructive, ...copy }: LeaveGuardDialogProps) => ReactNode;
+//# sourceMappingURL=leave-guard.d.ts.map

package/dist/lib/unsaved-changes/leave-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leave-guard.d.ts","sourceRoot":"","sources":["../../../src/lib/unsaved-changes/leave-guard.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAoB,MAAM,OAAO,CAAC;AACzD,OAAO,EAEN,KAAK,kBAAkB,EACvB,MAAM,oDAAoD,CAAC;AAI5D,6FAA6F;AAC7F,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC;IACjC,oGAAoG;IACpG,QAAQ,EAAE,OAAO,CAAC;IAClB,qDAAqD;IACrD,MAAM,EAAE,OAAO,CAAC;IAChB,2EAA2E;IAC3E,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACpC,+EAA+E;IAC/E,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,4EAA4E;IAC5E,MAAM,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC,CAAC;AAEH,kCAAkC;AAClC,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC;IAChC,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,IAAI,EAAE,MAAM,IAAI,CAAC;CACjB,CAAC,CAAC;AAEH,kEAAkE;AAClE,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACrC,QAAQ,EAAE,OAAO,CAAC;IAClB,0CAA0C;IAC1C,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC;IAC5B,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACpC,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,2DAA2D;IAC3D,MAAM,EAAE,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,KAAK,IAAI,CAAC;CAC/C,CAAC,CAAC;AAIH;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,SACvB,OAAO,GAAG,SAAS,KACvB,cAsCF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,SAClB,cAAc,WACX,SAAS,KAChB,UAUF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,UAClB,OAAO,KACZ,UAIF,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,IAAI,CACvC,kBAAkB,EAChB,OAAO,GACP,aAAa,GACb,cAAc,GACd,aAAa,GACb,aAAa,CACf,GACA,QAAQ,CAAC;IAAE,KAAK,EAAE,UAAU,CAAA;CAAE,CAAC,CAAC;AAEjC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,oCAI1B,qBAAqB,KAAG,SAY1B,CAAC"}

package/dist/lib/unsaved-changes/leave-guard.js

@@ -0,0 +1,170 @@
+import { ConfirmDialog } from "../../components/confirm-dialog/confirm-dialog.js";
+import { useBeforeUnload } from "./before-unload.js";
+import { useUnsavedChanges } from "./registry.js";
+import { c } from "react/compiler-runtime";
+import { useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+// src/lib/unsaved-changes/leave-guard.tsx
+var STAY = () => void 0;
+/**
+* The state every leave guard shares. `when` defaults to whether anything
+* reports unsaved changes.
+*
+* @example
+* const guard = leaveGuardOf(useLeaveGuardCore(isDirty));
+*/
+var useLeaveGuardCore = (when) => {
+	const $ = c(6);
+	const unsaved = useUnsavedChanges();
+	const guarding = when ?? unsaved;
+	const [held, setHeld] = useState(void 0);
+	const [leaving, setLeaving] = useState(false);
+	const agreed = useRef(false);
+	if (leaving && !guarding) setLeaving(false);
+	const t0 = guarding && !leaving;
+	let t1;
+	let t2;
+	let t3;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t1 = (proceed) => {
+			agreed.current = false;
+			setHeld({
+				proceed,
+				stay: STAY
+			});
+		};
+		t2 = () => {
+			agreed.current = true;
+		};
+		t3 = (leave) => {
+			const proceeding = agreed.current;
+			agreed.current = false;
+			setHeld(void 0);
+			if (leave === void 0) return;
+			if (proceeding) {
+				setLeaving(true);
+				leave.proceed();
+			} else leave.stay();
+		};
+		$[0] = t1;
+		$[1] = t2;
+		$[2] = t3;
+	} else {
+		t1 = $[0];
+		t2 = $[1];
+		t3 = $[2];
+	}
+	let t4;
+	if ($[3] !== held || $[4] !== t0) {
+		t4 = {
+			blocking: t0,
+			held,
+			hold: t1,
+			agree: t2,
+			settle: t3
+		};
+		$[3] = held;
+		$[4] = t0;
+		$[5] = t4;
+	} else t4 = $[5];
+	return t4;
+};
+/**
+* The guard over `core`, answering for `routed` — a leave a router holds — or
+* else the one handed to `hold`.
+*
+* @example
+* const guard = leaveGuardOf(core, blocker.status === "blocked" ? { proceed: blocker.proceed, stay: blocker.reset } : undefined);
+*/
+var leaveGuardOf = (core, routed) => {
+	const leave = routed ?? core.held;
+	return {
+		blocking: core.blocking,
+		asking: leave !== void 0,
+		hold: core.hold,
+		agree: core.agree,
+		settle: () => core.settle(leave)
+	};
+};
+/**
+* Guards against leaving while `when`, such as a form with unsaved changes,
+* without knowing the router: the browser asks before a reload or a close, and
+* whatever blocks an in-app leave hands it to `hold`. `when` defaults to
+* whether anything reports unsaved changes, which every `Form.Root` does.
+* `@maanlamp/react-web-ui/unsaved-changes/tanstack-router` wires it to
+* TanStack Router.
+*
+* @example
+* const guard = useLeaveGuard();
+* const close = () => (guard.blocking ? guard.hold(() => setOpen(false)) : setOpen(false));
+* <LeaveGuardDialog guard={guard} title="Discard your changes?" confirmLabel="Discard" cancelLabel="Keep editing" />
+*/
+var useLeaveGuard = (when) => {
+	const $ = c(2);
+	const t0 = useLeaveGuardCore(when);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = leaveGuardOf(t0);
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const guard = t1;
+	useBeforeUnload(guard.blocking);
+	return guard;
+};
+/**
+* The question a guarded page asks when it is left: a `ConfirmDialog` that
+* lets the held leave through or stays.
+*
+* @example
+* <LeaveGuardDialog
+* 	guard={guard}
+* 	title="Discard your changes?"
+* 	confirmLabel="Discard"
+* 	cancelLabel="Keep editing"
+* />
+*/
+var LeaveGuardDialog = (t0) => {
+	const $ = c(12);
+	let copy;
+	let guard;
+	let t1;
+	if ($[0] !== t0) {
+		({guard, destructive: t1, ...copy} = t0);
+		$[0] = t0;
+		$[1] = copy;
+		$[2] = guard;
+		$[3] = t1;
+	} else {
+		copy = $[1];
+		guard = $[2];
+		t1 = $[3];
+	}
+	const destructive = t1 === void 0 ? true : t1;
+	let t2;
+	if ($[4] !== guard) {
+		t2 = (open) => {
+			if (!open) guard.settle();
+		};
+		$[4] = guard;
+		$[5] = t2;
+	} else t2 = $[5];
+	let t3;
+	if ($[6] !== copy || $[7] !== destructive || $[8] !== guard.agree || $[9] !== guard.asking || $[10] !== t2) {
+		t3 = /* @__PURE__ */ jsx(ConfirmDialog, {
+			...copy,
+			open: guard.asking,
+			onOpenChange: t2,
+			onConfirm: guard.agree,
+			destructive
+		});
+		$[6] = copy;
+		$[7] = destructive;
+		$[8] = guard.agree;
+		$[9] = guard.asking;
+		$[10] = t2;
+		$[11] = t3;
+	} else t3 = $[11];
+	return t3;
+};
+export { LeaveGuardDialog, leaveGuardOf, useLeaveGuard, useLeaveGuardCore };

package/dist/lib/unsaved-changes/policy.d.ts

@@ -0,0 +1,25 @@
+import type { AnyFormState } from "@tanstack/react-form";
+/**
+ * Decides from a form's live state whether leaving would lose unsaved
+ * changes. `Form.Root` reports into the leave guards while it returns true.
+ *
+ * @example
+ * const policy: LeaveGuardPolicy = state => state.isDirty && !state.isSubmitted;
+ */
+export type LeaveGuardPolicy = (state: AnyFormState) => boolean;
+/**
+ * Guards while the form's values were edited away from their defaults and are
+ * not being submitted. The default for `Form.Root`.
+ *
+ * @example
+ * <Form.Root form={form} leaveGuard={whenDirty}>…</Form.Root>
+ */
+export declare const whenDirty: LeaveGuardPolicy;
+/**
+ * Never guards, for a form whose edits need not survive leaving.
+ *
+ * @example
+ * <Form.Root form={form} leaveGuard={never}>…</Form.Root>
+ */
+export declare const never: LeaveGuardPolicy;
+//# sourceMappingURL=policy.d.ts.map

package/dist/lib/unsaved-changes/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../../src/lib/unsaved-changes/policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAC9B,KAAK,EAAE,YAAY,KACf,OAAO,CAAC;AAEb;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,EAAE,gBAGJ,CAAC;AAErB;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,gBAA8B,CAAC"}

package/dist/lib/unsaved-changes/policy.js

@@ -0,0 +1,17 @@
+// src/lib/unsaved-changes/policy.ts
+/**
+* Guards while the form's values were edited away from their defaults and are
+* not being submitted. The default for `Form.Root`.
+*
+* @example
+* <Form.Root form={form} leaveGuard={whenDirty}>…</Form.Root>
+*/
+var whenDirty = (state) => state.isDirty && !state.isDefaultValue && !state.isSubmitting;
+/**
+* Never guards, for a form whose edits need not survive leaving.
+*
+* @example
+* <Form.Root form={form} leaveGuard={never}>…</Form.Root>
+*/
+var never = () => false;
+export { never, whenDirty };

package/dist/lib/unsaved-changes/registry.d.ts

@@ -0,0 +1,37 @@
+/** A record of what has unsaved changes right now, which a leave guard reads. */
+export type UnsavedChangesRegistry = Readonly<{
+    /** Records one source of unsaved changes, until the returned function is called. */
+    register: () => () => void;
+    /** Whether any source has unsaved changes. */
+    hasUnsavedChanges: () => boolean;
+    /** Calls `listener` whenever that answer may have changed, until the returned function is called. */
+    subscribe: (listener: () => void) => () => void;
+}>;
+/**
+ * Creates an empty registry of unsaved changes.
+ *
+ * @example
+ * const registry = createUnsavedChangesRegistry();
+ * const unregister = registry.register();
+ * registry.hasUnsavedChanges(); // true
+ * unregister();
+ * registry.hasUnsavedChanges(); // false
+ */
+export declare const createUnsavedChangesRegistry: () => UnsavedChangesRegistry;
+/**
+ * Reports unsaved changes to the page's leave guards while `dirty`, and stops
+ * once it is not or the caller unmounts. `Form.Root` reports its form.
+ *
+ * @example
+ * useReportUnsavedChanges(editor.isDirty);
+ */
+export declare const useReportUnsavedChanges: (dirty: boolean) => void;
+/**
+ * Whether anything on the page reports unsaved changes, such as a `Form.Root`
+ * whose form was edited and not submitted.
+ *
+ * @example
+ * const unsaved = useUnsavedChanges();
+ */
+export declare const useUnsavedChanges: () => boolean;
+//# sourceMappingURL=registry.d.ts.map

package/dist/lib/unsaved-changes/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/lib/unsaved-changes/registry.ts"],"names":[],"mappings":"AAEA,iFAAiF;AACjF,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC7C,oFAAoF;IACpF,QAAQ,EAAE,MAAM,MAAM,IAAI,CAAC;IAC3B,8CAA8C;IAC9C,iBAAiB,EAAE,MAAM,OAAO,CAAC;IACjC,qGAAqG;IACrG,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;CAChD,CAAC,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,QACpC,sBAsCH,CAAC;AAIH;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,UAC5B,OAAO,KACZ,IAKF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,QAAO,OAKnC,CAAC"}

package/dist/lib/unsaved-changes/registry.js

@@ -0,0 +1,78 @@
+import { c } from "react/compiler-runtime";
+import { useEffect, useSyncExternalStore } from "react";
+// src/lib/unsaved-changes/registry.ts
+/**
+* Creates an empty registry of unsaved changes.
+*
+* @example
+* const registry = createUnsavedChangesRegistry();
+* const unregister = registry.register();
+* registry.hasUnsavedChanges(); // true
+* unregister();
+* registry.hasUnsavedChanges(); // false
+*/
+var createUnsavedChangesRegistry = () => {
+	let sources = /* @__PURE__ */ new Set();
+	let listeners = /* @__PURE__ */ new Set();
+	const notify = () => {
+		for (const listener of listeners) listener();
+	};
+	return {
+		register: () => {
+			const source = Symbol("unsaved changes");
+			sources = /* @__PURE__ */ new Set([...sources, source]);
+			notify();
+			return () => {
+				if (sources.has(source)) {
+					sources = new Set([...sources].filter((other) => other !== source));
+					notify();
+				}
+			};
+		},
+		hasUnsavedChanges: () => sources.size > 0,
+		subscribe: (listener) => {
+			listeners = /* @__PURE__ */ new Set([...listeners, listener]);
+			return () => {
+				listeners = new Set([...listeners].filter((other) => other !== listener));
+			};
+		}
+	};
+};
+var registry = createUnsavedChangesRegistry();
+/**
+* Reports unsaved changes to the page's leave guards while `dirty`, and stops
+* once it is not or the caller unmounts. `Form.Root` reports its form.
+*
+* @example
+* useReportUnsavedChanges(editor.isDirty);
+*/
+var useReportUnsavedChanges = (dirty) => {
+	const $ = c(3);
+	let t0;
+	let t1;
+	if ($[0] !== dirty) {
+		t0 = () => dirty ? registry.register() : void 0;
+		t1 = [dirty];
+		$[0] = dirty;
+		$[1] = t0;
+		$[2] = t1;
+	} else {
+		t0 = $[1];
+		t1 = $[2];
+	}
+	useEffect(t0, t1);
+};
+/**
+* Whether anything on the page reports unsaved changes, such as a `Form.Root`
+* whose form was edited and not submitted.
+*
+* @example
+* const unsaved = useUnsavedChanges();
+*/
+var useUnsavedChanges = () => {
+	return useSyncExternalStore(registry.subscribe, registry.hasUnsavedChanges, _temp);
+};
+function _temp() {
+	return false;
+}
+export { createUnsavedChangesRegistry, useReportUnsavedChanges, useUnsavedChanges };

package/dist/lib/unsaved-changes/tanstack-router.d.ts

@@ -0,0 +1,13 @@
+import { type LeaveGuard } from "./leave-guard.tsx";
+/**
+ * `useLeaveGuard` wired to TanStack Router: while `when`, every navigation
+ * away is held for the guard's `LeaveGuardDialog`, and the browser asks before
+ * a reload or a close. `when` defaults to whether anything reports unsaved
+ * changes, which every `Form.Root` does.
+ *
+ * @example
+ * const guard = useRouterLeaveGuard();
+ * <LeaveGuardDialog guard={guard} title="Discard your changes?" confirmLabel="Discard" cancelLabel="Keep editing" />
+ */
+export declare const useRouterLeaveGuard: (when?: boolean) => LeaveGuard;
+//# sourceMappingURL=tanstack-router.d.ts.map

package/dist/lib/unsaved-changes/tanstack-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tanstack-router.d.ts","sourceRoot":"","sources":["../../../src/lib/unsaved-changes/tanstack-router.ts"],"names":[],"mappings":"AACA,OAAO,EACN,KAAK,UAAU,EAGf,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,UACxB,OAAO,KACZ,UAcF,CAAC"}

package/dist/lib/unsaved-changes/tanstack-router.js

@@ -0,0 +1,50 @@
+import { leaveGuardOf, useLeaveGuardCore } from "./leave-guard.js";
+import { c } from "react/compiler-runtime";
+import { useBlocker } from "@tanstack/react-router";
+// src/lib/unsaved-changes/tanstack-router.ts
+/**
+* `useLeaveGuard` wired to TanStack Router: while `when`, every navigation
+* away is held for the guard's `LeaveGuardDialog`, and the browser asks before
+* a reload or a close. `when` defaults to whether anything reports unsaved
+* changes, which every `Form.Root` does.
+*
+* @example
+* const guard = useRouterLeaveGuard();
+* <LeaveGuardDialog guard={guard} title="Discard your changes?" confirmLabel="Discard" cancelLabel="Keep editing" />
+*/
+var useRouterLeaveGuard = (when) => {
+	const $ = c(10);
+	const core = useLeaveGuardCore(when);
+	let t0;
+	if ($[0] !== core.blocking) {
+		t0 = () => core.blocking;
+		$[0] = core.blocking;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== core.blocking || $[3] !== t0) {
+		t1 = {
+			shouldBlockFn: t0,
+			withResolver: true,
+			enableBeforeUnload: core.blocking
+		};
+		$[2] = core.blocking;
+		$[3] = t0;
+		$[4] = t1;
+	} else t1 = $[4];
+	const blocker = useBlocker(t1);
+	let t2;
+	if ($[5] !== blocker.proceed || $[6] !== blocker.reset || $[7] !== blocker.status || $[8] !== core) {
+		t2 = leaveGuardOf(core, blocker.status === "blocked" ? {
+			proceed: blocker.proceed,
+			stay: blocker.reset
+		} : void 0);
+		$[5] = blocker.proceed;
+		$[6] = blocker.reset;
+		$[7] = blocker.status;
+		$[8] = core;
+		$[9] = t2;
+	} else t2 = $[9];
+	return t2;
+};
+export { useRouterLeaveGuard };

package/dist/lib/use-infinite-scroll.d.ts

@@ -0,0 +1,32 @@
+import { type RefObject } from "react";
+/** What {@link useInfiniteScroll} watches and calls. */
+export type UseInfiniteScrollOptions = Readonly<{
+    /** The scroll container. Attach the same ref to the scrolling element. */
+    ref: RefObject<HTMLElement | null>;
+    /**
+     * Whether another page can and should load now, typically
+     * `hasNextPage && !isFetchingNextPage`. The edge is checked again whenever
+     * this turns `true`, so a short page still loads the next one.
+     */
+    enabled: boolean;
+    /** Loads the next page. */
+    onLoadMore: () => void;
+    /** Distance from the load edge, in pixels, at which loading begins. @default 512 */
+    threshold?: number;
+    /** The load edge is the top, for a `flex-direction: column-reverse` container. */
+    reversed?: boolean;
+}>;
+/**
+ * Calls `onLoadMore` whenever the scroll container comes within `threshold`
+ * pixels of its load edge: on scroll, and whenever `enabled` turns `true`.
+ *
+ * @example
+ * const listRef = useRef<HTMLDivElement>(null);
+ * useInfiniteScroll({
+ * 	ref: listRef,
+ * 	enabled: query.hasNextPage && !query.isFetchingNextPage,
+ * 	onLoadMore: () => void query.fetchNextPage(),
+ * });
+ */
+export declare const useInfiniteScroll: ({ ref, enabled, onLoadMore, threshold, reversed, }: UseInfiniteScrollOptions) => void;
+//# sourceMappingURL=use-infinite-scroll.d.ts.map

package/dist/lib/use-infinite-scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-infinite-scroll.d.ts","sourceRoot":"","sources":["../../src/lib/use-infinite-scroll.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,OAAO,CAAC;AAE1D,wDAAwD;AACxD,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC/C,0EAA0E;IAC1E,GAAG,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IACnC;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,2BAA2B;IAC3B,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,oFAAoF;IACpF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kFAAkF;IAClF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,uDAM3B,wBAAwB,KAAG,IAkC7B,CAAC"}

package/dist/lib/use-infinite-scroll.js

@@ -0,0 +1,78 @@
+import { c } from "react/compiler-runtime";
+import { useEffect, useRef } from "react";
+// src/lib/use-infinite-scroll.ts
+/**
+* Calls `onLoadMore` whenever the scroll container comes within `threshold`
+* pixels of its load edge: on scroll, and whenever `enabled` turns `true`.
+*
+* @example
+* const listRef = useRef<HTMLDivElement>(null);
+* useInfiniteScroll({
+* 	ref: listRef,
+* 	enabled: query.hasNextPage && !query.isFetchingNextPage,
+* 	onLoadMore: () => void query.fetchNextPage(),
+* });
+*/
+var useInfiniteScroll = (t0) => {
+	const $ = c(12);
+	const { ref, enabled, onLoadMore, threshold: t1, reversed: t2 } = t0;
+	const threshold = t1 === void 0 ? 512 : t1;
+	const reversed = t2 === void 0 ? false : t2;
+	let t3;
+	if ($[0] !== enabled || $[1] !== onLoadMore) {
+		t3 = {
+			enabled,
+			onLoadMore
+		};
+		$[0] = enabled;
+		$[1] = onLoadMore;
+		$[2] = t3;
+	} else t3 = $[2];
+	const latest = useRef(t3);
+	let t4;
+	if ($[3] !== enabled || $[4] !== onLoadMore) {
+		t4 = () => {
+			latest.current = {
+				enabled,
+				onLoadMore
+			};
+		};
+		$[3] = enabled;
+		$[4] = onLoadMore;
+		$[5] = t4;
+	} else t4 = $[5];
+	useEffect(t4);
+	let t5;
+	let t6;
+	if ($[6] !== enabled || $[7] !== ref || $[8] !== reversed || $[9] !== threshold) {
+		t5 = () => {
+			const element = ref.current;
+			if (element === null) return;
+			const maybeLoadMore = () => {
+				if (!latest.current.enabled) return;
+				const maxScroll = element.scrollHeight - element.clientHeight;
+				if ((reversed ? maxScroll - Math.abs(element.scrollTop) : maxScroll - element.scrollTop) <= threshold) latest.current.onLoadMore();
+			};
+			if (enabled) maybeLoadMore();
+			element.addEventListener("scroll", maybeLoadMore, { passive: true });
+			return () => element.removeEventListener("scroll", maybeLoadMore);
+		};
+		t6 = [
+			ref,
+			enabled,
+			threshold,
+			reversed
+		];
+		$[6] = enabled;
+		$[7] = ref;
+		$[8] = reversed;
+		$[9] = threshold;
+		$[10] = t5;
+		$[11] = t6;
+	} else {
+		t5 = $[10];
+		t6 = $[11];
+	}
+	useEffect(t5, t6);
+};
+export { useInfiniteScroll };

package/dist/lib/use-intent.d.ts

@@ -0,0 +1,18 @@
+import { type FocusEvent, type PointerEvent } from "react";
+/** The trigger handlers {@link useIntent} returns. */
+export type IntentHandlers = Readonly<{
+    onPointerEnter?: (event: PointerEvent) => void;
+    onPointerLeave?: (event: PointerEvent) => void;
+    onFocus?: (event: FocusEvent) => void;
+}>;
+/**
+ * Trigger handlers that call `onIntent` once a pointer rests on the trigger or
+ * it takes focus, so the caller can warm whatever the popup will show. Returns
+ * no handlers when `onIntent` is omitted.
+ *
+ * @example
+ * const intent = useIntent(() => prefetchRates(id));
+ * return <button {...intent}>…</button>;
+ */
+export declare const useIntent: (onIntent: (() => void) | undefined) => IntentHandlers;
+//# sourceMappingURL=use-intent.d.ts.map

package/dist/lib/use-intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-intent.d.ts","sourceRoot":"","sources":["../../src/lib/use-intent.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,UAAU,EACf,KAAK,YAAY,EAGjB,MAAM,OAAO,CAAC;AAIf,sDAAsD;AACtD,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACrC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IAC/C,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IAC/C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;CACtC,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,aACX,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,KAChC,cA6BF,CAAC"}