bootstrap-vue-next/dist/BFormRadio-C9U9PbDA.js

Seamless integration of Vue 3, Bootstrap 5, and TypeScript for modern, type-safe UI development

require("./chunk-CoQrYLCe.js");
const require_keys = require("./keys-durSVUrO.js");
const require_dist = require("./dist-B_c893QG.js");
const require_dom = require("./dom-Bs6DzM72.js");
const require_useDefaults = require("./useDefaults-DsLf4iRY.js");
const require_useId = require("./useId-DHrBgM7P.js");
const require_ConditionalWrapper = require("./ConditionalWrapper-BcQirqyl.js");
const require_useFormCheck = require("./useFormCheck-H0B2G8GH.js");
let vue = require("vue");
//#region src/components/BFormRadio/BFormRadio.vue?vue&type=script&setup=true&lang.ts
var _hoisted_1$1 = [
	"id",
	"disabled",
	"required",
	"name",
	"form",
	"aria-label",
	"aria-labelledby",
	"value",
	"aria-required"
];
var _hoisted_2 = ["for"];
//#endregion
//#region src/components/BFormRadio/BFormRadio.vue
var BFormRadio_default = /* @__PURE__ */ (0, vue.defineComponent)({
	inheritAttrs: false,
	__name: "BFormRadio",
	props: /* @__PURE__ */ (0, vue.mergeModels)({
		ariaLabel: { default: void 0 },
		ariaLabelledby: { default: void 0 },
		autofocus: {
			type: Boolean,
			default: false
		},
		button: {
			type: Boolean,
			default: void 0
		},
		buttonGroup: {
			type: Boolean,
			default: false
		},
		buttonVariant: { default: void 0 },
		disabled: {
			type: Boolean,
			default: false
		},
		form: { default: void 0 },
		id: { default: void 0 },
		inline: {
			type: Boolean,
			default: void 0
		},
		name: { default: void 0 },
		plain: {
			type: Boolean,
			default: void 0
		},
		required: {
			type: Boolean,
			default: false
		},
		reverse: {
			type: Boolean,
			default: void 0
		},
		size: { default: void 0 },
		state: {
			type: [Boolean, null],
			default: void 0
		},
		value: {
			type: [
				Boolean,
				String,
				Array,
				Object,
				Number,
				null
			],
			default: true
		}
	}, {
		"modelValue": {
			type: [
				Boolean,
				String,
				Array,
				Object,
				Number,
				null
			],
			default: void 0
		},
		"modelModifiers": {}
	}),
	emits: ["update:modelValue"],
	setup(__props, { expose: __expose }) {
		const props = require_useDefaults.useDefaults(__props, "BFormRadio");
		const slots = (0, vue.useSlots)();
		const modelValue = (0, vue.useModel)(__props, "modelValue");
		const computedId = require_useId.useId(() => props.id, "form-check");
		const parentData = (0, vue.inject)(require_keys.radioGroupKey, null);
		const formGroupData = (0, vue.inject)(require_keys.formGroupKey, null)?.(computedId);
		const input = (0, vue.useTemplateRef)("_input");
		const { focused } = require_dist.useFocus(input, { initialValue: props.autofocus });
		const hasDefaultSlot = (0, vue.computed)(() => !require_dom.isEmptySlot(slots.default));
		const propDefaults = {
			plain: false,
			button: false,
			inline: false,
			reverse: false,
			size: "md",
			buttonVariant: "secondary",
			state: null
		};
		const resolvedProps = (0, vue.computed)(() => ({
			plain: props.plain ?? parentData?.plain.value ?? propDefaults.plain,
			button: props.button ?? parentData?.buttons.value ?? propDefaults.button,
			inline: props.inline ?? parentData?.inline.value ?? propDefaults.inline,
			reverse: props.reverse ?? parentData?.reverse.value ?? propDefaults.reverse,
			state: props.state ?? parentData?.state.value ?? propDefaults.state,
			size: props.size ?? parentData?.size.value ?? propDefaults.size,
			buttonVariant: props.buttonVariant ?? parentData?.buttonVariant.value ?? propDefaults.buttonVariant
		}));
		const resolvedPlain = (0, vue.computed)(() => resolvedProps.value.plain);
		const localValue = (0, vue.computed)({
			get: () => parentData ? parentData.modelValue.value : modelValue.value,
			set: (newValue) => {
				if (newValue === void 0) return;
				if (parentData !== null) {
					parentData.modelValue.value = newValue;
					return;
				}
				modelValue.value = newValue;
			}
		});
		const computedRequired = (0, vue.computed)(() => !!(props.name ?? parentData?.name.value) && (props.required || parentData?.required.value));
		const isButtonGroup = (0, vue.computed)(() => props.buttonGroup || (parentData?.buttons.value ?? false));
		const classesObject = (0, vue.computed)(() => ({
			...resolvedProps.value,
			hasDefaultSlot: hasDefaultSlot.value
		}));
		const computedClasses = require_useFormCheck.getClasses(classesObject);
		const inputClasses = require_useFormCheck.getInputClasses(classesObject);
		const labelClasses = require_useFormCheck.getLabelClasses(classesObject);
		__expose({
			blur: () => {
				focused.value = false;
			},
			element: input,
			focus: () => {
				focused.value = true;
			}
		});
		return (_ctx, _cache) => {
			return (0, vue.openBlock)(), (0, vue.createBlock)(require_ConditionalWrapper.ConditionalWrapper_default, {
				skip: isButtonGroup.value,
				class: (0, vue.normalizeClass)((0, vue.unref)(computedClasses))
			}, {
				default: (0, vue.withCtx)(() => [(0, vue.withDirectives)((0, vue.createElementVNode)("input", (0, vue.mergeProps)({ id: (0, vue.unref)(computedId) }, _ctx.$attrs, {
					ref: "_input",
					"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => localValue.value = $event),
					class: (0, vue.unref)(inputClasses),
					type: "radio",
					disabled: (0, vue.unref)(props).disabled || (0, vue.unref)(parentData)?.disabled.value || (0, vue.unref)(formGroupData)?.disabled.value,
					required: computedRequired.value || void 0,
					name: (0, vue.unref)(props).name || (0, vue.unref)(parentData)?.name.value,
					form: (0, vue.unref)(props).form || (0, vue.unref)(parentData)?.form.value,
					"aria-label": (0, vue.unref)(props).ariaLabel,
					"aria-labelledby": (0, vue.unref)(props).ariaLabelledby,
					value: (0, vue.unref)(props).value,
					"aria-required": computedRequired.value || void 0
				}), null, 16, _hoisted_1$1), [[vue.vModelRadio, localValue.value]]), hasDefaultSlot.value || !resolvedPlain.value ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("label", {
					key: 0,
					for: (0, vue.unref)(computedId),
					class: (0, vue.normalizeClass)((0, vue.unref)(labelClasses))
				}, [(0, vue.renderSlot)(_ctx.$slots, "default")], 10, _hoisted_2)) : (0, vue.createCommentVNode)("", true)]),
				_: 3
			}, 8, ["skip", "class"]);
		};
	}
});
//#endregion
//#region src/components/BFormRadio/BFormRadioGroupBase.vue?vue&type=script&setup=true&lang.ts
var _hoisted_1 = ["id"];
//#endregion
//#region src/components/BFormRadio/BFormRadioGroupBase.vue
var BFormRadioGroupBase_default = /* @__PURE__ */ (0, vue.defineComponent)({
	__name: "BFormRadioGroupBase",
	props: /* @__PURE__ */ (0, vue.mergeModels)({
		ariaInvalid: {
			type: [Boolean, String],
			default: void 0
		},
		autofocus: {
			type: Boolean,
			default: false
		},
		buttonVariant: { default: "secondary" },
		buttons: {
			type: Boolean,
			default: false
		},
		disabled: {
			type: Boolean,
			default: false
		},
		form: { default: void 0 },
		id: { default: void 0 },
		name: { default: void 0 },
		options: { default: () => [] },
		plain: {
			type: Boolean,
			default: false
		},
		required: {
			type: Boolean,
			default: false
		},
		reverse: {
			type: Boolean,
			default: false
		},
		size: { default: "md" },
		stacked: {
			type: Boolean,
			default: false
		},
		state: {
			type: [Boolean, null],
			default: null
		},
		validated: {
			type: Boolean,
			default: false
		}
	}, {
		"modelValue": { default: null },
		"modelModifiers": {}
	}),
	emits: ["update:modelValue"],
	setup(__props, { expose: __expose }) {
		const props = require_useDefaults.useDefaults(__props, "BFormRadioGroup");
		const modelValue = (0, vue.useModel)(__props, "modelValue");
		const computedId = require_useId.useId(() => props.id, "radio");
		const computedName = require_useId.useId(() => props.name, "radio");
		const { focused } = require_dist.useFocus((0, vue.useTemplateRef)("_element"), { initialValue: props.autofocus });
		const normalizedOptions = (0, vue.computed)(() => props.options.map((option) => {
			if (typeof option === "object" && option !== null) return {
				...option,
				disabled: props.disabled ? true : option.disabled ?? false
			};
			return {
				text: String(option),
				value: option,
				disabled: props.disabled ? true : false
			};
		}));
		(0, vue.provide)(require_keys.radioGroupKey, {
			modelValue,
			buttonVariant: (0, vue.toRef)(() => props.buttonVariant),
			form: (0, vue.toRef)(() => props.form),
			name: computedName,
			buttons: (0, vue.toRef)(() => props.buttons),
			state: (0, vue.toRef)(() => props.state),
			plain: (0, vue.toRef)(() => props.plain),
			size: (0, vue.toRef)(() => props.size),
			inline: (0, vue.toRef)(() => !props.stacked),
			reverse: (0, vue.toRef)(() => props.reverse),
			required: (0, vue.toRef)(() => props.required),
			disabled: (0, vue.toRef)(() => props.disabled)
		});
		const classesObject = (0, vue.computed)(() => ({
			required: props.required,
			ariaInvalid: props.ariaInvalid,
			state: props.state,
			validated: props.validated,
			buttons: props.buttons,
			stacked: props.stacked,
			size: props.size
		}));
		const computedAttrs = require_useFormCheck.getGroupAttr(classesObject);
		const computedClasses = require_useFormCheck.getGroupClasses(classesObject);
		__expose({
			blur: () => {
				focused.value = false;
			},
			focus: () => {
				focused.value = true;
			}
		});
		return (_ctx, _cache) => {
			return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", (0, vue.mergeProps)((0, vue.unref)(computedAttrs), {
				id: (0, vue.unref)(computedId),
				ref: "_element",
				role: "radiogroup",
				class: [(0, vue.unref)(computedClasses), "bv-no-focus-ring"],
				tabindex: "-1"
			}), [
				(0, vue.renderSlot)(_ctx.$slots, "first"),
				((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(normalizedOptions.value, (item, index) => {
					return (0, vue.openBlock)(), (0, vue.createBlock)(BFormRadio_default, (0, vue.mergeProps)({ key: index }, { ref_for: true }, item), {
						default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "option", (0, vue.mergeProps)({ ref_for: true }, item), () => [(0, vue.createTextVNode)((0, vue.toDisplayString)(item.text), 1)])]),
						_: 2
					}, 1040);
				}), 128)),
				(0, vue.renderSlot)(_ctx.$slots, "default")
			], 16, _hoisted_1);
		};
	}
});
//#endregion
//#region src/components/BFormRadio/BFormRadioGroup.vue
var BFormRadioGroup_default = /* @__PURE__ */ (0, vue.defineComponent)({
	__name: "BFormRadioGroup",
	props: /* @__PURE__ */ (0, vue.mergeModels)({
		ariaInvalid: {
			type: [Boolean, String],
			default: void 0
		},
		autofocus: {
			type: Boolean,
			default: false
		},
		buttonVariant: { default: "secondary" },
		buttons: {
			type: Boolean,
			default: false
		},
		disabled: {
			type: Boolean,
			default: false
		},
		disabledField: { default: "disabled" },
		form: { default: void 0 },
		id: { default: void 0 },
		name: { default: void 0 },
		options: { default: () => [] },
		plain: {
			type: Boolean,
			default: false
		},
		required: {
			type: Boolean,
			default: false
		},
		reverse: {
			type: Boolean,
			default: false
		},
		size: { default: "md" },
		stacked: {
			type: Boolean,
			default: false
		},
		state: {
			type: [Boolean, null],
			default: null
		},
		textField: { default: "text" },
		validated: {
			type: Boolean,
			default: false
		},
		valueField: { default: "value" }
	}, {
		"modelValue": { default: void 0 },
		"modelModifiers": {}
	}),
	emits: ["update:modelValue"],
	setup(__props) {
		const props = __props;
		const modelValue = (0, vue.useModel)(__props, "modelValue");
		const normalizedOptions = (0, vue.computed)(() => (props.options ?? []).map((el) => typeof el === "string" || typeof el === "number" || typeof el === "boolean" ? {
			value: el,
			disabled: props.disabled,
			text: el.toString()
		} : {
			value: el[props.valueField],
			disabled: props.disabled || (el[props.disabledField] ?? false),
			text: el[props.textField] ?? ""
		}));
		const forwardedProps = (0, vue.computed)(() => ({
			id: props.id,
			name: props.name,
			size: props.size,
			state: props.state,
			buttonVariant: props.buttonVariant,
			buttons: props.buttons,
			stacked: props.stacked,
			disabled: props.disabled,
			required: props.required,
			validated: props.validated,
			autofocus: props.autofocus,
			form: props.form,
			ariaInvalid: props.ariaInvalid,
			plain: props.plain,
			reverse: props.reverse
		}));
		return (_ctx, _cache) => {
			return (0, vue.openBlock)(), (0, vue.createBlock)(BFormRadioGroupBase_default, (0, vue.mergeProps)(forwardedProps.value, {
				modelValue: modelValue.value,
				"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => modelValue.value = $event),
				options: normalizedOptions.value
			}), {
				first: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "first")]),
				option: (0, vue.withCtx)((slotProps) => [(0, vue.renderSlot)(_ctx.$slots, "option", (0, vue.normalizeProps)((0, vue.guardReactiveProps)(slotProps)))]),
				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default")]),
				_: 3
			}, 16, ["modelValue", "options"]);
		};
	}
});
//#endregion
Object.defineProperty(exports, "BFormRadioGroup_default", {
	enumerable: true,
	get: function() {
		return BFormRadioGroup_default;
	}
});
Object.defineProperty(exports, "BFormRadio_default", {
	enumerable: true,
	get: function() {
		return BFormRadio_default;
	}
});

//# sourceMappingURL=BFormRadio-C9U9PbDA.js.map