@bagelink/vue 1.14.13 → 1.15.0

package/src/utils/date.ts

@@ -0,0 +1,482 @@
+import { getI18n } from '../i18n'
+
+function getLocale(): string {
+	try {
+		const { locale } = getI18n().global
+		return typeof locale === 'string' ? locale : locale.value
+	} catch {
+		if (typeof navigator === 'undefined') return 'en-US'
+		return (navigator.languages && navigator.languages.length)
+			? navigator.languages[0]
+			: navigator.language
+	}
+}
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export type DateInput = Date | number | string
+
+// ─── Date convention ────────────────────────────────────────────────────────
+//
+// Server → Client:  UTC (defaults to UTC when no TZ info present)
+// Client → Server:  Local time with TZ offset, OR UTC with Z suffix
+// Server accepts:   Anything with TZ info; defaults to UTC when absent
+// Client accepts:   Anything with TZ info; defaults to UTC when absent
+// Display:          Always device-local time (browser's Intl / Date methods)
+//
+// ── utc() — parse server dates ──────────────────────────────────────────────
+//
+//  utc(input)      → Date (interpreted as UTC when no TZ info)
+//  utc.iso(input)  → normalized ISO string with Z
+//  utc.date(input) → "YYYY-MM-DD" in UTC
+//  utc.ms(input)   → epoch milliseconds
+//
+// Handles:
+//  • Missing "Z" suffix or TZ offset → assumes UTC
+//  • Space instead of "T"            → normalizes
+//  • Strings with explicit TZ offset → respects it
+//  • Already a Date / number         → passes through
+//
+// ── local() — format for server submission ──────────────────────────────────
+//
+//  local.iso(date)  → ISO string with local TZ offset, e.g. "2026-05-05T11:00:00.000+03:00"
+//  local.offset()   → current device TZ offset string, e.g. "+03:00"
+//
+
+function _parseUTC(input: DateInput): Date {
+	if (input instanceof Date) return input
+	if (typeof input === 'number') return new Date(input)
+	// Normalize: "2026-05-05 08:00:00" → "2026-05-05T08:00:00Z"
+	let s = input.trim().replace(' ', 'T')
+	// If no TZ info at all, assume UTC
+	if (!s.endsWith('Z') && !s.includes('+') && !/[+-]\d{2}:\d{2}$/.test(s)) s += 'Z'
+	return new Date(s)
+}
+
+export const utc = Object.assign(_parseUTC, {
+	/** Parse and return normalized ISO string with Z */
+	iso(input: DateInput): string {
+		return _parseUTC(input).toISOString()
+	},
+	/** Parse and return UTC date-only string "YYYY-MM-DD" */
+	date(input: DateInput): string {
+		return _parseUTC(input).toISOString().slice(0, 10)
+	},
+	/** Parse and return epoch ms */
+	ms(input: DateInput): number {
+		return _parseUTC(input).getTime()
+	},
+})
+
+// ── local — format dates with device TZ for server submission ───────────────
+
+function _tzOffset(date: Date): string {
+	const off = -date.getTimezoneOffset()
+	const sign = off >= 0 ? '+' : '-'
+	const h = String(Math.floor(Math.abs(off) / 60)).padStart(2, '0')
+	const m = String(Math.abs(off) % 60).padStart(2, '0')
+	return `${sign}${h}:${m}`
+}
+
+function _localISO(date: Date): string {
+	const y = date.getFullYear()
+	const mo = String(date.getMonth() + 1).padStart(2, '0')
+	const d = String(date.getDate()).padStart(2, '0')
+	const h = String(date.getHours()).padStart(2, '0')
+	const mi = String(date.getMinutes()).padStart(2, '0')
+	const s = String(date.getSeconds()).padStart(2, '0')
+	const ms = String(date.getMilliseconds()).padStart(3, '0')
+	return `${y}-${mo}-${d}T${h}:${mi}:${s}.${ms}${_tzOffset(date)}`
+}
+
+export const local = {
+	/** Format a Date as ISO string with local TZ offset, e.g. "2026-05-05T11:00:00.000+03:00" */
+	iso(date: Date = new Date()): string {
+		return _localISO(date)
+	},
+	/** Current device TZ offset string, e.g. "+03:00" or "-05:00" */
+	offset(date: Date = new Date()): string {
+		return _tzOffset(date)
+	},
+}
+
+export type TimeDeltaUnit = 'days' | 'hours' | 'minutes' | 'seconds' | 'weeks' | 'months' | 'years'
+
+export interface TimeDeltaOptions {
+	days?: number
+	hours?: number
+	minutes?: number
+	seconds?: number
+	weeks?: number
+	months?: number
+	years?: number
+}
+
+export type DateDiffUnit = 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months'
+
+export type DayFormatTypes = 'DD' | 'DDD' | 'DDDD'
+export type MonthFormatTypes = 'MM' | 'MMM' | 'MMMM'
+export type YearFormatTypes = 'YY' | 'YYYY'
+export type HourFormatTypes = 'HH'
+export type MinuteFormatTypes = 'mm'
+export type SecondFormatTypes = 'ss'
+export type MillisecondFormatTypes = 'sss'
+export type AmPmFormatTypes = 'AmPm'
+export type DateFormatSeparatorTypes = '/' | '-' | ' ' | ':' | '.'
+
+export type CommonDateFormats
+	= | `${DayFormatTypes}${DateFormatSeparatorTypes}${MonthFormatTypes}${DateFormatSeparatorTypes}${YearFormatTypes}`
+		| `${MonthFormatTypes}${DateFormatSeparatorTypes}${YearFormatTypes}`
+		| 'DD.MM.YY' | 'DD.MM.YYYY' | 'DD/MM/YY' | 'DD/MM/YYYY'
+		| 'MM.DD.YY' | 'MM.DD.YYYY' | 'MM/DD/YY' | 'MM/DD/YYYY'
+		| 'YYYY-MM-DD' | 'YY-MM-DD'
+		| 'DD MMM YYYY' | 'DD MMMM YYYY'
+		| 'DDD, DD MMM' | 'DDDD, DD MMMM'
+		| 'MMM DD' | 'MMMM DD'
+
+export type CommonTimeFormats
+	= | 'HH:mm' | 'HH:mm:ss' | 'HH:mm:ss:sss'
+		| 'HH:mm AmPm'
+
+export type CommonDateTimeFormats
+	= | `${CommonDateFormats} ${CommonTimeFormats}`
+		| `${CommonTimeFormats}, ${CommonDateFormats}`
+		| 'YYYY-MM-DD HH:MM'
+
+export type NamedFormats = 'ISO' | 'ISO8601' | 'UTC' | 'RFC2822' | 'RFC3339' | 'UNIX' | 'TIMESTAMP'
+
+export type DateTimeAcceptedFormats
+	= | CommonDateFormats
+		| CommonTimeFormats
+		| CommonDateTimeFormats
+		| DayFormatTypes
+		| MonthFormatTypes
+		| YearFormatTypes
+		| HourFormatTypes
+		| MinuteFormatTypes
+		| SecondFormatTypes
+		| MillisecondFormatTypes
+		| NamedFormats
+
+export interface FormatDateOptions extends Partial<Pick<Intl.DateTimeFormatOptions, 'hour12'>> {
+	format?: DateTimeAcceptedFormats
+	locale?: Intl.LocalesArgument
+	tz?: string
+}
+
+// ─── Time constants ────────────────────────────────────────────────────────────
+
+export const MS = {
+	SECOND: 1_000,
+	MINUTE: 60_000,
+	HOUR: 3_600_000,
+	DAY: 86_400_000,
+	WEEK: 604_800_000,
+} as const
+
+export const { SECOND } = MS
+export const { MINUTE } = MS
+export const { HOUR } = MS
+export const { DAY } = MS
+export const { WEEK } = MS
+
+// ─── Core date arithmetic ──────────────────────────────────────────────────────
+
+export function timeDelta(date: DateInput, options: TimeDeltaOptions): Date {
+	const d = new Date(date)
+	if (options.days) d.setDate(d.getDate() + options.days)
+	if (options.hours) d.setHours(d.getHours() + options.hours)
+	if (options.minutes) d.setMinutes(d.getMinutes() + options.minutes)
+	if (options.seconds) d.setSeconds(d.getSeconds() + options.seconds)
+	if (options.weeks) d.setDate(d.getDate() + options.weeks * 7)
+	if (options.months) d.setMonth(d.getMonth() + options.months)
+	if (options.years) d.setFullYear(d.getFullYear() + options.years)
+	return d
+}
+
+const _MS_PER_UNIT: Record<DateDiffUnit, number> = {
+	seconds: 1_000,
+	minutes: 60_000,
+	hours: 3_600_000,
+	days: 86_400_000,
+	weeks: 604_800_000,
+	months: 0,
+}
+
+export function dateDiff(a: DateInput, b: DateInput, unit: DateDiffUnit = 'days'): number {
+	const da = new Date(a)
+	const db = new Date(b)
+	if (unit === 'months') {
+		const years = db.getFullYear() - da.getFullYear()
+		return years * 12 + (db.getMonth() - da.getMonth())
+	}
+	return Math.floor((db.getTime() - da.getTime()) / _MS_PER_UNIT[unit])
+}
+
+// ─── DateChain — fluent wrapper ────────────────────────────────────────────────
+
+export class DateChain {
+	private _date: Date
+
+	constructor(date: DateInput) {
+		this._date = new Date(date)
+	}
+
+	add(n: number, unit: TimeDeltaUnit = 'days'): DateChain {
+		return new DateChain(timeDelta(this._date, { [unit]: n }))
+	}
+
+	subtract(n: number, unit: TimeDeltaUnit = 'days'): DateChain {
+		return new DateChain(timeDelta(this._date, { [unit]: -n }))
+	}
+
+	diff(other: DateInput, unit: DateDiffUnit = 'days'): number {
+		return dateDiff(this._date, other, unit)
+	}
+
+	isBefore(other: DateInput): boolean {
+		return this._date.getTime() < new Date(other).getTime()
+	}
+
+	isAfter(other: DateInput): boolean {
+		return this._date.getTime() > new Date(other).getTime()
+	}
+
+	isSameDay(other: DateInput): boolean {
+		const o = new Date(other)
+		return (
+			this._date.getFullYear() === o.getFullYear()
+			&& this._date.getMonth() === o.getMonth()
+			&& this._date.getDate() === o.getDate()
+		)
+	}
+
+	toDate(): Date {
+		return new Date(this._date)
+	}
+
+	valueOf(): number {
+		return this._date.getTime()
+	}
+
+	toString(): string {
+		return this._date.toISOString()
+	}
+}
+
+// ─── d — blended callable + static namespace ──────────────────────────────────
+
+function _d(date?: DateInput): DateChain {
+	return new DateChain(date !== undefined ? date : new Date())
+}
+
+export const d = Object.assign(_d, {
+	// ── Relative to now ──────────────────────────────────────────
+	get now(): DateChain { return new DateChain(new Date()) },
+	get today(): DateChain {
+		const t = new Date()
+		t.setHours(0, 0, 0, 0)
+		return new DateChain(t)
+	},
+	get tomorrow(): DateChain { return new DateChain(timeDelta(new Date(), { days: 1 })) },
+	get yesterday(): DateChain { return new DateChain(timeDelta(new Date(), { days: -1 })) },
+	get nextWeek(): DateChain { return new DateChain(timeDelta(new Date(), { weeks: 1 })) },
+	get lastWeek(): DateChain { return new DateChain(timeDelta(new Date(), { weeks: -1 })) },
+
+	// ── Current month ────────────────────────────────────────────
+	get firstOfMonth(): DateChain {
+		const t = new Date()
+		return new DateChain(new Date(t.getFullYear(), t.getMonth(), 1))
+	},
+	get lastOfMonth(): DateChain {
+		const t = new Date()
+		return new DateChain(new Date(t.getFullYear(), t.getMonth() + 1, 0))
+	},
+
+	// ── Current week (Sunday start) ──────────────────────────────
+	get firstOfWeek(): DateChain {
+		const t = new Date()
+		return new DateChain(new Date(t.setDate(t.getDate() - t.getDay())))
+	},
+	get lastOfWeek(): DateChain {
+		const t = new Date()
+		return new DateChain(new Date(t.setDate(t.getDate() + (6 - t.getDay()))))
+	},
+
+	// ── Next month ───────────────────────────────────────────────
+	get firstOfNextMonth(): DateChain {
+		const t = new Date()
+		return new DateChain(new Date(t.getFullYear(), t.getMonth() + 1, 1))
+	},
+	get lastOfNextMonth(): DateChain {
+		const t = new Date()
+		return new DateChain(new Date(t.getFullYear(), t.getMonth() + 2, 0))
+	},
+
+	// ── Next year ────────────────────────────────────────────────
+	get firstOfNextYear(): DateChain {
+		return new DateChain(new Date(new Date().getFullYear() + 1, 0, 1))
+	},
+
+	// ── Methods ──────────────────────────────────────────────────
+	in: (n: number, unit: TimeDeltaUnit = 'days'): DateChain => new DateChain(timeDelta(new Date(), { [unit]: n })),
+	ago: (n: number, unit: TimeDeltaUnit = 'days'): DateChain => new DateChain(timeDelta(new Date(), { [unit]: -n })),
+	diff: (a: DateInput, b: DateInput, unit: DateDiffUnit = 'days'): number => dateDiff(a, b, unit),
+	isBefore: (a: DateInput, b: DateInput): boolean => new Date(a).getTime() < new Date(b).getTime(),
+	isAfter: (a: DateInput, b: DateInput): boolean => new Date(a).getTime() > new Date(b).getTime(),
+	isSameDay: (a: DateInput, b: DateInput): boolean => {
+		const da = new Date(a)
+		const db = new Date(b)
+		return (
+			da.getFullYear() === db.getFullYear()
+			&& da.getMonth() === db.getMonth()
+			&& da.getDate() === db.getDate()
+		)
+	},
+})
+
+// ─── Timezone + formatting ─────────────────────────────────────────────────────
+
+export function handleTimezone(date: Date, intFmtOpt: Intl.DateTimeFormatOptions): Date {
+	if (intFmtOpt.timeZone === 'UTC') {
+		const utcDate = new Date(date.getTime())
+		utcDate.setMinutes(utcDate.getMinutes() + date.getTimezoneOffset())
+		return utcDate
+	}
+	try {
+		const formatter = new Intl.DateTimeFormat('en-US', { ...intFmtOpt, month: 'numeric' })
+		const formattedParts = formatter.formatToParts(date)
+		const parts: Record<string, number> = {}
+		for (const part of formattedParts) {
+			if (part.type !== 'literal' && part.type !== 'timeZoneName')
+				parts[part.type] = Number.parseInt(part.value, 10)
+		}
+		return new Date(
+			parts.year,
+			(parts.month || 1) - 1,
+			parts.day,
+			parts.hour || 0,
+			parts.minute || 0,
+			parts.second || 0,
+		)
+	} catch (error) {
+		console.warn(`Error handling timezone ${intFmtOpt.timeZone}:`, error)
+		return date
+	}
+}
+
+export function getDatePartsMap(date: Date, locale: Intl.LocalesArgument, intFmtOpt?: Intl.DateTimeFormatOptions) {
+	const d = intFmtOpt?.timeZone ? handleTimezone(date, intFmtOpt) : date
+	const year = d.getFullYear().toString()
+	return {
+		AmPm: d.toLocaleString(locale, { hour: 'numeric', hour12: true, minute: 'numeric' }).split(' ')[1],
+		DD: String(d.getDate()).padStart(2, '0'),
+		DDD: d.toLocaleString(locale, { weekday: 'short' }),
+		DDDD: d.toLocaleString(locale, { weekday: 'long' }),
+		HH: String(d.getHours()).padStart(2, '0'),
+		mm: String(d.getMinutes()).padStart(2, '0'),
+		MM: String(d.getMonth() + 1).padStart(2, '0'),
+		MMM: d.toLocaleString(locale, { month: 'short' }),
+		MMMM: d.toLocaleString(locale, { month: 'long' }),
+		ss: String(d.getSeconds()).padStart(2, '0'),
+		sss: String(d.getMilliseconds()).padStart(3, '0'),
+		YY: year.slice(-2),
+		YYYY: year,
+	}
+}
+
+// Precomputed token regex (module-level, avoid re-creating on every call)
+const _sampleMap = getDatePartsMap(new Date(), 'en-US')
+const _orderedTokens = (Object.keys(_sampleMap).sort((a, b) => b.length - a.length)) as (keyof typeof _sampleMap)[]
+const _tokenRegex = new RegExp(_orderedTokens.join('|'), 'g')
+
+export function formatDate(date?: DateInput, format?: DateTimeAcceptedFormats): string
+export function formatDate(date?: DateInput, opts?: FormatDateOptions): string
+export function formatDate(
+	date?: DateInput,
+	formatOrOpts?: DateTimeAcceptedFormats | FormatDateOptions,
+): string {
+	if (!date) return ''
+
+	let format: DateTimeAcceptedFormats | undefined
+	let locale: Intl.LocalesArgument | undefined
+	let timeZone: string | undefined
+	let rest: Partial<Pick<Intl.DateTimeFormatOptions, 'hour12'>> = {}
+
+	if (typeof formatOrOpts === 'string') {
+		format = formatOrOpts
+	} else if (formatOrOpts && typeof formatOrOpts === 'object') {
+		format = formatOrOpts.format
+		locale = formatOrOpts.locale
+		timeZone = formatOrOpts.tz
+		rest = formatOrOpts
+	}
+
+	if (format === 'ISO' || format === 'ISO8601') {
+		const parsed = new Date(date)
+		return Number.isNaN(parsed.getTime()) ? '' : parsed.toISOString()
+	}
+
+	format = format || 'DD.MM.YY'
+	locale = locale || getLocale()
+
+	try {
+		let parsed = new Date(date)
+
+		// Handle DD.MM.YY(YY) and DD/MM/YY(YY) strings that new Date() can't parse
+		if (typeof date === 'string' && Number.isNaN(parsed.getTime())) {
+			const parts = date.split(/[/.-]/)
+			if (parts.length === 3) {
+				const [d, m, y] = parts.map(p => Number.parseInt(p, 10))
+				if (!Number.isNaN(d) && !Number.isNaN(m) && !Number.isNaN(y)) {
+					const fullYear = y < 100 ? 2000 + y : y
+					parsed = new Date(fullYear, m - 1, d)
+				}
+			}
+		}
+
+		if (Number.isNaN(parsed.getTime())) {
+			console.warn('Invalid date provided to formatDate:', date)
+			return ''
+		}
+
+		const intFmtOpt: Intl.DateTimeFormatOptions = {
+			day: 'numeric',
+			hour: '2-digit',
+			hour12: rest.hour12 === undefined ? true : rest.hour12,
+			minute: '2-digit',
+			month: 'long',
+			second: '2-digit',
+			timeZone,
+			weekday: 'long',
+			year: 'numeric',
+		}
+
+		const datePartsMap = getDatePartsMap(parsed, locale, intFmtOpt)
+		const formattedParts = new Intl.DateTimeFormat(locale, intFmtOpt).formatToParts(parsed)
+		const partsMap: Partial<Record<Intl.DateTimeFormatPartTypes, string>> = {}
+
+		for (const part of formattedParts) {
+			if (part.type !== 'literal') partsMap[part.type] = part.value
+		}
+
+		if (partsMap.month) {
+			datePartsMap.MMM = partsMap.month.substring(0, 3)
+			datePartsMap.MMMM = partsMap.month
+		}
+		if (partsMap.weekday) {
+			datePartsMap.DDD = new Intl.DateTimeFormat(locale, { weekday: 'short', timeZone }).format(parsed)
+			datePartsMap.DDDD = partsMap.weekday
+		}
+		if (partsMap.dayPeriod) {
+			datePartsMap.AmPm = partsMap.dayPeriod
+		}
+
+		return format.replace(_tokenRegex, match => datePartsMap[match as keyof typeof datePartsMap])
+	} catch (error) {
+		console.warn(`Error formatting date: ${date} with format: ${format}`, error)
+		return ''
+	}
+}
+
+export const fmtDate = formatDate

package/src/utils/fetch.ts

@@ -0,0 +1,128 @@
+import { fuzzyMatch } from './string'
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+type RawResponse<T> = T[] | { data: T[] } | { items: T[] }
+
+type ClientFetcher<T> = () => Promise<RawResponse<T>>
+type ServerFetcher<T> = (query: string) => Promise<RawResponse<T>>
+type Fetcher<T> = ClientFetcher<T> | ServerFetcher<T>
+
+type Mapper<T, R> = (items: T[]) => R[]
+
+export interface OptionItem {
+	label: string
+	value: string | number
+	[key: string]: any
+}
+
+export interface ToOptionsConfig<T> {
+	label: keyof T | ((item: T) => string)
+	value: keyof T
+}
+
+export interface NormalizedFetchResult<R> {
+	(filter?: string): Promise<R[]>
+	clearCache: () => void
+}
+
+// ─── toOptions ────────────────────────────────────────────────────────────────
+
+function defaultLabel<T>(item: T): string {
+	const t = item as any
+	return t.label ?? t.name ?? t.title ?? String(t.id ?? '')
+}
+
+function defaultValue<T>(item: T): string | number {
+	const t = item as any
+	return t.value ?? t.key ?? t.id ?? ''
+}
+
+export function toOptions<T>(items: T[]): OptionItem[]
+export function toOptions<T>(config: ToOptionsConfig<T>): Mapper<T, OptionItem>
+export function toOptions<T>(
+	itemsOrConfig: T[] | ToOptionsConfig<T>,
+): OptionItem[] | Mapper<T, OptionItem> {
+	if (Array.isArray(itemsOrConfig)) {
+		return itemsOrConfig.map(item => ({
+			...item as any,
+			label: defaultLabel(item),
+			value: defaultValue(item),
+		}))
+	}
+
+	const config = itemsOrConfig
+	return (items: T[]) => items.map(item => ({
+		...item as any,
+		label: typeof config.label === 'function'
+			? config.label(item)
+			: String(item[config.label] ?? ''),
+		value: item[config.value] as string | number,
+	}))
+}
+
+// ─── normalizedFetch ──────────────────────────────────────────────────────────
+
+function unwrap<T>(response: RawResponse<T>): T[] {
+	if (Array.isArray(response)) return response
+	if ('data' in response) return response.data
+	if ('items' in response) return response.items
+	return []
+}
+
+export function normalizedFetch<T, R>(
+	fetcher: Fetcher<T>,
+	mapper: Mapper<T, R>,
+	options?: { timeout?: number },
+): NormalizedFetchResult<R> {
+	const timeout = options?.timeout ?? 10_000
+	const isServerSearch = fetcher.length > 0
+	let cache: R[] | null = null
+
+	async function fetchWithTimeout(query?: string): Promise<R[]> {
+		const call = isServerSearch
+			? (fetcher as ServerFetcher<T>)(query ?? '')
+			: (fetcher as ClientFetcher<T>)()
+
+		const result = await Promise.race([
+			call,
+			new Promise<never>((_, reject) => setTimeout(() => { reject(new Error('Request timeout')) }, timeout),
+			),
+		])
+
+		return mapper(unwrap(result))
+	}
+
+	const getter = async (filter?: string): Promise<R[]> => {
+		try {
+			if (isServerSearch) {
+				return await fetchWithTimeout(filter)
+			}
+
+			if (!cache) {
+				cache = await fetchWithTimeout()
+			}
+
+			if (filter) {
+				return cache.filter((item) => {
+					const { label } = item as any
+					if (typeof label !== 'string') return true
+					return fuzzyMatch(label, filter).matches
+				}).sort((a, b) => {
+					const labelA = (a as any).label ?? ''
+					const labelB = (b as any).label ?? ''
+					return fuzzyMatch(labelB, filter!).score - fuzzyMatch(labelA, filter!).score
+				})
+			}
+
+			return cache
+		} catch (error) {
+			console.error('normalizedFetch error:', error)
+			return []
+		}
+	}
+
+	getter.clearCache = () => { cache = null }
+
+	return getter
+}

package/src/utils/index.ts

@@ -172,6 +172,25 @@ export async function appendScript(src: string, options?: { id?: string }): Prom
 	return loadingPromise
 }
 
+/**
+ * Wait for a global (e.g. a CDN script's `window.X`) to become available.
+ * Resolves with the global value, or rejects after `timeout` ms (default 10s).
+ *
+ * @example
+ * await appendScript('https://unpkg.com/leaflet/dist/leaflet.js')
+ * const L = await awaitGlobal('L')
+ */
+export async function awaitGlobal<T = any>(name: string, { timeout = 10_000, interval = 50 }: { timeout?: number, interval?: number } = {}): Promise<T> {
+	const start = Date.now()
+	while ((window as any)[name] === undefined) {
+		if (Date.now() - start > timeout) {
+			throw new Error(`awaitGlobal: window.${name} not available after ${timeout}ms`)
+		}
+		await sleep(interval)
+	}
+	return (window as any)[name] as T
+}
+
 export function appendStyle(src: string): Promise<void> {
 	return new Promise((resolve, reject) => {
 		if (document.querySelector(`link[href="${src}"]`)) {
@@ -198,9 +217,6 @@ export function normalizeDimension(value: string | number | undefined, defaultMe
 	return value
 }
 
-export * as bagelFormUtils from './BagelFormUtils'
-export { useForm } from './BagelFormUtils'
-
 export type { NormalizedOption } from './options'
 export { getOptionIcon, getOptionLabel, getOptionValue, normalizeOption } from './options'
 
@@ -291,5 +307,40 @@ export function downloadFile(source: string | Blob, fileName?: string) {
 
 export { defaultOptions, showdown } from './showdown'
 
+// Note: the `DateInput` type from './date' is intentionally not re-exported
+// here to avoid clashing with the DateInput component. Import it from
+// '@bagelink/vue/src/utils/date' directly if needed.
+export type {
+	CommonDateFormats,
+	CommonDateTimeFormats,
+	CommonTimeFormats,
+	DateDiffUnit,
+	DateTimeAcceptedFormats,
+	FormatDateOptions,
+	NamedFormats,
+	TimeDeltaOptions,
+	TimeDeltaUnit,
+} from './date'
+export {
+	d,
+	DateChain,
+	dateDiff,
+	DAY,
+	fmtDate,
+	formatDate,
+	getDatePartsMap,
+	handleTimezone,
+	HOUR,
+	local,
+	MINUTE,
+	MS,
+	SECOND,
+	timeDelta,
+	utc,
+	WEEK,
+} from './date'
+export * from './fetch'
+export * from './string'
+
 export { formatString } from './strings'
 export { useDebounceFn } from '@vueuse/core'

package/src/utils/sizeParsing.ts

@@ -7,11 +7,11 @@ export function standardSize(value: number | string | undefined, unit: UnitSize
 	// Handle SizeType values
 	if (typeof value === 'string') {
 		const sizeTypeMap: Record<SizeType, number> = {
-			xSmall: 16,
-			small: 24,
-			medium: 32,
-			large: 48,
-			xLarge: 64
+			xs: 16,
+			sm: 24,
+			md: 32,
+			lg: 48,
+			xl: 64
 		}
 
 		if (value in sizeTypeMap) {