vft 0.0.523 → 0.0.525

package/es/components/input/input.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,541 @@
+import { debugWarn } from "../../utils/error.js";
+import { useNamespace } from "../../hooks/use-namespace/index.js";
+import { VftIcon } from "../icon/index.js";
+import { useFormDisabled, useFormSize } from "../form/hooks/use-form-common-props.js";
+import { useFormItem, useFormItemInputId } from "../form/hooks/use-form-item.js";
+import { calcTextareaHeight } from "./utils.js";
+import { isObject, isString, noop, singleAttrToObj } from "@vft/utils";
+import { isClient as isClient$1, useResizeObserver } from "@vueuse/core";
+import { isNil } from "lodash-es";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, defineComponent, getCurrentInstance, mergeProps, nextTick, normalizeClass, normalizeStyle, onMounted, openBlock, ref, renderSlot, shallowRef, toDisplayString, unref, useAttrs, useSlots, vShow, watch, withDirectives, withKeys, withModifiers } from "vue";
+import { useAttrs as useAttrs$1, useCursor } from "@vft/use";
+import { UPDATE_MODEL_EVENT } from "@vft/constants";
+//#region ../../packages/components/input/input.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = ["role"];
+const _hoisted_2 = [
+	"id",
+	"type",
+	"disabled",
+	"formatter",
+	"parser",
+	"readonly",
+	"autocomplete",
+	"tabindex",
+	"aria-label",
+	"placeholder",
+	"form"
+];
+const _hoisted_3 = [
+	"id",
+	"tabindex",
+	"disabled",
+	"readonly",
+	"autocomplete",
+	"aria-label",
+	"placeholder",
+	"form"
+];
+var input_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "input",
+	props: {
+		id: {
+			type: String,
+			required: false
+		},
+		size: {
+			type: String,
+			required: false,
+			default: ""
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		modelValue: {
+			type: [String, Number],
+			required: false
+		},
+		type: {
+			type: String,
+			required: false,
+			default: "text"
+		},
+		resize: {
+			type: String,
+			required: false
+		},
+		autosize: {
+			type: [Object, Boolean],
+			required: false,
+			default: false
+		},
+		autocomplete: {
+			type: String,
+			required: false,
+			default: "off"
+		},
+		formatter: {
+			type: Function,
+			required: false
+		},
+		parser: {
+			type: Function,
+			required: false
+		},
+		placeholder: {
+			type: String,
+			required: false
+		},
+		form: {
+			type: String,
+			required: false
+		},
+		readonly: {
+			type: Boolean,
+			required: false
+		},
+		clearable: {
+			type: Boolean,
+			required: false
+		},
+		showPassword: {
+			type: Boolean,
+			required: false
+		},
+		showWordLimit: {
+			type: Boolean,
+			required: false
+		},
+		suffixIcon: {
+			type: [String, Object],
+			required: false
+		},
+		prefixIcon: {
+			type: [Object, String],
+			required: false
+		},
+		clearIcon: {
+			type: [Object, String],
+			required: false
+		},
+		containerRole: {
+			type: String,
+			required: false
+		},
+		label: {
+			type: String,
+			required: false
+		},
+		tabindex: {
+			type: [String, Number],
+			required: false,
+			default: 0
+		},
+		validateEvent: {
+			type: Boolean,
+			required: false,
+			default: true
+		},
+		inputStyle: {
+			type: [
+				Boolean,
+				null,
+				String,
+				Object,
+				Array
+			],
+			required: false,
+			skipCheck: true
+		}
+	},
+	emits: {
+		[UPDATE_MODEL_EVENT]: (value) => isString(value),
+		input: (value) => isString(value),
+		change: (value) => isString(value),
+		suffixClick: (value) => isString(value),
+		prefixClick: (value) => isString(value),
+		focus: (evt) => evt instanceof FocusEvent,
+		blur: (evt) => evt instanceof FocusEvent,
+		clear: () => true,
+		enter: () => true,
+		mouseleave: (evt) => evt instanceof MouseEvent,
+		mouseenter: (evt) => evt instanceof MouseEvent,
+		keydown: (evt) => evt instanceof Event,
+		compositionstart: (evt) => evt instanceof CompositionEvent,
+		compositionupdate: (evt) => evt instanceof CompositionEvent,
+		compositionend: (evt) => evt instanceof CompositionEvent,
+		passwordVisibleChange: (visible) => typeof visible === "boolean"
+	},
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const emit = __emit;
+		const rawAttrs = useAttrs();
+		const slots = useSlots();
+		const containerAttrs = computed(() => {
+			const comboBoxAttrs = {};
+			if (__props.containerRole === "combobox") {
+				comboBoxAttrs["aria-haspopup"] = rawAttrs["aria-haspopup"];
+				comboBoxAttrs["aria-owns"] = rawAttrs["aria-owns"];
+				comboBoxAttrs["aria-expanded"] = rawAttrs["aria-expanded"];
+			}
+			return comboBoxAttrs;
+		});
+		const containerKls = computed(() => [
+			__props.type === "textarea" ? nsTextarea.b() : nsInput.b(),
+			nsInput.m(inputSize.value),
+			nsInput.is("disabled", inputDisabled.value),
+			nsInput.is("exceed", inputExceed.value),
+			nsInput.is("focus", focused.value),
+			{
+				[nsInput.b("group")]: slots.prepend || slots.append,
+				[nsInput.bm("group", "append")]: slots.append,
+				[nsInput.bm("group", "prepend")]: slots.prepend,
+				[nsInput.m("prefix")]: slots.prefix || __props.prefixIcon,
+				[nsInput.m("suffix")]: slots.suffix || __props.suffixIcon || __props.clearable || __props.showPassword,
+				[nsInput.bm("suffix", "password-clear")]: showClear.value && showPwdVisible.value
+			},
+			rawAttrs.class
+		]);
+		const instance = getCurrentInstance();
+		const wrapperKls = computed(() => [nsInput.e("wrapper"), nsInput.is("focus", focused.value)]);
+		const attrs = useAttrs$1({ excludeKeys: computed(() => {
+			return Object.keys(containerAttrs.value);
+		}) });
+		const { form: _form, formItem } = useFormItem();
+		const { inputId } = useFormItemInputId(instance.props, { formItemContext: formItem });
+		const inputSize = useFormSize();
+		const inputDisabled = useFormDisabled();
+		const nsInput = useNamespace("input");
+		const nsTextarea = useNamespace("textarea");
+		const input = shallowRef();
+		const textarea = shallowRef();
+		const focused = ref(false);
+		const hovering = ref(false);
+		const isComposing = ref(false);
+		const passwordVisible = ref(false);
+		const countStyle = ref();
+		const textareaCalcStyle = shallowRef(__props.inputStyle);
+		const _ref = computed(() => input.value || textarea.value);
+		const _prefixIcon = computed(() => {
+			return singleAttrToObj(__props.prefixIcon, "icon", { size: 16 });
+		});
+		const _suffixIcon = computed(() => {
+			return singleAttrToObj(__props.suffixIcon, "icon", { size: 16 });
+		});
+		const _clearIcon = computed(() => {
+			return singleAttrToObj(__props.clearIcon, "icon", {
+				icon: "icon-circle-close",
+				size: 16
+			});
+		});
+		const needStatusIcon = computed(() => _form?.statusIcon ?? false);
+		const validateState = computed(() => formItem?.validateState || "");
+		const validateIcon = computed(() => validateState.value && {
+			validating: "icon-loading",
+			success: "icon-circle-check",
+			error: "icon-circle-close"
+		}[validateState.value]);
+		const passwordIcon = computed(() => passwordVisible.value ? {
+			icon: "icon-view",
+			size: 16
+		} : {
+			icon: "icon-hide",
+			size: 16
+		});
+		const containerStyle = computed(() => [rawAttrs.style, __props.inputStyle]);
+		const textareaStyle = computed(() => [
+			__props.inputStyle,
+			textareaCalcStyle.value,
+			{ resize: __props.resize }
+		]);
+		const nativeInputValue = computed(() => isNil(__props.modelValue) ? "" : String(__props.modelValue));
+		const showClear = computed(() => __props.clearable && !inputDisabled.value && !__props.readonly && !!nativeInputValue.value && (focused.value || hovering.value));
+		const showPwdVisible = computed(() => __props.showPassword && !inputDisabled.value && !__props.readonly && !!nativeInputValue.value && (!!nativeInputValue.value || focused.value));
+		const isWordLimitVisible = computed(() => __props.showWordLimit && !!attrs.value.maxlength && (__props.type === "text" || __props.type === "textarea") && !inputDisabled.value && !__props.readonly && !__props.showPassword);
+		const textLength = computed(() => Array.from(nativeInputValue.value).length);
+		const inputExceed = computed(() => !!isWordLimitVisible.value && textLength.value > Number(attrs.value.maxlength));
+		const suffixVisible = computed(() => !!slots.suffix || !!__props.suffixIcon || showClear.value || __props.showPassword || isWordLimitVisible.value || !!validateState.value && needStatusIcon.value);
+		const [recordCursor, setCursor] = useCursor(input);
+		useResizeObserver(textarea, (entries) => {
+			if (!isWordLimitVisible.value || __props.resize !== "both") return;
+			const { width } = entries[0].contentRect;
+			countStyle.value = { 
+			/** right: 100% - width + padding(15) + right(6) */
+right: `calc(100% - ${width + 15 + 6}px)` };
+		});
+		const resizeTextarea = () => {
+			if (!isClient$1 || __props.type !== "textarea") return;
+			if (__props.autosize) {
+				const minRows = isObject(__props.autosize) ? __props.autosize.minRows : void 0;
+				const maxRows = isObject(__props.autosize) ? __props.autosize.maxRows : void 0;
+				textareaCalcStyle.value = { ...calcTextareaHeight(textarea.value, minRows, maxRows) };
+			} else textareaCalcStyle.value = { minHeight: calcTextareaHeight(textarea.value).minHeight };
+		};
+		const setNativeInputValue = () => {
+			const input = _ref.value;
+			if (!input || input.value === nativeInputValue.value) return;
+			input.value = nativeInputValue.value;
+		};
+		const handleInput = async (event) => {
+			recordCursor();
+			let { value } = event.target;
+			if (attrs.value.maxlength && value.length >= attrs.value.maxlength) value = value.slice(0, Number(attrs.value.maxlength));
+			if (__props.formatter) {
+				value = __props.parser ? __props.parser(value) : value;
+				value = __props.formatter(value);
+			}
+			if (isComposing.value) return;
+			if (value === nativeInputValue.value) {
+				setNativeInputValue();
+				return;
+			}
+			emit(UPDATE_MODEL_EVENT, value);
+			emit("input", value);
+			await nextTick();
+			setNativeInputValue();
+			setCursor();
+		};
+		const handleChange = (event) => {
+			emit("change", event.target.value);
+		};
+		const handleSuffixClick = () => {
+			emit("suffixClick", __props.modelValue);
+		};
+		const handlePrefixClick = () => {
+			emit("prefixClick", __props.modelValue);
+		};
+		const handleCompositionStart = (event) => {
+			emit("compositionstart", event);
+			isComposing.value = true;
+		};
+		const isKorean = (text) => /([(\uAC00-\uD7AF)|\u3130-\u318F])+/.test(text);
+		const handleCompositionUpdate = (event) => {
+			emit("compositionupdate", event);
+			const text = event.target?.value;
+			const lastCharacter = text[text.length - 1] || "";
+			isComposing.value = !isKorean(lastCharacter);
+		};
+		const handleCompositionEnd = (event) => {
+			emit("compositionend", event);
+			if (isComposing.value) {
+				isComposing.value = false;
+				handleInput(event);
+			}
+		};
+		const handlePasswordVisible = () => {
+			passwordVisible.value = !passwordVisible.value;
+			emit("passwordVisibleChange", passwordVisible.value);
+			focus();
+		};
+		const focus = async () => {
+			await nextTick();
+			_ref.value?.focus();
+		};
+		const blur = () => _ref.value?.blur();
+		const handleFocus = (event) => {
+			focused.value = true;
+			emit("focus", event);
+		};
+		const handleBlur = (event) => {
+			focused.value = false;
+			emit("blur", event);
+			if (__props.validateEvent) formItem?.validate?.("blur").catch((err) => debugWarn(err));
+		};
+		const handleMouseLeave = (evt) => {
+			hovering.value = false;
+			emit("mouseleave", evt);
+		};
+		const handleMouseEnter = (evt) => {
+			hovering.value = true;
+			emit("mouseenter", evt);
+		};
+		const handleKeydown = (evt) => {
+			const key = evt.key;
+			if (evt.target.type === "number") {
+				if ([
+					"e",
+					"+",
+					"-0",
+					"E"
+				].includes(key)) {
+					evt.returnValue = false;
+					return false;
+				}
+			}
+			emit("keydown", evt);
+		};
+		const select = () => {
+			_ref.value?.select();
+		};
+		const clear = () => {
+			emit(UPDATE_MODEL_EVENT, "");
+			emit("change", "");
+			emit("clear");
+			emit("input", "");
+		};
+		watch(() => __props.modelValue, () => {
+			nextTick(() => resizeTextarea());
+			if (__props.validateEvent) formItem?.validate?.("change").catch((err) => debugWarn(err));
+		});
+		watch(nativeInputValue, () => setNativeInputValue());
+		watch(() => __props.type, async () => {
+			await nextTick();
+			setNativeInputValue();
+			resizeTextarea();
+		});
+		onMounted(() => {
+			if (!__props.formatter && __props.parser) debugWarn("VftInput", "If you set the parser, you also need to set the formatter.");
+			setNativeInputValue();
+			nextTick(resizeTextarea);
+		});
+		__expose({
+			/** @description HTML input element */
+			input,
+			/** @description HTML textarea element */
+			textarea,
+			/** @description HTML element, input or textarea */
+			ref: _ref,
+			/** @description style of textarea. */
+			textareaStyle,
+			/** @description from props (used on unit test) */
+			autosize: __props.autosize,
+			/** @description HTML input element native method */
+			focus,
+			/** @description HTML input element native method */
+			blur,
+			/** @description HTML input element native method */
+			select,
+			/** @description clear input value */
+			clear,
+			/** @description resize textarea. */
+			resizeTextarea
+		});
+		return (_ctx, _cache) => {
+			return withDirectives((openBlock(), createElementBlock("div", mergeProps(containerAttrs.value, {
+				class: containerKls.value,
+				style: containerStyle.value,
+				role: __props.containerRole,
+				onMouseenter: handleMouseEnter,
+				onMouseleave: handleMouseLeave,
+				onMousewheel: _cache[1] || (_cache[1] = ($event) => __props.type === "number" && focused.value ? $event.preventDefault() : null)
+			}), [createCommentVNode(" input "), __props.type !== "textarea" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+				createCommentVNode(" prepend slot "),
+				_ctx.$slots.prepend ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					class: normalizeClass(unref(nsInput).be("group", "prepend"))
+				}, [renderSlot(_ctx.$slots, "prepend")], 2)) : createCommentVNode("v-if", true),
+				createElementVNode("div", { class: normalizeClass(wrapperKls.value) }, [
+					createCommentVNode(" prefix slot "),
+					_ctx.$slots.prefix || _prefixIcon.value?.icon ? (openBlock(), createElementBlock("span", {
+						key: 0,
+						class: normalizeClass(unref(nsInput).e("prefix"))
+					}, [createElementVNode("span", {
+						class: normalizeClass(unref(nsInput).e("prefix-inner")),
+						onClick: handlePrefixClick
+					}, [renderSlot(_ctx.$slots, "prefix"), _prefixIcon.value?.icon ? (openBlock(), createBlock(unref(VftIcon), mergeProps({
+						key: 0,
+						pointer: ""
+					}, _prefixIcon.value, { class: unref(nsInput).e("icon") }), null, 16, ["class"])) : createCommentVNode("v-if", true)], 2)], 2)) : createCommentVNode("v-if", true),
+					createElementVNode("input", mergeProps({
+						id: unref(inputId),
+						ref_key: "input",
+						ref: input,
+						class: unref(nsInput).e("inner")
+					}, unref(attrs), {
+						type: __props.showPassword ? passwordVisible.value ? "text" : "password" : __props.type,
+						disabled: unref(inputDisabled),
+						formatter: __props.formatter,
+						parser: __props.parser,
+						readonly: __props.readonly,
+						autocomplete: __props.autocomplete,
+						tabindex: __props.tabindex,
+						"aria-label": __props.label,
+						placeholder: __props.placeholder,
+						style: __props.inputStyle,
+						form: __props.form,
+						onCompositionstart: handleCompositionStart,
+						onCompositionupdate: handleCompositionUpdate,
+						onCompositionend: handleCompositionEnd,
+						onInput: handleInput,
+						onFocus: handleFocus,
+						onBlur: handleBlur,
+						onChange: handleChange,
+						onKeydown: handleKeydown,
+						onKeyup: _cache[0] || (_cache[0] = withKeys(($event) => emit("enter"), ["enter"]))
+					}), null, 16, _hoisted_2),
+					createCommentVNode(" suffix slot "),
+					suffixVisible.value ? (openBlock(), createElementBlock("span", {
+						key: 1,
+						class: normalizeClass(unref(nsInput).e("suffix"))
+					}, [createElementVNode("span", {
+						class: normalizeClass(unref(nsInput).e("suffix-inner")),
+						onClick: handleSuffixClick
+					}, [
+						!showClear.value || !showPwdVisible.value || !isWordLimitVisible.value ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [renderSlot(_ctx.$slots, "suffix"), _suffixIcon.value?.icon ? (openBlock(), createBlock(unref(VftIcon), mergeProps({ key: 0 }, _suffixIcon.value, { class: unref(nsInput).e("icon") }), null, 16, ["class"])) : createCommentVNode("v-if", true)], 64)) : createCommentVNode("v-if", true),
+						showClear.value ? (openBlock(), createBlock(unref(VftIcon), mergeProps({
+							key: 1,
+							pointer: "",
+							class: [unref(nsInput).e("icon"), unref(nsInput).e("clear")]
+						}, _clearIcon.value, {
+							onMousedown: withModifiers(unref(noop), ["prevent"]),
+							onClick: withModifiers(clear, ["stop"])
+						}), null, 16, ["class", "onMousedown"])) : createCommentVNode("v-if", true),
+						showPwdVisible.value ? (openBlock(), createBlock(unref(VftIcon), mergeProps({ key: 2 }, passwordIcon.value, {
+							class: [unref(nsInput).e("icon"), unref(nsInput).e("password")],
+							onClick: handlePasswordVisible
+						}), null, 16, ["class"])) : createCommentVNode("v-if", true),
+						isWordLimitVisible.value ? (openBlock(), createElementBlock("span", {
+							key: 3,
+							class: normalizeClass(unref(nsInput).e("count"))
+						}, [createElementVNode("span", { class: normalizeClass(unref(nsInput).e("count-inner")) }, toDisplayString(textLength.value) + " / " + toDisplayString(unref(attrs).maxlength), 3)], 2)) : createCommentVNode("v-if", true),
+						validateState.value && validateIcon.value && needStatusIcon.value ? (openBlock(), createBlock(unref(VftIcon), {
+							key: 4,
+							icon: validateIcon.value,
+							class: normalizeClass([
+								unref(nsInput).e("icon"),
+								unref(nsInput).e("validateIcon"),
+								unref(nsInput).is("loading", validateState.value === "validating")
+							])
+						}, null, 8, ["icon", "class"])) : createCommentVNode("v-if", true)
+					], 2)], 2)) : createCommentVNode("v-if", true)
+				], 2),
+				createCommentVNode(" append slot "),
+				_ctx.$slots.append ? (openBlock(), createElementBlock("div", {
+					key: 1,
+					class: normalizeClass(unref(nsInput).be("group", "append"))
+				}, [renderSlot(_ctx.$slots, "append")], 2)) : createCommentVNode("v-if", true)
+			], 64)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+				createCommentVNode(" textarea "),
+				createElementVNode("textarea", mergeProps({
+					id: unref(inputId),
+					ref_key: "textarea",
+					ref: textarea,
+					class: unref(nsTextarea).e("inner")
+				}, unref(attrs), {
+					tabindex: __props.tabindex,
+					disabled: unref(inputDisabled),
+					readonly: __props.readonly,
+					autocomplete: __props.autocomplete,
+					style: textareaStyle.value,
+					"aria-label": __props.label,
+					placeholder: __props.placeholder,
+					form: __props.form,
+					onCompositionstart: handleCompositionStart,
+					onCompositionupdate: handleCompositionUpdate,
+					onCompositionend: handleCompositionEnd,
+					onInput: handleInput,
+					onFocus: handleFocus,
+					onBlur: handleBlur,
+					onChange: handleChange,
+					onKeydown: handleKeydown
+				}), null, 16, _hoisted_3),
+				isWordLimitVisible.value ? (openBlock(), createElementBlock("span", {
+					key: 0,
+					style: normalizeStyle(countStyle.value),
+					class: normalizeClass(unref(nsInput).e("count"))
+				}, toDisplayString(textLength.value) + " / " + toDisplayString(unref(attrs).maxlength), 7)) : createCommentVNode("v-if", true)
+			], 64))], 16, _hoisted_1)), [[vShow, __props.type !== "hidden"]]);
+		};
+	}
+});
+//#endregion
+export { input_vue_vue_type_script_setup_true_lang_default as default };

package/es/components/input/style/css.js

@@ -1,2 +1,2 @@
-import "vft/theme-style/base.css";
+import "../../base/style/css.js";
 import "vft/theme-style/vft-input.css";

package/es/components/input/style/index.js

@@ -1,2 +1,2 @@
-import "vft/theme-style/src/base.scss";
+import "../../base/style/index.js";
 import "vft/theme-style/src/input.scss";

package/es/components/input/utils.js

@@ -1,6 +1,7 @@
-import { isNumber as s } from "@vft/utils";
-let t;
-const b = `
+import { isNumber } from "@vft/utils";
+//#region ../../packages/components/input/utils.ts
+let hiddenTextarea = void 0;
+const HIDDEN_STYLE = `
   height:0 !important;
   visibility:hidden !important;
   overflow:hidden !important;
@@ -8,47 +9,65 @@ const b = `
   z-index:-1000 !important;
   top:0 !important;
   right:0 !important;
-`, c = [
-  "letter-spacing",
-  "line-height",
-  "padding-top",
-  "padding-bottom",
-  "font-family",
-  "font-weight",
-  "font-size",
-  "text-rendering",
-  "text-transform",
-  "width",
-  "text-indent",
-  "padding-left",
-  "padding-right",
-  "border-width",
-  "box-sizing"
+`;
+const CONTEXT_STYLE = [
+	"letter-spacing",
+	"line-height",
+	"padding-top",
+	"padding-bottom",
+	"font-family",
+	"font-weight",
+	"font-size",
+	"text-rendering",
+	"text-transform",
+	"width",
+	"text-indent",
+	"padding-left",
+	"padding-right",
+	"border-width",
+	"box-sizing"
 ];
-function m(n) {
-  const e = window.getComputedStyle(n), l = e.getPropertyValue("box-sizing"), r = Number.parseFloat(e.getPropertyValue("padding-bottom")) + Number.parseFloat(e.getPropertyValue("padding-top")), a = Number.parseFloat(e.getPropertyValue("border-bottom-width")) + Number.parseFloat(e.getPropertyValue("border-top-width"));
-  return { contextStyle: c.map(
-    (p) => `${p}:${e.getPropertyValue(p)}`
-  ).join(";"), paddingSize: r, borderSize: a, boxSizing: l };
+function calculateNodeStyling(targetElement) {
+	const style = window.getComputedStyle(targetElement);
+	const boxSizing = style.getPropertyValue("box-sizing");
+	const paddingSize = Number.parseFloat(style.getPropertyValue("padding-bottom")) + Number.parseFloat(style.getPropertyValue("padding-top"));
+	const borderSize = Number.parseFloat(style.getPropertyValue("border-bottom-width")) + Number.parseFloat(style.getPropertyValue("border-top-width"));
+	return {
+		contextStyle: CONTEXT_STYLE.map((name) => `${name}:${style.getPropertyValue(name)}`).join(";"),
+		paddingSize,
+		borderSize,
+		boxSizing
+	};
 }
-function x(n, e = 1, l) {
-  t || (t = document.createElement("textarea"), document.body.appendChild(t));
-  const { paddingSize: r, borderSize: a, boxSizing: d, contextStyle: p } = m(n);
-  t.setAttribute("style", `${p};${b}`), t.value = n.value || n.placeholder || "";
-  let o = t.scrollHeight;
-  const g = {};
-  d === "border-box" ? o = o + a : d === "content-box" && (o = o - r), t.value = "";
-  const h = t.scrollHeight - r;
-  if (s(e)) {
-    let i = h * e;
-    d === "border-box" && (i = i + r + a), o = Math.max(i, o), g.minHeight = `${i}px`;
-  }
-  if (s(l)) {
-    let i = h * l;
-    d === "border-box" && (i = i + r + a), o = Math.min(i, o);
-  }
-  return g.height = `${o}px`, t.parentNode?.removeChild(t), t = void 0, g;
+function calcTextareaHeight(targetElement, minRows = 1, maxRows) {
+	if (!hiddenTextarea) {
+		hiddenTextarea = document.createElement("textarea");
+		document.body.appendChild(hiddenTextarea);
+	}
+	const { paddingSize, borderSize, boxSizing, contextStyle } = calculateNodeStyling(targetElement);
+	hiddenTextarea.setAttribute("style", `${contextStyle};${HIDDEN_STYLE}`);
+	hiddenTextarea.value = targetElement.value || targetElement.placeholder || "";
+	let height = hiddenTextarea.scrollHeight;
+	const result = {};
+	if (boxSizing === "border-box") height = height + borderSize;
+	else if (boxSizing === "content-box") height = height - paddingSize;
+	hiddenTextarea.value = "";
+	const singleRowHeight = hiddenTextarea.scrollHeight - paddingSize;
+	if (isNumber(minRows)) {
+		let minHeight = singleRowHeight * minRows;
+		if (boxSizing === "border-box") minHeight = minHeight + paddingSize + borderSize;
+		height = Math.max(minHeight, height);
+		result.minHeight = `${minHeight}px`;
+	}
+	if (isNumber(maxRows)) {
+		let maxHeight = singleRowHeight * maxRows;
+		if (boxSizing === "border-box") maxHeight = maxHeight + paddingSize + borderSize;
+		height = Math.min(maxHeight, height);
+	}
+	result.height = `${height}px`;
+	hiddenTextarea.parentNode?.removeChild(hiddenTextarea);
+	hiddenTextarea = void 0;
+	return result;
 }
-export {
-  x as calcTextareaHeight
-};
+//#endregion
+export { calcTextareaHeight };