@deftui/react 0.2.5 → 0.3.1

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

@@ -0,0 +1,688 @@
+// src/vendor/reui.io/cascader/cascader-lib.tsx
+/** Root level key in `childrenOf`. NUL-prefixed so no real value collides. */
+const CASCADER_ROOT_KEY = "\0root";
+/**
+* Paging pseudo-node prefix. Written as an escape sequence, not a raw 0x00
+* byte: a literal NUL makes this module read as binary and `grep -I` skips it.
+*/
+const CASCADER_MORE_PREFIX = "\0more:";
+/**
+* The four scroll classes. In the lib because `cascader-columns.tsx` needs them
+* too and must not import `cascader.tsx`. Shell > bound > scrollport > rows.
+*/
+/**
+* The bound. `min()` over an undefined custom property is an INVALID
+* declaration that drops the whole max-height, hence the `100vh` fallback: an
+* inline panel has no positioner, so no `--available-height`. `24rem` is the
+* default cap, so the common case sets no variable at all.
+*/
+const CASCADER_LIST_HEIGHT_CLASS = "max-h-[min(var(--available-height,100vh),var(--cascader-max-height,24rem))]";
+/**
+* Each style's list padding: rows take it as `padding`, the scrollport as
+* `scroll-padding` floored at 4px so lyra's `0` does not strand a row.
+* Mirrored per style from `registry/styles/style-*.css`; keep them in step.
+*/
+const CASCADER_LIST_PAD_CLASS = "[--cascader-list-pad:4px]";
+/** The scrollport: a `max-h-*` on the ScrollArea ROOT bounds nothing. */
+const CASCADER_SCROLL_CLASS = "size-full min-h-0 **:data-[slot=scroll-area-viewport]:h-full **:data-[slot=scroll-area-viewport]:overscroll-contain **:data-[slot=scroll-area-viewport]:scroll-py-[max(var(--cascader-list-pad,4px),4px)]";
+/** The rows' box; `data-empty:p-0` keeps an empty state from double inset. */
+const CASCADER_ROWS_CLASS = "p-(--cascader-list-pad,4px) data-empty:p-0";
+/**
+* What counts as a keyboard stop. Base UI's ScrollArea viewport makes ITSELF
+* tabbable when content overflows (`hiddenState.x && hiddenState.y ? -1 : 0`),
+* an unnamed stop per level that `ui/scroll-area.tsx` will not let us suppress.
+*/
+const CASCADER_TAB_STOP_SELECTOR = "a[href],button:not([disabled]),input:not([disabled]),select:not([disabled]),textarea:not([disabled]),[tabindex]:not([tabindex=\"-1\"])";
+/** The stop to step over: nothing here focuses the scrollport on purpose. */
+const CASCADER_TAB_SKIP_SELECTOR = "[data-slot=\"scroll-area-viewport\"]";
+/** Out of the tab order whatever they contain; layout is never consulted. */
+const CASCADER_TAB_HIDDEN_SELECTOR = "[hidden],[inert],[aria-hidden='true']";
+/** The panel's real keyboard stops, in DOM order. */
+function getCascaderTabStops(panel) {
+	return Array.from(panel.querySelectorAll(CASCADER_TAB_STOP_SELECTOR)).filter((stop) => stop.getAttribute("tabindex") !== "-1" && !stop.matches(CASCADER_TAB_SKIP_SELECTOR) && !stop.closest(CASCADER_TAB_HIDDEN_SELECTOR));
+}
+/** The footer's own stops; an `aria-disabled` command still counts as one. */
+function getCascaderFooterStops(scope) {
+	const footer = scope.matches("[data-slot=\"cascader-footer\"]") ? scope : scope.querySelector("[data-slot=\"cascader-footer\"]");
+	if (!footer) return [];
+	return getCascaderTabStops(footer);
+}
+/**
+* Hands focus to the panel's search field, or the popup without one. A Retry
+* button is replaced by the loading state as the retry starts, and a focused
+* node that unmounts drops focus to the body.
+*/
+function focusCascaderHome(from) {
+	const panel = from.closest("[data-slot=\"cascader-panel\"]");
+	const home = panel?.querySelector("[data-slot=\"cascader-input\"]") ?? from.closest("[data-slot=\"cascader-content\"]") ?? panel;
+	if (home && home === panel && !home.hasAttribute("tabindex")) home.setAttribute("tabindex", "-1");
+	home?.focus();
+}
+/** Where Tab lands, or `null` to let the browser out: focus is never trapped. */
+function getCascaderTabTarget(panel, from, backwards) {
+	const stops = getCascaderTabStops(panel);
+	if (stops.length === 0 || !from) return null;
+	const index = stops.indexOf(from);
+	if (index !== -1) return stops[index + (backwards ? -1 : 1)] ?? null;
+	if (backwards) {
+		for (let i = stops.length - 1; i >= 0; i -= 1) if (from.compareDocumentPosition(stops[i]) & Node.DOCUMENT_POSITION_PRECEDING) return stops[i];
+		return null;
+	}
+	for (const stop of stops) if (from.compareDocumentPosition(stop) & Node.DOCUMENT_POSITION_FOLLOWING) return stop;
+	return null;
+}
+/**
+* The writing direction at `element`. `DirectionProvider` may only vote yes:
+* unmounted it answers `"ltr"`, which would override a real `<html dir="rtl">`.
+*/
+function isCascaderRtl(element, provided) {
+	if (provided === "rtl") return true;
+	const explicit = element.closest("[dir]")?.getAttribute("dir")?.toLowerCase();
+	if (explicit === "rtl") return true;
+	if (explicit === "ltr") return false;
+	return element.ownerDocument?.defaultView?.getComputedStyle(element).direction === "rtl";
+}
+/**
+* The paging row as a REAL node, not a DOM-only row after the list: every index
+* Base UI hands out indexes the RENDERED array, so a DOM-only row shifts them.
+*/
+function createCascaderMoreNode(parentKey, loadedCount = 0) {
+	return {
+		value: `${CASCADER_MORE_PREFIX}${parentKey}`,
+		label: "",
+		count: loadedCount
+	};
+}
+function isCascaderMoreNode(node) {
+	return node.value.startsWith(CASCADER_MORE_PREFIX);
+}
+/** The level key a paging pseudo-node belongs to, or `null` for a real node. */
+function getCascaderMoreParent(node) {
+	if (!isCascaderMoreNode(node)) return null;
+	return node.value.slice(6);
+}
+/** Either input shape into one index. Cycle-guarded depths; first wins. */
+function buildCascaderIndex(items, getParent) {
+	const byValue = /* @__PURE__ */ new Map();
+	const childrenOf = /* @__PURE__ */ new Map();
+	const parentOf = /* @__PURE__ */ new Map();
+	const depthOf = /* @__PURE__ */ new Map();
+	const all = [];
+	const push = (parentKey, node) => {
+		const bucket = childrenOf.get(parentKey);
+		if (bucket) bucket.push(node);
+		else childrenOf.set(parentKey, [node]);
+	};
+	if (getParent) {
+		for (const node of items ?? []) {
+			if (node == null) {
+				if (process.env.NODE_ENV !== "production") warnCascaderOnce("nullish-entry", "Ignored a null or undefined entry in `items` or `children`. Check the arrays you pass in.");
+				continue;
+			}
+			if (byValue.has(node.value)) continue;
+			byValue.set(node.value, node);
+			all.push(node);
+		}
+		for (const node of all) {
+			const rawParent = getParent(node);
+			const parent = rawParent != null && byValue.has(rawParent) ? rawParent : null;
+			parentOf.set(node.value, parent);
+			push(parent ?? "\0root", node);
+		}
+		for (const node of all) {
+			let depth = 0;
+			let cursor = parentOf.get(node.value) ?? null;
+			const seen = /* @__PURE__ */ new Set([node.value]);
+			while (cursor != null && !seen.has(cursor)) {
+				seen.add(cursor);
+				depth += 1;
+				cursor = parentOf.get(cursor) ?? null;
+			}
+			depthOf.set(node.value, depth);
+		}
+	} else {
+		const walk = (nodes, parent, depth) => {
+			for (const node of nodes ?? []) {
+				if (node == null) {
+					if (process.env.NODE_ENV !== "production") warnCascaderOnce("nullish-entry", "Ignored a null or undefined entry in `items` or `children`. Check the arrays you pass in.");
+					continue;
+				}
+				if (byValue.has(node.value)) continue;
+				byValue.set(node.value, node);
+				parentOf.set(node.value, parent);
+				depthOf.set(node.value, depth);
+				all.push(node);
+				push(parent ?? "\0root", node);
+				if (node.children?.length) walk(node.children, node.value, depth + 1);
+			}
+		};
+		walk(items, null, 0);
+	}
+	return {
+		byValue,
+		childrenOf,
+		parentOf,
+		depthOf,
+		roots: childrenOf.get("\0root") ?? [],
+		all
+	};
+}
+/** One branch-flagged copy per node, so a re-merge keeps row identity. */
+const BRANCH_COPIES = /* @__PURE__ */ new WeakMap();
+function asCascaderBranch(node) {
+	if (node.hasChildren) return node;
+	let copy = BRANCH_COPIES.get(node);
+	if (!copy) {
+		copy = {
+			...node,
+			hasChildren: true
+		};
+		BRANCH_COPIES.set(node, copy);
+	}
+	return copy;
+}
+/**
+* Folds loaded pages into an index built from `items`, so a re-render with a
+* new `items` array keeps what the user drilled into. Static `items` wins;
+* `detached` is `byValue` ONLY, or deep search doubles it and `childrenOf` lies.
+*
+* A resolved chain node in `links` that no page placed still gets its parent,
+* so the trigger keeps its path. While its parent's level is unloaded it is
+* searchable but no row; while that level has pages left (`paging`) it is
+* LISTED, last, and in `pinned`; once the level loaded completely without it
+* (moved, deleted) it is `hidden`: no row, hit or cascade child. A node some
+* link names as a parent reads as a branch, whatever chain wrote it last.
+*/
+function mergeCascaderIndex(base, pages, detached, links, paging) {
+	if (pages.size === 0 && !detached?.size) return base;
+	const byValue = new Map(base.byValue);
+	const childrenOf = new Map(base.childrenOf);
+	const parentOf = new Map(base.parentOf);
+	const depthOf = new Map(base.depthOf);
+	const copied = /* @__PURE__ */ new Set();
+	const append = (parentKey, node) => {
+		let bucket = childrenOf.get(parentKey);
+		if (!copied.has(parentKey)) {
+			bucket = bucket ? bucket.slice() : [];
+			childrenOf.set(parentKey, bucket);
+			copied.add(parentKey);
+		}
+		bucket.push(node);
+	};
+	const insert = (parentKey, nodes) => {
+		for (const node of nodes) {
+			if (byValue.has(node.value)) continue;
+			byValue.set(node.value, node);
+			parentOf.set(node.value, parentKey === "\0root" ? null : parentKey);
+			append(parentKey, node);
+			if (node.children?.length) insert(node.value, node.children);
+		}
+	};
+	for (const [parentKey, nodes] of pages) insert(parentKey, nodes);
+	const pinned = /* @__PURE__ */ new Set();
+	const hidden = /* @__PURE__ */ new Set();
+	const linkParents = new Set(links?.values());
+	for (const [value, parentKey] of links ?? []) {
+		const linked = detached?.get(value);
+		if (!linked || byValue.has(value)) continue;
+		const node = linkParents.has(value) ? asCascaderBranch(linked) : linked;
+		byValue.set(value, node);
+		parentOf.set(value, parentKey === "\0root" ? null : parentKey);
+		if (paging?.has(parentKey)) {
+			append(parentKey, node);
+			pinned.add(value);
+		} else if (pages.has(parentKey) || base.childrenOf.has(parentKey)) hidden.add(value);
+	}
+	for (const value of byValue.keys()) {
+		if (depthOf.has(value)) continue;
+		let depth = 0;
+		let cursor = parentOf.get(value) ?? null;
+		const seen = /* @__PURE__ */ new Set([value]);
+		while (cursor != null && !seen.has(cursor)) {
+			seen.add(cursor);
+			depth += 1;
+			cursor = parentOf.get(cursor) ?? null;
+		}
+		depthOf.set(value, depth);
+	}
+	const roots = childrenOf.get("\0root") ?? [];
+	const all = [];
+	const visited = /* @__PURE__ */ new Set();
+	const walk = (nodes) => {
+		for (const node of nodes) {
+			if (visited.has(node.value)) continue;
+			visited.add(node.value);
+			all.push(node);
+			const children = childrenOf.get(node.value);
+			if (children?.length) walk(children);
+		}
+	};
+	walk(roots);
+	for (const [value, node] of byValue) {
+		if (visited.has(value) || hidden.has(value)) continue;
+		visited.add(value);
+		all.push(node);
+	}
+	if (detached) for (const [value, node] of detached) {
+		if (byValue.has(value)) continue;
+		byValue.set(value, node);
+	}
+	return {
+		byValue,
+		childrenOf,
+		parentOf,
+		depthOf,
+		roots,
+		all,
+		pinned,
+		hidden
+	};
+}
+/** Per index, so a query does not rebuild it. */
+const LISTED_VALUES = /* @__PURE__ */ new WeakMap();
+/**
+* Values reachable from the roots through `childrenOf`: the nodes a level can
+* show. A tree query keeps only these, or a resolved node no level lists left
+* its ancestors expanded over nothing.
+*/
+function getCascaderListedValues(index) {
+	let listed = LISTED_VALUES.get(index);
+	if (listed) return listed;
+	const seen = /* @__PURE__ */ new Set();
+	const walk = (nodes) => {
+		for (const node of nodes) {
+			if (seen.has(node.value)) continue;
+			seen.add(node.value);
+			const children = index.childrenOf.get(node.value);
+			if (children?.length) walk(children);
+		}
+	};
+	walk(index.roots);
+	listed = seen;
+	LISTED_VALUES.set(index, listed);
+	return listed;
+}
+/**
+* A level's rows plus its paging row, placed BEFORE the `pinned` rows, which
+* sit last: the first row a page appends then takes the paging row's index,
+* so the highlight Base UI keeps by index lands on it.
+*/
+function withCascaderMoreRow(rows, more, pinned) {
+	const at = pinned?.size ? rows.findIndex((row) => pinned.has(row.value)) : -1;
+	if (at === -1) return [...rows, more];
+	return [
+		...rows.slice(0, at),
+		more,
+		...rows.slice(at)
+	];
+}
+/** Children of `parent`, or the root level when `parent` is nullish. */
+function getCascaderChildren(index, parent) {
+	return index.childrenOf.get(parent ?? "\0root") ?? [];
+}
+/** A branch has known children, or `hasChildren` for an unfetched level. */
+function isCascaderBranch(index, node) {
+	if (node.hasChildren) return true;
+	return (index.childrenOf.get(node.value)?.length ?? 0) > 0;
+}
+/** Trailing count for the default row. Explicit `count` wins over the tree. */
+function getCascaderCount(index, node) {
+	if (typeof node.count === "number") return node.count;
+	return index.childrenOf.get(node.value)?.length ?? 0;
+}
+/**
+* Whether a node is disabled: its own flag, or any ancestor's, since a disabled
+* branch keeps its whole subtree shut. The index's copy counts as its own, so a
+* server hit that omits the flag `items` sets is still caught. Ancestry is
+* `parentOf`: a detached hit the index has never placed answers for itself.
+*/
+function isCascaderDisabled(index, node) {
+	if (node.disabled || index.byValue.get(node.value)?.disabled) return true;
+	const seen = /* @__PURE__ */ new Set([node.value]);
+	let cursor = index.parentOf.get(node.value) ?? null;
+	while (cursor != null && !seen.has(cursor)) {
+		seen.add(cursor);
+		if (index.byValue.get(cursor)?.disabled) return true;
+		cursor = index.parentOf.get(cursor) ?? null;
+	}
+	return false;
+}
+/** Whether a node may be committed as a selection. */
+function isCascaderSelectable(index, node, selectable) {
+	if (isCascaderMoreNode(node)) return false;
+	if (isCascaderDisabled(index, node)) return false;
+	if (typeof selectable === "function") return selectable(node);
+	if (selectable === "any") return true;
+	return !isCascaderBranch(index, node);
+}
+/** Ancestor chain for `value`, root first. Empty while async data loads. */
+function getCascaderPath(index, value) {
+	if (value == null) return [];
+	const chain = [];
+	const seen = /* @__PURE__ */ new Set();
+	let cursor = value;
+	while (cursor != null && !seen.has(cursor)) {
+		seen.add(cursor);
+		const node = index.byValue.get(cursor);
+		if (!node) break;
+		chain.push(node);
+		cursor = index.parentOf.get(cursor) ?? null;
+	}
+	return chain.reverse();
+}
+/**
+* `toLocaleLowerCase`, not `toLowerCase`: the invariant mapping turns Turkish
+* "I" into "i" not "ı", so "ışık" would never match "IŞIK". Both sides fold here.
+*/
+function foldCascaderText(text) {
+	return text.toLocaleLowerCase();
+}
+/** Folds once so callers can hoist the cost out of a per-node loop. */
+function normalizeCascaderQuery(query) {
+	return foldCascaderText(query.trim());
+}
+/** Case-insensitive substring over label and keywords; pre-fold the query. */
+function matchesCascaderQuery(node, normalized) {
+	if (!normalized) return true;
+	if (foldCascaderText(node.label ?? "").includes(normalized)) return true;
+	if (node.keywords) {
+		for (const keyword of node.keywords) if (foldCascaderText(keyword).includes(normalized)) return true;
+	}
+	return false;
+}
+/** Filters one level in place-order. Returns the input when the query is empty. */
+function filterCascaderLevel(nodes, query, matches = matchesCascaderQuery) {
+	const normalized = normalizeCascaderQuery(query);
+	if (!normalized) return nodes;
+	return nodes.filter((node) => matches(node, normalized));
+}
+/** Searches every node, optionally under `within`, in one pass over `all`. */
+function searchCascaderDeep(index, query, options = {}) {
+	const normalized = normalizeCascaderQuery(query);
+	if (!normalized) return [];
+	const { within, limit = 200, matches = matchesCascaderQuery } = options;
+	const results = [];
+	const ancestry = within == null ? null : /* @__PURE__ */ new Map();
+	const isWithin = (node) => {
+		if (within == null || !ancestry) return true;
+		const trail = [];
+		let answer = false;
+		let cursor = index.parentOf.get(node.value);
+		while (cursor != null) {
+			if (cursor === within) {
+				answer = true;
+				break;
+			}
+			const cached = ancestry.get(cursor);
+			if (cached !== void 0) {
+				answer = cached;
+				break;
+			}
+			ancestry.set(cursor, false);
+			trail.push(cursor);
+			cursor = index.parentOf.get(cursor) ?? null;
+		}
+		if (answer) for (const value of trail) ancestry.set(value, true);
+		return answer;
+	};
+	for (const node of index.all) {
+		if (results.length >= limit) break;
+		if (!matches(node, normalized)) continue;
+		if (!isWithin(node)) continue;
+		results.push(node);
+	}
+	return results;
+}
+/**
+* Flattens the tree into tree mode's visible rows. A `sentinels` paging row
+* COUNTS as a sibling in `aria-setsize`: it holds an index of its own.
+*/
+function flattenCascaderTree(index, expanded, sentinels) {
+	const rows = [];
+	const walk = (nodes, parentKey, depth) => {
+		const items = sentinels?.has(parentKey) ? withCascaderMoreRow(nodes, createCascaderMoreNode(parentKey, nodes.length), index.pinned) : nodes;
+		const setSize = items.length;
+		for (let i = 0; i < items.length; i += 1) {
+			const node = items[i];
+			if (isCascaderMoreNode(node)) {
+				rows.push({
+					node,
+					depth,
+					branch: false,
+					expanded: false,
+					setSize,
+					posInSet: i + 1
+				});
+				continue;
+			}
+			const branch = isCascaderBranch(index, node);
+			const isExpanded = branch && expanded.has(node.value);
+			rows.push({
+				node,
+				depth,
+				branch,
+				expanded: isExpanded,
+				setSize,
+				posInSet: i + 1
+			});
+			if (isExpanded) walk(index.childrenOf.get(node.value) ?? [], node.value, depth + 1);
+		}
+	};
+	walk(index.roots, CASCADER_ROOT_KEY, 0);
+	return rows;
+}
+/** Shortens a path; the ellipsis segment still carries the hidden nodes. */
+function collapseCascaderPath(path, options = {}) {
+	const { maxSegments = 3, collapse = "middle" } = options;
+	const asNodes = (nodes) => nodes.map((node) => ({
+		type: "node",
+		node
+	}));
+	if (collapse === "none" || maxSegments <= 0 || path.length <= maxSegments) return asNodes(path);
+	if (collapse === "start") {
+		const tail = path.slice(path.length - maxSegments);
+		return [{
+			type: "ellipsis",
+			hidden: path.slice(0, path.length - maxSegments)
+		}, ...asNodes(tail)];
+	}
+	const head = path.slice(0, 1);
+	const tailCount = maxSegments - 1;
+	const tail = path.slice(path.length - tailCount);
+	const hidden = path.slice(1, path.length - tailCount);
+	if (hidden.length === 0) return asNodes(path);
+	return [
+		...asNodes(head),
+		{
+			type: "ellipsis",
+			hidden
+		},
+		...asNodes(tail)
+	];
+}
+/** Per index, so a press does not rebuild it. */
+const SELECTION_CHILDREN = /* @__PURE__ */ new WeakMap();
+/**
+* Children by parent, built from `parentOf`. Unlike `childrenOf` it also holds
+* a resolved chain node whose level has not loaded, which the selection walks
+* must see: unchecking an ancestor has to take it along. A `hidden` one is left
+* out, since its level loaded without it.
+*/
+function getSelectionChildren(index) {
+	let map = SELECTION_CHILDREN.get(index);
+	if (map) return map;
+	map = /* @__PURE__ */ new Map();
+	for (const [value, parent] of index.parentOf) {
+		const node = index.byValue.get(value);
+		if (!node || index.hidden?.has(value)) continue;
+		const key = parent ?? "\0root";
+		const bucket = map.get(key);
+		if (bucket) bucket.push(node);
+		else map.set(key, [node]);
+	}
+	SELECTION_CHILDREN.set(index, map);
+	return map;
+}
+/**
+* Every KNOWN node under `value`, root first: loaded, or on a resolved chain.
+* Reaching an unfetched descendant would mean a network request per level of
+* the subtree on every selection.
+*/
+function collectCascaderSubtree(index, value) {
+	const root = index.byValue.get(value);
+	if (!root) return [];
+	const childrenOf = getSelectionChildren(index);
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	const walk = (node) => {
+		if (seen.has(node.value)) return;
+		seen.add(node.value);
+		out.push(node);
+		const children = childrenOf.get(node.value);
+		if (children) for (const child of children) walk(child);
+	};
+	walk(root);
+	return out;
+}
+/**
+* Toggles `value` with its known subtree (loaded, or on a resolved chain), then
+* reconciles ancestors. One flat array, no hidden "checked" state: a branch is
+* in the selection exactly when every selectable known child of it is, which
+* keeps a row's checked state an O(1) lookup. Nodes `isSelectable` rejects are skipped down AND ignored up,
+* the pressed node excepted.
+*/
+function applyCascadeSelection(index, selected, value, select, isSelectable = () => true) {
+	const next = new Set(selected);
+	const subtree = collectCascaderSubtree(index, value);
+	if (subtree.length === 0) {
+		if (select) next.add(value);
+		else next.delete(value);
+	}
+	for (const node of subtree) {
+		if (node.value !== value && !isSelectable(node)) continue;
+		if (select) next.add(node.value);
+		else next.delete(node.value);
+	}
+	const seen = /* @__PURE__ */ new Set([value]);
+	let cursor = index.parentOf.get(value) ?? null;
+	while (cursor != null && !seen.has(cursor)) {
+		seen.add(cursor);
+		const parent = index.byValue.get(cursor);
+		const selectable = (getSelectionChildren(index).get(cursor) ?? []).filter((child) => isSelectable(child));
+		if (selectable.length > 0 && selectable.every((child) => next.has(child.value)) && !!parent && isSelectable(parent)) next.add(cursor);
+		else next.delete(cursor);
+		cursor = index.parentOf.get(cursor) ?? null;
+	}
+	return Array.from(next);
+}
+/**
+* How many selected nodes each value has BELOW it, itself excluded. Walks UP
+* from each selection: a per-row subtree scan would be quadratic and re-paid.
+*/
+function getCascaderSelectedDescendants(index, selected) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const value of selected) {
+		const seen = /* @__PURE__ */ new Set([value]);
+		let cursor = index.parentOf.get(value) ?? null;
+		while (cursor != null && !seen.has(cursor)) {
+			seen.add(cursor);
+			counts.set(cursor, (counts.get(cursor) ?? 0) + 1);
+			cursor = index.parentOf.get(cursor) ?? null;
+		}
+	}
+	return counts;
+}
+/** The PARTIALLY selected values, read off counts the caller already holds. */
+function getCascaderIndeterminateFrom(counts, selected) {
+	const selectedSet = new Set(selected);
+	const partial = /* @__PURE__ */ new Set();
+	for (const [value, count] of counts) if (count > 0 && !selectedSet.has(value)) partial.add(value);
+	return partial;
+}
+/**
+* The cascade selection under a reporting strategy. DERIVED OUTPUT ONLY: the
+* STORED value stays the full closure, which keeps a checked state an O(1)
+* lookup. `"all"` is the closure; `"parent"` drops a value whose parent is
+* selected; `"child"` drops one with a selected child.
+*/
+function getCascaderCheckedValues(index, selected, strategy) {
+	if (strategy === "all") return selected;
+	const set = new Set(selected);
+	if (strategy === "parent") return selected.filter((value) => {
+		const parent = index.parentOf.get(value);
+		return parent == null || !set.has(parent);
+	});
+	const withSelectedChild = /* @__PURE__ */ new Set();
+	for (const value of selected) {
+		if (index.hidden?.has(value)) continue;
+		const parent = index.parentOf.get(value);
+		if (parent != null) withSelectedChild.add(parent);
+	}
+	return selected.filter((value) => !withSelectedChild.has(value));
+}
+/** Values in `nodes` whose label collides, so the chip must show its path. */
+function findAmbiguousCascaderLabels(nodes) {
+	const firstByLabel = /* @__PURE__ */ new Map();
+	const ambiguous = /* @__PURE__ */ new Set();
+	for (const node of nodes) {
+		const first = firstByLabel.get(node.label);
+		if (first === void 0) {
+			firstByLabel.set(node.label, node.value);
+			continue;
+		}
+		ambiguous.add(node.value);
+		ambiguous.add(first);
+	}
+	return ambiguous;
+}
+/** Warnings already emitted. Module scoped, or they repeat once per render. */
+const CASCADER_WARNED = /* @__PURE__ */ new Set();
+/** Warns once per `key`, never in production, never by throwing. */
+function warnCascaderOnce(key, message) {
+	if (process.env.NODE_ENV === "production") return;
+	if (CASCADER_WARNED.has(key)) return;
+	CASCADER_WARNED.add(key);
+	console.warn(`[Cascader] ${message}`);
+}
+/** Dev-time scan, kept out of `buildCascaderIndex` so the build stays hot. */
+function findCascaderDataIssues(items, getParent) {
+	const seen = /* @__PURE__ */ new Set();
+	const duplicates = /* @__PURE__ */ new Set();
+	const flat = [];
+	const visit = (nodes) => {
+		for (const node of nodes ?? []) {
+			if (node == null) continue;
+			if (seen.has(node.value)) duplicates.add(node.value);
+			else seen.add(node.value);
+			flat.push(node);
+			if (node.children?.length) visit(node.children);
+		}
+	};
+	visit(items);
+	const cycles = [];
+	if (getParent) {
+		const parentOf = /* @__PURE__ */ new Map();
+		for (const node of flat) {
+			if (parentOf.has(node.value)) continue;
+			const raw = getParent(node);
+			parentOf.set(node.value, raw != null && seen.has(raw) ? raw : null);
+		}
+		for (const node of flat) {
+			const walked = /* @__PURE__ */ new Set([node.value]);
+			let cursor = parentOf.get(node.value) ?? null;
+			while (cursor != null) {
+				if (walked.has(cursor)) {
+					cycles.push(node.value);
+					break;
+				}
+				walked.add(cursor);
+				cursor = parentOf.get(cursor) ?? null;
+			}
+		}
+	}
+	return {
+		duplicates: Array.from(duplicates),
+		cycles
+	};
+}
+export { CASCADER_LIST_HEIGHT_CLASS, CASCADER_LIST_PAD_CLASS, CASCADER_MORE_PREFIX, CASCADER_ROOT_KEY, CASCADER_ROWS_CLASS, CASCADER_SCROLL_CLASS, applyCascadeSelection, buildCascaderIndex, collapseCascaderPath, collectCascaderSubtree, createCascaderMoreNode, filterCascaderLevel, findAmbiguousCascaderLabels, findCascaderDataIssues, flattenCascaderTree, focusCascaderHome, foldCascaderText, getCascaderCheckedValues, getCascaderChildren, getCascaderCount, getCascaderFooterStops, getCascaderIndeterminateFrom, getCascaderListedValues, getCascaderMoreParent, getCascaderPath, getCascaderSelectedDescendants, getCascaderTabTarget, isCascaderBranch, isCascaderDisabled, isCascaderMoreNode, isCascaderRtl, isCascaderSelectable, matchesCascaderQuery, mergeCascaderIndex, normalizeCascaderQuery, searchCascaderDeep, warnCascaderOnce, withCascaderMoreRow };