@web-utils/form-ui 1.0.0-beta85 → 1.0.0-beta87

package/fy-input-tree/index.d.ts

@@ -0,0 +1,351 @@
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    nodeClick: FunctionConstructor;
+    treeLoad: FunctionConstructor;
+    checked: FunctionConstructor;
+    lazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    leafOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tags: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    limit: {
+        type: NumberConstructor;
+        default: number;
+    };
+    expandOnClickNode: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    filter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    filterText: {
+        type: StringConstructor;
+        default: string;
+    };
+    checkStrictly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    accordion: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    parent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    iconClass: StringConstructor;
+    defaultExpandedKeys: ArrayConstructor;
+    defaultExpandAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    popperAppendToBody: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {
+    node: never[];
+    filterValue: string;
+    dicList: never[];
+}, {
+    treeProps(): any;
+    currentNodeKey(): "" | undefined;
+    keysList(): string[] | undefined;
+    labelShow(): any[];
+}, {
+    handleClear(): void;
+    handleTreeLoad(node: any, resolve: any): void;
+    filterNode(value: any, data: any): boolean;
+    checkChange(checkedNodes: any, checkedKeys: any, halfCheckedNodes: any, halfCheckedKeys: any): void;
+    getHalfList(): any;
+    init(): void;
+    disabledParentNode(dic: any, parent: any): void;
+    handleNodeClick(data: any, node: any, nodeComp: any): void;
+}, {
+    mixins: {
+        methods: {
+            getSlotName(item: any | undefined, type: string | undefined, slot: string): any;
+            getSlotList(list: never[] | undefined, slot: string, propList: Array<any>): string[];
+        };
+    }[];
+    data(): {
+        stringMode: boolean;
+        name: string;
+        text: undefined;
+        propsHttpDefault: {
+            name: string;
+            url: string;
+            fileName: string;
+            res: string;
+        };
+        propsDefault: {
+            rowKey: string;
+            rowParentKey: string;
+            nodeKey: string;
+            label: string;
+            value: string;
+            desc: string;
+            groups: string;
+            title: string;
+            leaf: string;
+            children: string;
+            hasChildren: string;
+            labelText: string;
+            disabled: string;
+        };
+    };
+    props: {
+        blur: FunctionConstructor;
+        focus: FunctionConstructor;
+        change: FunctionConstructor;
+        click: FunctionConstructor;
+        typeformat: FunctionConstructor;
+        control: FunctionConstructor;
+        separator: {
+            type: StringConstructor;
+            default: string;
+        };
+        params: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        listType: {
+            type: StringConstructor;
+        };
+        tableData: {
+            type: ObjectConstructor;
+        };
+        modelValue: {};
+        column: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        label: {
+            type: StringConstructor;
+            default: string;
+        };
+        readonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        size: StringConstructor;
+        tip: {
+            type: StringConstructor;
+            default: string;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        dataType: {
+            type: StringConstructor;
+        };
+        clearable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        type: {
+            type: StringConstructor;
+            default: string;
+        };
+        dicUrl: {
+            type: StringConstructor;
+            default: string;
+        };
+        dicMethod: {
+            type: StringConstructor;
+            default: string;
+        };
+        dicFormatter: FunctionConstructor;
+        dicQuery: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        dic: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        placeholder: {
+            type: StringConstructor;
+            default: string;
+        };
+        rules: {
+            type: ArrayConstructor;
+        };
+        min: {
+            type: NumberConstructor;
+        };
+        max: {
+            type: NumberConstructor;
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        button: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        group: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        row: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        prop: {
+            type: StringConstructor;
+            default: string;
+        };
+        border: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        popperClass: {
+            type: StringConstructor;
+        };
+        propsHttp: {
+            type: ObjectConstructor;
+            default: () => {
+                name: string;
+                url: string;
+                fileName: string;
+                res: string;
+            };
+        };
+        props: {
+            type: ObjectConstructor;
+            default: () => {
+                rowKey: string;
+                rowParentKey: string;
+                nodeKey: string;
+                label: string;
+                value: string;
+                desc: string;
+                groups: string;
+                title: string;
+                leaf: string;
+                children: string;
+                hasChildren: string;
+                labelText: string;
+                disabled: string;
+            };
+        };
+    };
+    watch: {
+        text: {
+            handler(this: any, n: any): void;
+        };
+        modelValue: {
+            handler(this: any): void;
+        };
+    };
+    computed: {
+        clearableVal(this: any): any;
+        componentName(this: any): string;
+        required(this: any): boolean;
+        isArray(this: any): boolean;
+        isString(this: any): boolean;
+        isNumber(this: any): boolean;
+        nameKey(this: any): any;
+        urlKey(this: any): any;
+        resKey(this: any): any;
+        groupsKey(this: any): any;
+        valueKey(this: any): any;
+        descKey(this: any): any;
+        leafKey(this: any): any;
+        labelKey(this: any): any;
+        childrenKey(this: any): any;
+        disabledKey(this: any): any;
+        idKey(this: any): any;
+    };
+    created(this: any): void;
+} | {
+    methods: {
+        bindEvent(this: any, name: any, params: any): void;
+        initVal(this: any): void;
+        getLabelText(this: any, item: any): any;
+        handleFocus(this: any, event: any): void;
+        handleBlur(this: any, event: any): void;
+        handleClick(this: any, event: any): void;
+        handleChange(this: any, value: any): void;
+    };
+}, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    nodeClick: FunctionConstructor;
+    treeLoad: FunctionConstructor;
+    checked: FunctionConstructor;
+    lazy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    leafOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tags: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    limit: {
+        type: NumberConstructor;
+        default: number;
+    };
+    expandOnClickNode: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    filter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    filterText: {
+        type: StringConstructor;
+        default: string;
+    };
+    checkStrictly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    accordion: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    parent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    iconClass: StringConstructor;
+    defaultExpandedKeys: ArrayConstructor;
+    defaultExpandAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    popperAppendToBody: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    filter: boolean;
+    parent: boolean;
+    lazy: boolean;
+    defaultExpandAll: boolean;
+    popperAppendToBody: boolean;
+    checkStrictly: boolean;
+    limit: number;
+    tags: boolean;
+    filterText: string;
+    leafOnly: boolean;
+    expandOnClickNode: boolean;
+    accordion: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/fy-input-tree/index.mjs

@@ -0,0 +1,266 @@
+import "../chunks/B2vpUK0j.mjs";
+import "../chunks/cvUTkWmm.mjs";
+import { r as e, t } from "../chunks/kN7dSjtl.mjs";
+import { t as n } from "../chunks/DA1LVvTS.mjs";
+import { t as r } from "../chunks/C1rRv4L7.mjs";
+import "../chunks/CNcSX5f1.mjs";
+import { t as i } from "../chunks/hFCEXdXW.mjs";
+import { n as a, t as o } from "../chunks/BsBVCVnp2.mjs";
+import { createBlock as s, createCommentVNode as c, createElementBlock as l, createElementVNode as u, createVNode as d, normalizeClass as f, openBlock as p, renderSlot as m, toDisplayString as h, withCtx as g, withModifiers as _ } from "vue";
+import { isBlank as v } from "@web-utils/core";
+//#region src/components/avue/fy-from/input-tree/FyInputTree.vue
+var y = {
+	name: "FyInputTree",
+	mixins: [a, o],
+	props: {
+		nodeClick: Function,
+		treeLoad: Function,
+		checked: Function,
+		lazy: {
+			type: Boolean,
+			default: !1
+		},
+		leafOnly: {
+			type: Boolean,
+			default: !1
+		},
+		tags: {
+			type: Boolean,
+			default: !1
+		},
+		limit: {
+			type: Number,
+			default: 0
+		},
+		expandOnClickNode: {
+			type: Boolean,
+			default: !0
+		},
+		filter: {
+			type: Boolean,
+			default: !0
+		},
+		filterText: {
+			type: String,
+			default: ""
+		},
+		checkStrictly: {
+			type: Boolean,
+			default: !1
+		},
+		accordion: {
+			type: Boolean,
+			default: !1
+		},
+		parent: {
+			type: Boolean,
+			default: !0
+		},
+		iconClass: String,
+		defaultExpandedKeys: Array,
+		defaultExpandAll: {
+			type: Boolean,
+			default: !1
+		},
+		popperAppendToBody: {
+			type: Boolean,
+			default: !0
+		}
+	},
+	data() {
+		return {
+			node: [],
+			filterValue: "",
+			dicList: []
+		};
+	},
+	computed: {
+		treeProps() {
+			let e = { ...this.props };
+			return e.isLeaf || (e.isLeaf = this.leafKey), e;
+		},
+		currentNodeKey() {
+			return this.multiple ? "" : this.text;
+		},
+		keysList() {
+			return this.multiple ? this.text : [this.text || ""];
+		},
+		labelShow() {
+			return [...this.node].map((e) => this.getLabelText(e));
+		}
+	},
+	watch: {
+		text() {
+			this.init();
+		},
+		dic: {
+			handler(e) {
+				this.dicList = e;
+			},
+			immediate: !0
+		},
+		dicList: {
+			handler() {
+				this.init();
+			},
+			immediate: !0
+		},
+		filterValue(e) {
+			this.$refs.tree.filter(e);
+		}
+	},
+	methods: {
+		handleClear() {
+			this.text = this.multiple ? [] : "", this.node = [], this.filterValue = "", this.$refs.tree.setCurrentKey(null), this.$refs.tree.setCheckedKeys([]);
+		},
+		handleTreeLoad(e, t) {
+			var n;
+			(n = this.treeLoad) == null || n.call(this, e, (n) => {
+				let r = (e, t, n) => {
+					e.forEach((e) => {
+						e[this.valueKey] === t ? e[this.childrenKey] = n : e[this.childrenKey] && r(e[this.childrenKey]);
+					});
+				};
+				r(this.dicList, e.key, n), t(n);
+			});
+		},
+		filterNode(e, t) {
+			return e ? t[this.labelKey].toLowerCase().indexOf(e.toLowerCase()) !== -1 : !0;
+		},
+		checkChange(e, t, n, r) {
+			this.text.splice(0, this.text.length), this.$refs.tree.getCheckedNodes(this.leafOnly, !1).forEach((e) => this.text.push(e[this.valueKey])), typeof this.checked == "function" && this.checked(e, t, n, r);
+		},
+		getHalfList() {
+			let e = this.$refs.tree.getCheckedNodes(!1, !0);
+			return e = e.map((e) => e[this.valueKey]), e;
+		},
+		init() {
+			this.$nextTick(() => {
+				if (this.node = [], this.multiple) this.$refs.tree.getCheckedNodes(this.leafOnly, !1).forEach((e) => {
+					this.node.push(e);
+				});
+				else {
+					let e = this.$refs.tree.getNode(this.text);
+					if (e) {
+						let t = e.data;
+						this.$refs.tree.setCurrentKey(t[this.valueKey]), this.node.push(t);
+					}
+				}
+			}), this.disabledParentNode(this.dic, this.parent);
+		},
+		disabledParentNode(e, t) {
+			e.forEach((e) => {
+				let n = e[this.childrenKey];
+				v(n) || (t || (e.disabled = !0), this.disabledParentNode(n, t));
+			});
+		},
+		handleNodeClick(e, t, n) {
+			e.disabled || (typeof this.nodeClick == "function" && this.nodeClick(e, t, n), !this.multiple && (v(e[this.childrenKey]) && !this.multiple || this.parent) && (this.text = e[this.valueKey], this.$refs.main.blur()));
+		}
+	}
+}, b = {
+	key: 0,
+	class: "avue-input-tree__filter"
+}, x = { class: "avue-input-tree__item" }, S = {
+	key: 0,
+	class: "avue-input-tree__desc"
+};
+function C(i, a, o, v, y, C) {
+	let w = n, T = r, E = t, D = e;
+	return p(), s(D, {
+		ref: "main",
+		class: "avue-input-tree",
+		size: i.size,
+		multiple: i.multiple,
+		"multiple-limit": o.limit,
+		"collapse-tags": o.tags,
+		"model-value": C.labelShow,
+		clearable: i.clearableVal,
+		placeholder: i.placeholder,
+		"popper-class": i.popperClass,
+		"popper-append-to-body": o.popperAppendToBody,
+		disabled: i.disabled,
+		onClick: i.handleClick,
+		onFocus: i.handleFocus,
+		onBlur: i.handleBlur,
+		onClear: C.handleClear
+	}, {
+		default: g(() => [o.filter ? (p(), l("div", b, [d(w, {
+			modelValue: y.filterValue,
+			"onUpdate:modelValue": a[0] || (a[0] = (e) => y.filterValue = e),
+			placeholder: o.filterText
+		}, null, 8, ["modelValue", "placeholder"])])) : c("v-if", !0), d(E, {
+			value: i.text,
+			class: "avue-input-tree__dropdown"
+		}, {
+			default: g(() => [d(T, {
+				ref: "tree",
+				data: y.dicList,
+				class: "avue-input-tree__select",
+				lazy: o.lazy,
+				load: C.handleTreeLoad,
+				"node-key": i.valueKey,
+				accordion: o.accordion,
+				"icon-class": o.iconClass,
+				"show-checkbox": i.multiple,
+				"expand-on-click-node": o.expandOnClickNode,
+				props: C.treeProps,
+				"check-strictly": o.checkStrictly,
+				"highlight-current": i.multiple !== !0,
+				"current-node-key": C.currentNodeKey,
+				"filter-node-method": C.filterNode,
+				"default-checked-keys": C.keysList,
+				"default-expanded-keys": o.defaultExpandedKeys ? o.defaultExpandedKeys : C.keysList,
+				"default-expand-all": o.defaultExpandAll,
+				onCheck: C.checkChange,
+				onNodeClick: _(C.handleNodeClick, ["self"])
+			}, {
+				default: g(({ data: e }) => [u("div", x, [m(i.$slots, "default", {
+					label: i.labelKey,
+					value: i.valueKey,
+					item: e
+				}, () => [u("span", { class: f({ "avue--disabled": e[i.disabledKey] }) }, h(e[i.labelKey]), 3), e[i.descKey] ? (p(), l("span", S, h(e[i.descKey]), 1)) : c("v-if", !0)])])]),
+				_: 3
+			}, 8, [
+				"data",
+				"lazy",
+				"load",
+				"node-key",
+				"accordion",
+				"icon-class",
+				"show-checkbox",
+				"expand-on-click-node",
+				"props",
+				"check-strictly",
+				"highlight-current",
+				"current-node-key",
+				"filter-node-method",
+				"default-checked-keys",
+				"default-expanded-keys",
+				"default-expand-all",
+				"onCheck",
+				"onNodeClick"
+			])]),
+			_: 3
+		}, 8, ["value"])]),
+		_: 3
+	}, 8, [
+		"size",
+		"multiple",
+		"multiple-limit",
+		"collapse-tags",
+		"model-value",
+		"clearable",
+		"placeholder",
+		"popper-class",
+		"popper-append-to-body",
+		"disabled",
+		"onClick",
+		"onFocus",
+		"onBlur",
+		"onClear"
+	]);
+}
+var w = /* @__PURE__ */ i(y, [["render", C]]);
+//#endregion
+export { w as default };

package/fy-input-tree/style.css

@@ -0,0 +1 @@
+.avue-input-tree .el-tag__close{display:none!important}.avue-input-tree__dropdown{background-color:#fff;min-height:300px;max-height:600px;padding:0 10px;overflow:visible}.avue-input-tree__dropdown:hover,.avue-input-tree__dropdown.hover{background-color:#fff}.avue-input-tree__item{width:100%;display:inline-block}.avue-input-tree__filter{margin:5px 0 0;padding:0 10px}.avue-input-tree__select{padding:10px 0}.avue-input-tree__desc{float:right;color:#8492a6;margin-right:12px;font-size:13px}