@cube-dev/ui-kit 0.127.3 → 0.129.0

package/dist/components/content/Tree/styled.js

@@ -0,0 +1,146 @@
+/** @license MIT | @cube-dev/ui-kit v0.129.0 | Cube Dev Team */
+import { _Item } from "../Item/Item.js";
+import { Action } from "../../actions/Action/Action.js";
+import { tasty } from "@tenphi/tasty";
+
+//#region src/components/content/Tree/styled.ts
+/**
+* Tree root.
+*
+* Renders as `role="treegrid"` (set on `gridProps` from `useTree`).
+*
+* Tree-wide modifiers (set on `TreeElement` itself):
+* - `has-height` — paired with `--tree-height` on inline `style`
+*   when the consumer passes a numeric `height` prop.
+*/
+const TreeElement = tasty({
+	qa: "Tree",
+	styles: {
+		display: "flex",
+		flow: "column",
+		width: "100%",
+		height: {
+			"": "auto",
+			"has-height": "fixed $tree-height"
+		},
+		flexGrow: {
+			"": 1,
+			"has-height": 0
+		},
+		flexShrink: {
+			"": 1,
+			"has-height": 0
+		},
+		flexBasis: {
+			"": 0,
+			"has-height": "auto"
+		},
+		minHeight: 0,
+		overflow: "auto",
+		scrollbar: "thin",
+		fill: "#clear",
+		color: "#dark",
+		transition: "theme",
+		outline: 0,
+		gap: "1bw",
+		padding: ".5x"
+	}
+});
+/**
+* Per-row wrapper carrying `role="row"`, `rowProps` from
+* `useTreeItem`, and the `--tree-level` CSS custom property used by
+* `TreeRowItem` to compute its left padding.
+*
+* Has no visual styles of its own — the row's appearance lives on
+* the inner `TreeRowItem` (which extends `Item`).
+*/
+const TreeNodeRow = tasty({
+	qa: "TreeRow",
+	styles: {
+		display: "block",
+		width: "100%",
+		outline: 0
+	}
+});
+/**
+* The visible row: an `Item` extension that owns layout (full-width,
+* tree indent) only. Color treatment is delegated to the
+* `default.item` variant (see `DEFAULT_ITEM_STYLES` in
+* `data/item-themes.ts`) so the Tree row matches the canonical Item
+* look out of the box. `hovered` / `focused` / `pressed` mods are
+* propagated from `TreeNode` because react-aria's treegrid uses a
+* roving-tabindex "virtual focus" model and never sets those data
+* attributes itself.
+*/
+const TreeRowItem = tasty(_Item, {
+	qa: "TreeItem",
+	type: "item",
+	size: "small",
+	as: "div",
+	styles: {
+		display: "grid",
+		width: "100%",
+		padding: "left ($tree-indent * 1x)",
+		"$tree-indent": "($tree-level, 0)",
+		cursor: {
+			"": "pointer",
+			disabled: "not-allowed"
+		}
+	}
+});
+/**
+* Wraps the checkbox sitting in `Item`'s `prefix` slot. `Item`'s
+* built-in Prefix padding collapses to `0` whenever there's an icon
+* (which is always true for tree rows because the toggle/placeholder
+* occupies the icon slot). We re-introduce a small inline gap on
+* both sides so the checkbox isn't flush against the chevron and the
+* title.
+*/
+const TreeNodeCheckboxWrapper = tasty({
+	qa: "TreeNodeCheckboxWrapper",
+	styles: {
+		display: "grid",
+		placeItems: "center",
+		placeContent: "center",
+		padding: "0 1x"
+	}
+});
+const TOGGLE_BASE_STYLES = {
+	display: "grid",
+	placeItems: "center",
+	placeContent: "center",
+	width: "3x",
+	height: "3x",
+	radius: true,
+	transition: "theme"
+};
+/**
+* Chevron toggle button placed in `Item`'s `icon` slot. Spreads
+* `expandButtonProps` from `useTreeItem` (an AriaButtonProps) and
+* stops the press from bubbling to the row's selection handler via
+* React Aria's PressResponder.
+*/
+const TreeNodeToggle = tasty(Action, {
+	qa: "TreeNodeToggle",
+	styles: {
+		...TOGGLE_BASE_STYLES,
+		color: {
+			"": "#dark-02",
+			":hover": "#dark"
+		},
+		fill: {
+			"": "#clear",
+			":hover": "#dark.04"
+		}
+	}
+});
+/**
+* Non-interactive placeholder that occupies the same footprint as
+* `TreeNodeToggle` so leaf rows visually align with siblings that
+* have a chevron.
+*/
+const TreeNodeTogglePlaceholder = tasty({ styles: TOGGLE_BASE_STYLES });
+
+//#endregion
+export { TreeElement, TreeNodeCheckboxWrapper, TreeNodeRow, TreeNodeToggle, TreeNodeTogglePlaceholder, TreeRowItem };
+//# sourceMappingURL=styled.js.map

package/dist/components/content/Tree/styled.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"styled.js","names":["Item"],"sources":["../../../../src/components/content/Tree/styled.ts"],"sourcesContent":["import { Styles, tasty } from '@tenphi/tasty';\n\nimport { Action } from '../../actions/Action/Action';\nimport { Item } from '../Item';\n\n/**\n * Tree root.\n *\n * Renders as `role=\"treegrid\"` (set on `gridProps` from `useTree`).\n *\n * Tree-wide modifiers (set on `TreeElement` itself):\n * - `has-height` — paired with `--tree-height` on inline `style`\n *   when the consumer passes a numeric `height` prop.\n */\nexport const TreeElement = tasty({\n  qa: 'Tree',\n  styles: {\n    display: 'flex',\n    flow: 'column',\n    width: '100%',\n    height: { '': 'auto', 'has-height': 'fixed $tree-height' },\n    flexGrow: { '': 1, 'has-height': 0 },\n    flexShrink: { '': 1, 'has-height': 0 },\n    flexBasis: { '': 0, 'has-height': 'auto' },\n    minHeight: 0,\n    overflow: 'auto',\n    scrollbar: 'thin',\n    fill: '#clear',\n    color: '#dark',\n    transition: 'theme',\n    outline: 0,\n    gap: '1bw',\n    padding: '.5x',\n  },\n});\n\n/**\n * Per-row wrapper carrying `role=\"row\"`, `rowProps` from\n * `useTreeItem`, and the `--tree-level` CSS custom property used by\n * `TreeRowItem` to compute its left padding.\n *\n * Has no visual styles of its own — the row's appearance lives on\n * the inner `TreeRowItem` (which extends `Item`).\n */\nexport const TreeNodeRow = tasty({\n  qa: 'TreeRow',\n  styles: {\n    display: 'block',\n    width: '100%',\n    outline: 0,\n  },\n});\n\n/**\n * The visible row: an `Item` extension that owns layout (full-width,\n * tree indent) only. Color treatment is delegated to the\n * `default.item` variant (see `DEFAULT_ITEM_STYLES` in\n * `data/item-themes.ts`) so the Tree row matches the canonical Item\n * look out of the box. `hovered` / `focused` / `pressed` mods are\n * propagated from `TreeNode` because react-aria's treegrid uses a\n * roving-tabindex \"virtual focus\" model and never sets those data\n * attributes itself.\n */\nexport const TreeRowItem = tasty(Item, {\n  qa: 'TreeItem',\n  type: 'item',\n  size: 'small',\n  as: 'div',\n  styles: {\n    /**\n     * `Item` is `inline-grid` by default, which leaves baseline\n     * descender space below the row inside the block-level\n     * `TreeNodeRow` and visually inflates the gap between rows\n     * past the intended `1bw`. Force block-level grid here.\n     */\n    display: 'grid',\n    width: '100%',\n    /**\n     * Per-level indent. `$tree-indent` is a local token that reads\n     * `--tree-level` (set inline on the parent `TreeNodeRow`) with a\n     * `0` fallback. Using `padding` shorthand (instead of\n     * `paddingInlineStart`) so it overrides `Item`'s default\n     * `padding: 0` reliably — a longhand override on a shorthand\n     * loses to it in the cascade when both are emitted from the same\n     * declaration block.\n     */\n    padding: 'left ($tree-indent * 1x)',\n    '$tree-indent': '($tree-level, 0)',\n    cursor: {\n      '': 'pointer',\n      disabled: 'not-allowed',\n    },\n  },\n});\n\n/**\n * Wraps the checkbox sitting in `Item`'s `prefix` slot. `Item`'s\n * built-in Prefix padding collapses to `0` whenever there's an icon\n * (which is always true for tree rows because the toggle/placeholder\n * occupies the icon slot). We re-introduce a small inline gap on\n * both sides so the checkbox isn't flush against the chevron and the\n * title.\n */\nexport const TreeNodeCheckboxWrapper = tasty({\n  qa: 'TreeNodeCheckboxWrapper',\n  styles: {\n    display: 'grid',\n    placeItems: 'center',\n    placeContent: 'center',\n    padding: '0 1x',\n  },\n});\n\nconst TOGGLE_BASE_STYLES: Styles = {\n  display: 'grid',\n  placeItems: 'center',\n  placeContent: 'center',\n  width: '3x',\n  height: '3x',\n  radius: true,\n  transition: 'theme',\n};\n\n/**\n * Chevron toggle button placed in `Item`'s `icon` slot. Spreads\n * `expandButtonProps` from `useTreeItem` (an AriaButtonProps) and\n * stops the press from bubbling to the row's selection handler via\n * React Aria's PressResponder.\n */\nexport const TreeNodeToggle = tasty(Action, {\n  qa: 'TreeNodeToggle',\n  styles: {\n    ...TOGGLE_BASE_STYLES,\n    color: { '': '#dark-02', ':hover': '#dark' },\n    fill: { '': '#clear', ':hover': '#dark.04' },\n  },\n});\n\n/**\n * Non-interactive placeholder that occupies the same footprint as\n * `TreeNodeToggle` so leaf rows visually align with siblings that\n * have a chevron.\n */\nexport const TreeNodeTogglePlaceholder = tasty({\n  styles: TOGGLE_BASE_STYLES,\n});\n"],"mappings":";;;;;;;;;;;;;;;AAcA,MAAa,cAAc,MAAM;CAC/B,IAAI;CACJ,QAAQ;EACN,SAAS;EACT,MAAM;EACN,OAAO;EACP,QAAQ;GAAE,IAAI;GAAQ,cAAc;GAAsB;EAC1D,UAAU;GAAE,IAAI;GAAG,cAAc;GAAG;EACpC,YAAY;GAAE,IAAI;GAAG,cAAc;GAAG;EACtC,WAAW;GAAE,IAAI;GAAG,cAAc;GAAQ;EAC1C,WAAW;EACX,UAAU;EACV,WAAW;EACX,MAAM;EACN,OAAO;EACP,YAAY;EACZ,SAAS;EACT,KAAK;EACL,SAAS;EACV;CACF,CAAC;;;;;;;;;AAUF,MAAa,cAAc,MAAM;CAC/B,IAAI;CACJ,QAAQ;EACN,SAAS;EACT,OAAO;EACP,SAAS;EACV;CACF,CAAC;;;;;;;;;;;AAYF,MAAa,cAAc,MAAMA,OAAM;CACrC,IAAI;CACJ,MAAM;CACN,MAAM;CACN,IAAI;CACJ,QAAQ;EAON,SAAS;EACT,OAAO;EAUP,SAAS;EACT,gBAAgB;EAChB,QAAQ;GACN,IAAI;GACJ,UAAU;GACX;EACF;CACF,CAAC;;;;;;;;;AAUF,MAAa,0BAA0B,MAAM;CAC3C,IAAI;CACJ,QAAQ;EACN,SAAS;EACT,YAAY;EACZ,cAAc;EACd,SAAS;EACV;CACF,CAAC;AAEF,MAAM,qBAA6B;CACjC,SAAS;CACT,YAAY;CACZ,cAAc;CACd,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,YAAY;CACb;;;;;;;AAQD,MAAa,iBAAiB,MAAM,QAAQ;CAC1C,IAAI;CACJ,QAAQ;EACN,GAAG;EACH,OAAO;GAAE,IAAI;GAAY,UAAU;GAAS;EAC5C,MAAM;GAAE,IAAI;GAAU,UAAU;GAAY;EAC7C;CACF,CAAC;;;;;;AAOF,MAAa,4BAA4B,MAAM,EAC7C,QAAQ,oBACT,CAAC"}

package/dist/components/content/Tree/tree-index.js

@@ -0,0 +1,26 @@
+/** @license MIT | @cube-dev/ui-kit v0.129.0 | Cube Dev Team */
+//#region src/components/content/Tree/tree-index.ts
+function buildTreeIndex(treeData) {
+	const byKey = /* @__PURE__ */ new Map();
+	const parentOf = /* @__PURE__ */ new Map();
+	const childrenOf = /* @__PURE__ */ new Map();
+	const visit = (nodes, parent) => {
+		for (const node of nodes) {
+			byKey.set(node.key, node);
+			parentOf.set(node.key, parent);
+			const childKeys = (node.children ?? []).map((c) => c.key);
+			childrenOf.set(node.key, childKeys);
+			if (node.children) visit(node.children, node.key);
+		}
+	};
+	visit(treeData, null);
+	return {
+		byKey,
+		parentOf,
+		childrenOf
+	};
+}
+
+//#endregion
+export { buildTreeIndex };
+//# sourceMappingURL=tree-index.js.map

package/dist/components/content/Tree/tree-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-index.js","names":[],"sources":["../../../../src/components/content/Tree/tree-index.ts"],"sourcesContent":["import type { CubeTreeNodeData } from './types';\n\n/**\n * Map of `key -> { node, parentKey, childKeys }` for fast cascading lookups.\n *\n * Built from the public `treeData` rather than from React Stately's\n * collection, because we need the consumer's original (controlled)\n * shape to derive parent/child relationships and to call back with the\n * actual `node` objects.\n *\n * Shared between `Tree.tsx` (for `nodesByKey` / `parentOf`) and\n * `useCheckboxTree` (cascading checked state) so a single tree walk\n * powers all three maps.\n */\nexport interface TreeIndex {\n  byKey: Map<string, CubeTreeNodeData>;\n  parentOf: Map<string, string | null>;\n  childrenOf: Map<string, string[]>;\n}\n\nexport function buildTreeIndex(treeData: CubeTreeNodeData[]): TreeIndex {\n  const byKey = new Map<string, CubeTreeNodeData>();\n  const parentOf = new Map<string, string | null>();\n  const childrenOf = new Map<string, string[]>();\n\n  const visit = (nodes: CubeTreeNodeData[], parent: string | null) => {\n    for (const node of nodes) {\n      byKey.set(node.key, node);\n      parentOf.set(node.key, parent);\n      const childKeys = (node.children ?? []).map((c) => c.key);\n      childrenOf.set(node.key, childKeys);\n      if (node.children) {\n        visit(node.children, node.key);\n      }\n    }\n  };\n\n  visit(treeData, null);\n\n  return { byKey, parentOf, childrenOf };\n}\n"],"mappings":";;AAoBA,SAAgB,eAAe,UAAyC;CACtE,MAAM,wBAAQ,IAAI,KAA+B;CACjD,MAAM,2BAAW,IAAI,KAA4B;CACjD,MAAM,6BAAa,IAAI,KAAuB;CAE9C,MAAM,SAAS,OAA2B,WAA0B;AAClE,OAAK,MAAM,QAAQ,OAAO;AACxB,SAAM,IAAI,KAAK,KAAK,KAAK;AACzB,YAAS,IAAI,KAAK,KAAK,OAAO;GAC9B,MAAM,aAAa,KAAK,YAAY,EAAE,EAAE,KAAK,MAAM,EAAE,IAAI;AACzD,cAAW,IAAI,KAAK,KAAK,UAAU;AACnC,OAAI,KAAK,SACP,OAAM,KAAK,UAAU,KAAK,IAAI;;;AAKpC,OAAM,UAAU,KAAK;AAErB,QAAO;EAAE;EAAO;EAAU;EAAY"}

package/dist/components/content/Tree/types.d.ts

@@ -0,0 +1,145 @@
+
+import { BaseProps, OuterStyleProps, Styles } from "@tenphi/tasty";
+import { ReactNode } from "react";
+import { Key as Key$1 } from "@react-types/shared";
+
+//#region src/components/content/Tree/types.d.ts
+/** Selection cardinality, mirroring React Aria/Stately's `selectionMode`. */
+type TreeSelectionMode = 'none' | 'single' | 'multiple';
+/**
+ * A single node in the `treeData` array.
+ *
+ * Mirrors AntD's `DataNode` shape but renames boolean flags to the
+ * `is*` convention used throughout `@cube-dev/ui-kit`.
+ */
+interface CubeTreeNodeData {
+  /** Unique identifier of the node. */
+  key: string;
+  /** Visible label (any `ReactNode`). */
+  title: ReactNode;
+  /** Children. Pass `undefined` together with `isLeaf={false}` for lazy nodes. */
+  children?: CubeTreeNodeData[];
+  /** Force leaf rendering (no expand toggle, no `loadData` call). */
+  isLeaf?: boolean;
+  /** Disable interactions on this row (focus / select / expand / check). */
+  isDisabled?: boolean;
+  /** Disable only the checkbox of this row. */
+  isCheckboxDisabled?: boolean;
+  /**
+   * Per-node `isCheckable` override.
+   *
+   * - `undefined` (default): inherits the tree-level `isCheckable`.
+   * - `false`: hide the checkbox for this row even when the tree is `isCheckable`.
+   */
+  isCheckable?: boolean;
+}
+/** Info passed as the second argument to `onCheck`. */
+interface TreeOnCheckInfo {
+  /** Whether the toggled node ended up checked. */
+  checked: boolean;
+  /** The toggled node. */
+  node: CubeTreeNodeData;
+  /** All currently checked nodes (flat). */
+  checkedNodes: CubeTreeNodeData[];
+  /** Keys of nodes in indeterminate state. */
+  halfCheckedKeys: Key$1[];
+}
+/** Info passed as the second argument to `onExpand`. */
+interface TreeOnExpandInfo {
+  /** Whether the toggled node ended up expanded. */
+  expanded: boolean;
+  /** The toggled node. */
+  node: CubeTreeNodeData;
+}
+/** Info passed as the second argument to `onSelect`. */
+interface TreeOnSelectInfo {
+  /** Whether the toggled node ended up selected. */
+  selected: boolean;
+  /** The toggled node. */
+  node: CubeTreeNodeData;
+  /** All currently selected nodes (flat). */
+  selectedNodes: CubeTreeNodeData[];
+}
+/** Argument shape for the `loadData` callback. */
+interface TreeLoadDataNode {
+  key: Key$1;
+  children?: CubeTreeNodeData[];
+}
+/**
+ * Public props for the `Tree` component.
+ *
+ * Designed to be a drop-in (modulo `is*` renames) for the AntD `Tree`
+ * `treeData` API, scoped to the v1 feature set.
+ */
+interface CubeTreeProps extends BaseProps, OuterStyleProps {
+  /** Hierarchical data describing the tree. */
+  treeData: CubeTreeNodeData[];
+  /** Render a checkbox in front of every (eligible) row. */
+  isCheckable?: boolean;
+  /** Allow row selection. Sugar for `selectionMode="none"` when `false`. */
+  isSelectable?: boolean;
+  /** Selection cardinality. Defaults to `'single'`. */
+  selectionMode?: TreeSelectionMode;
+  /** Disable the entire tree. */
+  isDisabled?: boolean;
+  /** Default expanded keys (uncontrolled). */
+  defaultExpandedKeys?: string[];
+  /** Controlled expanded keys. */
+  expandedKeys?: string[];
+  /**
+   * Auto-expand parents of currently expanded keys.
+   *
+   * Useful while filtering: passing matched leaf keys with this flag will
+   * keep their parents expanded as well.
+   */
+  autoExpandParent?: boolean;
+  /** Default checked keys (uncontrolled). */
+  defaultCheckedKeys?: string[];
+  /**
+   * Controlled checked keys.
+   *
+   * Accepts either an array of keys or AntD's `{ checked, halfChecked }` shape.
+   */
+  checkedKeys?: string[] | {
+    checked: string[];
+    halfChecked?: string[];
+  };
+  /** Default selected keys (uncontrolled). */
+  defaultSelectedKeys?: string[];
+  /** Controlled selected keys. */
+  selectedKeys?: string[];
+  /**
+   * Fixed height in pixels. When omitted, the tree fills the available
+   * vertical space and scrolls internally.
+   */
+  height?: number;
+  /**
+   * Async loader called the first time a non-leaf node with no `children`
+   * is expanded. The consumer is expected to merge new children into
+   * `treeData` (typical AntD pattern).
+   */
+  loadData?: (node: TreeLoadDataNode) => Promise<void>;
+  /** Called when a node is expanded or collapsed. */
+  onExpand?: (expandedKeys: Key$1[], info: TreeOnExpandInfo) => void;
+  /**
+   * Called when a node is checked or unchecked.
+   *
+   * The first argument is `Key[]` by default; pass `checkedKeys` as
+   * `{ checked, halfChecked }` to receive the same shape back.
+   */
+  onCheck?: (checked: Key$1[] | {
+    checked: Key$1[];
+    halfChecked: Key$1[];
+  }, info: TreeOnCheckInfo) => void;
+  /** Called when row selection changes. */
+  onSelect?: (selectedKeys: Key$1[], info: TreeOnSelectInfo) => void;
+  /** Override styles for `[data-element="Row"]` (per-row root). */
+  rowStyles?: Styles;
+  /** Accessible label for the tree. Defaults to `"Tree"`. */
+  ariaLabel?: string;
+  /** QA selector. */
+  qa?: string;
+}
+//#endregion
+export { CubeTreeNodeData, CubeTreeProps, TreeLoadDataNode, TreeOnCheckInfo, TreeOnExpandInfo, TreeOnSelectInfo, TreeSelectionMode };
+//# sourceMappingURL=types.d.ts.map

package/dist/components/content/Tree/use-checkbox-tree.js

@@ -0,0 +1,231 @@
+/** @license MIT | @cube-dev/ui-kit v0.129.0 | Cube Dev Team */
+import { useEvent } from "../../../_internal/hooks/use-event.js";
+import { useMemo, useState } from "react";
+
+//#region src/components/content/Tree/use-checkbox-tree.ts
+/**
+* Returns whether a node should be checkable (i.e. clicking the
+* checkbox should affect it).
+*
+* Skips:
+* - explicitly disabled nodes (`isDisabled === true`)
+* - explicitly disabled checkboxes (`isCheckboxDisabled === true`)
+* - nodes that opted out via `isCheckable === false`
+*/
+function isNodeEligible(node) {
+	if (!node) return false;
+	if (node.isDisabled) return false;
+	if (node.isCheckboxDisabled) return false;
+	if (node.isCheckable === false) return false;
+	return true;
+}
+/**
+* Recursively walk a subtree bottom-up, deriving which nodes are fully
+* checked vs half-checked.  Mutates `checked` and `half` in place.
+*/
+function deriveCheckedState(node, index, checked, half) {
+	const childKeys = index.childrenOf.get(node.key) ?? [];
+	if (childKeys.length === 0) {
+		const eligible = isNodeEligible(node);
+		const isChecked = checked.has(node.key);
+		return {
+			allChecked: !eligible || isChecked,
+			anyChecked: isChecked,
+			anyEligible: eligible
+		};
+	}
+	let allChecked = true;
+	let anyChecked = false;
+	let anyEligible = false;
+	for (const childKey of childKeys) {
+		const child = index.byKey.get(childKey);
+		if (!child) continue;
+		const r = deriveCheckedState(child, index, checked, half);
+		if (r.anyEligible) anyEligible = true;
+		if (!r.allChecked) allChecked = false;
+		if (r.anyChecked) anyChecked = true;
+	}
+	const eligible = isNodeEligible(node);
+	if (!anyEligible) half.delete(node.key);
+	else if (allChecked) {
+		checked.add(node.key);
+		half.delete(node.key);
+	} else if (anyChecked) {
+		checked.delete(node.key);
+		half.add(node.key);
+	} else {
+		checked.delete(node.key);
+		half.delete(node.key);
+	}
+	return {
+		allChecked: !eligible ? allChecked : checked.has(node.key) && allChecked,
+		anyChecked: anyChecked || checked.has(node.key),
+		anyEligible: anyEligible || eligible
+	};
+}
+function normalizeControlledChecked(controlled) {
+	if (controlled == null) return null;
+	if (Array.isArray(controlled)) return {
+		checked: new Set(controlled),
+		halfChecked: /* @__PURE__ */ new Set()
+	};
+	return {
+		checked: new Set(controlled.checked ?? []),
+		halfChecked: new Set(controlled.halfChecked ?? [])
+	};
+}
+/**
+* Local hook implementing AntD-style cascading checkbox state.
+*
+* - `checked` and `halfChecked` are always derived together from a single
+*   `checked` set (the source of truth) so callers don't need to track
+*   indeterminate keys themselves.
+* - When the consumer passes `checkedKeys` as `{ checked, halfChecked }`,
+*   we keep the wire shape on the way out — same as AntD.
+* - Toggling a node propagates *down* (skipping ineligible descendants)
+*   and recomputes ancestors *up* in a single pass.
+*/
+function useCheckboxTree(opts) {
+	const { treeData, index, isCheckable, defaultCheckedKeys, checkedKeys, onCheck } = opts;
+	/**
+	* Normalize the controlled `checkedKeys` prop into stable `Set` instances.
+	* Memoized on the `checkedKeys` reference so unrelated re-renders don't
+	* invalidate the derivation memo below — `normalizeControlledChecked`
+	* allocates fresh `Set`s each call, which would otherwise force
+	* `deriveCheckedState` to re-walk the entire tree on every render in
+	* controlled mode.
+	*/
+	const controlled = useMemo(() => normalizeControlledChecked(checkedKeys), [checkedKeys]);
+	const isControlled = controlled != null;
+	const wantsObjectShape = checkedKeys != null && !Array.isArray(checkedKeys);
+	const [uncontrolledChecked, setUncontrolledChecked] = useState(() => new Set(defaultCheckedKeys ?? []));
+	const sourceChecked = isControlled ? controlled.checked : uncontrolledChecked;
+	/**
+	* Derive `{ checked, halfChecked }` from the source-of-truth `checked` set
+	* by walking the tree bottom-up:
+	*
+	* - A parent is considered fully checked iff every eligible descendant
+	*   leaf is checked.
+	* - A parent is half-checked iff at least one eligible descendant is
+	*   checked or half-checked, but not all.
+	*
+	* Ineligible nodes (disabled / opt-out) are ignored when computing the
+	* parent's state — they neither force a parent into the unchecked nor
+	* half state.
+	*/
+	const { checkedSet, halfCheckedSet } = useMemo(() => {
+		if (!isCheckable) return {
+			checkedSet: /* @__PURE__ */ new Set(),
+			halfCheckedSet: /* @__PURE__ */ new Set()
+		};
+		/**
+		* If the consumer passed the object shape (`{ checked, halfChecked }`),
+		* they own the half-checked set and we use it as-is. With the array
+		* shape we still need to derive `halfChecked` ourselves — the consumer
+		* only provides `checked`, so parents should still light up
+		* indeterminate when only some descendants are checked.
+		*/
+		if (isControlled && wantsObjectShape) return {
+			checkedSet: new Set(sourceChecked),
+			halfCheckedSet: new Set(controlled.halfChecked)
+		};
+		const checked = new Set(sourceChecked);
+		const half = /* @__PURE__ */ new Set();
+		for (const root of treeData) deriveCheckedState(root, index, checked, half);
+		return {
+			checkedSet: checked,
+			halfCheckedSet: half
+		};
+	}, [
+		isCheckable,
+		isControlled,
+		wantsObjectShape,
+		sourceChecked,
+		controlled,
+		treeData,
+		index
+	]);
+	return {
+		checkedSet,
+		halfCheckedSet,
+		toggle: useEvent((key) => {
+			const node = index.byKey.get(key);
+			if (!node || !isNodeEligible(node)) return;
+			const willCheck = !checkedSet.has(key);
+			/**
+			* Seed from the derived `checkedSet`, not `sourceChecked`. The
+			* source-of-truth set may only contain leaf keys (e.g. when
+			* `defaultCheckedKeys` is leaf-only, or a consumer in controlled-array
+			* mode passes only leaves). The ancestor walk below decides whether
+			* each ancestor is fully checked by inspecting its direct children
+			* via `next.has(ck)` — those children may themselves be inner nodes
+			* whose "fully checked" status only exists in the derived set. Seeding
+			* from `sourceChecked` causes a sibling subtree's parent key to be
+			* missing from `next`, which would incorrectly drop the grandparent
+			* from the stored state (the next render's `useMemo` self-corrects,
+			* but the intermediate stored value violates the cascade invariant).
+			*/
+			const next = new Set(checkedSet);
+			const apply = (n, value) => {
+				if (!isNodeEligible(n)) return;
+				if (value) next.add(n.key);
+				else next.delete(n.key);
+				const childKeys = index.childrenOf.get(n.key) ?? [];
+				for (const ck of childKeys) {
+					const child = index.byKey.get(ck);
+					if (child) apply(child, value);
+				}
+			};
+			apply(node, willCheck);
+			/**
+			* After the cascade, recompute ancestors so the public `checked` set
+			* doesn't carry parent keys that should be half-checked instead.
+			* Ancestors of `key` get visited bottom-up here.
+			*/
+			let parentKey = index.parentOf.get(key);
+			while (parentKey) {
+				const parent = index.byKey.get(parentKey);
+				if (!parent) break;
+				const childKeys = index.childrenOf.get(parentKey) ?? [];
+				let allEligibleChecked = true;
+				let anyEligible = false;
+				for (const ck of childKeys) {
+					const child = index.byKey.get(ck);
+					if (!child) continue;
+					if (!isNodeEligible(child)) continue;
+					anyEligible = true;
+					if (!next.has(ck)) {
+						allEligibleChecked = false;
+						break;
+					}
+				}
+				if (anyEligible && allEligibleChecked && isNodeEligible(parent)) next.add(parentKey);
+				else next.delete(parentKey);
+				parentKey = index.parentOf.get(parentKey);
+			}
+			if (!isControlled) setUncontrolledChecked(next);
+			if (onCheck) {
+				const finalChecked = new Set(next);
+				const finalHalf = /* @__PURE__ */ new Set();
+				for (const root of treeData) deriveCheckedState(root, index, finalChecked, finalHalf);
+				const checkedArr = Array.from(finalChecked);
+				const halfArr = Array.from(finalHalf);
+				const info = {
+					checked: willCheck,
+					node,
+					checkedNodes: checkedArr.map((k) => index.byKey.get(k)).filter((n) => !!n),
+					halfCheckedKeys: halfArr
+				};
+				if (wantsObjectShape) onCheck({
+					checked: checkedArr,
+					halfChecked: halfArr
+				}, info);
+				else onCheck(checkedArr, info);
+			}
+		})
+	};
+}
+
+//#endregion
+export { useCheckboxTree };
+//# sourceMappingURL=use-checkbox-tree.js.map

package/dist/components/content/Tree/use-checkbox-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-checkbox-tree.js","names":[],"sources":["../../../../src/components/content/Tree/use-checkbox-tree.ts"],"sourcesContent":["import { useMemo, useState } from 'react';\n\nimport { useEvent } from '../../../_internal/hooks';\n\nimport type { Key } from '@react-types/shared';\nimport type { TreeIndex } from './tree-index';\nimport type { CubeTreeNodeData, TreeOnCheckInfo } from './types';\n\nexport interface UseCheckboxTreeOptions {\n  treeData: CubeTreeNodeData[];\n  /**\n   * Pre-built tree index, shared with `Tree.tsx` so that `treeData`\n   * is walked exactly once per change rather than once per consumer.\n   */\n  index: TreeIndex;\n  isCheckable: boolean;\n  defaultCheckedKeys?: string[];\n  /** Either an array (AntD's default) or `{ checked, halfChecked }`. */\n  checkedKeys?: string[] | { checked: string[]; halfChecked?: string[] };\n  onCheck?: (\n    checked: Key[] | { checked: Key[]; halfChecked: Key[] },\n    info: TreeOnCheckInfo,\n  ) => void;\n}\n\nexport interface CheckboxTree {\n  /** Set of keys that are fully checked. */\n  checkedSet: Set<string>;\n  /** Set of keys that are in the indeterminate (half-checked) state. */\n  halfCheckedSet: Set<string>;\n  /** Toggle a key, propagating to descendants and updating ancestors. */\n  toggle: (key: string) => void;\n}\n\n/**\n * Returns whether a node should be checkable (i.e. clicking the\n * checkbox should affect it).\n *\n * Skips:\n * - explicitly disabled nodes (`isDisabled === true`)\n * - explicitly disabled checkboxes (`isCheckboxDisabled === true`)\n * - nodes that opted out via `isCheckable === false`\n */\nfunction isNodeEligible(node: CubeTreeNodeData | undefined): boolean {\n  if (!node) return false;\n  if (node.isDisabled) return false;\n  if (node.isCheckboxDisabled) return false;\n  if (node.isCheckable === false) return false;\n  return true;\n}\n\n/**\n * Recursively walk a subtree bottom-up, deriving which nodes are fully\n * checked vs half-checked.  Mutates `checked` and `half` in place.\n */\nfunction deriveCheckedState(\n  node: CubeTreeNodeData,\n  index: TreeIndex,\n  checked: Set<string>,\n  half: Set<string>,\n): { allChecked: boolean; anyChecked: boolean; anyEligible: boolean } {\n  const childKeys = index.childrenOf.get(node.key) ?? [];\n\n  if (childKeys.length === 0) {\n    const eligible = isNodeEligible(node);\n    const isChecked = checked.has(node.key);\n    return {\n      allChecked: !eligible || isChecked,\n      anyChecked: isChecked,\n      anyEligible: eligible,\n    };\n  }\n\n  let allChecked = true;\n  let anyChecked = false;\n  let anyEligible = false;\n\n  for (const childKey of childKeys) {\n    const child = index.byKey.get(childKey);\n    if (!child) continue;\n    const r = deriveCheckedState(child, index, checked, half);\n    if (r.anyEligible) anyEligible = true;\n    if (!r.allChecked) allChecked = false;\n    if (r.anyChecked) anyChecked = true;\n  }\n\n  const eligible = isNodeEligible(node);\n\n  if (!anyEligible) {\n    // No eligible descendants — this node behaves like a leaf for\n    // checking purposes: its own checked state stands as-is.\n    half.delete(node.key);\n  } else if (allChecked) {\n    checked.add(node.key);\n    half.delete(node.key);\n  } else if (anyChecked) {\n    checked.delete(node.key);\n    half.add(node.key);\n  } else {\n    checked.delete(node.key);\n    half.delete(node.key);\n  }\n\n  return {\n    allChecked: !eligible ? allChecked : checked.has(node.key) && allChecked,\n    anyChecked: anyChecked || checked.has(node.key),\n    anyEligible: anyEligible || eligible,\n  };\n}\n\nfunction normalizeControlledChecked(\n  controlled: UseCheckboxTreeOptions['checkedKeys'],\n): { checked: Set<string>; halfChecked: Set<string> } | null {\n  if (controlled == null) return null;\n  if (Array.isArray(controlled)) {\n    return {\n      checked: new Set(controlled),\n      halfChecked: new Set(),\n    };\n  }\n  return {\n    checked: new Set(controlled.checked ?? []),\n    halfChecked: new Set(controlled.halfChecked ?? []),\n  };\n}\n\n/**\n * Local hook implementing AntD-style cascading checkbox state.\n *\n * - `checked` and `halfChecked` are always derived together from a single\n *   `checked` set (the source of truth) so callers don't need to track\n *   indeterminate keys themselves.\n * - When the consumer passes `checkedKeys` as `{ checked, halfChecked }`,\n *   we keep the wire shape on the way out — same as AntD.\n * - Toggling a node propagates *down* (skipping ineligible descendants)\n *   and recomputes ancestors *up* in a single pass.\n */\nexport function useCheckboxTree(opts: UseCheckboxTreeOptions): CheckboxTree {\n  const {\n    treeData,\n    index,\n    isCheckable,\n    defaultCheckedKeys,\n    checkedKeys,\n    onCheck,\n  } = opts;\n\n  /**\n   * Normalize the controlled `checkedKeys` prop into stable `Set` instances.\n   * Memoized on the `checkedKeys` reference so unrelated re-renders don't\n   * invalidate the derivation memo below — `normalizeControlledChecked`\n   * allocates fresh `Set`s each call, which would otherwise force\n   * `deriveCheckedState` to re-walk the entire tree on every render in\n   * controlled mode.\n   */\n  const controlled = useMemo(\n    () => normalizeControlledChecked(checkedKeys),\n    [checkedKeys],\n  );\n  const isControlled = controlled != null;\n  const wantsObjectShape = checkedKeys != null && !Array.isArray(checkedKeys);\n\n  const [uncontrolledChecked, setUncontrolledChecked] = useState<Set<string>>(\n    () => new Set(defaultCheckedKeys ?? []),\n  );\n\n  const sourceChecked = isControlled\n    ? controlled!.checked\n    : uncontrolledChecked;\n\n  /**\n   * Derive `{ checked, halfChecked }` from the source-of-truth `checked` set\n   * by walking the tree bottom-up:\n   *\n   * - A parent is considered fully checked iff every eligible descendant\n   *   leaf is checked.\n   * - A parent is half-checked iff at least one eligible descendant is\n   *   checked or half-checked, but not all.\n   *\n   * Ineligible nodes (disabled / opt-out) are ignored when computing the\n   * parent's state — they neither force a parent into the unchecked nor\n   * half state.\n   */\n  const { checkedSet, halfCheckedSet } = useMemo(() => {\n    if (!isCheckable) {\n      return {\n        checkedSet: new Set<string>(),\n        halfCheckedSet: new Set<string>(),\n      };\n    }\n\n    /**\n     * If the consumer passed the object shape (`{ checked, halfChecked }`),\n     * they own the half-checked set and we use it as-is. With the array\n     * shape we still need to derive `halfChecked` ourselves — the consumer\n     * only provides `checked`, so parents should still light up\n     * indeterminate when only some descendants are checked.\n     */\n    if (isControlled && wantsObjectShape) {\n      return {\n        checkedSet: new Set(sourceChecked),\n        halfCheckedSet: new Set(controlled!.halfChecked),\n      };\n    }\n\n    const checked = new Set(sourceChecked);\n    const half = new Set<string>();\n\n    for (const root of treeData) {\n      deriveCheckedState(root, index, checked, half);\n    }\n\n    return { checkedSet: checked, halfCheckedSet: half };\n  }, [\n    isCheckable,\n    isControlled,\n    wantsObjectShape,\n    sourceChecked,\n    controlled,\n    treeData,\n    index,\n  ]);\n\n  const toggle = useEvent((key: string) => {\n    const node = index.byKey.get(key);\n    if (!node || !isNodeEligible(node)) return;\n\n    const isCurrentlyChecked = checkedSet.has(key);\n    const willCheck = !isCurrentlyChecked;\n\n    /**\n     * Seed from the derived `checkedSet`, not `sourceChecked`. The\n     * source-of-truth set may only contain leaf keys (e.g. when\n     * `defaultCheckedKeys` is leaf-only, or a consumer in controlled-array\n     * mode passes only leaves). The ancestor walk below decides whether\n     * each ancestor is fully checked by inspecting its direct children\n     * via `next.has(ck)` — those children may themselves be inner nodes\n     * whose \"fully checked\" status only exists in the derived set. Seeding\n     * from `sourceChecked` causes a sibling subtree's parent key to be\n     * missing from `next`, which would incorrectly drop the grandparent\n     * from the stored state (the next render's `useMemo` self-corrects,\n     * but the intermediate stored value violates the cascade invariant).\n     */\n    const next = new Set(checkedSet);\n\n    const apply = (n: CubeTreeNodeData, value: boolean) => {\n      if (!isNodeEligible(n)) return;\n      if (value) next.add(n.key);\n      else next.delete(n.key);\n      const childKeys = index.childrenOf.get(n.key) ?? [];\n      for (const ck of childKeys) {\n        const child = index.byKey.get(ck);\n        if (child) apply(child, value);\n      }\n    };\n\n    apply(node, willCheck);\n\n    /**\n     * After the cascade, recompute ancestors so the public `checked` set\n     * doesn't carry parent keys that should be half-checked instead.\n     * Ancestors of `key` get visited bottom-up here.\n     */\n    let parentKey = index.parentOf.get(key);\n    while (parentKey) {\n      const parent = index.byKey.get(parentKey);\n      if (!parent) break;\n      const childKeys = index.childrenOf.get(parentKey) ?? [];\n      let allEligibleChecked = true;\n      let anyEligible = false;\n      for (const ck of childKeys) {\n        const child = index.byKey.get(ck);\n        if (!child) continue;\n        if (!isNodeEligible(child)) continue;\n        anyEligible = true;\n        if (!next.has(ck)) {\n          allEligibleChecked = false;\n          break;\n        }\n      }\n      if (anyEligible && allEligibleChecked && isNodeEligible(parent)) {\n        next.add(parentKey);\n      } else {\n        next.delete(parentKey);\n      }\n      parentKey = index.parentOf.get(parentKey);\n    }\n\n    if (!isControlled) {\n      setUncontrolledChecked(next);\n    }\n\n    if (onCheck) {\n      const finalChecked = new Set(next);\n      const finalHalf = new Set<string>();\n\n      for (const root of treeData) {\n        deriveCheckedState(root, index, finalChecked, finalHalf);\n      }\n\n      const checkedArr = Array.from(finalChecked);\n      const halfArr = Array.from(finalHalf);\n      const checkedNodes: CubeTreeNodeData[] = checkedArr\n        .map((k) => index.byKey.get(k))\n        .filter((n): n is CubeTreeNodeData => !!n);\n\n      const info: TreeOnCheckInfo = {\n        checked: willCheck,\n        node,\n        checkedNodes,\n        halfCheckedKeys: halfArr,\n      };\n\n      if (wantsObjectShape) {\n        onCheck({ checked: checkedArr, halfChecked: halfArr }, info);\n      } else {\n        onCheck(checkedArr, info);\n      }\n    }\n  });\n\n  return { checkedSet, halfCheckedSet, toggle };\n}\n"],"mappings":"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"}

package/dist/components/content/Tree/use-load-data.js

@@ -0,0 +1,75 @@
+/** @license MIT | @cube-dev/ui-kit v0.129.0 | Cube Dev Team */
+import { useEvent } from "../../../_internal/hooks/use-event.js";
+import { useRef, useState } from "react";
+
+//#region src/components/content/Tree/use-load-data.ts
+/**
+* Tracks which rows are currently fetching their children via `loadData`
+* and exposes a setter for the Tree to call after every expand change.
+*
+* `loadData` is fired exactly once per key per "first expand" event:
+*
+* - Skipped if there is no `loadData` callback.
+* - Skipped for leaf nodes (`isLeaf === true`).
+* - Skipped if the node already has `children` (already loaded).
+* - Skipped if a previous fetch for the same key is still in flight.
+*
+* The promise's resolution is awaited only to clear the `loading` mod;
+* the consumer is expected to commit the new children to the controlled
+* `treeData` themselves (matching AntD's pattern).
+*/
+function useLoadData(opts) {
+	const { nodesByKey, loadData, initialExpandedKeys } = opts;
+	const [loadingKeys, setLoadingKeys] = useState(() => /* @__PURE__ */ new Set());
+	const previousExpandedRef = useRef(new Set(initialExpandedKeys));
+	const inFlightRef = useRef(/* @__PURE__ */ new Set());
+	return {
+		loadingKeys,
+		onExpandedChanged: useEvent((expandedKeys) => {
+			const next = /* @__PURE__ */ new Set();
+			for (const k of expandedKeys) next.add(String(k));
+			const prev = previousExpandedRef.current;
+			const newlyExpanded = [];
+			for (const k of next) if (!prev.has(k)) newlyExpanded.push(k);
+			previousExpandedRef.current = next;
+			if (!loadData || newlyExpanded.length === 0) return;
+			const toLoad = [];
+			for (const key of newlyExpanded) {
+				const node = nodesByKey.get(key);
+				if (!node) continue;
+				if (node.isLeaf) continue;
+				if (node.children && node.children.length > 0) continue;
+				if (inFlightRef.current.has(key)) continue;
+				inFlightRef.current.add(key);
+				toLoad.push(key);
+			}
+			if (toLoad.length === 0) return;
+			setLoadingKeys((current) => {
+				const updated = new Set(current);
+				for (const k of toLoad) updated.add(k);
+				return updated;
+			});
+			for (const key of toLoad) {
+				const loadNode = nodesByKey.get(key);
+				Promise.resolve(loadData({
+					key,
+					children: loadNode?.children
+				})).catch((err) => {
+					console.error(`[Tree] loadData failed for key "${key}":`, err);
+				}).finally(() => {
+					inFlightRef.current.delete(key);
+					setLoadingKeys((current) => {
+						if (!current.has(key)) return current;
+						const updated = new Set(current);
+						updated.delete(key);
+						return updated;
+					});
+				});
+			}
+		})
+	};
+}
+
+//#endregion
+export { useLoadData };
+//# sourceMappingURL=use-load-data.js.map