bitboss-ui 2.1.135 → 3.0.0-alpha.4

package/dist/components/BbBaseButton/BbBaseButton.vue.d.ts

@@ -0,0 +1,13 @@
+import { BbBaseButtonProps, BbBaseButtonSlots } from './types';
+type __VLS_Slots = BbBaseButtonSlots;
+declare const __VLS_base: import('vue').DefineComponent<BbBaseButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BbBaseButtonProps> & Readonly<{}>, {
+    type: HTMLButtonElement["type"];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BbBaseButton/BbBaseButton.vue.js

@@ -0,0 +1,6 @@
+import e from "./BbBaseButton.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                     */
+//#region src/components/BbBaseButton/BbBaseButton.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/BbBaseButton/BbBaseButton.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,171 @@
+import { useFrameworkDetection as e } from "../../composables/useFrameworkDetection.js";
+import t from "./RouterComponent.vue.js";
+import { useInertiaPage as n } from "../../composables/useInertiaPage.js";
+import { config as r } from "virtual:bitboss-ui/config";
+import { computed as i, createBlock as a, createElementBlock as o, createTextVNode as s, defineComponent as c, mergeProps as l, openBlock as u, renderSlot as d, resolveDynamicComponent as f, toDisplayString as p, withCtx as m } from "vue";
+//#region src/components/BbBaseButton/BbBaseButton.vue?vue&type=script&setup=true&lang.ts
+var h = "http://localhost", g = /*@__PURE__*/ c({
+	__name: "BbBaseButton",
+	props: {
+		activeClass: {},
+		ariaCurrentValue: {},
+		block: { type: Boolean },
+		data: {},
+		disabled: { type: Boolean },
+		exactActiveClass: {},
+		headers: {},
+		href: {},
+		download: { type: [Boolean, String] },
+		external: { type: Boolean },
+		method: {},
+		onBefore: {},
+		onCancel: {},
+		onCancelToken: {},
+		onFinish: {},
+		only: {},
+		onProgress: {},
+		onStart: {},
+		onSuccess: {},
+		preserveScroll: { type: [Boolean, Function] },
+		preserveState: { type: [
+			Boolean,
+			Function,
+			null
+		] },
+		queryStringArrayFormat: {},
+		replace: { type: Boolean },
+		rel: {},
+		tag: {},
+		target: {},
+		text: {},
+		to: {},
+		type: { default: "button" }
+	},
+	setup(c) {
+		let g = c, { isInertia: _, isNuxt: v } = e(), { getPageUrl: y } = n(), b = (e, t) => {
+			let n = e.trim();
+			if (!n) return !1;
+			if (n.startsWith("#") || n.startsWith("//")) return !0;
+			if (!/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(n)) return !1;
+			if (!t) return !0;
+			try {
+				return new URL(n).origin !== t;
+			} catch {
+				return !0;
+			}
+		}, x = (e) => e === "/" ? e : e.replace(/\/+$/, ""), S = i(() => {
+			let e = y();
+			if (e) try {
+				return x(new URL(e, h).pathname);
+			} catch {
+				return;
+			}
+		}), C = i(() => {
+			let e = y();
+			if (!e) return null;
+			try {
+				return new URL(e, h).origin;
+			} catch {
+				return null;
+			}
+		}), w = i(() => !!(g.href && !b(g.href, C.value))), T = i(() => {
+			if (!w.value || !g.href) return;
+			let e = S.value ?? "/";
+			try {
+				return x(new URL(g.href, `${h}${e}`).pathname);
+			} catch {
+				return;
+			}
+		}), E = typeof window < "u", D = E ? window.location.origin : null, O = i(() => E ? x(window.location.pathname) : void 0), k = i(() => {
+			if (!g.href || b(g.href, D)) return;
+			let e = O.value ?? "/";
+			try {
+				return x(new URL(g.href, `${h}${e}`).pathname);
+			} catch {
+				return;
+			}
+		}), A = i(() => _ ? S.value : O.value), j = i(() => _ ? T.value : k.value), M = i(() => {
+			if (g.to) return !1;
+			let e = A.value, t = j.value;
+			return !e || !t ? !1 : t === e;
+		}), N = i(() => {
+			if (g.to) return !1;
+			let e = A.value, t = j.value;
+			return !e || !t ? !1 : t === "/" ? e.startsWith("/") : e === t || e.startsWith(`${t}/`);
+		}), P = i(() => !!(g.href && _ && w.value && !g.disabled && !g.target && !g.download && !g.external || g.to && !g.disabled)), F = i(() => !!(g.href || g.to && g.disabled)), I = i(() => g.activeClass ?? r.linkActiveClass), L = i(() => g.exactActiveClass ?? r.linkExactActiveClass), R = i(() => ({
+			"bb-base-button": !0,
+			"bb-base-button--block": g.block,
+			"bb-base-button--disabled": g.disabled,
+			[I.value]: N.value,
+			[L.value]: M.value
+		})), z = i(() => {
+			let e = g.rel?.trim() ?? "";
+			if (g.target !== "_blank") return e || void 0;
+			let t = new Set(e.split(/\s+/).filter(Boolean));
+			return t.add("noopener"), t.add("noreferrer"), Array.from(t).join(" ");
+		}), B = () => ({
+			disabled: g.disabled,
+			type: g.type
+		}), V = () => {
+			if (g.disabled) return {
+				"aria-disabled": !0,
+				role: "link",
+				href: void 0,
+				tabindex: -1
+			};
+			let e = {
+				href: g.href,
+				rel: z.value,
+				target: g.target,
+				download: g.download === !0 ? "" : (g.download ?? void 0) || void 0
+			};
+			return M.value && (e["aria-current"] = g.ariaCurrentValue ?? "page"), e;
+		}, H = () => ({
+			data: g.data,
+			headers: g.headers,
+			method: g.method,
+			onBefore: g.onBefore,
+			onCancel: g.onCancel,
+			onCancelToken: g.onCancelToken,
+			onFinish: g.onFinish,
+			only: g.only,
+			onProgress: g.onProgress,
+			onStart: g.onStart,
+			onSuccess: g.onSuccess,
+			preserveScroll: g.preserveScroll,
+			preserveState: g.preserveState,
+			queryStringArrayFormat: g.queryStringArrayFormat,
+			replace: g.replace
+		}), U = () => ({
+			activeClass: I.value,
+			ariaCurrentValue: g.ariaCurrentValue,
+			exactActiveClass: L.value,
+			...v ? { external: g.external } : {},
+			rel: z.value,
+			replace: g.replace,
+			target: g.target,
+			to: g.to
+		}), W = i(() => g.tag ?? "button"), G = i(() => W.value === "button" ? B() : {}), K = i(() => V()), q = i(() => U()), J = i(() => _ ? {
+			...K.value,
+			...H()
+		} : q.value);
+		return (e, n) => P.value ? (u(), a(t, l({
+			key: 0,
+			class: R.value
+		}, J.value), {
+			default: m(() => [d(e.$slots, "default", {}, () => [s(p(e.text), 1)])]),
+			_: 3
+		}, 16, ["class"])) : F.value ? (u(), o("a", l({
+			key: 1,
+			class: R.value
+		}, K.value), [d(e.$slots, "default", {}, () => [s(p(e.text), 1)])], 16)) : (u(), a(f(W.value), l({
+			key: 2,
+			class: R.value
+		}, G.value), {
+			default: m(() => [d(e.$slots, "default", {}, () => [s(p(e.text), 1)])]),
+			_: 3
+		}, 16, ["class"]));
+	}
+});
+//#endregion
+export { g as default };

package/dist/components/BbBaseButton/RouterComponent.vue.js

@@ -0,0 +1,5 @@
+import e from "./RouterComponent.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/BbBaseButton/RouterComponent.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/BbBaseButton/RouterComponent.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,29 @@
+import { useLogger as e } from "../../composables/useLogger.js";
+import { useFrameworkDetection as t } from "../../composables/useFrameworkDetection.js";
+import { config as n } from "virtual:bitboss-ui/config";
+import { createBlock as r, defineComponent as i, getCurrentInstance as a, openBlock as o, renderSlot as s, resolveComponent as c, resolveDynamicComponent as l, unref as u, withCtx as d } from "vue";
+import { InertiaLink as f } from "virtual:bitboss-ui/link";
+//#region src/components/BbBaseButton/RouterComponent.vue?vue&type=script&setup=true&lang.ts
+var p = /*@__PURE__*/ i({
+	__name: "RouterComponent",
+	setup(i) {
+		let { isInertia: p, isNuxt: m } = t(), h;
+		if (p) {
+			if (h = a()?.appContext.components?.[n.inertiaLinkName] ?? f, !h) {
+				let { warn: t } = e();
+				t(`Inertia link component "${n.inertiaLinkName}" could not be resolved, and "@inertiajs/vue3" is not installed in this app. Install it, register a link component globally under the name "${n.inertiaLinkName}", or set the bitboss-ui config key "inertiaLinkName" to the name you do register.`), h = n.inertiaLinkName;
+			}
+		} else if (m) {
+			if (h = c(n.nuxtLinkName), typeof h == "string") {
+				let { warn: t } = e();
+				t(`Nuxt link component "${n.nuxtLinkName}" could not be resolved. Ensure you app registers a link component with the name "${n.nuxtLinkName}" or set bitboss-ui config key "nuxtLinkName" to the correct value globally.`);
+			}
+		} else h = "router-link";
+		return (e, t) => (o(), r(l(u(h)), null, {
+			default: d(() => [s(e.$slots, "default")]),
+			_: 3
+		}));
+	}
+});
+//#endregion
+export { p as default };

package/dist/components/BbBaseButton/types.d.ts

@@ -0,0 +1,191 @@
+import { ButtonTag } from '../../types/CommonProps';
+import { RouteLocationRaw } from 'vue-router';
+export type BbBaseButtonProps = {
+    /**
+     * CSS class applied when the component renders as a link and the target of the link is the current route or the url matches partially.
+     * Ported for Inertia compatibility.
+     * @defaultValue `'router-link-active'`
+     */
+    activeClass?: string;
+    /**
+     * Value forwarded to the `aria-current` attribute when the component renders
+     * as a router link and the target route is an exact match.
+     *
+     * Use to communicate the current location to assistive technologies.
+     * @defaultValue `'page'`
+     */
+    ariaCurrentValue?: 'page' | 'step' | 'location' | 'date' | 'time' | 'true' | 'false';
+    /**
+     * Makes the component take the full available width (block-level layout).
+     * Adds the `bb-base-button--block` modifier class.
+     */
+    block?: boolean;
+    /**
+     * Request payload forwarded to Inertia when navigating via `href` in an
+     * Inertia-enabled app. Ignored when not using Inertia.
+     */
+    data?: object;
+    /**
+     * Disables user interaction.
+     *
+     * - When rendering as a native button, sets the `disabled` attribute.
+     * - When rendering as a link (anchor/Inertia), removes `href`, adds
+     *   `aria-disabled="true"`, and prevents navigation while keeping focusable
+     *   semantics consistent.
+     */
+    disabled?: boolean;
+    /**
+     * CSS class applied when the component renders as a link and the target of the link
+     * and the url matches exactly.
+     * Ported for Inertia compatibility.
+     * @defaultValue `'router-link-exact-active'`
+     */
+    exactActiveClass?: string;
+    /**
+     * Additional HTTP headers forwarded to Inertia when navigating via `href`
+     * in an Inertia-enabled app.
+     */
+    headers?: object;
+    /**
+     * Hyperlink reference used when rendering as an anchor (or as an Inertia
+     * link in Inertia-enabled apps). If provided and not disabled, the component
+     * renders as an anchor/Inertia link.
+     */
+    href?: HTMLAnchorElement['href'];
+    /**
+     * Marks an `href` link as a download. Renders a plain `<a download>` doing a
+     * native navigation — never an Inertia/router visit — so file downloads
+     * (including same-origin, `blob:` and `data:` URLs) work. Pass a string to
+     * set the suggested filename. One of the native-anchor signals alongside
+     * `target` and `external`.
+     */
+    download?: boolean | string;
+    /**
+     * Forces an `href` link to render as a plain `<a>` (native navigation),
+     * bypassing Inertia/router interception — the same intent as Nuxt's
+     * `NuxtLink` `external`. Use for links outside the SPA. One of the
+     * native-anchor signals alongside `target` and `download`.
+     */
+    external?: boolean;
+    /**
+     * HTTP method used for Inertia navigation when `href` is provided in an
+     * Inertia-enabled app. Ignored otherwise.
+     */
+    method?: 'get' | 'post' | 'put' | 'patch' | 'delete';
+    /**
+     * Lifecycle hook invoked by Inertia right before the request is sent.
+     */
+    onBefore?: () => void;
+    /**
+     * Lifecycle hook invoked by Inertia when a request is cancelled.
+     */
+    onCancel?: () => void;
+    /**
+     * Receives the Inertia cancel token source when a request is initiated.
+     * Can be used to cancel the request.
+     *
+     * Typed platform-agnostically (matching BbButton) so the library's types
+     * never require `@inertiajs/vue3` to be installed.
+     */
+    onCancelToken?: (cancelToken: unknown) => void;
+    /**
+     * Lifecycle hook invoked by Inertia after the request has finished
+     * (regardless of success or error).
+     */
+    onFinish?: () => void;
+    /**
+     * Limits the properties that are preserved in Inertia partial reloads.
+     */
+    only?: string[];
+    /**
+     * Progress callback invoked by Inertia with the upload/download percentage
+     * when available.
+     */
+    onProgress?: (progress: {
+        percentage: number | undefined;
+    }) => void;
+    /**
+     * Lifecycle hook invoked by Inertia when a request starts.
+     */
+    onStart?: () => void;
+    /**
+     * Lifecycle hook invoked by Inertia when a request succeeds.
+     */
+    onSuccess?: () => void;
+    /**
+     * Controls whether Inertia should preserve the current scroll position after
+     * navigation. Can be a boolean or a predicate receiving the visit props.
+     * @defaultValue `false`
+     */
+    preserveScroll?: boolean | ((props: Record<string, unknown>) => boolean);
+    /**
+     * Controls whether Inertia should preserve the current state after navigation.
+     * Can be a boolean or a predicate receiving the visit props.
+     * @defaultValue `false`
+     */
+    preserveState?: boolean | ((props: Record<string, unknown>) => boolean) | null;
+    /**
+     * Format to use when serializing array values into the query string for
+     * Inertia requests.
+     * @defaultValue `'brackets'`
+     */
+    queryStringArrayFormat?: 'brackets' | 'indices';
+    /**
+     * Uses history replacement instead of push navigation.
+     *
+     * - With Vue Router (`to`), calls `router.replace`.
+     * - With Inertia (`href`), performs a replace visit.
+     */
+    replace?: boolean;
+    /**
+     * Relationship between the current document and the linked resource.
+     * Useful for security when opening new tabs (e.g. `noopener noreferrer`).
+     */
+    rel?: HTMLAnchorElement['rel'];
+    /**
+     * Element to render for the plain (non-link, non-router) button:
+     *
+     * - `'button'` (default) — real button semantics and keyboard behavior
+     * - `'div'` / `'span'` — a clickable box nested inside another button or
+     *   link, where a nested `<button>` would be invalid markup
+     * - `'label'` — a file-upload trigger wrapping a visually hidden `<input>`
+     *
+     * Ignored when the component renders as a link/router (`href`/`to`) — those
+     * always render `<a>`/router-link. When set to a non-`button` tag the native
+     * `type`/`disabled` attributes are dropped (they're invalid off a
+     * `<button>`); disabled state is still conveyed via the
+     * `bb-base-button--disabled` class.
+     *
+     * @defaultValue `'button'`
+     */
+    tag?: ButtonTag;
+    /**
+     * Target browsing context for anchor/Inertia links (e.g. `_self`, `_blank`).
+     * Ignored when rendering as a native button.
+     */
+    target?: HTMLAnchorElement['target'];
+    /**
+     * Fallback text content rendered when no default slot is provided.
+     */
+    text?: string;
+    /**
+     * Route location to navigate to. When provided (and not disabled), the
+     * component renders as a Vue Router link.
+     */
+    to?: RouteLocationRaw;
+    /**
+     * Native `type` attribute used when rendering as a button (e.g. `button`,
+     * `submit`, `reset`).
+     *
+     * @defaultValue `'button'`
+     */
+    type?: HTMLButtonElement['type'];
+};
+export type BbBaseButtonSlots = {
+    /**
+     * Primary content rendered inside the button element. Falls back to the `text` prop when empty.
+     */
+    default?: (props: object) => any;
+};
+/** Runtime list of every {@link BbBaseButtonProps} key (kept exhaustive by the map above). */
+export declare const BB_BASE_BUTTON_PROP_KEYS: Array<keyof BbBaseButtonProps>;

package/dist/components/BbBaseButton/types.js

@@ -0,0 +1,33 @@
+var e = Object.keys({
+	activeClass: !0,
+	ariaCurrentValue: !0,
+	block: !0,
+	data: !0,
+	disabled: !0,
+	download: !0,
+	exactActiveClass: !0,
+	external: !0,
+	headers: !0,
+	href: !0,
+	method: !0,
+	onBefore: !0,
+	onCancel: !0,
+	onCancelToken: !0,
+	onFinish: !0,
+	only: !0,
+	onProgress: !0,
+	onStart: !0,
+	onSuccess: !0,
+	preserveScroll: !0,
+	preserveState: !0,
+	queryStringArrayFormat: !0,
+	replace: !0,
+	rel: !0,
+	tag: !0,
+	target: !0,
+	text: !0,
+	to: !0,
+	type: !0
+});
+//#endregion
+export { e as BB_BASE_BUTTON_PROP_KEYS };

package/dist/components/BbBaseCheckbox/BbBaseCheckbox.vue.d.ts

@@ -0,0 +1,40 @@
+import { BaseCheckboxProps, BaseCheckboxIconSlotProps } from './types';
+type __VLS_Slots = {
+    /**
+     * Replaces the default checkmark SVG rendered inside the checkbox box.
+     */
+    icon?: (props: BaseCheckboxIconSlotProps) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BaseCheckboxProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    input: (event: Event) => any;
+    "update:modelValue": (value: any) => any;
+    click: (event: MouseEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+    blur: (event: FocusEvent) => any;
+    change: (event: Event) => any;
+    focus: (event: FocusEvent) => any;
+    mousedown: (event: MouseEvent) => any;
+    mouseup: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<BaseCheckboxProps> & Readonly<{
+    onInput?: ((event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    onClick?: ((event: MouseEvent) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((event: Event) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onMousedown?: ((event: MouseEvent) => any) | undefined;
+    onMouseup?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    trueValue: any;
+    falseValue: any;
+    checked: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BbBaseCheckbox/BbBaseCheckbox.vue.js

@@ -0,0 +1,6 @@
+import e from "./BbBaseCheckbox.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                       */
+//#region src/components/BbBaseCheckbox/BbBaseCheckbox.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/components/BbBaseCheckbox/BbBaseCheckbox.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,145 @@
+import { isEqual as e } from "../../utilities/functions/isEqual.js";
+import t from "../BbBaseCheckboxIcon/BbBaseCheckboxIcon.vue.js";
+import { computed as n, createCommentVNode as r, createElementBlock as i, createElementVNode as a, createVNode as o, defineComponent as s, guardReactiveProps as c, mergeProps as l, normalizeClass as u, normalizeProps as d, openBlock as f, ref as p, renderSlot as m, watch as h } from "vue";
+//#region src/components/BbBaseCheckbox/BbBaseCheckbox.vue?vue&type=script&setup=true&lang.ts
+var g = /*@__PURE__*/ s({
+	__name: "BbBaseCheckbox",
+	props: {
+		ariaDescribedby: {},
+		autofocus: {},
+		checked: {
+			type: Boolean,
+			default: void 0
+		},
+		disabled: { type: Boolean },
+		falseValue: { default: !1 },
+		hasErrors: { type: Boolean },
+		hasWarning: { type: Boolean },
+		id: {},
+		indeterminate: { type: Boolean },
+		modelValue: {},
+		name: {},
+		readonly: { type: Boolean },
+		required: { type: Boolean },
+		submitWhenFalse: { type: Boolean },
+		trueValue: { default: !0 }
+	},
+	emits: [
+		"blur",
+		"change",
+		"click",
+		"focus",
+		"input",
+		"keydown",
+		"mousedown",
+		"mouseup",
+		"update:modelValue"
+	],
+	setup(s, { emit: g }) {
+		let _ = s, v = g, y = n(() => !!_.hasWarning && !_.hasErrors), b = p(null), x = n(() => _.checked === void 0 ? e(_.trueValue, _.modelValue) : _.checked), S = p(x.value), C = p(!1), w = p(!1), T = (e) => {
+			C.value = !1, w.value = !1, v("blur", e);
+		}, E = (e) => {
+			if (e.target instanceof HTMLInputElement) {
+				if (_.readonly) {
+					e.target.checked = S.value, b.value && (b.value.indeterminate = !!_.indeterminate);
+					return;
+				}
+				S.value = e.target.checked, b.value && (b.value.indeterminate = !!_.indeterminate);
+				let t = e.target.checked ? _.trueValue : _.falseValue;
+				v("change", e), v("update:modelValue", t);
+			}
+		}, D = (e) => {
+			C.value = !0, e.target instanceof HTMLInputElement && (w.value = e.target.matches(":focus-visible")), v("focus", e);
+		}, O = (e) => e === void 0 ? "" : typeof e == "string" ? e : JSON.stringify(e), k = n(() => {
+			let e = O(_.falseValue);
+			return {
+				disabled: _.disabled,
+				name: _.name,
+				type: "hidden",
+				value: e
+			};
+		}), A = {
+			onBlur: T,
+			onChange: E,
+			onFocus: D,
+			onClick: (e) => {
+				_.readonly && e.preventDefault(), v("click", e);
+			},
+			onInput: (e) => v("input", e),
+			onKeydown: (e) => {
+				_.readonly && (e.key === " " || e.key === "Spacebar" || e.key === "Enter") && e.preventDefault(), v("keydown", e);
+			},
+			onMousedown: (e) => v("mousedown", e),
+			onMouseup: (e) => v("mouseup", e)
+		}, j = n(() => {
+			let e = O(_.trueValue);
+			return {
+				"aria-describedby": _.ariaDescribedby,
+				autofocus: _.autofocus,
+				"aria-readonly": _.readonly ? !0 : void 0,
+				checked: S.value,
+				class: "sr-only",
+				disabled: _.disabled,
+				id: _.id,
+				indeterminate: _.indeterminate,
+				name: _.name,
+				required: _.readonly ? void 0 : _.required,
+				type: "checkbox",
+				value: e,
+				...A
+			};
+		}), M = n(() => ({
+			checked: S.value,
+			disabled: !!_.disabled,
+			falseValue: _.falseValue,
+			focused: C.value,
+			focusVisible: w.value,
+			hasErrors: !!_.hasErrors,
+			hasWarning: y.value,
+			id: _.id,
+			indeterminate: _.indeterminate,
+			name: _.name,
+			parsedValue: j.value.value,
+			readonly: !!_.readonly,
+			trueValue: _.trueValue,
+			value: S.value ? _.trueValue : _.falseValue
+		}));
+		return h([x, () => _.indeterminate], ([e, t]) => {
+			S.value = e, b.value && (b.value.indeterminate = !!t);
+		}), (e, n) => (f(), i("span", { class: u(["bb-base-checkbox", {
+			"bb-base-checkbox--checked": S.value,
+			"bb-base-checkbox--disabled": e.disabled,
+			"bb-base-checkbox--errors": e.hasErrors,
+			"bb-base-checkbox--warnings": y.value,
+			"bb-base-checkbox--focused": C.value,
+			"bb-base-checkbox--focus-visible": w.value,
+			"bb-base-checkbox--indeterminate": e.indeterminate,
+			"bb-base-checkbox--readonly": e.readonly
+		}]) }, [
+			!S.value && e.submitWhenFalse ? (f(), i("input", d(l({ key: 0 }, k.value)), null, 16)) : r("", !0),
+			a("input", l(j.value, {
+				ref_key: "checkboxInput",
+				ref: b
+			}), null, 16),
+			m(e.$slots, "icon", d(c(M.value)), () => [o(t, {
+				checked: S.value,
+				disabled: !!e.disabled,
+				"focus-visible": w.value,
+				"has-errors": !!e.hasErrors,
+				"has-warning": y.value,
+				indeterminate: !!e.indeterminate,
+				readonly: !!e.readonly
+			}, null, 8, [
+				"checked",
+				"disabled",
+				"focus-visible",
+				"has-errors",
+				"has-warning",
+				"indeterminate",
+				"readonly"
+			])])
+		], 2));
+	}
+});
+//#endregion
+export { g as default };