@proyecto-viviana/solid-stately 0.3.0 → 0.4.0

package/src/calendar/createRangeCalendarState.ts

@@ -21,6 +21,8 @@ import {
   endOfMonth,
   startOfWeek,
   getWeeksInMonth,
+  maxDate,
+  minDate,
   DateFormatter,
   createCalendar as intlCreateCalendar,
   toCalendar as intlToCalendar,
@@ -68,8 +70,12 @@ export interface RangeCalendarStateProps<T extends DateValue = DateValue> {
   locale?: MaybeAccessor<string | undefined>;
   /** Creates a calendar object for a locale calendar identifier. */
   createCalendar?: (identifier: CalendarIdentifier) => InternationalizedCalendar;
-  /** Callback to determine if a date is unavailable. */
-  isDateUnavailable?: (date: DateValue) => boolean;
+  /**
+   * Callback that determines if a date is unavailable. The second argument is the
+   * current selection anchor (the first selected date), so availability can be
+   * derived from it. Mirrors @react-stately/calendar 1.18.
+   */
+  isDateUnavailable?: (date: DateValue, anchorDate: CalendarDate | null) => boolean;
   /** The number of months to display at once. */
   visibleMonths?: MaybeAccessor<number | undefined>;
   /** Controls how the initial visible months are aligned around the current value. */
@@ -95,6 +101,10 @@ export interface RangeCalendarState<T extends DateValue = DateValue> {
   focusedDate: Accessor<CalendarDate>;
   /** Sets the focused date. */
   setFocusedDate: (date: CalendarDate) => void;
+  /** The minimum allowed date that a user may select. */
+  minValue: Accessor<DateValue | null>;
+  /** The maximum allowed date that a user may select. */
+  maxValue: Accessor<DateValue | null>;
   /** The anchor date when selecting a range (first click). */
   anchorDate: Accessor<CalendarDate | null>;
   /** Sets the anchor date. */
@@ -189,6 +199,8 @@ export function createRangeCalendarState<T extends DateValue = CalendarDate>(
 ): RangeCalendarState<T> {
   const timeZone = getLocalTimeZone();
   const locale = createMemo(() => access(props.locale) ?? "en-US");
+  const minValueState = createMemo(() => access(props.minValue) ?? null);
+  const maxValueState = createMemo(() => access(props.maxValue) ?? null);
   const resolvedOptions = createMemo(() => new DateFormatter(locale()).resolvedOptions());
   const calendar = createMemo(() =>
     (props.createCalendar ?? intlCreateCalendar)(resolvedOptions().calendar as CalendarIdentifier),
@@ -200,17 +212,56 @@ export function createRangeCalendarState<T extends DateValue = CalendarDate>(
   const toDisplayCalendarDate = (date: DateValue): CalendarDate =>
     intlToCalendar(toCalendarDate(date), calendar());
 
+  // The anchor date is the first selected date during a range drag. Declared up
+  // here (ahead of constrainDate) because the available-range derivation below
+  // depends on it, and constrainDate consults that range.
+  const [anchorDate, setAnchorDate] = createSignal<CalendarDate | null>(null);
+
+  // Mirrors @react-stately/calendar useRangeCalendarState getAvailableRange: once
+  // a range selection is anchored and unavailable dates exist, contiguous ranges
+  // are required (unless allowsNonContiguousRanges), so the selectable span is
+  // bounded by the nearest unavailable date on each side of the anchor.
+  const getAvailableRange = (
+    anchor: CalendarDate | null,
+  ): { start?: CalendarDate; end?: CalendarDate } | null => {
+    if (anchor && props.isDateUnavailable && !props.allowsNonContiguousRanges) {
+      const predicate = (date: CalendarDate): boolean => props.isDateUnavailable!(date, anchor);
+      return {
+        start: nextUnavailableDate(anchor, predicate, visibleMonths, -1),
+        end: nextUnavailableDate(anchor, predicate, visibleMonths, 1),
+      };
+    }
+    return null;
+  };
+
+  const availableRange = createMemo(() => getAvailableRange(anchorDate()));
+
+  // minValue/maxValue narrowed by the available range, in display-calendar space
+  // (what every cell/navigation bound below compares against). Mirrors upstream's
+  // maxDate(minValue, availableRange?.start) / minDate(maxValue, availableRange?.end);
+  // maxDate/minDate ignore undefined operands, so an absent bound passes through.
+  const effectiveMinValue = createMemo<CalendarDate | null>(() => {
+    const min = access(props.minValue);
+    const minCal = min != null ? toDisplayCalendarDate(min) : undefined;
+    return maxDate(minCal, availableRange()?.start) ?? null;
+  });
+  const effectiveMaxValue = createMemo<CalendarDate | null>(() => {
+    const max = access(props.maxValue);
+    const maxCal = max != null ? toDisplayCalendarDate(max) : undefined;
+    return minDate(maxCal, availableRange()?.end) ?? null;
+  });
+
   const constrainDate = (date: CalendarDate): CalendarDate => {
-    const minValue = access(props.minValue);
-    const maxValue = access(props.maxValue);
+    const min = effectiveMinValue();
+    const max = effectiveMaxValue();
 
     let constrained = date;
 
-    if (minValue && constrained.compare(toDisplayCalendarDate(minValue)) < 0) {
-      constrained = toDisplayCalendarDate(minValue);
+    if (min && constrained.compare(min) < 0) {
+      constrained = min;
     }
-    if (maxValue && constrained.compare(toDisplayCalendarDate(maxValue)) > 0) {
-      constrained = toDisplayCalendarDate(maxValue);
+    if (max && constrained.compare(max) > 0) {
+      constrained = max;
     }
 
     return constrained;
@@ -319,7 +370,6 @@ export function createRangeCalendarState<T extends DateValue = CalendarDate>(
   const [visibleRangeStart, setVisibleRangeStart] = createSignal<CalendarDate>(
     alignVisibleRangeStart(initialFocusedDate),
   );
-  const [anchorDate, setAnchorDate] = createSignal<CalendarDate | null>(null);
   const [isFocused, setFocused] = createSignal(false);
   const [isDragging, setDragging] = createSignal(false);
 
@@ -344,7 +394,27 @@ export function createRangeCalendarState<T extends DateValue = CalendarDate>(
   const isDisabled = createMemo(() => access(props.isDisabled) ?? false);
   const isReadOnly = createMemo(() => access(props.isReadOnly) ?? false);
   const validationState = createMemo(() => access(props.validationState));
-  const isValueInvalid = createMemo(() => validationState() === "invalid");
+  // A committed range is invalid when (not mid-drag) either endpoint is
+  // unavailable or falls outside [minValue, maxValue]. Mirrors upstream
+  // useRangeCalendarState's isInvalid derivation. Calls props.isDateUnavailable
+  // directly (with a null anchor) rather than the closures defined further down,
+  // since this memo runs eagerly during init.
+  const isInvalidSelection = createMemo(() => {
+    const v = sourceValue();
+    if (!v || anchorDate()) return false;
+    if (props.isDateUnavailable?.(v.start, null) || props.isDateUnavailable?.(v.end, null)) {
+      return true;
+    }
+    const min = access(props.minValue);
+    const max = access(props.maxValue);
+    const minCal = min != null ? toDisplayCalendarDate(min) : null;
+    const maxCal = max != null ? toDisplayCalendarDate(max) : null;
+    return (
+      isDateOutsideRange(toDisplayCalendarDate(v.start), minCal, maxCal) ||
+      isDateOutsideRange(toDisplayCalendarDate(v.end), minCal, maxCal)
+    );
+  });
+  const isValueInvalid = createMemo(() => validationState() === "invalid" || isInvalidSelection());
 
   // Highlighted range during selection
   const highlightedRange = createMemo<RangeValue<CalendarDate> | null>(() => {
@@ -518,7 +588,7 @@ export function createRangeCalendarState<T extends DateValue = CalendarDate>(
 
   // Check if a date is unavailable
   const isCellUnavailable = (date: DateValue): boolean => {
-    return props.isDateUnavailable?.(date) ?? false;
+    return props.isDateUnavailable?.(date, anchorDate()) ?? false;
   };
 
   // Check if a date is disabled
@@ -526,23 +596,23 @@ export function createRangeCalendarState<T extends DateValue = CalendarDate>(
     if (isDisabled()) return true;
     if (props.isDateDisabled?.(date)) return true;
 
-    const minValue = access(props.minValue);
-    const maxValue = access(props.maxValue);
+    const min = effectiveMinValue();
+    const max = effectiveMaxValue();
     const calDate = toDisplayCalendarDate(date);
 
-    if (minValue && calDate.compare(toDisplayCalendarDate(minValue)) < 0) return true;
-    if (maxValue && calDate.compare(toDisplayCalendarDate(maxValue)) > 0) return true;
+    if (min && calDate.compare(min) < 0) return true;
+    if (max && calDate.compare(max) > 0) return true;
 
     return false;
   };
 
   const isDateOutsideAllowedRange = (date: DateValue): boolean => {
-    const minValue = access(props.minValue);
-    const maxValue = access(props.maxValue);
+    const min = effectiveMinValue();
+    const max = effectiveMaxValue();
     const calDate = toDisplayCalendarDate(date);
 
-    if (minValue && calDate.compare(toDisplayCalendarDate(minValue)) < 0) return true;
-    if (maxValue && calDate.compare(toDisplayCalendarDate(maxValue)) > 0) return true;
+    if (min && calDate.compare(min) < 0) return true;
+    if (max && calDate.compare(max) > 0) return true;
 
     return false;
   };
@@ -694,6 +764,8 @@ export function createRangeCalendarState<T extends DateValue = CalendarDate>(
     visibleRange,
     timeZone,
     locale,
+    minValue: minValueState,
+    maxValue: maxValueState,
     firstDayOfWeek: firstDayOfWeekName,
     validationState,
     isValueInvalid,
@@ -747,3 +819,43 @@ function convertValue(newValue: CalendarDate, oldValue?: DateValue | null): Date
 
   return localValue;
 }
+
+/** Whether a date falls outside the closed [minValue, maxValue] interval. */
+function isDateOutsideRange(
+  date: CalendarDate,
+  minValue?: CalendarDate | null,
+  maxValue?: CalendarDate | null,
+): boolean {
+  return (
+    (minValue != null && date.compare(minValue) < 0) ||
+    (maxValue != null && date.compare(maxValue) > 0)
+  );
+}
+
+/**
+ * Walks outward from the anchor one day at a time in `dir` until it reaches an
+ * unavailable date, then returns the last available date before it — or
+ * undefined when no unavailable date is found within `visibleMonths` of the
+ * anchor (no narrowing needed on that side). Mirrors @react-stately/calendar
+ * nextUnavailableDate.
+ */
+function nextUnavailableDate(
+  anchorDate: CalendarDate,
+  isDateUnavailable: (date: CalendarDate) => boolean,
+  visibleMonths: number,
+  dir: number,
+): CalendarDate | undefined {
+  let nextDate = anchorDate.add({ days: dir });
+  const minBound = anchorDate.subtract({ months: visibleMonths });
+  const maxBound = anchorDate.add({ months: visibleMonths });
+  while (
+    (dir < 0 ? nextDate.compare(minBound) >= 0 : nextDate.compare(maxBound) <= 0) &&
+    !isDateUnavailable(nextDate)
+  ) {
+    nextDate = nextDate.add({ days: dir });
+  }
+  if (isDateUnavailable(nextDate)) {
+    return nextDate.add({ days: -dir });
+  }
+  return undefined;
+}

package/src/calendar/index.ts

@@ -2,6 +2,8 @@ export {
   createCalendarState,
   type CalendarStateProps,
   type CalendarState,
+  type CalendarSelectionMode,
+  type CalendarValueType,
   type ValidationState,
   type CalendarPageBehavior,
   type CalendarSelectionAlignment,

package/src/collections/createListState.ts

@@ -4,10 +4,12 @@
  * Based on @react-stately/list.
  */
 
-import { createSignal, createMemo, type Accessor } from "solid-js";
+import { createMemo, type Accessor } from "solid-js";
 import { access, type MaybeAccessor } from "../utils";
 import { ListCollection } from "./ListCollection";
-import { createSelectionState, type SelectionState } from "./createSelectionState";
+import type { SelectionState, SelectionPressEvent } from "./createSelectionState";
+import { createMultipleSelectionState } from "../selection/createMultipleSelectionState";
+import { SelectionManager } from "../selection/SelectionManager";
 import type {
   Collection,
   CollectionItemLike,
@@ -51,6 +53,8 @@ export interface ListStateProps<T = unknown> {
 export interface ListState<T = unknown> extends SelectionState {
   /** The collection of items. */
   readonly collection: Accessor<Collection<T>>;
+  /** The collection-aware selection manager (single source of truth for selection). */
+  readonly selectionManager: SelectionManager<T>;
   /** Whether the collection is focused. */
   readonly isFocused: Accessor<boolean>;
   /** Set the focused state. */
@@ -116,8 +120,9 @@ export function createListState<T = unknown>(
     return [...new Set([...propsDisabled, ...itemDisabled])];
   });
 
-  // Create selection state
-  const selectionState = createSelectionState({
+  // Raw selection + focus state (the lower layer). This owns the selected keys,
+  // focus, selection behavior, and disabled keys, but is not collection-aware.
+  const state = createMultipleSelectionState({
     get selectionMode() {
       return getProps().selectionMode;
     },
@@ -147,24 +152,50 @@ export function createListState<T = unknown>(
     },
   });
 
-  // Focus state
-  const [isFocused, setIsFocused] = createSignal(false);
-  const [focusedKey, setFocusedKeyInternal] = createSignal<Key | null>(null);
-  const [childFocusStrategy, setChildFocusStrategy] = createSignal<FocusStrategy | null>(null);
-
-  const setFocusedKey = (key: Key | null, childStrategy?: FocusStrategy) => {
-    setFocusedKeyInternal(key);
-    setChildFocusStrategy(childStrategy ?? null);
-  };
+  // The collection-aware selection manager (the upper layer): the single source
+  // of truth for every selection operation. It reads the collection live so it
+  // stays reactive as the collection memo recomputes.
+  const selectionManager = new SelectionManager<T>(() => collection(), state);
 
   return {
     collection,
-    isFocused,
-    setFocused: setIsFocused,
-    focusedKey,
-    setFocusedKey,
-    childFocusStrategy,
-    ...selectionState,
+    selectionManager,
+
+    // Focus — delegate to the raw state (the single source of truth). The
+    // setter routes through the manager so it inherits the existence guard and
+    // the upstream 'first' child-focus default.
+    isFocused: () => state.isFocused,
+    setFocused: (isFocused: boolean) => state.setFocused(isFocused),
+    focusedKey: () => state.focusedKey,
+    setFocusedKey: (key: Key | null, childStrategy?: FocusStrategy) =>
+      selectionManager.setFocusedKey(key, childStrategy),
+    childFocusStrategy: () => state.childFocusStrategy,
+
+    // Flattened selection surface — delegates to the manager so the list path
+    // shares one faithful engine. extendSelection keeps its legacy second
+    // argument for back-compat, but ignores it (the manager reads the
+    // collection itself).
+    selectionMode: () => selectionManager.selectionMode,
+    selectionBehavior: () => selectionManager.selectionBehavior,
+    disallowEmptySelection: () => selectionManager.disallowEmptySelection,
+    selectedKeys: () => state.selectedKeys,
+    disabledKeys: () => selectionManager.disabledKeys,
+    disabledBehavior: () => selectionManager.disabledBehavior,
+    isEmpty: () => selectionManager.isEmpty,
+    isSelectAll: () => selectionManager.isSelectAll,
+    isSelected: (key: Key) => selectionManager.isSelected(key),
+    isDisabled: (key: Key) => selectionManager.isDisabled(key),
+    setSelectionBehavior: (behavior: SelectionBehavior) =>
+      selectionManager.setSelectionBehavior(behavior),
+    toggleSelection: (key: Key) => selectionManager.toggleSelection(key),
+    replaceSelection: (key: Key) => selectionManager.replaceSelection(key),
+    setSelectedKeys: (keys: Iterable<Key>) => selectionManager.setSelectedKeys(keys),
+    selectAll: () => selectionManager.selectAll(),
+    clearSelection: () => selectionManager.clearSelection(),
+    toggleSelectAll: () => selectionManager.toggleSelectAll(),
+    extendSelection: (toKey: Key, _collection?: Collection) =>
+      selectionManager.extendSelection(toKey),
+    select: (key: Key, e?: SelectionPressEvent) => selectionManager.select(key, e),
   };
 }
 

package/src/collections/createMenuState.ts

@@ -69,6 +69,9 @@ export function createMenuState<T = unknown>(
     get selectionBehavior() {
       return getProps().selectionBehavior;
     },
+    get allowDuplicateSelectionEvents() {
+      return getProps().allowDuplicateSelectionEvents;
+    },
   });
 
   const close = () => {

package/src/collections/createSelectionState.ts

@@ -74,11 +74,24 @@ export interface SelectionState {
   /** Extend selection to a key (for shift-click). */
   extendSelection(toKey: Key, collection: Collection): void;
   /** Select a key based on interaction. */
-  select(
-    key: Key,
-    e?: { shiftKey?: boolean; ctrlKey?: boolean; metaKey?: boolean },
-    collection?: Collection,
-  ): void;
+  select(key: Key, e?: SelectionPressEvent): void;
+}
+
+/**
+ * The press/pointer interaction consulted by {@link SelectionState.select}.
+ * Mirrors react-stately's `SelectionManager.select(e)`: only `pointerType` is
+ * read here (touch / virtual force toggle, since those devices have no modifier
+ * keys). Modifier keys (ctrl / meta / shift) are resolved one layer up in the
+ * aria-layer `onSelect` (solidaria `selectItem`), matching upstream's split
+ * between react-stately and react-aria. The modifier fields are accepted so a
+ * full press/pointer event is assignable, but they are not read here.
+ */
+export interface SelectionPressEvent {
+  pointerType?: "mouse" | "pen" | "touch" | "keyboard" | "virtual";
+  shiftKey?: boolean;
+  ctrlKey?: boolean;
+  metaKey?: boolean;
+  altKey?: boolean;
 }
 
 /**
@@ -268,33 +281,30 @@ export function createSelectionState(
     updateSelection(new Set(rangeKeys));
   };
 
-  const select = (
-    key: Key,
-    e?: { shiftKey?: boolean; ctrlKey?: boolean; metaKey?: boolean },
-    collection?: Collection,
-  ) => {
-    if (isDisabled(key)) return;
+  const select = (key: Key, e?: SelectionPressEvent) => {
+    // Mirrors react-stately's SelectionManager.select: only pointerType +
+    // selectionBehavior are consulted here. Modifier-key handling (ctrl / meta
+    // ⇒ toggle, shift ⇒ extend) lives one layer up in solidaria's aria-layer
+    // `selectItem`, which is where the platform-aware isCtrlKeyPressed is
+    // available. The primitives self-guard disabled keys, so no guard is
+    // needed here (matching upstream).
     if (selectionMode() === "none") return;
 
-    const mode = selectionMode();
-    const behavior = selectionBehavior();
-
-    if (mode === "single") {
-      if (behavior === "replace" || !isSelected(key)) {
+    if (selectionMode() === "single") {
+      // Single mode ignores selectionBehavior. Re-selecting the current item
+      // deselects it when empty selection is allowed; otherwise it stays
+      // selected (replace).
+      if (isSelected(key) && !disallowEmptySelection()) {
+        toggleSelection(key);
+      } else {
         replaceSelection(key);
-      } else if (!disallowEmptySelection()) {
-        clearSelection();
       }
-      return;
-    }
-
-    // Multiple selection
-    if (e?.shiftKey && collection) {
-      extendSelection(key, collection);
-      return;
-    }
-
-    if (e?.ctrlKey || e?.metaKey || behavior === "toggle") {
+    } else if (
+      selectionBehavior() === "toggle" ||
+      (e != null && (e.pointerType === "touch" || e.pointerType === "virtual"))
+    ) {
+      // touch / virtual (VoiceOver) have no modifier keys, so multi-select is
+      // only reachable by toggling.
       toggleSelection(key);
     } else {
       replaceSelection(key);

package/src/collections/getChildNodes.ts

@@ -0,0 +1,98 @@
+/**
+ * Helpers for traversing collection nodes and comparing their document order.
+ *
+ * Based on @react-stately/collections.
+ */
+
+import type { Collection, CollectionNode } from "./types";
+
+export function getChildNodes<T>(
+  node: CollectionNode<T>,
+  collection: Collection<T>,
+): Iterable<CollectionNode<T>> {
+  // New API: call collection.getChildren with the node key.
+  if (typeof collection.getChildren === "function") {
+    return collection.getChildren(node.key);
+  }
+
+  // Old API: access childNodes directly.
+  return node.childNodes;
+}
+
+export function getFirstItem<T>(iterable: Iterable<T>): T | undefined {
+  return getNthItem(iterable, 0);
+}
+
+export function getNthItem<T>(iterable: Iterable<T>, index: number): T | undefined {
+  if (index < 0) {
+    return undefined;
+  }
+
+  let i = 0;
+  for (const item of iterable) {
+    if (i === index) {
+      return item;
+    }
+
+    i++;
+  }
+}
+
+export function getLastItem<T>(iterable: Iterable<T>): T | undefined {
+  let lastItem: T | undefined = undefined;
+  for (const value of iterable) {
+    lastItem = value;
+  }
+
+  return lastItem;
+}
+
+export function compareNodeOrder<T>(
+  collection: Collection<T>,
+  a: CollectionNode<T>,
+  b: CollectionNode<T>,
+): number {
+  // If the two nodes have the same parent, compare their indices.
+  if (a.parentKey === b.parentKey) {
+    return a.index - b.index;
+  }
+
+  // Otherwise, collect all of the ancestors from each node, and find the first one that doesn't match starting from the root.
+  // Include the base nodes in case we are comparing nodes of different levels so that we can compare the higher node to the lower level node's
+  // ancestor of the same level
+  const aAncestors = [...getAncestors(collection, a), a];
+  const bAncestors = [...getAncestors(collection, b), b];
+  const firstNonMatchingAncestor = aAncestors
+    .slice(0, bAncestors.length)
+    .findIndex((a, i) => a !== bAncestors[i]);
+  if (firstNonMatchingAncestor !== -1) {
+    // Compare the indices of two children within the common ancestor.
+    a = aAncestors[firstNonMatchingAncestor];
+    b = bAncestors[firstNonMatchingAncestor];
+    return a.index - b.index;
+  }
+
+  // If there isn't a non matching ancestor, we might be in a case where one of the nodes is the ancestor of the other.
+  if (aAncestors.findIndex((node) => node === b) >= 0) {
+    return 1;
+  } else if (bAncestors.findIndex((node) => node === a) >= 0) {
+    return -1;
+  }
+
+  // 🤷
+  return -1;
+}
+
+function getAncestors<T>(collection: Collection<T>, node: CollectionNode<T>): CollectionNode<T>[] {
+  const parents: CollectionNode<T>[] = [];
+
+  let currNode: CollectionNode<T> | null = node;
+  while (currNode?.parentKey != null) {
+    currNode = collection.getItem(currNode.parentKey);
+    if (currNode) {
+      parents.unshift(currNode);
+    }
+  }
+
+  return parents;
+}

package/src/collections/index.ts

@@ -16,10 +16,19 @@ export type {
 
 export { ListCollection, createListCollection } from "./ListCollection";
 
+export {
+  getChildNodes,
+  getFirstItem,
+  getNthItem,
+  getLastItem,
+  compareNodeOrder,
+} from "./getChildNodes";
+
 export {
   createSelectionState,
   type SelectionStateProps,
   type SelectionState,
+  type SelectionPressEvent,
 } from "./createSelectionState";
 
 export {

package/src/combobox/createComboBoxState.ts

@@ -11,6 +11,7 @@ import { access, type MaybeAccessor } from "../utils";
 import { createListState } from "../collections/createListState";
 import { createOverlayTriggerState } from "../overlays";
 import type { Key, CollectionNode, Collection, FocusStrategy } from "../collections/types";
+import type { SelectionManager } from "../selection/SelectionManager";
 
 export type MenuTriggerAction = "focus" | "input" | "manual";
 
@@ -78,6 +79,12 @@ export interface ComboBoxStateProps<T = unknown> {
 export interface ComboBoxState<T = unknown> {
   /** The collection of items (may be filtered). */
   readonly collection: Accessor<Collection<T>>;
+  /**
+   * The collection-aware selection manager. Mirrors upstream `useComboBoxState`,
+   * which returns the `useListState` selection manager bound to the unfiltered
+   * collection (selection spans all items; filtering is display-only).
+   */
+  readonly selectionManager: SelectionManager<T>;
   /** Whether the combobox dropdown is open. */
   readonly isOpen: Accessor<boolean>;
   /** Open the combobox dropdown. */
@@ -624,6 +631,7 @@ export function createComboBoxState<T = unknown>(
     inputValue,
     defaultInputValue: getProps().defaultInputValue ?? "",
     setInputValue,
+    selectionManager: listState.selectionManager,
     focusedKey: listState.focusedKey,
     setFocusedKey: listState.setFocusedKey,
     isFocused,

package/src/dnd/index.d.ts

@@ -32,6 +32,7 @@ export type {
   DroppableCollectionRootDropEvent,
   DroppableCollectionOnItemDropEvent,
   DroppableCollectionReorderEvent,
+  DragType,
   DragTypes,
   DropTargetDelegate,
   DraggableCollectionStartEvent,

package/src/dnd/index.ts

@@ -33,6 +33,7 @@ export type {
   DroppableCollectionRootDropEvent,
   DroppableCollectionOnItemDropEvent,
   DroppableCollectionReorderEvent,
+  DragType,
   DragTypes,
   DropTargetDelegate,
   DraggableCollectionStartEvent,

package/src/dnd/types.d.ts

@@ -174,10 +174,12 @@ export interface DroppableCollectionReorderEvent {
   /** The drop target. */
   target: ItemDropTarget;
 }
+/** A drag type: either a MIME type string or a symbol such as the directory drag type. */
+export type DragType = string | symbol;
 /** Interface for checking drag types. */
 export interface DragTypes {
   /** Returns whether the drag contains data of the given type. */
-  has(type: string | symbol): boolean;
+  has(type: DragType | DragType[]): boolean;
 }
 /** Delegate for determining drop targets within a collection. */
 export interface DropTargetDelegate {

package/src/dnd/types.ts

@@ -205,10 +205,13 @@ export interface DroppableCollectionReorderEvent {
   target: ItemDropTarget;
 }
 
+/** A drag type: either a MIME type string or a symbol such as the directory drag type. */
+export type DragType = string | symbol;
+
 /** Interface for checking drag types. */
 export interface DragTypes {
   /** Returns whether the drag contains data of the given type. */
-  has(type: string | symbol): boolean;
+  has(type: DragType | DragType[]): boolean;
 }
 
 /** Delegate for determining drop targets within a collection. */