@deftui/react 0.3.0 → 0.3.1

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

@@ -0,0 +1,56 @@
+import { CascaderCollapse, CascaderNode, CascaderValueDisplay } from "./cascader-types.mjs";
+import * as React$1 from "react";
+import { useRender } from "@base-ui/react/use-render";
+import { Combobox } from "@base-ui/react";
+export type CascaderNavProps = useRender.ComponentProps<"div">;
+/**
+ * Header: back control, search input, and the separator under them. The
+ * breadcrumb belongs with the list below: it describes the rows, not the field.
+ */
+declare function CascaderNav({ className, ...props }: CascaderNavProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+export interface CascaderBackProps extends Omit<useRender.ComponentProps<"button">, "children"> {
+  children?: React$1.ReactNode;
+}
+/** Pops one level. Renders nothing at the root, so no dead header space. */
+declare function CascaderBack({ className, children, ...props }: CascaderBackProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+export interface CascaderBreadcrumbProps extends Omit<useRender.ComponentProps<"nav">, "children"> {
+  /** Maximum visible node segments before the middle collapses. */
+  maxSegments?: number;
+  collapse?: CascaderCollapse;
+  /** Clicking a segment navigates back to that level. Defaults to true. */
+  interactive?: boolean;
+}
+/**
+ * Compact trail of the current level AND its ancestors, collapsed by the same
+ * helper as `CascaderValue` so panel and trigger cannot disagree. The current
+ * level IS the last crumb: dropping it read as a rendering bug, a trail naming
+ * only the places you are not.
+ */
+declare function CascaderBreadcrumb({ className, maxSegments, collapse, interactive, ...props }: CascaderBreadcrumbProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | null;
+export interface CascaderInputProps extends Combobox.Input.Props {
+  /** Renders the back control inline, before the field. Defaults to true. */
+  showBack?: boolean;
+}
+/**
+ * Search field. MUST render inside the positioner: only there does Base UI skip
+ * the refill from the committed selection that would fight every level swap.
+ */
+declare function CascaderInput({ className, showBack, placeholder, onKeyDown, "aria-describedby": ariaDescribedBy, ...props }: CascaderInputProps): React$1.JSX.Element;
+export interface CascaderValueProps extends Omit<useRender.ComponentProps<"span">, "children"> {
+  /** `path` shows the full trail, `leaf` only the node, `count` only a total. */
+  display?: CascaderValueDisplay;
+  maxSegments?: number;
+  collapse?: CascaderCollapse;
+  separator?: React$1.ReactNode;
+  /** Renders the selected node's icon before the trail. */
+  showIcon?: boolean;
+  placeholder?: React$1.ReactNode;
+  /** Replaces the whole rendering. Receives the resolved selection and path. */
+  children?: (selected: CascaderNode[], path: CascaderNode[]) => React$1.ReactNode;
+}
+/**
+ * Trigger display. Defaults to the collapsed selection path rather than a bare
+ * leaf label, which in a nested picker is frequently ambiguous.
+ */
+declare function CascaderValue({ className, display, maxSegments, collapse, separator, showIcon, placeholder, children, ...props }: CascaderValueProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+export { CascaderBack, CascaderBreadcrumb, CascaderInput, CascaderNav, CascaderValue };

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

@@ -0,0 +1,310 @@
+"use client";
+import { useCascaderActions, useCascaderState } from "./cascader-context.mjs";
+import { resolveCascaderSearchLabel } from "./cascader-i18n.mjs";
+import { collapseCascaderPath, getCascaderFooterStops, getCascaderPath, isCascaderRtl } from "./cascader-lib.mjs";
+import { cn } from "cn";
+import { mergeProps } from "@base-ui/react/merge-props";
+import * as React$1 from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useRender } from "@base-ui/react/use-render";
+import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react";
+import { Combobox } from "@base-ui/react";
+import { useDirection } from "@base-ui/react/direction-provider";
+// src/vendor/reui.io/cascader/cascader-nav.tsx
+function PathChevron() {
+	return /* @__PURE__ */ jsx(ChevronRightIcon, { className: "size-3 shrink-0 opacity-50 rtl:-scale-x-100" });
+}
+/**
+* Header: back control, search input, and the separator under them. The
+* breadcrumb belongs with the list below: it describes the rows, not the field.
+*/
+function CascaderNav({ className, ...props }) {
+	const defaultProps = {
+		"data-slot": "cascader-nav",
+		className: cn("border-border/60 flex shrink-0 flex-col gap-1 border-b px-1.5 py-1", className)
+	};
+	return useRender({
+		defaultTagName: "div",
+		render: props.render,
+		props: mergeProps(defaultProps, props)
+	});
+}
+/** Pops one level. Renders nothing at the root, so no dead header space. */
+function CascaderBack({ className, children, ...props }) {
+	const { popLevel, labels, mode } = useCascaderActions();
+	const { path } = useCascaderState();
+	const hidden = mode !== "drill" || path.length === 0;
+	const defaultProps = {
+		"data-slot": "cascader-back",
+		type: "button",
+		"aria-label": labels.back,
+		onClick: () => popLevel(),
+		className: cn("text-muted-foreground hover:bg-accent hover:text-accent-foreground focus-visible:ring-ring/50 flex shrink-0 items-center justify-center rounded-md outline-hidden transition-colors focus-visible:ring-2", "size-6", className),
+		children: children ?? /* @__PURE__ */ jsx(ChevronLeftIcon, { className: "size-4 rtl:-scale-x-100" })
+	};
+	const element = useRender({
+		defaultTagName: "button",
+		render: props.render,
+		props: mergeProps(defaultProps, props)
+	});
+	return hidden ? null : element;
+}
+/**
+* Compact trail of the current level AND its ancestors, collapsed by the same
+* helper as `CascaderValue` so panel and trigger cannot disagree. The current
+* level IS the last crumb: dropping it read as a rendering bug, a trail naming
+* only the places you are not.
+*/
+function CascaderBreadcrumb({ className, maxSegments = 3, collapse = "middle", interactive = true, ...props }) {
+	const { goToDepth, mode, labels } = useCascaderActions();
+	const { path, index } = useCascaderState();
+	const nodes = path.map((value) => index.byValue.get(value)).filter(Boolean);
+	const segments = collapseCascaderPath(nodes, {
+		maxSegments,
+		collapse
+	});
+	const currentValue = nodes.length ? nodes[nodes.length - 1].value : null;
+	const hidden = mode !== "drill" || nodes.length === 0;
+	const goTo = (node) => {
+		const depth = path.indexOf(node.value);
+		if (depth < 0) return;
+		goToDepth(depth + 1);
+	};
+	const defaultProps = {
+		"data-slot": "cascader-breadcrumb",
+		"aria-label": labels.breadcrumbLabel,
+		className: cn("text-muted-foreground flex min-w-0 shrink-0 items-center gap-0.5 pt-1.5 pb-0.5 text-xs", "px-3", className),
+		children: segments.map((segment, i) => /* @__PURE__ */ jsxs(React$1.Fragment, { children: [i > 0 ? /* @__PURE__ */ jsx(PathChevron, {}) : null, segment.type === "ellipsis" ? /* @__PURE__ */ jsx("span", {
+			"data-slot": "cascader-breadcrumb-ellipsis",
+			title: segment.hidden.map((n) => n.label).join(` ${labels.pathSeparator} `),
+			className: "shrink-0",
+			children: "…"
+		}) : interactive && segment.node.value !== currentValue ? /* @__PURE__ */ jsx("button", {
+			type: "button",
+			"data-slot": "cascader-breadcrumb-item",
+			onClick: () => goTo(segment.node),
+			className: "hover:text-foreground focus-visible:ring-ring/50 max-w-32 truncate rounded-sm outline-hidden transition-colors focus-visible:ring-2",
+			children: segment.node.label
+		}) : /* @__PURE__ */ jsx("span", {
+			"data-slot": "cascader-breadcrumb-item",
+			...segment.node.value === currentValue ? { "aria-current": "page" } : null,
+			className: cn("max-w-32 truncate", segment.node.value === currentValue && "text-foreground font-medium"),
+			children: segment.node.label
+		})] }, segment.type === "node" ? segment.node.value : `gap-${i}`))
+	};
+	const element = useRender({
+		defaultTagName: "nav",
+		render: props.render,
+		props: mergeProps(defaultProps, props)
+	});
+	return hidden ? null : element;
+}
+/**
+* Search field. MUST render inside the positioner: only there does Base UI skip
+* the refill from the committed selection that would fight every level swap.
+*/
+function CascaderInput({ className, showBack = true, placeholder, onKeyDown, "aria-describedby": ariaDescribedBy, ...props }) {
+	const { labels, popLevel, mode, getHighlighted, isBranch, isDisabled, navigate, index, toggleExpanded, inline, invalid, baseId, searchScope } = useCascaderActions();
+	const direction = useDirection();
+	const { currentParent, query, path, expanded, renderedItems, treeRows } = useCascaderState();
+	const resolvedPlaceholder = placeholder ?? resolveCascaderSearchLabel(labels, searchScope === "global" ? void 0 : currentParent?.label);
+	const backVisible = showBack && mode === "drill" && path.length > 0;
+	const hintId = `${baseId}-hint`;
+	const listId = `${baseId}-column-${mode === "columns" ? path.length : 0}`;
+	const hintRef = React$1.useRef(null);
+	const [hintDir, setHintDir] = React$1.useState("ltr");
+	React$1.useLayoutEffect(() => {
+		const hint = hintRef.current;
+		if (!hint) return;
+		setHintDir(isCascaderRtl(hint, direction) ? "rtl" : "ltr");
+	}, [direction]);
+	/**
+	* Moves the highlight to `targetIndex` in `treeRows`. Base UI has no
+	* imperative setter (`actionsRef` is `{ unmount }`), so the move is arrow
+	* presses, sound only because `useListNavigation` fires `onItemHighlighted`
+	* SYNCHRONOUSLY per keydown. A press that fails to close the gap ends it.
+	*/
+	const moveHighlightTo = (field, targetIndex) => {
+		const rowIndex = () => {
+			const highlighted = getHighlighted();
+			if (!highlighted) return -1;
+			return treeRows.findIndex((row) => row.node.value === highlighted.value);
+		};
+		let current = rowIndex();
+		for (let step = 0; step < treeRows.length; step += 1) {
+			if (current === -1 || current === targetIndex) return;
+			const key = current > targetIndex ? "ArrowUp" : "ArrowDown";
+			field.dispatchEvent(new KeyboardEvent("keydown", {
+				key,
+				bubbles: true,
+				cancelable: true
+			}));
+			const next = rowIndex();
+			if (next === -1 || !(key === "ArrowUp" ? next < current && next >= targetIndex : next > current && next <= targetIndex)) return;
+			current = next;
+		}
+	};
+	/**
+	* The tree pattern's two level keys; Base UI leaves both alone (list
+	* navigation is vertical-only, the chip handler no-ops without
+	* `Combobox.Chips`). Passed in rather than hardcoded because RTL swaps them:
+	* APG defines them as "toward the children", not as a physical arrow.
+	*/
+	const handleTreeKeyDown = (event, field, caretAtStart, caretAtEnd, forwardKey, backKey) => {
+		const forward = event.key === forwardKey;
+		if (!forward && event.key !== backKey) return;
+		if (forward ? !caretAtEnd : !caretAtStart) return;
+		const highlighted = getHighlighted();
+		if (!highlighted) return;
+		const rowIndex = treeRows.findIndex((row) => row.node.value === highlighted.value);
+		if (rowIndex < 0) return;
+		const row = treeRows[rowIndex];
+		if (forward) {
+			if (!row.branch) return;
+			event.preventDefault();
+			if (!row.expanded) {
+				navigate(row.node);
+				return;
+			}
+			const child = treeRows[rowIndex + 1];
+			if (child && child.depth === row.depth + 1) moveHighlightTo(field, rowIndex + 1);
+			return;
+		}
+		const heldByQuery = isDisabled(row.node) && !expanded.has(row.node.value);
+		if (row.branch && row.expanded && !heldByQuery) {
+			event.preventDefault();
+			toggleExpanded(row.node.value);
+			return;
+		}
+		const parentValue = index.parentOf.get(row.node.value);
+		if (!parentValue) return;
+		const parentIndex = treeRows.findIndex((entry) => entry.node.value === parentValue);
+		if (parentIndex < 0) return;
+		event.preventDefault();
+		moveHighlightTo(field, parentIndex);
+	};
+	const handleKeyDown = (event) => {
+		onKeyDown?.(event);
+		if (event.defaultPrevented) return;
+		const field = event.currentTarget;
+		const caretAtStart = field.selectionStart === 0 && field.selectionEnd === 0;
+		const caretAtEnd = field.selectionStart === query.length && field.selectionEnd === query.length;
+		if (event.key === "ArrowDown" && !event.altKey) {
+			const rowCount = mode === "tree" ? treeRows.length : renderedItems.length;
+			const lastValue = mode === "tree" ? treeRows[rowCount - 1]?.node.value : renderedItems[rowCount - 1]?.value;
+			const highlighted = getHighlighted();
+			if (rowCount === 0 || highlighted != null && highlighted.value === lastValue) {
+				const panel = field.closest("[data-slot=\"cascader-panel\"]");
+				const stop = panel ? getCascaderFooterStops(panel)[0] : void 0;
+				if (stop) {
+					event.preventDefault();
+					stop.focus();
+					return;
+				}
+			}
+		}
+		const rtl = isCascaderRtl(field, direction);
+		const forwardKey = rtl ? "ArrowLeft" : "ArrowRight";
+		const backKey = rtl ? "ArrowRight" : "ArrowLeft";
+		if (mode === "tree") {
+			handleTreeKeyDown(event, field, caretAtStart, caretAtEnd, forwardKey, backKey);
+			return;
+		}
+		if (event.key === forwardKey && caretAtEnd) {
+			const highlighted = getHighlighted();
+			if (highlighted && isBranch(highlighted)) {
+				event.preventDefault();
+				navigate(highlighted);
+				return;
+			}
+		}
+		if (event.key === backKey && caretAtStart || event.key === "Backspace" && query.length === 0) {
+			if (path.length > 0) {
+				event.preventDefault();
+				popLevel();
+			}
+		}
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		"data-slot": "cascader-input-row",
+		className: cn("flex shrink-0 items-center gap-1", "h-8"),
+		children: [
+			showBack ? /* @__PURE__ */ jsx(CascaderBack, {}) : null,
+			/* @__PURE__ */ jsx(Combobox.Input, {
+				"data-slot": "cascader-input",
+				placeholder: resolvedPlaceholder,
+				onKeyDown: handleKeyDown,
+				"aria-describedby": [ariaDescribedBy, hintId].filter(Boolean).join(" "),
+				...mode === "tree" ? { "aria-haspopup": "tree" } : null,
+				...inline ? {
+					"aria-expanded": true,
+					"aria-controls": listId
+				} : null,
+				...invalid ? {
+					"aria-invalid": true,
+					"data-invalid": ""
+				} : null,
+				className: cn("placeholder:text-muted-foreground h-full w-full min-w-0 flex-1 bg-transparent px-1.5 text-sm outline-hidden disabled:cursor-not-allowed disabled:opacity-50", backVisible && "ps-0", className),
+				...props
+			}),
+			/* @__PURE__ */ jsx("span", {
+				id: hintId,
+				ref: hintRef,
+				className: "sr-only",
+				children: labels.keyboardHint(mode, hintDir)
+			})
+		]
+	});
+}
+/**
+* Trigger display. Defaults to the collapsed selection path rather than a bare
+* leaf label, which in a nested picker is frequently ambiguous.
+*/
+function CascaderValue({ className, display = "path", maxSegments = 3, collapse = "middle", separator, showIcon = true, placeholder, children, ...props }) {
+	const { labels, multiple, resolveNode } = useCascaderActions();
+	const { index, selectedValues } = useCascaderState();
+	const selected = selectedValues.map(resolveNode);
+	const resolvedPath = selectedValues.length === 1 ? getCascaderPath(index, selectedValues[0]) : [];
+	const path = resolvedPath.length > 0 ? resolvedPath : selected.length === 1 ? selected : [];
+	let content;
+	if (children) content = children(selected, path);
+	else if (selectedValues.length === 0) content = /* @__PURE__ */ jsx("span", {
+		className: "text-muted-foreground truncate",
+		children: placeholder
+	});
+	else if (display === "count" || multiple && selectedValues.length > 1) content = labels.selectedCount(selectedValues.length);
+	else {
+		const leaf = path[path.length - 1] ?? selected[0];
+		const segments = display === "leaf" ? [{
+			type: "node",
+			node: leaf
+		}] : collapseCascaderPath(path, {
+			maxSegments,
+			collapse
+		});
+		content = /* @__PURE__ */ jsxs(Fragment, { children: [showIcon && leaf?.icon ? /* @__PURE__ */ jsx("span", {
+			"data-slot": "cascader-value-icon",
+			className: "text-muted-foreground flex shrink-0 items-center",
+			children: leaf.icon
+		}) : null, segments.map((segment, i) => /* @__PURE__ */ jsxs(React$1.Fragment, { children: [i > 0 ? separator ?? /* @__PURE__ */ jsx(PathChevron, {}) : null, segment.type === "ellipsis" ? /* @__PURE__ */ jsx("span", {
+			"data-slot": "cascader-value-ellipsis",
+			title: segment.hidden.map((n) => n.label).join(` ${labels.pathSeparator} `),
+			className: "text-muted-foreground shrink-0",
+			children: "…"
+		}) : /* @__PURE__ */ jsx("span", {
+			className: cn("truncate", i < segments.length - 1 && "text-muted-foreground"),
+			children: segment.node?.label
+		})] }, segment.type === "node" ? segment.node.value : `gap-${i}`))] });
+	}
+	const defaultProps = {
+		"data-slot": "cascader-value",
+		className: cn("flex min-w-0 items-center gap-1 truncate", className),
+		children: content
+	};
+	return useRender({
+		defaultTagName: "span",
+		render: props.render,
+		props: mergeProps(defaultProps, props)
+	});
+}
+export { CascaderBack, CascaderBreadcrumb, CascaderInput, CascaderNav, CascaderValue };

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

@@ -0,0 +1,140 @@
+import * as React$1 from "react";
+/**
+ * A node in the cascader tree. Two input shapes normalize to one internal
+ * index: nested (nodes carry `children`), or flat adjacency plus the root's
+ * `getParent`, which skips the re-nesting step for large datasets.
+ */
+export interface CascaderNode<T = unknown> {
+  /** Stable id. Also the committed selection value. */
+  value: string;
+  label: string;
+  icon?: React$1.ReactNode;
+  description?: string;
+  children?: CascaderNode<T>[];
+  /** Declares a branch before load; async nodes read as leaves without it. */
+  hasChildren?: boolean;
+  /** Trailing count. Defaults to known children; set it for async nodes. */
+  count?: number;
+  /** Listed, never selected or opened; on a branch, its whole subtree too. */
+  disabled?: boolean;
+  keywords?: string[];
+  /**
+   * Only read on a node nested inside a `getChildren` result. For the level a
+   * node OWNS the authoritative signal is that level's `CascaderLoadResult`.
+   */
+  hasMore?: boolean;
+  data?: T;
+}
+/**
+ * One footer ACTION. Deliberately not a `CascaderNode`, so a command can never
+ * be passed where an option is expected and join the ring, filter or selection.
+ */
+export interface CascaderActionItem {
+  /** Stable key. Falls back to the label when it is a string, then the index. */
+  value?: string;
+  label: React$1.ReactNode;
+  icon?: React$1.ReactNode;
+  disabled?: boolean;
+  /** Ignored when `items` is present - a flyout opens instead. */
+  onSelect?: () => void;
+  /** Turns the row into a submenu trigger. One level deep on purpose. */
+  items?: CascaderActionItem[];
+  /** Consecutive entries sharing a heading are drawn under one. */
+  group?: string;
+}
+/** Panel layout. See the docs for the keyboard map of each. */
+export type CascaderMode = "drill" | "columns" | "tree";
+export type CascaderSearchScope = "level" | "deep" | "global";
+/**
+ * Which nodes may be committed. The predicate arm is generic over the payload
+ * rather than quantified per call: a per-call `<T>` would force every predicate
+ * to accept EVERY payload, so `(node: CascaderNode<Member>) => boolean` could
+ * never satisfy it.
+ */
+export type CascaderSelectable<T = unknown> = "leaf" | "any" | ((node: CascaderNode<T>) => boolean);
+export type CascaderCollapse = "middle" | "start" | "none";
+export type CascaderValueDisplay = "path" | "leaf" | "count";
+export type CascaderChangeReason = "select" | "deselect" | "clear";
+/** Second argument to `onValueChange`: resolved nodes, so no re-lookup. */
+export interface CascaderChangeDetails<T = unknown> {
+  /** The node committed or toggled. Null when the selection was cleared. */
+  node: CascaderNode<T> | null;
+  /** Ancestor chain of `node`, root first, node last. */
+  path: CascaderNode<T>[];
+  nodes: CascaderNode<T>[];
+  reason: CascaderChangeReason;
+}
+/** Why a level was fetched. `resolve`: `resolveValue` hit an unloaded node. */
+export type CascaderLoadReason = "level" | "more" | "prefetch" | "retry" | "resolve";
+/** Argument handed to `getChildren` and `resolveValue`. */
+export interface CascaderLoadContext {
+  /**
+   * Aborted when the request is superseded, `loadKey` changes or the cascader
+   * unmounts, and for a `getChildren` load also when the popup closes.
+   */
+  signal: AbortSignal;
+  cursor?: string;
+  reason?: CascaderLoadReason;
+}
+/** Value returned by `getChildren`. A bare array is also accepted. */
+export interface CascaderLoadResult<T = unknown> {
+  items: CascaderNode<T>[];
+  nextCursor?: string;
+  /** Defaults to whether `nextCursor` was supplied. */
+  hasMore?: boolean;
+}
+/** Argument handed to `onSearch`. */
+export interface CascaderSearchContext {
+  signal: AbortSignal;
+  /** The path the user is searching within, deepest last. Empty under a
+   * global search, whose scope is the whole tree. */
+  path: string[];
+}
+/**
+ * Every user facing string, so the primitive ships no hardcoded copy. The
+ * callbacks take plain labels, not nodes: a `CascaderNode<T>` parameter would
+ * force this object to carry the item generic. `*Announcement` is live-region.
+ */
+export interface CascaderLabels {
+  /** `parentLabel` is absent at the root and under a global search. */
+  search: string | ((parentLabel?: string) => string);
+  back: string;
+  /** A level's FIRST page. `loadingMore` is the next, `loadMore` its idle row. */
+  loading: string;
+  loadingMore: string;
+  loadMore: string;
+  error: string;
+  retry: string;
+  empty: string;
+  /** Rendered by `CascaderValue` when `display="count"`. */
+  selectedCount: (count: number) => string;
+  breadcrumbLabel: string;
+  chipsLabel: string;
+  removeChip: (label: string) => string;
+  /** Trail separator. Not every locale writes one with a slash. */
+  pathSeparator: string;
+  /** Names the root level wherever there is no parent node to name it. */
+  rootLevel: string;
+  itemCount: (count: number) => string;
+  /** Appended to a branch row's name outside tree mode: it opens another list. */
+  branchAffordance: string;
+  /** Columns-trail rows are plain buttons, so they carry no `aria-selected`. */
+  selectedState: string;
+  /** Same for the mixed state, which a `role="button"` row may not carry. */
+  partiallySelectedState: string;
+  columnsLabel: string;
+  actionsLabel: string;
+  submenuAffordance: string;
+  panelLabel: string;
+  /** Read per mode AND per direction: the level keys mirror in RTL. */
+  keyboardHint: (mode: CascaderMode, dir: "ltr" | "rtl") => string;
+  rootAnnouncement: (count: number) => string;
+  expandedAnnouncement: (label: string, count: number) => string;
+  collapsedAnnouncement: (label: string) => string;
+  levelAnnouncement: (parentLabel: string, depth: number, count: number) => string;
+  resultsAnnouncement: (count: number) => string;
+  maxReachedAnnouncement: (max: number) => string;
+  /** `count` is the descendants swept along; `selecting` is the direction. */
+  cascadeAnnouncement: (label: string, count: number, selecting: boolean) => string;
+  searchingAnnouncement: string;
+}

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

@@ -0,0 +1,18 @@
+import "./cascader-context.mjs";
+import * as React$1 from "react";
+import "@tanstack/react-virtual";
+export interface CascaderVirtualItemsProps {
+  /** Row height before measurement. Defaults to the root `estimateRowSize`. */
+  estimateSize?: number;
+  /** Rows rendered beyond each edge. Defaults to the root `overscan`. */
+  overscan?: number;
+}
+/**
+ * Windowed replacement for `CascaderItems`, dropped inside `CascaderList`. The
+ * registration is a LAYOUT effect because the root derives `virtualized` from
+ * it and the flip has to land before the browser paints. Until the root has
+ * seen it, this renders exactly what `CascaderItems` does, so no frame carries
+ * indexed rows while Base UI still owns the composite list.
+ */
+declare function CascaderVirtualItems(props: CascaderVirtualItemsProps): React$1.JSX.Element;
+export { CascaderVirtualItems };