@octanejs/aria 0.0.46 → 0.0.47

package/src/tooltip/usePreviewTrigger.tsx

@@ -0,0 +1,266 @@
+/** @jsxImportSource octane */
+// Ported from adobe/react-spectrum@5ecb3333001313e83898cd07644227897e3bae1f (packages/react-aria/src/tooltip/usePreviewTrigger.ts).
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {
+	KeyboardEvent as AriaKeyboardEvent,
+	DOMAttributes,
+	FocusableElement,
+	RefObject,
+} from '@react-types/shared';
+import { AriaPopoverProps } from '../overlays/usePopover';
+import { focusWithoutScrolling } from '../utils/focusWithoutScrolling';
+import { getActiveElement } from '../utils/shadowdom/DOMFunctions';
+import { getFocusableTreeWalker } from '../focus/FocusScope';
+import {
+	getInteractionModality,
+	useFocusVisibleListener,
+	useInteractionModality,
+} from '../interactions/useFocusVisible';
+import { getOwnerDocument } from '../utils/domHelpers';
+import intlMessages from '../intl/previewtrigger/index';
+import { mergeProps } from '../utils/mergeProps';
+import { nodeContains } from '../utils/shadowdom/DOMFunctions';
+import {
+	TooltipTriggerProps,
+	TooltipTriggerState,
+} from '../upstream-exports/react-stately/useTooltipTriggerState';
+import { useEffect, useRef } from '../compat/react';
+import { useEffectEvent } from '../utils/useEffectEvent';
+import { useEvent } from '../utils/useEvent';
+import { useHover } from '../interactions/useHover';
+import { useId } from '../utils/useId';
+import { useLocalizedStringFormatter } from '../i18n/useLocalizedStringFormatter';
+import { useLongPress } from '../interactions/useLongPress';
+import { useSafeArea } from './useSafeArea';
+
+export interface AriaPreviewTriggerProps extends Omit<
+	TooltipTriggerProps,
+	'trigger' | 'shouldCloseOnPress'
+> {}
+
+export interface AriaPreviewTriggerOptions extends AriaPreviewTriggerProps {
+	/** A ref to the trigger element (e.g. a Link). */
+	triggerRef: RefObject<FocusableElement | null>;
+	/** A ref to the popover element. */
+	popoverRef: RefObject<Element | null>;
+}
+
+export interface PreviewTriggerTriggerAria {
+	/**
+	 * Props for the trigger element (e.g. a Link).
+	 */
+	triggerProps: DOMAttributes;
+	/**
+	 * Props for the popover overlay element.
+	 */
+	popoverProps: Omit<AriaPopoverProps, 'triggerRef' | 'popoverRef'> & DOMAttributes;
+}
+
+/**
+ * Provides the behavior and accessibility implementation for a preview trigger.
+ * A preview trigger displays a popover on hover, focus, or long press. Unlike a
+ * tooltip, the popover may contain interactive content.
+ */
+export function usePreviewTrigger(
+	props: AriaPreviewTriggerOptions,
+	state: TooltipTriggerState,
+): PreviewTriggerTriggerAria {
+	let { triggerRef, popoverRef, isDisabled } = props;
+	let stringFormatter = useLocalizedStringFormatter(intlMessages, '@react-aria/link-preview');
+	let popoverId = useId();
+
+	// Suppresses the next focus from reopening the preview (e.g. when restoring focus on Escape).
+	let ignoreFocus = useRef(false);
+	// When opened via long press, move focus into the popover once it opens so touch screen readers
+	// (e.g. VoiceOver) move their virtual cursor into the preview.
+	let shouldFocusOnOpen = useRef(false);
+	// Whether the pointer is currently within the safe area (the trigger, the popover, or the region
+	// between them). Tracked by useSafeArea below so the preview stays open while the pointer travels
+	// from the link to the popover, even with closeDelay of 0.
+	let pointerInSafeArea = useRef(false);
+
+	let isFocusVisible = useRef(false);
+	useFocusVisibleListener((visible) => {
+		isFocusVisible.current = visible;
+	}, []);
+
+	// Cancel a pending close and keep the preview open.
+	let keepOpen = useEffectEvent(() => state.open(true));
+
+	// Close the preview unless something is still keeping it open: the pointer is within the safe
+	// area, or focus is within the trigger or popover. During focus transitions the active element
+	// may briefly be the body; the popover's focusin handler re-opens in that case (focus moving in).
+	let checkClose = useEffectEvent(() => {
+		if (pointerInSafeArea.current) {
+			return;
+		}
+		let active = triggerRef.current ? getActiveElement(getOwnerDocument(triggerRef.current)) : null;
+		if (
+			isFocusVisible.current &&
+			((triggerRef.current && nodeContains(triggerRef.current, active)) ||
+				(popoverRef.current && nodeContains(popoverRef.current, active)))
+		) {
+			return;
+		}
+		state.close();
+	});
+
+	useEffect(() => {
+		let popover = popoverRef.current;
+		if (!state.isOpen || !popover || !shouldFocusOnOpen.current) {
+			return;
+		}
+
+		// When opened via long press, move focus to the popover itself so touch screen readers move
+		// their virtual cursor into the preview.
+		shouldFocusOnOpen.current = false;
+		focusWithoutScrolling(popover as FocusableElement);
+	}, [state.isOpen, popoverRef]);
+
+	let onHoverStart = () => {
+		// Match useTooltipTrigger: only treat as hovered when the modality is actually a pointer.
+		if (getInteractionModality() === 'pointer') {
+			pointerInSafeArea.current = true;
+			state.open();
+		}
+	};
+
+	let onHoverEnd = () => {
+		// Before the preview opens, cancel a pending warmup if the pointer leaves the trigger. Once
+		// open, the safe-area polygon (useSafeArea) governs closing as the pointer moves to the popover.
+		if (!state.isOpen) {
+			pointerInSafeArea.current = false;
+			state.close();
+		}
+	};
+
+	let onTriggerFocus = (e: FocusEvent) => {
+		if (ignoreFocus.current) {
+			ignoreFocus.current = false;
+			return;
+		}
+
+		// Prevent browser focusing the link on long press when focus is already in the popover.
+		if (state.isOpen && e.relatedTarget === popoverRef.current) {
+			focusWithoutScrolling(popoverRef.current as FocusableElement);
+			return;
+		}
+
+		if (isFocusVisible.current) {
+			// Open after the warmup delay on keyboard focus, not immediately like a tooltip. This way
+			// tabbing quickly through the page doesn't open previews (and add their tab stops); the
+			// delay ensures the user is actually interested in the link's details.
+			state.open();
+		}
+	};
+
+	useEvent(triggerRef, 'react-aria-focus-scope-restore', (e) => {
+		e.preventDefault();
+		ignoreFocus.current = true;
+		triggerRef.current?.focus();
+	});
+
+	// Move focus from the link into the preview when the user presses Tab while it is open.
+	// Tabbing back out of the popover is handled by the popover's own FocusScope.
+	let onTriggerKeyDown = (e: AriaKeyboardEvent) => {
+		if (e.key === 'Tab' && !e.shiftKey && state.isOpen && popoverRef.current) {
+			let walker = getFocusableTreeWalker(popoverRef.current, { tabbable: true });
+			let first = walker.nextNode() as FocusableElement | null;
+			if (first) {
+				e.preventDefault();
+				first.focus();
+			}
+		} else if (e.key === 'Escape') {
+			e.preventDefault();
+			state.close(true);
+		}
+	};
+
+	let { hoverProps } = useHover({ isDisabled, onHoverStart, onHoverEnd });
+	let focusableProps = {
+		onFocus: onTriggerFocus,
+		onBlur: checkClose,
+		onKeyDown: onTriggerKeyDown,
+	};
+
+	// Only describe the long press interaction when the user is actually using touch, otherwise it
+	// is confusing (e.g. a screen reader announcing "long press" while navigating with a keyboard).
+	// null is the default before the user has interacted with anything.
+	let modality = useInteractionModality();
+	let shouldLongPress =
+		(modality === 'pointer' || modality === 'virtual' || modality == null) &&
+		typeof window !== 'undefined' &&
+		'ontouchstart' in window;
+
+	// Open the preview on long press on touch devices, since there is no hover. Move focus into the
+	// popover once it opens so touch screen readers (e.g. VoiceOver) move their virtual cursor in.
+	let { longPressProps } = useLongPress({
+		isDisabled,
+		pointerType: 'touch',
+		accessibilityDescription: shouldLongPress
+			? stringFormatter.format('longPressMessage')
+			: undefined,
+		onLongPress() {
+			shouldFocusOnOpen.current = true;
+			state.open(true);
+		},
+	});
+
+	// Keep the preview open while the pointer is anywhere within the safe area connecting the link
+	// and the popover, so moving the pointer between them (even diagonally) doesn't close it. This
+	// works for any popover placement and even when closeDelay is 0.
+	useSafeArea({
+		triggerRef,
+		overlayRef: popoverRef,
+		isOpen: state.isOpen,
+		isDisabled,
+		onSafeAreaChange: (isInSafeArea) => {
+			if (isInSafeArea === pointerInSafeArea.current) {
+				return;
+			}
+			pointerInSafeArea.current = isInSafeArea;
+			if (isInSafeArea) {
+				keepOpen();
+			} else {
+				checkClose();
+			}
+		},
+	});
+
+	// oxlint-disable-next-line react/react-compiler
+	let triggerProps = mergeProps(focusableProps, hoverProps, longPressProps);
+	let describedBy = [triggerProps['aria-describedby'], state.isOpen ? popoverId : null]
+		.filter(Boolean)
+		.join(' ');
+
+	return {
+		triggerProps: {
+			...triggerProps,
+			'aria-haspopup': 'dialog',
+			'aria-expanded': state.isOpen,
+			'aria-controls': state.isOpen ? popoverId : undefined,
+			'aria-describedby': describedBy || undefined,
+			style: {
+				WebkitTouchCallout: 'none',
+				// @ts-ignore
+				WebkitUserDrag: 'none',
+			},
+		},
+		popoverProps: {
+			id: popoverId,
+			onFocusWithin: keepOpen,
+			onBlurWithin: checkClose,
+		},
+	};
+}

package/src/tooltip/useSafeArea.tsx

@@ -0,0 +1,171 @@
+/** @jsxImportSource octane */
+// Ported from adobe/react-spectrum@5ecb3333001313e83898cd07644227897e3bae1f (packages/react-aria/src/tooltip/useSafeArea.ts).
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { getOwnerDocument, getOwnerWindow } from '../utils/domHelpers';
+import { RefObject } from '@react-types/shared';
+import { useEffect } from '../compat/react';
+import { useEffectEvent } from '../utils/useEffectEvent';
+
+interface Point {
+	x: number;
+	y: number;
+}
+
+interface SafeAreaOptions {
+	/** Ref for the trigger element. */
+	triggerRef: RefObject<Element | null>;
+	/** Ref for the overlay element. */
+	overlayRef: RefObject<Element | null>;
+	/** Whether the overlay is open. */
+	isOpen: boolean;
+	/** Whether this feature is disabled. */
+	isDisabled?: boolean;
+	/**
+	 * Called on pointer move (and when the pointer leaves the document) with whether the pointer is
+	 * currently within the "safe area" — the trigger, the overlay, or the region between them. This
+	 * lets an overlay stay open while the pointer travels from the trigger to the overlay, even
+	 * diagonally and regardless of placement.
+	 */
+	onSafeAreaChange: (isInSafeArea: boolean) => void;
+}
+
+// A small amount of padding (in pixels) added around the trigger and overlay so the safe area is
+// slightly forgiving of sub-pixel jitter and the gap between the elements.
+const PADDING = 8;
+
+/**
+ * Tracks whether the pointer is within a "safe area" connecting a trigger and its overlay, so the
+ * overlay can stay open while the pointer moves between them. The safe area is the union of the
+ * trigger rect, the overlay rect, and the convex hull connecting the two (a polygon), which works
+ * for any placement of the overlay relative to the trigger.
+ */
+export function useSafeArea(options: SafeAreaOptions): void {
+	let { triggerRef, overlayRef, isOpen, isDisabled } = options;
+	let onSafeAreaChange = useEffectEvent(options.onSafeAreaChange);
+
+	useEffect(() => {
+		let trigger = triggerRef.current;
+		if (isDisabled || !isOpen || !trigger) {
+			return;
+		}
+
+		let onPointerMove = (e: PointerEvent) => {
+			if (e.pointerType === 'touch') {
+				return;
+			}
+			let point = { x: e.clientX, y: e.clientY };
+			let triggerRect = trigger!.getBoundingClientRect();
+			let overlayRect = overlayRef.current?.getBoundingClientRect();
+			onSafeAreaChange(isPointInSafeArea(point, triggerRect, overlayRect));
+		};
+
+		// If the pointer leaves the document entirely, it is no longer in the safe area.
+		let onPointerLeave = () => onSafeAreaChange(false);
+
+		let win = getOwnerWindow(trigger);
+		let doc = getOwnerDocument(trigger);
+		win.addEventListener('pointermove', onPointerMove);
+		doc.documentElement.addEventListener('pointerleave', onPointerLeave);
+		return () => {
+			win.removeEventListener('pointermove', onPointerMove);
+			doc.documentElement.removeEventListener('pointerleave', onPointerLeave);
+		};
+	}, [isDisabled, isOpen, triggerRef, overlayRef]);
+}
+
+function isPointInSafeArea(point: Point, triggerRect: DOMRect, overlayRect?: DOMRect): boolean {
+	if (rectContains(triggerRect, point)) {
+		return true;
+	}
+	if (!overlayRect) {
+		return false;
+	}
+	if (rectContains(overlayRect, point)) {
+		return true;
+	}
+	// Otherwise, check whether the point is within the convex hull connecting the two rects.
+	let hull = convexHull([...rectCorners(triggerRect), ...rectCorners(overlayRect)]);
+	return hull.length >= 3 && isPointInPolygon(point, hull);
+}
+
+function rectContains(rect: DOMRect, point: Point): boolean {
+	return (
+		point.x >= rect.left - PADDING &&
+		point.x <= rect.right + PADDING &&
+		point.y >= rect.top - PADDING &&
+		point.y <= rect.bottom + PADDING
+	);
+}
+
+function rectCorners(rect: DOMRect): Point[] {
+	let left = rect.left - PADDING;
+	let right = rect.right + PADDING;
+	let top = rect.top - PADDING;
+	let bottom = rect.bottom + PADDING;
+	return [
+		{ x: left, y: top },
+		{ x: right, y: top },
+		{ x: right, y: bottom },
+		{ x: left, y: bottom },
+	];
+}
+
+// Computes the convex hull of a set of points using the monotone chain algorithm.
+function convexHull(points: Point[]): Point[] {
+	let sorted = points.slice().sort((a, b) => a.x - b.x || a.y - b.y);
+	if (sorted.length < 3) {
+		return sorted;
+	}
+
+	let cross = (o: Point, a: Point, b: Point) =>
+		(a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+
+	let lower: Point[] = [];
+	for (let p of sorted) {
+		while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+			lower.pop();
+		}
+		lower.push(p);
+	}
+
+	let upper: Point[] = [];
+	for (let i = sorted.length - 1; i >= 0; i--) {
+		let p = sorted[i];
+		while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+			upper.pop();
+		}
+		upper.push(p);
+	}
+
+	lower.pop();
+	upper.pop();
+	return lower.concat(upper);
+}
+
+// Ray casting point-in-polygon test.
+function isPointInPolygon(point: Point, polygon: Point[]): boolean {
+	let { x, y } = point;
+	let inside = false;
+	for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+		let xi = polygon[i].x;
+		let yi = polygon[i].y;
+		let xj = polygon[j].x;
+		let yj = polygon[j].y;
+		let intersect = yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+		if (intersect) {
+			inside = !inside;
+		}
+	}
+	return inside;
+}

package/src/upstream-exports/react-aria/mergeRefs.tsx

@@ -0,0 +1,3 @@
+/** @jsxImportSource octane */
+// Ported from adobe/react-spectrum@5ecb3333001313e83898cd07644227897e3bae1f (packages/react-aria/exports/mergeRefs.ts).
+export { mergeRefs } from '../../utils/mergeRefs';

package/src/upstream-exports/react-aria/usePreviewTrigger.tsx

@@ -0,0 +1,18 @@
+/** @jsxImportSource octane */
+// Ported from adobe/react-spectrum@5ecb3333001313e83898cd07644227897e3bae1f (packages/react-aria/exports/usePreviewTrigger.ts).
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+export { usePreviewTrigger } from '../../tooltip/usePreviewTrigger';
+export type {
+	AriaPreviewTriggerProps,
+	PreviewTriggerTriggerAria,
+} from '../../tooltip/usePreviewTrigger';

package/src/upstream-exports/react-aria/useTokenField.tsx

@@ -0,0 +1,22 @@
+/** @jsxImportSource octane */
+// Ported from adobe/react-spectrum@5ecb3333001313e83898cd07644227897e3bae1f (packages/react-aria/exports/useTokenField.ts).
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing
+ */
+
+export {
+	useTokenField,
+	tokenFieldPositionToDOMRange,
+	setTokenFieldSelection,
+} from '../../tokenfield/useTokenField';
+export { useToken } from '../../tokenfield/useToken';
+export type { TokenFieldAria, AriaTokenFieldProps } from '../../tokenfield/useTokenField';
+export type { TokenAria, TokenProps } from '../../tokenfield/useToken';

package/src/upstream-exports/react-stately/private/collections/getChildNodes.tsx

@@ -0,0 +1,8 @@
+/** @jsxImportSource octane */
+export {
+	getChildNodes,
+	getFirstItem,
+	getLastItem,
+	getNthItem,
+	compareNodeOrder,
+} from '../../../../stately/collections/getChildNodes';

package/src/upstream-exports/react-stately/private/collections/getItemCount.tsx

@@ -0,0 +1,2 @@
+/** @jsxImportSource octane */
+export { getItemCount } from '../../../../stately/collections/getItemCount';

package/src/upstream-exports/react-stately/private/grid/GridCollection.tsx

@@ -0,0 +1,7 @@
+/** @jsxImportSource octane */
+export {
+	type GridNode,
+	GridCollection,
+	type IGridCollection,
+	type GridRow,
+} from '../../../../stately/grid/GridCollection';

package/src/upstream-exports/react-stately/private/grid/useGridState.tsx

@@ -0,0 +1,6 @@
+/** @jsxImportSource octane */
+export {
+	useGridState,
+	type GridState,
+	type GridStateOptions,
+} from '../../../../stately/grid/useGridState';

package/src/upstream-exports/react-stately/private/utils/number.tsx

@@ -0,0 +1,2 @@
+/** @jsxImportSource octane */
+export { clamp, snapValueToStep, toFixedNumber } from '../../../../stately/utils/number';

package/src/upstream-exports/react-stately/useComboBoxState.tsx

@@ -0,0 +1,23 @@
+/** @jsxImportSource octane */
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+export { useComboBoxState } from '../../stately/combobox/useComboBoxState';
+
+export type {
+	ComboBoxProps,
+	ComboBoxStateOptions,
+	ComboBoxState,
+	ComboBoxValidationValue,
+	SelectionMode,
+	MenuTriggerAction,
+} from '../../stately/combobox/useComboBoxState';

package/src/upstream-exports/react-stately/useListState.tsx

@@ -0,0 +1,15 @@
+/** @jsxImportSource octane */
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+export type { ListProps, ListState } from '../../stately/list/useListState';
+export { useListState, UNSTABLE_useFilteredListState } from '../../stately/list/useListState';

package/src/upstream-exports/react-stately/useMenuTriggerState.tsx

@@ -0,0 +1,26 @@
+/** @jsxImportSource octane */
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+export { useMenuTriggerState } from '../../stately/menu/useMenuTriggerState';
+export { useSubmenuTriggerState } from '../../stately/menu/useSubmenuTriggerState';
+
+export type {
+	MenuTriggerProps,
+	MenuTriggerState,
+	RootMenuTriggerState,
+	MenuTriggerType,
+} from '../../stately/menu/useMenuTriggerState';
+export type {
+	SubmenuTriggerProps,
+	SubmenuTriggerState,
+} from '../../stately/menu/useSubmenuTriggerState';

package/src/upstream-exports/react-stately/useMultipleSelectionState.tsx

@@ -0,0 +1,21 @@
+/** @jsxImportSource octane */
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+export type { MultipleSelectionStateProps } from '../../stately/selection/useMultipleSelectionState';
+export { useMultipleSelectionState } from '../../stately/selection/useMultipleSelectionState';
+export {
+	type MultipleSelectionManager,
+	type MultipleSelectionState,
+	type FocusState,
+} from '../../stately/selection/types';
+export type { DisabledBehavior, Selection, SelectionBehavior } from '@react-types/shared';

package/src/upstream-exports/react-stately/useNumberFieldState.tsx

@@ -0,0 +1,20 @@
+/** @jsxImportSource octane */
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+export { useNumberFieldState } from '../../stately/numberfield/useNumberFieldState';
+
+export type { NumberFieldStateOptions } from '../../stately/numberfield/useNumberFieldState';
+export type {
+	NumberFieldProps,
+	NumberFieldState,
+} from '../../stately/numberfield/useNumberFieldState';

package/src/upstream-exports/react-stately/useOverlayTriggerState.tsx

@@ -0,0 +1,20 @@
+/** @jsxImportSource octane */
+// Ported from adobe/react-spectrum@5ecb3333001313e83898cd07644227897e3bae1f (packages/react-stately/exports/useOverlayTriggerState.ts).
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+export { useOverlayTriggerState } from '../../stately/overlays/useOverlayTriggerState';
+
+export type {
+	OverlayTriggerProps,
+	OverlayTriggerState,
+} from '../../stately/overlays/useOverlayTriggerState';

package/src/upstream-exports/react-stately/useRadioGroupState.tsx

@@ -0,0 +1,16 @@
+/** @jsxImportSource octane */
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+export { useRadioGroupState } from '../../stately/radio/useRadioGroupState';
+
+export type { RadioGroupProps, RadioGroupState } from '../../stately/radio/useRadioGroupState';