@choice-ui/react 1.3.11 → 1.4.0

package/dist/components/tooltip/src/types.d.ts

@@ -0,0 +1,55 @@
+import { Placement, UseFloatingReturn } from '@floating-ui/react';
+import { ReactNode } from 'react';
+import { KbdKey } from '@choice-ui/kbd';
+export interface TooltipOptions {
+    disabled?: boolean;
+    initialOpen?: boolean;
+    offset?: number;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    placement?: Placement;
+}
+export interface TooltipContextValue {
+    arrowRef: React.RefObject<HTMLElement>;
+    context: UseFloatingReturn["context"];
+    disabled: boolean;
+    floatingStyles: React.CSSProperties;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    getReferenceProps: (userProps?: React.HTMLProps<HTMLElement> | undefined) => Record<string, unknown>;
+    isPositioned: UseFloatingReturn["isPositioned"];
+    middlewareData: UseFloatingReturn["middlewareData"];
+    open: boolean;
+    placement: Placement;
+    refs: UseFloatingReturn["refs"];
+    setOpen: (open: boolean) => void;
+    strategy: UseFloatingReturn["strategy"];
+    update: UseFloatingReturn["update"];
+    x: number | null;
+    y: number | null;
+}
+export interface TooltipProps {
+    children?: React.ReactNode;
+    className?: string;
+    content?: React.ReactNode;
+    disabled?: boolean;
+    offset?: number;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    placement?: Placement;
+    portalId?: string;
+    shortcut?: {
+        keys?: ReactNode;
+        modifier?: KbdKey[];
+    };
+    variant?: "default" | "light";
+    withArrow?: boolean;
+}
+export interface TooltipContentProps extends React.HTMLProps<HTMLDivElement> {
+    portalId?: string;
+    variant?: "default" | "light";
+    withArrow?: boolean;
+}
+export interface TooltipArrowProps {
+    className?: string;
+    variant?: "default" | "light";
+}

package/dist/components/tooltip/tsup.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('tsup').Options | import('tsup').Options[] | ((overrideOptions: import('tsup').Options) => import('tsup').Options | import('tsup').Options[] | Promise<import('tsup').Options | import('tsup').Options[]>);
+export default _default;

package/dist/components/tree-list/src/components/drop-indicator.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { DropPosition } from '../types';
+interface DropIndicatorProps {
+    dropPosition: DropPosition | null | undefined;
+    isDropTarget: boolean;
+    isExpanded: boolean;
+    isFolderWithChildren: boolean;
+    level: number;
+}
+export declare const DropIndicator: React.FC<DropIndicatorProps>;
+export {};

package/dist/components/tree-list/src/components/index.d.ts

@@ -0,0 +1,6 @@
+export * from './tree-node';
+export * from './drop-indicator';
+export * from './tree-node-wrapper';
+export * from './tree-node-rename-input';
+export * from './tree-node-toggle';
+export * from './tree-node-icon';

package/dist/components/tree-list/src/components/tree-node-icon.d.ts

@@ -0,0 +1,10 @@
+import { MouseEvent, ReactNode } from 'react';
+import { TreeNodeType } from '../types';
+interface TreeNodeIconProps {
+    isSelected: boolean;
+    node: TreeNodeType;
+    onIconDoubleClick?: (node: TreeNodeType, event: MouseEvent<HTMLDivElement>) => void;
+    renderIcon?: (node: TreeNodeType) => ReactNode;
+}
+export declare function TreeNodeIcon({ node, isSelected, renderIcon, onIconDoubleClick, }: TreeNodeIconProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/tree-list/src/components/tree-node-rename-input.d.ts

@@ -0,0 +1,54 @@
+import { RefObject } from 'react';
+export interface TreeNodeRenameInputProps {
+    /**
+     * 节点名称展示区域的 ref，用于外部测量宽度
+     */
+    contentRef: RefObject<HTMLDivElement>;
+    /**
+     * 完整路径的节点名称数组（从根到当前节点）
+     */
+    fullPath?: string[];
+    /**
+     * 是否可编辑（可重命名），默认为 true
+     */
+    isEditable?: boolean;
+    /**
+     * 是否处于重命名状态
+     */
+    isRenaming: boolean;
+    /**
+     * 当前节点是否被选中，用于样式控制
+     */
+    isSelected: boolean;
+    /**
+     * 当前节点名称
+     */
+    name: string;
+    /**
+     * 重命名完成后触发，返回新的名称
+     * 如果启用 showFullPathOnRename，newName 将包含完整路径
+     */
+    onRename?: (newName: string) => void;
+    /**
+     * 当输入值变化时触发
+     */
+    onRenameValueChange: (value: string) => void;
+    /**
+     * 当重命名状态变化时触发
+     */
+    onRenamingChange: (isRenaming: boolean) => void;
+    /**
+     * 重命名输入框的值
+     */
+    renameValue: string;
+    /**
+     * 是否在重命名时显示完整路径
+     * 当为 true 时，输入框会显示完整路径，但只选中最后一部分
+     */
+    showFullPathOnRename?: boolean;
+    /**
+     * 请求外部重新测量节点宽度
+     */
+    triggerMeasure?: () => void;
+}
+export declare function TreeNodeRenameInput(props: TreeNodeRenameInputProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/tree-list/src/components/tree-node-toggle.d.ts

@@ -0,0 +1,14 @@
+import { MouseEvent } from 'react';
+interface TreeNodeToggleProps {
+    isDragging: boolean;
+    isExpanded: boolean;
+    isFolderWithChildren: boolean;
+    nodeId: string;
+    onExpandClick: (event: MouseEvent<HTMLButtonElement>) => void;
+    shouldRenderToggle: boolean;
+}
+export interface TreeNodeToggleHandle {
+    clearTimeout: () => void;
+}
+export declare const TreeNodeToggle: import('react').ForwardRefExoticComponent<TreeNodeToggleProps & import('react').RefAttributes<TreeNodeToggleHandle>>;
+export {};

package/dist/components/tree-list/src/components/tree-node-wrapper.d.ts

@@ -0,0 +1,35 @@
+import { default as React } from 'react';
+import { DropPosition, TreeNodeType } from '../types';
+interface TreeNodeWrapperProps {
+    containerWidth: number;
+    dragNodes: TreeNodeType[];
+    flattenedNodes: TreeNodeType[];
+    hasHorizontalScroll: boolean;
+    isCommandKeyPressed: boolean;
+    isDragging: boolean;
+    listRef: React.RefObject<HTMLDivElement>;
+    node: TreeNodeType;
+    onContextMenu: (node: TreeNodeType, event: React.MouseEvent) => void;
+    onDragEnd: () => void;
+    onDragOver: (node: TreeNodeType, event: React.DragEvent) => void;
+    onDragStart: (nodes: TreeNodeType[], event: React.DragEvent) => void;
+    onDrop: (node: TreeNodeType, position: DropPosition) => void;
+    onExpand: (node: TreeNodeType, expanded: boolean) => void;
+    onHover?: (node: TreeNodeType, isHovered: boolean, event: React.MouseEvent) => void;
+    onIconDoubleClick?: (node: TreeNodeType, event: React.MouseEvent) => void;
+    onMeasure: (width: number) => void;
+    onRename: (node: TreeNodeType, newName: string) => void;
+    onSelect: (node: TreeNodeType, event?: React.MouseEvent | React.KeyboardEvent) => void;
+    renderActions?: (node: TreeNodeType) => React.ReactNode;
+    renderIcon?: (node: TreeNodeType) => React.ReactNode;
+    renderLabel?: (node: TreeNodeType) => React.ReactNode;
+    renderNode?: (node: TreeNodeType) => React.ReactNode;
+    selectedNodes: TreeNodeType[];
+    showFullPathOnRename?: boolean;
+    visibleNodes: TreeNodeType[];
+}
+/**
+ * 使用 memo 优化性能，只有当相关属性变化时才重新渲染
+ */
+export declare const TreeNodeWrapper: React.MemoExoticComponent<(props: TreeNodeWrapperProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/components/tree-list/src/components/tree-node.d.ts

@@ -0,0 +1,2 @@
+import { TreeNodeProps } from '../types';
+export declare const TreeNode: import('react').ForwardRefExoticComponent<TreeNodeProps & import('react').RefAttributes<HTMLDivElement>>;

package/dist/components/tree-list/src/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export * from './use-drag-drop';
+export * from './use-expansion';
+export * from './use-has-horizontal-scroll';
+export * from './use-modifier-keys';
+export * from './use-renaming';
+export * from './use-selection';

package/dist/components/tree-list/src/hooks/use-drag-drop.d.ts

@@ -0,0 +1,15 @@
+import { DragState, DropPosition, TreeNodeType } from '../types';
+export interface UseDragDropProps {
+    allowDrag: boolean;
+    allowDrop: boolean;
+    nodeHeight: number;
+    onNodeDrop?: (nodes: TreeNodeType[], targetNode: TreeNodeType, position: DropPosition) => void;
+}
+export declare function useDragDrop({ allowDrag, allowDrop, nodeHeight, onNodeDrop }: UseDragDropProps): {
+    dragState: DragState;
+    listRef: import('react').RefObject<HTMLDivElement>;
+    startDrag: (nodes: TreeNodeType[], event: React.DragEvent) => void;
+    handleDragOver: (node: TreeNodeType, event: React.DragEvent) => void;
+    handleDrop: (targetNode: TreeNodeType, position: DropPosition) => void;
+    handleDragEnd: () => void;
+};

package/dist/components/tree-list/src/hooks/use-expansion.d.ts

@@ -0,0 +1,10 @@
+import { TreeNodeType } from '../types';
+export interface UseExpansionProps {
+    expandedNodeIds?: Set<string>;
+    onNodeExpand?: (node: TreeNodeType, isExpanded: boolean) => void;
+}
+export declare function useExpansion({ expandedNodeIds: controlledExpandedNodeIds, onNodeExpand, }: UseExpansionProps): {
+    expandedNodeIds: Set<string>;
+    setExpandedNodeIds: import('react').Dispatch<import('react').SetStateAction<Set<string>>> | undefined;
+    expandNode: (node: TreeNodeType, forceExpanded?: boolean) => void;
+};

package/dist/components/tree-list/src/hooks/use-node-width.d.ts

@@ -0,0 +1,47 @@
+interface UseNodeWidthOptions {
+    /**
+     * 节点标识，用于唯一标识此节点
+     */
+    nodeId: string;
+    /**
+     * 节点名称，名称变化时会触发重新测量
+     */
+    name: string;
+    /**
+     * 缩进级别，影响计算的总宽度
+     */
+    level: number;
+    /**
+     * 是否处于重命名状态
+     */
+    isRenaming: boolean;
+    /**
+     * 重命名时的值
+     */
+    renameValue?: string;
+    /**
+     * 是否被hover
+     */
+    isHovered?: boolean;
+    /**
+     * 容器宽度，用于计算滚动时的宽度
+     */
+    containerWidth?: number;
+    /**
+     * 宽度变化时的回调函数
+     */
+    onWidthChange?: (nodeId: string, width: number) => void;
+    /**
+     * 重置重命名状态的回调函数
+     */
+    onResetRenaming?: () => void;
+}
+/**
+ * 用于测量和跟踪节点宽度的 hook
+ */
+export declare function useNodeWidth({ nodeId, name, level, isRenaming, renameValue, isHovered, containerWidth, onWidthChange, onResetRenaming, }: UseNodeWidthOptions): {
+    contentRef: import('react').MutableRefObject<HTMLDivElement | null>;
+    triggerMeasure: () => void;
+    nodeWidth: string;
+};
+export {};

package/dist/components/tree-list/src/hooks/use-renaming.d.ts

@@ -0,0 +1,9 @@
+import { TreeNodeType } from '../types';
+export interface UseRenamingProps {
+    onNodeRename?: (node: TreeNodeType, newName: string) => void;
+}
+export declare function useRenaming({ onNodeRename }: UseRenamingProps): {
+    isRenaming: string | null;
+    startRename: (node: TreeNodeType) => void;
+    endRename: (node: TreeNodeType, newName: string) => void;
+};

package/dist/components/tree-list/src/hooks/use-selection.d.ts

@@ -0,0 +1,11 @@
+import { TreeNodeType } from '../types';
+export interface UseSelectionProps {
+    allowMultiSelect: boolean;
+    flattenedNodes: TreeNodeType[];
+    onNodeSelect?: (selectedNodes: TreeNodeType[], event?: React.MouseEvent | React.KeyboardEvent) => void;
+    selectedNodeIds: Set<string>;
+}
+export declare function useSelection({ allowMultiSelect, flattenedNodes, selectedNodeIds, onNodeSelect, }: UseSelectionProps): {
+    selectedNodeIds: Set<string>;
+    selectNode: (node: TreeNodeType, multiple?: boolean, range?: boolean, _event?: React.MouseEvent | React.KeyboardEvent) => void;
+};

package/dist/components/tree-list/src/index.d.ts

@@ -0,0 +1,4 @@
+export { TreeList, useTreeContext } from './tree-list';
+export { TreeNode, TreeNodeWrapper } from './components';
+export * from './types';
+export * from './utils';

package/dist/components/tree-list/src/tree-list.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { TreeListContext, TreeListHandle, TreeListProps } from './types';
+export declare const useTreeContext: () => TreeListContext;
+export declare const TreeList: React.ForwardRefExoticComponent<TreeListProps & React.RefAttributes<TreeListHandle>>;

package/dist/components/tree-list/src/types.d.ts

@@ -0,0 +1,129 @@
+import { MouseEvent as ReactMouseEvent, ReactNode } from 'react';
+export interface TreeNodeData {
+    [key: string]: string | number | boolean | TreeNodeData[] | undefined | TreeNodeState;
+    children?: TreeNodeData[];
+    id: string;
+    isEditable?: boolean;
+    isFolder?: boolean;
+    name: string;
+    parentId?: string;
+}
+export interface TreeNodeState {
+    dropPosition?: DropPosition;
+    indexKey: string;
+    isDragging: boolean;
+    isDropTarget: boolean;
+    isExpanded: boolean;
+    isParentSelected?: boolean;
+    isSelected: boolean;
+    isVisible: boolean;
+    level: number;
+}
+export interface TreeNodeType extends TreeNodeData {
+    state: TreeNodeState;
+}
+export interface TreeListProps {
+    allowDrag?: boolean;
+    allowDrop?: boolean;
+    allowMultiSelect?: boolean;
+    className?: string;
+    containerWidth?: number;
+    data: TreeNodeData[];
+    initialExpandedNodeIds?: Set<string>;
+    keyboardNavigation?: boolean;
+    nodeHeight?: number;
+    onExpandedNodesChange?: (expandedNodeIds: Set<string>) => void;
+    onMouseDown?: () => void;
+    onNodeContextMenu?: (node: TreeNodeType, event: React.MouseEvent) => void;
+    onNodeCreate?: (parentNode: TreeNodeType | null, nodeType: "folder" | "component" | "layer") => void;
+    onNodeDrop?: (sourceNodes: TreeNodeType[], targetNode: TreeNodeType, position: DropPosition) => void;
+    onNodeHover?: (node: TreeNodeType, isHovered: boolean, event: React.MouseEvent) => void;
+    onNodeIconDoubleClick?: (node: TreeNodeType, event: ReactMouseEvent) => void;
+    onNodeRename?: (node: TreeNodeType, newName: string) => void;
+    onNodeSelect?: (nodes: TreeNodeType[], event?: React.MouseEvent | React.KeyboardEvent) => void;
+    renderActions?: (node: TreeNodeType) => ReactNode;
+    renderIcon?: (node: TreeNodeType) => ReactNode;
+    renderLabel?: (node: TreeNodeType) => ReactNode;
+    renderNode?: (node: TreeNodeType) => ReactNode;
+    selectedNodeIds: Set<string>;
+    /**
+     * 是否在重命名时显示完整路径
+     * 当为 true 时，输入框会显示完整路径（如 "Folder2/Folder 2 / Group 1"），
+     * 但只选中最后一部分（如 "Folder 2 / Group 1"）
+     */
+    showFullPathOnRename?: boolean;
+    style?: React.CSSProperties;
+    virtualScroll?: boolean;
+}
+export interface TreeNodeProps {
+    className?: string;
+    containerWidth?: number;
+    /**
+     * 完整路径的节点名称数组（从根到当前节点）
+     */
+    fullPath?: string[];
+    hasHorizontalScroll?: boolean;
+    isCommandKeyPressed?: boolean;
+    isFirstSelected?: boolean;
+    isLastInParent?: boolean;
+    isLastSelected?: boolean;
+    isMiddleSelected?: boolean;
+    isMultiSelectionActive?: boolean;
+    node: TreeNodeType;
+    onContextMenu?: (node: TreeNodeType, event: React.MouseEvent) => void;
+    onDragEnd?: (event: React.DragEvent) => void;
+    onDragOver?: (node: TreeNodeType, event: React.DragEvent) => void;
+    onDragStart?: (node: TreeNodeType, event: React.DragEvent) => void;
+    onDrop?: (node: TreeNodeType, event: React.DragEvent) => void;
+    onExpand?: (node: TreeNodeType) => void;
+    onHover?: (node: TreeNodeType, isHovered: boolean, event: React.MouseEvent) => void;
+    onIconDoubleClick?: (node: TreeNodeType, event: ReactMouseEvent) => void;
+    onMeasure?: (width: number) => void;
+    onRename?: (node: TreeNodeType, newName: string) => void;
+    onSelect?: (node: TreeNodeType, event: React.MouseEvent | React.KeyboardEvent) => void;
+    renderActions?: (node: TreeNodeType) => ReactNode;
+    renderIcon?: (node: TreeNodeType) => ReactNode;
+    renderLabel?: (node: TreeNodeType) => ReactNode;
+    /**
+     * 是否在重命名时显示完整路径
+     */
+    showFullPathOnRename?: boolean;
+    size?: number;
+    start?: number;
+    style?: React.CSSProperties;
+}
+export interface VirtualItem {
+    end: number;
+    index: number;
+    node: TreeNodeType;
+    size: number;
+    start: number;
+}
+export interface DragState {
+    dragNodes: TreeNodeType[];
+    dropPosition: DropPosition | null;
+    dropTargetNode: TreeNodeType | null;
+    isDragging: boolean;
+}
+export type DropPosition = "before" | "after" | "inside";
+export interface KeyboardNavigationState {
+    focusedNodeId: string | null;
+    lastSelectedNodeId: string | null;
+}
+export interface TreeListContext {
+    dragState: DragState;
+    endRename: (node: TreeNodeType, newName: string) => void;
+    expandNode: (node: TreeNodeType, expanded?: boolean) => void;
+    expandedNodeIds: Set<string>;
+    flattenedNodes: TreeNodeType[];
+    handleContextMenu: (node: TreeNodeType, event: React.MouseEvent) => void;
+    handleDrop: (targetNode: TreeNodeType, position: DropPosition) => void;
+    selectNode: (node: TreeNodeType, multiple?: boolean, range?: boolean) => void;
+    selectedNodes: TreeNodeType[];
+    startDrag: (nodes: TreeNodeType[], event: React.DragEvent) => void;
+    startRename: (node: TreeNodeType) => void;
+}
+export interface TreeListHandle {
+    collapseAll: () => void;
+    expandNodes: (nodeIds: string[]) => void;
+}

package/dist/components/tree-list/src/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './tree';
+export * from './node';

package/dist/components/tree-list/src/utils/node.d.ts

@@ -0,0 +1,21 @@
+import { TreeNodeType } from '../types';
+/**
+ * 判断节点是否是父文件夹的最后一个子项
+ */
+export declare function isLastInParent(node: TreeNodeType, flattenedNodes: TreeNodeType[]): boolean;
+/**
+ * 计算节点在选择组中的位置状态
+ */
+export interface SelectionPosition {
+    isFirstSelected: boolean;
+    isLastSelected: boolean;
+    isMiddleSelected: boolean;
+}
+/**
+ * 获取节点在选择组中的位置状态
+ */
+export declare function getSelectionPosition(node: TreeNodeType, visibleNodes: TreeNodeType[], selectedNodesCount: number): SelectionPosition;
+/**
+ * 检查目标节点是否是拖拽节点的子孙
+ */
+export declare function isInvalidDropTarget(targetNode: TreeNodeType, dragNodes: TreeNodeType[], flattenedNodes: TreeNodeType[]): boolean;

package/dist/components/tree-list/src/utils/tree.d.ts

@@ -0,0 +1,53 @@
+import { DropPosition, TreeNodeType, TreeNodeData } from '../types';
+/**
+ * 将扁平化的数据转换为树形结构
+ */
+export declare function buildTree(data: TreeNodeData[], parentId?: string | null): TreeNodeData[];
+/**
+ * 将树形结构扁平化为数组，用于虚拟列表
+ */
+export declare function flattenTree(nodes: TreeNodeData[], level?: number, parent?: TreeNodeData | null, result?: TreeNodeType[], expandedIds?: Set<string>, selectedIds?: Set<string>, hasSelectedAncestor?: boolean): TreeNodeType[];
+/**
+ * 获取节点的所有可见子节点
+ */
+export declare function getVisibleChildren(node: TreeNodeType, flattenedNodes: TreeNodeType[]): TreeNodeType[];
+/**
+ * 获取所有可见节点
+ */
+export declare function getVisibleNodes(flattenedNodes: TreeNodeType[]): TreeNodeType[];
+/**
+ * 深度遍历查找节点
+ */
+export declare function findNodeById(nodes: TreeNodeData[], id: string): TreeNodeData | undefined;
+/**
+ * 获取当前节点的所有祖先节点ID
+ */
+export declare function getAncestorIds(flattenedNodes: TreeNodeType[], nodeId: string): string[];
+/**
+ * 获取节点的完整路径名称数组（从根到当前节点）
+ */
+export declare function getNodePathNames(flattenedNodes: TreeNodeType[], nodeId: string): string[];
+/**
+ * 获取当前节点的所有子孙节点
+ */
+export declare function getDescendantIds(flattenedNodes: TreeNodeType[], nodeId: string): string[];
+/**
+ * 查找指定节点的完整路径（返回节点ID数组）
+ */
+export declare function findNodePathById(nodes: TreeNodeData[], targetId: string, path?: string[]): string[] | null;
+/**
+ * 修改节点显示名称
+ */
+export declare function renameNode(nodes: TreeNodeData[], nodeId: string, newName: string): TreeNodeData[];
+/**
+ * 处理多选逻辑 (Shift + Click)
+ */
+export declare function getNodesInRange(flattenedNodes: TreeNodeType[], startId: string, endId: string): string[];
+/**
+ * 计算拖放位置
+ */
+export declare function calculateDropPosition(event: React.DragEvent, element: HTMLElement): DropPosition;
+/**
+ * 处理键盘导航
+ */
+export declare function getNextNodeId(currentNodeId: string, flattenedNodes: TreeNodeType[], key: "ArrowUp" | "ArrowDown" | "ArrowLeft" | "ArrowRight"): string | null;

package/dist/components/tree-list/tsup.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('tsup').Options | import('tsup').Options[] | ((overrideOptions: import('tsup').Options) => import('tsup').Options | import('tsup').Options[] | Promise<import('tsup').Options | import('tsup').Options[]>);
+export default _default;

package/dist/components/virtualized-grid/src/error-boundary.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+interface ErrorBoundaryState {
+    error?: Error;
+    errorInfo?: React.ErrorInfo;
+    hasError: boolean;
+}
+interface ErrorBoundaryProps {
+    children: React.ReactNode;
+    fallback?: React.ComponentType<{
+        error?: Error;
+        retry: () => void;
+    }>;
+    onError?: (error: Error, errorInfo: React.ErrorInfo) => void;
+}
+export declare class VirtualizedGridErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    retry: () => void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
+export {};

package/dist/components/virtualized-grid/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './virtualized-grid';
+export * from './use-virtualized-grid';
+export * from './utility';
+export * from './types';
+export * from './use-item-pool';
+export * from './error-boundary';

package/dist/components/virtualized-grid/src/tv.d.ts

@@ -0,0 +1,34 @@
+export declare const VirtualizedGridTv: import('tailwind-variants').TVReturnType<{
+    listMode: {
+        true: {};
+        false: {
+            grid: string;
+        };
+    };
+}, {
+    base: string;
+    grid: string;
+    item: string;
+}, undefined, {
+    listMode: {
+        true: {};
+        false: {
+            grid: string;
+        };
+    };
+}, {
+    base: string;
+    grid: string;
+    item: string;
+}, import('tailwind-variants').TVReturnType<{
+    listMode: {
+        true: {};
+        false: {
+            grid: string;
+        };
+    };
+}, {
+    base: string;
+    grid: string;
+    item: string;
+}, undefined, unknown, unknown, undefined>>;