@deftui/react 0.2.5 → 0.3.1

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

@@ -0,0 +1,445 @@
+"use client";
+import { useCascaderActions } from "./cascader-context.mjs";
+import { CASCADER_ACTION_CLASS, CascaderGroup, CascaderLabel } from "./cascader-item.mjs";
+import { CASCADER_LIST_PAD_CLASS, getCascaderFooterStops, isCascaderRtl } from "./cascader-lib.mjs";
+import { cn } from "cn";
+import * as React$1 from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { ChevronRightIcon } from "lucide-react";
+import { Popover } from "@base-ui/react";
+import { useDirection } from "@base-ui/react/direction-provider";
+// src/vendor/reui.io/cascader/cascader-footer.tsx
+/**
+* The pinned footer, and the side-anchored flyout a footer row can open. These
+* are COMMANDS: nothing here joins the selection, the filter set or the
+* highlight. The flyout is a Base UI `Popover` rendered as a REACT CHILD of
+* `Combobox.Popup` with its OWN `Portal` and NO `container`: a nested portal
+* resolves to the parent portal node, so it is a DOM sibling of the combobox
+* popup (not clipped, not `aria-hidden`) but a React descendant, which is what
+* the outside-press and focus-out whitelists read. `Combobox` builds no
+* `FloatingTree`, so the flyout is not consulted first and one Escape would
+* dismiss both; hence `CascaderSubmenu` registering with the root to turn one
+* Escape into two. `Combobox.List` clicks its highlighted row on Enter, hence
+* the footer sitting outside `CascaderList`. And a `Positioner` throws without
+* its `Portal`, while `modal` stays `false` on the `Root` so the combobox
+* keeps its own dismissal behaviour.
+*/
+/**
+* Keys the option list acts on, swallowed at the footer boundary. Escape and
+* Tab are absent on purpose: Escape must reach the root, Tab must keep moving.
+*/
+const FOOTER_SWALLOWED_KEYS = /* @__PURE__ */ new Set([
+	"Enter",
+	" ",
+	"ArrowUp",
+	"ArrowDown",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown"
+]);
+/**
+* Actions pinned below the list, a SIBLING of `CascaderList`. Children win
+* over the root's `actions` prop; with neither it renders nothing.
+*/
+function CascaderFooter({ className, children, onKeyDown, ...props }) {
+	const { actions, labels } = useCascaderActions();
+	const hasChildren = React$1.Children.count(children) > 0;
+	const handleKeyDown = React$1.useCallback((event) => {
+		onKeyDown?.(event);
+		if (event.defaultPrevented) return;
+		if (!FOOTER_SWALLOWED_KEYS.has(event.key)) return;
+		event.stopPropagation();
+		if (event.key !== "ArrowDown" && event.key !== "ArrowUp") return;
+		const footer = event.currentTarget;
+		const stops = getCascaderFooterStops(footer);
+		const active = document.activeElement;
+		const index = active ? stops.indexOf(active) : -1;
+		if (index === -1) return;
+		event.preventDefault();
+		const next = event.key === "ArrowDown" ? stops[index + 1] : stops[index - 1];
+		if (next) {
+			next.focus();
+			return;
+		}
+		if (event.key === "ArrowUp" && index > 0) return;
+		footer.closest("[data-slot=\"cascader-panel\"]")?.querySelector("[data-slot=\"cascader-input\"]")?.focus();
+	}, [onKeyDown]);
+	if (!hasChildren && actions.length === 0) return null;
+	return /* @__PURE__ */ jsx("div", {
+		"data-slot": "cascader-footer",
+		role: "group",
+		"aria-label": labels.actionsLabel,
+		onKeyDown: handleKeyDown,
+		className: cn("border-border/60 flex shrink-0 flex-col gap-0.5 border-t", CASCADER_LIST_PAD_CLASS, "p-(--cascader-list-pad,4px)", className),
+		...props,
+		children: hasChildren ? children : /* @__PURE__ */ jsx(CascaderFooterActions, { actions })
+	});
+}
+function CascaderFooterActions({ actions }) {
+	return /* @__PURE__ */ jsx(Fragment, { children: actions.map((action, i) => action.items?.length ? /* @__PURE__ */ jsxs(CascaderSubmenu, { children: [/* @__PURE__ */ jsx(CascaderSubmenuTrigger, {
+		icon: action.icon,
+		disabled: action.disabled,
+		children: action.label
+	}), /* @__PURE__ */ jsx(CascaderSubmenuContent, { children: /* @__PURE__ */ jsx(CascaderActionList, { items: action.items }) })] }, actionKey(action, i)) : /* @__PURE__ */ jsx(CascaderAction, {
+		icon: action.icon,
+		disabled: action.disabled,
+		onSelect: action.onSelect,
+		children: action.label
+	}, actionKey(action, i))) });
+}
+function actionKey(action, index) {
+	if (action.value != null) return action.value;
+	if (typeof action.label === "string") return action.label;
+	return String(index);
+}
+/**
+* Consecutive entries sharing a `group`, as runs not buckets: two separated
+* runs with the same name stay two, so the author's order survives.
+*/
+function groupActionRuns(items) {
+	const runs = [];
+	for (const item of items) {
+		const last = runs[runs.length - 1];
+		if (last && last.group === item.group) last.items.push(item);
+		else runs.push({
+			group: item.group,
+			items: [item]
+		});
+	}
+	return runs;
+}
+/**
+* Flyout body for a data-driven submenu. A named run becomes a real
+* `CascaderGroup`; unnamed runs stay unwrapped, as an unnamed group is noise.
+*/
+function CascaderActionList({ items }) {
+	const { close } = useCascaderSubmenu();
+	const runs = React$1.useMemo(() => groupActionRuns(items), [items]);
+	const renderAction = (item, i) => /* @__PURE__ */ jsx(CascaderAction, {
+		icon: item.icon,
+		disabled: item.disabled,
+		onSelect: () => {
+			item.onSelect?.();
+			close();
+		},
+		children: item.label
+	}, actionKey(item, i));
+	return /* @__PURE__ */ jsx(Fragment, { children: runs.map((run, runIndex) => run.group ? /* @__PURE__ */ jsxs(CascaderGroup, {
+		className: "gap-0.5",
+		children: [/* @__PURE__ */ jsx(CascaderLabel, { children: run.group }), run.items.map(renderAction)]
+	}, `${run.group}-${runIndex}`) : /* @__PURE__ */ jsx(React$1.Fragment, { children: run.items.map(renderAction) }, `run-${runIndex}`)) });
+}
+/**
+* The cascader popup's panel per style, spelled with `style-<name>:` variants
+* rather than ReUI theme CSS so an installed footer needs only Tailwind.
+*/
+const FLYOUT_SURFACE_CLASS = "bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 max-h-72 overflow-hidden ring-1 duration-100 ring-foreground/10 rounded-md shadow-md";
+/**
+* One footer command, shaped like a row and deliberately NOT one. A real
+* `<button>`, never a `Combobox.Item`: an item would join the arrow-key ring,
+* appear in `filteredItems`, and vanish the moment a query matched nothing -
+* exactly when "Create new attribute" is most useful. Disabled is
+* `aria-disabled`, never the native attribute: that one is not a tab stop and
+* the panel's Tab order reads `button:not([disabled])`, so a footer whose ONLY
+* row is a disabled command had no stop after the search field (measured on
+* `c-cascader-8`). Staying focusable costs the guards below, plus the
+* greyed-out look: `CASCADER_ACTION_CLASS` keys that off `aria-disabled`
+* instead of `:disabled`.
+*/
+function CascaderAction({ className, icon, children, onSelect, onClick, onKeyDown, disabled, ...props }) {
+	const inMenu = React$1.useContext(CascaderMenuContext);
+	const handleClick = React$1.useCallback((event) => {
+		if (disabled) {
+			event.preventDefault();
+			return;
+		}
+		onClick?.(event);
+		if (event.defaultPrevented) return;
+		onSelect?.();
+	}, [
+		disabled,
+		onClick,
+		onSelect
+	]);
+	const handleKeyDown = React$1.useCallback((event) => {
+		if (disabled) {
+			if (event.key === "Enter" || event.key === " ") event.preventDefault();
+			return;
+		}
+		onKeyDown?.(event);
+	}, [disabled, onKeyDown]);
+	return /* @__PURE__ */ jsxs("button", {
+		type: "button",
+		"data-slot": "cascader-action",
+		...disabled ? {
+			"aria-disabled": true,
+			"data-disabled": ""
+		} : null,
+		onClick: handleClick,
+		onKeyDown: handleKeyDown,
+		...inMenu ? {
+			role: "menuitem",
+			tabIndex: -1
+		} : null,
+		className: cn(CASCADER_ACTION_CLASS, className),
+		...props,
+		children: [icon ? /* @__PURE__ */ jsx("span", {
+			"data-slot": "cascader-action-icon",
+			className: "text-muted-foreground flex shrink-0 items-center justify-center",
+			children: icon
+		}) : null, /* @__PURE__ */ jsx("span", {
+			className: "min-w-0 flex-1 truncate text-start",
+			children
+		})]
+	});
+}
+/** Marks the subtree INSIDE a flyout. See `inMenu` in `CascaderAction`. */
+const CascaderMenuContext = React$1.createContext(false);
+/**
+* Every entry a menu's roving focus may land on, in DOM order, read from the
+* DOM because the entries are whatever the consumer composed. A disabled
+* `CascaderAction` is INCLUDED: it carries `aria-disabled`, not the native
+* attribute, so `:not([disabled])` excludes only a consumer's own natively
+* disabled `menuitem`, which cannot take focus.
+*/
+function menuItems(popup) {
+	if (!popup) return [];
+	return Array.from(popup.querySelectorAll("[role=\"menuitem\"]:not([disabled])"));
+}
+const CascaderSubmenuContext = React$1.createContext(void 0);
+/** The flyout's own state. `close()` is the one a custom entry usually wants. */
+function useCascaderSubmenu() {
+	const context = React$1.useContext(CascaderSubmenuContext);
+	if (!context) throw new Error("useCascaderSubmenu must be used within a CascaderSubmenu");
+	return context;
+}
+/**
+* A footer row plus the flyout it opens. Registers with the cascader root
+* while open, which turns one Escape into two. Cleared in an EFFECT, so the
+* flyout still reads as open during the event that closed it.
+*/
+function CascaderSubmenu({ open: openProp, defaultOpen = false, onOpenChange, children }) {
+	const { setFlyoutOpen } = useCascaderActions();
+	const key = React$1.useId();
+	const triggerId = React$1.useId();
+	const rowRef = React$1.useRef(null);
+	const keyboardRef = React$1.useRef(false);
+	const [uncontrolled, setUncontrolled] = React$1.useState(defaultOpen);
+	const open = openProp ?? uncontrolled;
+	const setOpen = React$1.useCallback((next) => {
+		if (openProp == null) setUncontrolled(next);
+		onOpenChange?.(next);
+	}, [openProp, onOpenChange]);
+	const close = React$1.useCallback(() => setOpen(false), [setOpen]);
+	React$1.useEffect(() => {
+		setFlyoutOpen(key, open);
+		return () => setFlyoutOpen(key, false);
+	}, [
+		setFlyoutOpen,
+		key,
+		open
+	]);
+	const context = React$1.useMemo(() => ({
+		rowRef,
+		open,
+		setOpen,
+		close,
+		triggerId,
+		keyboardRef
+	}), [
+		open,
+		setOpen,
+		close,
+		triggerId
+	]);
+	return /* @__PURE__ */ jsx(CascaderSubmenuContext.Provider, {
+		value: context,
+		children: /* @__PURE__ */ jsx(Popover.Root, {
+			open,
+			onOpenChange: setOpen,
+			modal: false,
+			children
+		})
+	});
+}
+/**
+* The footer row that opens the flyout, and its anchor. `aria-haspopup="menu"`
+* rather than the `dialog` Base UI would announce: what opens is a list of
+* commands with roving focus. `disabled` is intercepted, not forwarded:
+* `Popover.Trigger` runs it through `useButton`, which writes the NATIVE
+* attribute for a native `<button>` and takes the row out of the panel's Tab
+* ring, the defect `CascaderAction` documents, and this component exposes no
+* `focusableWhenDisabled` to opt out. Published as `aria-disabled`, with the
+* arrow keys, Enter and Space, and the click closed by hand (`useClick`
+* ignores `defaultPrevented`).
+*/
+function CascaderSubmenuTrigger({ className, icon, children, onKeyDown, onClick, disabled, ...props }) {
+	const { labels } = useCascaderActions();
+	const { rowRef, setOpen, triggerId, keyboardRef } = useCascaderSubmenu();
+	const direction = useDirection();
+	const handleClick = React$1.useCallback((event) => {
+		if (disabled) {
+			event.preventDefault();
+			event.preventBaseUIHandler();
+			return;
+		}
+		onClick?.(event);
+	}, [disabled, onClick]);
+	const handleKeyDown = React$1.useCallback((event) => {
+		if (disabled) {
+			if (event.key === "Enter" || event.key === " ") event.preventDefault();
+			return;
+		}
+		onKeyDown?.(event);
+		if (event.defaultPrevented) return;
+		const openKey = isCascaderRtl(event.currentTarget, direction) ? "ArrowLeft" : "ArrowRight";
+		if (event.key === "Enter" || event.key === " ") {
+			keyboardRef.current = true;
+			return;
+		}
+		if (event.key !== openKey) return;
+		event.preventDefault();
+		keyboardRef.current = true;
+		setOpen(true);
+	}, [
+		disabled,
+		onKeyDown,
+		direction,
+		setOpen,
+		keyboardRef
+	]);
+	return /* @__PURE__ */ jsxs(Popover.Trigger, {
+		ref: rowRef,
+		id: triggerId,
+		"data-slot": "cascader-submenu-trigger",
+		"aria-haspopup": "menu",
+		...disabled ? {
+			"aria-disabled": true,
+			"data-disabled": ""
+		} : null,
+		onClick: handleClick,
+		onKeyDown: handleKeyDown,
+		className: cn(CASCADER_ACTION_CLASS, "aria-expanded:bg-accent aria-expanded:text-accent-foreground", className),
+		...props,
+		children: [
+			icon ? /* @__PURE__ */ jsx("span", {
+				"data-slot": "cascader-action-icon",
+				className: "text-muted-foreground flex shrink-0 items-center justify-center",
+				children: icon
+			}) : null,
+			/* @__PURE__ */ jsx("span", {
+				className: "min-w-0 flex-1 truncate text-start",
+				children
+			}),
+			/* @__PURE__ */ jsxs("span", {
+				className: "sr-only",
+				children: [", ", labels.submenuAffordance]
+			}),
+			/* @__PURE__ */ jsx(ChevronRightIcon, {
+				"aria-hidden": "true",
+				className: "text-muted-foreground -me-0.5 size-4 shrink-0 rtl:-scale-x-100"
+			})
+		]
+	});
+}
+/**
+* The flyout itself. `Portal` with NO `container`: a nested portal resolves to
+* the parent portal node, the mechanism the file header describes.
+*/
+function CascaderSubmenuContent({ className, children, onKeyDown, side = "inline-end", align = "end", sideOffset = 8, alignOffset = 0, ...props }) {
+	const { rowRef, close, triggerId, keyboardRef } = useCascaderSubmenu();
+	const direction = useDirection();
+	const popupRef = React$1.useRef(null);
+	const typeaheadRef = React$1.useRef({
+		buffer: "",
+		at: 0
+	});
+	/**
+	* Keyboard opens land on the first entry; a pointer open falls through to
+	* Base UI's default, the popup, so a click paints no focus ring. Not an
+	* effect of our own: Base UI's focus manager runs on open and wins the race.
+	*/
+	const initialFocus = React$1.useCallback(() => {
+		const byKeyboard = keyboardRef.current;
+		keyboardRef.current = false;
+		if (!byKeyboard) return true;
+		return menuItems(popupRef.current)[0] ?? true;
+	}, [keyboardRef]);
+	const closeAndReturn = React$1.useCallback(() => {
+		close();
+		rowRef.current?.focus();
+	}, [close, rowRef]);
+	const handleKeyDown = React$1.useCallback((event) => {
+		onKeyDown?.(event);
+		event.stopPropagation();
+		if (event.defaultPrevented) return;
+		const popup = popupRef.current;
+		const items = menuItems(popup);
+		if (items.length === 0) return;
+		const active = document.activeElement;
+		const index = active ? items.indexOf(active) : -1;
+		const move = (next) => {
+			event.preventDefault();
+			items[(next + items.length) % items.length]?.focus();
+		};
+		const closeKey = isCascaderRtl(event.currentTarget, direction) ? "ArrowRight" : "ArrowLeft";
+		switch (event.key) {
+			case "ArrowDown": return move(index + 1);
+			case "ArrowUp": return move(index === -1 ? items.length - 1 : index - 1);
+			case "Home": return move(0);
+			case "End": return move(items.length - 1);
+			case closeKey:
+				event.preventDefault();
+				return closeAndReturn();
+			case "Tab":
+				close();
+				rowRef.current?.focus();
+				return;
+		}
+		if (event.key.length !== 1 || event.metaKey || event.ctrlKey || event.altKey) return;
+		const now = event.timeStamp;
+		const state = typeaheadRef.current;
+		state.buffer = now - state.at > 500 ? event.key : state.buffer + event.key;
+		state.at = now;
+		const prefix = state.buffer.toLowerCase();
+		const from = index === -1 ? 0 : index;
+		const hit = [...items.slice(state.buffer.length > 1 ? from : from + 1), ...items.slice(0, state.buffer.length > 1 ? from : from + 1)].find((item) => (item.textContent ?? "").trim().toLowerCase().startsWith(prefix));
+		if (hit) {
+			event.preventDefault();
+			hit.focus();
+		}
+	}, [
+		onKeyDown,
+		direction,
+		close,
+		closeAndReturn,
+		rowRef
+	]);
+	return /* @__PURE__ */ jsx(Popover.Portal, { children: /* @__PURE__ */ jsx(Popover.Positioner, {
+		anchor: rowRef,
+		side,
+		align,
+		sideOffset,
+		alignOffset,
+		className: "isolate z-50",
+		children: /* @__PURE__ */ jsx(Popover.Popup, {
+			ref: popupRef,
+			initialFocus,
+			"data-slot": "cascader-submenu-content",
+			role: "menu",
+			"aria-orientation": "vertical",
+			"aria-labelledby": triggerId,
+			tabIndex: -1,
+			onKeyDown: handleKeyDown,
+			"data-menu-target": "",
+			className: cn(FLYOUT_SURFACE_CLASS, "flex max-w-(--available-width) min-w-48 flex-col gap-0.5 outline-hidden", CASCADER_LIST_PAD_CLASS, "p-(--cascader-list-pad,4px)", className),
+			...props,
+			children: /* @__PURE__ */ jsx(CascaderMenuContext.Provider, {
+				value: true,
+				children
+			})
+		})
+	}) });
+}
+export { CascaderAction, CascaderFooter, CascaderSubmenu, CascaderSubmenuContent, CascaderSubmenuTrigger, useCascaderSubmenu };

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

@@ -0,0 +1,64 @@
+// src/vendor/reui.io/cascader/cascader-i18n.tsx
+/** Name of the root level. Hoisted so the root announcement can reuse it. */
+const ROOT_LEVEL = "Top level";
+/** Hoisted for the same reason: several defaults end in an item count. */
+const itemCount = (count) => `${count} ${count === 1 ? "item" : "items"}`;
+/**
+* English defaults. Every string the primitive can render lives here, so a
+* consumer can translate the whole surface by passing `labels`.
+*/
+const CASCADER_LABELS = {
+	search: (parentLabel) => parentLabel ? `Search ${parentLabel}...` : "Search...",
+	back: "Back",
+	loading: "Loading...",
+	loadingMore: "Loading more...",
+	loadMore: "Load more",
+	error: "Could not load items.",
+	retry: "Retry",
+	empty: "No results found.",
+	selectedCount: (count) => `${count} selected`,
+	breadcrumbLabel: "Breadcrumb",
+	chipsLabel: "Selected items",
+	removeChip: (label) => `Remove ${label}`,
+	pathSeparator: "/",
+	rootLevel: ROOT_LEVEL,
+	itemCount,
+	branchAffordance: "submenu",
+	selectedState: "selected",
+	partiallySelectedState: "partially selected",
+	columnsLabel: "Levels",
+	actionsLabel: "Actions",
+	submenuAffordance: "opens a menu",
+	panelLabel: "Options",
+	keyboardHint: (mode, dir) => {
+		const open = dir === "rtl" ? "Left" : "Right";
+		const back = dir === "rtl" ? "Right" : "Left";
+		if (mode === "tree") return `Use the ${open} Arrow key to expand and the ${back} Arrow key to collapse.`;
+		if (mode === "columns") return `Use the ${open} Arrow key to open the next column and the ${back} Arrow key to go back.`;
+		return `Use the ${open} Arrow key to open a branch and the ${back} Arrow key to go back.`;
+	},
+	rootAnnouncement: (count) => `${ROOT_LEVEL}, ${itemCount(count)}`,
+	expandedAnnouncement: (label, count) => `${label} expanded, ${itemCount(count)}`,
+	collapsedAnnouncement: (label) => `${label} collapsed`,
+	levelAnnouncement: (parentLabel, depth, count) => `${parentLabel}, level ${depth}, ${itemCount(count)}`,
+	resultsAnnouncement: (count) => count === 1 ? "1 result" : `${count} results`,
+	maxReachedAnnouncement: (max) => `Selection limit of ${max} reached`,
+	cascadeAnnouncement: (label, count, selecting) => `${label} ${selecting ? "selected" : "deselected"}, ${itemCount(count)} followed`,
+	searchingAnnouncement: "Searching..."
+};
+/**
+* Shallow-merges consumer overrides over the defaults, so `labels` can carry a
+* single key without restating the rest.
+*/
+function resolveCascaderLabels(labels) {
+	if (!labels) return CASCADER_LABELS;
+	return {
+		...CASCADER_LABELS,
+		...labels
+	};
+}
+/** Resolves the search placeholder, which may be a string or a function. */
+function resolveCascaderSearchLabel(labels, parentLabel) {
+	return typeof labels.search === "function" ? labels.search(parentLabel) : labels.search;
+}
+export { CASCADER_LABELS, resolveCascaderLabels, resolveCascaderSearchLabel };

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

@@ -0,0 +1,92 @@
+import { CascaderNode } from "./cascader-types.mjs";
+import * as React$1 from "react";
+import { Combobox } from "@base-ui/react";
+type VetoableEvent = {
+  preventBaseUIHandler?: () => void;
+};
+/** A row press. The veto hook is optional: an `as="button"` row is outside Base
+ *  UI's listbox and gets a plain React event. */
+export type CascaderRowEvent = React$1.MouseEvent<HTMLElement> & VetoableEvent;
+export interface CascaderItemProps extends Omit<Combobox.Item.Props, "value" | "children" | "className" | "style" | "onClick" | "onMouseUp"> {
+  /** No state callback: the row merges `className` and `style` itself. */
+  className?: string;
+  style?: React$1.CSSProperties;
+  onClick?: (event: CascaderRowEvent) => void;
+  onMouseUp?: (event: CascaderRowEvent) => void;
+  node: CascaderNode;
+  /** Explicit render index. Required while virtualized and DELIBERATELY IGNORED
+   *  otherwise: it self-registers the row and breaks `aria-activedescendant`. */
+  index?: number;
+  /** Indentation depth. Drives `--cascader-indent` in tree mode. */
+  depth?: number;
+  /** Renders the ancestor chain under the label, for deep and global search. */
+  showPath?: boolean;
+  /** `option` renders a real `Combobox.Item`; `button` renders identical markup
+   *  outside the listbox, for the ancestor columns in columns mode. */
+  as?: "option" | "button";
+  /** Tree mode: this row is an expanded branch. */
+  expanded?: boolean;
+  /** Indent each depth by this many pixels. Tree mode only. */
+  indent?: number;
+  /** Whether the node has children. Defaults to the cascader's own answer, as do
+   *  the three below: callers pass them because they already hold the level,
+   *  which keeps a memoised row off the volatile context. */
+  branch?: boolean;
+  /** Whether the node may be committed. Defaults to the cascader's own answer. */
+  selectable?: boolean;
+  /** Whether the node is currently selected. Defaults to the cascader's answer. */
+  selected?: boolean;
+  /** Some but not all of the loaded subtree selected. `cascade` only. */
+  indeterminate?: boolean;
+  /** Selected nodes below this one, at any depth. Drives the trailing count. */
+  selectedCount?: number;
+  /** Paging row only: a request for this level is in flight. */
+  loading?: boolean;
+  /** Paging row only: this level's last request failed. */
+  error?: boolean;
+  /** Branch row only: this node's OWN children are being fetched. The chevron
+   *  (or, in tree mode, the expander) becomes a spinner IN PLACE, in the same
+   *  16px box: no skeleton row appears below, nothing reflows. */
+  childrenLoading?: boolean;
+  /** Branch row only: the last fetch of this node's children failed. The same
+   *  box becomes the retry. The press path is unchanged: it goes through
+   *  `navigate`, which refires the failed level rather than moving. */
+  childrenError?: boolean;
+  children?: React$1.ReactNode;
+}
+export interface CascaderItemsProps {
+  /** Replaces the default row for every item. */
+  children?: (node: CascaderNode, index: number) => React$1.ReactNode;
+}
+/** Whatever the active view is: the current level, the deepest column, or the
+ *  flattened tree rows. Lives here so `cascader.tsx` never imports a row
+ *  component, which would cycle with the context. `index` is deliberately not
+ *  passed; see `CascaderItemProps`. */
+declare function CascaderItems({ children }: CascaderItemsProps): React$1.JSX.Element;
+export interface CascaderGroupProps extends Omit<Combobox.Group.Props, "className"> {
+  /** Base UI also accepts a state callback here; the group has no state. */
+  className?: string;
+}
+/** A run of related rows, named by the `CascaderLabel` inside it: the group is
+ *  `role="group"` and Base UI points its `aria-labelledby` at the label, where a
+ *  heading alone inside a listbox is dropped from the accessibility tree.
+ *  Grouping is composition, not data: `CascaderItems` renders one flat run per
+ *  level, so its indices line up with `listRef`. */
+declare function CascaderGroup({ className, ...props }: CascaderGroupProps): React$1.JSX.Element;
+export interface CascaderLabelProps extends Omit<Combobox.GroupLabel.Props, "className" | "style"> {
+  /** No state callback; outside a group this is not a Base UI part at all. */
+  className?: string;
+  style?: React$1.CSSProperties;
+}
+/** A heading. Inside `CascaderGroup` it is the group's accessible name; outside
+ *  one (the footer flyout is a menu, not a listbox) it is decoration only. */
+declare function CascaderLabel(props: CascaderLabelProps): React$1.JSX.Element;
+export interface CascaderSeparatorProps extends Omit<Combobox.Separator.Props, "className"> {
+  /** Base UI also accepts a state callback here; only the orientation varies. */
+  className?: string;
+}
+/** Decorative on purpose: Base UI's separator is `role="separator"`, which a
+ *  `listbox` may not own, and a run that needs separating for a screen reader
+ *  needs a `CascaderGroup`, not a line. A consumer can pass the role back. */
+declare function CascaderSeparator({ className, ...props }: CascaderSeparatorProps): React$1.JSX.Element;
+export { CascaderGroup, CascaderItems, CascaderLabel, CascaderSeparator };