@astryx-vue/core 0.1.0 → 0.1.3

package/dist/useClickableContainer-DyNpnSEa.js

@@ -0,0 +1,112 @@
+//#region src/composables/useClickableContainer.ts
+/**
+* 对应原版 Astryx 的 `hooks/useClickableContainer`。
+*
+* 让整块容器可点，同时把点在嵌套按钮、链接、输入框上的点击留给那些控件自己。
+* ClickableCard 和 SelectableCard 都走这里，避免两套“点到谁算谁”的判断。
+*/
+const INTERACTIVE_SELECTORS = [
+	"button",
+	"a",
+	"input",
+	"select",
+	"textarea",
+	"[role=\"button\"]",
+	"[role=\"link\"]",
+	"[role=\"checkbox\"]",
+	"[role=\"radio\"]",
+	"[role=\"switch\"]",
+	"[role=\"tab\"]",
+	"[role=\"menuitem\"]",
+	"[role=\"option\"]",
+	"[role=\"combobox\"]",
+	"[role=\"listbox\"]",
+	"[role=\"slider\"]",
+	"[role=\"spinbutton\"]",
+	"[data-pressable-container]"
+].join(",");
+const NON_INTERACTIVE_SELECTORS = "[aria-readonly=\"true\"]";
+function hasInteractiveAncestor(element, root) {
+	let current = element;
+	while (current != null && current !== root && current !== document.body) {
+		if (current.matches(INTERACTIVE_SELECTORS) && !current.matches(NON_INTERACTIVE_SELECTORS)) return true;
+		current = current.parentElement;
+	}
+	return false;
+}
+function hasTextSelection(node) {
+	if (typeof document === "undefined" || document.getSelection == null) return false;
+	const selection = document.getSelection();
+	if (selection == null || selection.isCollapsed) return false;
+	return node.contains(selection.anchorNode);
+}
+function openInNewTab(href) {
+	window.open(href, "_blank", "noopener");
+}
+/**
+* 把容器的 click / mouseup 交给调用方绑到根元素上。
+* 组件挂载后会给容器加上 `data-pressable-container`，嵌套的可点容器因此不会互相抢走点击。
+*/
+function useClickableContainer(options) {
+	function markContainer() {
+		const container = options.containerRef.value;
+		if (container != null) container.dataset.pressableContainer = "true";
+	}
+	function onClick(event) {
+		markContainer();
+		if (options.disabled) return;
+		const container = options.containerRef.value;
+		if (container == null) return;
+		if (hasTextSelection(container)) return;
+		const target = event.target;
+		if (!(target instanceof Element)) return;
+		if (target !== event.currentTarget && hasInteractiveAncestor(target, container)) return;
+		options.onClick?.(event);
+		if (event.defaultPrevented) return;
+		const href = options.href;
+		if (href != null && href !== "") {
+			if (options.target === "_blank" || event.metaKey || event.ctrlKey) {
+				openInNewTab(href);
+				return;
+			}
+			const interactive = options.interactiveRef?.value;
+			if (interactive != null) {
+				interactive.click();
+				return;
+			}
+			window.location.assign(href);
+			return;
+		}
+		if (options.onClick == null) {
+			const interactive = options.interactiveRef?.value;
+			if (interactive != null) {
+				interactive.dispatchEvent(new MouseEvent("click", {
+					bubbles: true,
+					cancelable: true,
+					button: event.button,
+					ctrlKey: event.ctrlKey,
+					metaKey: event.metaKey,
+					shiftKey: event.shiftKey,
+					altKey: event.altKey
+				}));
+				event.stopPropagation();
+			}
+		}
+	}
+	function onMouseUp(event) {
+		if (options.disabled) return;
+		const href = options.href;
+		if (href == null || href === "" || event.button !== 1) return;
+		const container = options.containerRef.value;
+		const target = event.target;
+		if (container == null || !(target instanceof Element)) return;
+		if (target !== event.currentTarget && hasInteractiveAncestor(target, container)) return;
+		openInNewTab(href);
+	}
+	return {
+		onClick,
+		onMouseUp
+	};
+}
+//#endregion
+export { useClickableContainer as n, INTERACTIVE_SELECTORS as t };

package/dist/useFileSelection-BPtaegqK.js

@@ -0,0 +1,58 @@
+//#region src/composables/useFileSelection.ts
+function matchesAccept(file, accept) {
+	if (accept == null || accept.trim() === "") return true;
+	const tokens = accept.split(",").map((token) => token.trim().toLowerCase()).filter(Boolean);
+	if (tokens.length === 0) return true;
+	const name = file.name.toLowerCase();
+	const type = file.type.toLowerCase();
+	return tokens.some((token) => {
+		if (token.startsWith(".")) return name.endsWith(token);
+		if (token.endsWith("/*")) return type.startsWith(token.slice(0, -1));
+		return type === token;
+	});
+}
+function formatFileSize(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1048576) return `${Math.max(1, Math.round(bytes / 1024))} KB`;
+	const megabytes = bytes / 1048576;
+	return `${megabytes >= 10 ? Math.round(megabytes) : Math.round(megabytes * 10) / 10} MB`;
+}
+function selectFiles(list, options) {
+	const incoming = list == null ? [] : [...list];
+	const rejections = [];
+	let accepted = incoming.filter((file) => {
+		if (!matchesAccept(file, options.accept)) {
+			rejections.push({
+				code: "type",
+				fileName: file.name
+			});
+			return false;
+		}
+		if (options.maxSize != null && file.size > options.maxSize) {
+			rejections.push({
+				code: "size",
+				fileName: file.name,
+				maxSize: options.maxSize
+			});
+			return false;
+		}
+		return true;
+	});
+	if (options.isMultiple && options.maxFiles != null && accepted.length > options.maxFiles) {
+		rejections.push({
+			code: "count",
+			maxFiles: options.maxFiles
+		});
+		accepted = accepted.slice(0, options.maxFiles);
+	}
+	if (!options.isMultiple) return {
+		files: accepted[0] ?? null,
+		rejections
+	};
+	return {
+		files: accepted,
+		rejections
+	};
+}
+//#endregion
+export { selectFiles as n, formatFileSize as t };

package/dist/useMonthGrid-CmJsZTcB.js

@@ -0,0 +1,139 @@
+import { CalendarDate } from "@internationalized/date";
+//#region src/composables/useDateRange.ts
+const WEEKDAY_INDEX = {
+	sun: 0,
+	mon: 1,
+	tue: 2,
+	wed: 3,
+	thu: 4,
+	fri: 5,
+	sat: 6
+};
+function resolveWeekStart(value) {
+	if (value == null) return 0;
+	if (typeof value === "number") return (value % 7 + 7) % 7;
+	return WEEKDAY_INDEX[value.toLowerCase()] ?? 0;
+}
+function compareISODate(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function spanDays(start, end) {
+	const [startYear, startMonth, startDay] = start.split("-").map(Number);
+	const [endYear, endMonth, endDay] = end.split("-").map(Number);
+	const startUtc = Date.UTC(startYear, startMonth - 1, startDay);
+	const endUtc = Date.UTC(endYear, endMonth - 1, endDay);
+	return Math.round((endUtc - startUtc) / 864e5) + 1;
+}
+function orderRange(a, b) {
+	return compareISODate(a, b) <= 0 ? {
+		start: a,
+		end: b
+	} : {
+		start: b,
+		end: a
+	};
+}
+function isSameRange(a, b) {
+	if (a == null || b == null) return a === b;
+	return a.start === b.start && a.end === b.end;
+}
+function isRangeWithinSpan(range, minRangeSpan = 1, maxRangeSpan) {
+	const span = spanDays(range.start, range.end);
+	if (span < minRangeSpan) return false;
+	if (maxRangeSpan != null && span > maxRangeSpan) return false;
+	return true;
+}
+/**
+* 第一次点击记下起点。第二次点击在跨度合法时提交区间。
+* 再次点击起点时，最短跨度允许单日就提交单日，否则取消这次选择。
+*/
+function applyRangeClick(pending, day, minRangeSpan = 1, maxRangeSpan) {
+	if (pending == null) return {
+		pending: day,
+		commit: null
+	};
+	if (pending === day) {
+		if (minRangeSpan <= 1) return {
+			pending: null,
+			commit: {
+				start: day,
+				end: day
+			}
+		};
+		return {
+			pending: null,
+			commit: null
+		};
+	}
+	const range = orderRange(pending, day);
+	if (!isRangeWithinSpan(range, minRangeSpan, maxRangeSpan)) return {
+		pending,
+		commit: null
+	};
+	return {
+		pending: null,
+		commit: range
+	};
+}
+function isDayOutsideSpan(pending, day, minRangeSpan = 1, maxRangeSpan) {
+	if (pending == null || pending === day) return false;
+	return !isRangeWithinSpan(orderRange(pending, day), minRangeSpan, maxRangeSpan);
+}
+function formatDateRange(range, locale) {
+	if (range == null) return "";
+	const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+	const startYear = Number(range.start.slice(0, 4));
+	const withYear = !(startYear === Number(range.end.slice(0, 4)) && startYear === currentYear);
+	const formatter = new Intl.DateTimeFormat(locale === "zh-CN" ? "zh-CN" : "en", {
+		month: "short",
+		day: "numeric",
+		year: withYear ? "numeric" : void 0
+	});
+	const format = (iso) => {
+		const [year, month, day] = iso.split("-").map(Number);
+		return formatter.format(new Date(year, month - 1, day));
+	};
+	return `${format(range.start)} – ${format(range.end)}`;
+}
+//#endregion
+//#region src/composables/useMonthGrid.ts
+function toISODate(date) {
+	const month = String(date.month).padStart(2, "0");
+	const day = String(date.day).padStart(2, "0");
+	return `${date.year}-${month}-${day}`;
+}
+function parseISODate(value) {
+	const [year, month, day] = value.split("-").map(Number);
+	return new CalendarDate(year, month, day);
+}
+function buildMonthGrid(year, month, weekStartsOn) {
+	const first = new CalendarDate(year, month, 1);
+	const start = resolveWeekStart(weekStartsOn);
+	const offset = (first.toDate("UTC").getUTCDay() - start + 7) % 7;
+	let cursor = first.subtract({ days: offset });
+	const weeks = [];
+	for (let week = 0; week < 6; week += 1) {
+		const days = [];
+		for (let day = 0; day < 7; day += 1) {
+			days.push(toISODate(cursor));
+			cursor = cursor.add({ days: 1 });
+		}
+		weeks.push(days);
+	}
+	return weeks;
+}
+function addMonths(year, month, amount) {
+	const date = new CalendarDate(year, month, 1).add({ months: amount });
+	return {
+		year: date.year,
+		month: date.month
+	};
+}
+function todayISODate() {
+	const now = /* @__PURE__ */ new Date();
+	const month = String(now.getMonth() + 1).padStart(2, "0");
+	const day = String(now.getDate()).padStart(2, "0");
+	return `${now.getFullYear()}-${month}-${day}`;
+}
+//#endregion
+export { todayISODate as a, formatDateRange as c, isSameRange as d, orderRange as f, toISODate as i, isDayOutsideSpan as l, spanDays as m, buildMonthGrid as n, applyRangeClick as o, resolveWeekStart as p, parseISODate as r, compareISODate as s, addMonths as t, isRangeWithinSpan as u };

package/dist/useResizable-CeESZS1v.d.ts

@@ -0,0 +1,72 @@
+import { n as PixelWidth } from "./types-JktRxujg.js";
+import { Ref } from "vue";
+//#region src/composables/useResizable.d.ts
+type ResizableDirection = 'horizontal' | 'vertical';
+interface ResizablePercentSize {
+  type: 'percent';
+  value: number;
+  min?: PixelWidth;
+  max?: PixelWidth;
+}
+type ResizableSize = number | `${number}px` | `${number}%` | PixelWidth | ResizablePercentSize;
+interface ResizableRegionConfig {
+  defaultSize?: ResizableSize | string;
+  minSize?: ResizableSize | string;
+  maxSize?: ResizableSize | string;
+  collapsible?: boolean;
+  collapsedSize?: number;
+  snaps?: number[];
+  /** Cascade priority. A lower number gives up space first when the shared container is narrower than the regions. */
+  shrinkOrder?: number;
+}
+interface UseResizableSingleOptions extends ResizableRegionConfig {
+  containerRef?: Ref<HTMLElement | null>;
+  direction?: ResizableDirection;
+  autoSaveId?: string;
+  defaultIsCollapsed?: boolean;
+  isCollapsed?: boolean;
+  onSizeChange?: (size: number) => void;
+  onCollapseChange?: (isCollapsed: boolean) => void;
+}
+interface UseResizableMultiConfig {
+  direction?: ResizableDirection;
+  containerRef?: Ref<HTMLElement | null>;
+  regions: Record<string, ResizableRegionConfig>;
+  autoSaveId?: string;
+}
+interface ResizableProps {
+  _size: number;
+  _isCollapsed: boolean;
+  _onResizeStart: () => void;
+  _onResizeMove: (delta: number) => void;
+  _onResizeEnd: () => void;
+  _onResizeCancel?: () => void;
+  _minSizePx: number;
+  _maxSizePx: number;
+  _snaps: number[];
+  _collapsedSize: number;
+  _collapsible: boolean;
+  _direction?: ResizableDirection;
+  _isResizableProps: true;
+}
+interface ResizableRegion {
+  size: number;
+  isCollapsed: boolean;
+  collapse: () => void;
+  expand: () => void;
+  resize: (size: number) => void;
+  props: ResizableProps;
+}
+declare function percent(value: number, options: {
+  min: PixelWidth;
+  max?: never;
+} | {
+  min?: never;
+  max: PixelWidth;
+}): ResizablePercentSize;
+declare function useResizable(options: UseResizableMultiConfig): Record<string, ResizableRegion>;
+declare function useResizable(options: UseResizableSingleOptions): ResizableRegion;
+type UseResizableOptions = UseResizableSingleOptions | UseResizableMultiConfig;
+type ResizableState = ResizableRegion;
+//#endregion
+export { ResizableRegionConfig as a, UseResizableMultiConfig as c, percent as d, useResizable as f, ResizableRegion as i, UseResizableOptions as l, ResizablePercentSize as n, ResizableSize as o, ResizableProps as r, ResizableState as s, ResizableDirection as t, UseResizableSingleOptions as u };

package/dist/useScrollableArea-DDk_CluT.js

@@ -0,0 +1,172 @@
+import { computed, onBeforeUnmount, onMounted, ref, watch } from "vue";
+//#region src/composables/useScrollableArea.ts
+const TOLERANCE = 1;
+const idleAxis = () => ({
+	isScrollable: false,
+	atStart: true,
+	atEnd: true
+});
+function mappingFor(element) {
+	const style = getComputedStyle(element);
+	const mode = style.writingMode.toLowerCase();
+	const vertical = mode.startsWith("vertical") || mode.startsWith("sideways");
+	const rtl = style.direction === "rtl";
+	if (!vertical) return {
+		inline: "x",
+		block: "y",
+		inlineReversed: rtl,
+		blockReversed: false
+	};
+	return {
+		inline: "y",
+		block: "x",
+		inlineReversed: mode === "sideways-lr" ? !rtl : rtl,
+		blockReversed: mode.endsWith("-rl")
+	};
+}
+function extent(element, axis) {
+	if (axis === "x") return {
+		client: element.clientWidth,
+		content: element.scrollWidth,
+		offset: element.scrollLeft
+	};
+	return {
+		client: element.clientHeight,
+		content: element.scrollHeight,
+		offset: element.scrollTop
+	};
+}
+function useScrollableArea(options) {
+	const viewport = ref(null);
+	const content = ref(null);
+	const inline = ref(idleAxis());
+	const block = ref(idleAxis());
+	const overflowInline = ref(false);
+	const overflowBlock = ref(false);
+	const mapping = ref({
+		inline: "x",
+		block: "y",
+		inlineReversed: false,
+		blockReversed: false
+	});
+	let observer;
+	const axis = computed(() => options.axis ?? "block");
+	const overscroll = computed(() => options.overscroll ?? "allow");
+	const stickyContainment = computed(() => options.stickyContainment ?? "whenScrollable");
+	function requested(name) {
+		return axis.value === name || axis.value === "both";
+	}
+	function sameAxis(current, next) {
+		return current.isScrollable === next.isScrollable && current.atStart === next.atStart && current.atEnd === next.atEnd;
+	}
+	function measure() {
+		const element = viewport.value;
+		if (element == null) return;
+		const nextMapping = mappingFor(element);
+		const read = (name, reversed) => {
+			const box = extent(element, nextMapping[name]);
+			const overflowing = box.content > box.client + TOLERANCE;
+			const max = Math.max(0, box.content - box.client);
+			const offset = reversed ? max - Math.abs(box.offset) : Math.abs(box.offset);
+			const active = requested(name) && overflowing;
+			return {
+				overflowing,
+				state: {
+					isScrollable: active,
+					atStart: !active || offset <= TOLERANCE,
+					atEnd: !active || offset >= max - TOLERANCE
+				}
+			};
+		};
+		const inlineRead = read("inline", nextMapping.inlineReversed);
+		const blockRead = read("block", nextMapping.blockReversed);
+		const nextInline = requested("inline") ? inlineRead.state : idleAxis();
+		const nextBlock = requested("block") ? blockRead.state : idleAxis();
+		if (mapping.value.inline === nextMapping.inline && mapping.value.block === nextMapping.block && mapping.value.inlineReversed === nextMapping.inlineReversed && mapping.value.blockReversed === nextMapping.blockReversed && overflowInline.value === inlineRead.overflowing && overflowBlock.value === blockRead.overflowing && sameAxis(inline.value, nextInline) && sameAxis(block.value, nextBlock)) return;
+		mapping.value = nextMapping;
+		overflowInline.value = inlineRead.overflowing;
+		overflowBlock.value = blockRead.overflowing;
+		inline.value = nextInline;
+		block.value = nextBlock;
+	}
+	let queued = false;
+	function queueMeasure() {
+		if (queued) return;
+		queued = true;
+		queueMicrotask(() => {
+			queued = false;
+			measure();
+		});
+	}
+	function bind(element) {
+		const node = element instanceof HTMLElement ? element : null;
+		if (viewport.value === node) return;
+		viewport.value?.removeEventListener("scroll", measure);
+		observer?.disconnect();
+		observer = void 0;
+		viewport.value = node;
+		if (node == null) return;
+		node.addEventListener("scroll", measure, { passive: true });
+		if (typeof ResizeObserver !== "undefined") {
+			observer = new ResizeObserver(() => queueMeasure());
+			observer.observe(node);
+			if (content.value) observer.observe(content.value);
+		}
+		queueMeasure();
+	}
+	watch(content, (element) => {
+		if (element && observer) observer.observe(element);
+		queueMeasure();
+	});
+	watch([
+		axis,
+		overscroll,
+		stickyContainment
+	], queueMeasure);
+	onMounted(queueMeasure);
+	onBeforeUnmount(() => {
+		viewport.value?.removeEventListener("scroll", measure);
+		observer?.disconnect();
+	});
+	const viewportStyle = computed(() => {
+		const map = mapping.value;
+		const requestedX = requested("inline") && map.inline === "x" || requested("block") && map.block === "x";
+		const requestedY = requested("inline") && map.inline === "y" || requested("block") && map.block === "y";
+		const overflowingX = overflowInline.value && map.inline === "x" || overflowBlock.value && map.block === "x";
+		const overflowingY = overflowInline.value && map.inline === "y" || overflowBlock.value && map.block === "y";
+		const contains = overflowingX || overflowingY || stickyContainment.value === "always";
+		const scrollsX = stickyContainment.value === "always" ? requestedX : overflowingX;
+		const scrollsY = stickyContainment.value === "always" ? requestedY : overflowingY;
+		const style = {
+			overflowX: contains ? scrollsX ? "auto" : "hidden" : "clip",
+			overflowY: contains ? scrollsY ? "auto" : "hidden" : "clip"
+		};
+		if (requested("inline")) style[map.inline === "x" ? "overscrollBehaviorX" : "overscrollBehaviorY"] = overscroll.value === "contain" && inline.value.isScrollable ? "contain" : "auto";
+		if (requested("block")) style[map.block === "x" ? "overscrollBehaviorX" : "overscrollBehaviorY"] = overscroll.value === "contain" && block.value.isScrollable ? "contain" : "auto";
+		return style;
+	});
+	const scrollable = computed(() => inline.value.isScrollable || block.value.isScrollable);
+	return {
+		viewport: bind,
+		content,
+		viewportAttrs: computed(() => ({
+			"role": options.role ?? "group",
+			"aria-label": options.label,
+			"tabindex": scrollable.value ? 0 : void 0,
+			"data-scroll-axis": axis.value,
+			"data-scrollable-inline": inline.value.isScrollable ? "true" : void 0,
+			"data-scrollable-block": block.value.isScrollable ? "true" : void 0,
+			"data-scroll-inline-start": inline.value.atStart ? "true" : void 0,
+			"data-scroll-inline-end": inline.value.atEnd ? "true" : void 0,
+			"data-scroll-block-start": block.value.atStart ? "true" : void 0,
+			"data-scroll-block-end": block.value.atEnd ? "true" : void 0
+		})),
+		viewportStyle,
+		state: computed(() => ({
+			inline: inline.value,
+			block: block.value
+		}))
+	};
+}
+//#endregion
+export { useScrollableArea as t };

package/dist/useTimeValue-DWk6oTAZ.js

@@ -0,0 +1,113 @@
+import { computed, onMounted, onScopeDispose, shallowRef } from "vue";
+//#region src/composables/useCoarsePointer.ts
+/** 粗指针（触摸）为 true。服务端和细指针设备为 false。 */
+function useCoarsePointer() {
+	const coarse = shallowRef(false);
+	let query;
+	function update() {
+		coarse.value = query?.matches ?? false;
+	}
+	onMounted(() => {
+		query = window.matchMedia("(pointer: coarse)");
+		update();
+		query.addEventListener("change", update);
+	});
+	onScopeDispose(() => {
+		query?.removeEventListener("change", update);
+	});
+	return computed(() => coarse.value);
+}
+//#endregion
+//#region src/composables/useTimeValue.ts
+const DISPLAY_TIME = /^(\d{1,2})(?::(\d{2}))?(?::(\d{2}))?\s*([ap])\.?m\.?$/i;
+const COMPACT_TIME = /^(\d{2})(\d{2})(\d{2})?$/;
+const ISO_TIME = /^(\d{2}):(\d{2})(?::(\d{2}))?$/;
+function clampPart(value, max) {
+	return Number.isInteger(value) && value >= 0 && value <= max;
+}
+function parseISOTime(value) {
+	const match = ISO_TIME.exec(value.trim());
+	if (!match) return null;
+	const hours = Number(match[1]);
+	const minutes = Number(match[2]);
+	const seconds = match[3] == null ? 0 : Number(match[3]);
+	if (!clampPart(hours, 23) || !clampPart(minutes, 59) || !clampPart(seconds, 59)) return null;
+	return {
+		hours,
+		minutes,
+		seconds
+	};
+}
+function formatISOTime(time, hasSeconds) {
+	const hours = String(time.hours).padStart(2, "0");
+	const minutes = String(time.minutes).padStart(2, "0");
+	const seconds = String(time.seconds).padStart(2, "0");
+	return hasSeconds ? `${hours}:${minutes}:${seconds}` : `${hours}:${minutes}`;
+}
+function formatDisplayTime(value, hourFormat, hasSeconds) {
+	const parsed = parseISOTime(value);
+	if (!parsed) return value;
+	if (hourFormat === "24h") return formatISOTime(parsed, hasSeconds);
+	const suffix = parsed.hours < 12 ? "AM" : "PM";
+	return `${parsed.hours % 12 || 12}:${String(parsed.minutes).padStart(2, "0")}${hasSeconds ? `:${String(parsed.seconds).padStart(2, "0")}` : ""} ${suffix}`;
+}
+function parseDisplayTime(text, hasSeconds) {
+	const trimmed = text.trim();
+	if (!trimmed) return null;
+	const meridiem = DISPLAY_TIME.exec(trimmed);
+	if (meridiem) {
+		let hours = Number(meridiem[1]);
+		const minutes = meridiem[2] == null ? 0 : Number(meridiem[2]);
+		const seconds = meridiem[3] == null ? 0 : Number(meridiem[3]);
+		if (!clampPart(hours, 12) || hours === 0 || !clampPart(minutes, 59) || !clampPart(seconds, 59)) return null;
+		const isPm = meridiem[4].toLowerCase() === "p";
+		if (hours === 12) hours = isPm ? 12 : 0;
+		else if (isPm) hours += 12;
+		return formatISOTime({
+			hours,
+			minutes,
+			seconds
+		}, hasSeconds);
+	}
+	const compact = COMPACT_TIME.exec(trimmed);
+	if (compact) return parseDisplayTime(`${compact[1]}:${compact[2]}${compact[3] ? `:${compact[3]}` : ""}`, hasSeconds);
+	const iso = parseISOTime(trimmed);
+	if (!iso) return null;
+	return formatISOTime(iso, hasSeconds);
+}
+function shiftTime(value, minuteDelta, hasSeconds) {
+	const parsed = parseISOTime(value) ?? {
+		hours: 0,
+		minutes: 0,
+		seconds: 0
+	};
+	const total = parsed.hours * 60 + parsed.minutes + minuteDelta;
+	const day = 1440;
+	const normalized = (total % day + day) % day;
+	return formatISOTime({
+		hours: Math.floor(normalized / 60),
+		minutes: normalized % 60,
+		seconds: parsed.seconds
+	}, hasSeconds);
+}
+function comparable(value) {
+	const parsed = parseISOTime(value);
+	if (!parsed) return value;
+	return formatISOTime(parsed, true);
+}
+function isTimeInRange(value, min, max) {
+	const current = comparable(value);
+	if (min && current < comparable(min)) return false;
+	if (max && current > comparable(max)) return false;
+	return true;
+}
+function resolveTimeSurface(options) {
+	const presentation = options.presentation ?? (options.nativePicker === "always" ? "native" : options.nativePicker === "never" ? "text-input" : "adaptive-native");
+	const needsTypedField = options.hasSeconds || options.increment !== 1;
+	if (presentation === "text-input" || presentation === "popover" || presentation === "bottom-sheet") return "text";
+	if (needsTypedField) return "text";
+	if (presentation === "native") return "native";
+	return options.coarse ? "native" : "text";
+}
+//#endregion
+export { parseISOTime as a, useCoarsePointer as c, parseDisplayTime as i, formatISOTime as n, resolveTimeSurface as o, isTimeInRange as r, shiftTime as s, formatDisplayTime as t };