@deftui/react 0.3.0 → 0.3.1

package/dist/index.d.mts

@@ -1,5 +1,7 @@
 import { useCopyToClipboard } from "./vendor/coss/hooks/use-copy-to-clipboard.mjs";
 import { useIsMobile, useMediaQuery } from "./vendor/coss/hooks/use-media-query.mjs";
+import { CascaderChangeDetails, CascaderLabels, CascaderMode, CascaderNode } from "./vendor/reui.io/cascader/cascader-types.mjs";
+import { CascaderProps, CascaderSingleProps } from "./vendor/reui.io/cascader/cascader.mjs";
 import { Separator } from "./vendor/shadcn/separator.mjs";
 import { Label } from "./vendor/shadcn/label.mjs";
 import { Button } from "./vendor/shadcn/button.mjs";
@@ -23,10 +25,9 @@ import { Form } from "./vendor/coss/form.mjs";
 import { ScrollArea } from "./vendor/coss/scroll-area.mjs";
 import { IconSwap } from "./vendor/tailored/icon-swap.mjs";
 import { JsonViewer } from "./vendor/tailored/json-viewer.mjs";
-import { FileTree, FileTreeNode } from "./vendor/tailored/file-tree.mjs";
-import { AlertDialog, Breadcrumb, ButtonGroup, Card, Combobox, Dialog, Drawer, Dropdown, Empty, Field, Frame, InputGroup, Kbd, Popover, Progress, Radio, Select, Table, Tabs, Tooltip } from "./widgets/index.mjs";
+import { AlertDialog, Breadcrumb, ButtonGroup, Card, Cascader, Combobox, Dialog, Drawer, Dropdown, Empty, Field, Frame, InputGroup, Kbd, Popover, Progress, Radio, Select, Table, Tabs, Timeline, Tooltip } from "./widgets/index.mjs";
 import { cn } from "cn";
 import { cva } from "class-variance-authority";
 import { mergeProps } from "@base-ui/react/merge-props";
 export * from "react-dropzone";
-export { AlertDialog, Badge, Breadcrumb, Button, ButtonGroup, Calendar, Card, Carousel, Checkbox, Combobox, DatePicker, type DateRange, DateRangePicker, Dialog, Drawer, Dropdown, Dropzone, Empty, Field, FileTree, type FileTreeNode, Form, Frame, IconSwap, Image, ImageProps, Input, InputGroup, JsonViewer, Kbd, Label, Lightbox, type LightboxActions, type LightboxBackdrop, type LightboxCaptions, type LightboxChangeReason, type LightboxClose, type LightboxContent, type LightboxControl, type LightboxControlContext, type LightboxCounter, type LightboxDownload, type LightboxImageChangeEventDetails, type LightboxImageItem, type LightboxItem, type LightboxMore, type LightboxNext, type LightboxOpenEventDetails, type LightboxPrevious, type LightboxProps, type LightboxSlide, type LightboxSlides, type LightboxThumbnail, type LightboxThumbnails, type LightboxToolbar, type LightboxTrigger, type LightboxTriggerProps, type LightboxVideoItem, type LightboxViewport, type LightboxZoom, type LightboxZoomButton, Pagination, Popover, Progress, Radio, ScrollArea, Select, Separator, Sidebar, Skeleton, Spinner, Switch, Table, Tabs, Textarea, TimePicker, Toaster as ToastProvider, Tooltip, cn, cva, formatBytes, mergeProps, toast, useCopyToClipboard, useDropzone, useIsMobile, type useLightbox, useMediaQuery, useSidebar };
+export { AlertDialog, Badge, Breadcrumb, Button, ButtonGroup, Calendar, Card, Carousel, Cascader, type CascaderChangeDetails, type CascaderLabels, type CascaderMode, type CascaderNode, type CascaderProps, type CascaderSingleProps, Checkbox, Combobox, DatePicker, type DateRange, DateRangePicker, Dialog, Drawer, Dropdown, Dropzone, Empty, Field, Form, Frame, IconSwap, Image, ImageProps, Input, InputGroup, JsonViewer, Kbd, Label, Lightbox, type LightboxActions, type LightboxBackdrop, type LightboxCaptions, type LightboxChangeReason, type LightboxClose, type LightboxContent, type LightboxControl, type LightboxControlContext, type LightboxCounter, type LightboxDownload, type LightboxImageChangeEventDetails, type LightboxImageItem, type LightboxItem, type LightboxMore, type LightboxNext, type LightboxOpenEventDetails, type LightboxPrevious, type LightboxProps, type LightboxSlide, type LightboxSlides, type LightboxThumbnail, type LightboxThumbnails, type LightboxToolbar, type LightboxTrigger, type LightboxTriggerProps, type LightboxVideoItem, type LightboxViewport, type LightboxZoom, type LightboxZoomButton, Pagination, Popover, Progress, Radio, ScrollArea, Select, Separator, Sidebar, Skeleton, Spinner, Switch, Table, Tabs, Textarea, TimePicker, Timeline, Toaster as ToastProvider, Tooltip, cn, cva, formatBytes, mergeProps, toast, useCopyToClipboard, useDropzone, useIsMobile, type useLightbox, useMediaQuery, useSidebar };

package/dist/index.mjs

@@ -22,9 +22,8 @@ import { Checkbox } from "./vendor/shadcn/checkbox.mjs";
 import { Form } from "./vendor/coss/form.mjs";
 import { IconSwap } from "./vendor/tailored/icon-swap.mjs";
 import { JsonViewer } from "./vendor/tailored/json-viewer.mjs";
-import { FileTree } from "./vendor/tailored/file-tree.mjs";
-import { AlertDialog, Breadcrumb, ButtonGroup, Card, Combobox, Dialog, Drawer, Dropdown, Empty, Field, Frame, InputGroup, Kbd, Popover, Progress, Radio, Select, Table, Tabs, Tooltip } from "./widgets/index.mjs";
+import { AlertDialog, Breadcrumb, ButtonGroup, Card, Cascader, Combobox, Dialog, Drawer, Dropdown, Empty, Field, Frame, InputGroup, Kbd, Popover, Progress, Radio, Select, Table, Tabs, Timeline, Tooltip } from "./widgets/index.mjs";
 import { cn } from "cn";
 import { cva } from "class-variance-authority";
 import { mergeProps } from "@base-ui/react/merge-props";
-export { AlertDialog, Badge, Breadcrumb, Button, ButtonGroup, Calendar, Card, Carousel, Checkbox, Combobox, DatePicker, DateRangePicker, Dialog, Drawer, Dropdown, Dropzone, Empty, Field, FileTree, Form, Frame, IconSwap, Image, Input, InputGroup, JsonViewer, Kbd, Label, Lightbox, Pagination, Popover, Progress, Radio, ScrollArea, Select, Separator, Sidebar, Skeleton, Spinner, Switch, Table, Tabs, Textarea, TimePicker, Toaster as ToastProvider, Tooltip, cn, cva, formatBytes, mergeProps, toast, useCopyToClipboard, useDropzone, useIsMobile, useMediaQuery, useSidebar };
+export { AlertDialog, Badge, Breadcrumb, Button, ButtonGroup, Calendar, Card, Carousel, Cascader, Checkbox, Combobox, DatePicker, DateRangePicker, Dialog, Drawer, Dropdown, Dropzone, Empty, Field, Form, Frame, IconSwap, Image, Input, InputGroup, JsonViewer, Kbd, Label, Lightbox, Pagination, Popover, Progress, Radio, ScrollArea, Select, Separator, Sidebar, Skeleton, Spinner, Switch, Table, Tabs, Textarea, TimePicker, Timeline, Toaster as ToastProvider, Tooltip, cn, cva, formatBytes, mergeProps, toast, useCopyToClipboard, useDropzone, useIsMobile, useMediaQuery, useSidebar };

package/dist/vendor/README.md

@@ -22,6 +22,8 @@ shadcn 组件使用 `components.json` 中的 `base-vega` 风格和 Lucide 图标
 | `@coss/table` | [coss/table.tsx](coss/table.tsx) | [Table](https://coss.com/ui/docs/components/table) | 默认变体的 `TableFooter` 移除底色，与 `card` 变体一样保持透明 |
 | `@coss/use-copy-to-clipboard` | [coss/hooks/use-copy-to-clipboard.ts](coss/hooks/use-copy-to-clipboard.ts) | [useCopyToClipboard](https://coss.com/ui/docs/hooks/use-copy-to-clipboard) | — |
 | `@coss/use-media-query` | [coss/hooks/use-media-query.ts](coss/hooks/use-media-query.ts) | [useMediaQuery](https://coss.com/ui/docs/hooks/use-media-query) | 断点：`md` 设为 768px，与 Tailwind 默认值一致 |
+| `@reui/cascader` | [reui.io/cascader/cascader.tsx](reui.io/cascader/cascader.tsx) | [Cascader](https://reui.io/docs/components/cascader) | 重映射 `scroll-area` 与 `spinner` 的导入 |
+| `@reui/timeline` | [reui.io/timeline.tsx](reui.io/timeline.tsx) | [Timeline](https://reui.io/docs/components/timeline) | — |
 | `badge` | [shadcn/badge.tsx](shadcn/badge.tsx) | [Badge](https://ui.shadcn.com/docs/components/base/badge) | 提供 `info`、`success`、`warning` 语义变体 |
 | `breadcrumb` | [shadcn/breadcrumb.tsx](shadcn/breadcrumb.tsx) | [Breadcrumb](https://ui.shadcn.com/docs/components/base/breadcrumb) | 未显式指定 `BreadcrumbList` 则自动包裹 |
 | `button` | [shadcn/button.tsx](shadcn/button.tsx) | [Button](https://ui.shadcn.com/docs/components/base/button) | `pill` 提供全圆角；`isPending` 提供加载态；提供额外 `destructive` 系列样式变体 |
@@ -64,5 +66,4 @@ shadcn 组件使用 `components.json` 中的 `base-vega` 风格和 Lucide 图标
 | `https://ui.iandefined.com/r/icon-swap.json` | [tailored/icon-swap.tsx](tailored/icon-swap.tsx) | [Icon Swap](https://ui.iandefined.com/docs/utilities/icon-swap/) | 进出场动画减弱模糊为 2px，缩短为 0.2s 时长 |
 | `https://ui.iandefined.com/r/lightbox.json` | [tailored/lightbox.tsx](tailored/lightbox.tsx) | [Lightbox](https://ui.iandefined.com/docs/components/lightbox/) | 适配本地组件和尺寸；修正嵌套弹层层级与点击隔离；补充加载失败反馈 |
 | `https://ui.iandefined.com/r/scroll-area.json` | [tailored/lightbox.tsx](tailored/lightbox.tsx) | [Scroll Area](https://ui.iandefined.com/docs/components/scroll-area/) | 作为 Lightbox 的私有依赖内联 |
-| `Tinkerers-Labs/mischief-ui/file-tree` | [tailored/file-tree.tsx](tailored/file-tree.tsx) | [File Tree](https://ui.tinkererslabs.com/docs/components/file-tree/) | — |
 | `Tinkerers-Labs/mischief-ui/json-viewer` | [tailored/json-viewer.tsx](tailored/json-viewer.tsx) | [JSON Viewer](https://ui.tinkererslabs.com/docs/components/json-viewer/) | — |

package/dist/vendor/reui.io/cascader/cascader-async.d.mts

@@ -0,0 +1,20 @@
+import { CascaderLoadContext, CascaderLoadResult, CascaderNode, CascaderSearchContext } from "./cascader-types.mjs";
+/**
+ * Async data for the cascader. Loaded pages live in their own store and are
+ * MERGED onto the index built from `items`, never folded into that build:
+ * `items` changes identity on any parent re-render, and folding would discard
+ * every level the user drilled into. Map membership is the load discriminator:
+ * no `states` entry means never fetched, while an entry with no `loading`, no
+ * `error` and no children means empty for real.
+ */
+/**
+ * Fetches one level. `node` is `null` for the root level, and only
+ * `{ value, label: value }`, no `data`, for a level on screen whose node has
+ * not loaded: a deep link before the level above loads, or a page-loaded
+ * level after a `loadKey` change.
+ */
+export type CascaderGetChildren<T = unknown> = (node: CascaderNode<T> | null, context: CascaderLoadContext) => CascaderNode<T>[] | CascaderLoadResult<T> | Promise<CascaderNode<T>[] | CascaderLoadResult<T>>;
+/** Server-side search, replacing the local index scan while the query is set. */
+export type CascaderOnSearch<T = unknown> = (query: string, context: CascaderSearchContext) => CascaderNode<T>[] | CascaderLoadResult<T> | Promise<CascaderNode<T>[] | CascaderLoadResult<T>>;
+/** Resolves a selected value to its ancestor chain, root first, node last. */
+export type CascaderResolveValue<T = unknown> = (value: string, context: CascaderLoadContext) => CascaderNode<T>[] | Promise<CascaderNode<T>[]>;

package/dist/vendor/reui.io/cascader/cascader-async.mjs

@@ -0,0 +1,578 @@
+"use client";
+import { useCascaderState } from "./cascader-context.mjs";
+import { CASCADER_ROOT_KEY, isCascaderMoreNode } from "./cascader-lib.mjs";
+import * as React$1 from "react";
+// src/vendor/reui.io/cascader/cascader-async.tsx
+/**
+* Highlight dwell before `prefetch` fetches: long enough that holding ArrowDown
+* does not fire a request per row, short enough to beat the ArrowRight press.
+*/
+const PREFETCH_DELAY = 150;
+/** Request keys for the two non-level requests. Never collide with a value. */
+const SEARCH_KEY = "\0search";
+const RESOLVE_PREFIX = "\0resolve:";
+const NO_STATE = {
+	loading: false,
+	error: false,
+	hasMore: false
+};
+/** Stable empty result, so an idle search never churns the state context. */
+const NO_RESULTS = [];
+function createStore() {
+	return {
+		pages: /* @__PURE__ */ new Map(),
+		states: /* @__PURE__ */ new Map(),
+		detached: /* @__PURE__ */ new Map(),
+		links: /* @__PURE__ */ new Map()
+	};
+}
+function sameLoadState(a, b) {
+	return a.loading === b.loading && a.error === b.error && a.hasMore === b.hasMore && a.cursor === b.cursor;
+}
+/**
+* Copy-on-write, and a NO-OP when nothing changed: the merged index is memoised
+* on store identity, so a fresh object for an unchanged state would rebuild it.
+*/
+function withLoadState(store, key, update) {
+	const current = store.states.get(key) ?? NO_STATE;
+	const next = update(current);
+	if (store.states.has(key) && sameLoadState(current, next)) return store;
+	const states = new Map(store.states);
+	states.set(key, next);
+	return {
+		...store,
+		states
+	};
+}
+function withPage(store, key, items, options) {
+	const previous = options.append ? store.pages.get(key) ?? [] : [];
+	const seen = new Set(previous.map((node) => node.value));
+	const merged = previous.slice();
+	for (const item of items) {
+		if (seen.has(item.value)) continue;
+		seen.add(item.value);
+		merged.push(item);
+	}
+	const pages = new Map(store.pages);
+	pages.set(key, merged);
+	const states = new Map(store.states);
+	states.set(key, {
+		loading: false,
+		error: false,
+		hasMore: options.hasMore,
+		cursor: options.cursor
+	});
+	return {
+		...store,
+		pages,
+		states
+	};
+}
+function withDetached(store, items) {
+	let detached = null;
+	for (const item of items) {
+		if (store.detached.get(item.value) === item) continue;
+		detached = detached ?? new Map(store.detached);
+		detached.set(item.value, item);
+	}
+	if (!detached) return store;
+	return {
+		...store,
+		detached
+	};
+}
+/**
+* Records a resolved ancestor chain, root first, as `detached` nodes plus
+* `links`, never as rows in `pages`: a stub there made an unloaded level read
+* as loaded. Writes no `states`, so every level on it still fetches for real.
+*/
+function withChain(store, chain) {
+	if (chain.length === 0) return store;
+	const detached = new Map(store.detached);
+	const links = new Map(store.links);
+	let parentKey = CASCADER_ROOT_KEY;
+	for (const node of chain) {
+		detached.set(node.value, node);
+		links.set(node.value, parentKey);
+		parentKey = node.value;
+	}
+	return {
+		...store,
+		detached,
+		links
+	};
+}
+/**
+* The loader. A SIBLING of the `buildCascaderIndex` memo, never inside it: the
+* build stays pure in `items`, the merge pure in that build plus this store.
+*/
+function useCascaderLoader({ base, getChildren, onSearch, resolveValue, searchDebounce = 250, loadKey, prefetch = false, onLoadError, enabled, query, levels, path, values }) {
+	const [store, setStore] = React$1.useState(createStore);
+	const [search, setSearch] = React$1.useState(null);
+	/**
+	* Latest callbacks, WRITTEN IN AN EFFECT: `getChildren` is inline in most
+	* consumers, so closing over it would refire every in-flight request per
+	* re-render. The ref is what keeps the request machinery `[]`-dep. Declared
+	* FIRST, since effects run in declaration order, so the level effect below
+	* already sees the current commit.
+	*/
+	const latest = React$1.useRef({
+		base,
+		store,
+		getChildren,
+		onSearch,
+		resolveValue,
+		onLoadError,
+		prefetch,
+		path,
+		query
+	});
+	React$1.useEffect(() => {
+		latest.current = {
+			base,
+			store,
+			getChildren,
+			onSearch,
+			resolveValue,
+			onLoadError,
+			prefetch,
+			path,
+			query
+		};
+	});
+	/** One AbortController PER KEY: columns mode runs several levels at once. */
+	const controllers = React$1.useRef(/* @__PURE__ */ new Map());
+	/** Monotonic per key. The stale guard for out-of-order responses. */
+	const requestIds = React$1.useRef(/* @__PURE__ */ new Map());
+	/** In-flight `(level, cursor)` signatures, so a duplicate ask is free. */
+	const inflight = React$1.useRef(/* @__PURE__ */ new Map());
+	/**
+	* The `(child count, cursor)` signature at the last paging fire, per level.
+	* Guards what `hasMore` cannot: a page of zero new items while the server
+	* still says `hasMore`. Cursor is IN the signature because an all-duplicates
+	* page advances it while the count stands still - real progress, which a
+	* count-only latch would brick forever.
+	*/
+	const moreLatch = React$1.useRef(/* @__PURE__ */ new Map());
+	/** Values `resolveValue` has already been asked about, so it asks once. */
+	const attempted = React$1.useRef(/* @__PURE__ */ new Set());
+	/**
+	* Values whose resolve failed. They stay `attempted` until the next open
+	* rather than the next values pass: with inline `items` every parent render
+	* is one, and an `onLoadError` that set parent state looped at network speed.
+	*/
+	const failed = React$1.useRef(/* @__PURE__ */ new Set());
+	/** Every node the loader has seen, so a level key can name its own node. */
+	const known = React$1.useRef(/* @__PURE__ */ new Map());
+	const timers = React$1.useRef({ prefetch: null });
+	/** Bumped by a `loadKey` change, so responses from before it are dropped. */
+	const epoch = React$1.useRef(0);
+	const remember = React$1.useCallback((nodes) => {
+		const map = known.current;
+		const walk = (list) => {
+			for (const node of list) {
+				map.set(node.value, node);
+				if (node.children?.length) walk(node.children);
+			}
+		};
+		walk(nodes);
+	}, []);
+	const abortKey = React$1.useCallback((key) => {
+		const controller = controllers.current.get(key);
+		if (!controller) return;
+		controllers.current.delete(key);
+		inflight.current.delete(key);
+		controller.abort();
+	}, []);
+	const runLoad = React$1.useCallback((key, reason, cursor, append) => {
+		const { getChildren: loader, base: currentBase } = latest.current;
+		if (!loader) return;
+		const signature = `${append ? "1" : "0"}:${cursor ?? ""}`;
+		if (inflight.current.get(key) === signature) return;
+		abortKey(key);
+		const controller = new AbortController();
+		controllers.current.set(key, controller);
+		inflight.current.set(key, signature);
+		const requestId = (requestIds.current.get(key) ?? 0) + 1;
+		requestIds.current.set(key, requestId);
+		const startEpoch = epoch.current;
+		const node = key === "\0root" ? null : currentBase.byValue.get(key) ?? known.current.get(key) ?? {
+			value: key,
+			label: key
+		};
+		setStore((prev) => withLoadState(prev, key, (state) => ({
+			...state,
+			loading: true,
+			error: false
+		})));
+		const settle = () => {
+			if (inflight.current.get(key) === signature) inflight.current.delete(key);
+			if (controllers.current.get(key) === controller) controllers.current.delete(key);
+		};
+		const stale = () => controller.signal.aborted || startEpoch !== epoch.current || requestId !== requestIds.current.get(key);
+		Promise.resolve().then(() => loader(node, {
+			signal: controller.signal,
+			cursor,
+			reason
+		})).then((result) => {
+			settle();
+			if (stale()) return;
+			const items = Array.isArray(result) ? result : result.items;
+			const nextCursor = Array.isArray(result) ? void 0 : result.nextCursor;
+			const hasMore = Array.isArray(result) ? false : result.hasMore ?? nextCursor != null;
+			if (!append) moreLatch.current.delete(key);
+			remember(items);
+			setStore((prev) => withPage(prev, key, items, {
+				append,
+				hasMore,
+				cursor: nextCursor
+			}));
+		}).catch((error) => {
+			settle();
+			if (stale()) return;
+			setStore((prev) => withLoadState(prev, key, (state) => ({
+				...state,
+				loading: false,
+				error: true
+			})));
+			latest.current.onLoadError?.(error, {
+				parent: key === "\0root" ? null : key,
+				reason
+			});
+		});
+	}, [abortKey, remember]);
+	const ensureLevel = React$1.useCallback((key, reason) => {
+		const { getChildren: loader, store: current, base: index } = latest.current;
+		if (!loader) return;
+		if (current.states.has(key)) return;
+		if (index.childrenOf.has(key)) return;
+		runLoad(key, reason, void 0, false);
+	}, [runLoad]);
+	const loadMore = React$1.useCallback((key) => {
+		const { getChildren: loader, store: current } = latest.current;
+		if (!loader) return;
+		const state = current.states.get(key);
+		if (!state || state.loading || !state.hasMore) return;
+		const signature = `${current.pages.get(key)?.length ?? 0}:${state.cursor ?? ""}`;
+		if (moreLatch.current.get(key) === signature) return;
+		moreLatch.current.set(key, signature);
+		runLoad(key, "more", state.cursor, true);
+	}, [runLoad]);
+	const retryLevel = React$1.useCallback((key) => {
+		const { getChildren: loader, store: current } = latest.current;
+		if (!loader) return;
+		const state = current.states.get(key);
+		if (!state?.error) return;
+		const loaded = current.pages.get(key)?.length ?? 0;
+		moreLatch.current.delete(key);
+		runLoad(key, "retry", loaded > 0 ? state.cursor : void 0, loaded > 0);
+	}, [runLoad]);
+	/**
+	* `detached` and `links` are deliberately untouched: chains and search hits
+	* belong to no level, and the trigger needs their path while the new page is
+	* in flight.
+	*/
+	const invalidateLevel = React$1.useCallback((value) => {
+		const key = value ?? "\0root";
+		abortKey(key);
+		requestIds.current.set(key, (requestIds.current.get(key) ?? 0) + 1);
+		moreLatch.current.delete(key);
+		setStore((prev) => {
+			if (!prev.states.has(key) && !prev.pages.has(key)) return prev;
+			const states = new Map(prev.states);
+			states.delete(key);
+			const pages = new Map(prev.pages);
+			pages.delete(key);
+			return {
+				...prev,
+				pages,
+				states
+			};
+		});
+	}, [abortKey]);
+	const prefetchNode = React$1.useCallback((node) => {
+		const { prefetch: on, getChildren: loader, store: current } = latest.current;
+		if (!on || !loader || !node) return;
+		if (isCascaderMoreNode(node)) return;
+		if (!node.hasChildren) return;
+		if (current.states.has(node.value)) return;
+		const holder = timers.current;
+		if (holder.prefetch) clearTimeout(holder.prefetch);
+		holder.prefetch = setTimeout(() => {
+			holder.prefetch = null;
+			ensureLevel(node.value, "prefetch");
+		}, PREFETCH_DELAY);
+	}, [ensureLevel]);
+	const runSearch = React$1.useCallback((text) => {
+		const { onSearch: searcher, path: currentPath } = latest.current;
+		if (!searcher) return;
+		abortKey(SEARCH_KEY);
+		const controller = new AbortController();
+		controllers.current.set(SEARCH_KEY, controller);
+		const requestId = (requestIds.current.get(SEARCH_KEY) ?? 0) + 1;
+		requestIds.current.set(SEARCH_KEY, requestId);
+		const startEpoch = epoch.current;
+		setSearch((prev) => ({
+			query: text,
+			results: prev?.results ?? [],
+			loading: true,
+			error: false
+		}));
+		const settle = () => {
+			if (controllers.current.get(SEARCH_KEY) === controller) controllers.current.delete(SEARCH_KEY);
+		};
+		const stale = () => controller.signal.aborted || startEpoch !== epoch.current || requestId !== requestIds.current.get(SEARCH_KEY);
+		Promise.resolve().then(() => searcher(text, {
+			signal: controller.signal,
+			path: currentPath
+		})).then((result) => {
+			settle();
+			if (stale()) return;
+			const items = Array.isArray(result) ? result : result.items;
+			remember(items);
+			setStore((prev) => withDetached(prev, items));
+			setSearch({
+				query: text,
+				results: items,
+				loading: false,
+				error: false
+			});
+		}).catch((error) => {
+			settle();
+			if (stale()) return;
+			setSearch((prev) => ({
+				query: text,
+				results: prev?.results ?? [],
+				loading: false,
+				error: true
+			}));
+			latest.current.onLoadError?.(error, {
+				parent: null,
+				reason: "search"
+			});
+		});
+	}, [abortKey, remember]);
+	const retrySearch = React$1.useCallback(() => {
+		const text = latest.current.query.trim();
+		if (text) runSearch(text);
+	}, [runSearch]);
+	const runResolve = React$1.useCallback((value) => {
+		const { resolveValue: resolver } = latest.current;
+		if (!resolver) return;
+		const key = `${RESOLVE_PREFIX}${value}`;
+		abortKey(key);
+		const controller = new AbortController();
+		controllers.current.set(key, controller);
+		const startEpoch = epoch.current;
+		const settle = () => {
+			if (controllers.current.get(key) === controller) controllers.current.delete(key);
+		};
+		Promise.resolve().then(() => resolver(value, {
+			signal: controller.signal,
+			reason: "resolve"
+		})).then((chain) => {
+			settle();
+			if (controller.signal.aborted || startEpoch !== epoch.current) return;
+			if (!chain?.length) return;
+			remember(chain);
+			setStore((prev) => withChain(prev, chain));
+		}).catch((error) => {
+			const live = controllers.current.get(key) === controller;
+			settle();
+			if (live) failed.current.add(value);
+			if (controller.signal.aborted || startEpoch !== epoch.current) return;
+			latest.current.onLoadError?.(error, {
+				parent: null,
+				reason: "resolve"
+			});
+		});
+	}, [abortKey, remember]);
+	const cancelPanel = React$1.useCallback(() => {
+		const keys = Array.from(controllers.current.keys()).filter((key) => !key.startsWith(RESOLVE_PREFIX));
+		for (const key of keys) {
+			controllers.current.get(key)?.abort();
+			controllers.current.delete(key);
+		}
+		inflight.current.clear();
+		const holder = timers.current;
+		if (holder.prefetch) {
+			clearTimeout(holder.prefetch);
+			holder.prefetch = null;
+		}
+		if (keys.length === 0) return;
+		setStore((prev) => {
+			let states = null;
+			for (const key of keys) {
+				const state = prev.states.get(key);
+				if (!state?.loading) continue;
+				states = states ?? new Map(prev.states);
+				if ((prev.pages.get(key)?.length ?? 0) > 0) states.set(key, {
+					...state,
+					loading: false
+				});
+				else states.delete(key);
+			}
+			return states ? {
+				...prev,
+				states
+			} : prev;
+		});
+		setSearch((prev) => prev?.loading ? {
+			...prev,
+			loading: false
+		} : prev);
+	}, []);
+	const loadKeyRef = React$1.useRef(null);
+	React$1.useEffect(() => {
+		const previous = loadKeyRef.current;
+		loadKeyRef.current = { key: loadKey };
+		if (!previous || Object.is(previous.key, loadKey)) return;
+		epoch.current += 1;
+		for (const controller of controllers.current.values()) controller.abort();
+		controllers.current.clear();
+		inflight.current.clear();
+		moreLatch.current.clear();
+		attempted.current.clear();
+		failed.current.clear();
+		known.current.clear();
+		const holder = timers.current;
+		if (holder.prefetch) {
+			clearTimeout(holder.prefetch);
+			holder.prefetch = null;
+		}
+		setStore(createStore);
+		setSearch(null);
+	}, [loadKey]);
+	React$1.useEffect(() => {
+		if (enabled) return;
+		if (controllers.current.size === 0) return;
+		cancelPanel();
+	}, [enabled, cancelPanel]);
+	React$1.useEffect(() => {
+		const active = controllers.current;
+		const holder = timers.current;
+		const pending = inflight.current;
+		const ids = requestIds.current;
+		const tried = attempted.current;
+		const parked = failed.current;
+		return () => {
+			for (const controller of active.values()) controller.abort();
+			active.clear();
+			pending.clear();
+			ids.clear();
+			tried.clear();
+			parked.clear();
+			if (holder.prefetch) clearTimeout(holder.prefetch);
+		};
+	}, []);
+	const hasLoader = typeof getChildren === "function";
+	const hasSearch = typeof onSearch === "function";
+	const hasResolve = typeof resolveValue === "function";
+	const trimmed = query.trim();
+	const levelsKey = JSON.stringify(levels);
+	const valuesKey = JSON.stringify(values);
+	React$1.useEffect(() => {
+		if (!enabled || !hasLoader) return;
+		for (const key of levels) ensureLevel(key, "level");
+	}, [
+		enabled,
+		hasLoader,
+		levelsKey,
+		store,
+		ensureLevel
+	]);
+	React$1.useEffect(() => {
+		if (!hasSearch) return void 0;
+		if (!enabled || !trimmed) {
+			abortKey(SEARCH_KEY);
+			setSearch((prev) => prev === null ? prev : null);
+			return;
+		}
+		const timer = setTimeout(() => runSearch(trimmed), searchDebounce);
+		return () => {
+			clearTimeout(timer);
+			abortKey(SEARCH_KEY);
+		};
+	}, [
+		hasSearch,
+		enabled,
+		trimmed,
+		searchDebounce,
+		abortKey,
+		runSearch
+	]);
+	React$1.useEffect(() => {
+		if (!enabled || failed.current.size === 0) return;
+		for (const value of failed.current) attempted.current.delete(value);
+		failed.current.clear();
+	}, [enabled]);
+	React$1.useEffect(() => {
+		if (!hasResolve) return;
+		for (const value of values) {
+			if (!value) continue;
+			if (attempted.current.has(value)) continue;
+			if (base.byValue.has(value) || known.current.has(value)) continue;
+			attempted.current.add(value);
+			runResolve(value);
+		}
+	}, [
+		enabled,
+		hasResolve,
+		valuesKey,
+		base,
+		runResolve,
+		loadKey
+	]);
+	const searchResults = React$1.useMemo(() => {
+		if (!hasSearch || !trimmed) return null;
+		if (!search || search.query !== trimmed) return NO_RESULTS;
+		return search.results;
+	}, [
+		hasSearch,
+		trimmed,
+		search
+	]);
+	const searchState = React$1.useMemo(() => {
+		if (!hasSearch || !trimmed) return null;
+		const settled = search?.query === trimmed;
+		return {
+			loading: !settled || !!search?.loading,
+			error: settled && !!search?.error,
+			hasMore: false
+		};
+	}, [
+		hasSearch,
+		trimmed,
+		search
+	]);
+	return React$1.useMemo(() => ({
+		active: hasLoader,
+		store,
+		states: store.states,
+		searchResults,
+		searchState,
+		ensureLevel,
+		loadMore,
+		retryLevel,
+		retrySearch,
+		invalidateLevel,
+		prefetchNode
+	}), [
+		hasLoader,
+		store,
+		searchResults,
+		searchState,
+		ensureLevel,
+		loadMore,
+		retryLevel,
+		retrySearch,
+		invalidateLevel,
+		prefetchNode
+	]);
+}
+/** One level's load state, `null` when never fetched. Omit for the root. */
+function useCascaderLoadState(parent) {
+	const { loadStates } = useCascaderState();
+	return loadStates.get(parent ?? "\0root") ?? null;
+}
+export { useCascaderLoadState, useCascaderLoader };

package/dist/vendor/reui.io/cascader/cascader-context.d.mts

@@ -0,0 +1,12 @@
+import { CascaderNode } from "./cascader-types.mjs";
+import "react";
+export interface CascaderItemState<T = unknown> {
+  branch: boolean;
+  selected: boolean;
+  /** The node's own flag or a disabled ancestor's, as `isCascaderDisabled`. */
+  disabled: boolean;
+  depth: number;
+  count: number;
+  /** Ancestor chain, root first. Populated for deep and global search rows. */
+  path: CascaderNode<T>[];
+}