@rebilly/revel 13.6.2 → 13.6.4

package/dist/components/r-select/r-select.vue_vue_type_script_lang.mjs

@@ -0,0 +1,599 @@
+import e from "../r-icon/r-icon.vue.mjs";
+import t from "../r-button/r-button.vue.mjs";
+import { isObject as n } from "../../common/helpers/is-object.mjs";
+import { nanoid as r } from "../../vendor/nanoid/non-secure/index.mjs";
+import i from "../r-badge/r-badge.vue.mjs";
+import { useValidate as a } from "../../composables/use-validate.mjs";
+import o from "../r-input-errors/r-input-errors.vue.mjs";
+import s from "../r-field-label/r-field-label.vue.mjs";
+import { AsyncExtension as c } from "./async-extension.mjs";
+import { defineComponent as l, ref as u } from "vue";
+//#region src/components/r-select/r-select.vue?vue&type=script&lang.ts
+function d(e) {
+	return e === 0 ? !1 : Array.isArray(e) && e.length === 0 ? !0 : !e;
+}
+function f(e) {
+	return (t) => !e(t);
+}
+function p(e, t) {
+	return e === void 0 && (e = "undefined"), e === null && (e = "null"), e === !1 && (e = "false"), e.toString().toLowerCase().indexOf(t.trim()) !== -1;
+}
+function m(e, t, n, r) {
+	let i = t.split(" ").filter((e) => !!e);
+	return e.filter((e) => i.every((t) => p(r(e, n), t)));
+}
+var h = (e) => e.reduce((e, t) => [...e, ...t.options || []], []), g = (e) => `and ${e} more`, _ = l({
+	name: "RSelect",
+	components: {
+		RInputErrors: o,
+		RIcon: e,
+		RButton: t,
+		RBadge: i,
+		RFieldLabel: s
+	},
+	props: {
+		allowEmpty: {
+			type: Boolean,
+			default: !0
+		},
+		autocomplete: {
+			type: String,
+			default: "off"
+		},
+		blockKeys: {
+			type: Array,
+			default() {
+				return [];
+			}
+		},
+		clearOnSelect: {
+			type: Boolean,
+			default: !0
+		},
+		closeOnSelect: {
+			type: Boolean,
+			default: !0
+		},
+		customLabel: {
+			type: Function,
+			default(e, t) {
+				return d(e) ? "" : typeof e == "object" && e[t] ? e[t] : e;
+			}
+		},
+		validate: {
+			type: Object,
+			default: null
+		},
+		showValidateMessages: {
+			type: Boolean,
+			default: !1
+		},
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		helpText: {
+			type: String,
+			default: null
+		},
+		hideSelected: {
+			type: Boolean,
+			default: !1
+		},
+		id: {
+			type: String,
+			default: () => r()
+		},
+		internalSearch: {
+			type: Boolean,
+			default: !0
+		},
+		label: {
+			type: String,
+			default: ""
+		},
+		required: {
+			type: Boolean,
+			default: !1
+		},
+		optional: {
+			type: Boolean,
+			default: !1
+		},
+		limit: {
+			type: Number,
+			default: 99999
+		},
+		limitText: {
+			type: Function,
+			default: g
+		},
+		loading: {
+			type: Boolean,
+			default: !1
+		},
+		max: {
+			type: [Number, Boolean],
+			default: !1
+		},
+		maxHeight: {
+			type: Number,
+			default: 300
+		},
+		multiple: {
+			type: Boolean,
+			default: !1
+		},
+		name: {
+			type: String,
+			default: ""
+		},
+		openDirection: {
+			type: String,
+			default: ""
+		},
+		options: {
+			type: Array,
+			default: () => []
+		},
+		optionHeight: {
+			type: Number,
+			default: 40
+		},
+		optionKey: {
+			type: String,
+			default: ""
+		},
+		optionLabel: {
+			type: String,
+			default: ""
+		},
+		optionsLimit: {
+			type: Number,
+			default: 1e3
+		},
+		preselectFirst: {
+			type: Boolean,
+			default: !1
+		},
+		preserveSearch: {
+			type: Boolean,
+			default: !1
+		},
+		placeholder: {
+			type: String,
+			default: "Select option"
+		},
+		resetAfter: {
+			type: Boolean,
+			default: !1
+		},
+		searchable: {
+			type: Boolean,
+			default: !0
+		},
+		showNoOptions: {
+			type: Boolean,
+			default: !0
+		},
+		showNoResults: {
+			type: Boolean,
+			default: !0
+		},
+		showPointer: {
+			type: Boolean,
+			default: !0
+		},
+		tabindex: {
+			type: Number,
+			default: 0
+		},
+		allowCustomOptions: {
+			type: Boolean,
+			default: !1
+		},
+		taggable: {
+			type: Boolean,
+			default: !1
+		},
+		customOptionsPosition: {
+			type: String,
+			default: "top"
+		},
+		customOptionsValidator: {
+			type: Function,
+			default: () => !0
+		},
+		modelValue: {
+			type: [
+				Array,
+				Object,
+				String,
+				Number,
+				Boolean
+			],
+			default() {
+				return [];
+			}
+		},
+		asyncFind: {
+			type: Function,
+			default: null
+		},
+		asyncConfig: {
+			type: Object,
+			default: () => ({})
+		},
+		asyncValuePropsKey: {
+			type: String,
+			default: ""
+		},
+		trackAsyncUpdatesByObject: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: [
+		"update:modelValue",
+		"search-change",
+		"open",
+		"close",
+		"remove",
+		"tag",
+		"async-loaded",
+		"select"
+	],
+	setup(e) {
+		let t = u(null), n = u(null), r = u(null), { isInvalid: i } = a(() => e.validate);
+		return {
+			searchElement: t,
+			tagsElement: n,
+			listElement: r,
+			isInvalid: i
+		};
+	},
+	data() {
+		return {
+			valueObject: null,
+			isOpen: !1,
+			optimizedHeight: this.maxHeight ?? 300,
+			pointer: 0,
+			pointerDirty: !1,
+			preferredOpenDirection: "below",
+			isHovered: !1,
+			search: "",
+			messages: {
+				loading: "Looking for matching results...",
+				more: g,
+				max: (e) => `Maximum of ${e} options selected. First remove a selected option to select another.`,
+				noOptions: "List is empty.",
+				noResult: "No elements found. Consider changing the search query."
+			},
+			async: new c({
+				component: this,
+				config: {
+					...this.asyncConfig,
+					limit: this.asyncConfig.limit || this.limit
+				},
+				asyncFind: this.asyncFind,
+				prepareCacheValuePrefix: this.prepareCacheValuePrefix
+			})
+		};
+	},
+	computed: {
+		computedLabel() {
+			return this.optionLabel || "label";
+		},
+		computedOptions() {
+			return this.computedIsAsync ? this.computedAsyncLastOptions || [] : this.options;
+		},
+		computedTrackBy() {
+			return this.optionKey || "value";
+		},
+		computedValue() {
+			let e = this.computedIsAsync ? h(this.async.getAllCacheItems()) : this.computedOptions, t = this.primitiveValue;
+			if (this.isComplexOptions && t !== null && Array.isArray(e)) {
+				if (!this.multiple) return e.find((e) => this.getOptionValue(e) === t) || {
+					[this.computedTrackBy]: t,
+					[this.computedLabel]: t
+				};
+				if (t && Array.isArray(t)) return t.map((t) => e.find((e) => this.getOptionValue(e) === t) || {
+					[this.computedTrackBy]: t,
+					[this.computedLabel]: t
+				});
+			}
+			return this.primitiveValue;
+		},
+		contentStyle() {
+			return {
+				display: this.computedOptions && this.computedOptions.length ? "inline-block" : "block",
+				minWidth: "100%"
+			};
+		},
+		computedAllowCustomOptions() {
+			return this.allowCustomOptions || this.taggable;
+		},
+		computedPlaceholder() {
+			return this.taggable && this.placeholder === "Select option" ? "Select or add new tags" : this.placeholder;
+		},
+		computedNoOptionsMessage() {
+			return this.taggable ? "No tags available. Start typing to create one." : this.messages.noOptions;
+		},
+		currentOptionLabel() {
+			let e = this.searchable ? "" : this.computedPlaceholder, t = this.computedOptions.find((e) => this.getOptionValue(e) === this.internalValue[0]);
+			!t && this.modelValue && (t = this.modelValue);
+			let n = this.internalValue && this.internalValue.length ? this.getOptionLabel(t || this.valueObject) : e;
+			return this.computedAllowCustomOptions && !n && ([n] = this.internalValue), this.multiple ? e : n;
+		},
+		filteredOptions() {
+			let e = this.search || "", t = e.toLowerCase().trim(), n = this.computedOptions && this.computedOptions.concat();
+			return this.computedOptions && this.internalSearch && (n = m(this.computedOptions, t, this.computedLabel, this.customLabel)), n = this.hideSelected ? n.filter(f(this.isSelected)) : n, this.computedAllowCustomOptions && t.length && !this.isExistingOption(t) && (this.customOptionsPosition === "bottom" ? n.push({
+				isTag: !0,
+				label: e
+			}) : n.unshift({
+				isTag: !0,
+				label: e
+			})), n.slice(0, this.optionsLimit);
+		},
+		hasContent() {
+			return (this.options.length !== 0 || this.showNoOptions) && (this.showNoResults || this.filteredOptions.length !== 0 || !this.search);
+		},
+		hasLabel() {
+			return (this.label || "").trim() !== "";
+		},
+		classes() {
+			return { "r-is-error": this.isInvalid };
+		},
+		labelClasses() {
+			return { "r-select-block-pointer-events": this.isOpen };
+		},
+		inputStyle() {
+			if (this.searchable || this.multiple && this.modelValue && typeof this.modelValue == "string" && this.modelValue.length) {
+				let e = this.preserveSearch && this.search.length > 0;
+				return this.isOpen || e ? { width: "100%" } : {
+					width: "0",
+					position: "absolute",
+					padding: "0"
+				};
+			}
+			return {};
+		},
+		internalValue() {
+			let e = !!this.modelValue && (this.computedOptions.find((e) => e === this.modelValue || typeof e == "object" && this.computedTrackBy in e && e[this.computedTrackBy] === this.modelValue) || this.computedAllowCustomOptions || this.computedIsAsync), t = Array.isArray(this.modelValue) ? this.modelValue : e && [this.modelValue] || [];
+			return this.modelValue === void 0 ? [] : t;
+		},
+		isAbove() {
+			return this.openDirection === "above" || this.openDirection === "top" ? !0 : this.openDirection === "below" || this.openDirection === "bottom" ? !1 : this.preferredOpenDirection === "above";
+		},
+		isComplexOptions() {
+			if (this.computedOptions) {
+				let [e] = this.computedOptions;
+				return typeof e != "string";
+			}
+			return !1;
+		},
+		isPlaceholderVisible() {
+			let e = this.preserveSearch && this.search.length > 0;
+			return !this.internalValue.length && (!this.searchable || !this.isOpen) && !e;
+		},
+		shouldShowPlaceholder() {
+			let e = this.preserveSearch && this.search.length > 0;
+			return (this.isPlaceholderVisible || this.loading) && !e;
+		},
+		isSingleLabelVisible() {
+			return !(!this.singleValue && this.singleValue === void 0 || this.isOpen && this.searchable || this.visibleValues.length);
+		},
+		optionKeys() {
+			return this.options.map((e) => this.customLabel(e, this.computedLabel).toString().toLowerCase());
+		},
+		pointerPosition() {
+			return this.pointer * this.optionHeight;
+		},
+		primitiveValue() {
+			return this.getPrimitiveValueFromValue({
+				value: this.multiple ? this.internalValue : this.modelValue,
+				multiple: this.multiple,
+				trackBy: this.computedTrackBy
+			});
+		},
+		singleValue() {
+			return this.internalValue[0];
+		},
+		valueKeys() {
+			return this.internalValue.map((e) => this.getOptionValue(e));
+		},
+		visibleElements() {
+			return this.optimizedHeight / this.optionHeight;
+		},
+		visibleValues() {
+			return this.multiple ? this.internalValue.slice(0, this.limit) : [];
+		},
+		computedIsAsync() {
+			return !!this.asyncFind;
+		},
+		computedIsLoading() {
+			return this.loading || this.async.isLoading;
+		},
+		computedAsyncLastOptions() {
+			let e = this.async.getLastCachedFindResult();
+			if (e && e.options) return e.options;
+		},
+		computedAsyncHasOptions() {
+			return this.async.hasOptions();
+		},
+		computedAsyncHasPrevOptions() {
+			return this.async.getOffset() > 0;
+		},
+		computedAsyncHasNextOptions() {
+			if (!this.computedAsyncHasOptions) return !1;
+			let { limit: e } = this.async.getConfig();
+			return ((t) => t ? Array.isArray(t) ? t.length >= e : n(t) ? Object.keys(t).length >= e : !1 : !1)(this.computedAsyncLastOptions);
+		},
+		displayNoResultsMessage() {
+			return !(!this.showNoResults || this.filteredOptions.length !== 0 || !this.search || this.loading || this.computedIsLoading);
+		},
+		showRemoveIcon() {
+			return this.allowEmpty && !this.multiple && this.internalValue.length > 0 && (this.isHovered || this.isOpen);
+		},
+		displayAsyncLoadingForPreselectedValue() {
+			return !this.computedIsAsync || this.modelValue && typeof this.modelValue == "object" && this.computedLabel in this.modelValue ? !1 : this.async.getLastCachedFindResult() === void 0;
+		}
+	},
+	watch: {
+		filteredOptions() {
+			this.pointerAdjust();
+		},
+		internalValue() {
+			this.resetAfter && this.internalValue.length && (this.search = "", this.$emit("update:modelValue", this.multiple ? [] : null));
+		},
+		isOpen() {
+			this.pointerDirty = !1;
+		},
+		pointer() {
+			this.searchElement && this.searchElement.setAttribute("aria-activedescendant", `${this.id}-${this.pointer.toString()}`);
+		},
+		async search() {
+			this.$emit("search-change", this.search, this.id), this.computedIsAsync && await this.handleAsyncFind(this.search);
+		},
+		loading() {
+			this.preselect();
+		}
+	},
+	mounted() {
+		!this.multiple && this.max && console.warn("[Revel warn]: Max prop should not be used when prop Multiple equals false."), this.preselect();
+	},
+	created() {
+		this.computedIsAsync && this.async.findBySearch("");
+	},
+	methods: {
+		activate() {
+			this.isOpen || this.disabled || (this.adjustPosition(), this.isOpen = !0, this.searchable ? (this.preserveSearch || (this.search = ""), this.$nextTick(() => this.searchElement && this.searchElement.focus())) : this.$el.focus(), this.$emit("open", this.id));
+		},
+		addPointerElement({ key: e }) {
+			this.filteredOptions.length > 0 && this.select(this.filteredOptions[this.pointer], e), this.pointerReset();
+		},
+		adjustPosition() {
+			if (typeof window > "u") return;
+			let e = this.$el.getBoundingClientRect().top, t = window.innerHeight - this.$el.getBoundingClientRect().bottom;
+			t > this.maxHeight || t > e || this.openDirection === "below" || this.openDirection === "bottom" ? (this.preferredOpenDirection = "below", this.optimizedHeight = Math.min(t - 40, this.maxHeight)) : (this.preferredOpenDirection = "above", this.optimizedHeight = Math.min(e - 40, this.maxHeight));
+		},
+		deactivate() {
+			this.isOpen && (this.isOpen = !1, this.searchable && this.searchElement ? this.searchElement.blur() : this.$el.blur(), this.preserveSearch || (this.search = ""), this.$emit("close", this.getValue(), this.id));
+		},
+		getOptionLabel(e) {
+			if (d(e) || e === null) return "";
+			if (typeof e == "object" && e.isTag) return e.label;
+			let t = this.customLabel(e, this.computedLabel);
+			return d(t) ? "" : t;
+		},
+		getOptionValue(e) {
+			if (e === null) return null;
+			let t = this.computedTrackBy;
+			return typeof e == "object" && t in e ? e[t] : e;
+		},
+		getSingleModelValue(e) {
+			return this.asyncFind !== null && this.trackAsyncUpdatesByObject ? e : this.getOptionValue(e);
+		},
+		getPrimitiveValueFromValue({ value: e, trackBy: t, multiple: n }) {
+			return e == null ? e : n ? e && Array.isArray(e) ? e.map((e) => this.getOptionValue(e)) : e : typeof e == "object" && t in e ? this.getOptionValue(e) : e;
+		},
+		getValue() {
+			let e = this.internalValue.length === 0 ? null : this.internalValue[0];
+			return this.multiple ? this.internalValue : e;
+		},
+		isExistingOption(e) {
+			return this.computedOptions ? this.optionKeys.indexOf(e) > -1 : !1;
+		},
+		isSelected(e) {
+			let t = this.getOptionValue(e);
+			return this.valueKeys.indexOf(t) > -1;
+		},
+		optionHighlight(e, t) {
+			return {
+				"r-select-option-is-highlight": e === this.pointer && this.showPointer,
+				"r-select-option-is-selected": this.isSelected(t)
+			};
+		},
+		pointerAdjust() {
+			this.pointer >= this.filteredOptions.length - 1 && (this.pointer = this.filteredOptions.length ? this.filteredOptions.length - 1 : 0);
+		},
+		pointerBackward() {
+			this.pointer > 0 && (--this.pointer, this.listElement && this.listElement.scrollTop >= this.pointerPosition && (this.listElement.scrollTop = this.pointerPosition)), this.pointerDirty = !0;
+		},
+		pointerForward() {
+			this.pointer < this.filteredOptions.length - 1 && (this.pointer += 1, this.listElement && this.listElement.scrollTop <= this.pointerPosition - (this.visibleElements - 1) * this.optionHeight && (this.listElement.scrollTop = this.pointerPosition - (this.visibleElements - 1) * this.optionHeight)), this.pointerDirty = !0;
+		},
+		pointerReset() {
+			this.closeOnSelect && (this.pointer = 0, this.listElement && (this.listElement.scrollTop = 0));
+		},
+		pointerSet(e) {
+			this.pointer = e, this.pointerDirty = !0;
+		},
+		prepareCacheValuePrefix(e) {
+			return typeof e == "string" ? e : String(this.getPrimitiveValueFromValue({
+				value: e,
+				multiple: this.multiple,
+				trackBy: this.computedTrackBy
+			}));
+		},
+		removeElement(e, t = !0) {
+			if (this.disabled || typeof e == "object" && e.$isDisabled) return;
+			if (!this.allowEmpty && this.internalValue.length <= 1) {
+				this.deactivate();
+				return;
+			}
+			let n = typeof e == "object" && this.computedTrackBy ? this.valueKeys.indexOf(e[this.computedTrackBy]) : this.valueKeys.indexOf(e);
+			if (this.$emit("remove", e, this.id), this.multiple && this.primitiveValue && Array.isArray(this.primitiveValue)) {
+				let e = this.primitiveValue.slice(0, n).concat(this.primitiveValue.slice(n + 1));
+				this.$emit("update:modelValue", e, this.id);
+			} else this.$emit("update:modelValue", null, this.id);
+			this.closeOnSelect && t && this.deactivate();
+		},
+		preselect() {
+			this.preselectFirst && !this.internalValue.length && this.computedOptions.length && this.select(this.filteredOptions[0]);
+		},
+		removeLastElement() {
+			this.blockKeys.indexOf("Delete") === -1 && this.search.length === 0 && Array.isArray(this.internalValue) && this.internalValue.length && this.removeElement(this.internalValue[this.internalValue.length - 1], !1);
+		},
+		select(e, t) {
+			if (this.validate && typeof this.validate == "object" && "$touch" in this.validate && this.validate.$touch(), !(t !== void 0 && this.blockKeys.indexOf(t) !== -1 || this.disabled) && (t !== "Tab" || this.pointerDirty)) {
+				if (typeof e == "object" && e.isTag) this.customOptionsValidator(e) && e.label && (this.$emit("tag", e.label, this.id), this.select(e.label), this.search = "", this.closeOnSelect && !this.multiple && this.deactivate());
+				else {
+					if (this.isSelected(e) && this.multiple) {
+						t !== "Tab" && (this.removeElement(e), this.$emit("remove", e));
+						return;
+					}
+					if (this.max && this.multiple && this.internalValue.length === this.max) return;
+					this.$emit("select", e, this.id), this.multiple ? this.$emit("update:modelValue", Array.isArray(this.primitiveValue) ? this.primitiveValue.concat([this.getOptionValue(e)]) : this.getOptionValue(e), this.id) : (this.valueObject = e, this.$emit("update:modelValue", this.getSingleModelValue(e), this.id)), this.clearOnSelect && (this.search = "");
+				}
+				this.closeOnSelect && this.deactivate();
+			}
+		},
+		toggle() {
+			this.isOpen ? this.deactivate() : this.activate();
+		},
+		updateSearch(e) {
+			this.search = e;
+		},
+		async handleAsyncFind(e) {
+			if (this.computedIsAsync) return this.async.findBySearch(e);
+		},
+		async handleAsyncLoadNext() {
+			if (this.computedIsAsync) return this.async.findNext();
+		},
+		async handleAsyncLoadPrev() {
+			if (this.computedIsAsync) return this.async.findPrev();
+		},
+		async handleAsyncLoadMore(e) {
+			if (this.computedIsAsync) return this.async.loadMore(e);
+		},
+		async handleAsyncLoadByQuery({ limit: e, offset: t }) {
+			if (this.computedIsAsync) return this.async.loadByQuery({
+				limit: e,
+				offset: t
+			});
+		}
+	}
+});
+//#endregion
+export { _ as default };

package/dist/components/r-tabs/r-tab.vue.mjs

@@ -0,0 +1,21 @@
+import e from "../../_virtual/_plugin-vue_export-helper.mjs";
+import t from "./r-tab.vue_vue_type_script_lang.mjs";
+import { Fragment as n, createCommentVNode as r, createElementBlock as i, createTextVNode as a, openBlock as o, renderSlot as s, vShow as c, withDirectives as l } from "vue";
+//#region src/components/r-tabs/r-tab.vue
+var u = ["id", "aria-labelledby"], d = ["id", "aria-labelledby"];
+function f(e, t, f, p, m, h) {
+	return e.resolvedLazy ? (o(), i(n, { key: 0 }, [e.$slots.default && e.hasBeenVisited ? l((o(), i("div", {
+		key: 0,
+		id: e.tabPanelId,
+		role: "tabpanel",
+		"aria-labelledby": e.tabId
+	}, [s(e.$slots, "default", {}, () => [t[0] ||= a("Default tab content", -1)])], 8, u)), [[c, e.shouldShowThisTab]]) : r("", !0)], 64)) : l((o(), i("div", {
+		key: 1,
+		id: e.tabPanelId,
+		role: "tabpanel",
+		"aria-labelledby": e.tabId
+	}, [s(e.$slots, "default", {}, () => [t[1] ||= a("Default tab content", -1)])], 8, d)), [[c, e.$slots.default && e.shouldShowThisTab]]);
+}
+var p = /*#__PURE__*/ e(t, [["render", f]]);
+//#endregion
+export { p as default };

package/dist/components/r-tabs/r-tab.vue_vue_type_script_lang.mjs

@@ -0,0 +1,84 @@
+import { nanoid as e } from "../../vendor/nanoid/non-secure/index.mjs";
+import { useValidate as t } from "../../composables/use-validate.mjs";
+import { computed as n, defineComponent as r, inject as i, onBeforeUnmount as a, ref as o, shallowRef as s, toRefs as c, watch as l } from "vue";
+//#region src/components/r-tabs/r-tab.vue?vue&type=script&lang.ts
+var u = r({
+	name: "RTab",
+	props: {
+		name: {
+			required: !0,
+			type: String
+		},
+		panelId: {
+			type: String,
+			default: ""
+		},
+		value: {
+			type: String,
+			default: ""
+		},
+		active: {
+			type: Boolean,
+			default: !1
+		},
+		to: {
+			type: [String, Object],
+			required: !1,
+			default: void 0
+		},
+		hidden: {
+			type: Boolean,
+			default: !1
+		},
+		lazy: {
+			type: Boolean,
+			default: void 0
+		},
+		validate: {
+			type: Array,
+			default: () => []
+		}
+	},
+	setup(r) {
+		let u = i("addItemToTabsList"), d = i("removeItemFromTabsList"), f = i("visibleTabs"), p = i("tabsLazy"), { name: m, panelId: h, hidden: g, active: _, value: v } = c(r), y = s(r.to);
+		l(() => JSON.stringify(r.to), () => {
+			y.value = r.to;
+		});
+		let b = r.validate.map((e) => t(() => e)), x = n(() => b.map((e) => e.validateErrorMessages.value).reduce((e, t) => e.concat(t), [])), S = n(() => b.some((e) => e.isInvalid.value)), C = n(() => h.value || e()), w = n(() => `tab-${C.value}`), T = n(() => {
+			if (f) return f.value.find(({ tabId: e }) => e === w.value)?.isActive;
+		}), E = n(() => `tabpanel-${C.value}`), D = n(() => r.lazy ?? p?.value ?? !0), O = o(r.active);
+		l(T, (e) => {
+			e && (O.value = !0);
+		});
+		let k = o(_.value);
+		return a(() => {
+			d?.(w.value);
+		}), {
+			shouldShowThisTab: T,
+			resolvedLazy: D,
+			hasBeenVisited: O,
+			tabPanelId: E,
+			tabId: w,
+			addItemToTabsList: () => {
+				u && u({
+					tabId: w,
+					tabPanelId: E,
+					hidden: g,
+					isActive: k,
+					name: m,
+					value: v,
+					active: _,
+					to: y,
+					validateErrorMessages: x,
+					isInvalid: S
+				});
+			},
+			visibleTabs: f
+		};
+	},
+	created() {
+		this.addItemToTabsList();
+	}
+});
+//#endregion
+export { u as default };