@react-stately/list 3.13.4 → 3.14.0

package/src/ListCollection.ts

@@ -1,114 +0,0 @@
-/*
- * 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, Node} from '@react-types/shared';
-
-export class ListCollection<T> implements Collection<Node<T>> {
-  private keyMap: Map<Key, Node<T>> = new Map();
-  private iterable: Iterable<Node<T>>;
-  private firstKey: Key | null = null;
-  private lastKey: Key | null = null;
-  private _size: number;
-
-  constructor(nodes: Iterable<Node<T>>) {
-    this.iterable = nodes;
-
-    let visit = (node: Node<T>) => {
-      this.keyMap.set(node.key, node);
-
-      if (node.childNodes && node.type === 'section') {
-        for (let child of node.childNodes) {
-          visit(child);
-        }
-      }
-    };
-
-    for (let node of nodes) {
-      visit(node);
-    }
-
-    let last: Node<T> | null = null;
-    let index = 0;
-    let size = 0;
-    for (let [key, node] of this.keyMap) {
-      if (last) {
-        last.nextKey = key;
-        node.prevKey = last.key;
-      } else {
-        this.firstKey = key;
-        node.prevKey = undefined;
-      }
-
-      if (node.type === 'item') {
-        node.index = index++;
-      }
-
-      // Only count sections and items when determining size so that
-      // loaders and separators in RAC/S2 don't influence the emptyState determination
-      if (node.type === 'section' || node.type === 'item') {
-        size++;
-      }
-
-      last = node;
-
-      // Set nextKey as undefined since this might be the last node
-      // If it isn't the last node, last.nextKey will properly set at start of new loop
-      last.nextKey = undefined;
-    }
-    this._size = size;
-    this.lastKey = last?.key ?? null;
-  }
-
-  *[Symbol.iterator](): IterableIterator<Node<T>> {
-    yield* this.iterable;
-  }
-
-  get size(): number {
-    return this._size;
-  }
-
-  getKeys(): IterableIterator<Key> {
-    return this.keyMap.keys();
-  }
-
-  getKeyBefore(key: Key): Key | null {
-    let node = this.keyMap.get(key);
-    return node ? node.prevKey ?? null : null;
-  }
-
-  getKeyAfter(key: Key): Key | null {
-    let node = this.keyMap.get(key);
-    return node ? node.nextKey ?? null : null;
-  }
-
-  getFirstKey(): Key | null {
-    return this.firstKey;
-  }
-
-  getLastKey(): Key | null {
-    return this.lastKey;
-  }
-
-  getItem(key: Key): Node<T> | null {
-    return this.keyMap.get(key) ?? null;
-  }
-
-  at(idx: number): Node<T> | null {
-    const keys = [...this.getKeys()];
-    return this.getItem(keys[idx]);
-  }
-
-  getChildren(key: Key): Iterable<Node<T>> {
-    let node = this.keyMap.get(key);
-    return node?.childNodes || [];
-  }
-}

package/src/useListState.ts

@@ -1,136 +0,0 @@
-/*
- * 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, CollectionStateBase, Key, LayoutDelegate, Node} from '@react-types/shared';
-import {ListCollection} from './ListCollection';
-import {MultipleSelectionStateProps, SelectionManager, useMultipleSelectionState} from '@react-stately/selection';
-import {useCallback, useEffect, useMemo, useRef} from 'react';
-import {useCollection} from '@react-stately/collections';
-
-export interface ListProps<T> extends CollectionStateBase<T>, MultipleSelectionStateProps {
-  /** Filter function to generate a filtered list of nodes. */
-  filter?: (nodes: Iterable<Node<T>>) => Iterable<Node<T>>,
-  /** @private */
-  suppressTextValueWarning?: boolean,
-  /**
-   * A delegate object that provides layout information for items in the collection.
-   * This can be used to override the behavior of shift selection.
-   */
-  layoutDelegate?: LayoutDelegate
-}
-
-export interface ListState<T> {
-  /** A collection of items in the list. */
-  collection: Collection<Node<T>>,
-
-  /** A set of items that are disabled. */
-  disabledKeys: Set<Key>,
-
-  /** A selection manager to read and update multiple selection state. */
-  selectionManager: SelectionManager
-}
-
-/**
- * Provides state management for list-like components. Handles building a collection
- * of items from props, and manages multiple selection state.
- */
-export function useListState<T extends object>(props: ListProps<T>): ListState<T>  {
-  let {filter, layoutDelegate} = props;
-
-  let selectionState = useMultipleSelectionState(props);
-  let disabledKeys = useMemo(() =>
-    props.disabledKeys ? new Set(props.disabledKeys) : new Set<Key>()
-  , [props.disabledKeys]);
-
-  let factory = useCallback(nodes => filter ? new ListCollection(filter(nodes)) : new ListCollection(nodes as Iterable<Node<T>>), [filter]);
-  let context = useMemo(() => ({suppressTextValueWarning: props.suppressTextValueWarning}), [props.suppressTextValueWarning]);
-
-  let collection = useCollection(props, factory, context);
-
-  let selectionManager = useMemo(() =>
-    new SelectionManager(collection, selectionState, {layoutDelegate})
-    , [collection, selectionState, layoutDelegate]
-  );
-
-  useFocusedKeyReset(collection, selectionManager);
-
-  return {
-    collection,
-    disabledKeys,
-    selectionManager
-  };
-}
-
-/**
- * Filters a collection using the provided filter function and returns a new ListState.
- */
-export function UNSTABLE_useFilteredListState<T extends object>(state: ListState<T>, filterFn: ((nodeValue: string, node: Node<T>) => boolean) | null | undefined): ListState<T> {
-  let collection = useMemo(() => filterFn ? state.collection.filter!(filterFn) : state.collection, [state.collection, filterFn]);
-  let selectionManager = state.selectionManager.withCollection(collection);
-  useFocusedKeyReset(collection, selectionManager);
-  return {
-    collection,
-    selectionManager,
-    disabledKeys: state.disabledKeys
-  };
-}
-
-function useFocusedKeyReset<T>(collection: Collection<Node<T>>, selectionManager: SelectionManager) {
-  // Reset focused key if that item is deleted from the collection.
-  const cachedCollection = useRef<Collection<Node<T>> | null>(null);
-  useEffect(() => {
-    if (selectionManager.focusedKey != null && !collection.getItem(selectionManager.focusedKey) && cachedCollection.current) {
-      const startItem = cachedCollection.current.getItem(selectionManager.focusedKey);
-      const cachedItemNodes = [...cachedCollection.current.getKeys()].map(
-        key => {
-          const itemNode = cachedCollection.current!.getItem(key);
-          return itemNode?.type === 'item' ? itemNode : null;
-        }
-      ).filter(node => node !== null);
-      const itemNodes = [...collection.getKeys()].map(
-        key => {
-          const itemNode = collection.getItem(key);
-          return itemNode?.type === 'item' ? itemNode : null;
-        }
-      ).filter(node => node !== null);
-      const diff: number = (cachedItemNodes?.length ?? 0) - (itemNodes?.length ?? 0);
-      let index = Math.min(
-        (
-          diff > 1 ?
-          Math.max((startItem?.index ?? 0) - diff + 1, 0) :
-          startItem?.index ?? 0
-        ),
-        (itemNodes?.length ?? 0) - 1);
-      let newNode: Node<T> | null = null;
-      let isReverseSearching = false;
-      while (index >= 0) {
-        if (!selectionManager.isDisabled(itemNodes[index].key)) {
-          newNode = itemNodes[index];
-          break;
-        }
-        // Find next, not disabled item.
-        if (index < itemNodes.length - 1 && !isReverseSearching) {
-          index++;
-        // Otherwise, find previous, not disabled item.
-        } else {
-          isReverseSearching = true;
-          if (index > (startItem?.index ?? 0)) {
-            index = (startItem?.index ?? 0);
-          }
-          index--;
-        }
-      }
-      selectionManager.setFocusedKey(newNode ? newNode.key : null);
-    }
-    cachedCollection.current = collection;
-  }, [collection, selectionManager]);
-}

package/src/useSingleSelectListState.ts

@@ -1,78 +0,0 @@
-/*
- * 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 {CollectionStateBase, Key, Node, Selection, SingleSelection} from '@react-types/shared';
-import {ListState, useListState} from './useListState';
-import {useControlledState} from '@react-stately/utils';
-import {useMemo} from 'react';
-
-export interface SingleSelectListProps<T> extends CollectionStateBase<T>, Omit<SingleSelection, 'disallowEmptySelection'> {
-  /** Filter function to generate a filtered list of nodes. */
-  filter?: (nodes: Iterable<Node<T>>) => Iterable<Node<T>>,
-  /** @private */
-  suppressTextValueWarning?: boolean
-}
-
-export interface SingleSelectListState<T> extends ListState<T> {
-  /** The key for the currently selected item. */
-  readonly selectedKey: Key | null,
-
-  /** Sets the selected key. */
-  setSelectedKey(key: Key | null): void,
-
-  /** The value of the currently selected item. */
-  readonly selectedItem: Node<T> | null
-}
-
-/**
- * Provides state management for list-like components with single selection.
- * Handles building a collection of items from props, and manages selection state.
- */
-export function useSingleSelectListState<T extends object>(props: SingleSelectListProps<T>): SingleSelectListState<T>  {
-  let [selectedKey, setSelectedKey] = useControlledState(props.selectedKey, props.defaultSelectedKey ?? null, props.onSelectionChange);
-  let selectedKeys = useMemo(() => selectedKey != null ? [selectedKey] : [], [selectedKey]);
-  let {collection, disabledKeys, selectionManager} = useListState({
-    ...props,
-    selectionMode: 'single',
-    disallowEmptySelection: true,
-    allowDuplicateSelectionEvents: true,
-    selectedKeys,
-    onSelectionChange: (keys: Selection) => {
-      // impossible, but TS doesn't know that
-      if (keys === 'all') {
-        return;
-      }
-      let key = keys.values().next().value ?? null;
-
-      // Always fire onSelectionChange, even if the key is the same
-      // as the current key (useControlledState does not).
-      if (key === selectedKey && props.onSelectionChange) {
-        props.onSelectionChange(key);
-      }
-
-      setSelectedKey(key);
-    }
-  });
-
-  let selectedItem = selectedKey != null
-    ? collection.getItem(selectedKey)
-    : null;
-
-  return {
-    collection,
-    disabledKeys,
-    selectionManager,
-    selectedKey,
-    setSelectedKey,
-    selectedItem
-  };
-}