@web-utils/form-ui 1.0.0-beta57 → 1.0.0-beta59

package/e-charts/index.d.ts

@@ -0,0 +1,79 @@
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+    };
+    theme: {
+        type: (ObjectConstructor | StringConstructor)[];
+    };
+    initOptions: {
+        type: ObjectConstructor;
+    };
+    group: {
+        type: StringConstructor;
+    };
+    width: {
+        type: StringConstructor;
+        default: string;
+    };
+    height: {
+        type: StringConstructor;
+        default: string;
+    };
+    autoResize: BooleanConstructor;
+    watchShallow: BooleanConstructor;
+    manualUpdate: BooleanConstructor;
+}>, {}, {
+    lastArea: number;
+}, {}, {
+    mergeOptions(options: any, notMerge: any, lazyUpdate: any): void;
+    appendData(params: any): void;
+    resize(options: any): void;
+    dispatchAction(payload: any): void;
+    convertToPixel(finder: any, value: any): any;
+    convertFromPixel(finder: any, value: any): any;
+    containPixel(finder: any, value: any): any;
+    showLoading(type: any, options: any): void;
+    hideLoading(): void;
+    getDataURL(options: any): any;
+    getConnectedDataURL(options: any): any;
+    clear(): void;
+    dispose(): void;
+    delegateMethod(name: any, ...args: any[]): any;
+    delegateGet(methodName: any): any;
+    getArea(): number;
+    init(options: any): void;
+    initOptionsWatcher(): void;
+    destroy(): void;
+    refresh(): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+    };
+    theme: {
+        type: (ObjectConstructor | StringConstructor)[];
+    };
+    initOptions: {
+        type: ObjectConstructor;
+    };
+    group: {
+        type: StringConstructor;
+    };
+    width: {
+        type: StringConstructor;
+        default: string;
+    };
+    height: {
+        type: StringConstructor;
+        default: string;
+    };
+    autoResize: BooleanConstructor;
+    watchShallow: BooleanConstructor;
+    manualUpdate: BooleanConstructor;
+}>> & Readonly<{}>, {
+    width: string;
+    height: string;
+    autoResize: boolean;
+    watchShallow: boolean;
+    manualUpdate: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/e-charts/index.mjs

@@ -0,0 +1,179 @@
+import { s as e } from "../chunks/D-hj62se2.mjs";
+import { t } from "../chunks/BwYEpK-u.mjs";
+import { createElementBlock as n, normalizeStyle as r, openBlock as i } from "vue";
+import { isString as a } from "@web-utils/core";
+import { debounce as o } from "@web-utils/integrations/lodash";
+import * as s from "echarts/core";
+import { addListener as c, removeListener as l } from "resize-detector";
+//#region src/components/ECharts.vue
+var u = [
+	"theme",
+	"initOptions",
+	"autoResize"
+], d = ["manualUpdate", "watchShallow"], f = {
+	name: "ECharts",
+	props: {
+		options: { type: Object },
+		theme: { type: [String, Object] },
+		initOptions: { type: Object },
+		group: { type: String },
+		width: {
+			type: String,
+			default: "100%"
+		},
+		height: {
+			type: String,
+			default: "100%"
+		},
+		autoResize: Boolean,
+		watchShallow: Boolean,
+		manualUpdate: Boolean
+	},
+	data() {
+		return { lastArea: 0 };
+	},
+	watch: { group(e) {
+		this.chart.group = e;
+	} },
+	created() {
+		this.initOptionsWatcher(), u.forEach((e) => {
+			this.$watch(e, () => {
+				this.refresh();
+			}, { deep: !0 });
+		}), d.forEach((e) => {
+			this.$watch(e, () => {
+				this.initOptionsWatcher(), this.refresh();
+			});
+		});
+	},
+	mounted() {
+		this.options && this.init();
+	},
+	activated() {
+		if (this.autoResize) {
+			var e;
+			(e = this.chart) == null || e.resize();
+		}
+	},
+	unmounted() {
+		this.chart && this.destroy();
+	},
+	methods: {
+		mergeOptions(e, t, n) {
+			this.manualUpdate && (this.manualOptions = e), this.chart ? this.delegateMethod("setOption", e, t, n) : this.init(e);
+		},
+		appendData(e) {
+			this.delegateMethod("appendData", e);
+		},
+		resize(e) {
+			this.delegateMethod("resize", e);
+		},
+		dispatchAction(e) {
+			this.delegateMethod("dispatchAction", e);
+		},
+		convertToPixel(e, t) {
+			return this.delegateMethod("convertToPixel", e, t);
+		},
+		convertFromPixel(e, t) {
+			return this.delegateMethod("convertFromPixel", e, t);
+		},
+		containPixel(e, t) {
+			return this.delegateMethod("containPixel", e, t);
+		},
+		showLoading(e, t) {
+			this.delegateMethod("showLoading", e, t);
+		},
+		hideLoading() {
+			this.delegateMethod("hideLoading");
+		},
+		getDataURL(e) {
+			return this.delegateMethod("getDataURL", e);
+		},
+		getConnectedDataURL(e) {
+			return this.delegateMethod("getConnectedDataURL", e);
+		},
+		clear() {
+			this.delegateMethod("clear");
+		},
+		dispose() {
+			this.delegateMethod("dispose");
+		},
+		delegateMethod(e, ...t) {
+			return this.chart || this.init(), this.chart[e](...t);
+		},
+		delegateGet(e) {
+			return this.chart || this.init(), this.chart[e]();
+		},
+		getArea() {
+			return this.$el.offsetWidth * this.$el.offsetHeight;
+		},
+		init(t) {
+			if (this.chart) return;
+			let n = s.init(this.$el, this.theme, this.initOptions);
+			this.group && (n.group = this.group), n.setOption(t || this.manualOptions || this.options || {}, !0);
+			let r = e(this.$attrs);
+			Object.keys(r).forEach((e) => {
+				let t = r[e];
+				e.indexOf("zr:") === 0 ? n.getZr().on(e.slice(3), t) : n.on(e, t);
+			}), this.autoResize && (this.lastArea = this.getArea(), this.__resizeHandler = o(() => {
+				this.lastArea === 0 ? (this.mergeOptions({}, !0), this.resize(), this.mergeOptions(this.options || this.manualOptions || {}, !0)) : this.resize(), this.lastArea = this.getArea();
+			}, 100, { leading: !0 }), c(this.$el, this.__resizeHandler)), Object.defineProperties(this, {
+				width: {
+					configurable: !0,
+					get: () => this.delegateGet("getWidth")
+				},
+				height: {
+					configurable: !0,
+					get: () => this.delegateGet("getHeight")
+				},
+				isDisposed: {
+					configurable: !0,
+					get: () => !!this.delegateGet("isDisposed")
+				},
+				computedOptions: {
+					configurable: !0,
+					get: () => this.delegateGet("getOption")
+				}
+			}), this.chart = n;
+		},
+		initOptionsWatcher() {
+			this.__unwatchOptions && (this.__unwatchOptions(), this.__unwatchOptions = null), this.manualUpdate || (this.__unwatchOptions = this.$watch("options", (e, t) => {
+				!this.chart && e ? this.init() : this.chart.setOption(e, e !== t);
+			}, { deep: !this.watchShallow }));
+		},
+		destroy() {
+			this.autoResize && l(this.$el, this.__resizeHandler), this.dispose(), this.chart = null;
+		},
+		refresh() {
+			this.chart && (this.destroy(), this.init());
+		}
+	},
+	connect(e) {
+		a(e) || (e = e.map((e) => e.chart)), s.connect(e);
+	},
+	disconnect(e) {
+		s.disConnect(e);
+	},
+	getMap(e) {
+		return s.getMap(e);
+	},
+	registerMap(e, t, n) {
+		s.registerMap(e, t, n);
+	},
+	registerTheme(e, t) {
+		s.registerTheme(e, t);
+	},
+	graphic: s.graphic
+};
+function p(e, t, a, o, s, c) {
+	return i(), n("div", {
+		class: "echarts",
+		style: r({
+			width: a.width,
+			height: a.height
+		})
+	}, null, 4);
+}
+var m = /* @__PURE__ */ t(f, [["render", p]]);
+//#endregion
+export { m as default };

package/e-charts/style.css

@@ -0,0 +1 @@
+.echarts{width:100%;height:100%}

package/easy-popup/index.d.ts

@@ -0,0 +1,114 @@
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    /**
+     * 是否开启边界检测
+     */
+    border: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * 显示点偏移量
+     */
+    offset: {
+        type: ObjectConstructor;
+        default: () => {
+            x: number;
+            y: number;
+        };
+    };
+    /**
+     * 边界距离
+     */
+    borderWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * 是否添加到 body
+     */
+    appendToBody: BooleanConstructor;
+    flexRow: BooleanConstructor;
+    flexColumn: BooleanConstructor;
+    /**
+     * 鼠标离开后隐藏
+     */
+    hideOnMouseLeave: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    interactive: BooleanConstructor;
+}>, {}, {
+    /**
+     * 是否显示
+     */
+    visible: boolean;
+    rendered: boolean;
+    /**
+     * 触发点坐标
+     */
+    axis: {
+        x: number;
+        y: number;
+    };
+}, {
+    position(): {
+        top: string;
+        left: string;
+    };
+}, {
+    show({ clientX: x, clientY: y }: {
+        clientX: any;
+        clientY: any;
+    }): void;
+    hide(): void;
+    doHide(e: any): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    /**
+     * 是否开启边界检测
+     */
+    border: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * 显示点偏移量
+     */
+    offset: {
+        type: ObjectConstructor;
+        default: () => {
+            x: number;
+            y: number;
+        };
+    };
+    /**
+     * 边界距离
+     */
+    borderWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * 是否添加到 body
+     */
+    appendToBody: BooleanConstructor;
+    flexRow: BooleanConstructor;
+    flexColumn: BooleanConstructor;
+    /**
+     * 鼠标离开后隐藏
+     */
+    hideOnMouseLeave: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    interactive: BooleanConstructor;
+}>> & Readonly<{}>, {
+    offset: Record<string, any>;
+    appendToBody: boolean;
+    border: boolean;
+    borderWidth: number;
+    flexRow: boolean;
+    flexColumn: boolean;
+    interactive: boolean;
+    hideOnMouseLeave: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/easy-popup/index.mjs

@@ -0,0 +1,92 @@
+import { t as e } from "../chunks/BwYEpK-u.mjs";
+import { Transition as t, createBlock as n, createCommentVNode as r, createElementBlock as i, normalizeClass as a, normalizeStyle as o, openBlock as s, renderSlot as c, vShow as l, withCtx as u, withDirectives as d } from "vue";
+import { getComputedHeight as f, getComputedWidth as p } from "@web-utils/core";
+//#region src/components/EasyPopup.vue
+var m = {
+	name: "EasyPopup",
+	props: {
+		border: {
+			type: Boolean,
+			default: !0
+		},
+		offset: {
+			type: Object,
+			default: () => ({
+				x: 6,
+				y: 2
+			})
+		},
+		borderWidth: {
+			type: Number,
+			default: 6
+		},
+		appendToBody: Boolean,
+		flexRow: Boolean,
+		flexColumn: Boolean,
+		hideOnMouseLeave: {
+			type: Boolean,
+			default: !0
+		},
+		interactive: Boolean
+	},
+	data() {
+		return {
+			visible: !1,
+			rendered: !1,
+			axis: {
+				x: 0,
+				y: 0
+			}
+		};
+	},
+	computed: { position() {
+		return {
+			top: `${this.axis.y + this.offset.y}px`,
+			left: `${this.axis.x + this.offset.x}px`
+		};
+	} },
+	watch: { async axis() {
+		if (this.border) {
+			await this.$nextTick();
+			let e = p(this.$refs.container), t = f(this.$refs.container), n = document.body.offsetWidth, r = document.body.offsetHeight;
+			this.axis.x + this.offset.x + e >= n && (this.axis.x = n - e - this.borderWidth - this.offset.x), this.axis.y + this.offset.y + t >= r && (this.axis.y = r - t - this.borderWidth - this.offset.y);
+		}
+	} },
+	unmounted() {
+		this.$el.remove();
+	},
+	methods: {
+		show({ clientX: e, clientY: t }) {
+			this.axis = {
+				x: e,
+				y: t
+			}, this.visible || (document.addEventListener("click", this.doHide, !0), this.rendered = !0, this.visible = !0), this.appendToBody && document.body.appendChild(this.$el);
+		},
+		hide() {
+			this.visible = !1, document.removeEventListener("click", this.doHide);
+		},
+		doHide(e) {
+			this.interactive && this.$el.contains(e.target) || this.hide();
+		}
+	}
+};
+function h(e, f, p, m, h, g) {
+	return s(), n(t, { name: "easy-popup" }, {
+		default: u(() => [h.rendered ? d((s(), i("div", {
+			key: 0,
+			ref: "container",
+			class: a(["easy-popup", {
+				"easy-popup__visible": h.visible,
+				"easy-popup__hide": !h.visible,
+				"flex-row": p.flexRow,
+				"flex-column": p.flexColumn
+			}]),
+			style: o(g.position),
+			onMouseleave: f[0] || (f[0] = (e) => p.hideOnMouseLeave ? g.hide() : null)
+		}, [c(e.$slots, "default")], 38)), [[l, h.visible]]) : r("v-if", !0)]),
+		_: 3
+	});
+}
+var g = /* @__PURE__ */ e(m, [["render", h]]);
+//#endregion
+export { g as default };

package/easy-popup/style.css

@@ -0,0 +1 @@
+.easy-popup{z-index:9999;background:#fff;border:1px solid #ebeef5;border-radius:4px;width:300px;min-height:200px;padding:12px;position:fixed;box-shadow:0 2px 12px #0000001a}@keyframes easy-popup-zoom-in{0%{opacity:0;transform:scale3d(0,0,0)}to{opacity:1}}.easy-popup-enter-active,.easy-popup-enter{animation:.2s easy-popup-zoom-in}@keyframes easy-popup-zoom-out{0%{opacity:1}to{opacity:0;transform:scale3d(0,0,0)}}.easy-popup-leave-active,.easy-popup-leave{animation:.2s easy-popup-zoom-out}

package/editable-progress/index.d.ts

@@ -0,0 +1,68 @@
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    strokeWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    value: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {
+    slider: boolean;
+    mouseDown: boolean;
+    tooltipClass: string;
+    percent: number;
+}, {}, {
+    formatTooltip(val: any): string;
+    onInput(percent: any): void;
+    onChange(percent: any): void;
+    onMouseOver(): void;
+    onMouseDown(): void;
+    onMouseUp(): void;
+    onMouseLeave(): void;
+    wrapperClick(): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("update:modelValue" | "change" | "input")[], "update:modelValue" | "change" | "input", import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    strokeWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    value: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onChange?: ((...args: any[]) => any) | undefined;
+    onInput?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    value: number;
+    strokeWidth: number;
+    step: number;
+    max: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/editable-progress/index.mjs

@@ -0,0 +1,120 @@
+import "../chunks/CjjJimnU.mjs";
+import { t as e } from "../chunks/cMuWbLPt.mjs";
+import { t } from "../chunks/DsYXqJLZ.mjs";
+import { t as n } from "../chunks/BwYEpK-u.mjs";
+import { createBlock as r, createCommentVNode as i, createElementBlock as a, createVNode as o, normalizeClass as s, normalizeStyle as c, openBlock as l, vShow as u, withDirectives as d } from "vue";
+//#region src/components/EditableProgress.vue
+var f = {
+	name: "EditableProgress",
+	props: {
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		strokeWidth: {
+			type: Number,
+			default: 22
+		},
+		step: {
+			type: Number,
+			default: 10
+		},
+		max: {
+			type: Number,
+			default: 100
+		},
+		value: {
+			type: Number,
+			default: 0
+		}
+	},
+	emits: [
+		"input",
+		"change",
+		"update:modelValue"
+	],
+	data() {
+		return {
+			slider: !1,
+			mouseDown: !1,
+			tooltipClass: "hide-tooltip",
+			percent: this.value
+		};
+	},
+	watch: { value(e) {
+		this.percent !== e && (this.percent = e);
+	} },
+	methods: {
+		formatTooltip(e) {
+			return `${e}%`;
+		},
+		onInput(e) {
+			this.value !== e && this.$emit("update:modelValue", e);
+		},
+		onChange(e) {
+			this.slider = !1, this.tooltipClass = "hide-tooltip", this.$emit("change", e);
+		},
+		onMouseOver() {
+			this.disabled || this.slider || (this.slider = !0, this.$nextTick(() => {
+				this.$refs.slider.$refs.button1.$refs.tooltip.updatePopper(), this.tooltipClass = "";
+			}));
+		},
+		onMouseDown() {
+			this.disabled || (this.mouseDown = !0, window.addEventListener("mouseup", this.onMouseUp));
+		},
+		onMouseUp() {
+			this.disabled || (this.mouseDown = !1, this.tooltipClass = "hide-tooltip", window.removeEventListener("mouseup", this.onMouseUp));
+		},
+		onMouseLeave() {
+			this.disabled || this.mouseDown || (this.tooltipClass = "hide-tooltip", this.slider = !1);
+		},
+		wrapperClick() {
+			this.disabled || (this.slider = !0);
+		}
+	}
+};
+function p(n, f, p, m, h, g) {
+	let _ = e, v = t;
+	return l(), a("div", {
+		class: "editable-progress",
+		onMouseover: f[1] || (f[1] = (...e) => g.onMouseOver && g.onMouseOver(...e)),
+		onMousedown: f[2] || (f[2] = (...e) => g.onMouseDown && g.onMouseDown(...e)),
+		onMouseleave: f[3] || (f[3] = (...e) => g.onMouseLeave && g.onMouseLeave(...e)),
+		onClick: f[4] || (f[4] = (...e) => g.wrapperClick && g.wrapperClick(...e))
+	}, [d(o(_, {
+		class: s(h.percent === 100 ? "progress__success" : ""),
+		"stroke-width": p.strokeWidth,
+		"text-inside": "",
+		percentage: h.percent
+	}, null, 8, [
+		"class",
+		"stroke-width",
+		"percentage"
+	]), [[u, !h.slider]]), p.disabled ? i("v-if", !0) : d((l(), r(v, {
+		key: 0,
+		ref: "slider",
+		modelValue: h.percent,
+		"onUpdate:modelValue": f[0] || (f[0] = (e) => h.percent = e),
+		"tooltip-class": h.tooltipClass,
+		max: p.max,
+		"format-tooltip": g.formatTooltip,
+		style: c({ width: `${p.max === 100 ? 100 : p.max - 1}%` }),
+		disabled: p.disabled,
+		step: p.step,
+		onInput: g.onInput,
+		onChange: g.onChange
+	}, null, 8, [
+		"modelValue",
+		"tooltip-class",
+		"max",
+		"format-tooltip",
+		"style",
+		"disabled",
+		"step",
+		"onInput",
+		"onChange"
+	])), [[u, h.slider]])], 32);
+}
+var m = /* @__PURE__ */ n(f, [["render", p]]);
+//#endregion
+export { m as default };

package/editable-progress/style.css

@@ -0,0 +1 @@
+.editable-progress{background-color:#e4e7ed;border-radius:100px;flex-direction:column;justify-content:center;align-items:flex-start;width:100%;display:flex}.editable-progress .el-progress,.editable-progress .el-slider{width:100%;font-weight:700}.editable-progress .el-slider__runway{margin:0}.editable-progress .el-progress-bar__outer{background-color:#e4e7ed}.editable-progress .el-slider__bar,.editable-progress .el-slider__runway{border-radius:100px;height:22px}.editable-progress .el-slider__button-wrapper{width:52px;height:52px}.editable-progress .el-slider__button-wrapper .el-slider__button{width:24px;height:24px}

package/editable-tree/index.d.ts

@@ -260,8 +260,8 @@ declare const _default: import('vue').DefineComponent<globalThis.ExtractPropType
     "onAdd-root-node"?: ((...args: any[]) => any) | undefined;
     "onCreate-new-node"?: ((...args: any[]) => any) | undefined;
 }>, {
-    icon: boolean | Function;
     label: string;
+    icon: boolean | Function;
     defaultExpandedKeys: unknown[];
     newNodeBuilder: Function;
     contextMenu: boolean;