@octane-xplat/ui 0.7.3 → 0.10.0

package/dist/native/stack-layout.js

@@ -0,0 +1,72 @@
+//#region src/stack-layout.ts
+/** Astryx spacing step → dips (step × 4, matching the upstream
+*  `--spacing-N` scale: 0.5→2, 1→4, 2→8, 3→12, 4→16, …, 10→40). */
+function spacingPx(step) {
+	return step == null ? void 0 : step * 4;
+}
+var JUSTIFY = {
+	start: "flex-start",
+	center: "center",
+	end: "flex-end",
+	between: "space-between",
+	around: "space-around",
+	evenly: "space-evenly"
+};
+var ALIGN = {
+	start: "flex-start",
+	center: "center",
+	end: "flex-end",
+	stretch: "stretch"
+};
+var ALIGN_SELF = {
+	start: "flex-start",
+	end: "flex-end"
+};
+/** Resolve Stack's directional alignment + spacing props into flex values.
+*  `hAlign`/`vAlign` follow the physical axes; `justify`/`align` alias the
+*  main/cross axes of the active direction. */
+function resolveStackLayout(props) {
+	const horizontal = (props.direction ?? "vertical") === "horizontal";
+	const resolvedHAlign = props.hAlign ?? (horizontal ? props.justify : props.align);
+	const resolvedVAlign = props.vAlign ?? (horizontal ? props.align : props.justify);
+	const main = horizontal ? resolvedHAlign : resolvedVAlign;
+	const cross = horizontal ? resolvedVAlign : resolvedHAlign;
+	const paddingInlineStart = spacingPx(props.paddingInlineStart ?? props.paddingInline ?? props.padding);
+	const paddingInlineEnd = spacingPx(props.paddingInlineEnd ?? props.paddingInline ?? props.padding);
+	const paddingBlockStart = spacingPx(props.paddingBlockStart ?? props.paddingBlock ?? props.padding);
+	const paddingBlockEnd = spacingPx(props.paddingBlockEnd ?? props.paddingBlock ?? props.padding);
+	return {
+		flexDirection: horizontal ? "row" : "column",
+		justifyContent: main != null ? JUSTIFY[main] ?? main : void 0,
+		alignItems: cross != null ? ALIGN[cross] ?? cross : void 0,
+		flexWrap: props.wrap != null && props.wrap !== "nowrap" ? props.wrap : void 0,
+		gap: spacingPx(props.gap),
+		scrollable: props.isScrollable === true,
+		paddingTop: paddingBlockStart,
+		paddingBottom: paddingBlockEnd,
+		paddingLeft: paddingInlineStart,
+		paddingRight: paddingInlineEnd,
+		paddingInlineStart,
+		paddingInlineEnd,
+		paddingBlockStart,
+		paddingBlockEnd
+	};
+}
+/** The style fragment for StackItem — `fill` grows (and is allowed to
+*  shrink) into remaining space; the min-size reset lets it become a
+*  scroll region under a flex parent. */
+function stackItemStyle(props) {
+	const style = {};
+	if (props.size === "fill") {
+		style.flexGrow = 1;
+		style.flexShrink = 1;
+	} else {
+		style.flexGrow = 0;
+		style.flexShrink = 0;
+	}
+	if (props.crossAlignSelf != null) style.alignSelf = ALIGN_SELF[props.crossAlignSelf] ?? props.crossAlignSelf;
+	if (props.isScrollable) style.overflow = "auto";
+	return style;
+}
+//#endregion
+export { resolveStackLayout, spacingPx, stackItemStyle };

package/dist/native/svg-glyph.js

@@ -0,0 +1,12 @@
+//#region src/svg-glyph.ts
+/** IconGlyph → a full `<svg>` string for SVGView. `svg` path data gets a
+*  `<path>` with the requested fill; `markup` wraps inside a viewBox shell
+*  with `color`/`fill` set on the root so `currentColor` and default-fill
+*  children pick up the tint. */
+function glyphSvgMarkup(glyph, color) {
+	const viewBox = glyph.viewBox ?? "0 0 24 24";
+	if (glyph.markup) return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox}"${color ? ` color="${color}" fill="${color}"` : ""}>${glyph.markup}</svg>`;
+	if (glyph.svg) return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox}"><path d="${glyph.svg}" fill="${color ?? "currentColor"}"/></svg>`;
+}
+//#endregion
+export { glyphSvgMarkup };

package/dist/native/svg-source.js

@@ -0,0 +1,29 @@
+import { glyphSvgMarkup } from "./svg-glyph.js";
+//#region src/svg-source.ts
+var SVG_DATA_URI = /^data:image\/svg\+xml[;,]/i;
+var SVG_PATH = /\.svg([?#].*)?$/i;
+var EMPTY_SVG = "<svg xmlns=\"http://www.w3.org/2000/svg\"/>";
+/** True when an `src` carries SVG: inline markup, an svg data URI, or an
+*  .svg path/URL. Anything else stays on the raster <image> path. */
+function isSvgSrc(src) {
+	return src.trimStart().startsWith("<svg") || SVG_DATA_URI.test(src) || SVG_PATH.test(src);
+}
+/** Normalize an svg-shaped src into SVGView's grammar: file/resource paths and
+*  markup pass through, data URIs decode to markup, remote URLs fetch to
+*  markup (SVGView has no fetch of its own — it awaits promise srcs). */
+function svgSource(src) {
+	if (SVG_DATA_URI.test(src)) {
+		const comma = src.indexOf(",");
+		const body = src.slice(comma + 1);
+		if (src.slice(0, comma).endsWith(";base64")) {
+			const atob = globalThis.atob;
+			if (!atob) return EMPTY_SVG;
+			return atob(body);
+		}
+		return decodeURIComponent(body);
+	}
+	if (/^https?:\/\//.test(src)) return fetch(src).then((r) => r.ok ? r.text() : EMPTY_SVG).catch(() => EMPTY_SVG);
+	return src;
+}
+//#endregion
+export { glyphSvgMarkup, isSvgSrc, svgSource };

package/dist/native/svg.mobile.js

@@ -1,40 +1,8 @@
+import { glyphSvgMarkup } from "./svg-glyph.js";
+import { isSvgSrc, svgSource } from "./svg-source.js";
 import { registerElement } from "@nativescript-community/octane";
-import { SVGView } from "./src/vendor/ui-svg";
+import { SVGView } from "./vendor/ui-svg";
 //#region src/svg.mobile.ts
 registerElement("svgview", SVGView);
-var SVG_DATA_URI = /^data:image\/svg\+xml[;,]/i;
-var SVG_PATH = /\.svg([?#].*)?$/i;
-var EMPTY_SVG = "<svg xmlns=\"http://www.w3.org/2000/svg\"/>";
-/** True when an `src` carries SVG: inline markup, an svg data URI, or an
-*  .svg path/URL. Anything else stays on the raster <image> path. */
-function isSvgSrc(src) {
-	return src.trimStart().startsWith("<svg") || SVG_DATA_URI.test(src) || SVG_PATH.test(src);
-}
-/** Normalize an svg-shaped src into SVGView's grammar: file/resource paths and
-*  markup pass through, data URIs decode to markup, remote URLs fetch to
-*  markup (SVGView has no fetch of its own — it awaits promise srcs). */
-function svgSource(src) {
-	if (SVG_DATA_URI.test(src)) {
-		const comma = src.indexOf(",");
-		const body = src.slice(comma + 1);
-		if (src.slice(0, comma).endsWith(";base64")) {
-			const atob = globalThis.atob;
-			if (!atob) return EMPTY_SVG;
-			return atob(body);
-		}
-		return decodeURIComponent(body);
-	}
-	if (/^https?:\/\//.test(src)) return fetch(src).then((r) => r.ok ? r.text() : EMPTY_SVG).catch(() => EMPTY_SVG);
-	return src;
-}
-/** IconGlyph → a full `<svg>` string for SVGView. `svg` path data gets a
-*  `<path>` with the requested fill; `markup` wraps inside a viewBox shell
-*  with `color`/`fill` set on the root so `currentColor` and default-fill
-*  children pick up the tint. */
-function glyphSvgMarkup(glyph, color) {
-	const viewBox = glyph.viewBox ?? "0 0 24 24";
-	if (glyph.markup) return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox}"${color ? ` color="${color}" fill="${color}"` : ""}>${glyph.markup}</svg>`;
-	if (glyph.svg) return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox}"><path d="${glyph.svg}" fill="${color ?? "currentColor"}"/></svg>`;
-}
 //#endregion
 export { glyphSvgMarkup, isSvgSrc, svgSource };

package/dist/native/tap-to-blur.ios.js

@@ -1,4 +1,3 @@
-import __decorate from "./_virtual/_@oxc-project_runtime@0.150.0/helpers/esm/decorate.js";
 //#region src/tap-to-blur.ios.ts
 /** Tap-outside-to-blur: iOS keeps a focused UITextField/UITextView as first
 *  responder until something else takes it, so a tap on blank chrome never
@@ -22,6 +21,7 @@ function attachTapToBlur(view) {
 		iosDetach();
 	};
 }
+var iosTargetClass = null;
 var iosCount = 0;
 var iosTarget = null;
 var iosRecognizer = null;
@@ -32,16 +32,7 @@ function iosAttach() {
 	const appWin = appWindow();
 	if (!appWin) return;
 	iosWindow = appWin;
-	let TapToBlurRecognizerTarget = class TapToBlurRecognizerTarget extends NSObject {
-		static {
-			this.ObjCProtocols = [UIGestureRecognizerDelegate];
-		}
-		static {
-			this.ObjCExposedMethods = { tap: {
-				returns: interop.types.void,
-				params: [UITapGestureRecognizer]
-			} };
-		}
+	if (!iosTargetClass) iosTargetClass = NSObject.extend({
 		gestureRecognizerShouldReceiveTouch(_recognizer, touch) {
 			let hit = touch.view;
 			while (hit) {
@@ -51,14 +42,20 @@ function iosAttach() {
 				hit = hit.superview;
 			}
 			return true;
-		}
+		},
 		tap(_recognizer) {
 			iosWindow.endEditing(true);
 		}
-	};
-	TapToBlurRecognizerTarget = __decorate([NativeClass], TapToBlurRecognizerTarget);
-	iosTarget = TapToBlurRecognizerTarget.new();
-	iosRecognizer = UITapGestureRecognizer.alloc().initWithTargetAction(iosTarget, "tap");
+	}, {
+		name: "XplatTapToBlurRecognizerTarget",
+		protocols: [UIGestureRecognizerDelegate],
+		exposedMethods: { "tap:": {
+			returns: interop.types.void,
+			params: [interop.types.id]
+		} }
+	});
+	iosTarget = iosTargetClass.new();
+	iosRecognizer = UITapGestureRecognizer.alloc().initWithTargetAction(iosTarget, "tap:");
 	iosRecognizer.delegate = iosTarget;
 	iosRecognizer.cancelsTouchesInView = false;
 	appWin.addGestureRecognizer(iosRecognizer);

package/dist/native/text-focus.js

@@ -0,0 +1,10 @@
+//#region src/text-focus.ts
+/** Dismiss the keyboard and release native editing focus. NativeScript's
+* dismissSoftInput returns void; its return value is not a fallback signal. */
+function blurText(view) {
+	if (typeof view.dismissSoftInput === "function") view.dismissSoftInput();
+	else view.blur?.();
+	view.android?.clearFocus?.();
+}
+//#endregion
+export { blurText };

package/dist/native/text-role.js

@@ -0,0 +1,50 @@
+//#region src/text-role.ts
+var VALID_TYPES = /* @__PURE__ */ new Set([
+	"body",
+	"large",
+	"label",
+	"supporting",
+	"code",
+	"display-1",
+	"display-2",
+	"display-3",
+	"inherit"
+]);
+var VALID_SIZES = /* @__PURE__ */ new Set([
+	"4xs",
+	"3xs",
+	"2xs",
+	"xsm",
+	"sm",
+	"base",
+	"lg",
+	"xl",
+	"2xl",
+	"3xl",
+	"4xl"
+]);
+var VALID_COLORS = /* @__PURE__ */ new Set([
+	"primary",
+	"secondary",
+	"disabled",
+	"placeholder",
+	"accent",
+	"inherit"
+]);
+var VALID_WEIGHTS = /* @__PURE__ */ new Set([
+	"normal",
+	"medium",
+	"semibold",
+	"bold"
+]);
+/** Class list for the type/color/weight axes; null when nothing applies. */
+function textRoleClasses(props) {
+	const out = [];
+	if (props.type && VALID_TYPES.has(props.type)) out.push(`vx-type-${props.type}`);
+	if (props.size && VALID_SIZES.has(props.size)) out.push(`vx-size-${props.size}`);
+	if (props.color && VALID_COLORS.has(props.color)) out.push(`vx-color-${props.color}`);
+	if (props.weight && VALID_WEIGHTS.has(props.weight)) out.push(`vx-weight-${props.weight}`);
+	return out;
+}
+//#endregion
+export { textRoleClasses };

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/text-write.js

@@ -1,5 +1,10 @@
 //#region src/text-write.ts
-/** Controlled `text` write for TextInput/TextArea leaves. The driver's
+var writing = /* @__PURE__ */ new WeakSet();
+/** Whether a textChange is the synchronous echo of our controlled write. */
+function isWritingText(view) {
+	return writing.has(view);
+}
+/** Controlled `text` write for TextInput/TextArea/SearchInput leaves. The driver's
 *  generic prop path writes view.text verbatim; on Android the EditText
 *  setText resets the cursor to 0 on every controlled write. Park and
 *  restore the selection around the write (clamped to the new length so an
@@ -11,17 +16,19 @@ function writeText(view, value) {
 	const next = value ?? "";
 	if (!view || view.text === next) return;
 	const et = view.android;
-	if (!et) {
+	const start = et?.getSelectionStart?.() ?? -1;
+	const end = et?.getSelectionEnd?.() ?? -1;
+	const nested = writing.has(view);
+	writing.add(view);
+	try {
 		view.text = next;
-		return;
-	}
-	const start = et.getSelectionStart?.() ?? -1;
-	const end = et.getSelectionEnd?.() ?? -1;
-	view.text = next;
-	if (start >= 0) {
-		const len = next.length;
-		et.setSelection(Math.min(start, len), Math.min(end >= 0 ? end : start, len));
+		if (start >= 0) {
+			const len = next.length;
+			et.setSelection(Math.min(start, len), Math.min(end >= 0 ? end : start, len));
+		}
+	} finally {
+		if (!nested) writing.delete(view);
 	}
 }
 //#endregion
-export { writeText };
+export { isWritingText, writeText };

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 };