ropav 0.2.0 → 0.3.0

package/dist/utils/focus.js

@@ -0,0 +1,121 @@
+//#region src/utils/focus.ts
+/**
+* Controls that can hold focus, in the order the browser would visit them.
+*
+* Deliberately not `[tabindex]` on its own: a `tabindex="-1"` element is focusable
+* programmatically but is not a tab stop, and counting it would make one arrow press appear
+* to land nowhere.
+*/
+var FOCUSABLE_SELECTOR = [
+	"button:not([disabled])",
+	"input:not([disabled])",
+	"select:not([disabled])",
+	"textarea:not([disabled])",
+	"a[href]",
+	"[tabindex]:not([tabindex=\"-1\"])"
+].join(",");
+/**
+* Whether an element is visible enough to take focus.
+*
+* `checkVisibility()` is the only reliable read of this — `offsetParent` is always `null` in
+* jsdom, and a `display: none` ancestor is invisible to a bounding-rect check. jsdom does not
+* implement `checkVisibility` either, so there everything else counts, which is what tests
+* exercising key order want anyway.
+*
+* `hidden` is read separately because it needs no layout and is the one case that matters even in
+* jsdom: a field's hidden input sits among the segments a picker moves focus through, and moving
+* onto something no browser will focus would leave focus where it was instead of moving on.
+*/
+var isElementVisible = (element) => {
+	if (element.hidden) return false;
+	return typeof element.checkVisibility === "function" ? element.checkVisibility() : true;
+};
+/** The focusable controls inside `element`, in document order, skipping hidden ones. */
+var focusableIn = (element) => [...element.querySelectorAll(FOCUSABLE_SELECTOR)].filter(isElementVisible);
+/**
+* The controls inside `element` that Tab actually visits.
+*
+* Narrower than {@link focusableIn}, and the difference matters: the selector cannot express
+* "not `tabindex="-1"`" for an element that is focusable by its tag alone, so a
+* `<button tabindex="-1">` matches `button:not([disabled])` and counts as focusable. That is
+* right for anything moving focus itself — a collection with a roving tab index holds every item
+* at `-1` and still has to page through them — and wrong for anything modelling the tab order,
+* where such a button is deliberately not a stop.
+*/
+var tabbableIn = (element) => focusableIn(element).filter((child) => child.tabIndex >= 0);
+/**
+* Whether an element scrolls its own content.
+*
+* Ported from React Aria's `isScrollable`. Paging keys need this: in a list that does not
+* scroll there is no page to move by, so Page Up and Page Down collapse to the ends instead.
+* The document's scrolling element is a special case — it scrolls despite defaulting to
+* `overflow: visible`.
+*/
+var isScrollable = (element) => {
+	if (!element) return false;
+	const style = getComputedStyle(element);
+	if (element === (document.scrollingElement ?? document.documentElement) && style.overflow !== "hidden") return true;
+	return /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);
+};
+/**
+* The nearest ancestor that scrolls its own content, or `null` when nothing up to the root does.
+*
+* Ported from React Aria's `getScrollParent`. Anything that watches for the edge of a list coming
+* into view has to observe against that box rather than the viewport, or a list inside a scrolling
+* panel would never report anything.
+*/
+var getScrollParent = (element) => {
+	let current = element;
+	while (current) {
+		if (isScrollable(current)) return current;
+		current = current.parentElement;
+	}
+	return null;
+};
+/**
+* Move focus around inside an element from the outside.
+*
+* Ported from React Aria's `createFocusManager`. A date field needs this because typing into one
+* segment moves focus to the next: the segment knows it is finished, but only its field knows what
+* comes after it.
+*
+* Takes a getter rather than an element so it can be built before the element exists, which is the
+* order a component sets things up in.
+*
+* React walks the tree with a `TreeWalker` and stops on anything focusable; this reads the list
+* {@link focusableIn} already builds. The two agree wherever nothing is held at `tabindex="-1"`,
+* which no field of segments does.
+*/
+var createFocusManager = (getRoot, options = {}) => {
+	const stops = () => {
+		const root = getRoot();
+		const all = root ? focusableIn(root) : [];
+		return options.accept ? all.filter(options.accept) : all;
+	};
+	const move = (step, options = {}) => {
+		const list = stops();
+		if (list.length === 0) return null;
+		const from = options.from ?? getRoot()?.ownerDocument.activeElement ?? null;
+		const index = from instanceof HTMLElement ? list.indexOf(from) : -1;
+		const target = index === -1 ? list[step === 1 ? 0 : list.length - 1] : list[index + step] ?? (options.wrap ? list[step === 1 ? 0 : list.length - 1] : void 0);
+		target?.focus();
+		return target ?? null;
+	};
+	return {
+		focusFirst: () => {
+			const [first] = stops();
+			first?.focus();
+			return first ?? null;
+		},
+		focusLast: () => {
+			const list = stops();
+			const last = list[list.length - 1];
+			last?.focus();
+			return last ?? null;
+		},
+		focusNext: (options) => move(1, options),
+		focusPrevious: (options) => move(-1, options)
+	};
+};
+//#endregion
+export { FOCUSABLE_SELECTOR, createFocusManager, focusableIn, getScrollParent, isElementVisible, isScrollable, tabbableIn };

package/dist/utils/form-value.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Put a value on a form control as both the live property and the default a reset restores from.
+ *
+ * The default is the half that matters for a form reset, and the half a Vapor binding never
+ * writes: binding `value` sets the property, so the element carries no reset source at all and the
+ * browser has nothing to restore from — it puts a text input back to empty and a range input back
+ * to the *midpoint of its range*.
+ *
+ * Re-asserting a tick after the `reset` event is not enough on its own, and the reason is worth
+ * writing down because it is measured rather than reasoned: when the reset comes from a real click
+ * the browser drains microtasks *between* dispatching the event and restoring the controls, so a
+ * `nextTick` write lands too early and is overwritten. Only a reset called from script — which is
+ * what a test usually does — leaves the microtask after the restore, which is exactly the shape
+ * that makes a jsdom test pass while the real thing is broken.
+ *
+ * Keeping the default in step sidesteps the ordering entirely: whenever the browser restores, it
+ * restores the value the field already holds. Writing both halves in one call is what makes it
+ * ordering-independent in *either* direction — called from a post-flush watcher the default is in
+ * place before a browser-initiated restore reads it, and were the two ever to run the other way
+ * round the property write in the same call is the one that lands. Which is the argument for
+ * putting this in a watcher rather than in a `reset` listener: a listener only ever gets one of
+ * the two orders, and it is the losing one.
+ *
+ * `defaultValue` rather than `setAttribute("value", …)`, because the two elements keep their reset
+ * source in different places: an `<input>`'s is the `value` attribute, a `<textarea>`'s is its
+ * child text content, and there is no attribute for the second. `defaultValue` is the one IDL that
+ * writes the right half of either, and on an input it still reflects — `getAttribute("value")`
+ * reads back what was written. Measured, including on a control the user has already typed into:
+ * the dirty value flag makes the current value independent of the default from the first keystroke
+ * on, so neither half disturbs what is on screen.
+ *
+ * One thing to keep true: every attribute bag that reaches a control this is called for has to
+ * carry `value` unconditionally. A key that *leaves* a Vapor bag arrives as `null`, and Vapor
+ * answers a null `value` with `removeAttribute("value")` — which would wipe the default written
+ * here. No bag in the package drops it today.
+ */
+export declare const setFormValue: (control: HTMLInputElement | HTMLTextAreaElement | null | undefined, value: string) => void;
+/**
+ * Put a checkbox or radio's state on both halves: the live `checked` property, and the
+ * `defaultChecked` that reflects the `checked` attribute.
+ *
+ * `checked` reflects nothing, so a binding leaves no mark on the element at all — a control the
+ * user has toggled has no reset source, and a browser-initiated reset puts it back to *unchecked*
+ * while the state still says selected. The form then submits nothing for a box the user can see is
+ * ticked. `defaultChecked` is the only way to reach the attribute that does not disturb what is on
+ * screen: the dirty checkedness flag makes the two independent from the first toggle on.
+ *
+ * On a radio the group comes free. Checking one radio unchecks the rest sharing its name, but the
+ * default half needs no walk at all — every radio in the group mirrors the same selected value, so
+ * each one settles its own default in the same flush, and exactly one of them ends up true.
+ *
+ * The ordering argument is the same as {@link setFormValue}'s, and so is the conclusion: call this
+ * from a post-flush watcher, not from a `reset` listener.
+ */
+export declare const setFormChecked: (input: HTMLInputElement | null | undefined, checked: boolean) => void;

package/dist/utils/form-value.js

@@ -0,0 +1,66 @@
+//#region src/utils/form-value.ts
+/**
+* Put a value on a form control as both the live property and the default a reset restores from.
+*
+* The default is the half that matters for a form reset, and the half a Vapor binding never
+* writes: binding `value` sets the property, so the element carries no reset source at all and the
+* browser has nothing to restore from — it puts a text input back to empty and a range input back
+* to the *midpoint of its range*.
+*
+* Re-asserting a tick after the `reset` event is not enough on its own, and the reason is worth
+* writing down because it is measured rather than reasoned: when the reset comes from a real click
+* the browser drains microtasks *between* dispatching the event and restoring the controls, so a
+* `nextTick` write lands too early and is overwritten. Only a reset called from script — which is
+* what a test usually does — leaves the microtask after the restore, which is exactly the shape
+* that makes a jsdom test pass while the real thing is broken.
+*
+* Keeping the default in step sidesteps the ordering entirely: whenever the browser restores, it
+* restores the value the field already holds. Writing both halves in one call is what makes it
+* ordering-independent in *either* direction — called from a post-flush watcher the default is in
+* place before a browser-initiated restore reads it, and were the two ever to run the other way
+* round the property write in the same call is the one that lands. Which is the argument for
+* putting this in a watcher rather than in a `reset` listener: a listener only ever gets one of
+* the two orders, and it is the losing one.
+*
+* `defaultValue` rather than `setAttribute("value", …)`, because the two elements keep their reset
+* source in different places: an `<input>`'s is the `value` attribute, a `<textarea>`'s is its
+* child text content, and there is no attribute for the second. `defaultValue` is the one IDL that
+* writes the right half of either, and on an input it still reflects — `getAttribute("value")`
+* reads back what was written. Measured, including on a control the user has already typed into:
+* the dirty value flag makes the current value independent of the default from the first keystroke
+* on, so neither half disturbs what is on screen.
+*
+* One thing to keep true: every attribute bag that reaches a control this is called for has to
+* carry `value` unconditionally. A key that *leaves* a Vapor bag arrives as `null`, and Vapor
+* answers a null `value` with `removeAttribute("value")` — which would wipe the default written
+* here. No bag in the package drops it today.
+*/
+var setFormValue = (control, value) => {
+	if (!control) return;
+	if (control.value !== value) control.value = value;
+	if (control.defaultValue !== value) control.defaultValue = value;
+};
+/**
+* Put a checkbox or radio's state on both halves: the live `checked` property, and the
+* `defaultChecked` that reflects the `checked` attribute.
+*
+* `checked` reflects nothing, so a binding leaves no mark on the element at all — a control the
+* user has toggled has no reset source, and a browser-initiated reset puts it back to *unchecked*
+* while the state still says selected. The form then submits nothing for a box the user can see is
+* ticked. `defaultChecked` is the only way to reach the attribute that does not disturb what is on
+* screen: the dirty checkedness flag makes the two independent from the first toggle on.
+*
+* On a radio the group comes free. Checking one radio unchecks the rest sharing its name, but the
+* default half needs no walk at all — every radio in the group mirrors the same selected value, so
+* each one settles its own default in the same flush, and exactly one of them ends up true.
+*
+* The ordering argument is the same as {@link setFormValue}'s, and so is the conclusion: call this
+* from a post-flush watcher, not from a `reset` listener.
+*/
+var setFormChecked = (input, checked) => {
+	if (!input) return;
+	if (input.checked !== checked) input.checked = checked;
+	if (input.defaultChecked !== checked) input.defaultChecked = checked;
+};
+//#endregion
+export { setFormChecked, setFormValue };

package/dist/utils/incomplete-date.d.ts

@@ -0,0 +1,82 @@
+import type { Calendar, DateValue } from "@internationalized/date";
+/** How the hours of a day are numbered in a locale. */
+export type HourCycle = "h11" | "h12" | "h23" | "h24";
+/** Every kind of part a formatted date can be cut into, editable or not. */
+export type DateSegmentType = "day" | "dayPeriod" | "era" | "hour" | "literal" | "minute" | "month" | "second" | "timeZoneName" | "year";
+/**
+ * Anything an incomplete date can be seeded from.
+ *
+ * Every member is optional rather than intersecting the `@internationalized/date` shapes: a
+ * `CalendarDate` has no hour and a `CalendarDateTime` has no offset, so an intersection would
+ * reject both of the types this is actually called with.
+ */
+export interface PartialDateFields {
+    era?: string;
+    year?: number;
+    month?: number;
+    day?: number;
+    hour?: number;
+    minute?: number;
+    second?: number;
+    millisecond?: number;
+    offset?: number;
+}
+export interface SegmentLimits {
+    value: number | null;
+    minValue: number;
+    maxValue: number;
+}
+/** Split a 24-hour hour into the day period and hour a locale's clock would show. */
+export declare const toHourCycle: (hour: number, hourCycle: HourCycle) => [number | null, number];
+/** Put a clock hour and day period back together into a 24-hour hour. */
+export declare const fromHourCycle: (hour: number, dayPeriod: number, hourCycle: HourCycle) => number;
+/**
+ * A date being typed, where any segment may still be blank.
+ *
+ * Ported from react-stately's `packages/react-stately/src/datepicker/IncompleteDate.ts`
+ * (react-stately 3.49.0), essentially unchanged — it is a plain class with no framework in it.
+ *
+ * This exists because a real `CalendarDate` cannot represent what a half-filled field holds. Typing
+ * "February 30" has to stay on screen while the day segment is still being edited, and a field with
+ * only a year in it has no month or day at all yet. Every segment is therefore nullable, and the
+ * value is only turned into a real date once it is complete and valid.
+ */
+export declare class IncompleteDate {
+    calendar: Calendar;
+    era: string | null;
+    year: number | null;
+    month: number | null;
+    day: number | null;
+    hour: number | null;
+    hourCycle: HourCycle;
+    dayPeriod: number | null;
+    minute: number | null;
+    second: number | null;
+    millisecond: number | null;
+    offset: number | null;
+    constructor(calendar: Calendar, hourCycle: HourCycle, dateValue?: PartialDateFields | null);
+    /** Read a segment, answering `undefined` for the ones no value is stored for. */
+    private read;
+    copy(): IncompleteDate;
+    /** Whether every one of the given segments has been filled in. */
+    isComplete(segments: DateSegmentType[]): boolean;
+    /** Whether a real date agrees with what is on screen, segment by segment. */
+    validate(date: DateValue, segments: DateSegmentType[]): boolean;
+    /** Whether every one of the given segments is still blank. */
+    isCleared(segments: DateSegmentType[]): boolean;
+    /** Set one segment, filling in whatever else that implies. */
+    set(field: DateSegmentType, value: number | string, placeholder: DateValue): IncompleteDate;
+    /** Blank one segment out. */
+    clear(field: DateSegmentType): IncompleteDate;
+    /**
+     * Step one segment by an amount, filling it from the placeholder if it is still blank.
+     *
+     * A blank segment takes the placeholder's value rather than stepping from it, so the first arrow
+     * press on an empty field lands on today rather than on the day after today.
+     */
+    cycle(field: DateSegmentType, amount: number, placeholder: DateValue, displaySegments: DateSegmentType[]): IncompleteDate;
+    /** Fill every blank segment from the given value, producing a real date. */
+    toValue(value: DateValue): DateValue;
+    /** The current value of a segment and how far it may be stepped in either direction. */
+    getSegmentLimits(type: string): SegmentLimits | undefined;
+}

package/dist/utils/incomplete-date.js

@@ -0,0 +1,312 @@
+import { CalendarDate } from "@internationalized/date";
+//#region src/utils/incomplete-date.ts
+/**
+* Move a segment's value by an amount, wrapping around at both ends.
+*
+* `round` snaps to a multiple of the step, so paging a minute field by 15 lands on :00/:15/:30/:45
+* rather than 15 minutes further along from wherever it was.
+*/
+var cycleValue = (value, amount, min, max, round = false) => {
+	let next = value;
+	if (round) {
+		next += Math.sign(amount);
+		if (next < min) next = max;
+		const div = Math.abs(amount);
+		next = amount > 0 ? Math.ceil(next / div) * div : Math.floor(next / div) * div;
+		if (next > max) next = min;
+	} else {
+		next += amount;
+		if (next < min) next = max - (min - next - 1);
+		else if (next > max) next = min + (next - max - 1);
+	}
+	return next;
+};
+/** Split a 24-hour hour into the day period and hour a locale's clock would show. */
+var toHourCycle = (hour, hourCycle) => {
+	let dayPeriod = hour >= 12 ? 1 : 0;
+	let next = hour;
+	switch (hourCycle) {
+		case "h11":
+			if (next >= 12) next -= 12;
+			break;
+		case "h12":
+			if (next === 0) next = 12;
+			else if (next > 12) next -= 12;
+			break;
+		case "h23":
+			dayPeriod = null;
+			break;
+		case "h24":
+			next += 1;
+			dayPeriod = null;
+	}
+	return [dayPeriod, next];
+};
+/** Put a clock hour and day period back together into a 24-hour hour. */
+var fromHourCycle = (hour, dayPeriod, hourCycle) => {
+	let next = hour;
+	switch (hourCycle) {
+		case "h11":
+			if (dayPeriod === 1) next += 12;
+			break;
+		case "h12":
+			if (next === 12) next = 0;
+			if (dayPeriod === 1) next += 12;
+			break;
+		case "h24": next -= 1;
+	}
+	return next;
+};
+/**
+* A date being typed, where any segment may still be blank.
+*
+* Ported from react-stately's `packages/react-stately/src/datepicker/IncompleteDate.ts`
+* (react-stately 3.49.0), essentially unchanged — it is a plain class with no framework in it.
+*
+* This exists because a real `CalendarDate` cannot represent what a half-filled field holds. Typing
+* "February 30" has to stay on screen while the day segment is still being edited, and a field with
+* only a year in it has no month or day at all yet. Every segment is therefore nullable, and the
+* value is only turned into a real date once it is complete and valid.
+*/
+var IncompleteDate = class IncompleteDate {
+	calendar;
+	era;
+	year;
+	month;
+	day;
+	hour;
+	hourCycle;
+	dayPeriod;
+	minute;
+	second;
+	millisecond;
+	offset;
+	constructor(calendar, hourCycle, dateValue) {
+		this.calendar = calendar;
+		this.hourCycle = hourCycle;
+		this.era = dateValue?.era ?? null;
+		this.year = dateValue?.year ?? null;
+		this.month = dateValue?.month ?? null;
+		this.day = dateValue?.day ?? null;
+		this.hour = dateValue?.hour ?? null;
+		this.dayPeriod = null;
+		this.minute = dateValue?.minute ?? null;
+		this.second = dateValue?.second ?? null;
+		this.millisecond = dateValue?.millisecond ?? null;
+		this.offset = dateValue != null && "offset" in dateValue ? dateValue.offset ?? null : null;
+		if (this.hour != null) {
+			const [dayPeriod, hour] = toHourCycle(this.hour, hourCycle);
+			this.dayPeriod = dayPeriod;
+			this.hour = hour;
+		}
+	}
+	/** Read a segment, answering `undefined` for the ones no value is stored for. */
+	read(field) {
+		if (field === "literal" || field === "timeZoneName") return void 0;
+		return this[field];
+	}
+	copy() {
+		const result = new IncompleteDate(this.calendar, this.hourCycle);
+		result.era = this.era;
+		result.year = this.year;
+		result.month = this.month;
+		result.day = this.day;
+		result.hour = this.hour;
+		result.dayPeriod = this.dayPeriod;
+		result.minute = this.minute;
+		result.second = this.second;
+		result.millisecond = this.millisecond;
+		result.offset = this.offset;
+		return result;
+	}
+	/** Whether every one of the given segments has been filled in. */
+	isComplete(segments) {
+		return segments.every((segment) => this.read(segment) != null);
+	}
+	/** Whether a real date agrees with what is on screen, segment by segment. */
+	validate(date, segments) {
+		return segments.every((segment) => {
+			if ((segment === "hour" || segment === "dayPeriod") && "hour" in date) {
+				const [dayPeriod, hour] = toHourCycle(date.hour, this.hourCycle);
+				return this.dayPeriod === dayPeriod && this.hour === hour;
+			}
+			return this.read(segment) === date[segment];
+		});
+	}
+	/** Whether every one of the given segments is still blank. */
+	isCleared(segments) {
+		return segments.every((segment) => this.read(segment) === null);
+	}
+	/** Set one segment, filling in whatever else that implies. */
+	set(field, value, placeholder) {
+		const result = this.copy();
+		result[field] = value;
+		if (field === "hour" && result.dayPeriod == null && "hour" in placeholder) result.dayPeriod = toHourCycle(placeholder.hour, this.hourCycle)[0];
+		if (field === "year" && result.era == null) result.era = placeholder.era;
+		if (field !== "second" && field !== "literal" && field !== "timeZoneName") result.offset = null;
+		return result;
+	}
+	/** Blank one segment out. */
+	clear(field) {
+		const result = this.copy();
+		result[field] = null;
+		if (field === "year") result.era = null;
+		result.offset = null;
+		return result;
+	}
+	/**
+	* Step one segment by an amount, filling it from the placeholder if it is still blank.
+	*
+	* A blank segment takes the placeholder's value rather than stepping from it, so the first arrow
+	* press on an empty field lands on today rather than on the day after today.
+	*/
+	cycle(field, amount, placeholder, displaySegments) {
+		const result = this.copy();
+		if (this.read(field) == null && field !== "dayPeriod" && field !== "era") {
+			if (field === "hour" && "hour" in placeholder) {
+				const [dayPeriod, hour] = toHourCycle(placeholder.hour, this.hourCycle);
+				result.dayPeriod = dayPeriod;
+				result.hour = hour;
+			} else result[field] = placeholder[field];
+			if (field === "year" && result.era == null) result.era = placeholder.era;
+			return result;
+		}
+		switch (field) {
+			case "era": {
+				const eras = this.calendar.getEras();
+				result.era = eras[cycleValue(eras.indexOf(result.era), amount, 0, eras.length - 1)];
+				break;
+			}
+			case "year": {
+				let date = new CalendarDate(this.calendar, this.era ?? placeholder.era, this.year ?? placeholder.year, this.month ?? 1, this.day ?? 1);
+				date = date.cycle(field, amount, { round: true });
+				result.era = date.era;
+				result.year = date.year;
+				break;
+			}
+			case "month":
+				result.month = cycleValue(result.month ?? 1, amount, 1, this.calendar.getMaximumMonthsInYear());
+				break;
+			case "day":
+				result.day = cycleValue(result.day ?? 1, amount, 1, this.calendar.getMaximumDaysInMonth());
+				break;
+			case "hour": {
+				const hasDateSegments = displaySegments.some((segment) => [
+					"day",
+					"month",
+					"year"
+				].includes(segment));
+				if ("timeZone" in placeholder && (!hasDateSegments || result.year != null && result.month != null && result.day != null)) {
+					const date = this.toValue(placeholder).cycle("hour", amount, {
+						hourCycle: this.hourCycle === "h12" ? 12 : 24,
+						round: false
+					});
+					const [dayPeriod, adjustedHour] = toHourCycle(date.hour, this.hourCycle);
+					result.hour = adjustedHour;
+					result.dayPeriod = dayPeriod;
+					result.offset = date.offset;
+				} else {
+					const limits = this.getSegmentLimits("hour");
+					result.hour = cycleValue(result.hour ?? 0, amount, limits.minValue, limits.maxValue);
+					if (result.dayPeriod == null && "hour" in placeholder) result.dayPeriod = toHourCycle(placeholder.hour, this.hourCycle)[0];
+				}
+				break;
+			}
+			case "dayPeriod":
+				result.dayPeriod = cycleValue(result.dayPeriod ?? 0, amount, 0, 1);
+				break;
+			case "minute":
+				result.minute = cycleValue(result.minute ?? 0, amount, 0, 59, true);
+				break;
+			case "second": result.second = cycleValue(result.second ?? 0, amount, 0, 59, true);
+		}
+		return result;
+	}
+	/** Fill every blank segment from the given value, producing a real date. */
+	toValue(value) {
+		if ("hour" in value) {
+			let hour = this.hour;
+			if (hour != null) hour = fromHourCycle(hour, this.dayPeriod ?? 0, this.hourCycle);
+			else if (this.hourCycle === "h12" || this.hourCycle === "h11") hour = this.dayPeriod === 1 ? 12 : 0;
+			let result = value.set({
+				day: this.day ?? value.day,
+				era: this.era ?? value.era,
+				hour: hour ?? value.hour,
+				millisecond: this.millisecond ?? value.millisecond,
+				minute: this.minute ?? value.minute,
+				month: this.month ?? value.month,
+				second: this.second ?? value.second,
+				year: this.year ?? value.year
+			});
+			if ("offset" in result && this.offset != null && result.offset !== this.offset) result = result.add({ milliseconds: result.offset - this.offset });
+			return result;
+		}
+		return value.set({
+			day: this.day ?? value.day,
+			era: this.era ?? value.era,
+			month: this.month ?? value.month,
+			year: this.year ?? value.year
+		});
+	}
+	/** The current value of a segment and how far it may be stepped in either direction. */
+	getSegmentLimits(type) {
+		switch (type) {
+			case "era": {
+				const eras = this.calendar.getEras();
+				return {
+					maxValue: eras.length - 1,
+					minValue: 0,
+					value: this.era != null ? eras.indexOf(this.era) : eras.length - 1
+				};
+			}
+			case "year": return {
+				maxValue: 9999,
+				minValue: 1,
+				value: this.year
+			};
+			case "month": return {
+				maxValue: this.calendar.getMaximumMonthsInYear(),
+				minValue: 1,
+				value: this.month
+			};
+			case "day": return {
+				maxValue: this.calendar.getMaximumDaysInMonth(),
+				minValue: 1,
+				value: this.day
+			};
+			case "dayPeriod": return {
+				maxValue: 1,
+				minValue: 0,
+				value: this.dayPeriod
+			};
+			case "hour":
+				if (this.hourCycle === "h12") return {
+					maxValue: 12,
+					minValue: 1,
+					value: this.hour
+				};
+				if (this.hourCycle === "h11") return {
+					maxValue: 11,
+					minValue: 0,
+					value: this.hour
+				};
+				return {
+					maxValue: 23,
+					minValue: 0,
+					value: this.hour
+				};
+			case "minute": return {
+				maxValue: 59,
+				minValue: 0,
+				value: this.minute
+			};
+			case "second": return {
+				maxValue: 59,
+				minValue: 0,
+				value: this.second
+			};
+		}
+	}
+};
+//#endregion
+export { IncompleteDate, fromHourCycle, toHourCycle };

package/dist/utils/index.d.ts

@@ -0,0 +1,35 @@
+export * from "./aria-hide-outside";
+export * from "./assertion";
+export * from "./block";
+export * from "./calendar";
+export * from "./color";
+export * from "./color-types";
+export * from "./compose";
+export * from "./create-context";
+export * from "./css";
+export * from "./date-format";
+export * from "./date-placeholder";
+export * from "./date-validation";
+export * from "./dnd-constants";
+export * from "./dnd-data-transfer";
+export * from "./dnd-drop-target-navigation";
+export * from "./dnd-list-drop-target-delegate";
+export * from "./dnd-state";
+export * from "./dnd-tree-drop-target-delegate";
+export * from "./dnd-types";
+export * from "./focus";
+export * from "./form-value";
+export * from "./incomplete-date";
+export * from "./locale";
+export * from "./number";
+export * from "./platform";
+export * from "./position";
+export * from "./text-value";
+export * from "./virtualizer-collection";
+export * from "./virtualizer-geometry";
+export * from "./virtualizer-layout";
+export * from "./virtualizer-layout-info";
+export * from "./virtualizer-list-layout";
+export * from "./virtualizer-overscan";
+export * from "./virtualizer-table-layout";
+export * from "./visually-hidden";