bitboss-ui 2.1.134 → 3.0.0-alpha.1

package/dist/components/BbDatePicker/BbDatePicker.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,319 @@
+import { useId as e } from "../../composables/useId.js";
+import { extractDomContainer as t } from "../../utilities/functions/extractDomContainer.js";
+import { transitions as n } from "../../utilities/misc/transitions.js";
+import r from "../CommonPopover/CommonPopover.vue.js";
+import { useMobile as i } from "../../composables/useMobile.js";
+import { useLocale as a } from "../../composables/useLocale.js";
+import o from "../BbOffCanvas/BbOffCanvas.vue.js";
+import { toInnerValue as s, toOuterValue as ee } from "../../utilities/functions/convertDateValue.js";
+import te from "../BbBaseDatePicker/BbBaseDatePicker.vue.js";
+import c from "../BbBaseDatePickerInput/BbBaseDatePickerTimeSelector.vue.js";
+import { config as ne } from "virtual:bitboss-ui/config";
+import { Fragment as re, computed as l, createBlock as u, createCommentVNode as d, createElementBlock as ie, createElementVNode as f, createVNode as p, defineComponent as m, guardReactiveProps as h, mergeProps as g, nextTick as ae, normalizeClass as oe, normalizeProps as _, normalizeStyle as se, onBeforeUnmount as ce, openBlock as v, ref as y, renderSlot as b, unref as x, watch as S, withCtx as C } from "vue";
+import { createReusableTemplate as le } from "@vueuse/core";
+//#region src/components/BbDatePicker/BbDatePicker.vue?vue&type=script&setup=true&lang.ts
+var w = /*@__PURE__*/ m({
+	__name: "BbDatePicker",
+	props: {
+		activator: {},
+		anchor: {},
+		modelValue: {},
+		time: {},
+		activeSegment: {},
+		datetime: { type: Boolean },
+		range: { type: Boolean },
+		seconds: { type: Boolean },
+		ampm: { type: Boolean },
+		step: {},
+		min: {},
+		max: {},
+		selectable: {},
+		floating: { type: Boolean },
+		firstDayOfWeek: {},
+		utc: { type: Boolean },
+		disabled: { type: Boolean },
+		readonly: { type: Boolean },
+		adaptive: {
+			type: Boolean,
+			default: void 0
+		},
+		offCanvasProps: {},
+		transitionDuration: { default: n.medium },
+		placement: {},
+		offset: { default: 4 },
+		padding: {},
+		boundary: {},
+		disableFlip: { type: Boolean },
+		eager: { type: Boolean },
+		label: {}
+	},
+	emits: [
+		"update:modelValue",
+		"update:time",
+		"update:activeSegment",
+		"grid-pick",
+		"time-pick"
+	],
+	setup(n, { expose: m, emit: w }) {
+		let T = n, E = w, { t: ue } = a(), { isMobile: D } = i(), de = `bdp-${e().id.value}`, [fe, O] = le(), k = y(null), A = y(null), j = l(() => T.activeSegment ?? M.value), M = y("start"), pe = (e) => {
+			M.value = e, E("update:activeSegment", e);
+		}, N = y(), P = y(), me = l(() => T.activator != null), he = (e) => {
+			N.value = t(e) ?? void 0;
+		}, F = (e) => {
+			P.value = t(e) ?? void 0;
+		};
+		S(() => T.activator, (e) => {
+			N.value = t(e) ?? void 0;
+		}, { immediate: !0 }), S(() => T.anchor, (e) => {
+			P.value = e == null ? void 0 : t(e) ?? void 0;
+		}, { immediate: !0 });
+		let I = l(() => P.value ?? N.value), L = y(!1), R = null, z = (e) => {
+			T.disabled || T.readonly || (e.stopPropagation(), L.value = !L.value);
+		}, B = (e) => {
+			e.target instanceof HTMLDialogElement && (L.value = !1);
+		};
+		S(L, async (e) => {
+			e ? (R = document.activeElement instanceof HTMLElement ? document.activeElement : null, G.value || document.addEventListener("click", B, { passive: !0 }), await ae(), k.value?.querySelector("[tabindex=\"0\"]")?.focus()) : (document.removeEventListener("click", B), A.value?.resetStatus(), R?.focus(), R = null);
+		});
+		let V = null;
+		S(N, (e) => {
+			V?.(), V = null, e && (e.addEventListener("click", z), V = () => {
+				e.removeEventListener("click", z), e.removeAttribute("aria-haspopup"), e.removeAttribute("aria-expanded"), e.removeAttribute("aria-label");
+			});
+		}, { immediate: !0 });
+		let H = l(() => T.label ?? ue("datePicker.openPicker").value);
+		S([
+			N,
+			L,
+			H
+		], ([e, t, n]) => {
+			e && (e.setAttribute("aria-haspopup", "dialog"), e.setAttribute("aria-expanded", t ? "true" : "false"), e.setAttribute("aria-label", n));
+		}, { immediate: !0 }), ce(() => {
+			V?.(), document.removeEventListener("click", B);
+		});
+		let U = () => (T.adaptive ?? ne.adaptive) && D.value ? "canvas" : "popover", W = y(U()), G = l(() => W.value === "canvas");
+		S([
+			() => T.adaptive,
+			D,
+			L
+		], () => {
+			L.value || (W.value = U());
+		});
+		let ge = l(() => ({
+			side: "bottom",
+			size: "auto",
+			draggable: !0,
+			disabled: T.disabled,
+			transitionDuration: T.transitionDuration,
+			...T.offCanvasProps
+		})), _e = () => {
+			N.value?.focus();
+		}, ve = l(() => T.min?.slice(0, 10)), K = l(() => T.max?.slice(0, 10)), ye = l(() => T.range && !Array.isArray(T.modelValue) ? [] : T.modelValue), be = (e) => T.range ? Array.isArray(e) && e.length === 2 : !!e, q = (e) => +(e === "end"), J = (e) => {
+			let t = T.modelValue;
+			return t == null ? null : Array.isArray(t) ? t[q(e)] ?? null : e === "start" ? t : null;
+		}, xe = (e) => {
+			let t = T.time;
+			if (t != null) {
+				if (Array.isArray(t)) return t[q(e)] ?? null;
+				if (e === "start" && typeof t == "string") return t;
+			}
+			if (T.floating) return null;
+			let n = J(e);
+			if (!n) return null;
+			let r = s(n);
+			return r.isValid() ? r.format(T.seconds ? "HH:mm:ss" : "HH:mm") : null;
+		}, Y = (e) => {
+			let t = xe(e);
+			if (!t) return null;
+			let [n = "", r = "", i = ""] = t.split(":");
+			return {
+				hour: n,
+				minute: r,
+				second: i
+			};
+		}, X = (e, t) => {
+			let n = s(e, { floating: T.floating });
+			if (!n.isValid()) return null;
+			let r = t?.hour ? parseInt(t.hour, 10) : 0, i = t?.minute ? parseInt(t.minute, 10) : 0, a = T.seconds && t?.second ? parseInt(t.second, 10) : 0, o = n.hour(r).minute(i).second(a).millisecond(0);
+			return {
+				value: ee(o, {
+					floating: T.floating,
+					utc: T.utc
+				}),
+				time: T.seconds ? o.format("HH:mm:ss") : o.format("HH:mm")
+			};
+		}, Z = () => ({
+			start: {
+				date: J("start"),
+				time: Y("start")
+			},
+			end: {
+				date: J("end"),
+				time: Y("end")
+			}
+		}), Q = (e) => {
+			if (T.range) {
+				let t = [], n = [];
+				for (let r of ["start", "end"]) {
+					let i = e[r];
+					if (!i.date) continue;
+					let a = X(i.date, i.time);
+					a && (t.push(a.value), n.push(a.time));
+				}
+				E("update:modelValue", t.length ? t : null), E("update:time", n.length ? n : null);
+				return;
+			}
+			let t = e.start;
+			if (!t.date) {
+				E("update:modelValue", null), E("update:time", null);
+				return;
+			}
+			let n = X(t.date, t.time);
+			E("update:modelValue", n ? n.value : null), E("update:time", n ? n.time : null);
+		}, Se = (e) => {
+			if (E("grid-pick", e), !T.datetime) {
+				E("update:modelValue", e), be(e) && (L.value = !1);
+				return;
+			}
+			if (e === null) {
+				E("update:modelValue", null), E("update:time", null);
+				return;
+			}
+			let t = Z();
+			Array.isArray(e) ? (t.start.date = e[0] ?? null, t.end.date = e[1] ?? null, e[1] || (t.end.time = null)) : t.start.date = e, Q(t);
+		}, Ce = l(() => !!J(j.value)), $ = l(() => Y(j.value)), we = l(() => $.value?.hour ?? ""), Te = l(() => $.value?.minute ?? ""), Ee = l(() => $.value?.second ?? ""), De = l(() => ""), Oe = (e) => {
+			if (E("time-pick", e), !T.datetime) return;
+			let t = j.value, n = Z();
+			if (!n[t].date) return;
+			let r = n[t].time ? { ...n[t].time } : {
+				hour: "",
+				minute: "",
+				second: ""
+			};
+			if (e.unit === "meridiem") {
+				let t = r.hour ? parseInt(r.hour, 10) : 0, n = e.value === "PM";
+				n && t < 12 && (t += 12), !n && t >= 12 && (t -= 12), r.hour = String(t).padStart(2, "0");
+			} else r[e.unit] = e.value;
+			r.hour ||= "00", r.minute ||= "00", T.seconds && !r.second && (r.second = "00"), n[t].time = r, Q(n);
+		}, ke = l(() => {
+			if (!T.datetime) return;
+			let e = [44, 44];
+			return T.seconds && e.push(44), T.ampm && e.push(48), { "--rail-w": `${33 + e.reduce((e, t) => e + t, 0) + (e.length - 1) * 6}px` };
+		});
+		return S(() => T.modelValue, (e) => {
+			!T.range || !T.datetime || T.activeSegment != null || Array.isArray(e) && e.length === 2 && pe("end");
+		}), m({ calendarEl: k }), (e, t) => (v(), ie(re, null, [
+			me.value ? d("", !0) : b(e.$slots, "activator", _(g({ key: 0 }, {
+				props: { ref: he },
+				anchorProps: { ref: F },
+				open: L.value,
+				value: e.modelValue,
+				disabled: !!e.disabled
+			}))),
+			p(x(fe), null, {
+				default: C(() => [f("div", {
+					ref_key: "calendarRef",
+					ref: k,
+					class: oe(["bb-date-picker__calendar", {
+						"bb-date-picker__calendar--datetime": e.datetime,
+						"bb-date-picker__calendar--sheet": G.value
+					}]),
+					style: se(ke.value)
+				}, [p(te, {
+					id: de,
+					ref_key: "gridRef",
+					ref: A,
+					disabled: e.disabled,
+					"first-day-of-week": e.firstDayOfWeek,
+					floating: e.floating,
+					header: "",
+					max: K.value,
+					min: ve.value,
+					"model-value": ye.value,
+					range: e.range,
+					readonly: e.readonly,
+					selectable: e.selectable,
+					utc: e.utc,
+					"onUpdate:modelValue": Se
+				}, {
+					day: C((t) => [b(e.$slots, "day", _(h(t)))]),
+					"append:day": C((t) => [b(e.$slots, "append:day", _(h(t)))]),
+					_: 3
+				}, 8, [
+					"disabled",
+					"first-day-of-week",
+					"floating",
+					"max",
+					"min",
+					"model-value",
+					"range",
+					"readonly",
+					"selectable",
+					"utc"
+				]), e.datetime ? (v(), u(c, {
+					key: 0,
+					ampm: e.ampm,
+					disabled: e.disabled || e.readonly || !Ce.value,
+					hour: we.value,
+					meridiem: De.value,
+					minute: Te.value,
+					second: Ee.value,
+					seconds: e.seconds,
+					step: e.step,
+					onSelect: Oe
+				}, null, 8, [
+					"ampm",
+					"disabled",
+					"hour",
+					"meridiem",
+					"minute",
+					"second",
+					"seconds",
+					"step"
+				])) : d("", !0)], 6)]),
+				_: 3
+			}),
+			G.value ? (v(), u(o, g({
+				key: 1,
+				modelValue: L.value,
+				"onUpdate:modelValue": t[0] ||= (e) => L.value = e,
+				class: "bb-date-picker-offcanvas"
+			}, ge.value, { onHidden: _e }), {
+				default: C(() => [p(x(O))]),
+				_: 1
+			}, 16, ["modelValue"])) : (v(), u(r, {
+				key: 2,
+				modelValue: L.value,
+				"onUpdate:modelValue": t[1] ||= (e) => L.value = e,
+				anchor: I.value,
+				"aria-label": H.value,
+				boundary: e.boundary,
+				class: "bb-date-picker__popover",
+				dialog: "",
+				"disable-flip": e.disableFlip,
+				eager: e.eager,
+				"hide-arrow": "",
+				offset: e.offset,
+				padding: e.padding,
+				placement: e.placement,
+				"transition-duration": e.transitionDuration
+			}, {
+				default: C(() => [p(x(O))]),
+				_: 1
+			}, 8, [
+				"modelValue",
+				"anchor",
+				"aria-label",
+				"boundary",
+				"disable-flip",
+				"eager",
+				"offset",
+				"padding",
+				"placement",
+				"transition-duration"
+			]))
+		], 64));
+	}
+});
+//#endregion
+export { w as default };

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

@@ -0,0 +1,155 @@
+import { ElementOrComponentRef, ElementOrComponentRefOrSelector } from '../../types/CommonProps';
+import { Placement } from '../../types/Placement';
+import { BbOffCanvasProps } from '../BbOffCanvas/types';
+import { TimeUnit } from '../BbBaseDatePickerInput/BbBaseDatePickerTimeSelector.vue';
+/** Which end of a range the time rail edits. */
+export type BbDatePickerSegment = 'start' | 'end';
+export type BbDatePickerProps = {
+    /**
+     * External activator element or component ref. When provided, the `activator`
+     * slot is not rendered and click + ARIA are attached programmatically to the
+     * referenced element — mirroring the `BbColorPalette` activator API.
+     */
+    activator?: ElementOrComponentRef;
+    /**
+     * Element or component ref the popover positions itself relative to.
+     * Defaults to the activator when omitted (anchor to a larger row while a
+     * smaller element stays the click target).
+     */
+    anchor?: ElementOrComponentRef;
+    /**
+     * v-model value. `null` for empty, a single ISO string for single selection,
+     * or a two-element `[start, end]` array when `range` is true. Plain
+     * `YYYY-MM-DD` when `floating`; carries the time inline when
+     * `datetime && !floating`.
+     */
+    modelValue: string | string[] | null;
+    /**
+     * Companion time model (`v-model:time`), 24-hour `HH:mm` / `HH:mm:ss`.
+     * With `floating` it is the only carrier of the time; otherwise it mirrors
+     * the time inside `modelValue`. Requires `datetime`.
+     */
+    time?: string | string[] | null;
+    /**
+     * Which end the time rail edits in range + datetime (`v-model:active-segment`).
+     * Standalone use manages this internally; an embedding host (the date input)
+     * drives it from its focused field. Ignored outside range + datetime.
+     */
+    activeSegment?: BbDatePickerSegment;
+    /**
+     * Adds a time rail beside the calendar. Non-floating values carry the time
+     * inside `modelValue`; with `floating` the time travels only through `time`.
+     */
+    datetime?: boolean;
+    /** Enables range selection (`[start, end]`). */
+    range?: boolean;
+    /** Adds the seconds column (requires `datetime`). */
+    seconds?: boolean;
+    /** 12-hour display with an AM/PM column (requires `datetime`); emits stay 24h. */
+    ampm?: boolean;
+    /**
+     * Minute-column granularity and arrow stepping (requires `datetime`).
+     * @defaultValue `1`
+     */
+    step?: number;
+    /** Minimum selectable date, `YYYY-MM-DD` (or `YYYY-MM-DDTHH:mm` with `datetime`). */
+    min?: string;
+    /** Maximum selectable date, `YYYY-MM-DD` (or `YYYY-MM-DDTHH:mm` with `datetime`). */
+    max?: string;
+    /** Predicate invoked per candidate date; return `false` to disable it. */
+    selectable?: (date: string) => boolean;
+    /** Emit dates as plain `YYYY-MM-DD` instead of zoned ISO strings. */
+    floating?: boolean;
+    /** First day of the week (0 = Sunday … 6 = Saturday). */
+    firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    /** Emit UTC (`...Z`) instead of the local offset. Ignored with `floating`. */
+    utc?: boolean;
+    /** Disables the activator and the calendar. */
+    disabled?: boolean;
+    /** Prevents opening while keeping the activator visible. */
+    readonly?: boolean;
+    /**
+     * On mobile, open in a bottom off-canvas sheet instead of a floating popover.
+     * When unset, falls back to the global `config.adaptive`.
+     * @defaultValue `config.adaptive` (`true`)
+     */
+    adaptive?: boolean;
+    /** Extra props forwarded to the `BbOffCanvas` sheet when adaptive on mobile. */
+    offCanvasProps?: Partial<BbOffCanvasProps>;
+    /** Popover/sheet transition duration in milliseconds. */
+    transitionDuration?: number;
+    /** Position of the popover relative to the activator/anchor. */
+    placement?: Placement;
+    /**
+     * Space the popover keeps from the activator.
+     * @defaultValue `4`
+     */
+    offset?: number;
+    /** Minimum empty space to keep from the edge of the page. */
+    padding?: number;
+    /** Constrains the popover within a bounding element or CSS selector. */
+    boundary?: ElementOrComponentRefOrSelector;
+    /** Disable the automatic flip to the opposite side on overflow. */
+    disableFlip?: boolean;
+    /** Render popover content before it is first shown. */
+    eager?: boolean;
+    /** Accessible label applied to the activator via `aria-label`. */
+    label?: string;
+};
+export type BbDatePickerEvents = {
+    /** Emitted when the selected date value changes (single/range/null). */
+    (e: 'update:modelValue', value: string | string[] | null): void;
+    /** Companion time model, alongside every change while `datetime` is on. */
+    (e: 'update:time', value: string | string[] | null): void;
+    /** The active range end changed (range + datetime only). */
+    (e: 'update:activeSegment', value: BbDatePickerSegment): void;
+    /**
+     * Relay of the raw calendar-grid pick, before this component combines it with
+     * the time. An embedding host binds this to run its own value engine; clean
+     * consumers ignore it and use `update:modelValue`.
+     */
+    (e: 'grid-pick', value: string | string[] | null): void;
+    /**
+     * Relay of the raw time-rail pick. An embedding host binds this to run its own
+     * value engine; clean consumers ignore it and use `update:time`.
+     */
+    (e: 'time-pick', payload: {
+        unit: TimeUnit;
+        value: string;
+    }): void;
+};
+/** Props exposed by the `activator` slot (mirrors `BbColorPalette`). */
+export type BbDatePickerActivatorSlotProps = {
+    /** Spread onto your activator element to register its ref. */
+    props: {
+        ref: (el: unknown) => void;
+    };
+    /** Spread onto a wrapping element to anchor the popover to something larger. */
+    anchorProps: {
+        ref: (el: unknown) => void;
+    };
+    /** Whether the calendar popover is currently open. */
+    open: boolean;
+    /** The current value (mirrors `modelValue`). */
+    value: string | string[] | null;
+    /** Whether the picker is disabled. */
+    disabled: boolean;
+};
+/** Scope handed to the `day` / `append:day` slots (forwarded to the grid). */
+export type BbDatePickerDaySlotProps = {
+    first: boolean;
+    highlighted: boolean;
+    item: any;
+    label: string;
+    last: boolean;
+    middle: boolean;
+    selected: boolean;
+};
+export type BbDatePickerSlots = {
+    /** Custom activator element. Apply `v-bind="props"` to your trigger. */
+    activator?: (props: BbDatePickerActivatorSlotProps) => any;
+    /** Replaces the day button label inside each calendar day. */
+    day?: (props: BbDatePickerDaySlotProps) => any;
+    /** Appends content below each calendar day. */
+    'append:day'?: (props: BbDatePickerDaySlotProps) => any;
+};

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

@@ -5,15 +5,17 @@ declare const __VLS_base: import('vue').DefineComponent<BbDatePickerInputProps,
     error: (error: DatePickerInputError) => any;
     focus: (event: FocusEvent) => any;
     active: () => any;
+    "update:time": (value: string | string[] | null) => any;
     inactive: () => any;
 }, string, import('vue').PublicProps, Readonly<BbDatePickerInputProps> & Readonly<{
     "onUpdate:modelValue"?: ((value: string | string[] | null) => any) | undefined;
     onError?: ((error: DatePickerInputError) => any) | undefined;
     onFocus?: ((event: FocusEvent) => any) | undefined;
     onActive?: (() => any) | undefined;
+    "onUpdate:time"?: ((value: string | string[] | null) => any) | undefined;
     onInactive?: (() => any) | undefined;
 }>, {
-    allowWriting: boolean | "not-mobile";
+    adaptive: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/BbDatePickerInput/BbDatePickerInput.vue.js

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

package/dist/components/BbDatePickerInput/BbDatePickerInput.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,179 @@
+import { removedPropsFor as e } from "../../deprecation/removedProps.js";
+import { warnRemovedAttrs as t } from "../../utilities/functions/warnRemovedAttrs.js";
+import n from "../BbBaseInputContainer/BbBaseInputContainer.vue.js";
+import { isNotEmpty as r } from "../../utilities/functions/isNotEmpty.js";
+import i from "../BbBaseDatePickerInput/BbBaseDatePickerInput.vue.js";
+import { config as a } from "virtual:bitboss-ui/config";
+import { computed as o, createBlock as s, createVNode as c, defineComponent as l, guardReactiveProps as u, mergeProps as d, normalizeProps as f, onBeforeUnmount as p, onDeactivated as m, openBlock as h, ref as g, renderSlot as _, withCtx as v } from "vue";
+//#region src/components/BbDatePickerInput/BbDatePickerInput.vue?vue&type=script&setup=true&lang.ts
+var y = /*@__PURE__*/ l({
+	__name: "BbDatePickerInput",
+	props: {
+		adaptive: {
+			type: Boolean,
+			default: void 0
+		},
+		description: {},
+		offCanvasProps: {},
+		disableWriting: { type: [Boolean, String] },
+		"append:icon": {},
+		autocomplete: {},
+		autofocus: {},
+		clearable: { type: Boolean },
+		compact: { type: Boolean },
+		direction: {},
+		disabled: { type: Boolean },
+		errors: {},
+		firstDayOfWeek: {},
+		floating: { type: Boolean },
+		hasErrors: { type: Boolean },
+		warnings: {},
+		hasWarning: { type: Boolean },
+		disableCalendar: { type: [Boolean, String] },
+		hideLabel: { type: Boolean },
+		hint: {},
+		id: {},
+		label: {},
+		labelPosition: {},
+		labelMode: {},
+		loading: { type: Boolean },
+		max: {},
+		min: {},
+		modelValue: {},
+		name: {},
+		persistentHint: { type: Boolean },
+		placeholder: {},
+		"prepend:icon": {},
+		range: { type: Boolean },
+		readonly: { type: Boolean },
+		required: { type: Boolean },
+		reverse: { type: Boolean },
+		selectable: {},
+		datetime: { type: Boolean },
+		ampm: { type: Boolean },
+		seconds: { type: Boolean },
+		step: {},
+		time: {},
+		transitionDuration: {},
+		utc: { type: Boolean }
+	},
+	emits: [
+		"active",
+		"error",
+		"focus",
+		"inactive",
+		"update:modelValue",
+		"update:time"
+	],
+	setup(l, { emit: y }) {
+		let b = l, x = y;
+		process.env.NODE_ENV !== "production" && t("BbDatePickerInput", e("BbDatePickerInput"));
+		let S = g(!1), C = o(() => b.persistentHint || S.value), w = o(() => r(b.modelValue)), T = o(() => b.labelMode ?? a.defaultInputLabelMode), E = () => {
+			S.value = !1;
+		};
+		m(E), p(E);
+		let D = {
+			onError: (e) => x("error", e),
+			onFocus: (e) => x("focus", e),
+			onActive: () => {
+				S.value = !0, x("active");
+			},
+			onInactive: () => {
+				E(), x("inactive");
+			},
+			"onUpdate:modelValue": (e) => x("update:modelValue", e),
+			"onUpdate:time": (e) => x("update:time", e)
+		};
+		return (e, t) => (h(), s(n, {
+			id: e.id,
+			class: "bb-date-picker-input",
+			compact: e.compact,
+			description: e.description,
+			direction: e.direction,
+			errors: e.errors,
+			"has-errors": e.hasErrors,
+			"has-value": w.value,
+			"has-warning": e.hasWarning,
+			"hide-label": e.hideLabel,
+			hint: e.hint,
+			label: e.label,
+			"label-mode": T.value,
+			"label-position": e.labelPosition,
+			"model-value": e.modelValue,
+			name: e.name,
+			reverse: e.reverse,
+			"show-hint": C.value,
+			warnings: e.warnings
+		}, {
+			label: v((t) => [_(e.$slots, "label", f(u(t)))]),
+			input: v(({ id: t, hasErrors: n, hasWarning: r, ariaDescribedby: a }) => [c(i, d({
+				id: t,
+				adaptive: e.adaptive,
+				ampm: e.ampm,
+				"append:icon": b["append:icon"],
+				"aria-describedby": a,
+				autocomplete: e.autocomplete,
+				autofocus: e.autofocus,
+				clearable: e.clearable,
+				compact: e.compact,
+				datetime: e.datetime,
+				"disable-calendar": e.disableCalendar,
+				"disable-writing": e.disableWriting,
+				disabled: e.disabled,
+				"first-day-of-week": e.firstDayOfWeek,
+				floating: e.floating,
+				"has-errors": n,
+				"has-warning": r,
+				loading: e.loading,
+				max: e.max,
+				min: e.min,
+				"model-value": e.modelValue,
+				name: e.name,
+				"off-canvas-props": e.offCanvasProps,
+				placeholder: e.placeholder,
+				"prepend:icon": b["prepend:icon"],
+				range: e.range,
+				readonly: e.readonly,
+				required: e.required,
+				seconds: e.seconds,
+				selectable: e.selectable,
+				step: e.step,
+				time: e.time,
+				"transition-duration": e.transitionDuration,
+				utc: e.utc
+			}, D), {
+				"prepend-outer": v(() => [_(e.$slots, "prepend-outer")]),
+				prepend: v(() => [_(e.$slots, "prepend")]),
+				prefix: v(() => [_(e.$slots, "prefix")]),
+				suffix: v(() => [_(e.$slots, "suffix")]),
+				append: v(() => [_(e.$slots, "append")]),
+				"append-outer": v(() => [_(e.$slots, "append-outer")]),
+				day: v((t) => [_(e.$slots, "day", f(u(t)))]),
+				"append:day": v((t) => [_(e.$slots, "append:day", f(u(t)))]),
+				_: 2
+			}, 1040, /* @__PURE__ */ "id.adaptive.ampm.append:icon.aria-describedby.autocomplete.autofocus.clearable.compact.datetime.disable-calendar.disable-writing.disabled.first-day-of-week.floating.has-errors.has-warning.loading.max.min.model-value.name.off-canvas-props.placeholder.prepend:icon.range.readonly.required.seconds.selectable.step.time.transition-duration.utc".split("."))]),
+			_: 3
+		}, 8, [
+			"id",
+			"compact",
+			"description",
+			"direction",
+			"errors",
+			"has-errors",
+			"has-value",
+			"has-warning",
+			"hide-label",
+			"hint",
+			"label",
+			"label-mode",
+			"label-position",
+			"model-value",
+			"name",
+			"reverse",
+			"show-hint",
+			"warnings"
+		]));
+	}
+});
+//#endregion
+export { y as default };