@octanejs/base-ui 0.1.49 → 0.1.51

package/src/utils/floating/enqueueFocus.ts

@@ -1,38 +0,0 @@
-// Ported verbatim from .base-ui/packages/react/src/floating-ui-react/utils/enqueueFocus.ts.
-// Focuses an element on the next frame (or synchronously), superseding any pending focus.
-import { NOOP } from '../empty';
-import type { FocusableElement } from './tabbable';
-
-interface Options {
-	preventScroll?: boolean | undefined;
-	sync?: boolean | undefined;
-	shouldFocus?: (() => boolean) | undefined;
-}
-
-let rafId = 0;
-export function enqueueFocus(el: FocusableElement | null, options: Options = {}): () => void {
-	const { preventScroll = false, sync = false, shouldFocus } = options;
-
-	cancelAnimationFrame(rafId);
-
-	function exec() {
-		if (shouldFocus && !shouldFocus()) {
-			return;
-		}
-		el?.focus({ preventScroll });
-	}
-
-	if (sync) {
-		exec();
-		return NOOP;
-	}
-
-	const currentRafId = requestAnimationFrame(exec);
-	rafId = currentRafId;
-	return () => {
-		if (rafId === currentRafId) {
-			cancelAnimationFrame(currentRafId);
-			rafId = 0;
-		}
-	};
-}

package/src/utils/floating/event.ts

@@ -1,53 +0,0 @@
-// Ported from .base-ui/packages/react/src/floating-ui-react/utils/event.ts (v1.6.0) — the subset
-// used so far. octane events are native, so these operate on native events directly.
-import { platform } from '../platform';
-
-export function isClickLikeEvent(event: Event): boolean {
-	const type = event.type;
-	return type === 'click' || type === 'mousedown' || type === 'keydown' || type === 'keyup';
-}
-
-export function isMouseLikePointerType(pointerType: string | undefined, strict?: boolean): boolean {
-	const values: Array<string | undefined> = ['mouse', 'pen'];
-	if (!strict) {
-		values.push('', undefined);
-	}
-	return values.includes(pointerType);
-}
-
-// octane events are native, so this is effectively always false for handler `event`s (a native
-// event has no `.nativeEvent`) — ported for faithfulness so `isReactEvent(e) ? e.nativeEvent : e`
-// resolves to the native event.
-export function isReactEvent(event: any): boolean {
-	return event != null && 'nativeEvent' in event;
-}
-
-export function isVirtualClick(event: MouseEvent | PointerEvent): boolean {
-	if ((event as PointerEvent).pointerType === '' && event.isTrusted) {
-		return true;
-	}
-	if (platform.os.android && (event as PointerEvent).pointerType) {
-		return event.type === 'click' && event.buttons === 1;
-	}
-	return event.detail === 0 && !(event as PointerEvent).pointerType;
-}
-
-export function isVirtualPointerEvent(event: PointerEvent): boolean {
-	if (platform.env.jsdom) {
-		return false;
-	}
-	return (
-		(!platform.os.android && event.width === 0 && event.height === 0) ||
-		(platform.os.android &&
-			event.width === 1 &&
-			event.height === 1 &&
-			event.pressure === 0 &&
-			event.detail === 0 &&
-			event.pointerType === 'mouse') ||
-		(event.width < 1 &&
-			event.height < 1 &&
-			event.pressure === 0 &&
-			event.detail === 0 &&
-			event.pointerType === 'touch')
-	);
-}

package/src/utils/floating/getEmptyRootContext.ts

@@ -1,19 +0,0 @@
-// Ported verbatim from .base-ui/packages/react/src/floating-ui-react/utils/getEmptyRootContext.ts.
-// The inert root context a popup store starts with before its real one is created.
-import { PopupTriggerMap } from '../popups/popupTriggerMap';
-import { FloatingRootStore } from './FloatingRootStore';
-import type { FloatingRootContext } from './types';
-
-export function getEmptyRootContext(): FloatingRootContext {
-	return new FloatingRootStore({
-		open: false,
-		transitionStatus: undefined,
-		floatingElement: null,
-		referenceElement: null,
-		triggerElements: new PopupTriggerMap(),
-		floatingId: undefined,
-		syncOnly: false,
-		nested: false,
-		onOpenChange: undefined,
-	});
-}

package/src/utils/floating/gridNavigation.ts

@@ -1,54 +0,0 @@
-// Ported from .base-ui/packages/react/src/floating-ui-react/hooks/gridNavigation.ts (v1.6.0). The
-// grid navigator `useListNavigation` injects for its own `grid` option — distinct from
-// `../composite/gridNavigation`, which builds the navigator `useCompositeRoot` takes.
-//
-// octane adaptations: the event is the NATIVE `KeyboardEvent`, and `React.RefObject<T>` is a plain
-// `{ current: T }`. Not a hook, so no slot. Upstream's `utils/composite` module is split in this
-// binding: the list algebra lives in `../composite/list-utils`, the grid algorithm in
-// `../composite/grid-utils`.
-import { getGridNavigatedIndex } from '../composite/grid-utils';
-import { isIndexOutOfListBounds, type DisabledIndices } from '../composite/list-utils';
-
-/**
- * Positional arguments are deliberate: property names of an options object
- * don't minify, and the signature is locked to the caller via `typeof` on the
- * `grid` option of `useListNavigation`.
- *
- * The injected grid navigator only ever operates on a uniform 1x1 grid (sizes are
- * always `1x1` and packing is never dense), so the cell-map machinery that supports
- * multi-cell items collapses to an identity transform over the item list. Calling
- * `getGridNavigatedIndex` directly keeps the cell-map helpers
- * (`createGridCellMap`/`getGridCellIndexOfCorner`/`getGridCellIndices`) out of
- * grid-combobox bundles.
- */
-export function gridNavigation(
-	event: KeyboardEvent,
-	prevIndex: number,
-	listRef: { current: Array<HTMLElement | null> },
-	orientation: 'horizontal' | 'vertical' | 'both',
-	loopFocus: boolean,
-	rtl: boolean,
-	disabledIndices: DisabledIndices | undefined,
-	minIndex: number,
-	maxIndex: number,
-	cols = 2,
-): number | undefined {
-	const nextIndex = getGridNavigatedIndex(listRef.current, {
-		event,
-		orientation,
-		loopFocus,
-		rtl,
-		cols,
-		disabledIndices,
-		minIndex,
-		maxIndex,
-		// An out-of-range previous index falls back to the first enabled item.
-		prevIndex: prevIndex > maxIndex ? minIndex : prevIndex,
-		stopEvent: true,
-	});
-
-	// `getGridNavigatedIndex` can return an out-of-bounds sentinel (e.g. `-1` when there is no
-	// previous item to move from); surface that as `undefined` so the caller treats it as
-	// "no navigation" rather than highlighting index `-1`.
-	return isIndexOutOfListBounds(listRef.current, nextIndex) ? undefined : nextIndex;
-}

package/src/utils/floating/markOthers.ts

@@ -1,197 +0,0 @@
-// Ported verbatim from .base-ui/packages/react/src/floating-ui-react/utils/markOthers.ts (v1.6.0).
-// Ref-counted `aria-hidden`/`inert` + `data-base-ui-inert` marker application to everything outside
-// the modal popup (an aria-hidden fork). Pure DOM — only import paths change.
-import { getNodeName, isShadowRoot } from '@floating-ui/utils/dom';
-import { ownerDocument } from '../owner';
-
-type Undo = () => void;
-
-interface MarkOthersOptions {
-	ariaHidden?: boolean | undefined;
-	inert?: boolean | undefined;
-	mark?: boolean | undefined;
-}
-
-const counters = {
-	inert: new WeakMap<Element, number>(),
-	'aria-hidden': new WeakMap<Element, number>(),
-};
-
-const markerName = 'data-base-ui-inert';
-type ControlAttribute = keyof typeof counters;
-
-const uncontrolledElementsSets: Record<ControlAttribute, WeakSet<Element>> = {
-	inert: new WeakSet<Element>(),
-	'aria-hidden': new WeakSet<Element>(),
-};
-let markerCounterMap = new WeakMap<Element, number>();
-let lockCount = 0;
-
-function getUncontrolledElementsSet(controlAttribute: ControlAttribute) {
-	return uncontrolledElementsSets[controlAttribute];
-}
-
-function unwrapHost(node: Node | null): Element | null {
-	if (!node) {
-		return null;
-	}
-	return isShadowRoot(node) ? node.host : unwrapHost(node.parentNode);
-}
-
-const correctElements = (parent: HTMLElement, targets: Element[]): Element[] =>
-	targets
-		.map((target) => {
-			if (parent.contains(target)) {
-				return target;
-			}
-			const correctedTarget = unwrapHost(target);
-			if (correctedTarget && parent.contains(correctedTarget)) {
-				return correctedTarget;
-			}
-			return null;
-		})
-		.filter((x): x is Element => x != null);
-
-const buildKeepSet = (targets: Element[]): Set<Node> => {
-	const keep = new Set<Node>();
-	targets.forEach((target) => {
-		let node: Node | null = target;
-		while (node && !keep.has(node)) {
-			keep.add(node);
-			node = node.parentNode;
-		}
-	});
-	return keep;
-};
-
-const collectOutsideElements = (
-	root: HTMLElement,
-	keepElements: Set<Node>,
-	stopElements: Set<Node>,
-): Element[] => {
-	const outside: Element[] = [];
-	const walk = (parent: Element | null) => {
-		if (!parent || stopElements.has(parent)) {
-			return;
-		}
-		Array.from(parent.children).forEach((node: Element) => {
-			if (getNodeName(node) === 'script') {
-				return;
-			}
-			if (keepElements.has(node)) {
-				walk(node);
-			} else {
-				outside.push(node);
-			}
-		});
-	};
-	walk(root);
-	return outside;
-};
-
-function applyAttributeToOthers(
-	uncorrectedAvoidElements: Element[],
-	body: HTMLElement,
-	ariaHidden: boolean,
-	inert: boolean,
-	{ mark = true }: MarkOthersOptions,
-): Undo {
-	let controlAttribute: ControlAttribute | null = null;
-	if (inert) {
-		controlAttribute = 'inert';
-	} else if (ariaHidden) {
-		controlAttribute = 'aria-hidden';
-	}
-
-	let counterMap: WeakMap<Element, number> | null = null;
-	let uncontrolledElementsSet: WeakSet<Element> | null = null;
-	const avoidElements = correctElements(body, uncorrectedAvoidElements);
-	const markerTargets = mark
-		? collectOutsideElements(body, buildKeepSet(avoidElements), new Set<Node>(avoidElements))
-		: [];
-	const hiddenElements: Element[] = [];
-	const markedElements: Element[] = [];
-
-	if (controlAttribute) {
-		const map = counters[controlAttribute];
-		const currentUncontrolledElementsSet = getUncontrolledElementsSet(controlAttribute);
-		uncontrolledElementsSet = currentUncontrolledElementsSet;
-		counterMap = map;
-		const ariaLiveElements = correctElements(
-			body,
-			Array.from(body.querySelectorAll('[aria-live]')),
-		);
-		const controlElements = avoidElements.concat(ariaLiveElements);
-		const controlTargets = collectOutsideElements(
-			body,
-			buildKeepSet(controlElements),
-			new Set<Node>(controlElements),
-		);
-
-		controlTargets.forEach((node) => {
-			const attribute = node.getAttribute(controlAttribute!);
-			const alreadyHidden = attribute !== null && attribute !== 'false';
-			const counterValue = (map.get(node) || 0) + 1;
-			map.set(node, counterValue);
-			hiddenElements.push(node);
-			if (counterValue === 1 && alreadyHidden) {
-				currentUncontrolledElementsSet.add(node);
-			}
-			if (!alreadyHidden) {
-				node.setAttribute(controlAttribute!, controlAttribute === 'inert' ? '' : 'true');
-			}
-		});
-	}
-
-	if (mark) {
-		markerTargets.forEach((node) => {
-			const markerValue = (markerCounterMap.get(node) || 0) + 1;
-			markerCounterMap.set(node, markerValue);
-			markedElements.push(node);
-			if (markerValue === 1) {
-				node.setAttribute(markerName, '');
-			}
-		});
-	}
-
-	lockCount += 1;
-
-	return () => {
-		if (counterMap) {
-			hiddenElements.forEach((element) => {
-				const currentCounterValue = counterMap!.get(element) || 0;
-				const counterValue = currentCounterValue - 1;
-				counterMap!.set(element, counterValue);
-				if (!counterValue) {
-					if (!uncontrolledElementsSet?.has(element) && controlAttribute) {
-						element.removeAttribute(controlAttribute);
-					}
-					uncontrolledElementsSet?.delete(element);
-				}
-			});
-		}
-		if (mark) {
-			markedElements.forEach((element) => {
-				const markerValue = (markerCounterMap.get(element) || 0) - 1;
-				markerCounterMap.set(element, markerValue);
-				if (!markerValue) {
-					element.removeAttribute(markerName);
-				}
-			});
-		}
-		lockCount -= 1;
-		if (!lockCount) {
-			counters.inert = new WeakMap();
-			counters['aria-hidden'] = new WeakMap();
-			uncontrolledElementsSets.inert = new WeakSet();
-			uncontrolledElementsSets['aria-hidden'] = new WeakSet();
-			markerCounterMap = new WeakMap();
-		}
-	};
-}
-
-export function markOthers(avoidElements: Element[], options: MarkOthersOptions = {}): Undo {
-	const { ariaHidden = false, inert = false, mark = true } = options;
-	const body = ownerDocument(avoidElements[0]).body;
-	return applyAttributeToOthers(avoidElements, body, ariaHidden, inert, { mark });
-}

package/src/utils/floating/nodes.ts

@@ -1,31 +0,0 @@
-// Ported from .base-ui/packages/react/src/floating-ui-react/utils/nodes.ts (the subset used).
-// Walks the FloatingTree's flat node list to collect a node's (optionally open) descendants.
-import type { FloatingNodeType } from './types';
-
-export function getNodeChildren(
-	nodes: Array<FloatingNodeType>,
-	id: string | undefined,
-	onlyOpenChildren = true,
-): Array<FloatingNodeType> {
-	const directChildren = nodes.filter((node) => node.parentId === id);
-	return directChildren.flatMap((child) => [
-		...(!onlyOpenChildren || child.context?.open ? [child] : []),
-		...getNodeChildren(nodes, child.id, onlyOpenChildren),
-	]);
-}
-
-export function getNodeAncestors(
-	nodes: Array<FloatingNodeType>,
-	id: string | undefined,
-): Array<FloatingNodeType> {
-	let allAncestors: Array<FloatingNodeType> = [];
-	let currentParentId = nodes.find((node) => node.id === id)?.parentId;
-	while (currentParentId) {
-		const currentNode = nodes.find((node) => node.id === currentParentId);
-		currentParentId = currentNode?.parentId;
-		if (currentNode) {
-			allAncestors = allAncestors.concat(currentNode);
-		}
-	}
-	return allAncestors;
-}