ep-craft 0.1.37 → 0.1.39

package/dist/components/tree-v2/composables/useTree.d.ts

@@ -0,0 +1,404 @@
+import type { Alignment as ScrollStrategy } from '../../virtual-list';
+import type { SetupContext } from 'vue';
+import type { treeEmits } from '../virtual-tree';
+import type { CheckboxValueType } from '../../checkbox';
+import type { Tree, TreeData, TreeKey, TreeNode, TreeNodeData, TreeProps } from '../types';
+export declare function useTree(props: TreeProps, emit: SetupContext<typeof treeEmits>['emit']): {
+    tree: import("vue").ShallowRef<Tree | undefined, Tree | undefined>;
+    flattenTree: import("vue").ComputedRef<TreeNode[]>;
+    isNotEmpty: import("vue").ComputedRef<boolean>;
+    listRef: import("vue").Ref<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        readonly className: import("../../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly containerElement: import("../../../utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown, "div", boolean>;
+        readonly data: import("../../../utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | (((new (...args: any[]) => any[]) | (() => any[])) | null)[], unknown, unknown, () => [], boolean>;
+        readonly direction: import("../../../utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;
+        readonly height: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly innerElement: import("../../../utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;
+        readonly innerProps: import("../../../utils").EpPropFinalized<(new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>) | (((new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>)) | null)[], unknown, unknown, () => {}, boolean>;
+        readonly style: import("../../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+        readonly useIsScrolling: BooleanConstructor;
+        readonly width: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly innerWidth: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly perfMode: import("../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly scrollbarAlwaysOn: BooleanConstructor;
+        readonly cache: import("../../../utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+        readonly estimatedItemSize: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly layout: import("../../../utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;
+        readonly initScrollOffset: import("../../../utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+        readonly total: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly itemSize: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(new (...args: any[]) => number | import("../../virtual-list").ItemSize) | (() => number | import("../../virtual-list").ItemSize) | (((new (...args: any[]) => number | import("../../virtual-list").ItemSize) | (() => number | import("../../virtual-list").ItemSize)) | null)[], never, never>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>, {
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        clientSize: import("vue").ComputedRef<string | number | undefined>;
+        estimatedTotalSize: import("vue").ComputedRef<number>;
+        windowStyle: import("vue").ComputedRef<(string | false | import("vue").CSSProperties | import("vue").StyleValue[] | {
+            [x: string]: string;
+            position: string;
+            WebkitOverflowScrolling: string;
+            willChange: string;
+        } | null | undefined)[]>;
+        windowRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        innerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        innerStyle: import("vue").ComputedRef<{
+            height: string;
+            pointerEvents: string | undefined;
+            width: string;
+            margin: number;
+            boxSizing: string;
+        }>;
+        itemsToRender: import("vue").ComputedRef<number[]>;
+        scrollbarRef: import("vue").Ref<any, any>;
+        states: import("vue").Ref<{
+            isScrolling: boolean;
+            scrollDir: import("../../virtual-list").ScrollDirection;
+            scrollOffset: number;
+            updateRequested: boolean;
+            isScrollbarDragging: boolean;
+        }, {
+            isScrolling: boolean;
+            scrollDir: import("../../virtual-list").ScrollDirection;
+            scrollOffset: number;
+            updateRequested: boolean;
+            isScrollbarDragging: boolean;
+        } | {
+            isScrolling: boolean;
+            scrollDir: import("../../virtual-list").ScrollDirection;
+            scrollOffset: number;
+            updateRequested: boolean;
+            isScrollbarDragging: boolean;
+        }>;
+        getItemStyle: (idx: number) => import("vue").CSSProperties;
+        onScroll: (e: Event) => void;
+        onScrollbarScroll: (distanceToGo: number, totalSteps: number) => void;
+        onWheel: (e: WheelEvent) => void;
+        scrollTo: (offset: number) => void;
+        scrollToItem: (idx: number, alignment?: ScrollStrategy) => void;
+        resetScrollTop: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("scroll" | "itemRendered" | "end-reached")[], "scroll" | "itemRendered" | "end-reached", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly className: import("../../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly containerElement: import("../../../utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown, "div", boolean>;
+        readonly data: import("../../../utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | (((new (...args: any[]) => any[]) | (() => any[])) | null)[], unknown, unknown, () => [], boolean>;
+        readonly direction: import("../../../utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;
+        readonly height: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly innerElement: import("../../../utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;
+        readonly innerProps: import("../../../utils").EpPropFinalized<(new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>) | (((new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>)) | null)[], unknown, unknown, () => {}, boolean>;
+        readonly style: import("../../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+        readonly useIsScrolling: BooleanConstructor;
+        readonly width: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly innerWidth: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly perfMode: import("../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly scrollbarAlwaysOn: BooleanConstructor;
+        readonly cache: import("../../../utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+        readonly estimatedItemSize: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly layout: import("../../../utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;
+        readonly initScrollOffset: import("../../../utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+        readonly total: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly itemSize: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(new (...args: any[]) => number | import("../../virtual-list").ItemSize) | (() => number | import("../../virtual-list").ItemSize) | (((new (...args: any[]) => number | import("../../virtual-list").ItemSize) | (() => number | import("../../virtual-list").ItemSize)) | null)[], never, never>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & Readonly<{
+        onScroll?: ((...args: any[]) => any) | undefined;
+        "onEnd-reached"?: ((...args: any[]) => any) | undefined;
+        onItemRendered?: ((...args: any[]) => any) | undefined;
+    }>, {
+        readonly data: any[];
+        readonly layout: import("../../../utils").EpPropMergeType<StringConstructor, "horizontal" | "vertical", never>;
+        readonly style: import("vue").StyleValue;
+        readonly direction: import("../../../utils").EpPropMergeType<StringConstructor, "ltr" | "rtl", never>;
+        readonly className: string;
+        readonly containerElement: import("../../../utils").EpPropMergeType<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown>;
+        readonly innerElement: import("../../../utils").EpPropMergeType<readonly [StringConstructor, ObjectConstructor], unknown, unknown>;
+        readonly innerProps: Record<string, unknown>;
+        readonly perfMode: import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly useIsScrolling: boolean;
+        readonly scrollbarAlwaysOn: boolean;
+        readonly cache: number;
+        readonly initScrollOffset: number;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any> | undefined, import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        readonly className: import("../../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly containerElement: import("../../../utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown, "div", boolean>;
+        readonly data: import("../../../utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | (((new (...args: any[]) => any[]) | (() => any[])) | null)[], unknown, unknown, () => [], boolean>;
+        readonly direction: import("../../../utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;
+        readonly height: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly innerElement: import("../../../utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;
+        readonly innerProps: import("../../../utils").EpPropFinalized<(new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>) | (((new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>)) | null)[], unknown, unknown, () => {}, boolean>;
+        readonly style: import("../../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+        readonly useIsScrolling: BooleanConstructor;
+        readonly width: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly innerWidth: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly perfMode: import("../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly scrollbarAlwaysOn: BooleanConstructor;
+        readonly cache: import("../../../utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+        readonly estimatedItemSize: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly layout: import("../../../utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;
+        readonly initScrollOffset: import("../../../utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+        readonly total: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly itemSize: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(new (...args: any[]) => number | import("../../virtual-list").ItemSize) | (() => number | import("../../virtual-list").ItemSize) | (((new (...args: any[]) => number | import("../../virtual-list").ItemSize) | (() => number | import("../../virtual-list").ItemSize)) | null)[], never, never>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>, {
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        clientSize: import("vue").ComputedRef<string | number | undefined>;
+        estimatedTotalSize: import("vue").ComputedRef<number>;
+        windowStyle: import("vue").ComputedRef<(string | false | import("vue").CSSProperties | import("vue").StyleValue[] | {
+            [x: string]: string;
+            position: string;
+            WebkitOverflowScrolling: string;
+            willChange: string;
+        } | null | undefined)[]>;
+        windowRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        innerRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        innerStyle: import("vue").ComputedRef<{
+            height: string;
+            pointerEvents: string | undefined;
+            width: string;
+            margin: number;
+            boxSizing: string;
+        }>;
+        itemsToRender: import("vue").ComputedRef<number[]>;
+        scrollbarRef: import("vue").Ref<any, any>;
+        states: import("vue").Ref<{
+            isScrolling: boolean;
+            scrollDir: import("../../virtual-list").ScrollDirection;
+            scrollOffset: number;
+            updateRequested: boolean;
+            isScrollbarDragging: boolean;
+        }, {
+            isScrolling: boolean;
+            scrollDir: import("../../virtual-list").ScrollDirection;
+            scrollOffset: number;
+            updateRequested: boolean;
+            isScrollbarDragging: boolean;
+        } | {
+            isScrolling: boolean;
+            scrollDir: import("../../virtual-list").ScrollDirection;
+            scrollOffset: number;
+            updateRequested: boolean;
+            isScrollbarDragging: boolean;
+        }>;
+        getItemStyle: (idx: number) => import("vue").CSSProperties;
+        onScroll: (e: Event) => void;
+        onScrollbarScroll: (distanceToGo: number, totalSteps: number) => void;
+        onWheel: (e: WheelEvent) => void;
+        scrollTo: (offset: number) => void;
+        scrollToItem: (idx: number, alignment?: ScrollStrategy) => void;
+        resetScrollTop: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("scroll" | "itemRendered" | "end-reached")[], "scroll" | "itemRendered" | "end-reached", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly className: import("../../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly containerElement: import("../../../utils").EpPropFinalized<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown, "div", boolean>;
+        readonly data: import("../../../utils").EpPropFinalized<(new (...args: any[]) => any[]) | (() => any[]) | (((new (...args: any[]) => any[]) | (() => any[])) | null)[], unknown, unknown, () => [], boolean>;
+        readonly direction: import("../../../utils").EpPropFinalized<StringConstructor, "ltr" | "rtl", never, "ltr", false>;
+        readonly height: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly innerElement: import("../../../utils").EpPropFinalized<readonly [StringConstructor, ObjectConstructor], unknown, unknown, "div", boolean>;
+        readonly innerProps: import("../../../utils").EpPropFinalized<(new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>) | (((new (...args: any[]) => Record<string, unknown>) | (() => Record<string, unknown>)) | null)[], unknown, unknown, () => {}, boolean>;
+        readonly style: import("../../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+        readonly useIsScrolling: BooleanConstructor;
+        readonly width: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly innerWidth: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<readonly [NumberConstructor, StringConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly perfMode: import("../../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly scrollbarAlwaysOn: BooleanConstructor;
+        readonly cache: import("../../../utils").EpPropFinalized<NumberConstructor, never, never, 2, false>;
+        readonly estimatedItemSize: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly layout: import("../../../utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", never, "vertical", false>;
+        readonly initScrollOffset: import("../../../utils").EpPropFinalized<NumberConstructor, never, never, 0, false>;
+        readonly total: {
+            readonly type: import("vue").PropType<number>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly itemSize: {
+            readonly type: import("vue").PropType<import("../../../utils").EpPropMergeType<(new (...args: any[]) => number | import("../../virtual-list").ItemSize) | (() => number | import("../../virtual-list").ItemSize) | (((new (...args: any[]) => number | import("../../virtual-list").ItemSize) | (() => number | import("../../virtual-list").ItemSize)) | null)[], never, never>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & Readonly<{
+        onScroll?: ((...args: any[]) => any) | undefined;
+        "onEnd-reached"?: ((...args: any[]) => any) | undefined;
+        onItemRendered?: ((...args: any[]) => any) | undefined;
+    }>, {
+        readonly data: any[];
+        readonly layout: import("../../../utils").EpPropMergeType<StringConstructor, "horizontal" | "vertical", never>;
+        readonly style: import("vue").StyleValue;
+        readonly direction: import("../../../utils").EpPropMergeType<StringConstructor, "ltr" | "rtl", never>;
+        readonly className: string;
+        readonly containerElement: import("../../../utils").EpPropMergeType<(new (...args: any[]) => string | Element) | (() => string | Element) | (((new (...args: any[]) => string | Element) | (() => string | Element)) | null)[], unknown, unknown>;
+        readonly innerElement: import("../../../utils").EpPropMergeType<readonly [StringConstructor, ObjectConstructor], unknown, unknown>;
+        readonly innerProps: Record<string, unknown>;
+        readonly perfMode: import("../../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly useIsScrolling: boolean;
+        readonly scrollbarAlwaysOn: boolean;
+        readonly cache: number;
+        readonly initScrollOffset: number;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any> | undefined>;
+    getKey: (node: TreeNodeData) => TreeKey;
+    getChildren: (node: TreeNodeData) => TreeNodeData[];
+    toggleExpand: (node: TreeNode) => void;
+    toggleCheckbox: (node: TreeNode, isChecked: CheckboxValueType, nodeClick?: boolean, immediateUpdate?: boolean, deep?: boolean) => void;
+    isChecked: (node: TreeNode) => boolean;
+    isIndeterminate: (node: TreeNode) => boolean;
+    isDisabled: (node: TreeNode) => boolean;
+    isCurrent: (node: TreeNode) => boolean;
+    isForceHiddenExpandIcon: (node: TreeNode) => boolean;
+    handleNodeClick: (node: TreeNode, e: MouseEvent) => void;
+    handleNodeDrop: (node: TreeNode, e: DragEvent) => void;
+    handleNodeCheck: (node: TreeNode, checked: CheckboxValueType) => void;
+    getCurrentNode: () => TreeNodeData | undefined;
+    getCurrentKey: () => TreeKey | undefined;
+    setCurrentKey: (key: TreeKey) => void;
+    getCheckedKeys: (leafOnly?: boolean) => TreeKey[];
+    getCheckedNodes: (leafOnly?: boolean) => TreeNodeData[];
+    getHalfCheckedKeys: () => TreeKey[];
+    getHalfCheckedNodes: () => TreeNodeData[];
+    setChecked: (key: TreeKey, isChecked: boolean, deep?: boolean) => void;
+    setCheckedKeys: (keys: TreeKey[]) => void;
+    filter: (query: string) => void;
+    setData: (data: TreeData) => void;
+    getNode: (data: TreeKey | TreeNodeData) => TreeNode | undefined;
+    expandNode: (node: TreeNode) => void;
+    collapseNode: (node: TreeNode) => void;
+    setExpandedKeys: (keys: TreeKey[]) => void;
+    scrollToNode: (key: TreeKey, strategy?: ScrollStrategy) => void;
+    scrollTo: (offset: number) => void;
+};

package/dist/components/tree-v2/composables/useTree.js

@@ -0,0 +1,228 @@
+import { ref as b, shallowRef as fe, computed as h, watch as D } from "vue";
+import { isObject as he } from "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import { TreeOptionsEnum as g, NODE_COLLAPSE as ve, NODE_EXPAND as ye, NODE_DROP as ke, NODE_CLICK as Ne, CURRENT_CHANGE as pe } from "../virtual-tree.js";
+import { useCheck as ge } from "./useCheck.js";
+import { useFilter as Ce } from "./useFilter.js";
+function we(o, v) {
+  const s = b(/* @__PURE__ */ new Set()), f = b(), u = fe(), N = b(), {
+    isIndeterminate: A,
+    isChecked: L,
+    toggleCheckbox: C,
+    getCheckedKeys: H,
+    getCheckedNodes: F,
+    getHalfCheckedKeys: P,
+    getHalfCheckedNodes: B,
+    setChecked: j,
+    setCheckedKeys: G
+  } = ge(o, u), { doFilter: U, hiddenNodeKeySet: X, isForceHiddenExpandIcon: Y } = Ce(
+    o,
+    u
+  ), q = h(() => {
+    var e;
+    return ((e = o.props) == null ? void 0 : e.value) || g.KEY;
+  }), z = h(() => {
+    var e;
+    return ((e = o.props) == null ? void 0 : e.children) || g.CHILDREN;
+  }), J = h(() => {
+    var e;
+    return ((e = o.props) == null ? void 0 : e.disabled) || g.DISABLED;
+  }), Q = h(() => {
+    var e;
+    return ((e = o.props) == null ? void 0 : e.label) || g.LABEL;
+  }), K = h(() => {
+    var i;
+    const e = s.value, t = X.value, n = [], c = ((i = u.value) == null ? void 0 : i.treeNodes) || [], a = [];
+    for (let r = c.length - 1; r >= 0; --r)
+      a.push(c[r]);
+    for (; a.length; ) {
+      const r = a.pop();
+      if (!t.has(r.key) && (n.push(r), r.children && e.has(r.key)))
+        for (let d = r.children.length - 1; d >= 0; --d)
+          a.push(r.children[d]);
+    }
+    return n;
+  }), V = h(() => K.value.length > 0);
+  function W(e) {
+    const t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+    let c = 1;
+    function a(r, d = 1, se = void 0) {
+      var R;
+      const I = [];
+      for (const y of r) {
+        const m = x(y), l = {
+          level: d,
+          key: m,
+          data: y
+        };
+        l.label = ee(y), l.parent = se;
+        const k = O(y);
+        l.disabled = $(y), l.isLeaf = !k || k.length === 0, l.expanded = s.value.has(m), k && k.length && (l.children = a(k, d + 1, l)), I.push(l), t.set(m, l), n.has(d) || n.set(d, []), (R = n.get(d)) == null || R.push(l);
+      }
+      return d > c && (c = d), I;
+    }
+    const i = a(e);
+    return {
+      treeNodeMap: t,
+      levelTreeNodeMap: n,
+      maxLevel: c,
+      treeNodes: i
+    };
+  }
+  function Z(e) {
+    const t = U(e);
+    t && (s.value = t);
+  }
+  function O(e) {
+    return e[z.value];
+  }
+  function x(e) {
+    return e ? e[q.value] : "";
+  }
+  function $(e) {
+    return e[J.value];
+  }
+  function ee(e) {
+    return e[Q.value];
+  }
+  function w(e) {
+    s.value.has(e.key) ? M(e) : T(e);
+  }
+  function E(e) {
+    const t = /* @__PURE__ */ new Set(), n = u.value.treeNodeMap;
+    s.value.forEach((c) => {
+      const a = n.get(c);
+      a && (a.expanded = !1);
+    }), e.forEach((c) => {
+      let a = n.get(c);
+      for (; a && !t.has(a.key); )
+        t.add(a.key), a.expanded = !0, a = a.parent;
+    }), s.value = t;
+  }
+  function te(e, t) {
+    ae(e), v(Ne, e.data, e, t), o.expandOnClickNode && w(e), o.showCheckbox && (o.checkOnClickNode || e.isLeaf && o.checkOnClickLeaf) && !e.disabled && C(e, !L(e), !0);
+  }
+  function ne(e, t) {
+    v(ke, e.data, e, t);
+  }
+  function ae(e) {
+    S(e) || (f.value = e.key, v(pe, e.data, e));
+  }
+  function oe(e, t) {
+    C(e, t);
+  }
+  function T(e) {
+    const t = s.value;
+    if (u.value && o.accordion) {
+      const { treeNodeMap: c } = u.value;
+      t.forEach((a) => {
+        const i = c.get(a);
+        e && e.level === (i == null ? void 0 : i.level) && (t.delete(a), i.expanded = !1);
+      });
+    }
+    t.add(e.key);
+    const n = p(e.key);
+    n && (n.expanded = !0, v(ye, n.data, n));
+  }
+  function M(e) {
+    s.value.delete(e.key);
+    const t = p(e.key);
+    t && (t.expanded = !1, v(ve, t.data, t));
+  }
+  function ce(e) {
+    return !!e.disabled;
+  }
+  function S(e) {
+    const t = f.value;
+    return t !== void 0 && t === e.key;
+  }
+  function re() {
+    var e, t;
+    if (f.value !== void 0)
+      return (t = (e = u.value) == null ? void 0 : e.treeNodeMap.get(f.value)) == null ? void 0 : t.data;
+  }
+  function de() {
+    return f.value;
+  }
+  function ue(e) {
+    f.value = e;
+  }
+  function _(e) {
+    u.value = W(e);
+  }
+  function p(e) {
+    var n;
+    const t = he(e) ? x(e) : e;
+    return (n = u.value) == null ? void 0 : n.treeNodeMap.get(t);
+  }
+  function le(e, t = "auto") {
+    const n = p(e);
+    n && N.value && N.value.scrollToItem(K.value.indexOf(n), t);
+  }
+  function ie(e) {
+    var t;
+    (t = N.value) == null || t.scrollTo(e);
+  }
+  return D(
+    () => o.currentNodeKey,
+    (e) => {
+      f.value = e;
+    },
+    {
+      immediate: !0
+    }
+  ), D(
+    () => o.defaultExpandedKeys,
+    (e) => {
+      E(e || []);
+    }
+  ), D(
+    () => o.data,
+    (e) => {
+      _(e), E(o.defaultExpandedKeys || []);
+    },
+    {
+      immediate: !0
+    }
+  ), {
+    tree: u,
+    flattenTree: K,
+    isNotEmpty: V,
+    listRef: N,
+    getKey: x,
+    getChildren: O,
+    toggleExpand: w,
+    toggleCheckbox: C,
+    isChecked: L,
+    isIndeterminate: A,
+    isDisabled: ce,
+    isCurrent: S,
+    isForceHiddenExpandIcon: Y,
+    handleNodeClick: te,
+    handleNodeDrop: ne,
+    handleNodeCheck: oe,
+    // expose
+    getCurrentNode: re,
+    getCurrentKey: de,
+    setCurrentKey: ue,
+    getCheckedKeys: H,
+    getCheckedNodes: F,
+    getHalfCheckedKeys: P,
+    getHalfCheckedNodes: B,
+    setChecked: j,
+    setCheckedKeys: G,
+    filter: Z,
+    setData: _,
+    getNode: p,
+    expandNode: T,
+    collapseNode: M,
+    setExpandedKeys: E,
+    scrollToNode: le,
+    scrollTo: ie
+  };
+}
+export {
+  we as useTree
+};

package/dist/components/tree-v2/index.d.ts

@@ -1,4 +1,13 @@
 import type { Plugin } from 'vue';
-import { ElTreeV2 } from 'element-plus';
-export declare const EpTreeV2: typeof ElTreeV2 & Plugin;
+import _EpTreeV2 from './EpTreeV2.vue';
+/**
+ * tree-v2 自持 barrel：用本地安装辅助把搬运来的虚拟树本体注册为 `ep-tree-v2`。
+ *
+ * - 必须使用 `../../utils/with-install`（本地版）：第二参是显式注册名。
+ * - 不导出 `ElTreeV2` 别名；公开面只保留 `EpTreeV2` 与 `TreeV2Instance`。
+ * - 节点上下文里的 `formItemContextKey` 已改为本地 Symbol，树节点不继承
+ *   父级表单项的 `disabled` / `size`。
+ */
+export declare const EpTreeV2: typeof _EpTreeV2 & Plugin;
 export default EpTreeV2;
+export type { TreeV2Instance } from './instance';

package/dist/components/tree-v2/index.js

@@ -1,6 +1,9 @@
-import { ElTreeV2 as e } from "element-plus";
 import { withInstall as r } from "../../utils/with-install.js";
-const t = Object.assign({}, e, { name: "EpTreeV2" }), m = r(t, "ep-tree-v2");
+import t from "./EpTreeV2.vue.js";
+const m = r(
+  t,
+  "ep-tree-v2"
+);
 export {
   m as EpTreeV2
 };