@falcon-ui/falcon-ui 1.0.0

package/types/components/tree/src/tree.vue.d.ts

@@ -0,0 +1,301 @@
+import { type TreeData, type TreeExpose, type TreeInteractionEvent, type TreeNodeInstance, type TreeNode } from './tree';
+type __VLS_Slots = {
+    default?: (props: {
+        node: TreeNode;
+        data: TreeData;
+    }) => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly data: {
+        readonly type: import("vue").PropType<TreeData[]>;
+        readonly default: () => never[];
+    };
+    readonly showLine: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeShowLine>;
+        readonly default: false;
+    };
+    readonly switcherIcon: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeSwitcherIconMode>;
+        readonly default: "arrow";
+    };
+    readonly switcherLoadingIcon: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeSwitcherLoadingIcon>;
+        readonly default: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    };
+    readonly selectable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly multiple: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly checkable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly checkStrictly: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly props: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeNodeProps>;
+        readonly default: () => {
+            label: string;
+            children: string;
+            isLeaf: string;
+        };
+    };
+    readonly classNames: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeClassNames>;
+    };
+    readonly nodeClassName: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeNodeClassName>;
+    };
+    readonly styles: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeStyles>;
+    };
+    readonly defaultExpandAll: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly defaultExpandedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly expandedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly autoExpandParent: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly defaultExpandParent: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly accordion: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly defaultSelectedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly selectedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly disabledKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly unselectableKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly defaultCheckedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly checkedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeCheckedKeys>;
+    };
+    readonly disabledCheckboxKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly hiddenCheckboxKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly loadData: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeLoadData>;
+    };
+    readonly loadedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly draggable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly allowDrag: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeAllowDrag>;
+    };
+    readonly allowDrop: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeAllowDrop>;
+    };
+    readonly filterTreeNode: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeFilterTreeNode>;
+    };
+}>, TreeExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (selectedKeys: import("@falcon-ui/falcon-ui").TreeKey[], event: import("@falcon-ui/falcon-ui").TreeSelectEvent) => void;
+    dblclick: (data: TreeData, node: TreeNode, component: TreeNodeInstance, event: MouseEvent) => void;
+    load: (loadedKeys: import("@falcon-ui/falcon-ui").TreeKey[], event: import("@falcon-ui/falcon-ui").TreeLoadEvent) => void;
+    "update:checkedKeys": (value: import("@falcon-ui/falcon-ui").TreeCheckedKeys) => void;
+    check: (checkedKeys: import("@falcon-ui/falcon-ui").TreeCheckedKeys, event: import("@falcon-ui/falcon-ui").TreeCheckEvent) => void;
+    "node-drag-start": (node: TreeNode, event: DragEvent) => void;
+    "node-drag-enter": (draggingNode: TreeNode, dropNode: TreeNode, event: DragEvent) => void;
+    "node-drag-over": (draggingNode: TreeNode, dropNode: TreeNode, event: DragEvent) => void;
+    "node-drag-leave": (draggingNode: TreeNode, dropNode: TreeNode, event: DragEvent) => void;
+    "node-drag-end": (draggingNode: TreeNode, dropNode: TreeNode | null, dropType: import("@falcon-ui/falcon-ui").TreeNodeDropType, event: DragEvent) => void;
+    "node-drop": (draggingNode: TreeNode, dropNode: TreeNode, dropType: "inner" | "before" | "after", event: DragEvent) => void;
+    "update:expandedKeys": (value: import("@falcon-ui/falcon-ui").TreeKey[]) => void;
+    expand: (event: import("@falcon-ui/falcon-ui").TreeExpandEvent) => void;
+    "node-expand": (data: TreeData, node: import("@falcon-ui/falcon-ui").TreeExpandedNode, instance: TreeNodeInstance) => void;
+    "node-collapse": (data: TreeData, node: import("@falcon-ui/falcon-ui").TreeExpandedNode, instance: TreeNodeInstance) => void;
+    "update:loadedKeys": (value: import("@falcon-ui/falcon-ui").TreeKey[]) => void;
+    "update:selectedKeys": (value: import("@falcon-ui/falcon-ui").TreeKey[]) => void;
+    "node-click": (data: TreeData, node: TreeNode, component: TreeNodeInstance, event: TreeInteractionEvent) => void;
+    "right-click": (data: TreeData, node: TreeNode, component: TreeNodeInstance, event: MouseEvent) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly data: {
+        readonly type: import("vue").PropType<TreeData[]>;
+        readonly default: () => never[];
+    };
+    readonly showLine: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeShowLine>;
+        readonly default: false;
+    };
+    readonly switcherIcon: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeSwitcherIconMode>;
+        readonly default: "arrow";
+    };
+    readonly switcherLoadingIcon: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeSwitcherLoadingIcon>;
+        readonly default: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    };
+    readonly selectable: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly multiple: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly checkable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly checkStrictly: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly props: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeNodeProps>;
+        readonly default: () => {
+            label: string;
+            children: string;
+            isLeaf: string;
+        };
+    };
+    readonly classNames: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeClassNames>;
+    };
+    readonly nodeClassName: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeNodeClassName>;
+    };
+    readonly styles: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeStyles>;
+    };
+    readonly defaultExpandAll: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly defaultExpandedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly expandedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly autoExpandParent: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly defaultExpandParent: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly accordion: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly defaultSelectedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly selectedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly disabledKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly unselectableKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly defaultCheckedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly checkedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeCheckedKeys>;
+    };
+    readonly disabledCheckboxKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly hiddenCheckboxKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly loadData: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeLoadData>;
+    };
+    readonly loadedKeys: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeKey[]>;
+    };
+    readonly draggable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly allowDrag: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeAllowDrag>;
+    };
+    readonly allowDrop: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeAllowDrop>;
+    };
+    readonly filterTreeNode: {
+        readonly type: import("vue").PropType<import("@falcon-ui/falcon-ui").TreeFilterTreeNode>;
+    };
+}>> & Readonly<{
+    onSelect?: ((selectedKeys: import("@falcon-ui/falcon-ui").TreeKey[], event: import("@falcon-ui/falcon-ui").TreeSelectEvent) => any) | undefined;
+    onDblclick?: ((data: TreeData, node: TreeNode, component: TreeNodeInstance, event: MouseEvent) => any) | undefined;
+    onLoad?: ((loadedKeys: import("@falcon-ui/falcon-ui").TreeKey[], event: import("@falcon-ui/falcon-ui").TreeLoadEvent) => any) | undefined;
+    "onUpdate:checkedKeys"?: ((value: import("@falcon-ui/falcon-ui").TreeCheckedKeys) => any) | undefined;
+    onCheck?: ((checkedKeys: import("@falcon-ui/falcon-ui").TreeCheckedKeys, event: import("@falcon-ui/falcon-ui").TreeCheckEvent) => any) | undefined;
+    "onNode-drag-start"?: ((node: TreeNode, event: DragEvent) => any) | undefined;
+    "onNode-drag-enter"?: ((draggingNode: TreeNode, dropNode: TreeNode, event: DragEvent) => any) | undefined;
+    "onNode-drag-over"?: ((draggingNode: TreeNode, dropNode: TreeNode, event: DragEvent) => any) | undefined;
+    "onNode-drag-leave"?: ((draggingNode: TreeNode, dropNode: TreeNode, event: DragEvent) => any) | undefined;
+    "onNode-drag-end"?: ((draggingNode: TreeNode, dropNode: TreeNode | null, dropType: import("@falcon-ui/falcon-ui").TreeNodeDropType, event: DragEvent) => any) | undefined;
+    "onNode-drop"?: ((draggingNode: TreeNode, dropNode: TreeNode, dropType: "inner" | "before" | "after", event: DragEvent) => any) | undefined;
+    "onUpdate:expandedKeys"?: ((value: import("@falcon-ui/falcon-ui").TreeKey[]) => any) | undefined;
+    onExpand?: ((event: import("@falcon-ui/falcon-ui").TreeExpandEvent) => any) | undefined;
+    "onNode-expand"?: ((data: TreeData, node: import("@falcon-ui/falcon-ui").TreeExpandedNode, instance: TreeNodeInstance) => any) | undefined;
+    "onNode-collapse"?: ((data: TreeData, node: import("@falcon-ui/falcon-ui").TreeExpandedNode, instance: TreeNodeInstance) => any) | undefined;
+    "onUpdate:loadedKeys"?: ((value: import("@falcon-ui/falcon-ui").TreeKey[]) => any) | undefined;
+    "onUpdate:selectedKeys"?: ((value: import("@falcon-ui/falcon-ui").TreeKey[]) => any) | undefined;
+    "onNode-click"?: ((data: TreeData, node: TreeNode, component: TreeNodeInstance, event: TreeInteractionEvent) => any) | undefined;
+    "onRight-click"?: ((data: TreeData, node: TreeNode, component: TreeNodeInstance, event: MouseEvent) => any) | undefined;
+}>, {
+    readonly draggable: boolean;
+    readonly data: TreeData[];
+    readonly props: import("@falcon-ui/falcon-ui").TreeNodeProps;
+    readonly multiple: boolean;
+    readonly checkStrictly: boolean;
+    readonly defaultExpandAll: boolean;
+    readonly autoExpandParent: boolean;
+    readonly accordion: boolean;
+    readonly showLine: import("@falcon-ui/falcon-ui").TreeShowLine;
+    readonly switcherIcon: import("@falcon-ui/falcon-ui").TreeSwitcherIconMode;
+    readonly switcherLoadingIcon: import("@falcon-ui/falcon-ui").TreeSwitcherLoadingIcon;
+    readonly selectable: boolean;
+    readonly checkable: boolean;
+    readonly defaultExpandParent: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/types/components/tree/src/use-tree-check-conduct.d.ts

@@ -0,0 +1,43 @@
+import { type TreeCheckedKeys, type TreeIndex, type TreeKey, type TreeNodeModel } from './tree';
+/**
+ * 勾选状态统一拆分为 checked / halfChecked 两套集合，便于默认联动与严格模式复用。
+ */
+export interface TreeCheckedState {
+    checkedKeys: TreeKey[];
+    halfCheckedKeys: TreeKey[];
+}
+/**
+ * 默认联动模式下，对输入数组执行父子传导与半选态计算。
+ */
+export declare const conductTreeCheckedState: (sourceCheckedKeys: TreeKey[] | undefined, treeIndex: TreeIndex) => TreeCheckedState;
+/**
+ * 严格模式下，`checked` 与 `halfChecked` 仅做归一化，不自动联动。
+ */
+export declare const normalizeStrictTreeCheckedState: (checkedKeys: TreeCheckedKeys | undefined, treeIndex: TreeIndex) => TreeCheckedState;
+/**
+ * 统一归一化当前模式下的勾选状态。
+ */
+export declare const normalizeTreeCheckedState: ({ checkedKeys, treeIndex, strict }: {
+    checkedKeys: TreeCheckedKeys | undefined;
+    treeIndex: TreeIndex;
+    strict: boolean;
+}) => TreeCheckedState;
+/**
+ * 默认联动模式下切换某个节点的勾选状态：
+ * 1. 勾选时选中当前节点及其可达子孙
+ * 2. 取消时移除当前节点、其可达子孙以及沿途可勾选祖先
+ * 3. 之后重新执行传导，生成新的 checked / halfChecked 结果
+ */
+export declare const toggleConductedTreeCheckedState: ({ node, checkedKeys, treeIndex }: {
+    node: TreeNodeModel;
+    checkedKeys: TreeKey[];
+    treeIndex: TreeIndex;
+}) => TreeCheckedState;
+/**
+ * 将当前模式下的勾选状态编码回对外值形态。
+ */
+export declare const createTreeCheckedKeysValue: ({ strict, checkedKeys, halfCheckedKeys }: {
+    strict: boolean;
+    checkedKeys: TreeKey[];
+    halfCheckedKeys: TreeKey[];
+}) => TreeCheckedKeys;

package/types/components/tree/src/use-tree-checked-state.d.ts

@@ -0,0 +1,34 @@
+import { type ComputedRef } from 'vue';
+import { type TreeCheckEvent, type TreeCheckedKeys, type TreeIndex, type TreeInteractionEvent, type TreeKey, type TreeNodeModel, type TreeProps } from './tree';
+interface UseTreeCheckedStateOptions {
+    props: TreeProps;
+    treeIndex: ComputedRef<TreeIndex>;
+    emit: TreeCheckedStateEmit;
+}
+export interface TreeCheckedStateEmit {
+    (event: 'update:checkedKeys', value: TreeCheckedKeys): void;
+    (event: 'check', checkedKeys: TreeCheckedKeys, checkEvent: TreeCheckEvent): void;
+}
+interface ToggleCheckedNodeOptions {
+    node: TreeNodeModel;
+    event: TreeInteractionEvent;
+}
+/**
+ * FlTree 阶段 7-9 的勾选状态层统一负责：
+ * 1. 默认联动模式的父子传导与半选态
+ * 2. strict 模式的 `{ checked, halfChecked }` 对象态
+ * 3. key-based 禁用、禁用 checkbox 与隐藏 checkbox 的交互边界
+ */
+export declare const useTreeCheckedState: ({ props, treeIndex, emit }: UseTreeCheckedStateOptions) => {
+    checkedKeys: ComputedRef<TreeKey[]>;
+    halfCheckedKeys: ComputedRef<TreeKey[]>;
+    isCheckboxDisabled: (node: TreeNodeModel) => boolean;
+    isControlled: ComputedRef<boolean>;
+    isNodeChecked: (nodeKey: TreeKey) => boolean;
+    isNodeHalfChecked: (nodeKey: TreeKey) => boolean;
+    isStrictMode: ComputedRef<boolean>;
+    isTreeCheckable: ComputedRef<boolean>;
+    shouldRenderCheckbox: (node: TreeNodeModel) => boolean;
+    toggleCheckedNode: ({ node, event }: ToggleCheckedNodeOptions) => void;
+};
+export {};

package/types/components/tree/src/use-tree-drag.d.ts

@@ -0,0 +1,45 @@
+import { type ComputedRef } from 'vue';
+import { type TreeIndex, type TreeKey, type TreeNodeDragEndArgs, type TreeNodeDragStartArgs, type TreeNodeDragTargetArgs, type TreeNodeDropArgs, type TreeNodeDropType, type TreeNodeModel, type TreeProps } from './tree';
+interface UseTreeDragStateOptions {
+    props: TreeProps;
+    treeIndex: ComputedRef<TreeIndex>;
+    emit: TreeDragStateEmit;
+    notifyDataChange: () => void;
+}
+export interface TreeDragStateEmit {
+    (event: 'node-drag-start', ...args: TreeNodeDragStartArgs): void;
+    (event: 'node-drag-enter', ...args: TreeNodeDragTargetArgs): void;
+    (event: 'node-drag-over', ...args: TreeNodeDragTargetArgs): void;
+    (event: 'node-drag-leave', ...args: TreeNodeDragTargetArgs): void;
+    (event: 'node-drag-end', ...args: TreeNodeDragEndArgs): void;
+    (event: 'node-drop', ...args: TreeNodeDropArgs): void;
+}
+interface TreeDragTargetOptions {
+    node: TreeNodeModel;
+    event: DragEvent;
+    element: HTMLElement;
+}
+interface TreeDragNodeOptions {
+    node: TreeNodeModel;
+    event: DragEvent;
+}
+/**
+ * FlTree 拖拽状态层，对齐 Element Plus Tree：
+ * 1. dragend 阶段内部原地重排 data
+ * 2. 使用 node-drag-* / node-drop 多参数事件
+ * 3. allowDrop 按 prev / inner / next 三种类型分别判断
+ */
+export declare const useTreeDragState: ({ props, treeIndex, emit, notifyDataChange }: UseTreeDragStateOptions) => {
+    getNodeDropType: (nodeKey: TreeKey) => TreeNodeDropType | undefined;
+    handleNodeDragEnd: ({ node, event }: TreeDragNodeOptions) => void;
+    handleNodeDragEnter: (options: TreeDragTargetOptions) => void;
+    handleNodeDragLeave: ({ node, event }: TreeDragTargetOptions) => void;
+    handleNodeDragOver: (options: TreeDragTargetOptions) => void;
+    handleNodeDragStart: ({ node, event }: TreeDragNodeOptions) => void;
+    handleNodeDrop: ({ event }: TreeDragTargetOptions) => void;
+    isNodeDraggable: () => boolean;
+    isNodeDragging: (nodeKey: TreeKey) => boolean;
+    isNodeDropAllowed: (nodeKey: TreeKey) => boolean;
+    isNodeDropTarget: (nodeKey: TreeKey) => boolean;
+};
+export {};

package/types/components/tree/src/use-tree-expanded-state.d.ts

@@ -0,0 +1,41 @@
+import { type ComputedRef } from 'vue';
+import { type TreeExpandEvent, type TreeExpandedNode, type TreeIndex, type TreeKey, type TreeNodeInstance, type TreeNodeModel, type TreeProps } from './tree';
+/**
+ * 统一约束组合式展开状态层的输入参数。
+ */
+interface UseTreeExpandedStateOptions {
+    props: TreeProps;
+    treeIndex: ComputedRef<TreeIndex>;
+    emit: TreeExpandedStateEmit;
+    isNodeExpandable?: (node: TreeNodeModel) => boolean;
+}
+/**
+ * 灞曞紑鐘舵€佸眰鍙叧蹇冨睍寮€鐩稿叧鐨勪簨浠跺悎鍚屻€?
+ */
+export interface TreeExpandedStateEmit {
+    (event: 'update:expandedKeys', value: TreeKey[]): void;
+    (event: 'expand', eventPayload: TreeExpandEvent): void;
+    (event: 'node-expand', data: TreeNodeModel['data'], node: TreeExpandedNode, instance: TreeNodeInstance): void;
+    (event: 'node-collapse', data: TreeNodeModel['data'], node: TreeExpandedNode, instance: TreeNodeInstance): void;
+}
+/**
+ * 切换展开状态时需要的节点上下文。
+ */
+interface ToggleNodeExpansionOptions {
+    node: TreeNodeModel;
+    instance: TreeNodeInstance;
+}
+/**
+ * FlTree 阶段 3 的展开状态层：
+ * 1. 管理非受控初始化与受控渲染优先级
+ * 2. 区分源展开键与最终渲染展开集合
+ * 3. 统一收口 switcher 展开/收起事件
+ */
+export declare const useTreeExpandedState: ({ props, treeIndex, emit, isNodeExpandable }: UseTreeExpandedStateOptions) => {
+    effectiveExpandedKeySet: ComputedRef<Set<TreeKey>>;
+    isControlled: ComputedRef<boolean>;
+    isNodeExpanded: (nodeKey: TreeKey) => boolean;
+    sourceExpandedKeys: ComputedRef<TreeKey[]>;
+    toggleNodeExpansion: ({ node, instance }: ToggleNodeExpansionOptions) => void;
+};
+export {};

package/types/components/tree/src/use-tree-keyboard.d.ts

@@ -0,0 +1,21 @@
+import { type ComputedRef } from 'vue';
+import type { TreeIndex, TreeKey, TreeNodeModel } from './tree';
+interface UseTreeKeyboardStateOptions {
+    treeIndex: ComputedRef<TreeIndex>;
+    selectedKeys: ComputedRef<TreeKey[]>;
+    isNodeExpanded: (nodeKey: TreeKey) => boolean;
+    isNodeExpandable: (node: TreeNodeModel) => boolean;
+}
+export declare const useTreeKeyboardState: ({ treeIndex, selectedKeys, isNodeExpanded, isNodeExpandable }: UseTreeKeyboardStateOptions) => {
+    activeDescendantId: ComputedRef<string | undefined>;
+    focusNode: (nodeKey: TreeKey) => void;
+    focusedKey: import("vue").Ref<TreeKey | undefined, TreeKey | undefined>;
+    getFocusedNode: () => TreeNodeModel | undefined;
+    getNodeId: (nodeKey: TreeKey) => string;
+    isNodeFocused: (nodeKey: TreeKey) => boolean;
+    moveFocusBy: (offset: number) => void;
+    moveFocusToFirstChild: (node: TreeNodeModel) => void;
+    moveFocusToParent: (node: TreeNodeModel) => void;
+    visibleNodeKeys: ComputedRef<TreeKey[]>;
+};
+export {};

package/types/components/tree/src/use-tree-load.d.ts

@@ -0,0 +1,25 @@
+import { type ComputedRef } from 'vue';
+import { type TreeIndex, type TreeKey, type TreeLoadEvent, type TreeNodeModel, type TreeProps } from './tree';
+interface UseTreeLoadStateOptions {
+    props: TreeProps;
+    treeIndex: ComputedRef<TreeIndex>;
+    emit: TreeLoadStateEmit;
+}
+export interface TreeLoadStateEmit {
+    (event: 'update:loadedKeys', value: TreeKey[]): void;
+    (event: 'load', loadedKeys: TreeKey[], loadEvent: TreeLoadEvent): void;
+}
+/**
+ * FlTree 阶段 13 的异步加载状态层：
+ * 1. 管理受控 / 非受控 loadedKeys
+ * 2. 维护节点加载中状态与重复请求保护
+ * 3. 只消费 loadData 的完成 / 失败结果，不读取 resolve 值
+ */
+export declare const useTreeLoadState: ({ props, treeIndex, emit }: UseTreeLoadStateOptions) => {
+    isControlled: ComputedRef<boolean>;
+    isNodeLoaded: (nodeKey: TreeKey) => boolean;
+    isNodeLoading: (nodeKey: TreeKey) => boolean;
+    loadNode: (node: TreeNodeModel) => Promise<void>;
+    loadedKeys: ComputedRef<TreeKey[]>;
+};
+export {};

package/types/components/tree/src/use-tree-scroll.d.ts

@@ -0,0 +1,17 @@
+import type { ComputedRef } from 'vue';
+import type { TreeIndex, TreeKey, TreeScrollToOptions } from './tree';
+interface UseTreeScrollStateOptions {
+    treeIndex: ComputedRef<TreeIndex>;
+}
+/**
+ * FlTree 阶段 17 的滚动定位状态层：
+ * 1. 只注册当前已经渲染的节点内容区元素
+ * 2. 自动寻找最近可滚动祖先，找不到时回退页面滚动容器
+ * 3. 不改变展开状态，也不要求 Tree 根节点成为固定高度滚动容器
+ */
+export declare const useTreeScrollState: ({ treeIndex }: UseTreeScrollStateOptions) => {
+    registerNodeElement: (nodeKey: TreeKey, element: HTMLElement | null) => void;
+    scrollTo: ({ key, align, offset }: TreeScrollToOptions) => void;
+    unregisterNodeElement: (nodeKey: TreeKey, element: HTMLElement | null) => void;
+};
+export {};

package/types/components/tree/src/use-tree-selected-state.d.ts

@@ -0,0 +1,29 @@
+import { type ComputedRef } from 'vue';
+import { type TreeIndex, type TreeInteractionEvent, type TreeKey, type TreeNodeModel, type TreeProps, type TreeSelectEvent } from './tree';
+interface UseTreeSelectedStateOptions {
+    props: TreeProps;
+    treeIndex: ComputedRef<TreeIndex>;
+    emit: TreeSelectedStateEmit;
+}
+export interface TreeSelectedStateEmit {
+    (event: 'update:selectedKeys', value: TreeKey[]): void;
+    (event: 'select', selectedKeys: TreeKey[], selectEvent: TreeSelectEvent): void;
+}
+interface SelectNodeOptions {
+    node: TreeNodeModel;
+    event: TreeInteractionEvent;
+}
+/**
+ * FlTree 阶段 5 的选中状态层同时承接单选与多选语义：
+ * 1. 受控模式只读取外部 selectedKeys
+ * 2. 非受控模式只在初始化时消费 defaultSelectedKeys
+ * 3. 后续数据变化只做 key 裁剪，不重复初始化
+ */
+export declare const useTreeSelectedState: ({ props, treeIndex, emit }: UseTreeSelectedStateOptions) => {
+    isControlled: ComputedRef<boolean>;
+    isNodeSelected: (nodeKey: TreeKey) => boolean;
+    isTreeSelectable: ComputedRef<boolean>;
+    selectNode: ({ node, event }: SelectNodeOptions) => void;
+    selectedKeys: ComputedRef<TreeKey[]>;
+};
+export {};

package/types/components/tree-select/index.d.ts

@@ -0,0 +1,5 @@
+import TreeSelect from './src/tree-select.vue';
+import type { SFCWithInstall } from '@falcon-ui/falcon-ui/utils';
+export declare const FlTreeSelect: SFCWithInstall<typeof TreeSelect>;
+export default FlTreeSelect;
+export type { TreeSelectEmits, TreeSelectExpose, TreeSelectProps } from './src/tree-select';

package/types/components/tree-select/src/tree-select.d.ts

@@ -0,0 +1,26 @@
+import type { ExtractPublicPropTypes } from 'vue';
+import type { TreeSelectInstance } from 'element-plus';
+export declare const treeSelectProps: {
+    /**
+     * 是否进入错误态。
+     */
+    readonly isError: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    /**
+     * 是否用于表格单元格内树选择场景。
+     */
+    readonly isTable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+};
+export declare const treeSelectEmits: {};
+export type TreeSelectProps = ExtractPublicPropTypes<typeof treeSelectProps>;
+export type TreeSelectEmits = typeof treeSelectEmits;
+export interface TreeSelectExpose extends TreeSelectInstance {
+    focus: () => void;
+    blur: () => void;
+    selectedLabel?: string | string[];
+}

package/types/components/tree-select/src/tree-select.vue.d.ts

@@ -0,0 +1,25 @@
+import type { TreeSelectExpose } from './tree-select';
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly isError: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly isTable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+}>, TreeSelectExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly isError: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly isTable: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+}>> & Readonly<{}>, {
+    readonly isError: boolean;
+    readonly isTable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/types/falcon-ui/index.d.ts

@@ -0,0 +1,8 @@
+import type { App, Plugin } from 'vue';
+export * from '@falcon-ui/falcon-ui/components';
+export * from '@falcon-ui/falcon-ui/hooks';
+export * from '@falcon-ui/falcon-ui/icons';
+export * from '@falcon-ui/falcon-ui/utils';
+export declare const install: (app: App) => void;
+declare const FalconUI: Plugin;
+export default FalconUI;

package/types/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src/use-component';
+export * from './src/use-clearable-state';
+export * from './src/use-dialog';

package/types/hooks/src/use-clearable-state.d.ts

@@ -0,0 +1,10 @@
+export type ClearValueResolver = () => unknown;
+export interface UseClearableStateOptions {
+    attrs: Record<string, unknown>;
+    isError: () => boolean;
+    resolveClearValue?: ClearValueResolver;
+}
+export declare const useClearableState: ({ attrs, isError, resolveClearValue }: UseClearableStateOptions) => {
+    clearModelValue: () => void;
+    resolveClearable: () => boolean;
+};