haze-ui 1.34.0 → 1.35.0

package/dist/types/components/Toggle/Toggle.d.ts

@@ -1,19 +1,26 @@
-import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ComponentPropsWithRef, ElementType } from 'react';
 import type { ControlOrValue } from 'react-use-control';
-type ToggleProps = {
+type ToggleOwnProps = {
     /** Whether the toggle is pressed; a control for full external ownership. */
     pressed?: ControlOrValue<boolean>;
     size?: 'sm' | 'md' | 'lg';
     /** Equal padding on all sides — for icon-only square toggles. */
     square?: boolean;
-    /** Forwarded to the underlying `<button>` — form bridges and
-     * `ref.current.focus()` reach. */
-    ref?: Ref<HTMLButtonElement>;
-} & Omit<ComponentPropsWithoutRef<'button'>, 'type' | 'aria-pressed'>;
+};
+/**
+ * Polymorphic like Button's `as` (delegated to {@link ToggleCore}):
+ * `as='a'` renders the toggle skin on a real anchor — href/link
+ * semantics with the same `aria-pressed` wiring.
+ */
+type ToggleProps<T extends ElementType = 'button'> = ToggleOwnProps & {
+    /** Render element — 'button' (default), 'a', or any component that
+     * forwards props and ref to a DOM element (a router Link). */
+    as?: T;
+} & Omit<ComponentPropsWithRef<T>, keyof ToggleOwnProps | 'as' | 'type' | 'aria-pressed'>;
 /**
  * A momentary pressed-state button (aria-pressed) for one-shot modes —
  * bold, mute, grid/list view. `pressed` is one prop, two modes: a plain
  * boolean leaves state internal, a control hands ownership to the caller.
  */
-export default function Toggle({ pressed: pressedControl, size, square, className, onClick, ref, ...rest }: ToggleProps): import("react").JSX.Element;
-export type { ToggleProps };
+export default function Toggle<T extends ElementType = 'button'>({ pressed: pressedControl, size, square, as, className, onClick, ...rest }: ToggleProps<T>): import("react").JSX.Element;
+export type { ToggleOwnProps, ToggleProps };

package/dist/types/components/Toggle/ToggleCore.d.ts

@@ -1,5 +1,5 @@
-import type { ComponentPropsWithoutRef, Ref } from 'react';
-type ToggleCoreProps = {
+import type { ComponentPropsWithRef, ComponentPropsWithoutRef, ElementType } from 'react';
+type ToggleCoreOwnProps = {
     pressed: boolean;
     onPressedChange: (pressed: boolean) => void;
     /** Native click event passthrough — invoked with the DOM event after
@@ -9,9 +9,18 @@ type ToggleCoreProps = {
     /** Equal padding on all sides — for icon-only square toggles. */
     square?: boolean;
     className?: string;
-    /** Forwarded to the `<button>` element. */
-    ref?: Ref<HTMLButtonElement>;
-} & Omit<ComponentPropsWithoutRef<'button'>, 'type' | 'aria-pressed'>;
+};
+/**
+ * Polymorphic like Button's `as`: the toggle skin and the pressed wiring
+ * (`aria-pressed`, click → `onPressedChange`) always land on the rendered
+ * element. `as='a'` renders a pressed-state anchor — `type='button'` is
+ * gated to the native-button shape.
+ */
+type ToggleCoreProps<T extends ElementType = 'button'> = ToggleCoreOwnProps & {
+    /** Render element — 'button' (default), 'a', or any component that
+     * forwards props and ref to a DOM element (a router Link). */
+    as?: T;
+} & Omit<ComponentPropsWithRef<T>, keyof ToggleCoreOwnProps | 'as' | 'type' | 'aria-pressed'>;
 /**
  * The controlled half of Toggle: a momentary pressed-state button
  * (`<button aria-pressed>`) — one-shot commands like bold/mute, not the
@@ -19,5 +28,5 @@ type ToggleCoreProps = {
  * lives here: it renders `pressed` and reports clicks through
  * `onPressedChange`, so the sugar (or any owner) owns the truth.
  */
-export default function ToggleCore({ pressed, onPressedChange, onNativeClick, size, square, className, ref, ...rest }: ToggleCoreProps): import("react").JSX.Element;
-export type { ToggleCoreProps };
+export default function ToggleCore<T extends ElementType = 'button'>({ pressed, onPressedChange, onNativeClick, size, square, as, className, ...rest }: ToggleCoreProps<T>): import("react").JSX.Element;
+export type { ToggleCoreOwnProps, ToggleCoreProps };

package/dist/types/components/Toolbar/ToolbarButton.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithRef, ElementType } from 'react';
 /**
  * A toolbar item wearing Button's skin — the same `variant`/`size`/
  * `square` props (see ButtonLink for the same styles.ts reuse), quieter
@@ -11,10 +11,22 @@ import type { ComponentPropsWithoutRef } from 'react';
  * look is keyed off that state attribute, so no extra prop can drift
  * out of sync with what assistive tech announces.
  */
-type ToolbarButtonProps = {
+type ToolbarButtonOwnProps = {
     variant?: 'solid' | 'outline' | 'ghost';
     size?: 'sm' | 'md' | 'lg';
     square?: boolean;
-} & Omit<ComponentPropsWithoutRef<'button'>, 'type'>;
-export default function ToolbarButton({ variant, size, square, className, ...rest }: ToolbarButtonProps): import("react").JSX.Element;
-export type { ToolbarButtonProps };
+};
+/**
+ * Polymorphic like Button's `as`: the skin and the toolbar wiring
+ * (`data-haze-toolbar-item`, the roving `tabIndex={-1}`) always land on
+ * the rendered element — `as='a'` renders a link-shaped toolbar item
+ * that still joins the roving model. `type='button'` is gated to the
+ * native-button shape.
+ */
+type ToolbarButtonProps<T extends ElementType = 'button'> = ToolbarButtonOwnProps & {
+    /** Render element — 'button' (default), 'a', or any component that
+     * forwards props and ref to a DOM element (a router Link). */
+    as?: T;
+} & Omit<ComponentPropsWithRef<T>, keyof ToolbarButtonOwnProps | 'as' | 'type'>;
+export default function ToolbarButton<T extends ElementType = 'button'>({ variant, size, square, as, className, ...rest }: ToolbarButtonProps<T>): import("react").JSX.Element;
+export type { ToolbarButtonOwnProps, ToolbarButtonProps };

package/dist/types/components/Toolbar/ToolbarToggle.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithRef, ElementType, MouseEvent } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 /**
  * A toolbar item that toggles: ToolbarButton's skin and roving behavior
@@ -7,13 +7,30 @@ import type { ControlOrValue } from 'react-use-control';
  * when passed a control. The pressed look is keyed off `aria-pressed`,
  * so the visual state can never drift from what assistive tech announces.
  */
-type ToolbarToggleProps = {
+type ToolbarToggleOwnProps = {
     /** Whether the item is pressed; a control for full external ownership. */
     pressed?: ControlOrValue<boolean>;
     variant?: 'solid' | 'outline' | 'ghost';
     size?: 'sm' | 'md' | 'lg';
     /** Equal padding on all sides — for icon-only square items. */
     square?: boolean;
-} & Omit<ComponentPropsWithoutRef<'button'>, 'type' | 'aria-pressed'>;
-export default function ToolbarToggle({ pressed: pressedControl, variant, size, square, className, onClick, ...rest }: ToolbarToggleProps): import("react").JSX.Element;
-export type { ToolbarToggleProps };
+    /**
+     * Element-agnostic click: whatever element `as` rendered, the
+     * consumer's handler fires first — the pressed-state toggle rides
+     * after it.
+     */
+    onClick?: (event: MouseEvent<HTMLElement>) => void;
+};
+/**
+ * Polymorphic like Button's `as`: the skin, the toolbar wiring
+ * (`data-haze-toolbar-item`, the roving `tabIndex={-1}`) and the
+ * `aria-pressed` state always land on the rendered element.
+ * `type='button'` is gated to the native-button shape.
+ */
+type ToolbarToggleProps<T extends ElementType = 'button'> = ToolbarToggleOwnProps & {
+    /** Render element — 'button' (default), 'a', or any component that
+     * forwards props and ref to a DOM element (a router Link). */
+    as?: T;
+} & Omit<ComponentPropsWithRef<T>, keyof ToolbarToggleOwnProps | 'as' | 'type' | 'aria-pressed'>;
+export default function ToolbarToggle<T extends ElementType = 'button'>({ pressed: pressedControl, variant, size, square, as, className, onClick, ...rest }: ToolbarToggleProps<T>): import("react").JSX.Element;
+export type { ToolbarToggleOwnProps, ToolbarToggleProps };

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

@@ -1,3 +1,3 @@
 import type { TreeProps, TreeVirtualizedConfig } from './types.js';
-export default function Tree({ treeData, multiple, checkable, checkStrictly, selectable, disabled, blockNode, showLine, showIcon, switcherIcon, loadingIcon, titleRender, iconRender, virtualized, loadData, searchValue, rowWrap, keyboardNavigation, expandedKeys: expandedKeysControl, selectedKeys: selectedKeysControl, checkedKeys: checkedKeysControl, ref, className, onExpand, onSelect, onCheck, }: TreeProps): import("react").JSX.Element;
+export default function Tree({ treeData, multiple, checkable, checkStrictly, selectable, disabled, blockNode, showLine, showIcon, switcherIcon, loadingIcon, titleRender, iconRender, virtualized, loadData, searchValue, rowWrap, keyboardNavigation, scrollHandleRef, expandedKeys: expandedKeysControl, selectedKeys: selectedKeysControl, checkedKeys: checkedKeysControl, ref, className, onExpand, onSelect, onCheck, }: TreeProps): import("react").JSX.Element;
 export type { TreeProps, TreeVirtualizedConfig };

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

@@ -1,4 +1,7 @@
 export { default as Tree } from './Tree.js';
 export { default as SortableTree } from './SortableTree.js';
-export type { TreeProps, TreeNodeData } from './types.js';
+export { useTree } from './useTree.js';
+export type { TreeProps, TreeNodeData, TreeScrollHandle } from './types.js';
+export type { UseTreeOptions, UseTreeResult, TreeScrollToOptions, } from './useTree.js';
 export type { SortableTreeProps, SortableTreeMoveInfo } from './SortableTree.js';
+export type { VisibleTreeRow } from './utils.js';

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

@@ -1,5 +1,6 @@
 import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+import type { VirtualListAlign } from '../VirtualList/index.js';
 /**
  * Tree 节点数据接口
  */
@@ -46,6 +47,25 @@ export type TreeVirtualizedConfig = {
      */
     overscan?: number;
 };
+/**
+ * Imperative scroll surface the tree reports through the internal
+ * `scrollHandleRef` seam (`useTree` wires it via `treeProps`;
+ * `SortableTree` forwards it with its `...rest`).
+ */
+export type TreeScrollHandle = {
+    /**
+     * Bring the row for `key` into view — `align` defaults to `'auto'`
+     * (VirtualList semantics: no-op while fully visible, entering from
+     * below pins to the start edge, from above to the end edge).
+     * Virtualized trees window-shift through `VirtualListHandle
+     * .scrollToIndex`; nested trees `scrollIntoView` the row. The request
+     * is durable: a `key` that is not currently visible (its ancestors
+     * are still collapsing into view — e.g. `useTree`'s `autoExpand`
+     * write has not committed yet) stays pending and resolves on the next
+     * rows change. It never expands anything by itself.
+     */
+    scrollToKey: (key: string, align?: VirtualListAlign) => void;
+};
 /**
  * Tree 组件 Props
  */

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

@@ -0,0 +1,96 @@
+import type { Dispatch, SetStateAction } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+import type { VirtualListAlign } from '../VirtualList/index.js';
+import type { TreeNodeData, TreeProps } from './types.js';
+import type { VisibleTreeRow } from './utils.js';
+/**
+ * Options for `useTree`.
+ */
+export type UseTreeOptions = {
+    /**
+     * The same `treeData` you hand to `<Tree>` — the source the path and
+     * flattening queries reason about. (Lazy `loadData` children live in
+     * the tree's internal cache and are invisible here; see `getPath`.)
+     */
+    treeData: TreeNodeData[];
+    /**
+     * Expansion state, `ControlOrValue<string[]>` — the exact contract of
+     * `Tree.expandedKeys`. Pass a `Control` (from your own `useControl`)
+     * for controlled sharing, or a plain array as the uncontrolled
+     * initial value; omit for `[]`. The hook threads the resulting
+     * control into `treeProps`, so switcher clicks inside the tree and
+     * `setExpandedKeys` writes are the same state.
+     */
+    expandedKeys?: ControlOrValue<string[]>;
+};
+/** Options for `UseTreeResult.scrollTo`. */
+export type TreeScrollToOptions = {
+    /**
+     * Expand the target's ancestor chain first (default `false` — scroll
+     * never silently mutates expansion). The scroll request is durable:
+     * it resolves on the commit that makes the row visible.
+     */
+    autoExpand?: boolean;
+    /** Row alignment once scrolled — `VirtualListAlign`, default `'auto'`. */
+    align?: VirtualListAlign;
+};
+/**
+ * Result of `useTree`.
+ */
+export type UseTreeResult = {
+    /**
+     * Props for `<Tree>` (or `<SortableTree>`): the `treeData` you passed
+     * in, the shared expansion control, and the internal scroll-handle
+     * wiring. Spread as `<Tree {...tree.treeProps} />` so `scrollTo` and
+     * the tree stay connected; the queries work without it too.
+     */
+    treeProps: Pick<TreeProps, 'treeData' | 'expandedKeys' | 'scrollHandleRef'>;
+    /** Current expanded keys (the value behind the shared control). */
+    expandedKeys: string[];
+    /**
+     * Write expansion — the same `Dispatch<SetStateAction<string[]>>` the
+     * tree's switcher writes through; `onExpand` on `<Tree>` still fires
+     * for user toggles.
+     */
+    setExpandedKeys: Dispatch<SetStateAction<string[]>>;
+    /**
+     * Ancestor chain of `key`, root first and the node itself last — `[]`
+     * for an unknown key. Strict ancestors are `path.slice(0, -1)`.
+     */
+    getPath: (key: string) => TreeNodeData[];
+    /**
+     * The currently visible rows in depth-first order — exactly the item
+     * sequence a `virtualized` tree windows over (one entry per rendered
+     * treeitem, parents before children, expanded subtrees only).
+     */
+    flattenVisible: () => VisibleTreeRow[];
+    /**
+     * Scroll the row for `key` into view: virtualized trees window-shift
+     * via `VirtualListHandle.scrollToIndex`, nested trees `scrollIntoView`
+     * the row. With `autoExpand` the ancestors are expanded first and the
+     * scroll lands on that commit. Requires `treeProps` to be spread onto
+     * the tree (the hook holds no DOM otherwise); an unknown key is a
+     * durable no-op — nothing expands, nothing scrolls.
+     */
+    scrollTo: (key: string, options?: TreeScrollToOptions) => void;
+};
+/**
+ * Companion hook for `Tree` (the AntD v6 `useTree` slot): owns the
+ * expansion state through `react-use-control`, answers path/flattening
+ * queries against the tree data, and drives imperative scrolling with
+ * optional ancestor auto-expansion.
+ *
+ * ```tsx
+ * const tree = useTree({ treeData });
+ * // tree.getPath('0-0-1') → [root, '0-0', the node] — breadcrumb-ready
+ * <Tree {...tree.treeProps} virtualized />
+ * <button onClick={() => tree.scrollTo('0-0-1', { autoExpand: true })}>
+ *   Jump
+ * </button>
+ * ```
+ *
+ * - `expandedKeys` accepts a control (controlled) or a plain array
+ *   (uncontrolled initial) — the same one-prop contract as the tree.
+ * - `scrollTo` never mutates expansion unless `autoExpand` is set.
+ */
+export declare function useTree(options: UseTreeOptions): UseTreeResult;

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

@@ -35,6 +35,13 @@ export declare function flattenTreeData(data: TreeNodeData[]): TreeNodeData[];
 export declare function findNodeByKey(data: TreeNodeData[], key: string): TreeNodeData | null;
 export declare function getChildKeys(data: TreeNodeData[], parentKey: string): string[];
 export declare function getParentKey(data: TreeNodeData[], targetKey: string, parentKey?: string): string | null;
+/**
+ * Ancestor chain of `key`: root first, the node itself last — `[]` when
+ * the key is unknown. One DFS pass (`getParentKey` re-walked per level
+ * would be O(depth · n)); the caller drops the last entry for the strict
+ * ancestors.
+ */
+export declare function getNodePath(data: TreeNodeData[], key: string): TreeNodeData[];
 export declare function getAllLeafKeys(data: TreeNodeData[]): string[];
 /**
  * Case-insensitive `[start, end)` ranges of every non-overlapping

package/dist/types/components/VirtualList/VirtualList.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/headless/index.d.ts

@@ -32,6 +32,7 @@ import { focusFirst, getTabbables, isTabbable, TABBABLE_SELECTOR } from '../util
 import { useFocusScope } from '../utils/focus-scope.js';
 import { getEnabledMenuItems, useMenuKeyboard, useRovingTabindex } from '../utils/menuKeyboard.js';
 import { Presence, whenExitSettles } from '../utils/presence.js';
+import { Portal } from '../utils/portal.js';
 import { mergeRefs } from '../utils/refs.js';
 import { SUBMENU_CLOSE_GRACE_MS, SUBMENU_OPEN_DELAY_MS, SubmenuProvider, useSubmenu, useSubmenuContext } from '../utils/submenu.js';
 import { useViewTransitionFlip } from '../utils/view-transition.js';
@@ -129,6 +130,21 @@ export type { PresenceProps } from '../utils/presence.js';
  * settle. The imperative companion to {@link Presence}.
  */
 export { whenExitSettles };
+/**
+ * Renders children into a DOM container outside the current React tree
+ * position — `document.body` by default, so overlays escape ancestor
+ * `overflow`, `transform` and stacking contexts. SSR-safe: nothing
+ * renders until the client mounts (no `document` access during render),
+ * and `disabled` renders the children in place instead. The primitive
+ * behind haze-ui's overlay families, exported for composing your own.
+ */
+export { Portal };
+/**
+ * Props accepted by {@link Portal}: `children`, an optional `container`
+ * (element or lazy getter, default `document.body`), and `disabled` to
+ * render in place.
+ */
+export type { PortalProps } from '../utils/portal.js';
 /**
  * Focus-domain hook for overlays: attach the returned ref callback to a
  * container and flip `enabled` to get initial focus, focus restoration

package/dist/types/hooks/index.d.ts

@@ -1,3 +1,5 @@
+export { useAnchorSpy } from './useAnchorSpy.js';
+export type { UseAnchorSpyOptions, UseAnchorSpyResult } from './useAnchorSpy.js';
 export { useBusyPressable } from './useBusyPressable.js';
 export { useClipboard } from './useClipboard.js';
 export type { UseClipboardResult } from './useClipboard.js';
@@ -30,4 +32,6 @@ export type { UseResizeObserverOptions, UseResizeObserverResult, } from './useRe
 export { usePrefersReducedMotion } from './usePrefersReducedMotion.js';
 export { usePrevious } from './usePrevious.js';
 export { useSessionStorage } from './useSessionStorage.js';
+export { useStorageState } from './useStorageState.js';
+export type { StorageKind } from './useStorageState.js';
 export { useTitle } from './useTitle.js';

package/dist/types/hooks/useAnchorSpy.d.ts

@@ -0,0 +1,62 @@
+import type { Dispatch, SetStateAction } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type UseAnchorSpyOptions = {
+    /** 追踪的区块 id 列表（文档顺序）。 */
+    ids: readonly string[];
+    /** 滚动容器，默认 `window`。 */
+    getContainer?: () => HTMLElement | Window;
+    /** 容器顶部与区块顶部保留的距离（吸顶头高度），px。 */
+    offsetTop?: number;
+    /** 滚动侦测触发线，距容器顶部 px（仅无 IntersectionObserver 的回退引擎）。 */
+    bounds?: number;
+    /** 高亮区块 id：接受 control（受控）或普通值（非受控初值）。 */
+    activeId?: ControlOrValue<string>;
+};
+type UseAnchorSpyResult = {
+    /** 当前高亮区块 id；无匹配时为空串。 */
+    activeId: string;
+    /** 写入高亮（点击导航、外部跳转），受控时同步到外部状态。 */
+    setActiveId: Dispatch<SetStateAction<string>>;
+};
+/**
+ * 滚动侦测（scroll-spy）：追踪一组区块 id，返回当前应高亮的那个。
+ *
+ * ```tsx
+ * function TocNav() {
+ *   const { activeId, setActiveId } = useAnchorSpy({ ids: ['basics', 'api'] });
+ *   return (
+ *     <nav>
+ *       {['basics', 'api'].map((id) => (
+ *         <a
+ *           key={id}
+ *           href={`#${id}`}
+ *           aria-current={activeId === id ? 'true' : undefined}
+ *           onClick={(event) => {
+ *             event.preventDefault();
+ *             setActiveId(id);
+ *           }}
+ *         >
+ *           {id}
+ *         </a>
+ *       ))}
+ *     </nav>
+ *   );
+ * }
+ * ```
+ *
+ * - IntersectionObserver 引擎：区块与 `offsetTop` 以下的视口带相交即
+ *   「可见」，按 `ids` 顺序取最靠前的可见区块。容器是元素时作为
+ *   observer root，否则用视口。
+ * - 回退引擎（无 IntersectionObserver 的环境）：监听容器 scroll，激活
+ *   最后一个顶部越过 `bounds` 触发线的区块。不做初始运行——初值交给
+ *   `activeId`（jsdom 的零矩形会误报）。
+ * - `activeId` 走 react-use-control：传 control 受控、传普通值作
+ *   非受控初值（默认 `ids[0]`）。
+ * - `ids` 身份随父级渲染漂移只会重建订阅——观察者重新上报当前位置，
+ *   行为不变。
+ *
+ * @param options 见 {@link UseAnchorSpyOptions}。
+ * @returns `{ activeId, setActiveId }`。
+ */
+export declare function useAnchorSpy({ ids, getContainer, offsetTop, bounds, activeId: activeIdControl, }: UseAnchorSpyOptions): UseAnchorSpyResult;
+export type { UseAnchorSpyOptions, UseAnchorSpyResult };

package/dist/types/icons/index.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Curated icon re-exports from [lucide-react](https://lucide.dev) — the
+ * `haze-ui/icons` subpath.
+ *
+ * Curation strategy: the ~100 most common UI glyphs (navigation chevrons,
+ * form feedback, media, communication, files, commerce), re-exported as
+ * individual named exports in alphabetical order. The full lucide catalog
+ * (1800+ icons) stays one `lucide-react` import away — import it directly
+ * when a rare glyph is needed; this barrel only fixes the common vocabulary
+ * and keeps the default choice obvious.
+ *
+ * Tree-shaking: `lucide-react` is a regular dependency with
+ * `sideEffects: false`, and the lib build emits `preserveModules` output
+ * with `lucide-react` external — an icon that is never imported costs zero
+ * bytes (and consumers who import none of haze-ui's icons never pull the
+ * package into their graph at all; it tree-shakes away entirely).
+ *
+ * Pairing with the `Icon` component:
+ *
+ * ```tsx
+ * import { Icon } from 'haze-ui';
+ * import { Check } from 'haze-ui/icons';
+ *
+ * <Icon icon={Check} />            // 20px (md) by default
+ * <Icon icon={Check} size='sm' />  // 16px — see hazeIconSize below
+ * ```
+ */
+export { ArrowDown } from 'lucide-react';
+export { ArrowLeft } from 'lucide-react';
+export { ArrowRight } from 'lucide-react';
+export { ArrowUp } from 'lucide-react';
+export { ArrowUpDown } from 'lucide-react';
+export { ArrowUpRight } from 'lucide-react';
+export { Asterisk } from 'lucide-react';
+export { AtSign } from 'lucide-react';
+export { Bell } from 'lucide-react';
+export { BellOff } from 'lucide-react';
+export { Bold } from 'lucide-react';
+export { BookOpen } from 'lucide-react';
+export { Bookmark } from 'lucide-react';
+export { Calendar } from 'lucide-react';
+export { ChartColumn } from 'lucide-react';
+export { ChartLine } from 'lucide-react';
+export { ChartPie } from 'lucide-react';
+export { Check } from 'lucide-react';
+export { CheckCheck } from 'lucide-react';
+export { ChevronDown } from 'lucide-react';
+export { ChevronLeft } from 'lucide-react';
+export { ChevronRight } from 'lucide-react';
+export { ChevronUp } from 'lucide-react';
+export { ChevronsUpDown } from 'lucide-react';
+export { Circle } from 'lucide-react';
+export { CircleQuestionMark } from 'lucide-react';
+export { Clipboard } from 'lucide-react';
+export { Clock } from 'lucide-react';
+export { Cloud } from 'lucide-react';
+export { CloudOff } from 'lucide-react';
+export { Code } from 'lucide-react';
+export { Command } from 'lucide-react';
+export { Copy } from 'lucide-react';
+export { Download } from 'lucide-react';
+export { Ellipsis } from 'lucide-react';
+export { EllipsisVertical } from 'lucide-react';
+export { ExternalLink } from 'lucide-react';
+export { Eye } from 'lucide-react';
+export { EyeOff } from 'lucide-react';
+export { File } from 'lucide-react';
+export { FileText } from 'lucide-react';
+export { Flag } from 'lucide-react';
+export { Folder } from 'lucide-react';
+export { FolderOpen } from 'lucide-react';
+export { Funnel } from 'lucide-react';
+export { Globe } from 'lucide-react';
+export { Hash } from 'lucide-react';
+export { Heart } from 'lucide-react';
+export { House } from 'lucide-react';
+export { Image } from 'lucide-react';
+export { Inbox } from 'lucide-react';
+export { Info } from 'lucide-react';
+export { Italic } from 'lucide-react';
+export { LayoutGrid } from 'lucide-react';
+export { LayoutList } from 'lucide-react';
+export { Link } from 'lucide-react';
+export { List } from 'lucide-react';
+export { Loader } from 'lucide-react';
+export { LoaderCircle } from 'lucide-react';
+export { Lock } from 'lucide-react';
+export { LockOpen } from 'lucide-react';
+export { LogOut } from 'lucide-react';
+export { Mail } from 'lucide-react';
+export { MapPin } from 'lucide-react';
+export { Menu } from 'lucide-react';
+export { MessageCircle } from 'lucide-react';
+export { MessageSquare } from 'lucide-react';
+export { Mic } from 'lucide-react';
+export { Minus } from 'lucide-react';
+export { Moon } from 'lucide-react';
+export { Pencil } from 'lucide-react';
+export { Phone } from 'lucide-react';
+export { Play } from 'lucide-react';
+export { Plus } from 'lucide-react';
+export { QrCode } from 'lucide-react';
+export { RefreshCw } from 'lucide-react';
+export { Save } from 'lucide-react';
+export { Search } from 'lucide-react';
+export { Send } from 'lucide-react';
+export { Settings } from 'lucide-react';
+export { Shield } from 'lucide-react';
+export { ShieldCheck } from 'lucide-react';
+export { ShoppingCart } from 'lucide-react';
+export { Sparkles } from 'lucide-react';
+export { SquareCheck } from 'lucide-react';
+export { Star } from 'lucide-react';
+export { Sun } from 'lucide-react';
+export { Tag } from 'lucide-react';
+export { Trash } from 'lucide-react';
+export { Underline } from 'lucide-react';
+export { Upload } from 'lucide-react';
+export { User } from 'lucide-react';
+export { UserPlus } from 'lucide-react';
+export { Users } from 'lucide-react';
+export { Volume2 } from 'lucide-react';
+export { VolumeX } from 'lucide-react';
+export { X } from 'lucide-react';
+export { Zap } from 'lucide-react';
+export { ZoomIn } from 'lucide-react';
+export { ZoomOut } from 'lucide-react';
+/**
+ * Pixel sizes the `Icon` component maps its `size` prop to (`sm`/`md`/`lg`
+ * → 16/20/24) — kept in lockstep with `components/Icon/Icon.tsx`. Use it
+ * when an icon lands outside `<Icon>` (e.g. a lucide glyph sized directly
+ * next to haze-ui components) so both paths agree on the size scale.
+ */
+export declare const hazeIconSize: Readonly<{
+    readonly sm: 16;
+    readonly md: 20;
+    readonly lg: 24;
+}>;

package/dist/types/index.d.ts

@@ -7,6 +7,7 @@ export { spacing } from './tokens/spacing.js';
 export { compact } from './tokens/density.js';
 export { typography } from './tokens/typography.js';
 export { motion, motionPresets } from './tokens/motion.js';
+export { remScale } from './tokens/zoom.js';
 export type { MotionPreset } from './tokens/motion.js';
 export { TOKEN_REGISTRY, COMPONENT_TOKENS } from './tokens/registry.js';
 export type { TokenDef } from './tokens/registry.js';
@@ -38,6 +39,8 @@ export { Popconfirm } from './components/Popconfirm/index.js';
 export type { PopconfirmProps, PopconfirmHandle, PopconfirmPlacement } from './components/Popconfirm/index.js';
 export { Popover } from './components/Popover/index.js';
 export type { PopoverProps, PopoverHandle, PopoverClassNames } from './components/Popover/index.js';
+export { NotificationCenter } from './components/NotificationCenter/index.js';
+export type { NotificationCenterProps, NotificationCenterClassNames, NotificationCenterItem, NotificationCenterSeverity, NotificationCenterKind } from './components/NotificationCenter/index.js';
 export { Card, cardVariants } from './components/Card/index.js';
 export type { CardProps } from './components/Card/index.js';
 export { Radio, RadioGroup, RadioGroupCore } from './components/Radio/index.js';
@@ -92,8 +95,9 @@ export { Datepicker, DatepickerCore } from './components/Datepicker/index.js';
 export type { DatepickerProps, DatepickerCoreProps, DatepickerPreset } from './components/Datepicker/index.js';
 export { DateField, DateFieldCore } from './components/DateField/index.js';
 export type { DateFieldProps, DateFieldCoreProps, DatePlaceholder, DateLabels } from './components/DateField/index.js';
-export { Tree, SortableTree } from './components/Tree/index.js';
-export type { TreeProps, TreeNodeData, SortableTreeProps, SortableTreeMoveInfo } from './components/Tree/index.js';
+export { Tree, SortableTree, useTree } from './components/Tree/index.js';
+export type { TreeProps, TreeNodeData, TreeScrollHandle, SortableTreeProps, SortableTreeMoveInfo } from './components/Tree/index.js';
+export type { UseTreeOptions, UseTreeResult, TreeScrollToOptions, VisibleTreeRow } from './components/Tree/index.js';
 export { TreeSelect } from './components/TreeSelect/index.js';
 export type { TreeSelectProps } from './components/TreeSelect/index.js';
 export { Divider } from './components/Divider/index.js';
@@ -289,6 +293,8 @@ export { ToolCallCard } from './components/ToolCallCard/index.js';
 export type { ToolCallCardProps, ToolCallStatus } from './components/ToolCallCard/index.js';
 export { ThinkingIndicator } from './components/ThinkingIndicator/index.js';
 export type { ThinkingIndicatorProps } from './components/ThinkingIndicator/index.js';
+export { TaskList, TaskListItem } from './components/TaskList/index.js';
+export type { TaskListProps, TaskListItemProps, TaskData } from './components/TaskList/index.js';
 export { StepTimeline, StepTimelineItem } from './components/StepTimeline/index.js';
 export type { StepTimelineProps, StepTimelineItemProps, StepStatus } from './components/StepTimeline/index.js';
 export { Trace, TraceItem, TraceDetails } from './components/Trace/index.js';
@@ -321,6 +327,8 @@ export { Sources } from './components/Sources/index.js';
 export type { SourcesProps, SourceItem } from './components/Sources/index.js';
 export { FilePreview } from './components/FilePreview/index.js';
 export type { FilePreviewProps, FilePreviewFile, FilePreviewStatus } from './components/FilePreview/index.js';
+export { FollowUpSuggestions } from './components/FollowUpSuggestions/index.js';
+export type { FollowUpSuggestionsProps } from './components/FollowUpSuggestions/index.js';
 export { InlineCompletion } from './components/InlineCompletion/index.js';
 export type { InlineCompletionProps } from './components/InlineCompletion/index.js';
 export { InlineCitation } from './components/InlineCitation/index.js';

package/dist/types/tokens/index.d.ts

@@ -9,3 +9,4 @@ export { PRIMITIVES, SEMANTIC_COLOR_TOKENS, createBrandTheme } from './palette.j
 export type { Family, Mode, PrimitiveScales, SemanticColorToken, ScaleSeed, BrandSeedOverrides, CreateBrandThemeOptions, BrandThemeCss } from './palette.js';
 export { deltaE, formatOklch, oklchToHex, parseHex, parseOklch, wcagContrast } from './oklch.js';
 export type { Oklch } from './oklch.js';
+export { remScale } from './zoom.js';

package/dist/types/tokens/zoom.d.ts

@@ -0,0 +1,33 @@
+import type { DensitySpaceTokenName } from './spacing.js';
+/** The spacing scale at a 16px = 1rem base, answered through the density indirection. */
+export declare const REM_SPACE_OVERRIDES: Record<DensitySpaceTokenName, string>;
+/** The text-size scale at a 16px = 1rem base (leading is unitless already). */
+export declare const REM_TEXT_SIZES: {
+    readonly '--haze-text-xs': "0.75rem";
+    readonly '--haze-text-sm': "0.875rem";
+    readonly '--haze-text-base': "1rem";
+    readonly '--haze-text-lg': "1.125rem";
+    readonly '--haze-text-xl': "1.25rem";
+    readonly '--haze-text-2xl': "1.5rem";
+    readonly '--haze-text-3xl': "1.875rem";
+};
+export type TextSizeTokenName = keyof typeof REM_TEXT_SIZES;
+/** The radius scale at a 16px = 1rem base (9999px = 624.9375rem exactly). */
+export declare const REM_RADII: {
+    readonly '--haze-radius-none': "0";
+    readonly '--haze-radius-sm': "0.25rem";
+    readonly '--haze-radius-md': "0.375rem";
+    readonly '--haze-radius-lg': "0.5rem";
+    readonly '--haze-radius-xl': "0.75rem";
+    readonly '--haze-radius-2xl': "1rem";
+    readonly '--haze-radius-full': "624.9375rem";
+};
+export type RadiusTokenName = keyof typeof REM_RADII;
+/**
+ * The declarations the remScale class emits, one per re-declared token.
+ * Exported for the token tests — the css template interpolates this exact
+ * function and Linaria evaluates it at build time (spacingDeclarations /
+ * compactDeclarations precedent).
+ */
+export declare function remDeclarations(): string;
+export declare const remScale: import("@linaria/core").LinariaClassName;