@octane-xplat/ui 0.7.3 → 0.10.0

package/dist/native/busy-lane.js

@@ -0,0 +1,23 @@
+import { createContext } from "octane/universal/native";
+//#region src/busy-lane.ts
+function createBusyIndicatorLane() {
+	let isBusy = false;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		onBusyChange(next) {
+			if (isBusy === next) return;
+			isBusy = next;
+			for (const listener of listeners) listener();
+		},
+		subscribe(onStoreChange) {
+			listeners.add(onStoreChange);
+			return () => listeners.delete(onStoreChange);
+		},
+		getIsBusy: () => isBusy
+	};
+}
+/** The wrapper's lane, or null when the base renders its own indicator. */
+var BusyLaneContext = createContext(null);
+var BusyLaneProvider = BusyLaneContext;
+//#endregion
+export { BusyLaneContext, BusyLaneProvider, createBusyIndicatorLane };

package/dist/native/button-group-context.js

@@ -0,0 +1,11 @@
+import { createContext, useContext } from "octane/universal/native";
+//#region src/button-group-context.ts
+var ButtonGroupContext = createContext(null);
+var ButtonGroupProvider = ButtonGroupContext;
+/** Button (and grouped trigger components) read group membership here;
+*  returns null outside a ButtonGroup. */
+function useButtonGroup() {
+	return useContext(ButtonGroupContext);
+}
+//#endregion
+export { ButtonGroupContext, ButtonGroupProvider, useButtonGroup };

package/dist/native/calendar-core.js

@@ -0,0 +1,216 @@
+import { daysInMonth, formatMonthYear, getStandaloneShortWeekdayNames, normalizeDayOfWeek, plainDateAddDays, plainDateAddMonths, plainDateCreate, plainDateDiffDays, plainDateFromISO, plainDateGetWeekNumber, plainDateIsAfter, plainDateIsBefore, plainDateIsEqual, plainDateToDate, plainDateToISO, plainDateToday, resolveLocale } from "./datetime.js";
+//#region src/calendar-core.ts
+/**
+* Pure calendar engine shared by every Calendar leaf — month grids, selection
+* state, constraint evaluation, range-pick reduction, and navigation bounds.
+* No hooks, no DOM, no platform imports.
+*/
+function isSameDay(a, b) {
+	return a === b;
+}
+function isDateInRange(iso, range) {
+	return iso >= range.start && iso <= range.end;
+}
+function getWeekNumber(iso) {
+	const pd = plainDateFromISO(iso);
+	return pd ? plainDateGetWeekNumber(pd) : 0;
+}
+/**
+* Build the week grid for a month. Outside-month days pad the first/last
+* week so every row has 7 cells; fixed grids (`hasVariableRowCount` false,
+* the default) always emit 6 weeks so the calendar height never shifts
+* between months.
+*/
+function buildMonthGrid(year, month, weekStartsOn, hasVariableRowCount = false, locale) {
+	const start = normalizeDayOfWeek(weekStartsOn);
+	const loc = locale ?? resolveLocale();
+	const names = getStandaloneShortWeekdayNames(loc);
+	const dayNames = Array.from({ length: 7 }, (_, i) => names[(start + i) % 7]);
+	const first = plainDateCreate(year, month, 1);
+	const lead = (plainDateToDate(first).getDay() - start + 7) % 7;
+	const gridStart = plainDateAddDays(first, -lead);
+	const monthDays = daysInMonth(year, month);
+	const last = plainDateCreate(year, month, monthDays);
+	const lastDow = plainDateToDate(last).getDay();
+	const trail = (start + 6 - lastDow + 7) % 7;
+	const totalDays = hasVariableRowCount ? lead + monthDays + trail : 42;
+	const weekCount = Math.ceil(totalDays / 7);
+	const today = plainDateToday();
+	const weeks = [];
+	for (let w = 0; w < weekCount; w++) {
+		const week = [];
+		for (let d = 0; d < 7; d++) {
+			const date = plainDateAddDays(gridStart, w * 7 + d);
+			const dow = plainDateToDate(date).getDay();
+			week.push({
+				date,
+				iso: plainDateToISO(date),
+				dayOfMonth: date.day,
+				isToday: plainDateIsEqual(date, today),
+				isOutsideMonth: date.month !== month || date.year !== year,
+				isWeekend: dow === 0 || dow === 6,
+				isSunday: dow === 0,
+				isMonday: dow === 1,
+				isFirstWeekOfMonth: date.day <= 7 && !plainDateIsBefore(date, first),
+				isLastWeekOfMonth: date.day > monthDays - 7 && !plainDateIsAfter(date, last)
+			});
+		}
+		weeks.push(week);
+	}
+	return {
+		year,
+		month,
+		weeks,
+		dayNames
+	};
+}
+function monthLabel(year, month, locale) {
+	return formatMonthYear(year, month, locale);
+}
+function createDateDisabledCheck(input) {
+	const minPd = input.min ? plainDateFromISO(input.min) : null;
+	const maxPd = input.max ? plainDateFromISO(input.max) : null;
+	const anchorPd = input.rangeAnchor ? plainDateFromISO(input.rangeAnchor) : null;
+	return (date) => {
+		if (minPd && plainDateIsBefore(date, minPd)) return true;
+		if (maxPd && plainDateIsAfter(date, maxPd)) return true;
+		if (input.dateConstraints) {
+			for (const constraint of input.dateConstraints) if (!constraint(plainDateToDate(date))) return true;
+		}
+		if (anchorPd) {
+			const span = Math.abs(plainDateDiffDays(date, anchorPd)) + 1;
+			if (input.maxRangeSpan != null && span > input.maxRangeSpan) return true;
+			if (input.minRangeSpan != null && span < input.minRangeSpan && !plainDateIsEqual(date, anchorPd)) return true;
+		}
+		return false;
+	};
+}
+/** Validate a complete range at every commit boundary, including presets.
+* Bounds/predicates apply to endpoints; interior days are not constrained. */
+function isDateRangeAllowed(range, input) {
+	const start = plainDateFromISO(range.start);
+	const end = plainDateFromISO(range.end);
+	if (!start || !end || plainDateIsAfter(start, end)) return false;
+	const span = plainDateDiffDays(end, start) + 1;
+	if (span < (input.minRangeSpan ?? 1)) return false;
+	if (input.maxRangeSpan != null && span > input.maxRangeSpan) return false;
+	const isDisabled = createDateDisabledCheck({
+		...input,
+		rangeAnchor: null
+	});
+	return !isDisabled(start) && !isDisabled(end);
+}
+/** Second-pick reducer: earlier pick → ordered commit; same-day pick →
+*  single-day range when minSpan allows, else cancel the in-progress
+*  selection. */
+function applyRangePick(anchor, iso, minRangeSpan) {
+	const day = plainDateFromISO(iso);
+	const anchorPd = plainDateFromISO(anchor);
+	if (!day || !anchorPd) return { kind: "cancel" };
+	if (plainDateIsEqual(day, anchorPd)) {
+		if ((minRangeSpan ?? 1) > 1) return { kind: "cancel" };
+		return {
+			kind: "commit",
+			range: {
+				start: iso,
+				end: iso
+			}
+		};
+	}
+	return {
+		kind: "commit",
+		range: plainDateIsBefore(day, anchorPd) ? {
+			start: iso,
+			end: anchor
+		} : {
+			start: anchor,
+			end: iso
+		}
+	};
+}
+/** First-of-month basis for everything that navigates. */
+function monthStart(pd) {
+	return {
+		year: pd.year,
+		month: pd.month,
+		day: 1
+	};
+}
+/** Initial focus precedence: explicit focusDate → selected value → today,
+*  clamped into [min, max] so an all-disabled window still opens on its
+*  nearest bound. With two months the base month shifts so `max` isn't
+*  stranded in an out-of-range trailing pane. */
+function getInitialFocusDate(input) {
+	const explicit = input.focusDate ? plainDateFromISO(input.focusDate) : null;
+	const selectedRaw = typeof input.value === "string" ? input.value : input.value?.start;
+	const selected = selectedRaw ? plainDateFromISO(selectedRaw) : null;
+	const minPd = input.min ? plainDateFromISO(input.min) : null;
+	const maxPd = input.max ? plainDateFromISO(input.max) : null;
+	let base = explicit ?? selected ?? plainDateToday();
+	if (minPd && plainDateIsBefore(base, minPd)) base = minPd;
+	if (maxPd && plainDateIsAfter(base, maxPd)) base = maxPd;
+	if ((input.numberOfMonths ?? 1) > 1) {
+		const leadingMonthEnd = plainDateCreate(base.year, base.month, daysInMonth(base.year, base.month));
+		if (minPd && plainDateIsBefore(leadingMonthEnd, minPd)) {
+			base = plainDateAddMonths(monthStart(base), 1);
+			if (base.day > daysInMonth(base.year, base.month)) base = {
+				...base,
+				day: daysInMonth(base.year, base.month)
+			};
+		}
+		if (maxPd) {
+			const trailingStart = monthStart(plainDateAddMonths(monthStart(base), 1));
+			if (plainDateIsAfter(trailingStart, maxPd)) base = monthStart(plainDateAddMonths(monthStart(base), -1));
+		}
+	}
+	return base;
+}
+function navigationBounds(baseMonth, numberOfMonths, min, max) {
+	const minPd = min ? plainDateFromISO(min) : null;
+	const maxPd = max ? plainDateFromISO(max) : null;
+	const prevMonth = plainDateAddMonths(baseMonth, -1);
+	const prevEnd = plainDateCreate(prevMonth.year, prevMonth.month, daysInMonth(prevMonth.year, prevMonth.month));
+	const nextStart = plainDateAddMonths(baseMonth, numberOfMonths);
+	return {
+		canNavigatePrevious: !(minPd && plainDateIsBefore(prevEnd, minPd)),
+		canNavigateNext: !(maxPd && plainDateIsAfter(nextStart, maxPd))
+	};
+}
+function computeDayCellState(day, opts) {
+	const disabled = opts.isDateDisabled(day.date);
+	if (day.isOutsideMonth) return {
+		isSelected: false,
+		isRangeStart: false,
+		isRangeEnd: false,
+		isInRange: false,
+		isPendingStart: false,
+		isDisabled: true
+	};
+	const iso = day.iso;
+	if (opts.mode === "single") return {
+		isSelected: (typeof opts.value === "string" ? opts.value : void 0) === iso,
+		isRangeStart: false,
+		isRangeEnd: false,
+		isInRange: false,
+		isPendingStart: false,
+		isDisabled: disabled
+	};
+	const range = typeof opts.value === "object" && opts.value ? opts.value : void 0;
+	const anchor = opts.rangeAnchor ?? null;
+	return {
+		isSelected: false,
+		isRangeStart: range ? range.start === iso : anchor === iso,
+		isRangeEnd: range ? range.end === iso : false,
+		isInRange: !!range && iso > range.start && iso < range.end || !!anchor && iso > anchor && !disabled,
+		isPendingStart: !range && anchor === iso,
+		isDisabled: disabled
+	};
+}
+/** Whether an in-pane day carries the range band — committed span plus the
+*  pending anchor. Outside-month pads never carry it (they would duplicate
+*  the real day's styling in the adjacent pane). */
+function dayCarriesBand(state) {
+	return state.isInRange || state.isRangeStart || state.isRangeEnd;
+}
+//#endregion
+export { applyRangePick, buildMonthGrid, computeDayCellState, createDateDisabledCheck, dayCarriesBand, getInitialFocusDate, getWeekNumber, isDateInRange, isDateRangeAllowed, isSameDay, monthLabel, monthStart, navigationBounds };

package/dist/native/calendar-hooks.tsrx.js

@@ -0,0 +1,62 @@
+import { plainDateAddMonths, plainDateFromISO, plainDateToISO } from "./datetime.js";
+import { buildMonthGrid, createDateDisabledCheck, getInitialFocusDate, monthStart, navigationBounds } from "./calendar-core.js";
+import { hookSlots, useMemo, useState } from "@nativescript-community/octane";
+//#region src/calendar-hooks.tsrx
+var _hs$ = /* @__PURE__ */ hookSlots(3);
+var _h$0 = /* @__PURE__ */ Symbol(_hs$);
+var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
+var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
+function useCalendarConstraints(options) {
+	return { isDateDisabled: useMemo(() => createDateDisabledCheck(options), [
+		options.min,
+		options.max,
+		options.dateConstraints,
+		options.maxRangeSpan,
+		options.minRangeSpan,
+		options.rangeAnchor
+	], _h$0) };
+}
+function useCalendarDays(options) {
+	return useMemo(() => buildMonthGrid(options.year, options.month, options.weekStartsOn, options.hasVariableRowCount, options.locale), [
+		options.year,
+		options.month,
+		options.weekStartsOn,
+		options.hasVariableRowCount,
+		options.locale
+	], _h$1);
+}
+function useCalendarNavigation(options) {
+	const numberOfMonths = options.numberOfMonths ?? 1;
+	const controlled = options.focusDate !== void 0;
+	const [internalBase, setInternalBase] = useState(() => monthStart(getInitialFocusDate({
+		focusDate: options.focusDate,
+		value: options.value,
+		min: options.min,
+		max: options.max,
+		numberOfMonths
+	})), _h$2);
+	const controlledPd = controlled ? plainDateFromISO(options.focusDate) : null;
+	const baseMonth = controlledPd ? monthStart(controlledPd) : internalBase;
+	const commit = (next) => {
+		const iso = plainDateToISO(next);
+		if (!controlled) setInternalBase(next);
+		options.onFocusDateChange?.(iso);
+	};
+	const bounds = navigationBounds(baseMonth, numberOfMonths, options.min, options.max);
+	return {
+		baseMonth,
+		canNavigatePrevious: bounds.canNavigatePrevious,
+		canNavigateNext: bounds.canNavigateNext,
+		navigateMonths(delta) {
+			if (delta < 0 && !bounds.canNavigatePrevious) return;
+			if (delta > 0 && !bounds.canNavigateNext) return;
+			commit(monthStart(plainDateAddMonths(baseMonth, delta)));
+		},
+		navigateTo(date) {
+			const pd = plainDateFromISO(date);
+			if (pd) commit(monthStart(pd));
+		}
+	};
+}
+//#endregion
+export { useCalendarConstraints, useCalendarDays, useCalendarNavigation };

package/dist/native/chat-context.js

@@ -0,0 +1,28 @@
+import { createContext, useContext } from "octane/universal/native";
+//#region src/chat-context.ts
+/** Per-message context: sender + density for bubbles and metadata. */
+var ChatMessageContext = createContext(null);
+var ChatMessageProvider = ChatMessageContext;
+/** Per-list context: density default for messages. */
+var ChatListContext = createContext(null);
+var ChatListProvider = ChatListContext;
+/** Composer shell → slots context (value, submit, input control seam). */
+var ChatComposerContext = createContext(null);
+var ChatComposerProvider = ChatComposerContext;
+/** Layout → message list context: scroll container + content refs. */
+var ChatLayoutContext = createContext(null);
+var ChatLayoutProvider = ChatLayoutContext;
+function useChatMessageContext() {
+	return useContext(ChatMessageContext);
+}
+function useChatListContext() {
+	return useContext(ChatListContext);
+}
+function useChatComposerContext() {
+	return useContext(ChatComposerContext);
+}
+function useChatLayoutContext() {
+	return useContext(ChatLayoutContext);
+}
+//#endregion
+export { ChatComposerContext, ChatComposerProvider, ChatLayoutContext, ChatLayoutProvider, ChatListContext, ChatListProvider, ChatMessageContext, ChatMessageProvider, useChatComposerContext, useChatLayoutContext, useChatListContext, useChatMessageContext };

package/dist/native/chat-group-items.js

@@ -0,0 +1,36 @@
+//#region src/chat-group-items.ts
+/** Group trigger items by `auxiliaryData.group`, preserving first-seen group
+*  order; ungrouped items trail (matches upstream groupItems default). */
+function groupChatItems(items) {
+	const getGroup = (item) => {
+		const g = item.auxiliaryData?.group;
+		return typeof g === "string" && g.length > 0 ? g : null;
+	};
+	if (!items.some((item) => getGroup(item) != null)) return [{
+		heading: null,
+		items
+	}];
+	const order = [];
+	const groups = /* @__PURE__ */ new Map();
+	const ungrouped = [];
+	for (const item of items) {
+		const group = getGroup(item);
+		if (group != null) {
+			if (!groups.has(group)) {
+				order.push(group);
+				groups.set(group, []);
+			}
+			groups.get(group).push(item);
+		} else ungrouped.push(item);
+	}
+	const named = order.map((heading) => ({
+		heading,
+		items: groups.get(heading)
+	}));
+	return ungrouped.length > 0 ? [...named, {
+		heading: null,
+		items: ungrouped
+	}] : named;
+}
+//#endregion
+export { groupChatItems };

package/dist/native/chat-tokenize.js

@@ -0,0 +1,41 @@
+//#region src/chat-tokenize.ts
+function escapeRegExp(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Split serialized message text into text runs and token parts, matching
+*  upstream's literal-value scan: each non-empty token `value` is matched
+*  literally; empty values are ignored; first longest match wins per
+*  position (alternation order follows the tokens array). */
+function tokenizeChatText(text, tokens) {
+	const matchable = tokens.filter((t) => t.value.length > 0);
+	if (!text || matchable.length === 0) return [{
+		kind: "text",
+		text
+	}];
+	const pattern = matchable.map((t) => escapeRegExp(t.value)).join("|");
+	const regex = new RegExp(`(${pattern})`, "g");
+	const byValue = new Map(matchable.map((t) => [t.value, t]));
+	const parts = [];
+	let lastIndex = 0;
+	let match;
+	while ((match = regex.exec(text)) !== null) {
+		if (match.index > lastIndex) parts.push({
+			kind: "text",
+			text: text.slice(lastIndex, match.index)
+		});
+		const token = byValue.get(match[0]);
+		if (token) parts.push({
+			kind: "token",
+			token,
+			index: match.index
+		});
+		lastIndex = match.index + match[0].length;
+	}
+	if (lastIndex < text.length) parts.push({
+		kind: "text",
+		text: text.slice(lastIndex)
+	});
+	return parts;
+}
+//#endregion
+export { tokenizeChatText };

package/dist/native/chat-tokens.tsrx.js

@@ -0,0 +1,60 @@
+import { cx } from "./cx.js";
+import { Icon } from "./Icon.tsrx.js";
+import { defineUniversalComponent, universalComponent, universalPlan, universalProps, universalValue } from "@nativescript-community/octane";
+//#region src/chat-tokens.tsrx
+var __octaneUniversalPlan0 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var __octaneUniversalPlan1 = universalPlan("nativescript", {
+	"kind": "host",
+	"type": "flexboxlayout",
+	"props": {
+		"flexDirection": "row",
+		"alignItems": "center"
+	},
+	"bindings": [["className", 0]],
+	"children": [
+		{
+			"kind": "slot",
+			"slot": 1
+		},
+		{
+			"kind": "host",
+			"type": "label",
+			"props": {
+				"className": "vx-chattoken-label",
+				"textWrap": false
+			},
+			"bindings": [["text", 2]]
+		},
+		{
+			"kind": "slot",
+			"slot": 3
+		}
+	]
+});
+function isCustomToken(token) {
+	return "render" in token && typeof token.render === "function";
+}
+var ChatTokenChip = defineUniversalComponent("nativescript", function ChatTokenChip(props) {
+	const token = props.token;
+	if (isCustomToken(token)) return token.render();
+	const variant = token.variant ?? "neutral";
+	return universalValue(__octaneUniversalPlan1, [
+		cx("vx-chat-token", `vx-chattoken--${variant}`, props.className),
+		token.icon ? universalValue(__octaneUniversalPlan0, [universalComponent("nativescript", Icon, universalProps([[
+			"set",
+			"name",
+			token.icon
+		], [
+			"set",
+			"size",
+			12
+		]]))]) : null,
+		typeof token.label === "string" ? token.label : "",
+		typeof token.label === "string" ? null : token.label
+	]);
+}, { "module": "@nativescript-community/octane" });
+//#endregion
+export { ChatTokenChip, isCustomToken };

package/dist/native/child-array.js

@@ -1,15 +1,12 @@
+import { Children } from "octane/universal/native";
 //#region src/child-array.ts
-/** Normalize a JSX children value to a flat array — children may be a
-*  single node, an array, or nested arrays from `.map` calls. */
+/** Normalize supported JSX children through their owning renderer. */
 function toChildArray(children) {
-	const out = [];
-	const walk = (node) => {
-		if (node == null || node === false) return;
-		if (Array.isArray(node)) for (const child of node) walk(child);
-		else out.push(node);
-	};
-	walk(children);
-	return out;
+	return Children.toArray(children);
+}
+/** Preserve each child's key when placing it inside a wrapper host. */
+function mapChildren(children, render) {
+	return Children.map(children, render);
 }
 //#endregion
-export { toChildArray };
+export { mapChildren, toChildArray };

package/dist/native/clipboard-write.js

@@ -0,0 +1,13 @@
+import { Utils } from "@nativescript/core";
+//#region src/clipboard-write.ts
+/** Write text to the system clipboard. Resolves false on failure. */
+async function copyText(text) {
+	try {
+		Utils.copyToClipboard(text);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { copyText };