bitboss-ui 2.1.134 → 3.0.0-alpha.1

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

@@ -0,0 +1,211 @@
+import { HTMLAttributes, InputHTMLAttributes } from 'vue';
+import { IconType } from '../../types/Icon';
+/**
+ * Props for the low-level number input with manual parsing, clamping, and increment/decrement helpers.
+ */
+export type BaseNumberInputProps = {
+    /**
+     * Name of the icon to render at the right hand side of the input.
+     */
+    'append:icon'?: IconType;
+    /**
+     * Id(s) of descriptive elements announced by screen readers.
+     */
+    ariaDescribedby?: InputHTMLAttributes['aria-describedby'];
+    /**
+     * Browser autocomplete hint for the field.
+     * @defaultValue `'off'`
+     */
+    autocomplete?: InputHTMLAttributes['autocomplete'];
+    /**
+     * Focus the input automatically after mount.
+     */
+    autofocus?: InputHTMLAttributes['autofocus'];
+    /**
+     * Show a clear button whenever a value is present and the control is interactive.
+     */
+    clearable?: boolean;
+    /**
+     * Apply the compact density variant.
+     */
+    compact?: boolean;
+    /**
+     * Disable manual input and the exposed increase/decrease helpers.
+     */
+    disabled?: boolean;
+    /**
+     * Force the error state; also toggles `aria-invalid`.
+     */
+    hasErrors?: boolean;
+    /**
+     * Apply warning styling (same chrome as errors, `--bb-warn` color).
+     * Suppressed when `hasErrors` is also set.
+     */
+    hasWarning?: boolean;
+    /**
+     * Explicit id forwarded to the native input.
+     */
+    id?: HTMLAttributes['id'];
+    /**
+     * Display the loading state styles.
+     */
+    loading?: boolean;
+    /**
+     * Upper bound for clamping user input and helper increments.
+     * @defaultValue `Number.MAX_SAFE_INTEGER`
+     */
+    max?: number;
+    /**
+     * Maximum number of decimal digits retained after processing.
+     * @defaultValue `8`
+     */
+    maxPrecision?: number;
+    /**
+     * Lower bound for clamping user input and helper decrements.
+     * @defaultValue `Number.MIN_SAFE_INTEGER`
+     */
+    min?: number;
+    /**
+     * v-model value. Accepts numbers, numeric strings, or null when empty.
+     */
+    modelValue: number | string | null;
+    /**
+     * Name attribute forwarded to the native input.
+     */
+    name?: InputHTMLAttributes['name'];
+    /**
+     * Placeholder text when no value is present.
+     */
+    placeholder?: InputHTMLAttributes['placeholder'];
+    /**
+     * Name of the icon to render at the left hand side of the input.
+     */
+    'prepend:icon'?: IconType;
+    /**
+     * Make the input read-only while keeping its value visible.
+     */
+    readonly?: boolean;
+    /**
+     * Mark the input as required for form validation.
+     */
+    required?: boolean;
+    /**
+     * Increment used by the `increase`/`decrease` helpers. Manual typing is never forced to this step.
+     * @defaultValue `1`
+     */
+    step?: number;
+};
+export type BaseNumberInputEvents = {
+    /**
+     * Emitted when the native input loses focus.
+     * Forwards the original DOM `FocusEvent`.
+     */
+    (e: 'blur', event: FocusEvent): void;
+    /**
+     * Emitted when the native input fires a change event.
+     * 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 a composition session ends (e.g. CJK IME confirmed).
+     * Forwards the original DOM `CompositionEvent`.
+     */
+    (e: 'compositionend', event: CompositionEvent): void;
+    /**
+     * Emitted when a composition session starts (e.g. CJK IME begins).
+     * Forwards the original DOM `CompositionEvent`.
+     */
+    (e: 'compositionstart', event: CompositionEvent): void;
+    /**
+     * Emitted by the `decrease` helper with the clamped value after decrementing by one `step`.
+     */
+    (e: 'decrease', value: number): void;
+    /**
+     * Emitted when the native input gains focus.
+     * Forwards the original DOM `FocusEvent`.
+     */
+    (e: 'focus', event: FocusEvent): void;
+    /**
+     * Emitted by the `increase` helper with the clamped value after incrementing by one `step`.
+     */
+    (e: 'increase', value: number): void;
+    /**
+     * Emitted on native input events from the number 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 key is released over the input.
+     * Forwards the original DOM `KeyboardEvent`.
+     */
+    (e: 'keyup', 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 content is pasted into the input.
+     * Forwards the original DOM `ClipboardEvent`.
+     */
+    (e: 'paste', event: ClipboardEvent): void;
+    /**
+     * Emitted on any value change with the parsed number or `null` when the field is empty.
+     */
+    (e: 'update:modelValue', value: number | null): void;
+};
+/**
+ * Props exposed by the step control slots (`append`, `append-outer`, `prepend`, `prepend-outer`).
+ */
+export type BaseNumberInputStepSlotProps = {
+    /**
+     * Increments the value by one `step`.
+     */
+    increase: () => void;
+    /**
+     * Decrements the value by one `step`.
+     */
+    decrease: () => void;
+};
+export type BaseNumberInputSlots = {
+    /**
+     * Inline content rendered at the start of the input field area, before the typed number.
+     */
+    prefix?: (props: BaseNumberInputStepSlotProps) => any;
+    /**
+     * Content rendered after the number input, at the end of the inner container.
+     * Typically used to place increment/decrement buttons next to the input.
+     */
+    append?: (props: BaseNumberInputStepSlotProps) => any;
+    /**
+     * Content rendered after the entire input control, outside the input chrome.
+     */
+    'append-outer'?: (props: BaseNumberInputStepSlotProps) => any;
+    /**
+     * Content rendered before the number input, at the start of the inner container.
+     */
+    prepend?: (props: BaseNumberInputStepSlotProps) => any;
+    /**
+     * Content rendered before the entire input control, outside the input chrome.
+     */
+    'prepend-outer'?: (props: BaseNumberInputStepSlotProps) => any;
+    /**
+     * Inline content rendered at the end of the input field area, after the typed number.
+     */
+    suffix?: (props: BaseNumberInputStepSlotProps) => any;
+};

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

@@ -0,0 +1,33 @@
+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;
+    "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<BaseRadioProps> & 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;
+}>, {
+    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.js

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

package/dist/components/BbBaseRadio/BbBaseRadio.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,114 @@
+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,
+				"aria-readonly": h.readonly ? !0 : void 0,
+				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

@@ -0,0 +1,179 @@
+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

@@ -0,0 +1,19 @@
+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.js

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