@octane-xplat/ui 0.9.0 → 0.11.0

package/dist/native/text-slot.tsrx.js

@@ -0,0 +1,34 @@
+import { mapChildren, toChildArray } from "./child-array.js";
+import { defineUniversalComponent, universalPlan, universalValue } from "@nativescript-community/octane";
+//#region src/text-slot.tsrx
+var __octaneUniversalPlan0 = universalPlan("nativescript", {
+	"kind": "host",
+	"type": "label",
+	"props": { "whiteSpace": "normal" },
+	"bindings": [["className", 0]],
+	"children": [{
+		"kind": "slot",
+		"slot": 1
+	}]
+});
+var __octaneUniversalPlan1 = universalPlan("nativescript", {
+	"kind": "range",
+	"children": [{
+		"kind": "slot",
+		"slot": 0
+	}]
+});
+var TextSlot = defineUniversalComponent("nativescript", function TextSlot(props) {
+	const runs = [];
+	let text = null;
+	for (const child of toChildArray(props.children)) if (typeof child === "string" || typeof child === "number" || typeof child === "bigint") text = (text ?? "") + String(child);
+	else {
+		if (text !== null) runs.push(text);
+		text = null;
+		runs.push(child);
+	}
+	if (text !== null) runs.push(text);
+	return universalValue(__octaneUniversalPlan1, [mapChildren(runs, (child) => typeof child === "string" ? universalValue(__octaneUniversalPlan0, [props.className, child]) : child)]);
+}, { "module": "@nativescript-community/octane" });
+//#endregion
+export { TextSlot };

package/dist/native/time-format.js

@@ -0,0 +1,215 @@
+//#region src/time-format.ts
+var FULL_OPTIONS = {
+	year: "numeric",
+	month: "long",
+	day: "numeric",
+	hour: "numeric",
+	minute: "2-digit",
+	second: "2-digit",
+	timeZoneName: "short"
+};
+var TIME_OPTIONS = {
+	hour: "numeric",
+	minute: "2-digit"
+};
+var DATE_OPTIONS = {
+	year: "numeric",
+	month: "short",
+	day: "numeric"
+};
+var DATE_LONG_OPTIONS = {
+	year: "numeric",
+	month: "long",
+	day: "numeric"
+};
+var DATE_WEEKDAY_OPTIONS = {
+	weekday: "short",
+	month: "short",
+	day: "numeric",
+	year: "numeric"
+};
+var DATE_TIME_OPTIONS = {
+	year: "numeric",
+	month: "short",
+	day: "numeric",
+	...TIME_OPTIONS
+};
+function pad(n) {
+	return String(n).padStart(2, "0");
+}
+/** Wall-clock fields for an instant in a named zone via Intl parts. */
+function getTimeZoneParts(instant, timezoneID) {
+	const parts = new Intl.DateTimeFormat("en-US", {
+		timeZone: timezoneID,
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hourCycle: "h23",
+		calendar: "gregory"
+	}).formatToParts(new Date(instant));
+	const lookup = Object.fromEntries(parts.filter((part) => part.type !== "literal").map((part) => [part.type, Number(part.value)]));
+	return {
+		year: lookup.year,
+		month: lookup.month,
+		day: lookup.day,
+		hour: lookup.hour,
+		minute: lookup.minute,
+		second: lookup.second
+	};
+}
+function getWallClock(date, timeZone) {
+	return timeZone === void 0 ? {
+		year: date.getFullYear(),
+		month: date.getMonth() + 1,
+		day: date.getDate(),
+		hour: date.getHours(),
+		minute: date.getMinutes(),
+		second: date.getSeconds()
+	} : getTimeZoneParts(date.getTime(), timeZone);
+}
+/** Render one instant in one absolute format. Pure in its arguments. */
+function formatInstant(date, format, locale, { timeZone, isTimezoneShown = false, timeZoneNameStyle = "short" } = {}) {
+	const zone = timeZone === void 0 ? {} : { timeZone };
+	const zoneName = isTimezoneShown ? { timeZoneName: "short" } : {};
+	switch (format) {
+		case "full": return new Intl.DateTimeFormat(locale, {
+			...FULL_OPTIONS,
+			timeZoneName: timeZoneNameStyle,
+			...zone,
+			calendar: "gregory"
+		}).format(date);
+		case "date": return new Intl.DateTimeFormat(locale, {
+			...DATE_OPTIONS,
+			...zone,
+			calendar: "gregory"
+		}).format(date);
+		case "date_long": return new Intl.DateTimeFormat(locale, {
+			...DATE_LONG_OPTIONS,
+			...zone,
+			calendar: "gregory"
+		}).format(date);
+		case "date_weekday": return new Intl.DateTimeFormat(locale, {
+			...DATE_WEEKDAY_OPTIONS,
+			...zone,
+			calendar: "gregory"
+		}).format(date);
+		case "date_time": return new Intl.DateTimeFormat(locale, {
+			...DATE_TIME_OPTIONS,
+			...zoneName,
+			...zone,
+			calendar: "gregory"
+		}).format(date);
+		case "time": return new Intl.DateTimeFormat(locale, {
+			...TIME_OPTIONS,
+			...zoneName,
+			...zone
+		}).format(date);
+		case "system_date": {
+			const w = getWallClock(date, timeZone);
+			return `${w.year}-${pad(w.month)}-${pad(w.day)}`;
+		}
+		case "system_date_time": {
+			const w = getWallClock(date, timeZone);
+			return `${w.year}-${pad(w.month)}-${pad(w.day)} ${pad(w.hour)}:${pad(w.minute)}:${pad(w.second)}`;
+		}
+		case "system_time": {
+			const w = getWallClock(date, timeZone);
+			return `${pad(w.hour)}:${pad(w.minute)}:${pad(w.second)}`;
+		}
+		case "unix_seconds": return String(Math.floor(date.getTime() / 1e3));
+	}
+}
+var MINUTE = 60;
+var HOUR = 3600;
+var DAY = 86400;
+var MONTH = 30 * DAY;
+var YEAR = 365 * DAY;
+/** Values this close to now are usually clock skew, not a future instant. */
+var FUTURE_SKEW_TOLERANCE = 30;
+var formatters = /* @__PURE__ */ new Map();
+function getFormatter(locale, style, numeric) {
+	const key = JSON.stringify([
+		locale,
+		style,
+		numeric
+	]);
+	let formatter = formatters.get(key);
+	if (formatter == null) {
+		formatter = new Intl.RelativeTimeFormat(locale, {
+			numeric,
+			style
+		});
+		formatters.set(key, formatter);
+	}
+	return formatter;
+}
+/**
+* Locale-correct relative time: the fixed tier selection is ours, wording,
+* plural rules, and word order belong to the CLDR-backed formatter.
+*/
+function formatRelativeTime(date, now, locale, style = "long") {
+	const diffSeconds = Math.round((now.getTime() - date.getTime()) / 1e3);
+	const absDiff = Math.abs(diffSeconds);
+	if (absDiff < 10 || diffSeconds < 0 && absDiff <= FUTURE_SKEW_TOLERANCE) return getFormatter(locale, style, "auto").format(0, "second");
+	let count;
+	let unit;
+	if (absDiff < MINUTE) {
+		count = absDiff;
+		unit = "second";
+	} else if (absDiff < HOUR) {
+		count = Math.floor(absDiff / MINUTE);
+		unit = "minute";
+	} else if (absDiff < DAY) {
+		count = Math.floor(absDiff / HOUR);
+		unit = "hour";
+	} else if (absDiff < MONTH) {
+		count = Math.floor(absDiff / DAY);
+		unit = "day";
+	} else if (absDiff < YEAR) {
+		count = Math.floor(absDiff / MONTH);
+		unit = "month";
+	} else {
+		count = Math.floor(absDiff / YEAR);
+		unit = "year";
+	}
+	const value = diffSeconds < 0 ? count : -count;
+	return getFormatter(locale, style, style === "long" && unit === "day" && value === -1 ? "auto" : "always").format(value, unit);
+}
+/** Seconds threshold for 'auto' format: below this, relative; else date_time. */
+var DEFAULT_AUTO_THRESHOLD = 7 * DAY;
+/** Parse the `Timestamp.value` contract: number < 1e12 = Unix seconds,
+*  larger = ms; strings parse as dates (ISO 8601 recommended). */
+function parseTimestampValue(value) {
+	if (typeof value === "number") return new Date(value < 0xe8d4a51000 ? value * 1e3 : value);
+	return new Date(value);
+}
+/** Interval (ms) for a live relative timestamp's next update. */
+function getLiveInterval(diffSeconds) {
+	const absDiff = Math.abs(diffSeconds);
+	if (absDiff < MINUTE) return 1e3;
+	if (absDiff < HOUR) return 3e4;
+	if (absDiff < DAY) return 6e4;
+	return 3e5;
+}
+function isRelativeFormat(format) {
+	return format === "relative" || format === "relative_short";
+}
+function isAbsoluteFormat(format) {
+	return format !== "relative" && format !== "relative_short" && format !== "auto";
+}
+/** Resolve the 'auto' alias to the concrete format for a given diff. */
+function resolveTimestampFormat(format, diffSeconds, autoThreshold) {
+	return format === "auto" ? Math.abs(diffSeconds) <= autoThreshold ? "relative" : "date_time" : format;
+}
+/** The visible text for one instant in the effective (resolved) format. */
+function formatTimestampText(date, format, now, locale, isTimezoneShown) {
+	if (format === "relative") return formatRelativeTime(date, now, locale, "long");
+	if (format === "relative_short") return formatRelativeTime(date, now, locale, "narrow");
+	if (isAbsoluteFormat(format)) return formatInstant(date, format, locale, { isTimezoneShown });
+	return "";
+}
+//#endregion
+export { DEFAULT_AUTO_THRESHOLD, formatInstant, formatRelativeTime, formatTimestampText, getLiveInterval, isAbsoluteFormat, isRelativeFormat, parseTimestampValue, resolveTimestampFormat };

package/dist/native/timer-format.js

@@ -0,0 +1,49 @@
+//#region src/timer-format.ts
+var ONE_SECOND_MS = 1e3;
+var ONE_MINUTE_MS = 60 * ONE_SECOND_MS;
+var ONE_HOUR_SECONDS = 3600;
+var MAX_TIMEOUT_MS = 2147483647;
+function pad(value) {
+	return String(value).padStart(2, "0");
+}
+function resolveTimerFormat(format) {
+	return format === "clock" ? "clock" : "elapsed";
+}
+function elapsedMilliseconds(now, startTime) {
+	return Math.max(0, now - startTime);
+}
+function timerPresentation(elapsedMs, format) {
+	const elapsedSeconds = Math.floor(elapsedMs / ONE_SECOND_MS);
+	if (format === "clock") {
+		const hours = Math.floor(elapsedSeconds / ONE_HOUR_SECONDS);
+		const minutes = Math.floor(elapsedSeconds % ONE_HOUR_SECONDS / 60);
+		const seconds = elapsedSeconds % 60;
+		return {
+			dateTime: `PT${elapsedSeconds}S`,
+			text: hours > 0 ? `${String(hours)}:${pad(minutes)}:${pad(seconds)}` : `${String(minutes)}:${pad(seconds)}`
+		};
+	}
+	if (elapsedSeconds < 60) return {
+		dateTime: `PT${elapsedSeconds}S`,
+		text: `${String(elapsedSeconds)}s`
+	};
+	const totalMinutes = Math.floor(elapsedSeconds / 60);
+	if (totalMinutes < 60) return {
+		dateTime: `PT${elapsedSeconds}S`,
+		text: `${String(totalMinutes)}m ${pad(elapsedSeconds % 60)}s`
+	};
+	return {
+		dateTime: `PT${totalMinutes * 60}S`,
+		text: `${String(Math.floor(totalMinutes / 60))}h ${pad(totalMinutes % 60)}m`
+	};
+}
+/** Ms until the next visible change — also the cadence the tick loop uses.
+*  Elapsed mode relaxes to once a minute past the hour mark; a future
+*  startTime schedules the first tick for the start boundary. */
+function msUntilNextChange(now, startTime, elapsedMs, format) {
+	if (now < startTime) return Math.min(startTime - now + ONE_SECOND_MS, MAX_TIMEOUT_MS);
+	const precision = format === "elapsed" && elapsedMs >= ONE_HOUR_SECONDS * ONE_SECOND_MS ? ONE_MINUTE_MS : ONE_SECOND_MS;
+	return precision - elapsedMs % precision;
+}
+//#endregion
+export { elapsedMilliseconds, msUntilNextChange, resolveTimerFormat, timerPresentation };

package/dist/native/toast-context.js

@@ -0,0 +1,8 @@
+import { createContext } from "octane/universal/native";
+//#region src/toast-context.ts
+var ToastViewportContext = createContext(null);
+/** JSX-provider form — universal-renderer contexts are callables, not
+*  `.Provider` members (same aliasing as DialogProvider). */
+var ToastViewportProvider = ToastViewportContext;
+//#endregion
+export { ToastViewportContext, ToastViewportProvider };

package/dist/native/toast-service.tsrx.js

@@ -0,0 +1,280 @@
+import { topRootLayout } from "./root-layout.js";
+import { applyThemeClasses } from "./theme/theme-scheme.js";
+import { Popover } from "./Popover.tsrx.js";
+import { Toast } from "./Toast.tsrx.js";
+import { ToastViewportContext } from "./toast-context.js";
+import { dismissToast, pushToast, toastStore, toastTiming } from "./toast-store.js";
+import { createNativeScriptRoot, defineUniversalComponent, hookSlots, universalChildren, universalComponent, universalIf, universalPlan, universalProps, universalValue, useCallback, useContext } from "@nativescript-community/octane";
+import { GridLayout, isAndroid, isIOS } from "@nativescript/core";
+//#region src/toast-service.tsrx
+var _h$0 = /* @__PURE__ */ Symbol(/* @__PURE__ */ hookSlots(1));
+var __octaneUniversalPlan0 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var __octaneUniversalPlan1 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var __octaneUniversalPlan2 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var __octaneUniversalPlan3 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var EDGE_GAP = 16;
+var STACK_GAP = 8;
+var nativeViewports = /* @__PURE__ */ new Map();
+var hosts = /* @__PURE__ */ new Map();
+var syncing = false;
+var storeSubscribed = false;
+function registerNativeToastViewport(id, viewport) {
+	nativeViewports.set(id, viewport);
+	sync();
+	return () => {
+		nativeViewports.delete(id);
+		sync();
+	};
+}
+var positionFor = (entry) => entry.options.position ?? (entry.viewportId ? nativeViewports.get(entry.viewportId)?.position : void 0) ?? "bottomEnd";
+var rootLayoutFor = (entry) => (entry.viewportId ? nativeViewports.get(entry.viewportId)?.rl : void 0) ?? topRootLayout();
+var maxVisibleFor = (entry) => (entry.viewportId ? nativeViewports.get(entry.viewportId)?.maxVisible : void 0) ?? 5;
+function relayoutBucket(bucket) {
+	const rlEntries = bucket.map((e) => ({
+		entry: e,
+		host: hosts.get(e.id)
+	})).filter((x) => x.host != null);
+	let offset = 0;
+	for (let i = rlEntries.length - 1; i >= 0; i--) {
+		const { host } = rlEntries[i];
+		const top = host.position.startsWith("top");
+		const margin = EDGE_GAP + offset;
+		if (top) host.host.marginTop = margin;
+		else host.host.marginBottom = margin;
+		offset += (host.host.getActualSize?.().height || 0) + STACK_GAP;
+	}
+}
+function detach(entry) {
+	const cur = hosts.get(entry.id);
+	if (!cur) return;
+	hosts.delete(entry.id);
+	if (cur.timer) clearTimeout(cur.timer);
+	cur.unbindTheme();
+	cur.root.unmount?.();
+	const owner = cur.host.parent;
+	if (owner?.hasChild?.(cur.host)) {
+		if (typeof owner.getPopupIndex === "function" && owner.getPopupIndex(cur.host) === -1) owner.removeChild?.(cur.host);
+		else if (!cur.closing) {
+			cur.closing = true;
+			(owner.close?.(cur.host))?.catch((error) => {
+				console.error("[Toast] close failed", error);
+				if (owner.hasChild?.(cur.host)) owner.removeChild?.(cur.host);
+			});
+		}
+	}
+	syncBuckets();
+}
+function syncBuckets() {
+	const list = toastStore.get();
+	const groups = /* @__PURE__ */ new Map();
+	for (const e of list) {
+		const host = hosts.get(e.id);
+		if (!host) continue;
+		const key = `${host.rl}:${positionFor(e)}`;
+		const bucket = groups.get(key) ?? [];
+		bucket.push(e);
+		groups.set(key, bucket);
+	}
+	for (const bucket of groups.values()) relayoutBucket(bucket);
+}
+function mount(entry) {
+	const rl = rootLayoutFor(entry);
+	if (!rl) {
+		console.warn("[Toast] RootLayout is not mounted; toast was skipped");
+		return;
+	}
+	const position = positionFor(entry);
+	const top = position.startsWith("top");
+	const host = new GridLayout();
+	const unbindTheme = applyThemeClasses(host, "vx-toast-host");
+	host.horizontalAlignment = position.endsWith("Start") ? "left" : "right";
+	host.verticalAlignment = top ? "top" : "bottom";
+	if (top) host.marginTop = EDGE_GAP;
+	else host.marginBottom = EDGE_GAP;
+	Object.assign(host, isIOS ? entry.options.ios : isAndroid ? entry.options.android : void 0);
+	const root = createNativeScriptRoot(host);
+	const rec = {
+		host,
+		root,
+		timer: null,
+		unbindTheme,
+		position,
+		rl,
+		closing: false
+	};
+	hosts.set(entry.id, rec);
+	const timing = toastTiming(entry.options);
+	if (timing.isAutoHide) rec.timer = setTimeout(() => dismissToast(entry.id, "auto"), timing.autoHideDuration);
+	root.render(ToastEntryView, { entry });
+	host.on("layoutChanged", () => syncBuckets());
+	rl.open(host).catch((error) => {
+		console.error("[Toast] open failed", error);
+		detach(entry);
+		dismissToast(entry.id, "manual");
+	});
+}
+function sync() {
+	if (syncing) return;
+	syncing = true;
+	try {
+		const list = toastStore.get();
+		const visible = /* @__PURE__ */ new Set();
+		const buckets = /* @__PURE__ */ new Map();
+		for (const e of list) {
+			const key = `${rootLayoutFor(e) ?? ""}:${positionFor(e)}:${e.options.anchor ? "a" : ""}`;
+			const bucket = buckets.get(key) ?? [];
+			bucket.push(e);
+			buckets.set(key, bucket);
+		}
+		for (const bucket of buckets.values()) for (let i = 0; i < bucket.length; i++) if (i >= bucket.length - maxVisibleFor(bucket[i])) visible.add(bucket[i].id);
+		for (const entry of list) {
+			const cur = hosts.get(entry.id);
+			if (!visible.has(entry.id)) {
+				if (cur) detach(entry);
+				continue;
+			}
+			if (cur) {
+				cur.root.render(ToastEntryView, { entry });
+				continue;
+			}
+			mount(entry);
+		}
+		for (const id of [...hosts.keys()]) if (!list.some((e) => e.id === id)) detach({
+			id,
+			options: {}
+		});
+		syncBuckets();
+	} finally {
+		syncing = false;
+	}
+}
+var ToastEntryView = defineUniversalComponent("nativescript", function ToastEntryView(props) {
+	const entry = props.entry;
+	const top = positionFor(entry).startsWith("top");
+	const anchored = entry.options.anchor != null;
+	return universalValue(__octaneUniversalPlan3, [universalIf(anchored, () => {
+		return universalValue(__octaneUniversalPlan1, [universalComponent("nativescript", Popover, universalProps([
+			[
+				"set",
+				"open",
+				!entry.exiting
+			],
+			[
+				"set",
+				"anchor",
+				entry.options.anchor
+			],
+			[
+				"set",
+				"placement",
+				entry.options.placement ?? (top ? "top" : "bottom")
+			],
+			[
+				"set",
+				"dismissOnOutsideTap",
+				false
+			],
+			[
+				"set",
+				"onDismiss",
+				() => dismissToast(entry.id, "manual")
+			]
+		], universalChildren("nativescript", () => {
+			return universalValue(__octaneUniversalPlan0, [universalComponent("nativescript", Toast, universalProps([
+				[
+					"set",
+					"type",
+					entry.options.type ?? "info"
+				],
+				[
+					"set",
+					"body",
+					entry.options.body
+				],
+				[
+					"set",
+					"endContent",
+					entry.options.endContent
+				],
+				[
+					"set",
+					"renderContent",
+					entry.options.renderContent
+				],
+				[
+					"set",
+					"isExiting",
+					entry.exiting
+				],
+				[
+					"set",
+					"onDismiss",
+					(reason) => dismissToast(entry.id, reason)
+				]
+			]))]);
+		})))]);
+	}, () => {
+		return universalValue(__octaneUniversalPlan2, [universalComponent("nativescript", Toast, universalProps([
+			[
+				"set",
+				"type",
+				entry.options.type ?? "info"
+			],
+			[
+				"set",
+				"body",
+				entry.options.body
+			],
+			[
+				"set",
+				"endContent",
+				entry.options.endContent
+			],
+			[
+				"set",
+				"renderContent",
+				entry.options.renderContent
+			],
+			[
+				"set",
+				"isExiting",
+				entry.exiting
+			],
+			[
+				"set",
+				"onDismiss",
+				(reason) => dismissToast(entry.id, reason)
+			]
+		]))]);
+	})]);
+}, { "module": "@nativescript-community/octane" });
+function ensureSubscribed() {
+	if (storeSubscribed) return;
+	storeSubscribed = true;
+	toastStore.subscribe(sync);
+}
+function show(options, viewportId) {
+	ensureSubscribed();
+	const id = pushToast(options, viewportId);
+	sync();
+	return () => dismissToast(id, "manual");
+}
+var showToast = (options) => show(options, void 0);
+function useToast() {
+	const ctx = useContext(ToastViewportContext);
+	return useCallback((options) => show(options, ctx?.id), [ctx?.id], _h$0);
+}
+//#endregion
+export { registerNativeToastViewport, showToast, sync, useToast };

package/dist/native/toast-store.js

@@ -0,0 +1,68 @@
+import { createStore } from "./store.js";
+//#region src/toast-store.ts
+/** Module-scope toast queue — the single source of truth for every leaf.
+*  Cross-root state uses module stores (overlay roots never share context
+*  with the declaring tree on native); each leaf's stack reads this and
+*  owns only presentation. */
+var toastStore = createStore([]);
+var counter = 0;
+var mountedViewports = /* @__PURE__ */ new Set();
+/** Registers a mounted stack so orphaned entries can drain to the
+*  fallback instead of vanishing with their viewport. */
+function registerToastViewport(id) {
+	mountedViewports.add(id);
+	return () => {
+		mountedViewports.delete(id);
+	};
+}
+/** Push a toast. Returns the entry id ('' when a same-`uniqueID` toast
+*  with `collisionBehavior: 'ignore'` suppressed it). Overwrite collision
+*  swaps the entry in place — the replaced toast's `onHide` does NOT fire
+*  (it was superseded, not dismissed). */
+function pushToast(options, viewportId) {
+	const list = toastStore.get();
+	const uniqueID = options.uniqueID;
+	if (uniqueID && (options.collisionBehavior ?? "overwrite") === "ignore" && list.some((t) => t.options.uniqueID === uniqueID)) return "";
+	const entry = {
+		id: `xplat-toast-${++counter}`,
+		options,
+		viewportId
+	};
+	if (uniqueID) {
+		if (list.findIndex((t) => t.options.uniqueID === uniqueID) >= 0) {
+			toastStore.set(list.map((t) => t.options.uniqueID === uniqueID ? entry : t));
+			return entry.id;
+		}
+	}
+	toastStore.set([...list, entry]);
+	return entry.id;
+}
+/** Dismiss a toast: fires `onHide` exactly once, flags `exiting` for the
+*  exit presentation, then prunes the entry after `TOAST_EXIT_MS`.
+*  Idempotent — a second call while exiting is a no-op. */
+function dismissToast(id, reason = "manual") {
+	if (!id) return;
+	const list = toastStore.get();
+	const entry = list.find((t) => t.id === id);
+	if (!entry || entry.exiting) return;
+	entry.options.onHide?.(reason);
+	toastStore.set(list.map((t) => t.id === id ? {
+		...t,
+		exiting: true
+	} : t));
+	setTimeout(() => {
+		toastStore.set(toastStore.get().filter((t) => t.id !== id));
+	}, 220);
+}
+/** Resolved auto-hide contract: error toasts hold for manual dismissal
+*  unless `isAutoHide` overrides; info toasts auto-hide after
+*  `autoHideDuration` (default 5000ms). */
+function toastTiming(options) {
+	const type = options.type ?? "info";
+	return {
+		isAutoHide: options.isAutoHide ?? type !== "error",
+		autoHideDuration: Math.max(0, options.autoHideDuration ?? 5e3)
+	};
+}
+//#endregion
+export { dismissToast, pushToast, registerToastViewport, toastStore, toastTiming };