@antdv-next/mobile 0.0.0-stage → 0.1.0

package/dist/tree/TreeNode.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,255 @@
+import Spinner_default from "../_base/Spinner.js";
+import { isRenderable } from "../_util/index.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import Checkbox_default from "../checkbox/Checkbox.js";
+import { useTreeContext } from "./context.js";
+import { getNodeChildren } from "./util.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, normalizeClass, normalizeStyle, openBlock, renderList, toDisplayString, unref } from "vue";
+import { CaretDownFilled, FileOutlined, MinusSquareOutlined, PlusSquareOutlined } from "@antdv-next/icons";
+// src/tree/TreeNode.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = [
+	"data-key",
+	"aria-level",
+	"aria-expanded",
+	"aria-selected",
+	"aria-checked",
+	"aria-disabled"
+];
+var _hoisted_2 = {
+	class: "am-tree-indent",
+	"aria-hidden": "true"
+};
+var _hoisted_3 = {
+	key: 0,
+	class: "am-tree-switcher-loading-icon"
+};
+var _hoisted_4 = {
+	key: 1,
+	class: "am-tree-switcher-leaf-line"
+};
+var _hoisted_5 = {
+	key: 2,
+	class: "am-tree-switcher-line-icon"
+};
+var _hoisted_6 = {
+	key: 3,
+	class: "am-tree-switcher-line-icon"
+};
+var _hoisted_7 = {
+	key: 5,
+	class: "am-tree-switcher-line-icon"
+};
+var _hoisted_8 = {
+	key: 6,
+	class: "am-tree-switcher-icon"
+};
+var TreeNode_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmTreeNode",
+	__name: "TreeNode",
+	props: { node: {} },
+	setup(__props) {
+		const props = __props;
+		const ctx = useTreeContext();
+		const data = computed(() => props.node.data);
+		const nodeKey = computed(() => props.node.key);
+		const level = computed(() => props.node.level);
+		const expanded = computed(() => ctx.expandedKeys.value.has(nodeKey.value));
+		const selected = computed(() => ctx.selectedKeys.value.has(nodeKey.value));
+		const checked = computed(() => ctx.checkedKeys.value.has(nodeKey.value));
+		const halfChecked = computed(() => ctx.halfCheckedKeys.value.has(nodeKey.value));
+		const loaded = computed(() => ctx.loadedKeys.value.has(nodeKey.value));
+		const loading = computed(() => ctx.loadingKeys.value.has(nodeKey.value));
+		const hasChildren = computed(() => getNodeChildren(data.value, ctx.fieldNames.value).length > 0);
+		const isLeaf = computed(() => {
+			const leaf = data.value.isLeaf;
+			if (leaf === false) return false;
+			if (leaf) return true;
+			if (hasChildren.value) return false;
+			return !ctx.props.loadData || loaded.value;
+		});
+		const disabled = computed(() => ctx.disabled.value || !!data.value.disabled);
+		const checkable = computed(() => !!ctx.props.checkable && data.value.checkable !== false);
+		const selectable = computed(() => typeof data.value.selectable === "boolean" ? data.value.selectable : ctx.props.selectable !== false);
+		const checkboxDisabled = computed(() => disabled.value || !!data.value.disableCheckbox);
+		const isEnd = computed(() => props.node.isEnd[level.value] === true);
+		const nodeAttribute = computed(() => ({
+			eventKey: nodeKey.value,
+			expanded: expanded.value,
+			selected: selected.value,
+			checked: checked.value,
+			halfChecked: halfChecked.value,
+			loaded: loaded.value,
+			loading: loading.value,
+			isLeaf: isLeaf.value,
+			disabled: disabled.value,
+			disableCheckbox: !!data.value.disableCheckbox,
+			checkable: checkable.value,
+			selectable: selectable.value,
+			pos: props.node.pos,
+			level: level.value,
+			data: data.value
+		}));
+		const renderIconSlot = (attrs) => ctx.slots.icon?.(attrs);
+		const renderSwitcherIconSlot = (attrs) => ctx.slots.switcherIcon?.(attrs);
+		const renderSwitcherLoadingIconSlot = () => ctx.slots.switcherLoadingIcon?.();
+		const renderTitleSlot = (node) => (ctx.slots.title ?? ctx.slots.titleRender)?.(node);
+		const showLine = computed(() => !!ctx.props.showLine);
+		const leafIcon = computed(() => {
+			const config = ctx.props.showLine;
+			return config && typeof config === "object" ? config.showLeafIcon : void 0;
+		});
+		/** node > slot > prop */
+		const customSwitcher = computed(() => {
+			if (isRenderable(data.value.switcherIcon)) return data.value.switcherIcon;
+			if (ctx.hasSlot.switcherIcon) return renderSwitcherIconSlot;
+			return isRenderable(ctx.props.switcherIcon) ? ctx.props.switcherIcon : void 0;
+		});
+		const loadingIcon = computed(() => {
+			if (ctx.hasSlot.switcherLoadingIcon) return renderSwitcherLoadingIconSlot;
+			return isRenderable(ctx.props.switcherLoadingIcon) ? ctx.props.switcherLoadingIcon : void 0;
+		});
+		const switcherKind = computed(() => {
+			if (loading.value) return "loading";
+			if (isLeaf.value) {
+				if (isRenderable(data.value.switcherIcon)) return "custom";
+				if (!showLine.value) return "none";
+				if (leafIcon.value === true) return "leaf-file";
+				return isRenderable(leafIcon.value) ? "leaf-custom" : "leaf-line";
+			}
+			if (customSwitcher.value !== void 0) return "custom";
+			return showLine.value ? "line" : "caret";
+		});
+		/** node > slot > prop */
+		const iconNode = computed(() => {
+			if (!ctx.props.showIcon) return void 0;
+			if (isRenderable(data.value.icon)) return data.value.icon;
+			if (ctx.hasSlot.icon) return renderIconSlot;
+			return isRenderable(ctx.props.icon) ? ctx.props.icon : void 0;
+		});
+		const title = computed(() => data.value[ctx.fieldNames.value.title]);
+		const hasTitleSlot = computed(() => ctx.hasSlot.title || ctx.hasSlot.titleRender);
+		const filtered = computed(() => !!ctx.props.filterTreeNode && !!ctx.props.filterTreeNode(ctx.getEventNode(nodeKey.value)));
+		function onExpand(event) {
+			if (loading.value || isLeaf.value) return;
+			ctx.onNodeExpand(event, ctx.getEventNode(nodeKey.value));
+		}
+		function onCheck(event) {
+			if (!checkable.value || checkboxDisabled.value) return;
+			ctx.onNodeCheck(event, ctx.getEventNode(nodeKey.value), !checked.value);
+		}
+		function onCheckboxChange(event) {
+			onCheck(event.nativeEvent);
+		}
+		function onSelectorClick(event) {
+			const node = ctx.getEventNode(nodeKey.value);
+			ctx.onNodeClick(event, node);
+			if (ctx.props.expandAction === "click") onExpand(event);
+			if (selectable.value) {
+				if (!disabled.value) ctx.onNodeSelect(event, node);
+			} else onCheck(event);
+		}
+		const classNames = computed(() => [
+			"am-tree-treenode",
+			{
+				"am-tree-treenode-disabled": disabled.value,
+				"am-tree-treenode-unselectable": !selectable.value,
+				"am-tree-treenode-switcher-open": !isLeaf.value && expanded.value,
+				"am-tree-treenode-switcher-close": !isLeaf.value && !expanded.value,
+				"am-tree-treenode-checkbox-checked": checked.value,
+				"am-tree-treenode-checkbox-indeterminate": halfChecked.value,
+				"am-tree-treenode-selected": selected.value,
+				"am-tree-treenode-loading": loading.value,
+				"am-tree-treenode-leaf": isLeaf.value,
+				"am-tree-treenode-leaf-last": isEnd.value,
+				"am-tree-filter-node": filtered.value
+			},
+			data.value.class,
+			data.value.className,
+			ctx.props.classes?.item
+		]);
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				role: "treeitem",
+				class: normalizeClass(classNames.value),
+				style: normalizeStyle([
+					{ "--am-tree-level": level.value },
+					data.value.style,
+					unref(ctx).props.styles?.item
+				]),
+				"data-key": nodeKey.value,
+				"aria-level": level.value + 1,
+				"aria-expanded": isLeaf.value ? void 0 : expanded.value,
+				"aria-selected": selectable.value && !disabled.value ? selected.value : void 0,
+				"aria-checked": checkable.value && !disabled.value ? halfChecked.value ? "mixed" : checked.value : void 0,
+				"aria-disabled": disabled.value || void 0
+			}, [
+				createElementVNode("span", _hoisted_2, [showLine.value ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(level.value, (index) => {
+					return openBlock(), createElementBlock("span", {
+						key: index,
+						class: normalizeClass(["am-tree-indent-unit", {
+							"am-tree-indent-unit-start": __props.node.isStart[index - 1],
+							"am-tree-indent-unit-end": __props.node.isEnd[index - 1]
+						}])
+					}, null, 2);
+				}), 128)) : createCommentVNode("", true)]),
+				createElementVNode("span", {
+					class: normalizeClass(["am-tree-switcher", [isLeaf.value ? "am-tree-switcher-noop" : expanded.value ? "am-tree-switcher-open" : "am-tree-switcher-close", unref(ctx).props.classes?.itemSwitcher]]),
+					style: normalizeStyle(unref(ctx).props.styles?.itemSwitcher),
+					onClick: onExpand
+				}, [switcherKind.value === "loading" ? (openBlock(), createElementBlock("span", _hoisted_3, [loadingIcon.value !== void 0 ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: loadingIcon.value
+				}, null, 8, ["node"])) : (openBlock(), createBlock(unref(Spinner_default), { key: 1 }))])) : switcherKind.value === "leaf-line" ? (openBlock(), createElementBlock("span", _hoisted_4)) : switcherKind.value === "leaf-file" ? (openBlock(), createElementBlock("span", _hoisted_5, [createVNode(unref(FileOutlined))])) : switcherKind.value === "leaf-custom" ? (openBlock(), createElementBlock("span", _hoisted_6, [createVNode(unref(RenderNode_default), {
+					node: leafIcon.value,
+					params: nodeAttribute.value
+				}, null, 8, ["node", "params"])])) : switcherKind.value === "custom" ? (openBlock(), createElementBlock("span", {
+					key: 4,
+					class: normalizeClass(showLine.value ? "am-tree-switcher-line-icon" : "am-tree-switcher-icon")
+				}, [createVNode(unref(RenderNode_default), {
+					node: customSwitcher.value,
+					params: nodeAttribute.value
+				}, null, 8, ["node", "params"])], 2)) : switcherKind.value === "line" ? (openBlock(), createElementBlock("span", _hoisted_7, [expanded.value ? (openBlock(), createBlock(unref(MinusSquareOutlined), { key: 0 })) : (openBlock(), createBlock(unref(PlusSquareOutlined), { key: 1 }))])) : switcherKind.value === "caret" ? (openBlock(), createElementBlock("span", _hoisted_8, [createVNode(unref(CaretDownFilled))])) : createCommentVNode("", true)], 6),
+				checkable.value ? (openBlock(), createBlock(Checkbox_default, {
+					key: 0,
+					"root-class": "am-tree-checkbox",
+					"skip-group": "",
+					checked: checked.value,
+					indeterminate: !checked.value && halfChecked.value,
+					disabled: checkboxDisabled.value,
+					onChange: onCheckboxChange
+				}, null, 8, [
+					"checked",
+					"indeterminate",
+					"disabled"
+				])) : createCommentVNode("", true),
+				createElementVNode("span", {
+					class: normalizeClass(["am-tree-node-content-wrapper", { "am-tree-node-selected": selected.value && !disabled.value }]),
+					onClick: onSelectorClick
+				}, [iconNode.value !== void 0 ? (openBlock(), createElementBlock("span", {
+					key: 0,
+					class: normalizeClass(["am-tree-icon", unref(ctx).props.classes?.itemIcon]),
+					style: normalizeStyle(unref(ctx).props.styles?.itemIcon)
+				}, [createVNode(unref(RenderNode_default), {
+					node: iconNode.value,
+					params: nodeAttribute.value
+				}, null, 8, ["node", "params"])], 6)) : createCommentVNode("", true), createElementVNode("span", {
+					class: normalizeClass(["am-tree-title", unref(ctx).props.classes?.itemTitle]),
+					style: normalizeStyle(unref(ctx).props.styles?.itemTitle)
+				}, [typeof title.value === "function" ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: title.value,
+					params: data.value
+				}, null, 8, ["node", "params"])) : hasTitleSlot.value ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 1,
+					node: renderTitleSlot,
+					params: data.value
+				}, null, 8, ["params"])) : unref(ctx).props.titleRender ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 2,
+					node: unref(ctx).props.titleRender,
+					params: data.value
+				}, null, 8, ["node", "params"])) : (openBlock(), createElementBlock(Fragment, { key: 3 }, [createTextVNode(toDisplayString(title.value ?? "---"), 1)], 64))], 6)], 2)
+			], 14, _hoisted_1);
+		};
+	}
+});
+export { TreeNode_vue_vue_type_script_setup_true_lang_default as default };

package/dist/tree/context.d.ts

@@ -0,0 +1,34 @@
+import type { ComputedRef, InjectionKey } from 'vue';
+import type { Key } from '../_util/type';
+import type { TreeEventDataNode, TreeProps, TreeSlots } from './interface';
+import type { TreeResolvedFieldNames } from './util';
+export interface TreeSlotFlags {
+    title: boolean;
+    titleRender: boolean;
+    icon: boolean;
+    switcherIcon: boolean;
+    switcherLoadingIcon: boolean;
+}
+/** Tree -> TreeNode: the rows read their state from here instead of receiving a dozen props each. */
+export interface TreeContext {
+    props: TreeProps;
+    /** the live slots of Tree: always call through it, never keep a slot function */
+    slots: TreeSlots;
+    /** which slots are present (reactive, so the rows follow a slot that is added / removed later) */
+    hasSlot: TreeSlotFlags;
+    disabled: ComputedRef<boolean>;
+    fieldNames: ComputedRef<TreeResolvedFieldNames>;
+    expandedKeys: ComputedRef<Set<Key>>;
+    selectedKeys: ComputedRef<Set<Key>>;
+    checkedKeys: ComputedRef<Set<Key>>;
+    halfCheckedKeys: ComputedRef<Set<Key>>;
+    loadedKeys: ComputedRef<Set<Key>>;
+    loadingKeys: ComputedRef<Set<Key>>;
+    getEventNode: (key: Key) => TreeEventDataNode;
+    onNodeClick: (event: MouseEvent, node: TreeEventDataNode) => void;
+    onNodeExpand: (event: Event, node: TreeEventDataNode) => void;
+    onNodeSelect: (event: Event, node: TreeEventDataNode) => void;
+    onNodeCheck: (event: Event, node: TreeEventDataNode, checked: boolean) => void;
+}
+export declare const treeContextKey: InjectionKey<TreeContext>;
+export declare function useTreeContext(): TreeContext;

package/dist/tree/context.js

@@ -0,0 +1,9 @@
+import { inject } from "vue";
+// src/tree/context.ts
+var treeContextKey = Symbol("AmTreeContext");
+function useTreeContext() {
+	const context = inject(treeContextKey, null);
+	if (!context) throw new Error("[@antdv-next/mobile] TreeNode must be rendered by Tree");
+	return context;
+}
+export { treeContextKey, useTreeContext };

package/dist/tree/index.d.ts

@@ -0,0 +1,145 @@
+export type * from './interface';
+declare const Tree: import("../_util/withInstall").WithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").TreeProps> & Readonly<{
+        onSelect?: ((selectedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeSelectInfo) => any) | undefined;
+        onClick?: ((event: MouseEvent, node: import("./interface").TreeEventDataNode) => any) | undefined;
+        onLoad?: ((loadedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeLoadInfo) => any) | undefined;
+        onScroll?: ((event: Event) => any) | undefined;
+        onCheck?: ((checkedKeys: import("./interface").TreeCheckedKeys, info: import("./interface").TreeCheckInfo) => any) | undefined;
+        "onUpdate:expandedKeys"?: ((expandedKeys: import("../_util/type.ts").Key[]) => any) | undefined;
+        "onUpdate:selectedKeys"?: ((selectedKeys: import("../_util/type.ts").Key[]) => any) | undefined;
+        "onUpdate:checkedKeys"?: ((checkedKeys: import("../_util/type.ts").Key[]) => any) | undefined;
+        onExpand?: ((expandedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeExpandInfo) => any) | undefined;
+    }>, {
+        scrollTo: (target: number | import("./interface").TreeScrollToConfig) => void;
+        readonly nativeElement: HTMLElement | undefined;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        select: (selectedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeSelectInfo) => any;
+        click: (event: MouseEvent, node: import("./interface").TreeEventDataNode) => any;
+        load: (loadedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeLoadInfo) => any;
+        scroll: (event: Event) => any;
+        check: (checkedKeys: import("./interface").TreeCheckedKeys, info: import("./interface").TreeCheckInfo) => any;
+        "update:expandedKeys": (expandedKeys: import("../_util/type.ts").Key[]) => any;
+        "update:selectedKeys": (selectedKeys: import("../_util/type.ts").Key[]) => any;
+        "update:checkedKeys": (checkedKeys: import("../_util/type.ts").Key[]) => any;
+        expand: (expandedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeExpandInfo) => any;
+    }, import("vue").PublicProps, {
+        icon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").TreeNodeAttribute) => import("vue").VNodeChild) | null;
+        multiple: boolean;
+        disabled: boolean;
+        showIcon: boolean;
+        virtual: boolean;
+        selectable: boolean;
+        checkable: boolean;
+        switcherIcon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").TreeNodeAttribute) => import("vue").VNodeChild) | null;
+        defaultExpandAll: boolean;
+        autoExpandParent: boolean;
+        defaultExpandParent: boolean;
+        checkStrictly: boolean;
+        blockNode: boolean;
+        showLine: boolean | import("./interface").TreeShowLineConfig;
+        switcherLoadingIcon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        expandAction: import("./interface").TreeExpandAction;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").TreeProps> & Readonly<{
+        onSelect?: ((selectedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeSelectInfo) => any) | undefined;
+        onClick?: ((event: MouseEvent, node: import("./interface").TreeEventDataNode) => any) | undefined;
+        onLoad?: ((loadedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeLoadInfo) => any) | undefined;
+        onScroll?: ((event: Event) => any) | undefined;
+        onCheck?: ((checkedKeys: import("./interface").TreeCheckedKeys, info: import("./interface").TreeCheckInfo) => any) | undefined;
+        "onUpdate:expandedKeys"?: ((expandedKeys: import("../_util/type.ts").Key[]) => any) | undefined;
+        "onUpdate:selectedKeys"?: ((selectedKeys: import("../_util/type.ts").Key[]) => any) | undefined;
+        "onUpdate:checkedKeys"?: ((checkedKeys: import("../_util/type.ts").Key[]) => any) | undefined;
+        onExpand?: ((expandedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeExpandInfo) => any) | undefined;
+    }>, {
+        scrollTo: (target: number | import("./interface").TreeScrollToConfig) => void;
+        readonly nativeElement: HTMLElement | undefined;
+    }, {}, {}, {}, {
+        icon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").TreeNodeAttribute) => import("vue").VNodeChild) | null;
+        multiple: boolean;
+        disabled: boolean;
+        showIcon: boolean;
+        virtual: boolean;
+        selectable: boolean;
+        checkable: boolean;
+        switcherIcon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").TreeNodeAttribute) => import("vue").VNodeChild) | null;
+        defaultExpandAll: boolean;
+        autoExpandParent: boolean;
+        defaultExpandParent: boolean;
+        checkStrictly: boolean;
+        blockNode: boolean;
+        showLine: boolean | import("./interface").TreeShowLineConfig;
+        switcherLoadingIcon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+        expandAction: import("./interface").TreeExpandAction;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").TreeProps> & Readonly<{
+    onSelect?: ((selectedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeSelectInfo) => any) | undefined;
+    onClick?: ((event: MouseEvent, node: import("./interface").TreeEventDataNode) => any) | undefined;
+    onLoad?: ((loadedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeLoadInfo) => any) | undefined;
+    onScroll?: ((event: Event) => any) | undefined;
+    onCheck?: ((checkedKeys: import("./interface").TreeCheckedKeys, info: import("./interface").TreeCheckInfo) => any) | undefined;
+    "onUpdate:expandedKeys"?: ((expandedKeys: import("../_util/type.ts").Key[]) => any) | undefined;
+    "onUpdate:selectedKeys"?: ((selectedKeys: import("../_util/type.ts").Key[]) => any) | undefined;
+    "onUpdate:checkedKeys"?: ((checkedKeys: import("../_util/type.ts").Key[]) => any) | undefined;
+    onExpand?: ((expandedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeExpandInfo) => any) | undefined;
+}>, {
+    scrollTo: (target: number | import("./interface").TreeScrollToConfig) => void;
+    readonly nativeElement: HTMLElement | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (selectedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeSelectInfo) => any;
+    click: (event: MouseEvent, node: import("./interface").TreeEventDataNode) => any;
+    load: (loadedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeLoadInfo) => any;
+    scroll: (event: Event) => any;
+    check: (checkedKeys: import("./interface").TreeCheckedKeys, info: import("./interface").TreeCheckInfo) => any;
+    "update:expandedKeys": (expandedKeys: import("../_util/type.ts").Key[]) => any;
+    "update:selectedKeys": (selectedKeys: import("../_util/type.ts").Key[]) => any;
+    "update:checkedKeys": (checkedKeys: import("../_util/type.ts").Key[]) => any;
+    expand: (expandedKeys: import("../_util/type.ts").Key[], info: import("./interface").TreeExpandInfo) => any;
+}, string, {
+    icon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").TreeNodeAttribute) => import("vue").VNodeChild) | null;
+    multiple: boolean;
+    disabled: boolean;
+    showIcon: boolean;
+    virtual: boolean;
+    selectable: boolean;
+    checkable: boolean;
+    switcherIcon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | ((ctx: import("./interface").TreeNodeAttribute) => import("vue").VNodeChild) | null;
+    defaultExpandAll: boolean;
+    autoExpandParent: boolean;
+    defaultExpandParent: boolean;
+    checkStrictly: boolean;
+    blockNode: boolean;
+    showLine: boolean | import("./interface").TreeShowLineConfig;
+    switcherLoadingIcon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    expandAction: import("./interface").TreeExpandAction;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./interface").TreeSlots;
+}), object>;
+export default Tree;

package/dist/tree/index.js

@@ -0,0 +1,5 @@
+import { withInstall } from "../_util/withInstall.js";
+import Tree_default from "./Tree.js";
+// src/tree/index.ts
+var Tree = withInstall(Tree_default, "AmTree");
+export { Tree as default };

package/dist/tree/interface.d.ts

@@ -0,0 +1,214 @@
+import type { CSSProperties } from 'vue';
+import type { Key, RenderNodeFn, VueNode } from '../_util/type';
+export type TreeKey = Key;
+export interface TreeFieldNames {
+    title?: string;
+    key?: string;
+    children?: string;
+}
+/** State of a rendered node, passed to the `icon` / `switcherIcon` render props and slots. */
+export interface TreeNodeAttribute {
+    eventKey: Key;
+    expanded: boolean;
+    selected: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    loaded: boolean;
+    loading: boolean;
+    isLeaf: boolean;
+    disabled: boolean;
+    disableCheckbox: boolean;
+    checkable: boolean;
+    selectable: boolean;
+    /** position in the tree, e.g. `0-1-2` */
+    pos: string;
+    /** depth, `0` for root nodes */
+    level: number;
+    /** the node of `treeData` */
+    data: TreeDataNode;
+}
+export interface TreeDataNode {
+    /** unique in the whole tree. Default: the position of the node (`0-0-1`). */
+    key?: Key;
+    title?: RenderNodeFn<TreeDataNode>;
+    children?: TreeDataNode[];
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    selectable?: boolean;
+    /** `false` hides the checkbox of this node */
+    checkable?: boolean;
+    /** With `loadData`: `true` never loads, `false` forces a parent node */
+    isLeaf?: boolean;
+    icon?: RenderNodeFn<TreeNodeAttribute>;
+    switcherIcon?: RenderNodeFn<TreeNodeAttribute>;
+    class?: string;
+    /** alias of `class` (PC name) */
+    className?: string;
+    style?: CSSProperties;
+    [key: string]: any;
+}
+/** A node of `treeData` together with its current state, the `node` of every event. */
+export interface TreeEventDataNode extends TreeDataNode {
+    key: Key;
+    expanded: boolean;
+    selected: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    loaded: boolean;
+    loading: boolean;
+    pos: string;
+}
+export interface TreeCheckedKeysObject {
+    checked: Key[];
+    halfChecked: Key[];
+}
+export type TreeCheckedKeys = Key[] | TreeCheckedKeysObject;
+export interface TreeExpandInfo {
+    node: TreeEventDataNode;
+    expanded: boolean;
+    nativeEvent: Event;
+}
+export interface TreeSelectInfo {
+    event: 'select';
+    selected: boolean;
+    node: TreeEventDataNode;
+    selectedNodes: TreeDataNode[];
+    nativeEvent: Event;
+}
+export interface TreeCheckedNodePosition {
+    node: TreeDataNode;
+    pos: string;
+}
+export interface TreeCheckInfo {
+    event: 'check';
+    node: TreeEventDataNode;
+    checked: boolean;
+    nativeEvent: Event;
+    checkedNodes: TreeDataNode[];
+    /** only without `checkStrictly` */
+    checkedNodesPositions?: TreeCheckedNodePosition[];
+    /** only without `checkStrictly` */
+    halfCheckedKeys?: Key[];
+}
+export interface TreeLoadInfo {
+    event: 'load';
+    node: TreeEventDataNode;
+}
+export interface TreeShowLineConfig {
+    /** `true`: a file icon in front of leaves, or a custom icon */
+    showLeafIcon: RenderNodeFn<TreeNodeAttribute>;
+}
+export type TreeExpandAction = false | 'click';
+export interface TreeScrollToConfig {
+    key: Key;
+    /** `top` / `bottom` as on PC, `center` and `auto` (only when out of view) in addition. Default `top`. */
+    align?: 'top' | 'bottom' | 'center' | 'auto';
+    offset?: number;
+    /** expand the target node first (uncontrolled `expandedKeys` only), same as PC */
+    autoExpand?: boolean;
+}
+export interface TreeSemanticClassNames {
+    root?: string;
+    item?: string;
+    itemIcon?: string;
+    itemTitle?: string;
+    itemSwitcher?: string;
+}
+export interface TreeSemanticStyles {
+    root?: CSSProperties;
+    item?: CSSProperties;
+    itemIcon?: CSSProperties;
+    itemTitle?: CSSProperties;
+    itemSwitcher?: CSSProperties;
+}
+export interface TreeProps {
+    /** Tree nodes: `{ key, title, children, disabled, disableCheckbox, selectable, checkable, isLeaf, icon, switcherIcon, class, style }` */
+    treeData?: TreeDataNode[];
+    /** Custom field names of `title` / `key` / `children` */
+    fieldNames?: TreeFieldNames;
+    /** (Controlled) expanded nodes, `v-model:expandedKeys` */
+    expandedKeys?: Key[];
+    defaultExpandedKeys?: Key[];
+    defaultExpandAll?: boolean;
+    /** Controlled `expandedKeys`: also expand the parents of the given keys */
+    autoExpandParent?: boolean;
+    /** Expand the parents of the initially expanded keys. Default `true`. */
+    defaultExpandParent?: boolean;
+    /** (Controlled) selected nodes, `v-model:selectedKeys` */
+    selectedKeys?: Key[];
+    defaultSelectedKeys?: Key[];
+    /** (Controlled) checked nodes, `v-model:checkedKeys`. `{ checked, halfChecked }` with `checkStrictly`. */
+    checkedKeys?: TreeCheckedKeys;
+    defaultCheckedKeys?: Key[];
+    /** Show a checkbox in front of every node */
+    checkable?: boolean;
+    /** Parent and children are checked independently */
+    checkStrictly?: boolean;
+    /** Default `true` */
+    selectable?: boolean;
+    /** Allow more than one selected node */
+    multiple?: boolean;
+    disabled?: boolean;
+    /** The node content fills the row, so the whole row is the touch target. Default `true` (mobile). */
+    blockNode?: boolean;
+    /** Render `icon` in front of the title */
+    showIcon?: boolean;
+    /** Guide lines. `{ showLeafIcon }` adds an icon in front of leaves. */
+    showLine?: boolean | TreeShowLineConfig;
+    /** Icon in front of the title (needs `showIcon`), the `icon` slot wins */
+    icon?: RenderNodeFn<TreeNodeAttribute>;
+    /** Expand / collapse icon, the `switcherIcon` slot wins */
+    switcherIcon?: RenderNodeFn<TreeNodeAttribute>;
+    /** Icon of a node that is loading its children, the `switcherLoadingIcon` slot wins */
+    switcherLoadingIcon?: VueNode;
+    /** Custom title, the `titleRender` / `title` slots win */
+    titleRender?: (node: TreeDataNode) => any;
+    /** Load the children of a node when it is expanded */
+    loadData?: (node: TreeEventDataNode) => Promise<any> | void;
+    /** (Controlled) nodes whose children were loaded */
+    loadedKeys?: Key[];
+    /** Highlight the nodes for which it returns `true` */
+    filterTreeNode?: (node: TreeEventDataNode) => boolean;
+    /** Mobile: a tap on the node content also expands / collapses it */
+    expandAction?: TreeExpandAction;
+    /** Only mount the rows around the visible window (needs `height`). `false` renders every row. Default `true`. */
+    virtual?: boolean;
+    /** Height of the scroll container. Without it the tree grows with its content. */
+    height?: number | string;
+    /** Min height of a row in px and the estimate used before a row is measured. Default `44`. */
+    itemHeight?: number;
+    /** Alias of `height`, the name used by Select / Cascader */
+    listHeight?: number | string;
+    /** Alias of `itemHeight`, the name used by Select / Cascader */
+    listItemHeight?: number;
+    rootClass?: string;
+    classes?: TreeSemanticClassNames;
+    styles?: TreeSemanticStyles;
+}
+export interface TreeEmits {
+    'update:expandedKeys': [expandedKeys: Key[]];
+    'update:selectedKeys': [selectedKeys: Key[]];
+    /** always the list of checked keys, also with `checkStrictly` (same as PC) */
+    'update:checkedKeys': [checkedKeys: Key[]];
+    'expand': [expandedKeys: Key[], info: TreeExpandInfo];
+    'select': [selectedKeys: Key[], info: TreeSelectInfo];
+    'check': [checkedKeys: TreeCheckedKeys, info: TreeCheckInfo];
+    'load': [loadedKeys: Key[], info: TreeLoadInfo];
+    /** the content of a node was tapped */
+    'click': [event: MouseEvent, node: TreeEventDataNode];
+    'scroll': [event: Event];
+}
+export interface TreeSlots {
+    /** custom title, receives the node of `treeData` (mobile alias of `titleRender`) */
+    title?: (node: TreeDataNode) => any;
+    titleRender?: (node: TreeDataNode) => any;
+    icon?: (props: TreeNodeAttribute) => any;
+    switcherIcon?: (props: TreeNodeAttribute) => any;
+    switcherLoadingIcon?: () => any;
+}
+export interface TreeExpose {
+    /** scroll to a node (or to a scroll offset). Needs `height`. */
+    scrollTo: (target: number | TreeScrollToConfig) => void;
+    /** the scroll container */
+    nativeElement: HTMLElement | undefined;
+}