@react-stately/data 3.15.1 → 3.16.0

package/src/useListData.ts

@@ -1,430 +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 {Key, Selection} from '@react-types/shared';
-import {useMemo, useState} from 'react';
-
-export interface ListOptions<T> {
-  /** Initial items in the list. */
-  initialItems?: T[],
-  /** The keys for the initially selected items. */
-  initialSelectedKeys?: 'all' | Iterable<Key>,
-  /** The initial text to filter the list by. */
-  initialFilterText?: string,
-  /** A function that returns a unique key for an item object. */
-  getKey?: (item: T) => Key,
-  /** A function that returns whether a item matches the current filter text. */
-  filter?: (item: T, filterText: string) => boolean
-}
-
-export interface ListData<T> {
-  /** The items in the list. */
-  items: T[],
-
-  /** The keys of the currently selected items in the list. */
-  selectedKeys: Selection,
-
-  /** Sets the selected keys. */
-  setSelectedKeys(keys: Selection): void,
-
-  /** Adds the given keys to the current selected keys. */
-  addKeysToSelection(keys: Selection): void,
-
-  /** Removes the given keys from the current selected keys. */
-  removeKeysFromSelection(keys: Selection): void,
-
-  /** The current filter text. */
-  filterText: string,
-
-  /** Sets the filter text. */
-  setFilterText(filterText: string): void,
-
-  /**
-   * Gets an item from the list by key.
-   * @param key - The key of the item to retrieve.
-   */
-  getItem(key: Key): T | undefined,
-
-  /**
-   * Inserts items into the list at the given index.
-   * @param index - The index to insert into.
-   * @param values - The values to insert.
-   */
-  insert(index: number, ...values: T[]): void,
-
-  /**
-   * Inserts items into the list before the item at the given key.
-   * @param key - The key of the item to insert before.
-   * @param values - The values to insert.
-   */
-  insertBefore(key: Key, ...values: T[]): void,
-
-  /**
-   * Inserts items into the list after the item at the given key.
-   * @param key - The key of the item to insert after.
-   * @param values - The values to insert.
-   */
-  insertAfter(key: Key, ...values: T[]): void,
-
-  /**
-   * Appends items to the list.
-   * @param values - The values to insert.
-   */
-  append(...values: T[]): void,
-
-  /**
-   * Prepends items to the list.
-   * @param value - The value to insert.
-   */
-  prepend(...values: T[]): void,
-
-  /**
-   * Removes items from the list by their keys.
-   * @param keys - The keys of the item to remove.
-   */
-  remove(...keys: Key[]): void,
-
-  /**
-   * Removes all items from the list that are currently
-   * in the set of selected items.
-   */
-  removeSelectedItems(): void,
-
-  /**
-   * Moves an item within the list.
-   * @param key - The key of the item to move.
-   * @param toIndex - The index to move the item to.
-   */
-  move(key: Key, toIndex: number): void,
-
-  /**
-   * Moves one or more items before a given key.
-   * @param key - The key of the item to move the items before.
-   * @param keys - The keys of the items to move.
-   */
-  moveBefore(key: Key, keys: Iterable<Key>): void,
-
-  /**
-   * Moves one or more items after a given key.
-   * @param key - The key of the item to move the items after.
-   * @param keys - The keys of the items to move.
-   */
-  moveAfter(key: Key, keys: Iterable<Key>): void,
-
-  /**
-   * Updates an item in the list.
-   * @param key - The key of the item to update.
-   * @param newValue - The new value for the item, or a function that returns the new value based on the previous value.
-   */
-  update(key: Key, newValue: T | ((prev: T) => T)): void
-}
-
-export interface ListState<T> {
-  items: T[],
-  selectedKeys: Selection,
-  filterText: string
-}
-
-interface CreateListOptions<T, C> extends ListOptions<T> {
-  cursor?: C
-}
-
-/**
- * Manages state for an immutable list data structure, and provides convenience methods to
- * update the data over time.
- */
-export function useListData<T>(options: ListOptions<T>): ListData<T> {
-  let {
-    initialItems = [],
-    initialSelectedKeys,
-    getKey = (item: any) => item.id ?? item.key,
-    filter,
-    initialFilterText = ''
-  } = options;
-
-  // Store both items and filteredItems in state so we can go back to the unfiltered list
-  let [state, setState] = useState<ListState<T>>({
-    items: initialItems,
-    selectedKeys: initialSelectedKeys === 'all' ? 'all' : new Set(initialSelectedKeys || []),
-    filterText: initialFilterText
-  });
-
-  let filteredItems = useMemo(
-    () => filter ? state.items.filter(item => filter(item, state.filterText)) : state.items,
-    [state.items, state.filterText, filter]);
-
-  return {
-    ...state,
-    items: filteredItems,
-    ...createListActions({getKey}, setState),
-    getItem(key: Key) {
-      return state.items.find(item => getKey(item) === key);
-    }
-  };
-}
-
-export function createListActions<T, C>(opts: CreateListOptions<T, C>, dispatch: (updater: (state: ListState<T>) => ListState<T>) => void): Omit<ListData<T>, 'items' | 'selectedKeys' | 'getItem' | 'filterText'> {
-  let {cursor, getKey} = opts;
-  return {
-    setSelectedKeys(selectedKeys: Selection) {
-      dispatch(state => ({
-        ...state,
-        selectedKeys
-      }));
-    },
-    addKeysToSelection(selectedKeys: Selection) {
-      dispatch(state => {
-        if (state.selectedKeys === 'all') {
-          return state;
-        }
-        if (selectedKeys === 'all') {
-          return {
-            ...state,
-            selectedKeys: 'all'
-          };
-        }
-
-        return {
-          ...state,
-          selectedKeys: new Set([...state.selectedKeys, ...selectedKeys])
-        };
-      });
-    },
-    removeKeysFromSelection(selectedKeys: Selection) {
-      dispatch(state => {
-        if (selectedKeys === 'all') {
-          return {
-            ...state,
-            selectedKeys: new Set()
-          };
-        }
-
-        let selection: Selection = state.selectedKeys  === 'all' ? new Set(state.items.map(getKey!)) : new Set(state.selectedKeys);
-        for (let key of selectedKeys) {
-          selection.delete(key);
-        }
-        return {
-          ...state,
-          selectedKeys: selection
-        };
-      });
-    },
-    setFilterText(filterText: string) {
-      dispatch(state => ({
-        ...state,
-        filterText
-      }));
-    },
-    insert(index: number, ...values: T[]) {
-      dispatch(state => insert(state, index, ...values));
-    },
-    insertBefore(key: Key, ...values: T[]) {
-      dispatch(state => {
-        let index = state.items.findIndex(item => getKey?.(item) === key);
-        if (index === -1) {
-          if (state.items.length === 0) {
-            index = 0;
-          } else {
-            return state;
-          }
-        }
-
-        return insert(state, index, ...values);
-      });
-    },
-    insertAfter(key: Key, ...values: T[]) {
-      dispatch(state => {
-        let index = state.items.findIndex(item => getKey?.(item) === key);
-        if (index === -1) {
-          if (state.items.length === 0) {
-            index = 0;
-          } else {
-            return state;
-          }
-        }
-
-        return insert(state, index + 1, ...values);
-      });
-    },
-    prepend(...values: T[]) {
-      dispatch(state => insert(state, 0, ...values));
-    },
-    append(...values: T[]) {
-      dispatch(state => insert(state, state.items.length, ...values));
-    },
-    remove(...keys: Key[]) {
-      dispatch(state => {
-        let keySet = new Set(keys);
-        let items = state.items.filter(item => !keySet.has(getKey!(item)));
-
-        let selection: Selection = 'all';
-        if (state.selectedKeys !== 'all') {
-          selection = new Set(state.selectedKeys);
-          for (let key of keys) {
-            selection.delete(key);
-          }
-        }
-        if (cursor == null && items.length === 0) {
-          selection = new Set();
-        }
-
-        return {
-          ...state,
-          items,
-          selectedKeys: selection
-        };
-      });
-    },
-    removeSelectedItems() {
-      dispatch(state => {
-        if (state.selectedKeys === 'all') {
-          return {
-            ...state,
-            items: [],
-            selectedKeys: new Set()
-          };
-        }
-
-        let selectedKeys = state.selectedKeys;
-        let items = state.items.filter(item => !selectedKeys.has(getKey!(item)));
-        return {
-          ...state,
-          items,
-          selectedKeys: new Set()
-        };
-      });
-    },
-    move(key: Key, toIndex: number) {
-      dispatch(state => {
-        let index = state.items.findIndex(item => getKey!(item) === key);
-        if (index === -1) {
-          return state;
-        }
-
-        let copy = state.items.slice();
-        let [item] = copy.splice(index, 1);
-        copy.splice(toIndex, 0, item);
-        return {
-          ...state,
-          items: copy
-        };
-      });
-    },
-    moveBefore(key: Key, keys: Iterable<Key>) {
-      dispatch(state => {
-        let toIndex = state.items.findIndex(item => getKey!(item) === key);
-        if (toIndex === -1) {
-          return state;
-        }
-
-        // Find indices of keys to move. Sort them so that the order in the list is retained.
-        let keyArray = Array.isArray(keys) ? keys : [...keys];
-        let indices = keyArray.map(key => state.items.findIndex(item => getKey!(item) === key)).sort((a, b) => a - b);
-        return move(state, indices, toIndex);
-      });
-    },
-    moveAfter(key: Key, keys: Iterable<Key>) {
-      dispatch(state => {
-        let toIndex = state.items.findIndex(item => getKey!(item) === key);
-        if (toIndex === -1) {
-          return state;
-        }
-
-        let keyArray = Array.isArray(keys) ? keys : [...keys];
-        let indices = keyArray.map(key => state.items.findIndex(item => getKey!(item) === key)).sort((a, b) => a - b);
-        return move(state, indices, toIndex + 1);
-      });
-    },
-    update(key: Key, newValue: T | ((prev: T) => T)) {
-      dispatch(state => {
-        let index = state.items.findIndex(item => getKey!(item) === key);
-        if (index === -1) {
-          return state;
-        }
-
-        let updatedValue: T;
-        if (typeof newValue === 'function') {
-          updatedValue = (newValue as (prev: T) => T)(state.items[index]);
-        } else {
-          updatedValue = newValue;
-        }
-
-        return {
-          ...state,
-          items: [
-            ...state.items.slice(0, index),
-            updatedValue,
-            ...state.items.slice(index + 1)
-          ]
-        };
-      });
-    }
-  };
-}
-
-function insert<T>(state: ListState<T>, index: number, ...values: T[]): ListState<T> {
-  return {
-    ...state,
-    items: [
-      ...state.items.slice(0, index),
-      ...values,
-      ...state.items.slice(index)
-    ]
-  };
-}
-
-function move<T>(state: ListState<T>, indices: number[], toIndex: number): ListState<T> {
-  // Shift the target down by the number of items being moved from before the target
-  toIndex -= indices.filter(index => index < toIndex).length;
-
-  let moves = indices.map(from => ({
-    from,
-    to: toIndex++
-  }));
-
-  // Shift later from indices down if they have a larger index
-  for (let i = 0; i < moves.length; i++) {
-    let a = moves[i].from;
-    for (let j = i; j < moves.length; j++) {
-      let b = moves[j].from;
-
-      if (b > a) {
-        moves[j].from--;
-      }
-    }
-  }
-
-  // Interleave the moves so they can be applied one by one rather than all at once
-  for (let i = 0; i < moves.length; i++) {
-    let a = moves[i];
-    for (let j = moves.length - 1; j > i; j--) {
-      let b = moves[j];
-
-      if (b.from < a.to) {
-        a.to++;
-      } else {
-        b.from++;
-      }
-    }
-  }
-
-  let copy = state.items.slice();
-  for (let move of moves) {
-    let [item] = copy.splice(move.from, 1);
-    copy.splice(move.to, 0, item);
-  }
-
-  return {
-    ...state,
-    items: copy
-  };
-}