@skdx/react 0.26.0

package/dist/tree-select/TreeSelectInput.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import type { TreeSelectInputProps } from './types.js';
+/**
+ * Optional filter field inside {@link TreeSelectContent}. Renders an
+ * `<input type="text">` that takes real DOM focus when the popup opens and
+ * keeps it for the whole interaction, carrying `aria-controls` pointing at the
+ * tree and `aria-activedescendant` naming the virtually-focused node — which
+ * is why the trigger drops its own `aria-activedescendant` as soon as one of
+ * these is mounted.
+ *
+ * It is a plain textbox rather than a second `role="combobox"`: the trigger
+ * already owns that role, and two comboboxes for one popup would be announced
+ * as two separate controls.
+ *
+ * Typing filters the tree. A match keeps its whole ancestor chain visible and
+ * expands it *transiently* — clearing the field restores exactly the expansion
+ * the user had before. Arrow keys, Home/End, Enter and Escape all behave as
+ * they do on the trigger; Space is left alone, because here it is a character
+ * the user is typing.
+ *
+ * @example
+ * ```tsx
+ * <TreeSelectInput placeholder="Filter regions…" aria-label="Filter regions" />
+ * ```
+ */
+export declare const TreeSelectInput: React.ForwardRefExoticComponent<Omit<TreeSelectInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;

package/dist/tree-select/TreeSelectItem.d.cts

@@ -0,0 +1,40 @@
+import * as React from 'react';
+import type { TreeSelectItemContextValue, TreeSelectItemProps } from './types.cjs';
+export declare const TreeSelectItemProvider: {
+    (props: TreeSelectItemContextValue & {
+        children: React.ReactNode;
+    }): React.JSX.Element;
+    displayName: string;
+}, useTreeSelectItemContext: (consumerName: string) => TreeSelectItemContextValue;
+/**
+ * One node of a {@link TreeSelect}'s tree, normally rendered for you by
+ * `TreeSelectTree`. Composes `TreeItem`, so it inherits `role="treeitem"`,
+ * `aria-level`, `aria-selected`, `aria-expanded` and
+ * `data-state="expanded" | "collapsed"` unchanged — and adds what a *checkable*
+ * node needs on top:
+ *
+ * - `aria-checked` of `true` / `false` / `"mixed"` (only while the root is
+ *   `multiple`), with `data-checked` of `"checked"` / `"unchecked"` /
+ *   `"indeterminate"` as its styling hook.
+ * - `aria-posinset` / `aria-setsize` measured against the node's *visible*
+ *   siblings, so they stay truthful while a filter is on.
+ * - `data-highlighted` on the virtually-focused node — the one the trigger's
+ *   or input's `aria-activedescendant` names.
+ * - `tabIndex={-1}` unconditionally: this tree is navigated by
+ *   `aria-activedescendant`, and a roving tab stop inside it would put a
+ *   second stop in the tab order.
+ *
+ * Clicking it checks the node (cascading through the subtree under
+ * `checkStrategy="cascade"`) instead of `TreeItem`'s default select-and-expand;
+ * expansion stays on the chevron, i.e. on `TreeItemIndicator`.
+ *
+ * @example
+ * ```tsx
+ * <TreeSelectItem node={node}>
+ *   <TreeItemIndicator>▸</TreeItemIndicator>
+ *   {node.label}
+ *   <TreeSelectItemIndicator>✓</TreeSelectItemIndicator>
+ * </TreeSelectItem>
+ * ```
+ */
+export declare const TreeSelectItem: React.ForwardRefExoticComponent<Omit<TreeSelectItemProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/tree-select/TreeSelectItem.d.ts

@@ -0,0 +1,40 @@
+import * as React from 'react';
+import type { TreeSelectItemContextValue, TreeSelectItemProps } from './types.js';
+export declare const TreeSelectItemProvider: {
+    (props: TreeSelectItemContextValue & {
+        children: React.ReactNode;
+    }): React.JSX.Element;
+    displayName: string;
+}, useTreeSelectItemContext: (consumerName: string) => TreeSelectItemContextValue;
+/**
+ * One node of a {@link TreeSelect}'s tree, normally rendered for you by
+ * `TreeSelectTree`. Composes `TreeItem`, so it inherits `role="treeitem"`,
+ * `aria-level`, `aria-selected`, `aria-expanded` and
+ * `data-state="expanded" | "collapsed"` unchanged — and adds what a *checkable*
+ * node needs on top:
+ *
+ * - `aria-checked` of `true` / `false` / `"mixed"` (only while the root is
+ *   `multiple`), with `data-checked` of `"checked"` / `"unchecked"` /
+ *   `"indeterminate"` as its styling hook.
+ * - `aria-posinset` / `aria-setsize` measured against the node's *visible*
+ *   siblings, so they stay truthful while a filter is on.
+ * - `data-highlighted` on the virtually-focused node — the one the trigger's
+ *   or input's `aria-activedescendant` names.
+ * - `tabIndex={-1}` unconditionally: this tree is navigated by
+ *   `aria-activedescendant`, and a roving tab stop inside it would put a
+ *   second stop in the tab order.
+ *
+ * Clicking it checks the node (cascading through the subtree under
+ * `checkStrategy="cascade"`) instead of `TreeItem`'s default select-and-expand;
+ * expansion stays on the chevron, i.e. on `TreeItemIndicator`.
+ *
+ * @example
+ * ```tsx
+ * <TreeSelectItem node={node}>
+ *   <TreeItemIndicator>▸</TreeItemIndicator>
+ *   {node.label}
+ *   <TreeSelectItemIndicator>✓</TreeSelectItemIndicator>
+ * </TreeSelectItem>
+ * ```
+ */
+export declare const TreeSelectItem: React.ForwardRefExoticComponent<Omit<TreeSelectItemProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/tree-select/TreeSelectItemIndicator.d.cts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import type { TreeSelectItemIndicatorProps } from './types.cjs';
+/**
+ * Marker shown inside a {@link TreeSelectItem} when the node is checked — or
+ * *partially* checked, which is the case worth designing for: a branch whose
+ * subtree is only half chosen renders this with
+ * `data-state="indeterminate"`, and that is where a dash goes instead of a
+ * tick. Renders an `aria-hidden` `<span>` with `data-state` of
+ * `"checked"` / `"indeterminate"`; renders nothing while the node is
+ * unchecked unless `forceMount` is set.
+ *
+ * The check state itself is announced by the item's `aria-checked`, so this is
+ * purely visual — hence `aria-hidden`.
+ *
+ * @example
+ * ```tsx
+ * <TreeSelectItem node={node}>
+ *   {node.label}
+ *   <TreeSelectItemIndicator>{'✓'}</TreeSelectItemIndicator>
+ * </TreeSelectItem>
+ * ```
+ */
+export declare const TreeSelectItemIndicator: React.ForwardRefExoticComponent<Omit<TreeSelectItemIndicatorProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;

package/dist/tree-select/TreeSelectItemIndicator.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import type { TreeSelectItemIndicatorProps } from './types.js';
+/**
+ * Marker shown inside a {@link TreeSelectItem} when the node is checked — or
+ * *partially* checked, which is the case worth designing for: a branch whose
+ * subtree is only half chosen renders this with
+ * `data-state="indeterminate"`, and that is where a dash goes instead of a
+ * tick. Renders an `aria-hidden` `<span>` with `data-state` of
+ * `"checked"` / `"indeterminate"`; renders nothing while the node is
+ * unchecked unless `forceMount` is set.
+ *
+ * The check state itself is announced by the item's `aria-checked`, so this is
+ * purely visual — hence `aria-hidden`.
+ *
+ * @example
+ * ```tsx
+ * <TreeSelectItem node={node}>
+ *   {node.label}
+ *   <TreeSelectItemIndicator>{'✓'}</TreeSelectItemIndicator>
+ * </TreeSelectItem>
+ * ```
+ */
+export declare const TreeSelectItemIndicator: React.ForwardRefExoticComponent<Omit<TreeSelectItemIndicatorProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;

package/dist/tree-select/TreeSelectPortal.d.cts

@@ -0,0 +1,20 @@
+import type { TreeSelectPortalProps } from './types.cjs';
+/**
+ * Teleports its children (typically {@link TreeSelectContent}) to
+ * `document.body` (or `container`, via `PortalProps`) while the
+ * {@link TreeSelect}'s popup is open, so it escapes clipping/overflow from
+ * ancestors. Renders nothing while closed unless `forceMount` is set.
+ *
+ * @example
+ * ```tsx
+ * <TreeSelectPortal>
+ *   <TreeSelectContent>
+ *     <TreeSelectTree aria-label="Regions" />
+ *   </TreeSelectContent>
+ * </TreeSelectPortal>
+ * ```
+ */
+export declare const TreeSelectPortal: {
+    ({ forceMount, children, ...props }: TreeSelectPortalProps): import("react").JSX.Element | null;
+    displayName: string;
+};

package/dist/tree-select/TreeSelectPortal.d.ts

@@ -0,0 +1,20 @@
+import type { TreeSelectPortalProps } from './types.js';
+/**
+ * Teleports its children (typically {@link TreeSelectContent}) to
+ * `document.body` (or `container`, via `PortalProps`) while the
+ * {@link TreeSelect}'s popup is open, so it escapes clipping/overflow from
+ * ancestors. Renders nothing while closed unless `forceMount` is set.
+ *
+ * @example
+ * ```tsx
+ * <TreeSelectPortal>
+ *   <TreeSelectContent>
+ *     <TreeSelectTree aria-label="Regions" />
+ *   </TreeSelectContent>
+ * </TreeSelectPortal>
+ * ```
+ */
+export declare const TreeSelectPortal: {
+    ({ forceMount, children, ...props }: TreeSelectPortalProps): import("react").JSX.Element | null;
+    displayName: string;
+};

package/dist/tree-select/TreeSelectTree.d.cts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import type { TreeSelectTreeProps } from './types.cjs';
+/**
+ * The `role="tree"` inside a {@link TreeSelect}'s popup: composes the `Tree`
+ * family and renders one `TreeSelectItem` per *visible* collection node,
+ * nesting each branch's children in a `TreeGroup`. Carries
+ * `aria-multiselectable` while the root is `multiple`, `aria-readonly` while it
+ * is `readOnly`, and the id the trigger's `aria-controls` points at.
+ *
+ * Expansion is handed to `Tree` as a controlled set, so the chevron
+ * (`TreeItemIndicator`) keeps working exactly as it does in a plain tree.
+ * Selection is *not*: the root owns cascading check state, because it has to
+ * be right for collapsed branches that `Tree` cannot see. Real DOM focus never
+ * enters here — every node is `tabIndex={-1}` and the navigation lives on the
+ * trigger or the filter input.
+ *
+ * Give it an accessible name (`aria-label` or `aria-labelledby`): a tree with
+ * no name announces as an unnamed group.
+ *
+ * @example
+ * ```tsx
+ * <TreeSelectTree
+ *   aria-label="Regions"
+ *   renderLabel={(node) => (
+ *     <>
+ *       <TreeItemIndicator>▸</TreeItemIndicator>
+ *       {node.label}
+ *       <TreeSelectItemIndicator>✓</TreeSelectItemIndicator>
+ *     </>
+ *   )}
+ * />
+ * ```
+ */
+export declare const TreeSelectTree: React.ForwardRefExoticComponent<Omit<TreeSelectTreeProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/tree-select/TreeSelectTree.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import type { TreeSelectTreeProps } from './types.js';
+/**
+ * The `role="tree"` inside a {@link TreeSelect}'s popup: composes the `Tree`
+ * family and renders one `TreeSelectItem` per *visible* collection node,
+ * nesting each branch's children in a `TreeGroup`. Carries
+ * `aria-multiselectable` while the root is `multiple`, `aria-readonly` while it
+ * is `readOnly`, and the id the trigger's `aria-controls` points at.
+ *
+ * Expansion is handed to `Tree` as a controlled set, so the chevron
+ * (`TreeItemIndicator`) keeps working exactly as it does in a plain tree.
+ * Selection is *not*: the root owns cascading check state, because it has to
+ * be right for collapsed branches that `Tree` cannot see. Real DOM focus never
+ * enters here — every node is `tabIndex={-1}` and the navigation lives on the
+ * trigger or the filter input.
+ *
+ * Give it an accessible name (`aria-label` or `aria-labelledby`): a tree with
+ * no name announces as an unnamed group.
+ *
+ * @example
+ * ```tsx
+ * <TreeSelectTree
+ *   aria-label="Regions"
+ *   renderLabel={(node) => (
+ *     <>
+ *       <TreeItemIndicator>▸</TreeItemIndicator>
+ *       {node.label}
+ *       <TreeSelectItemIndicator>✓</TreeSelectItemIndicator>
+ *     </>
+ *   )}
+ * />
+ * ```
+ */
+export declare const TreeSelectTree: React.ForwardRefExoticComponent<Omit<TreeSelectTreeProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/tree-select/TreeSelectTrigger.d.cts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import type { TreeSelectTriggerProps } from './types.cjs';
+/**
+ * Opens the {@link TreeSelect}'s popup and displays the current selection, and
+ * doubles as the popper anchor the popup positions against. Renders a
+ * `<button type="button" role="combobox">` with `aria-haspopup="tree"`,
+ * `aria-expanded`, `aria-controls` pointing at the tree, `data-state`,
+ * `data-disabled`, `data-readonly`, `data-multiple`, and `data-placeholder`
+ * while nothing is checked.
+ *
+ * It also carries `aria-activedescendant` for the virtually-focused node —
+ * but only while no `TreeSelectInput` is mounted, since that input takes real
+ * DOM focus (and with it the activedescendant) as soon as the popup opens.
+ *
+ * Click, Enter, Space or Arrow Up/Down opens the popup; once open the same
+ * keys walk the tree (see {@link TreeSelect}), and printable characters run
+ * typeahead over the visible nodes.
+ *
+ * @example
+ * ```tsx
+ * <TreeSelectTrigger>
+ *   <TreeSelectValue placeholder="Pick a region" />
+ * </TreeSelectTrigger>
+ * ```
+ */
+export declare const TreeSelectTrigger: React.ForwardRefExoticComponent<Omit<TreeSelectTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/dist/tree-select/TreeSelectTrigger.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import type { TreeSelectTriggerProps } from './types.js';
+/**
+ * Opens the {@link TreeSelect}'s popup and displays the current selection, and
+ * doubles as the popper anchor the popup positions against. Renders a
+ * `<button type="button" role="combobox">` with `aria-haspopup="tree"`,
+ * `aria-expanded`, `aria-controls` pointing at the tree, `data-state`,
+ * `data-disabled`, `data-readonly`, `data-multiple`, and `data-placeholder`
+ * while nothing is checked.
+ *
+ * It also carries `aria-activedescendant` for the virtually-focused node —
+ * but only while no `TreeSelectInput` is mounted, since that input takes real
+ * DOM focus (and with it the activedescendant) as soon as the popup opens.
+ *
+ * Click, Enter, Space or Arrow Up/Down opens the popup; once open the same
+ * keys walk the tree (see {@link TreeSelect}), and printable characters run
+ * typeahead over the visible nodes.
+ *
+ * @example
+ * ```tsx
+ * <TreeSelectTrigger>
+ *   <TreeSelectValue placeholder="Pick a region" />
+ * </TreeSelectTrigger>
+ * ```
+ */
+export declare const TreeSelectTrigger: React.ForwardRefExoticComponent<Omit<TreeSelectTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/dist/tree-select/TreeSelectValue.d.cts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import type { TreeSelectValueProps } from './types.cjs';
+/**
+ * Displays the {@link TreeSelect}'s current selection — the checked node's
+ * `label` (or its `value`), or `placeholder` when nothing is checked. Renders
+ * a `<span>` with `pointer-events: none` so clicks pass through to the
+ * trigger. Pass explicit `children` to override the derived text entirely.
+ *
+ * While the root is `multiple`, renders one chip per emitted value instead —
+ * a `data-chip` span carrying `data-value`, to be styled like a TagsInput tag.
+ * Note that *which* nodes those are is `valueStrategy`'s decision: under
+ * `'shallowest'` a fully-checked branch shows as one chip for the branch, not
+ * one per leaf, which is usually what you want on a trigger. The chips are
+ * deliberately inert: the trigger is a `<button>`, so a remove button nested
+ * inside one would be invalid HTML and unreachable by keyboard.
+ *
+ * @example
+ * ```tsx
+ * <TreeSelectTrigger>
+ *   <TreeSelectValue placeholder="Pick a region" />
+ * </TreeSelectTrigger>
+ * ```
+ */
+export declare const TreeSelectValue: React.ForwardRefExoticComponent<Omit<TreeSelectValueProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;

package/dist/tree-select/TreeSelectValue.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import type { TreeSelectValueProps } from './types.js';
+/**
+ * Displays the {@link TreeSelect}'s current selection — the checked node's
+ * `label` (or its `value`), or `placeholder` when nothing is checked. Renders
+ * a `<span>` with `pointer-events: none` so clicks pass through to the
+ * trigger. Pass explicit `children` to override the derived text entirely.
+ *
+ * While the root is `multiple`, renders one chip per emitted value instead —
+ * a `data-chip` span carrying `data-value`, to be styled like a TagsInput tag.
+ * Note that *which* nodes those are is `valueStrategy`'s decision: under
+ * `'shallowest'` a fully-checked branch shows as one chip for the branch, not
+ * one per leaf, which is usually what you want on a trigger. The chips are
+ * deliberately inert: the trigger is a `<button>`, so a remove button nested
+ * inside one would be invalid HTML and unreachable by keyboard.
+ *
+ * @example
+ * ```tsx
+ * <TreeSelectTrigger>
+ *   <TreeSelectValue placeholder="Pick a region" />
+ * </TreeSelectTrigger>
+ * ```
+ */
+export declare const TreeSelectValue: React.ForwardRefExoticComponent<Omit<TreeSelectValueProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;

package/dist/tree-select/collection.d.cts

@@ -0,0 +1,87 @@
+import type { TreeCheckedState } from '../tree/types.cjs';
+import type { TreeSelectNode, TreeSelectValueStrategy } from './types.cjs';
+/**
+ * The whole of `tree-select`'s hard part lives in this module, as plain
+ * functions over plain data: cascading check state, the `valueStrategy`
+ * projection, and the filter's ancestor-preservation rule. None of it touches
+ * React or the DOM — which is deliberate, because all three answers must be
+ * correct for *collapsed* branches, and a collapsed branch has no DOM at all.
+ * (The `tree` family derives its own tri-state from rendered descendants and
+ * therefore cannot see them; see `TreeSelect.md`.)
+ */
+/** @internal Everything derived once per collection about a single node. */
+export interface TreeSelectIndexEntry {
+    node: TreeSelectNode;
+    /** Parent's value, or `null` for a root node. */
+    parent: string | null;
+    /** 1-based depth, which is exactly `aria-level`. */
+    depth: number;
+    /** Immediate children's values, in collection order. */
+    childValues: string[];
+    /** Every descendant's value, in pre-order. */
+    descendants: string[];
+    /**
+     * The *enabled* leaf descendants this node's tri-state is derived from — or
+     * `[node.value]` when it is itself an enabled leaf, and `[]` when it (or its
+     * whole subtree) is disabled. Excluding disabled leaves is what stops a
+     * branch containing one from being permanently stuck at `"mixed"`.
+     */
+    leaves: string[];
+    /** Own `disabled`, or any ancestor's — disabling a branch disables its subtree. */
+    disabled: boolean;
+}
+/** @internal Value → entry, built once per `collection` identity. */
+export type TreeSelectIndex = ReadonlyMap<string, TreeSelectIndexEntry>;
+/** @internal One row of the visible, expanded tree, in the order the arrow keys walk it. */
+export interface TreeSelectFlatNode {
+    value: string;
+    parent: string | null;
+    depth: number;
+    disabled: boolean;
+    /** Whether it has at least one *visible* child, which is what decides `aria-expanded`. */
+    hasChildren: boolean;
+    expanded: boolean;
+    /** 1-based position among its visible siblings — `aria-posinset`. */
+    posinset: number;
+    /** Number of visible siblings including itself — `aria-setsize`. */
+    setsize: number;
+}
+/** @internal Flattens a collection into a value-keyed index plus its pre-order value list. */
+export declare function indexCollection(collection: readonly TreeSelectNode[]): {
+    index: Map<string, TreeSelectIndexEntry>;
+    order: string[];
+};
+/** @internal A node's ancestors, nearest first. */
+export declare function ancestorsOf(value: string, index: TreeSelectIndex): string[];
+/**
+ * @internal A node's tri-state value. Without cascading it is plain
+ * membership; with it, a branch is `true` only when every enabled leaf below
+ * it is checked and `"mixed"` when only some are.
+ */
+export declare function checkStateOf(value: string, checked: ReadonlySet<string>, index: TreeSelectIndex, cascade: boolean): TreeCheckedState;
+/**
+ * @internal Expands an emitted `value` back into the full checked set the
+ * component reasons about. This is the inverse of {@link projectValue}, and
+ * the pair has to round-trip: `'shallowest'` emits a parent standing in for
+ * its subtree, `'leaf'` emits leaves standing in for their parent, and both
+ * must come back as the same set.
+ */
+export declare function normalizeChecked(values: readonly string[], index: TreeSelectIndex, order: readonly string[], cascade: boolean): Set<string>;
+/** @internal Reduces the full checked set to the values a consumer actually receives. */
+export declare function projectValue(checked: ReadonlySet<string>, index: TreeSelectIndex, order: readonly string[], strategy: TreeSelectValueStrategy): string[];
+/** @internal The checked set after activating one node. */
+export declare function toggleChecked(value: string, checked: ReadonlySet<string>, index: TreeSelectIndex, cascade: boolean, multiple: boolean): Set<string>;
+/**
+ * @internal Which nodes survive the filter, and which branches have to open to
+ * reveal them. A match drags its whole ancestor chain into visibility — a
+ * matched leaf whose parent is hidden is unreachable, which is the classic
+ * filtered-tree bug — and its whole subtree, so a matched branch can still be
+ * explored.
+ */
+export declare function computeFilter(index: TreeSelectIndex, order: readonly string[], matches: (node: TreeSelectNode) => boolean): {
+    visible: Set<string>;
+    autoExpanded: Set<string>;
+    matchCount: number;
+};
+/** @internal Walks the visible collection in navigation order, descending only into expanded branches. */
+export declare function flattenVisible(collection: readonly TreeSelectNode[], index: TreeSelectIndex, visible: ReadonlySet<string> | null, expanded: ReadonlySet<string>): TreeSelectFlatNode[];

package/dist/tree-select/collection.d.ts

@@ -0,0 +1,87 @@
+import type { TreeCheckedState } from '../tree/types.js';
+import type { TreeSelectNode, TreeSelectValueStrategy } from './types.js';
+/**
+ * The whole of `tree-select`'s hard part lives in this module, as plain
+ * functions over plain data: cascading check state, the `valueStrategy`
+ * projection, and the filter's ancestor-preservation rule. None of it touches
+ * React or the DOM — which is deliberate, because all three answers must be
+ * correct for *collapsed* branches, and a collapsed branch has no DOM at all.
+ * (The `tree` family derives its own tri-state from rendered descendants and
+ * therefore cannot see them; see `TreeSelect.md`.)
+ */
+/** @internal Everything derived once per collection about a single node. */
+export interface TreeSelectIndexEntry {
+    node: TreeSelectNode;
+    /** Parent's value, or `null` for a root node. */
+    parent: string | null;
+    /** 1-based depth, which is exactly `aria-level`. */
+    depth: number;
+    /** Immediate children's values, in collection order. */
+    childValues: string[];
+    /** Every descendant's value, in pre-order. */
+    descendants: string[];
+    /**
+     * The *enabled* leaf descendants this node's tri-state is derived from — or
+     * `[node.value]` when it is itself an enabled leaf, and `[]` when it (or its
+     * whole subtree) is disabled. Excluding disabled leaves is what stops a
+     * branch containing one from being permanently stuck at `"mixed"`.
+     */
+    leaves: string[];
+    /** Own `disabled`, or any ancestor's — disabling a branch disables its subtree. */
+    disabled: boolean;
+}
+/** @internal Value → entry, built once per `collection` identity. */
+export type TreeSelectIndex = ReadonlyMap<string, TreeSelectIndexEntry>;
+/** @internal One row of the visible, expanded tree, in the order the arrow keys walk it. */
+export interface TreeSelectFlatNode {
+    value: string;
+    parent: string | null;
+    depth: number;
+    disabled: boolean;
+    /** Whether it has at least one *visible* child, which is what decides `aria-expanded`. */
+    hasChildren: boolean;
+    expanded: boolean;
+    /** 1-based position among its visible siblings — `aria-posinset`. */
+    posinset: number;
+    /** Number of visible siblings including itself — `aria-setsize`. */
+    setsize: number;
+}
+/** @internal Flattens a collection into a value-keyed index plus its pre-order value list. */
+export declare function indexCollection(collection: readonly TreeSelectNode[]): {
+    index: Map<string, TreeSelectIndexEntry>;
+    order: string[];
+};
+/** @internal A node's ancestors, nearest first. */
+export declare function ancestorsOf(value: string, index: TreeSelectIndex): string[];
+/**
+ * @internal A node's tri-state value. Without cascading it is plain
+ * membership; with it, a branch is `true` only when every enabled leaf below
+ * it is checked and `"mixed"` when only some are.
+ */
+export declare function checkStateOf(value: string, checked: ReadonlySet<string>, index: TreeSelectIndex, cascade: boolean): TreeCheckedState;
+/**
+ * @internal Expands an emitted `value` back into the full checked set the
+ * component reasons about. This is the inverse of {@link projectValue}, and
+ * the pair has to round-trip: `'shallowest'` emits a parent standing in for
+ * its subtree, `'leaf'` emits leaves standing in for their parent, and both
+ * must come back as the same set.
+ */
+export declare function normalizeChecked(values: readonly string[], index: TreeSelectIndex, order: readonly string[], cascade: boolean): Set<string>;
+/** @internal Reduces the full checked set to the values a consumer actually receives. */
+export declare function projectValue(checked: ReadonlySet<string>, index: TreeSelectIndex, order: readonly string[], strategy: TreeSelectValueStrategy): string[];
+/** @internal The checked set after activating one node. */
+export declare function toggleChecked(value: string, checked: ReadonlySet<string>, index: TreeSelectIndex, cascade: boolean, multiple: boolean): Set<string>;
+/**
+ * @internal Which nodes survive the filter, and which branches have to open to
+ * reveal them. A match drags its whole ancestor chain into visibility — a
+ * matched leaf whose parent is hidden is unreachable, which is the classic
+ * filtered-tree bug — and its whole subtree, so a matched branch can still be
+ * explored.
+ */
+export declare function computeFilter(index: TreeSelectIndex, order: readonly string[], matches: (node: TreeSelectNode) => boolean): {
+    visible: Set<string>;
+    autoExpanded: Set<string>;
+    matchCount: number;
+};
+/** @internal Walks the visible collection in navigation order, descending only into expanded branches. */
+export declare function flattenVisible(collection: readonly TreeSelectNode[], index: TreeSelectIndex, visible: ReadonlySet<string> | null, expanded: ReadonlySet<string>): TreeSelectFlatNode[];

package/dist/tree-select/index.d.cts

@@ -0,0 +1,11 @@
+export { TreeSelect, defaultTreeSelectFilter, defaultGetMatchCountLabel } from './TreeSelect.cjs';
+export { TreeSelectTrigger } from './TreeSelectTrigger.cjs';
+export { TreeSelectValue } from './TreeSelectValue.cjs';
+export { TreeSelectPortal } from './TreeSelectPortal.cjs';
+export { TreeSelectContent } from './TreeSelectContent.cjs';
+export { TreeSelectTree } from './TreeSelectTree.cjs';
+export { TreeSelectItem } from './TreeSelectItem.cjs';
+export { TreeSelectItemIndicator } from './TreeSelectItemIndicator.cjs';
+export { TreeSelectEmpty } from './TreeSelectEmpty.cjs';
+export { TreeSelectInput } from './TreeSelectInput.cjs';
+export type { TreeSelectNode, TreeSelectCheckStrategy, TreeSelectValueStrategy, TreeSelectFilter, TreeSelectProps, TreeSelectTriggerProps, TreeSelectValueProps, TreeSelectPortalProps, TreeSelectContentProps, TreeSelectTreeProps, TreeSelectItemProps, TreeSelectItemIndicatorProps, TreeSelectEmptyProps, TreeSelectInputProps, } from './types.cjs';

package/dist/tree-select/index.d.ts

@@ -0,0 +1,11 @@
+export { TreeSelect, defaultTreeSelectFilter, defaultGetMatchCountLabel } from './TreeSelect.js';
+export { TreeSelectTrigger } from './TreeSelectTrigger.js';
+export { TreeSelectValue } from './TreeSelectValue.js';
+export { TreeSelectPortal } from './TreeSelectPortal.js';
+export { TreeSelectContent } from './TreeSelectContent.js';
+export { TreeSelectTree } from './TreeSelectTree.js';
+export { TreeSelectItem } from './TreeSelectItem.js';
+export { TreeSelectItemIndicator } from './TreeSelectItemIndicator.js';
+export { TreeSelectEmpty } from './TreeSelectEmpty.js';
+export { TreeSelectInput } from './TreeSelectInput.js';
+export type { TreeSelectNode, TreeSelectCheckStrategy, TreeSelectValueStrategy, TreeSelectFilter, TreeSelectProps, TreeSelectTriggerProps, TreeSelectValueProps, TreeSelectPortalProps, TreeSelectContentProps, TreeSelectTreeProps, TreeSelectItemProps, TreeSelectItemIndicatorProps, TreeSelectEmptyProps, TreeSelectInputProps, } from './types.js';