bootstrap-vue-next/dist/BFormCheckbox-eSsgdaji.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/BFormCheckbox/BFormCheckbox.vue?vue&type=script&setup=true&lang.ts
var _hoisted_1$1 = [
	"id",
	"disabled",
	"required",
	"name",
	"form",
	"aria-label",
	"aria-labelledby",
	"aria-required",
	"value",
	"true-value",
	"false-value",
	"indeterminate"
];
var _hoisted_2 = ["for"];
//#endregion
//#region src/components/BFormCheckbox/BFormCheckbox.vue
var BFormCheckbox_default = /* @__PURE__ */ (0, vue.defineComponent)({
	inheritAttrs: false,
	__name: "BFormCheckbox",
	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
		},
		switch: {
			type: Boolean,
			default: void 0
		},
		uncheckedValue: {
			type: [
				Array,
				Set,
				String,
				Boolean,
				Object,
				Number,
				null
			],
			default: false
		},
		wrapperAttrs: { default: void 0 },
		inputClass: { default: void 0 },
		value: {
			type: [
				String,
				Boolean,
				Array,
				Set,
				Object,
				Number,
				null
			],
			default: true
		}
	}, {
		"modelValue": {
			type: [
				Array,
				Set,
				String,
				Boolean,
				Object,
				Number,
				null
			],
			default: void 0
		},
		"modelModifiers": {},
		"indeterminate": {
			type: Boolean,
			default: false
		},
		"indeterminateModifiers": {}
	}),
	emits: ["update:modelValue", "update:indeterminate"],
	setup(__props, { expose: __expose }) {
		const props = require_useDefaults.useDefaults(__props, "BFormCheckbox");
		const slots = (0, vue.useSlots)();
		const attrs = (0, vue.useAttrs)();
		const modelValue = (0, vue.useModel)(__props, "modelValue");
		const indeterminate = (0, vue.useModel)(__props, "indeterminate");
		const processedAttrs = (0, vue.computed)(() => {
			const { class: wrapperClass, ...inputAttrs } = attrs;
			return {
				wrapperClass,
				inputAttrs
			};
		});
		const computedId = require_useId.useId(() => props.id, "form-check");
		const parentData = (0, vue.inject)(require_keys.checkboxGroupKey, 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,
			switch: 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,
			switch: props.switch ?? parentData?.switch.value ?? propDefaults.switch,
			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: (newVal) => {
				if (newVal === void 0) return;
				indeterminate.value = false;
				if (parentData !== null && Array.isArray(newVal)) {
					parentData.modelValue.value = newVal;
					return;
				}
				modelValue.value = newVal;
			}
		});
		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 wrapperClasses = require_useFormCheck.getClasses(classesObject);
		const computedWrapperClasses = (0, vue.computed)(() => [wrapperClasses.value, processedAttrs.value.wrapperClass]);
		const inputClasses = require_useFormCheck.getInputClasses(classesObject);
		const computedInputClasses = (0, vue.computed)(() => [inputClasses.value, props.inputClass]);
		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, (0, vue.mergeProps)({ skip: isButtonGroup.value }, (0, vue.unref)(props).wrapperAttrs, { class: computedWrapperClasses.value }), {
				default: (0, vue.withCtx)(() => [(0, vue.withDirectives)((0, vue.createElementVNode)("input", (0, vue.mergeProps)({
					id: (0, vue.unref)(computedId),
					ref: "_input",
					"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => localValue.value = $event),
					class: computedInputClasses.value,
					type: "checkbox",
					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,
					"aria-required": computedRequired.value || void 0,
					value: (0, vue.unref)(props).value,
					"true-value": (0, vue.unref)(props).value,
					"false-value": (0, vue.unref)(props).uncheckedValue,
					indeterminate: indeterminate.value || void 0
				}, processedAttrs.value.inputAttrs), null, 16, _hoisted_1$1), [[vue.vModelCheckbox, 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
			}, 16, ["skip", "class"]);
		};
	}
});
//#endregion
//#region src/components/BFormCheckbox/BFormCheckboxGroupBase.vue?vue&type=script&setup=true&lang.ts
var _hoisted_1 = ["id"];
//#endregion
//#region src/components/BFormCheckbox/BFormCheckboxGroupBase.vue
var BFormCheckboxGroupBase_default = /* @__PURE__ */ (0, vue.defineComponent)({
	__name: "BFormCheckboxGroupBase",
	props: /* @__PURE__ */ (0, vue.mergeModels)({
		id: { default: void 0 },
		name: { default: void 0 },
		size: { default: "md" },
		state: {
			type: [Boolean, null],
			default: null
		},
		buttonVariant: { default: "secondary" },
		buttons: {
			type: Boolean,
			default: false
		},
		stacked: {
			type: Boolean,
			default: false
		},
		disabled: {
			type: Boolean,
			default: false
		},
		required: {
			type: Boolean,
			default: false
		},
		validated: {
			type: Boolean,
			default: false
		},
		autofocus: {
			type: Boolean,
			default: false
		},
		form: { default: void 0 },
		ariaInvalid: {
			type: [Boolean, String],
			default: void 0
		},
		plain: {
			type: Boolean,
			default: false
		},
		reverse: {
			type: Boolean,
			default: false
		},
		switches: {
			type: Boolean,
			default: false
		},
		options: { default: () => [] }
	}, {
		"modelValue": { default: () => [] },
		"modelModifiers": {}
	}),
	emits: ["update:modelValue"],
	setup(__props, { expose: __expose }) {
		const props = require_useDefaults.useDefaults(__props, "BFormCheckboxGroup");
		const modelValue = (0, vue.useModel)(__props, "modelValue");
		const computedId = require_useId.useId(() => props.id, "checkbox");
		const computedName = require_useId.useId(() => props.name, "checkbox");
		const _element = (0, vue.useTemplateRef)("_element");
		const { focused } = require_dist.useFocus(_element, { initialValue: props.autofocus });
		(0, vue.provide)(require_keys.checkboxGroupKey, {
			modelValue,
			switch: (0, vue.toRef)(() => props.switches),
			buttonVariant: (0, vue.toRef)(() => props.buttonVariant),
			form: (0, vue.toRef)(() => props.form),
			name: computedName,
			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),
			buttons: (0, vue.toRef)(() => props.buttons),
			disabled: (0, vue.toRef)(() => props.disabled)
		});
		const normalizedOptions = (0, vue.computed)(() => props.options.map((option) => {
			if (typeof option === "object" && option !== null) return {
				...option,
				text: option.text ?? String(option.value ?? ""),
				value: option.value ?? null,
				disabled: props.disabled ? true : option.disabled ?? false
			};
			return {
				text: String(option),
				value: option,
				disabled: props.disabled ? true : false
			};
		}));
		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 attrs = require_useFormCheck.getGroupAttr(classesObject);
		const classes = 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)(attrs), {
				id: (0, vue.unref)(computedId),
				ref_key: "_element",
				ref: _element,
				role: "group",
				class: [(0, vue.unref)(classes), "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)(BFormCheckbox_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/BFormCheckbox/BFormCheckboxGroup.vue
var BFormCheckboxGroup_default = /* @__PURE__ */ (0, vue.defineComponent)({
	__name: "BFormCheckboxGroup",
	props: /* @__PURE__ */ (0, vue.mergeModels)({
		options: { default: () => [] },
		valueField: { default: "value" },
		textField: { default: "text" },
		disabledField: { default: "disabled" },
		id: { default: void 0 },
		name: { default: void 0 },
		size: { default: "md" },
		state: {
			type: [Boolean, null],
			default: null
		},
		buttonVariant: { default: "secondary" },
		buttons: {
			type: Boolean,
			default: false
		},
		stacked: {
			type: Boolean,
			default: false
		},
		disabled: {
			type: Boolean,
			default: false
		},
		required: {
			type: Boolean,
			default: false
		},
		validated: {
			type: Boolean,
			default: false
		},
		autofocus: {
			type: Boolean,
			default: false
		},
		form: { default: void 0 },
		ariaInvalid: {
			type: [Boolean, String],
			default: void 0
		},
		plain: {
			type: Boolean,
			default: false
		},
		reverse: {
			type: Boolean,
			default: false
		},
		switches: {
			type: Boolean,
			default: false
		}
	}, {
		"modelValue": { default: () => [] },
		"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] ?? String(el[props.valueField])
		}));
		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,
			switches: props.switches
		}));
		return (_ctx, _cache) => {
			return (0, vue.openBlock)(), (0, vue.createBlock)(BFormCheckboxGroupBase_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, "BFormCheckboxGroup_default", {
	enumerable: true,
	get: function() {
		return BFormCheckboxGroup_default;
	}
});
Object.defineProperty(exports, "BFormCheckbox_default", {
	enumerable: true,
	get: function() {
		return BFormCheckbox_default;
	}
});

//# sourceMappingURL=BFormCheckbox-eSsgdaji.js.map