@octanejs/aria 0.0.40 → 0.0.42

package/src/virtualizer/Virtualizer.tsx

@@ -0,0 +1,147 @@
+/** @jsxImportSource octane */
+// Ported from adobe/react-spectrum@1c84a49a1faf50b571c84e00bcf9c60b22ddd03e (packages/react-aria/src/virtualizer/Virtualizer.tsx).
+/*
+ * 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.
+ */
+
+import { Collection, Key, RefObject } from '@react-types/shared';
+import {
+	Layout,
+	Rect,
+	ReusableView,
+	useVirtualizerState,
+} from '../upstream-exports/react-stately/useVirtualizerState';
+import { mergeProps } from '../utils/mergeProps';
+import React, {
+	ForwardedRef,
+	HTMLAttributes,
+	ReactElement,
+	ReactNode,
+	useCallback,
+} from '../compat/react';
+import { ScrollView } from './ScrollView';
+import { useLoadMore } from '../utils/useLoadMore';
+import { useObjectRef } from '../utils/useObjectRef';
+import { VirtualizerItem } from './VirtualizerItem';
+
+type RenderWrapper<T extends object, V> = (
+	parent: ReusableView<T, V> | null,
+	reusableView: ReusableView<T, V>,
+	children: ReusableView<T, V>[],
+	renderChildren: (views: ReusableView<T, V>[]) => ReactElement[],
+) => ReactElement | null;
+
+interface VirtualizerProps<T extends object, V, O> extends Omit<
+	HTMLAttributes<HTMLElement>,
+	'children' | 'onScroll'
+> {
+	children: (type: string, content: T) => V;
+	renderWrapper?: RenderWrapper<T, V>;
+	layout: Layout<T, O>;
+	collection: Collection<T>;
+	persistedKeys?: Set<Key> | null;
+	scrollDirection?: 'horizontal' | 'vertical' | 'both';
+	isLoading?: boolean;
+	onLoadMore?: () => void;
+	layoutOptions?: O;
+	onScroll?: (e: Event) => void;
+}
+
+// forwardRef doesn't support generic parameters, so cast the result to the correct type
+// https://stackoverflow.com/questions/58469229/react-with-typescript-generics-while-using-react-forwardref
+export const Virtualizer = React.forwardRef(function Virtualizer<
+	T extends object,
+	V extends ReactNode,
+	O,
+>(props: VirtualizerProps<T, V, O>, forwardedRef: ForwardedRef<HTMLDivElement | null>) {
+	let {
+		children: renderView,
+		renderWrapper,
+		layout,
+		collection,
+		scrollDirection,
+		isLoading,
+		onLoadMore,
+		persistedKeys,
+		layoutOptions,
+		...otherProps
+	} = props;
+
+	let ref = useObjectRef(forwardedRef);
+
+	let state = useVirtualizerState({
+		layout,
+		collection,
+		renderView,
+		onVisibleRectChange(rect) {
+			if (ref.current) {
+				ref.current.scrollLeft = rect.x;
+				ref.current.scrollTop = rect.y;
+			}
+		},
+		persistedKeys,
+		layoutOptions,
+	});
+
+	useLoadMore({ isLoading, onLoadMore, scrollOffset: 1 }, ref);
+	let onVisibleRectChange = useCallback(
+		(rect: Rect) => {
+			state.setVisibleRect(rect);
+		},
+		[state],
+	);
+
+	return (
+		<ScrollView
+			{...mergeProps(otherProps, { onVisibleRectChange })}
+			ref={ref}
+			contentSize={state.contentSize}
+			onScrollStart={state.startScrolling}
+			onScrollEnd={state.endScrolling}
+			scrollDirection={scrollDirection}
+		>
+			{renderChildren(null, state.visibleViews, renderWrapper || defaultRenderWrapper)}
+		</ScrollView>
+	);
+}) as <T extends object, V, O>(
+	props: VirtualizerProps<T, V, O> & { ref?: RefObject<HTMLDivElement | null> },
+) => ReactElement;
+
+function renderChildren<T extends object, V>(
+	parent: ReusableView<T, V> | null,
+	views: ReusableView<T, V>[],
+	renderWrapper: RenderWrapper<T, V>,
+): ReactElement[] {
+	return views.map((view) => {
+		return renderWrapper(
+			parent,
+			view,
+			view.children ? Array.from(view.children) : [],
+			(childViews: ReusableView<T, V>[]) => renderChildren(view, childViews, renderWrapper),
+		);
+	});
+}
+
+function defaultRenderWrapper<T extends object, V extends ReactNode>(
+	parent: ReusableView<T, V> | null,
+	reusableView: ReusableView<T, V>,
+): ReactElement {
+	return (
+		<VirtualizerItem
+			key={reusableView.key}
+			layoutInfo={reusableView.layoutInfo!}
+			virtualizer={reusableView.virtualizer}
+			parent={parent?.layoutInfo}
+		>
+			{reusableView.rendered}
+		</VirtualizerItem>
+	);
+}

package/src/virtualizer/VirtualizerItem.tsx

@@ -0,0 +1,108 @@
+/** @jsxImportSource octane */
+// Ported from adobe/react-spectrum@1c84a49a1faf50b571c84e00bcf9c60b22ddd03e (packages/react-aria/src/virtualizer/VirtualizerItem.tsx).
+/*
+ * 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.
+ */
+
+import { Direction } from '@react-types/shared';
+import { LayoutInfo } from '../upstream-exports/react-stately/useVirtualizerState';
+import React, { CSSProperties, JSX, ReactNode, useRef } from '../compat/react';
+import { useLocale } from '../i18n/I18nProvider';
+import { useVirtualizerItem, VirtualizerItemOptions } from './useVirtualizerItem';
+
+interface VirtualizerItemProps extends Omit<VirtualizerItemOptions, 'ref'> {
+	layoutInfo: LayoutInfo;
+	parent?: LayoutInfo | null;
+	style?: CSSProperties;
+	className?: string;
+	children: ReactNode;
+}
+
+export function VirtualizerItem(props: VirtualizerItemProps): JSX.Element {
+	let { style, className, layoutInfo, virtualizer, parent, children } = props;
+	let { direction } = useLocale();
+	let ref = useRef<HTMLDivElement | null>(null);
+	useVirtualizerItem({
+		layoutInfo,
+		virtualizer,
+		ref,
+	});
+
+	return (
+		<div
+			role="presentation"
+			ref={ref}
+			className={className}
+			style={{ ...layoutInfoToStyle(layoutInfo, direction, parent), ...style }}
+		>
+			{children}
+		</div>
+	);
+}
+
+let cache = new WeakMap();
+export function layoutInfoToStyle(
+	layoutInfo: LayoutInfo,
+	dir: Direction,
+	parent?: LayoutInfo | null,
+): CSSProperties {
+	let xProperty = dir === 'rtl' ? 'right' : 'left';
+	let cached = cache.get(layoutInfo);
+	if (cached && cached[xProperty] != null) {
+		if (!parent) {
+			return cached;
+		}
+
+		// Invalidate if the parent position changed.
+		let top = layoutInfo.rect.y - parent.rect.y;
+		let x = layoutInfo.rect.x - parent.rect.x;
+		if (cached.top === top && cached[xProperty] === x) {
+			return cached;
+		}
+	}
+
+	let rectStyles: Record<string, number | undefined> = {
+		// TODO: For layoutInfos that are sticky that have parents with overflow visible, their "top" will be relative to the to the nearest scrolling container
+		// which WON'T be the parent since the parent has overflow visible. This means we shouldn't offset the height by the parent's position
+		// Not 100% about this change here since it is quite ambigious what the scrolling container maybe and how its top is positioned with respect to the
+		// calculated layoutInfo.y here
+		top:
+			layoutInfo.rect.y -
+			(parent && !(parent.allowOverflow && layoutInfo.isSticky) ? parent.rect.y : 0),
+		[xProperty]:
+			layoutInfo.rect.x -
+			(parent && !(parent.allowOverflow && layoutInfo.isSticky) ? parent.rect.x : 0),
+		width: layoutInfo.rect.width,
+		height: layoutInfo.rect.height,
+	};
+
+	// Get rid of any non finite values since they aren't valid css values
+	Object.entries(rectStyles).forEach(([key, value]) => {
+		if (!Number.isFinite(value)) {
+			rectStyles[key] = undefined;
+		}
+	});
+
+	let style: CSSProperties = {
+		position: layoutInfo.isSticky ? 'sticky' : 'absolute',
+		// Sticky elements are positioned in normal document flow. Display inline-block so that they don't push other sticky columns onto the following rows.
+		display: layoutInfo.isSticky ? 'inline-block' : undefined,
+		overflow: layoutInfo.allowOverflow ? 'visible' : 'hidden',
+		opacity: layoutInfo.opacity,
+		zIndex: layoutInfo.zIndex,
+		transform: layoutInfo.transform ?? undefined,
+		contain: 'size layout style',
+		...rectStyles,
+	};
+
+	cache.set(layoutInfo, style);
+	return style;
+}

package/src/virtualizer/useVirtualizerItem.tsx

@@ -0,0 +1,57 @@
+/** @jsxImportSource octane */
+// Ported from adobe/react-spectrum@1c84a49a1faf50b571c84e00bcf9c60b22ddd03e (packages/react-aria/src/virtualizer/useVirtualizerItem.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.
+ */
+
+import { Key, RefObject } from '@react-types/shared';
+import { LayoutInfo, Size } from '../upstream-exports/react-stately/useVirtualizerState';
+import { useCallback } from '../compat/react';
+import { useLayoutEffect } from '../utils/useLayoutEffect';
+
+interface IVirtualizer {
+	updateItemSize(key: Key, size: Size): void;
+}
+
+export interface VirtualizerItemOptions {
+	layoutInfo: LayoutInfo | null;
+	virtualizer: IVirtualizer;
+	ref: RefObject<HTMLElement | null>;
+}
+
+export function useVirtualizerItem(options: VirtualizerItemOptions): { updateSize: () => void } {
+	let { layoutInfo, virtualizer, ref } = options;
+	let key = layoutInfo?.key;
+
+	let updateSize = useCallback(() => {
+		if (key != null && ref.current) {
+			let size = getSize(ref.current);
+			virtualizer.updateItemSize(key, size);
+		}
+	}, [virtualizer, key, ref]);
+
+	useLayoutEffect(() => {
+		if (layoutInfo?.estimatedSize) {
+			updateSize();
+		}
+	});
+
+	return { updateSize };
+}
+
+function getSize(node: HTMLElement): Size {
+	// Reset height before measuring so we get the intrinsic size
+	let height = node.style.height;
+	node.style.height = '';
+	let size = new Size(node.scrollWidth, node.scrollHeight);
+	node.style.height = height;
+	return size;
+}

package/src/virtualizer/utils.tsx

@@ -0,0 +1,105 @@
+/** @jsxImportSource octane */
+// Ported from adobe/react-spectrum@1c84a49a1faf50b571c84e00bcf9c60b22ddd03e (packages/react-aria/src/virtualizer/utils.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.
+ */
+
+import { Direction } from '@react-types/shared';
+
+export type RTLOffsetType = 'negative' | 'positive-descending' | 'positive-ascending';
+
+let cachedRTLResult: RTLOffsetType | null = null;
+
+// Original licensing for the following methods can be found in the
+// NOTICE file in the root directory of this source tree.
+// See https://github.com/bvaughn/react-window/blob/master/src/createGridComponent.js
+
+// According to the spec, scrollLeft should be negative for RTL aligned elements.
+// Chrome does not seem to adhere; its scrollLeft values are positive (measured relative to the left).
+// Safari's elastic bounce makes detecting this even more complicated wrt potential false positives.
+// The safest way to check this is to intentionally set a negative offset,
+// and then verify that the subsequent "scroll" event matches the negative offset.
+// If it does not match, then we can assume a non-standard RTL scroll implementation.
+export function getRTLOffsetType(recalculate: boolean = false): RTLOffsetType {
+	if (cachedRTLResult === null || recalculate) {
+		const outerDiv = document.createElement('div');
+		const outerStyle = outerDiv.style;
+		outerStyle.width = '50px';
+		outerStyle.height = '50px';
+		outerStyle.overflow = 'scroll';
+		outerStyle.direction = 'rtl';
+
+		const innerDiv = document.createElement('div');
+		const innerStyle = innerDiv.style;
+		innerStyle.width = '100px';
+		innerStyle.height = '100px';
+
+		outerDiv.appendChild(innerDiv);
+
+		document.body.appendChild(outerDiv);
+
+		if (outerDiv.scrollLeft > 0) {
+			cachedRTLResult = 'positive-descending';
+		} else {
+			outerDiv.scrollLeft = 1;
+			if (outerDiv.scrollLeft === 0) {
+				cachedRTLResult = 'negative';
+			} else {
+				cachedRTLResult = 'positive-ascending';
+			}
+		}
+
+		document.body.removeChild(outerDiv);
+
+		return cachedRTLResult;
+	}
+
+	return cachedRTLResult;
+}
+
+export function getScrollLeft(node: Element, direction: Direction): number {
+	let { scrollLeft } = node;
+
+	// scrollLeft in rtl locales differs across browsers, so normalize.
+	// See comment by getRTLOffsetType below for details.
+	if (direction === 'rtl') {
+		let { scrollWidth, clientWidth } = node;
+		switch (getRTLOffsetType()) {
+			case 'negative':
+				scrollLeft = -scrollLeft;
+				break;
+			case 'positive-descending':
+				scrollLeft = scrollWidth - clientWidth - scrollLeft;
+				break;
+		}
+	}
+
+	return scrollLeft;
+}
+
+export function setScrollLeft(node: Element, direction: Direction, scrollLeft: number): void {
+	if (direction === 'rtl') {
+		switch (getRTLOffsetType()) {
+			case 'negative':
+				scrollLeft = -scrollLeft;
+				break;
+			case 'positive-ascending':
+				break;
+			default: {
+				const { clientWidth, scrollWidth } = node;
+				scrollLeft = scrollWidth - clientWidth - scrollLeft;
+				break;
+			}
+		}
+	}
+
+	node.scrollLeft = scrollLeft;
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Dominic Gannaway
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/src/components/useDragAndDrop.ts

@@ -1,164 +0,0 @@
-// Ported from react-aria-components (source: .react-spectrum/packages/react-aria-components/src/useDragAndDrop.tsx).
-// PHASE-7: the react-aria drag-and-drop ENGINE (useDraggableCollection(State),
-// useDroppableCollection(State), useDropIndicator, DragManager, ListDropTargetDelegate)
-// is NOT ported yet. This module ships the `DragAndDropHooks` / `DragAndDropOptions`
-// TYPE surface so collection components can accept a `dragAndDropHooks` prop (their dnd
-// branches stay inert until a consumer can construct hooks), with every engine-referencing
-// member typed via local structural aliases below. The `useDragAndDrop()` function itself
-// is a THROWING STUB (the remix-router framework-stub precedent): importing is safe;
-// CALLING throws with a pointer to the phase plan instead of failing somewhere deep inside.
-// octane adaptations: `.tsx` → `.ts`; `JSX.Element` → a structural `any` alias.
-import type {
-	DragItem,
-	DraggableCollectionProps,
-	DropTarget,
-	DropTargetDelegate,
-	DroppableCollectionProps,
-	Key,
-	RefObject,
-} from '@react-types/shared';
-
-export { DropIndicator, DropIndicatorContext, DragAndDropContext } from './DragAndDrop';
-export type { DropIndicatorProps, DropIndicatorRenderProps } from './DragAndDrop';
-
-// octane adaptation: structural alias for React's JSX.Element.
-type JSXElement = any;
-
-// ── PHASE-7 structural aliases ──────────────────────────────────────────────
-// Stand-ins for the unported react-aria/react-stately dnd engine types. They keep
-// `DragAndDropHooks` importable as a TYPE without pulling any engine code; Phase 7
-// replaces them with the real ported definitions.
-/** PHASE-7: react-stately/useDraggableCollectionState's DraggableCollectionState (engine unported). */
-export type DraggableCollectionState = any;
-/** PHASE-7: react-stately/useDraggableCollectionState's DraggableCollectionStateOptions (engine unported). */
-export type DraggableCollectionStateOptions = any;
-/** PHASE-7: react-aria/useDraggableCollection's DraggableCollectionOptions (engine unported). */
-export type DraggableCollectionOptions = any;
-/** PHASE-7: react-aria/useDraggableCollection's DraggableItemProps (engine unported). */
-export type DraggableItemProps = any;
-/** PHASE-7: react-aria/useDraggableCollection's DraggableItemResult (engine unported). */
-export type DraggableItemResult = any;
-/** PHASE-7: react-aria/useDraggableCollection's DragPreview component type (engine unported). */
-export type DragPreview = any;
-/** PHASE-7: react-stately/useDroppableCollectionState's DroppableCollectionState (engine unported). */
-export type DroppableCollectionState = any;
-/** PHASE-7: react-stately/useDroppableCollectionState's DroppableCollectionStateOptions (engine unported). */
-export type DroppableCollectionStateOptions = any;
-/** PHASE-7: react-aria/useDroppableCollection's DroppableCollectionOptions (engine unported). */
-export type DroppableCollectionOptions = any;
-/** PHASE-7: react-aria/useDroppableCollection's DroppableCollectionResult (engine unported). */
-export type DroppableCollectionResult = any;
-/** PHASE-7: react-aria/useDroppableCollection's DroppableItemOptions (engine unported). */
-export type DroppableItemOptions = any;
-/** PHASE-7: react-aria/useDroppableCollection's DroppableItemResult (engine unported). */
-export type DroppableItemResult = any;
-/** PHASE-7: react-aria/useDropIndicator's DropIndicatorProps (engine unported; `target` is real). */
-export interface AriaDropIndicatorProps {
-	/** The drop target that the drop indicator represents. */
-	target: DropTarget;
-	/** PHASE-7: the activate-button ref (engine unported). */
-	activateButtonRef?: RefObject<any>;
-}
-/** PHASE-7: react-aria/useDropIndicator's DropIndicatorAria (engine unported). */
-export type DropIndicatorAria = any;
-/** PHASE-7: react-aria/ListDropTargetDelegate's class type (engine unported). */
-export type ListDropTargetDelegate = any;
-
-interface DraggableCollectionStateOpts<T = object> extends Omit<
-	DraggableCollectionStateOptions,
-	'getItems'
-> {}
-
-interface DragHooks<T = object> {
-	useDraggableCollectionState?: (
-		props: DraggableCollectionStateOpts<T>,
-	) => DraggableCollectionState;
-	useDraggableCollection?: (
-		props: DraggableCollectionOptions,
-		state: DraggableCollectionState,
-		ref: RefObject<HTMLElement | null>,
-	) => void;
-	useDraggableItem?: (
-		props: DraggableItemProps,
-		state: DraggableCollectionState,
-	) => DraggableItemResult;
-	DragPreview?: DragPreview;
-	renderDragPreview?: (
-		items: DragItem[],
-	) => JSXElement | { element: JSXElement; x: number; y: number };
-	isVirtualDragging?: () => boolean;
-}
-
-interface DropHooks {
-	useDroppableCollectionState?: (
-		props: DroppableCollectionStateOptions,
-	) => DroppableCollectionState;
-	useDroppableCollection?: (
-		props: DroppableCollectionOptions,
-		state: DroppableCollectionState,
-		ref: RefObject<HTMLElement | null>,
-	) => DroppableCollectionResult;
-	useDroppableItem?: (
-		options: DroppableItemOptions,
-		state: DroppableCollectionState,
-		ref: RefObject<HTMLElement | null>,
-	) => DroppableItemResult;
-	useDropIndicator?: (
-		props: AriaDropIndicatorProps,
-		state: DroppableCollectionState,
-		ref: RefObject<HTMLElement | null>,
-	) => DropIndicatorAria;
-	renderDropIndicator?: (target: DropTarget) => JSXElement;
-	dropTargetDelegate?: DropTargetDelegate;
-	ListDropTargetDelegate: ListDropTargetDelegate;
-}
-
-export type DragAndDropHooks<T = object> = DragHooks<T> & DropHooks;
-
-export interface DragAndDrop<T = object> {
-	/** Drag and drop hooks for the collection element. */
-	dragAndDropHooks: DragAndDropHooks<T>;
-}
-
-export interface DragAndDropOptions<T = object>
-	extends Omit<DraggableCollectionProps, 'preview' | 'getItems'>, DroppableCollectionProps {
-	/**
-	 * A function that returns the items being dragged. If not specified, we assume that the
-	 * collection is not draggable.
-	 *
-	 * @default () => []
-	 */
-	getItems?: (keys: Set<Key>, items: T[]) => DragItem[];
-	/**
-	 * A function that renders a drag preview, which is shown under the user's cursor while dragging.
-	 * By default, a copy of the dragged element is rendered.
-	 */
-	renderDragPreview?: (
-		items: DragItem[],
-	) => JSXElement | { element: JSXElement; x: number; y: number };
-	/**
-	 * A function that renders a drop indicator element between two items in a collection.
-	 * This should render a `<DropIndicator>` element. If this function is not provided, a
-	 * default DropIndicator is provided.
-	 */
-	renderDropIndicator?: (target: DropTarget) => JSXElement;
-	/**
-	 * A custom delegate object that provides drop targets for pointer coordinates within the
-	 * collection.
-	 */
-	dropTargetDelegate?: DropTargetDelegate;
-	/** Whether the drag and drop events should be disabled. */
-	isDisabled?: boolean;
-}
-
-/**
- * Provides the hooks required to enable drag and drop behavior for a drag and drop compatible
- * collection component.
- *
- * PHASE-7: throwing stub — the dnd engine is not ported yet.
- */
-export function useDragAndDrop<T = object>(options: DragAndDropOptions<T>): DragAndDrop<T> {
-	throw new Error(
-		'@octanejs/aria: useDragAndDrop is not ported yet (drag and drop arrives in a later phase)',
-	);
-}