@octanejs/aria 0.0.1

package/src/interactions/useScrollWheel.ts

@@ -0,0 +1,55 @@
+// Ported from react-aria (source: .react-spectrum/packages/react-aria/src/interactions/useScrollWheel.ts).
+// octane adaptations:
+// - The wheel handler receives the native WheelEvent (upstream's untyped param).
+// - Public-hook slot threading (splitSlot/subSlot) per the binding convention.
+import type { RefObject, ScrollEvents } from '@react-types/shared';
+import { useCallback } from 'octane';
+
+import { S, splitSlot, subSlot } from '../internal';
+import { useEvent } from '../utils/useEvent';
+
+export interface ScrollWheelProps extends ScrollEvents {
+	/** Whether the scroll listener should be disabled. */
+	isDisabled?: boolean;
+}
+
+// scroll wheel needs to be added not passively so it's cancelable, small helper hook to remember that
+// (that means bypassing framework-delegated wheel handling with a direct element listener —
+// which useEvent is. Element-target wheel listeners are cancelable by default; the browser's
+// passive-by-default intervention only covers window/document/body. Upstream likewise passes
+// no explicit `passive: false` — see the pinned source.)
+export function useScrollWheel(props: ScrollWheelProps, ref: RefObject<HTMLElement | null>): void;
+// Slot-threading form: sibling ported hooks pass their derived sub-slot as the trailing arg.
+export function useScrollWheel(
+	props: ScrollWheelProps,
+	ref: RefObject<HTMLElement | null>,
+	slot: symbol | undefined,
+): void;
+export function useScrollWheel(...args: any[]): void {
+	const [user, slotArg] = splitSlot(args);
+	const slot = slotArg ?? S('useScrollWheel');
+	const props = user[0] as ScrollWheelProps;
+	const ref = user[1] as RefObject<HTMLElement | null>;
+
+	let { onScroll, isDisabled } = props;
+	let onScrollHandler = useCallback(
+		(e: WheelEvent) => {
+			// If the ctrlKey is pressed, this is a zoom event, do nothing.
+			if (e.ctrlKey) {
+				return;
+			}
+
+			// stop scrolling the page
+			e.preventDefault();
+			e.stopPropagation();
+
+			if (onScroll) {
+				onScroll({ deltaX: e.deltaX, deltaY: e.deltaY });
+			}
+		},
+		[onScroll],
+		subSlot(slot, 'handler'),
+	);
+
+	useEvent(ref, 'wheel', isDisabled ? undefined : onScrollHandler, subSlot(slot, 'wheel'));
+}

package/src/interactions/utils.ts

@@ -0,0 +1,212 @@
+// Ported from react-aria (source: .react-spectrum/packages/react-aria/src/interactions/utils.ts).
+// octane adaptation: handlers receive NATIVE events (there is no synthetic layer), so the
+// "synthetic event" here is the native event augmented in place — `createSyntheticEvent`
+// stays for the paths that dispatch/wrap events themselves, and its self-referential
+// `nativeEvent` keeps downstream `.nativeEvent` reads working for both arrival paths.
+import type { FocusableElement } from '@react-types/shared';
+import { useCallback, useRef } from 'octane';
+
+import { S, splitSlot, subSlot } from '../internal';
+import { focusWithoutScrolling } from '../utils/focusWithoutScrolling';
+import { getActiveElement, getEventTarget } from '../utils/shadowdom/DOMFunctions';
+import { getOwnerWindow } from '../utils/domHelpers';
+import { isFocusable } from '../utils/isFocusable';
+import { useLayoutEffect } from '../utils/useLayoutEffect';
+
+// The augmented-native-event surface react-aria's internals read. On octane the native
+// event IS the event object; these fields are stamped onto it.
+export type SyntheticEventShim<E extends Event = Event> = E & {
+	nativeEvent: E;
+	isDefaultPrevented(): boolean;
+	isPropagationStopped(): boolean;
+	persist(): void;
+};
+
+// Turn a native event into the augmented shape above (upstream: "into a React synthetic
+// event"). Mutates the per-dispatch event object, exactly like upstream.
+export function createSyntheticEvent<E extends Event>(nativeEvent: E): SyntheticEventShim<E> {
+	let event = nativeEvent as SyntheticEventShim<E>;
+	event.nativeEvent = nativeEvent;
+	event.isDefaultPrevented = () => event.defaultPrevented;
+	// cancelBubble is technically deprecated in the spec, but still supported in all browsers.
+	event.isPropagationStopped = () => (event as any).cancelBubble;
+	event.persist = () => {};
+	return event;
+}
+
+export function setEventTarget(event: Event, target: Element): void {
+	Object.defineProperty(event, 'target', { value: target });
+	Object.defineProperty(event, 'currentTarget', { value: target });
+}
+
+export function useSyntheticBlurEvent(onBlur: (e: FocusEvent) => void): (e: FocusEvent) => void;
+// Slot-threading form: sibling ported hooks pass their derived sub-slot as the trailing arg.
+export function useSyntheticBlurEvent(
+	onBlur: (e: FocusEvent) => void,
+	slot: symbol | undefined,
+): (e: FocusEvent) => void;
+export function useSyntheticBlurEvent(...args: any[]): (e: FocusEvent) => void {
+	const [user, slotArg] = splitSlot(args);
+	const slot = slotArg ?? S('useSyntheticBlurEvent');
+	const onBlur = user[0] as (e: FocusEvent) => void;
+
+	let stateRef = useRef(
+		{
+			isFocused: false,
+			observer: null as MutationObserver | null,
+		},
+		subSlot(slot, 'state'),
+	);
+
+	// Clean up MutationObserver on unmount. See below.
+
+	useLayoutEffect(
+		() => {
+			const state = stateRef.current;
+			return () => {
+				if (state.observer) {
+					state.observer.disconnect();
+					state.observer = null;
+				}
+			};
+		},
+		[],
+		subSlot(slot, 'teardown'),
+	);
+
+	// This function is called during a focus event.
+	return useCallback(
+		(e: FocusEvent) => {
+			// Browsers do not fire blur when a focused element becomes disabled. Most fire a
+			// native focusout event in this case, except for Firefox. In that case, we use a
+			// MutationObserver to watch for the disabled attribute, and dispatch these events
+			// ourselves. For browsers that do, focusout fires before the MutationObserver, so
+			// onBlur should not fire twice.
+			let eventTarget = getEventTarget(e);
+			if (
+				eventTarget instanceof HTMLButtonElement ||
+				eventTarget instanceof HTMLInputElement ||
+				eventTarget instanceof HTMLTextAreaElement ||
+				eventTarget instanceof HTMLSelectElement
+			) {
+				stateRef.current.isFocused = true;
+
+				let target = eventTarget;
+				let onBlurHandler: ((e: FocusEvent) => void) | null = (e: FocusEvent) => {
+					stateRef.current.isFocused = false;
+
+					if (target.disabled) {
+						// For backward compatibility, dispatch the augmented event shape.
+						let event = createSyntheticEvent(e);
+						onBlur?.(event);
+					}
+
+					// We no longer need the MutationObserver once the target is blurred.
+					if (stateRef.current.observer) {
+						stateRef.current.observer.disconnect();
+						stateRef.current.observer = null;
+					}
+				};
+
+				target.addEventListener('focusout', onBlurHandler as EventListener, { once: true });
+
+				stateRef.current.observer = new MutationObserver(() => {
+					if (stateRef.current.isFocused && target.disabled) {
+						stateRef.current.observer?.disconnect();
+						let relatedTargetEl = target === getActiveElement() ? null : getActiveElement();
+						target.dispatchEvent(new FocusEvent('blur', { relatedTarget: relatedTargetEl }));
+						target.dispatchEvent(
+							new FocusEvent('focusout', { bubbles: true, relatedTarget: relatedTargetEl }),
+						);
+					}
+				});
+
+				stateRef.current.observer.observe(target, {
+					attributes: true,
+					attributeFilter: ['disabled'],
+				});
+			}
+		},
+		[onBlur],
+		subSlot(slot, 'handler'),
+	);
+}
+
+export let ignoreFocusEvent = false;
+
+/**
+ * This function prevents the next focus event fired on `target`, without using
+ * `event.preventDefault()`. It works by waiting for the series of focus events to occur, and
+ * reverts focus back to where it was before. It also makes these events mostly non-observable by
+ * using a capturing listener on the window and stopping propagation.
+ */
+export function preventFocus(target: FocusableElement | null): (() => void) | undefined {
+	// The browser will focus the nearest focusable ancestor of our target.
+	while (target && !isFocusable(target, { skipVisibilityCheck: true })) {
+		target = target.parentElement as FocusableElement | null;
+	}
+
+	let window = getOwnerWindow(target);
+	let activeElement = window.document.activeElement as FocusableElement | null;
+	if (!activeElement || activeElement === target) {
+		return;
+	}
+
+	ignoreFocusEvent = true;
+	let isRefocusing = false;
+	let onBlur = (e: FocusEvent) => {
+		if (getEventTarget(e) === activeElement || isRefocusing) {
+			e.stopImmediatePropagation();
+		}
+	};
+
+	let onFocusOut = (e: FocusEvent) => {
+		if (getEventTarget(e) === activeElement || isRefocusing) {
+			e.stopImmediatePropagation();
+
+			// If there was no focusable ancestor, we don't expect a focus event.
+			// Re-focus the original active element here.
+			if (!target && !isRefocusing) {
+				isRefocusing = true;
+				focusWithoutScrolling(activeElement);
+				cleanup();
+			}
+		}
+	};
+
+	let onFocus = (e: FocusEvent) => {
+		if (getEventTarget(e) === target || isRefocusing) {
+			e.stopImmediatePropagation();
+		}
+	};
+
+	let onFocusIn = (e: FocusEvent) => {
+		if (getEventTarget(e) === target || isRefocusing) {
+			e.stopImmediatePropagation();
+
+			if (!isRefocusing) {
+				isRefocusing = true;
+				focusWithoutScrolling(activeElement);
+				cleanup();
+			}
+		}
+	};
+
+	window.addEventListener('blur', onBlur, true);
+	window.addEventListener('focusout', onFocusOut, true);
+	window.addEventListener('focusin', onFocusIn, true);
+	window.addEventListener('focus', onFocus, true);
+
+	let cleanup = () => {
+		cancelAnimationFrame(raf);
+		window.removeEventListener('blur', onBlur, true);
+		window.removeEventListener('focusout', onFocusOut, true);
+		window.removeEventListener('focusin', onFocusIn, true);
+		window.removeEventListener('focus', onFocus, true);
+		ignoreFocusEvent = false;
+		isRefocusing = false;
+	};
+
+	let raf = requestAnimationFrame(cleanup);
+	return cleanup;
+}

package/src/internal.ts

@@ -0,0 +1,57 @@
+// Slot mechanics for @octanejs/aria's plain-`.ts` hooks. octane's compiler
+// injects a per-call-site Symbol slot as the trailing arg of every hook call in a
+// compiled `.tsx`/`.tsrx`. These hook files are published source (consumed from
+// node_modules, where the auto-slotting pass is skipped), so each PUBLIC hook
+// receives the caller's slot as its trailing argument and derives a distinct
+// sub-slot for every base hook it composes. Public hooks keep their react-aria
+// parameter types and absorb the injected slot through a trailing rest param:
+//   export function useHover(props: HoverProps, ...args: any[]): HoverResult {
+//     const slot = restSlot(args) ?? S('useHover');
+// (Same pattern as the other @octanejs bindings; see packages/floating-ui.)
+
+// Derive a stable, distinct sub-slot from a wrapper's slot, namespaced per hook.
+// Memoized: subSlot runs on EVERY hook call every render, and the naive form
+// pays a string concat + global symbol-registry lookup each time. The cache is
+// keyed by the slot symbol itself; the minted value is byte-identical to the
+// uncached Symbol.for result, so identity is preserved across HMR re-evals and
+// the per-package copies of this helper. Key universe is bounded: slots are
+// per-call-site module constants (never minted per render).
+const subSlotCache = new Map<symbol, Map<string, symbol>>();
+export function subSlot(slot: symbol | undefined, tag: string): symbol | undefined {
+	if (slot === undefined) return undefined;
+	let byTag = subSlotCache.get(slot);
+	if (byTag === undefined) subSlotCache.set(slot, (byTag = new Map()));
+	let sym = byTag.get(tag);
+	if (sym === undefined) byTag.set(tag, (sym = Symbol.for((slot.description ?? '') + ':' + tag)));
+	return sym;
+}
+
+// Split the compiler-injected trailing slot off a hook's args. Needed when a
+// public hook takes optional user args, so the slot can't be located positionally.
+export function splitSlot(args: any[]): [any[], symbol | undefined] {
+	const tail = args[args.length - 1];
+	const slot = typeof tail === 'symbol' ? (tail as symbol) : undefined;
+	return [slot !== undefined ? args.slice(0, -1) : args, slot];
+}
+
+// The common public-hook form: all REQUIRED user params are declared, so the
+// rest array contains at most the injected slot (plus possibly trailing
+// optional user args — callers pass those before the injected slot, so the
+// symbol is always last).
+export function restSlot(args: any[]): symbol | undefined {
+	const tail = args[args.length - 1];
+	return typeof tail === 'symbol' ? (tail as symbol) : undefined;
+}
+
+// A stable per-call-site slot for the binding's plain-`.ts` COMPONENTS (written
+// with createElement, not compiled, so they get no auto-injected slots). A
+// component runs in its OWN per-instance scope (componentSlot), so a globally
+// stable Symbol.for(tag) resolves to a distinct slot per instance. Pass S('tag')
+// as the slot to base hooks; sub-hooks derive their own sub-slots from its
+// description.
+const sCache = new Map<string, symbol>();
+export function S(tag: string): symbol {
+	let sym = sCache.get(tag);
+	if (sym === undefined) sCache.set(tag, (sym = Symbol.for('@octanejs/aria:' + tag)));
+	return sym;
+}

package/src/ssr/SSRProvider.ts

@@ -0,0 +1,72 @@
+// Ported from react-aria (source: .react-spectrum/packages/react-aria/src/ssr/SSRProvider.tsx).
+// octane always has SSR-stable `useId` and `useSyncExternalStore`, so React's legacy
+// (<18) SSRProvider machinery — the context-threaded id counter, the Fiber-keyed
+// StrictMode double-render guard — collapses away exactly like upstream's modern path:
+// `SSRProvider` is a pass-through, `useSSRSafeId` prefixes the framework id, and
+// `useIsSSR` reads the store-snapshot seam (server snapshot → true, client → false).
+import { useId as octaneUseId, useState, useSyncExternalStore } from 'octane';
+
+import { S, splitSlot, subSlot } from '../internal';
+
+export interface SSRProviderProps {
+	/** Your application here. */
+	children: any;
+}
+
+/**
+ * Legacy-React compatibility wrapper — a no-op pass-through in octane, matching
+ * upstream's behavior on React 18+.
+ */
+export function SSRProvider(props: SSRProviderProps): any {
+	return props.children;
+}
+
+// In order to support multiple copies of the library potentially being on the page at
+// once, client-only ids get a random per-module prefix. When the app was server
+// rendered (or in tests, where ids must be deterministic), the plain `react-aria`
+// prefix is used so server and client agree.
+const defaultPrefix = String(Math.round(Math.random() * 10000000000));
+
+/** @private */
+export function useSSRSafeId(defaultId?: string): string;
+// Slot-threading form: sibling ported hooks pass their derived sub-slot as the trailing arg.
+export function useSSRSafeId(defaultId: string | undefined, slot: symbol | undefined): string;
+export function useSSRSafeId(...args: any[]): string {
+	const [user, slotArg] = splitSlot(args);
+	const slot = slotArg ?? S('useSSRSafeId');
+	const defaultId = user[0] as string | undefined;
+
+	const id = octaneUseId(subSlot(slot, 'id'));
+	const isSSR = useIsSSR(subSlot(slot, 'ssr'));
+	const [didSSR] = useState(isSSR, subSlot(slot, 'didSSR'));
+	const prefix =
+		didSSR || process.env.NODE_ENV === 'test' ? 'react-aria' : `react-aria${defaultPrefix}`;
+	return defaultId || `${prefix}-${id}`;
+}
+
+function getSnapshot(): boolean {
+	return false;
+}
+
+function getServerSnapshot(): boolean {
+	return true;
+}
+
+function subscribe(): () => void {
+	// noop
+	return () => {};
+}
+
+/**
+ * Returns whether the component is currently being server side rendered or
+ * hydrated on the client. Can be used to delay browser-specific rendering
+ * until after hydration.
+ */
+export function useIsSSR(): boolean;
+// Slot-threading form: sibling ported hooks pass their derived sub-slot as the trailing arg.
+export function useIsSSR(slot: symbol | undefined): boolean;
+export function useIsSSR(...args: any[]): boolean {
+	const [, slotArg] = splitSlot(args);
+	const slot = slotArg ?? S('useIsSSR');
+	return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot, subSlot(slot, 'store'));
+}

package/src/stately/flags.ts

@@ -0,0 +1,21 @@
+// Ported from react-stately (source: .react-spectrum/packages/react-stately/src/flags/flags.ts).
+// Internal feature flags (upstream ships them under `react-stately/private/flags/flags`).
+
+let _tableNestedRows = false;
+let _shadowDOM = false;
+
+export function enableTableNestedRows(): void {
+	_tableNestedRows = true;
+}
+
+export function tableNestedRows(): boolean {
+	return _tableNestedRows;
+}
+
+export function enableShadowDOM(): void {
+	_shadowDOM = true;
+}
+
+export function shadowDOM(): boolean {
+	return _shadowDOM;
+}

package/src/stately/index.ts

@@ -0,0 +1,7 @@
+// @octanejs/aria/stately — the `react-stately` surface, ported onto octane. Exports mirror
+// the upstream monopackage exports (.react-spectrum/packages/react-stately/exports/) and
+// grow area-by-area with the migration plan (docs/aria-migration-plan.md).
+
+// utils
+export { useControlledState } from './utils/useControlledState';
+export type { SetStateAction } from './utils/useControlledState';

package/src/stately/utils/number.ts

@@ -0,0 +1,70 @@
+// Ported from react-stately (source: .react-spectrum/packages/react-stately/src/utils/number.ts).
+
+/**
+ * Takes a value and forces it to the closest min/max if it's outside. Also forces it to the closest
+ * valid step.
+ */
+export function clamp(value: number, min: number = -Infinity, max: number = Infinity): number {
+	let newValue = Math.min(Math.max(value, min), max);
+	return newValue;
+}
+
+export function roundToStepPrecision(value: number, step: number): number {
+	let roundedValue = value;
+	let precision = 0;
+	let stepString = step.toString();
+	// Handle negative exponents in exponential notation (e.g., "1e-7" → precision 8)
+	let eIndex = stepString.toLowerCase().indexOf('e-');
+	if (eIndex > 0) {
+		precision = Math.abs(Math.floor(Math.log10(Math.abs(step)))) + eIndex;
+	} else {
+		let pointIndex = stepString.indexOf('.');
+		if (pointIndex >= 0) {
+			precision = stepString.length - pointIndex;
+		}
+	}
+	if (precision > 0) {
+		let pow = Math.pow(10, precision);
+		roundedValue = Math.round(roundedValue * pow) / pow;
+	}
+	return roundedValue;
+}
+
+export function snapValueToStep(
+	value: number,
+	min: number | undefined,
+	max: number | undefined,
+	step: number,
+): number {
+	min = Number(min);
+	max = Number(max);
+	let remainder = (value - (isNaN(min) ? 0 : min)) % step;
+	let snappedValue = roundToStepPrecision(
+		Math.abs(remainder) * 2 >= step
+			? value + Math.sign(remainder) * (step - Math.abs(remainder))
+			: value - remainder,
+		step,
+	);
+
+	if (!isNaN(min)) {
+		if (snappedValue < min) {
+			snappedValue = min;
+		} else if (!isNaN(max) && snappedValue > max) {
+			snappedValue = min + Math.floor(roundToStepPrecision((max - min) / step, step)) * step;
+		}
+	} else if (!isNaN(max) && snappedValue > max) {
+		snappedValue = Math.floor(roundToStepPrecision(max / step, step)) * step;
+	}
+
+	// correct floating point behavior by rounding to step precision
+	snappedValue = roundToStepPrecision(snappedValue, step);
+
+	return snappedValue;
+}
+
+/* Takes a value and rounds off to the number of digits. */
+export function toFixedNumber(value: number, digits: number, base: number = 10): number {
+	const pow = Math.pow(base, digits);
+
+	return Math.round(value * pow) / pow;
+}

package/src/stately/utils/useControlledState.ts

@@ -0,0 +1,75 @@
+// Ported from react-stately (source: .react-spectrum/packages/react-stately/src/utils/useControlledState.ts).
+// octane adaptations: React's SetStateAction type is declared locally; octane always has
+// `useInsertionEffect`, so upstream's React-17 layout-effect fallback collapses away; the
+// dev-only controlled↔uncontrolled switch warning (and the ref that only fed it) is not ported.
+
+import { useCallback, useInsertionEffect, useReducer, useState, useRef } from 'octane';
+
+import { S, splitSlot, subSlot } from '../../internal';
+
+export type SetStateAction<S> = S | ((prevState: S) => S);
+
+// Use the earliest effect possible to reset the ref below.
+const useEarlyEffect: typeof useInsertionEffect =
+	typeof document !== 'undefined' ? useInsertionEffect : ((() => {}) as any);
+
+export function useControlledState<T, C = T>(
+	value: Exclude<T, undefined>,
+	defaultValue: Exclude<T, undefined> | undefined,
+	onChange?: (v: C, ...args: any[]) => void,
+): [T, (value: SetStateAction<T>, ...args: any[]) => void];
+export function useControlledState<T, C = T>(
+	value: Exclude<T, undefined> | undefined,
+	defaultValue: Exclude<T, undefined>,
+	onChange?: (v: C, ...args: any[]) => void,
+): [T, (value: SetStateAction<T>, ...args: any[]) => void];
+export function useControlledState(...args: any[]): any {
+	const [user, slotArg] = splitSlot(args);
+	const slot = slotArg ?? S('useControlledState');
+	const value = user[0];
+	const defaultValue = user[1];
+	const onChange = user[2] as ((v: any, ...onChangeArgs: any[]) => void) | undefined;
+
+	// Store the value in both state and a ref. The state value will only be used when uncontrolled.
+	// The ref is used to track the most current value, which is passed to the function setState callback.
+	let [stateValue, setStateValue] = useState(value || defaultValue, subSlot(slot, 'state'));
+	let valueRef = useRef(stateValue, subSlot(slot, 'valueRef'));
+
+	let isControlled = value !== undefined;
+
+	// After each render, update the ref to the current value.
+	// This ensures that the setState callback argument is reset.
+	// Note: the effect should not have any dependencies so that controlled values always reset.
+	let currentValue = isControlled ? value : stateValue;
+	useEarlyEffect(
+		() => {
+			valueRef.current = currentValue;
+		},
+		null,
+		subSlot(slot, 'sync'),
+	);
+
+	let [, forceUpdate] = useReducer<object, void>(() => ({}), {}, subSlot(slot, 'force'));
+	let setValue = useCallback(
+		(value: any, ...setterArgs: any[]) => {
+			let newValue = typeof value === 'function' ? value(valueRef.current) : value;
+			if (!Object.is(valueRef.current, newValue)) {
+				// Update the ref so that the next setState callback has the most recent value.
+				valueRef.current = newValue;
+
+				setStateValue(newValue);
+
+				// Always trigger a re-render, even when controlled, so that the layout effect above runs to reset the value.
+				forceUpdate();
+
+				// Trigger onChange. Note that if setState is called multiple times in a single event,
+				// onChange will be called for each one instead of only once.
+				onChange?.(newValue, ...setterArgs);
+			}
+		},
+		[onChange],
+		subSlot(slot, 'set'),
+	);
+
+	return [currentValue, setValue];
+}

package/src/utils/chain.ts

@@ -0,0 +1,14 @@
+// Ported from react-aria (source: .react-spectrum/packages/react-aria/src/utils/chain.ts).
+
+/**
+ * Calls all functions in the order they were chained with the same arguments.
+ */
+export function chain(...callbacks: any[]): (...args: any[]) => void {
+	return (...args: any[]) => {
+		for (let callback of callbacks) {
+			if (typeof callback === 'function') {
+				callback(...args);
+			}
+		}
+	};
+}

package/src/utils/constants.ts

@@ -0,0 +1,5 @@
+// Ported from react-aria (source: .react-spectrum/packages/react-aria/src/utils/constants.ts).
+
+// Custom event names for updating the autocomplete's aria-activedecendant.
+export const CLEAR_FOCUS_EVENT = 'react-aria-clear-focus';
+export const FOCUS_EVENT = 'react-aria-focus';

package/src/utils/domHelpers.ts

@@ -0,0 +1,36 @@
+// Ported from react-aria (source: .react-spectrum/packages/react-aria/src/utils/domHelpers.ts).
+
+export const getOwnerDocument = (el: Element | null | undefined): Document => {
+	return el?.ownerDocument ?? document;
+};
+
+export const getOwnerWindow = (
+	el: (Window & typeof globalThis) | Element | null | undefined,
+): Window & typeof globalThis => {
+	if (el && 'window' in el && el.window === el) {
+		return el;
+	}
+
+	const doc = getOwnerDocument(el as Element | null | undefined);
+	return doc.defaultView || window;
+};
+
+/**
+ * Type guard that checks if a value is a Node. Verifies the presence and type of the nodeType
+ * property.
+ */
+function isNode(value: unknown): value is Node {
+	return (
+		value !== null &&
+		typeof value === 'object' &&
+		'nodeType' in value &&
+		typeof (value as Node).nodeType === 'number'
+	);
+}
+/**
+ * Type guard that checks if a node is a ShadowRoot. Uses nodeType and host property checks to
+ * distinguish ShadowRoot from other DocumentFragments.
+ */
+export function isShadowRoot(node: Node | null): node is ShadowRoot {
+	return isNode(node) && node.nodeType === Node.DOCUMENT_FRAGMENT_NODE && 'host' in node;
+}