@deftui/react 0.2.5 → 0.3.1

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>[];
+}

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

@@ -0,0 +1,56 @@
+"use client";
+import * as React$1 from "react";
+// src/vendor/reui.io/cascader/cascader-context.tsx
+const CascaderStateContext = React$1.createContext(void 0);
+/**
+* One provider serves every `T`, so the context holds an erased `unknown` value
+* and this cast restores it. The primitive never inspects the payload.
+*/
+function useCascaderState() {
+	const context = React$1.useContext(CascaderStateContext);
+	if (!context) throw new Error("useCascaderState must be used within a Cascader");
+	return context;
+}
+const CascaderActionsContext = React$1.createContext(void 0);
+function useCascaderActions() {
+	const context = React$1.useContext(CascaderActionsContext);
+	if (!context) throw new Error("useCascaderActions must be used within a Cascader");
+	return context;
+}
+const CascaderRenderContext = React$1.createContext({});
+function useCascaderRender() {
+	return React$1.useContext(CascaderRenderContext);
+}
+const NO_HIGHLIGHT = {
+	index: -1,
+	value: null
+};
+function createCascaderHighlightStore() {
+	let snapshot = NO_HIGHLIGHT;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		subscribe(onStoreChange) {
+			listeners.add(onStoreChange);
+			return () => {
+				listeners.delete(onStoreChange);
+			};
+		},
+		getSnapshot() {
+			return snapshot;
+		},
+		set(next) {
+			if (next.index === snapshot.index && next.value === snapshot.value) return;
+			snapshot = next;
+			for (const listener of listeners) listener();
+		}
+	};
+}
+/** Shared and permanently empty, so the hook degrades outside a `Cascader`. */
+const FALLBACK_HIGHLIGHT_STORE = createCascaderHighlightStore();
+const CascaderHighlightContext = React$1.createContext(FALLBACK_HIGHLIGHT_STORE);
+/** Subscribes to the highlight. Re-renders ONLY the calling component. */
+function useCascaderHighlight() {
+	const store = React$1.useContext(CascaderHighlightContext);
+	return React$1.useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+}
+export { CascaderActionsContext, CascaderHighlightContext, CascaderRenderContext, CascaderStateContext, createCascaderHighlightStore, useCascaderActions, useCascaderHighlight, useCascaderRender, useCascaderState };

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

@@ -0,0 +1,60 @@
+import * as React$1 from "react";
+import { Popover } from "@base-ui/react";
+export type CascaderFooterProps = React$1.ComponentProps<"div">;
+/**
+ * Actions pinned below the list, a SIBLING of `CascaderList`. Children win
+ * over the root's `actions` prop; with neither it renders nothing.
+ */
+declare function CascaderFooter({ className, children, onKeyDown, ...props }: CascaderFooterProps): React$1.JSX.Element | null;
+export interface CascaderActionProps extends Omit<React$1.ComponentProps<"button">, "onSelect"> {
+  icon?: React$1.ReactNode;
+  /** Fires on press, after `onClick`, and not at all when disabled. */
+  onSelect?: () => void;
+}
+/**
+ * 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`.
+ */
+declare function CascaderAction({ className, icon, children, onSelect, onClick, onKeyDown, disabled, ...props }: CascaderActionProps): React$1.JSX.Element;
+export interface CascaderSubmenuProps {
+  open?: boolean;
+  defaultOpen?: boolean;
+  onOpenChange?: (open: boolean) => void;
+  children?: React$1.ReactNode;
+}
+/**
+ * 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.
+ */
+declare function CascaderSubmenu({ open: openProp, defaultOpen, onOpenChange, children }: CascaderSubmenuProps): React$1.JSX.Element;
+export interface CascaderSubmenuTriggerProps extends Omit<React$1.ComponentProps<"button">, "onSelect"> {
+  icon?: React$1.ReactNode;
+}
+/**
+ * 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`).
+ */
+declare function CascaderSubmenuTrigger({ className, icon, children, onKeyDown, onClick, disabled, ...props }: CascaderSubmenuTriggerProps): React$1.JSX.Element;
+export interface CascaderSubmenuContentProps extends Popover.Popup.Props, Pick<Popover.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset"> {}
+/**
+ * The flyout itself. `Portal` with NO `container`: a nested portal resolves to
+ * the parent portal node, the mechanism the file header describes.
+ */
+declare function CascaderSubmenuContent({ className, children, onKeyDown, side, align, sideOffset, alignOffset, ...props }: CascaderSubmenuContentProps): React$1.JSX.Element;
+export { CascaderAction, CascaderFooter, CascaderSubmenu, CascaderSubmenuContent, CascaderSubmenuTrigger };