bitboss-ui 3.0.0-beta.5 → 3.0.0-beta.50

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

@@ -1,33 +0,0 @@
-import { BaseRadioProps, BaseRadioSlots } from './types';
-type __VLS_Slots = BaseRadioSlots;
-declare const __VLS_base: import('vue').DefineComponent<BaseRadioProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-    input: (event: Event) => any;
-    click: (event: MouseEvent) => any;
-    "update:modelValue": (value: any) => 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<BaseRadioProps> & Readonly<{
-    onInput?: ((event: Event) => any) | undefined;
-    onClick?: ((event: MouseEvent) => any) | undefined;
-    "onUpdate:modelValue"?: ((value: any) => 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;
-}>, {
-    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/BbBaseRadio/BbBaseRadio.vue_vue_type_script_setup_true_lang.js

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

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

@@ -1,179 +0,0 @@
-import { InputHTMLAttributes, HTMLAttributes } from 'vue';
-/**
- * Props for the base radio control that exposes a stylable icon slot while keeping native semantics.
- */
-export type BaseRadioProps = {
-    /**
-     * Id(s) of descriptive elements associated with the radio.
-     */
-    ariaDescribedby?: InputHTMLAttributes['aria-describedby'];
-    /**
-     * Focus the control automatically after mount.
-     */
-    autofocus?: InputHTMLAttributes['autofocus'];
-    /**
-     * Force the radio into a checked state regardless of `modelValue`.
-     */
-    checked?: boolean;
-    /**
-     * Disable the radio. When combined with `readonly`, the control is also disabled to mimic native behaviour.
-     */
-    disabled?: boolean;
-    /**
-     * Apply the error styling class.
-     */
-    hasErrors?: boolean;
-    /**
-     * Apply the warning styling class. Errors take priority when both are set.
-     */
-    hasWarning?: boolean;
-    /**
-     * Explicit id for the underlying input element.
-     */
-    id?: HTMLAttributes['id'];
-    /**
-     * Current v-model value used to determine checked state.
-     */
-    modelValue?: any;
-    /**
-     * Shared group name for the radio input (required to join options).
-     */
-    name: InputHTMLAttributes['name'];
-    /**
-     * Treat the radio as read-only. Implemented by disabling the input while preserving styling hooks.
-     */
-    readonly?: boolean;
-    /**
-     * Mark the radio as required within its group.
-     */
-    required?: boolean;
-    /**
-     * Value emitted when the radio becomes checked. Accepts any serializable value.
-     */
-    value: any;
-};
-export type BaseRadioEvents = {
-    /**
-     * Emitted when the native input loses focus.
-     * Forwards the original DOM `FocusEvent`.
-     */
-    (e: 'blur', event: FocusEvent): void;
-    /**
-     * Emitted when the radio selection changes.
-     * Forwards the original DOM `Event`.
-     */
-    (e: 'change', event: Event): void;
-    /**
-     * Emitted when the input receives a click interaction.
-     * Forwards the original DOM `MouseEvent`.
-     */
-    (e: 'click', event: MouseEvent): void;
-    /**
-     * Emitted when the native input gains focus.
-     * Forwards the original DOM `FocusEvent`.
-     */
-    (e: 'focus', event: FocusEvent): void;
-    /**
-     * Emitted on native input events from the radio input.
-     * Forwards the original DOM `Event`.
-     */
-    (e: 'input', event: Event): void;
-    /**
-     * Emitted for keyboard interaction on the input.
-     * Forwards the original DOM `KeyboardEvent`.
-     */
-    (e: 'keydown', event: KeyboardEvent): void;
-    /**
-     * Emitted when a pointing device button is pressed over the input.
-     * Forwards the original DOM `MouseEvent`.
-     */
-    (e: 'mousedown', event: MouseEvent): void;
-    /**
-     * Emitted when a pointing device button is released over the input.
-     * Forwards the original DOM `MouseEvent`.
-     */
-    (e: 'mouseup', event: MouseEvent): void;
-    /**
-     * Emitted when the radio becomes selected, carrying the radio's `value` prop.
-     */
-    (e: 'update:modelValue', value: any): void;
-};
-/**
- * Props exposed by the `icon` slot for custom radio visuals.
- *
- * These values are normalized at runtime so consumers receive stable types
- * (not optional/undefined booleans).
- */
-export type BaseRadioIconSlotProps = {
-    /**
-     * Whether the radio is currently selected.
-     */
-    checked: boolean;
-    /**
-     * Whether the radio is disabled.
-     * Mirrors `props.disabled`.
-     */
-    disabled: Exclude<BaseRadioProps['disabled'], undefined>;
-    /**
-     * Whether the native input currently has focus.
-     */
-    focused: boolean;
-    /**
-     * Whether focus is keyboard-visible (`:focus-visible`).
-     */
-    focusVisible: boolean;
-    /**
-     * Whether the radio is in an error state.
-     * Mirrors `props.hasErrors`.
-     */
-    hasErrors: Exclude<BaseRadioProps['hasErrors'], undefined>;
-    /**
-     * Whether the radio is in a warning state.
-     * Mirrors `props.hasWarning`, suppressed when `hasErrors` is true.
-     */
-    hasWarning: boolean;
-    /**
-     * The `id` attribute of the underlying input.
-     * Mirrors `props.id`.
-     */
-    id: BaseRadioProps['id'];
-    /**
-     * The `name` attribute of the underlying input.
-     * Mirrors `props.name`.
-     */
-    name: BaseRadioProps['name'];
-    /**
-     * The radio value serialized to a string for form submission.
-     */
-    parsedValue: string;
-    /**
-     * Whether the radio is read-only.
-     * Mirrors `props.readonly`.
-     */
-    readonly: BaseRadioProps['readonly'];
-    /**
-     * The effective value of this radio option (the `value` prop).
-     */
-    value: any;
-};
-export type BaseRadioSlots = {
-    /**
-     * Replaces the default radio dot visual rendered inside the radio container.
-     * @param checked - Whether the radio is currently selected.
-     * @param disabled - Whether the radio is disabled.
-     * @param focused - Whether the radio input currently has focus.
-     * @param focusVisible - Whether focus is keyboard-visible (`:focus-visible`).
-     * @param hasErrors - Whether the radio is in an error state.
-     * @param hasWarning - Whether the radio is in a warning state.
-     * @param id - The `id` attribute of the underlying input.
-     * @param name - The `name` attribute of the underlying input.
-     * @param parsedValue - The radio value serialized to a string for form submission.
-     * @param readonly - Whether the radio is read-only.
-     * @param value - The current effective value of this radio option.
-     */
-    icon?: (props: BaseRadioIconSlotProps) => any;
-};
-/**
- * @deprecated Use `BaseRadioIconSlotProps`.
- */
-export type SlotAttributes = BaseRadioIconSlotProps;

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

@@ -1,19 +0,0 @@
-import { BaseRadioGroupProps, BaseRadioGroupEvents, BaseRadioGroupSlots } from './types';
-declare const __VLS_export: <T = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<BaseRadioGroupProps<T> & __VLS_EmitsToProps<__VLS_NormalizeEmits<BaseRadioGroupEvents>>> & import('vue').PublicProps & (typeof globalThis extends {
-        __VLS_PROPS_FALLBACK: infer P;
-    } ? P : {});
-    expose: (exposed: {}) => void;
-    attrs: any;
-    slots: BaseRadioGroupSlots<T>;
-    emit: BaseRadioGroupEvents;
-}>) => import('vue').VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
-};
-declare const _default: typeof __VLS_export;
-export default _default;
-type __VLS_PrettifyLocal<T> = (T extends any ? {
-    [K in keyof T]: T[K];
-} : {
-    [K in keyof T as K]: T[K];
-}) & {};

package/dist/components/BbBaseRadioGroup/BbBaseRadioGroup.vue_vue_type_script_setup_true_lang.js

@@ -1,179 +0,0 @@
-import { useItemsGetter as e } from "../../composables/useItemsGetter.js";
-import { hash as t } from "../../utilities/functions/hash.js";
-import { useHashedWatcher as n } from "../../composables/useHashedWatcher.js";
-import r from "../OptionsContainer/OptionsContainer.vue.js";
-import { useIndexById as i } from "../../composables/useIndexById.js";
-import { useBaseOptions as a } from "../../composables/useBaseOptions.js";
-import { useCoherence as o } from "../../composables/useCoherence.js";
-import { usePrefill as s } from "../../composables/usePrefill.js";
-import { useActiveInactiveState as c } from "../../composables/useActiveInactiveState.js";
-import { useOnFalsy as l } from "../../composables/useOnFalsy.js";
-import { useOnTruthy as u } from "../../composables/useOnTruthy.js";
-import d from "../BbBaseRadio/BbBaseRadio.vue.js";
-import { computed as f, createBlock as p, createSlots as m, createVNode as h, defineComponent as g, guardReactiveProps as _, mergeProps as v, normalizeProps as y, openBlock as b, renderSlot as x, toRef as S, unref as C, useAttrs as w, useTemplateRef as T, withCtx as E } from "vue";
-//#region src/components/BbBaseRadioGroup/BbBaseRadioGroup.vue?vue&type=script&setup=true&lang.ts
-var D = /*@__PURE__*/ g({
-	__name: "BbBaseRadioGroup",
-	props: {
-		ariaDescribedby: {},
-		ariaLabelledby: {},
-		autofocus: {},
-		dependencies: {},
-		depsDebounceTime: { default: 0 },
-		direction: { default: "horizontal" },
-		disabled: { type: Boolean },
-		enforceCoherence: { type: Boolean },
-		hasErrors: { type: Boolean },
-		hasWarning: { type: Boolean },
-		hideLabel: { type: Boolean },
-		id: {},
-		items: {
-			type: [Array, Function],
-			default: () => []
-		},
-		itemText: {},
-		itemValue: {},
-		loadingText: {},
-		modelValue: {},
-		modelValueDebounceTime: { default: 0 },
-		name: {},
-		noDataText: {},
-		readonly: { type: Boolean },
-		required: { type: Boolean },
-		selectable: {
-			type: [Boolean, Function],
-			default: !0
-		}
-	},
-	emits: [
-		"blur",
-		"change",
-		"click",
-		"focus",
-		"inactive",
-		"active",
-		"input",
-		"keydown",
-		"mousedown",
-		"mouseup",
-		"update:modelValue"
-	],
-	setup(g, { emit: D }) {
-		let O = g, k = D, A = w(), j = f(() => O.ariaLabelledby || A["aria-labelledby"] || A["aria-label"] ? "radiogroup" : void 0), M = T("container"), { active: N } = c(M);
-		l(N, () => k("inactive")), u(N, () => k("active"));
-		let { getter: P, items: F, loading: I } = e({ items: S(O, "items") }), L = () => {
-			O.enforceCoherence && !H.value && k("update:modelValue", null);
-		}, { hasPrefilled: R } = s({
-			trigger: !0,
-			currentValue: O.modelValue,
-			multiple: !1,
-			fn: async (e) => {
-				await P(e, O.modelValue), L();
-			}
-		}), { data: z } = i({ items: f(() => [].concat(O.modelValue)) }), { options: B } = a({
-			disabled: S(O, "disabled"),
-			items: F,
-			itemText: O.itemText,
-			itemValue: O.itemValue,
-			max: Infinity,
-			selectable: S(O, "selectable"),
-			selectedIndexedByHash: z
-		}), { data: V } = i({
-			items: B,
-			key: "valueHash"
-		}), { coherent: H } = o({
-			modelValue: S(O, "modelValue"),
-			multiple: !1,
-			iteratee: (e) => !!V.value[t(e)]
-		}), U = 0;
-		n(() => O.modelValue, async () => {
-			U++, H.value || (await P(!0, O.modelValue), L()), U--;
-		}, { debounce: O.modelValueDebounceTime }), n(() => [O.dependencies, O.items], async () => {
-			R.value && (U++, await P(!0, O.modelValue), U === 1 && L(), U--);
-		}, { debounce: O.depsDebounceTime });
-		let W = (e) => {
-			if (O.id) return [O.id, e.valueHash].filter(Boolean).join("-");
-		}, G = {
-			onBlur: (e) => k("blur", e),
-			onChange: (e) => k("change", e),
-			onClick: (e) => k("click", e),
-			onFocus: (e) => k("focus", e),
-			onInput: (e) => k("input", e),
-			onKeydown: (e) => k("keydown", e),
-			onMousedown: (e) => k("mousedown", e),
-			onMouseup: (e) => k("mouseup", e),
-			"onUpdate:modelValue": (e) => k("update:modelValue", e)
-		};
-		return (e, t) => (b(), p(r, {
-			ref_key: "container",
-			ref: M,
-			"aria-labelledby": e.ariaLabelledby,
-			"aria-readonly": j.value && e.readonly ? !0 : void 0,
-			"class-prefix": "bb-base-radio-group",
-			direction: e.direction,
-			"has-errors": e.hasErrors,
-			"has-warning": e.hasWarning,
-			"hide-label": e.hideLabel,
-			loading: !!C(I),
-			"loading-text": e.loadingText,
-			"no-data-text": e.noDataText,
-			options: C(B),
-			role: j.value
-		}, {
-			prepend: E(() => [x(e.$slots, "prepend")]),
-			loading: E(() => [x(e.$slots, "loading")]),
-			"no-data": E(() => [x(e.$slots, "no-data")]),
-			label: E((t) => [x(e.$slots, "label", y(_(t)))]),
-			input: E(({ option: t, index: n }) => [h(d, v({
-				id: W(t),
-				"aria-describedby": e.ariaDescribedby,
-				autofocus: e.autofocus && !n,
-				checked: t.selected,
-				disabled: t.disabled,
-				"has-errors": e.hasErrors,
-				"has-warning": e.hasWarning,
-				"model-value": O.modelValue,
-				name: e.name,
-				readonly: e.readonly,
-				required: e.required,
-				value: t.value
-			}, G), m({ _: 2 }, [e.$slots.icon ? {
-				name: "icon",
-				fn: E((n) => [x(e.$slots, "icon", v({
-					item: t.item,
-					text: t.text
-				}, n))]),
-				key: "0"
-			} : void 0]), 1040, [
-				"id",
-				"aria-describedby",
-				"autofocus",
-				"checked",
-				"disabled",
-				"has-errors",
-				"has-warning",
-				"model-value",
-				"name",
-				"readonly",
-				"required",
-				"value"
-			])]),
-			append: E(() => [x(e.$slots, "append")]),
-			_: 3
-		}, 8, [
-			"aria-labelledby",
-			"aria-readonly",
-			"direction",
-			"has-errors",
-			"has-warning",
-			"hide-label",
-			"loading",
-			"loading-text",
-			"no-data-text",
-			"options",
-			"role"
-		]));
-	}
-});
-//#endregion
-export { D as default };