@react-stately/data 3.0.0-nightly-641446f65-240905

package/dist/useListData.module.js

@@ -0,0 +1,217 @@
+import {useState as $bc4N1$useState, useMemo as $bc4N1$useMemo} from "react";
+
+/*
+ * 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.
+ */ 
+function $0d86e9c8f07f9a7b$export$762f73dccccd255d(options) {
+    let { initialItems: initialItems = [], initialSelectedKeys: initialSelectedKeys, getKey: getKey = (item)=>{
+        var _item_id;
+        return (_item_id = item.id) !== null && _item_id !== void 0 ? _item_id : item.key;
+    }, filter: filter, initialFilterText: initialFilterText = '' } = options;
+    // Store both items and filteredItems in state so we can go back to the unfiltered list
+    let [state, setState] = (0, $bc4N1$useState)({
+        items: initialItems,
+        selectedKeys: initialSelectedKeys === 'all' ? 'all' : new Set(initialSelectedKeys || []),
+        filterText: initialFilterText
+    });
+    let filteredItems = (0, $bc4N1$useMemo)(()=>filter ? state.items.filter((item)=>filter(item, state.filterText)) : state.items, [
+        state.items,
+        state.filterText,
+        filter
+    ]);
+    return {
+        ...state,
+        items: filteredItems,
+        ...$0d86e9c8f07f9a7b$export$79c0c687a5963b0a({
+            getKey: getKey
+        }, setState),
+        getItem (key) {
+            return state.items.find((item)=>getKey(item) === key);
+        }
+    };
+}
+function $0d86e9c8f07f9a7b$export$79c0c687a5963b0a(opts, dispatch) {
+    let { cursor: cursor, getKey: getKey } = opts;
+    return {
+        setSelectedKeys (selectedKeys) {
+            dispatch((state)=>({
+                    ...state,
+                    selectedKeys: selectedKeys
+                }));
+        },
+        setFilterText (filterText) {
+            dispatch((state)=>({
+                    ...state,
+                    filterText: filterText
+                }));
+        },
+        insert (index, ...values) {
+            dispatch((state)=>$0d86e9c8f07f9a7b$var$insert(state, index, ...values));
+        },
+        insertBefore (key, ...values) {
+            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 $0d86e9c8f07f9a7b$var$insert(state, index, ...values);
+            });
+        },
+        insertAfter (key, ...values) {
+            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 $0d86e9c8f07f9a7b$var$insert(state, index + 1, ...values);
+            });
+        },
+        prepend (...values) {
+            dispatch((state)=>$0d86e9c8f07f9a7b$var$insert(state, 0, ...values));
+        },
+        append (...values) {
+            dispatch((state)=>$0d86e9c8f07f9a7b$var$insert(state, state.items.length, ...values));
+        },
+        remove (...keys) {
+            dispatch((state)=>{
+                let keySet = new Set(keys);
+                let items = state.items.filter((item)=>!keySet.has(getKey(item)));
+                let 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: 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: items,
+                    selectedKeys: new Set()
+                };
+            });
+        },
+        move (key, toIndex) {
+            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, keys) {
+            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 $0d86e9c8f07f9a7b$var$move(state, indices, toIndex);
+            });
+        },
+        moveAfter (key, keys) {
+            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 $0d86e9c8f07f9a7b$var$move(state, indices, toIndex + 1);
+            });
+        },
+        update (key, newValue) {
+            dispatch((state)=>{
+                let index = state.items.findIndex((item)=>getKey(item) === key);
+                if (index === -1) return state;
+                return {
+                    ...state,
+                    items: [
+                        ...state.items.slice(0, index),
+                        newValue,
+                        ...state.items.slice(index + 1)
+                    ]
+                };
+            });
+        }
+    };
+}
+function $0d86e9c8f07f9a7b$var$insert(state, index, ...values) {
+    return {
+        ...state,
+        items: [
+            ...state.items.slice(0, index),
+            ...values,
+            ...state.items.slice(index)
+        ]
+    };
+}
+function $0d86e9c8f07f9a7b$var$move(state, indices, toIndex) {
+    // 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: 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
+    };
+}
+
+
+export {$0d86e9c8f07f9a7b$export$762f73dccccd255d as useListData, $0d86e9c8f07f9a7b$export$79c0c687a5963b0a as createListActions};
+//# sourceMappingURL=useListData.module.js.map

package/dist/useListData.module.js.map

@@ -0,0 +1 @@
+{"mappings":"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","sources":["packages/@react-stately/data/src/useListData.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {Key, Selection} from '@react-types/shared';\nimport {useMemo, useState} from 'react';\n\nexport interface ListOptions<T> {\n  /** Initial items in the list. */\n  initialItems?: T[],\n  /** The keys for the initially selected items. */\n  initialSelectedKeys?: 'all' | Iterable<Key>,\n  /** The initial text to filter the list by. */\n  initialFilterText?: string,\n  /** A function that returns a unique key for an item object. */\n  getKey?: (item: T) => Key,\n  /** A function that returns whether a item matches the current filter text. */\n  filter?: (item: T, filterText: string) => boolean\n}\n\nexport interface ListData<T> {\n  /** The items in the list. */\n  items: T[],\n\n  /** The keys of the currently selected items in the list. */\n  selectedKeys: Selection,\n\n  /** Sets the selected keys. */\n  setSelectedKeys(keys: Selection): void,\n\n  /** The current filter text. */\n  filterText: string,\n\n  /** Sets the filter text. */\n  setFilterText(filterText: string): void,\n\n  /**\n   * Gets an item from the list by key.\n   * @param key - The key of the item to retrieve.\n   */\n  getItem(key: Key): T,\n\n  /**\n   * Inserts items into the list at the given index.\n   * @param index - The index to insert into.\n   * @param values - The values to insert.\n   */\n  insert(index: number, ...values: T[]): void,\n\n  /**\n   * Inserts items into the list before the item at the given key.\n   * @param key - The key of the item to insert before.\n   * @param values - The values to insert.\n   */\n  insertBefore(key: Key, ...values: T[]): void,\n\n  /**\n   * Inserts items into the list after the item at the given key.\n   * @param key - The key of the item to insert after.\n   * @param values - The values to insert.\n   */\n  insertAfter(key: Key, ...values: T[]): void,\n\n  /**\n   * Appends items to the list.\n   * @param values - The values to insert.\n   */\n  append(...values: T[]): void,\n\n  /**\n   * Prepends items to the list.\n   * @param value - The value to insert.\n   */\n  prepend(...values: T[]): void,\n\n  /**\n   * Removes items from the list by their keys.\n   * @param keys - The keys of the item to remove.\n   */\n  remove(...keys: Key[]): void,\n\n  /**\n   * Removes all items from the list that are currently\n   * in the set of selected items.\n   */\n  removeSelectedItems(): void,\n\n  /**\n   * Moves an item within the list.\n   * @param key - The key of the item to move.\n   * @param toIndex - The index to move the item to.\n   */\n  move(key: Key, toIndex: number): void,\n\n  /**\n   * Moves one or more items before a given key.\n   * @param key - The key of the item to move the items before.\n   * @param keys - The keys of the items to move.\n   */\n  moveBefore(key: Key, keys: Iterable<Key>): void,\n\n  /**\n   * Moves one or more items after a given key.\n   * @param key - The key of the item to move the items after.\n   * @param keys - The keys of the items to move.\n   */\n  moveAfter(key: Key, keys: Iterable<Key>): void,\n\n  /**\n   * Updates an item in the list.\n   * @param key - The key of the item to update.\n   * @param newValue - The new value for the item.\n   */\n  update(key: Key, newValue: T): void\n}\n\nexport interface ListState<T> {\n  items: T[],\n  selectedKeys: Selection,\n  filterText: string\n}\n\ninterface CreateListOptions<T, C> extends ListOptions<T> {\n  cursor?: C\n}\n\n/**\n * Manages state for an immutable list data structure, and provides convenience methods to\n * update the data over time.\n */\nexport function useListData<T>(options: ListOptions<T>): ListData<T> {\n  let {\n    initialItems = [],\n    initialSelectedKeys,\n    getKey = (item: any) => item.id ?? item.key,\n    filter,\n    initialFilterText = ''\n  } = options;\n\n  // Store both items and filteredItems in state so we can go back to the unfiltered list\n  let [state, setState] = useState<ListState<T>>({\n    items: initialItems,\n    selectedKeys: initialSelectedKeys === 'all' ? 'all' : new Set(initialSelectedKeys || []),\n    filterText: initialFilterText\n  });\n\n  let filteredItems = useMemo(\n    () => filter ? state.items.filter(item => filter(item, state.filterText)) : state.items,\n    [state.items, state.filterText, filter]);\n\n  return {\n    ...state,\n    items: filteredItems,\n    ...createListActions({getKey}, setState),\n    getItem(key: Key) {\n      return state.items.find(item => getKey(item) === key);\n    }\n  };\n}\n\nexport function createListActions<T, C>(opts: CreateListOptions<T, C>, dispatch: (updater: (state: ListState<T>) => ListState<T>) => void): Omit<ListData<T>, 'items' | 'selectedKeys' | 'getItem' | 'filterText'> {\n  let {cursor, getKey} = opts;\n  return {\n    setSelectedKeys(selectedKeys: Selection) {\n      dispatch(state => ({\n        ...state,\n        selectedKeys\n      }));\n    },\n    setFilterText(filterText: string) {\n      dispatch(state => ({\n        ...state,\n        filterText\n      }));\n    },\n    insert(index: number, ...values: T[]) {\n      dispatch(state => insert(state, index, ...values));\n    },\n    insertBefore(key: Key, ...values: T[]) {\n      dispatch(state => {\n        let index = state.items.findIndex(item => getKey(item) === key);\n        if (index === -1) {\n          if (state.items.length === 0) {\n            index = 0;\n          } else {\n            return state;\n          }\n        }\n\n        return insert(state, index, ...values);\n      });\n    },\n    insertAfter(key: Key, ...values: T[]) {\n      dispatch(state => {\n        let index = state.items.findIndex(item => getKey(item) === key);\n        if (index === -1) {\n          if (state.items.length === 0) {\n            index = 0;\n          } else {\n            return state;\n          }\n        }\n\n        return insert(state, index + 1, ...values);\n      });\n    },\n    prepend(...values: T[]) {\n      dispatch(state => insert(state, 0, ...values));\n    },\n    append(...values: T[]) {\n      dispatch(state => insert(state, state.items.length, ...values));\n    },\n    remove(...keys: Key[]) {\n      dispatch(state => {\n        let keySet = new Set(keys);\n        let items = state.items.filter(item => !keySet.has(getKey(item)));\n\n        let selection: Selection = 'all';\n        if (state.selectedKeys !== 'all') {\n          selection = new Set(state.selectedKeys);\n          for (let key of keys) {\n            selection.delete(key);\n          }\n        }\n        if (cursor == null && items.length === 0) {\n          selection = new Set();\n        }\n\n        return {\n          ...state,\n          items,\n          selectedKeys: selection\n        };\n      });\n    },\n    removeSelectedItems() {\n      dispatch(state => {\n        if (state.selectedKeys === 'all') {\n          return {\n            ...state,\n            items: [],\n            selectedKeys: new Set()\n          };\n        }\n\n        let selectedKeys = state.selectedKeys;\n        let items = state.items.filter(item => !selectedKeys.has(getKey(item)));\n        return {\n          ...state,\n          items,\n          selectedKeys: new Set()\n        };\n      });\n    },\n    move(key: Key, toIndex: number) {\n      dispatch(state => {\n        let index = state.items.findIndex(item => getKey(item) === key);\n        if (index === -1) {\n          return state;\n        }\n\n        let copy = state.items.slice();\n        let [item] = copy.splice(index, 1);\n        copy.splice(toIndex, 0, item);\n        return {\n          ...state,\n          items: copy\n        };\n      });\n    },\n    moveBefore(key: Key, keys: Iterable<Key>) {\n      dispatch(state => {\n        let toIndex = state.items.findIndex(item => getKey(item) === key);\n        if (toIndex === -1) {\n          return state;\n        }\n\n        // Find indices of keys to move. Sort them so that the order in the list is retained.\n        let keyArray = Array.isArray(keys) ? keys : [...keys];\n        let indices = keyArray.map(key => state.items.findIndex(item => getKey(item) === key)).sort((a, b) => a - b);\n        return move(state, indices, toIndex);\n      });\n    },\n    moveAfter(key: Key, keys: Iterable<Key>) {\n      dispatch(state => {\n        let toIndex = state.items.findIndex(item => getKey(item) === key);\n        if (toIndex === -1) {\n          return state;\n        }\n\n        let keyArray = Array.isArray(keys) ? keys : [...keys];\n        let indices = keyArray.map(key => state.items.findIndex(item => getKey(item) === key)).sort((a, b) => a - b);\n        return move(state, indices, toIndex + 1);\n      });\n    },\n    update(key: Key, newValue: T) {\n      dispatch(state => {\n        let index = state.items.findIndex(item => getKey(item) === key);\n        if (index === -1) {\n          return state;\n        }\n\n        return {\n          ...state,\n          items: [\n            ...state.items.slice(0, index),\n            newValue,\n            ...state.items.slice(index + 1)\n          ]\n        };\n      });\n    }\n  };\n}\n\nfunction insert<T>(state: ListState<T>, index: number, ...values: T[]): ListState<T> {\n  return {\n    ...state,\n    items: [\n      ...state.items.slice(0, index),\n      ...values,\n      ...state.items.slice(index)\n    ]\n  };\n}\n\nfunction move<T>(state: ListState<T>, indices: number[], toIndex: number): ListState<T> {\n  // Shift the target down by the number of items being moved from before the target\n  toIndex -= indices.filter(index => index < toIndex).length;\n\n  let moves = indices.map(from => ({\n    from,\n    to: toIndex++\n  }));\n\n  // Shift later from indices down if they have a larger index\n  for (let i = 0; i < moves.length; i++) {\n    let a = moves[i].from;\n    for (let j = i; j < moves.length; j++) {\n      let b = moves[j].from;\n\n      if (b > a) {\n        moves[j].from--;\n      }\n    }\n  }\n\n  // Interleave the moves so they can be applied one by one rather than all at once\n  for (let i = 0; i < moves.length; i++) {\n    let a = moves[i];\n    for (let j = moves.length - 1; j > i; j--) {\n      let b = moves[j];\n\n      if (b.from < a.to) {\n        a.to++;\n      } else {\n        b.from++;\n      }\n    }\n  }\n\n  let copy = state.items.slice();\n  for (let move of moves) {\n    let [item] = copy.splice(move.from, 1);\n    copy.splice(move.to, 0, item);\n  }\n\n  return {\n    ...state,\n    items: copy\n  };\n}\n"],"names":[],"version":3,"file":"useListData.module.js.map"}

package/dist/useTreeData.main.js

@@ -0,0 +1,224 @@
+var $aMaLn$react = require("react");
+
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+
+$parcel$export(module.exports, "useTreeData", () => $2d16d1aab63a81f4$export$d14e1352e21f4a16);
+/*
+ * 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.
+ */ 
+function $2d16d1aab63a81f4$export$d14e1352e21f4a16(options) {
+    let { initialItems: initialItems = [], initialSelectedKeys: initialSelectedKeys, getKey: getKey = (item)=>{
+        var _item_id;
+        return (_item_id = item.id) !== null && _item_id !== void 0 ? _item_id : item.key;
+    }, getChildren: getChildren = (item)=>item.children } = options;
+    // We only want to compute this on initial render.
+    let [tree, setItems] = (0, $aMaLn$react.useState)(()=>buildTree(initialItems, new Map()));
+    let { items: items, nodeMap: nodeMap } = tree;
+    let [selectedKeys, setSelectedKeys] = (0, $aMaLn$react.useState)(new Set(initialSelectedKeys || []));
+    function buildTree(initialItems = [], map, parentKey) {
+        if (initialItems == null) initialItems = [];
+        return {
+            items: initialItems.map((item)=>{
+                let node = {
+                    key: getKey(item),
+                    parentKey: parentKey,
+                    value: item,
+                    children: null
+                };
+                node.children = buildTree(getChildren(item), map, node.key).items;
+                map.set(node.key, node);
+                return node;
+            }),
+            nodeMap: map
+        };
+    }
+    function updateTree(items, key, update, originalMap) {
+        let node = originalMap.get(key);
+        if (!node) return {
+            items: items,
+            nodeMap: originalMap
+        };
+        let map = new Map(originalMap);
+        // Create a new node. If null, then delete the node, otherwise replace.
+        let newNode = update(node);
+        if (newNode == null) deleteNode(node, map);
+        else addNode(newNode, map);
+        // Walk up the tree and update each parent to refer to the new children.
+        while(node.parentKey){
+            let nextParent = map.get(node.parentKey);
+            let copy = {
+                key: nextParent.key,
+                parentKey: nextParent.parentKey,
+                value: nextParent.value,
+                children: null
+            };
+            let children = nextParent.children;
+            if (newNode == null) children = children.filter((c)=>c !== node);
+            copy.children = children.map((child)=>{
+                if (child === node) return newNode;
+                return child;
+            });
+            map.set(copy.key, copy);
+            newNode = copy;
+            node = nextParent;
+        }
+        if (newNode == null) items = items.filter((c)=>c !== node);
+        return {
+            items: items.map((item)=>{
+                if (item === node) return newNode;
+                return item;
+            }),
+            nodeMap: map
+        };
+    }
+    function addNode(node, map) {
+        map.set(node.key, node);
+        for (let child of node.children)addNode(child, map);
+    }
+    function deleteNode(node, map) {
+        map.delete(node.key);
+        for (let child of node.children)deleteNode(child, map);
+    }
+    return {
+        items: items,
+        selectedKeys: selectedKeys,
+        setSelectedKeys: setSelectedKeys,
+        getItem (key) {
+            return nodeMap.get(key);
+        },
+        insert (parentKey, index, ...values) {
+            setItems(({ items: items, nodeMap: originalMap })=>{
+                let { items: newNodes, nodeMap: newMap } = buildTree(values, originalMap, parentKey);
+                // If parentKey is null, insert into the root.
+                if (parentKey == null) return {
+                    items: [
+                        ...items.slice(0, index),
+                        ...newNodes,
+                        ...items.slice(index)
+                    ],
+                    nodeMap: newMap
+                };
+                // Otherwise, update the parent node and its ancestors.
+                return updateTree(items, parentKey, (parentNode)=>({
+                        key: parentNode.key,
+                        parentKey: parentNode.parentKey,
+                        value: parentNode.value,
+                        children: [
+                            ...parentNode.children.slice(0, index),
+                            ...newNodes,
+                            ...parentNode.children.slice(index)
+                        ]
+                    }), newMap);
+            });
+        },
+        insertBefore (key, ...values) {
+            let node = nodeMap.get(key);
+            if (!node) return;
+            let parentNode = nodeMap.get(node.parentKey);
+            let nodes = parentNode ? parentNode.children : items;
+            let index = nodes.indexOf(node);
+            this.insert(parentNode === null || parentNode === void 0 ? void 0 : parentNode.key, index, ...values);
+        },
+        insertAfter (key, ...values) {
+            let node = nodeMap.get(key);
+            if (!node) return;
+            let parentNode = nodeMap.get(node.parentKey);
+            let nodes = parentNode ? parentNode.children : items;
+            let index = nodes.indexOf(node);
+            this.insert(parentNode === null || parentNode === void 0 ? void 0 : parentNode.key, index + 1, ...values);
+        },
+        prepend (parentKey, ...values) {
+            this.insert(parentKey, 0, ...values);
+        },
+        append (parentKey, ...values) {
+            if (parentKey == null) this.insert(null, items.length, ...values);
+            else {
+                let parentNode = nodeMap.get(parentKey);
+                if (!parentNode) return;
+                this.insert(parentKey, parentNode.children.length, ...values);
+            }
+        },
+        remove (...keys) {
+            if (keys.length === 0) return;
+            let newItems = items;
+            let prevMap = nodeMap;
+            let newTree;
+            for (let key of keys){
+                newTree = updateTree(newItems, key, ()=>null, prevMap);
+                prevMap = newTree.nodeMap;
+                newItems = newTree.items;
+            }
+            setItems(newTree);
+            let selection = new Set(selectedKeys);
+            for (let key of selectedKeys)if (!newTree.nodeMap.has(key)) selection.delete(key);
+            setSelectedKeys(selection);
+        },
+        removeSelectedItems () {
+            this.remove(...selectedKeys);
+        },
+        move (key, toParentKey, index) {
+            setItems(({ items: items, nodeMap: originalMap })=>{
+                let node = originalMap.get(key);
+                if (!node) return {
+                    items: items,
+                    nodeMap: originalMap
+                };
+                let { items: newItems, nodeMap: newMap } = updateTree(items, key, ()=>null, originalMap);
+                const movedNode = {
+                    ...node,
+                    parentKey: toParentKey
+                };
+                // If parentKey is null, insert into the root.
+                if (toParentKey == null) {
+                    newMap.set(movedNode.key, movedNode);
+                    return {
+                        items: [
+                            ...newItems.slice(0, index),
+                            movedNode,
+                            ...newItems.slice(index)
+                        ],
+                        nodeMap: newMap
+                    };
+                }
+                // Otherwise, update the parent node and its ancestors.
+                return updateTree(newItems, toParentKey, (parentNode)=>({
+                        key: parentNode.key,
+                        parentKey: parentNode.parentKey,
+                        value: parentNode.value,
+                        children: [
+                            ...parentNode.children.slice(0, index),
+                            movedNode,
+                            ...parentNode.children.slice(index)
+                        ]
+                    }), newMap);
+            });
+        },
+        update (oldKey, newValue) {
+            setItems(({ items: items, nodeMap: originalMap })=>updateTree(items, oldKey, (oldNode)=>{
+                    let node = {
+                        key: oldNode.key,
+                        parentKey: oldNode.parentKey,
+                        value: newValue,
+                        children: null
+                    };
+                    let tree = buildTree(getChildren(newValue), originalMap, node.key);
+                    node.children = tree.items;
+                    return node;
+                }, originalMap));
+        }
+    };
+}
+
+
+//# sourceMappingURL=useTreeData.main.js.map

package/dist/useTreeData.main.js.map

@@ -0,0 +1 @@
+{"mappings":"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","sources":["packages/@react-stately/data/src/useTreeData.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {Key} from '@react-types/shared';\nimport {useState} from 'react';\n\nexport interface TreeOptions<T extends object> {\n  /** Initial root items in the tree. */\n  initialItems?: T[],\n  /** The keys for the initially selected items. */\n  initialSelectedKeys?: Iterable<Key>,\n  /** A function that returns a unique key for an item object. */\n  getKey?: (item: T) => Key,\n  /** A function that returns the children for an item object. */\n  getChildren?: (item: T) => T[]\n}\n\ninterface TreeNode<T extends object> {\n  /** A unique key for the tree node. */\n  key: Key,\n  /** The key of the parent node. */\n  parentKey: Key,\n  /** The value object for the tree node. */\n  value: T,\n  /** Children of the tree node. */\n  children: TreeNode<T>[]\n}\n\nexport interface TreeData<T extends object> {\n  /** The root nodes in the tree. */\n  items: TreeNode<T>[],\n\n  /** The keys of the currently selected items in the tree. */\n  selectedKeys: Set<Key>,\n\n  /** Sets the selected keys. */\n  setSelectedKeys(keys: Set<Key>): void,\n\n  /**\n   * Gets a node from the tree by key.\n   * @param key - The key of the item to retrieve.\n   */\n  getItem(key: Key): TreeNode<T>,\n\n  /**\n   * Inserts an item into a parent node as a child.\n   * @param parentKey - The key of the parent item to insert into. `null` for the root.\n   * @param index - The index within the parent to insert into.\n   * @param value - The value to insert.\n   */\n  insert(parentKey: Key | null, index: number, ...values: T[]): void,\n\n  /**\n   * Inserts items into the list before the item at the given key.\n   * @param key - The key of the item to insert before.\n   * @param values - The values to insert.\n   */\n  insertBefore(key: Key, ...values: T[]): void,\n\n  /**\n   * Inserts items into the list after the item at the given key.\n   * @param key - The key of the item to insert after.\n   * @param values - The values to insert.\n   */\n  insertAfter(key: Key, ...values: T[]): void,\n\n  /**\n   * Appends an item into a parent node as a child.\n   * @param parentKey - The key of the parent item to insert into. `null` for the root.\n   * @param value - The value to insert.\n   */\n  append(parentKey: Key | null, ...values: T[]): void,\n\n  /**\n   * Prepends an item into a parent node as a child.\n   * @param parentKey - The key of the parent item to insert into. `null` for the root.\n   * @param value - The value to insert.\n   */\n  prepend(parentKey: Key | null, ...value: T[]): void,\n\n  /**\n   * Removes an item from the tree by its key.\n   * @param key - The key of the item to remove.\n   */\n  remove(...keys: Key[]): void,\n\n  /**\n   * Removes all items from the tree that are currently\n   * in the set of selected items.\n   */\n  removeSelectedItems(): void,\n\n  /**\n   * Moves an item within the tree.\n   * @param key - The key of the item to move.\n   * @param toParentKey - The key of the new parent to insert into. `null` for the root.\n   * @param index - The index within the new parent to insert at.\n   */\n  move(key: Key, toParentKey: Key | null, index: number): void,\n\n  /**\n   * Updates an item in the tree.\n   * @param key - The key of the item to update.\n   * @param newValue - The new value for the item.\n   */\n  update(key: Key, newValue: T): void\n}\n\n/**\n * Manages state for an immutable tree data structure, and provides convenience methods to\n * update the data over time.\n */\nexport function useTreeData<T extends object>(options: TreeOptions<T>): TreeData<T> {\n  let {\n    initialItems = [],\n    initialSelectedKeys,\n    getKey = (item: any) => item.id ?? item.key,\n    getChildren = (item: any) => item.children\n  } = options;\n\n  // We only want to compute this on initial render.\n  let [tree, setItems] = useState<{items: TreeNode<T>[], nodeMap: Map<Key, TreeNode<T>>}>(() => buildTree(initialItems, new Map()));\n  let {items, nodeMap} = tree;\n\n  let [selectedKeys, setSelectedKeys] = useState(new Set<Key>(initialSelectedKeys || []));\n\n  function buildTree(initialItems: T[] | null = [], map: Map<Key, TreeNode<T>>, parentKey?: Key | null) {\n    if (initialItems == null) {\n      initialItems = [];\n    }\n    return {\n      items: initialItems.map(item => {\n        let node: TreeNode<T> = {\n          key: getKey(item),\n          parentKey: parentKey,\n          value: item,\n          children: null\n        };\n\n        node.children = buildTree(getChildren(item), map, node.key).items;\n        map.set(node.key, node);\n        return node;\n      }),\n      nodeMap: map\n    };\n  }\n\n  function updateTree(items: TreeNode<T>[], key: Key, update: (node: TreeNode<T>) => TreeNode<T>, originalMap: Map<Key, TreeNode<T>>) {\n    let node = originalMap.get(key);\n    if (!node) {\n      return {items, nodeMap: originalMap};\n    }\n    let map = new Map<Key, TreeNode<T>>(originalMap);\n\n    // Create a new node. If null, then delete the node, otherwise replace.\n    let newNode = update(node);\n    if (newNode == null) {\n      deleteNode(node, map);\n    } else {\n      addNode(newNode, map);\n    }\n\n    // Walk up the tree and update each parent to refer to the new children.\n    while (node.parentKey) {\n      let nextParent = map.get(node.parentKey);\n      let copy: TreeNode<T> = {\n        key: nextParent.key,\n        parentKey: nextParent.parentKey,\n        value: nextParent.value,\n        children: null\n      };\n\n      let children = nextParent.children;\n      if (newNode == null) {\n        children = children.filter(c => c !== node);\n      }\n\n      copy.children = children.map(child => {\n        if (child === node) {\n          return newNode;\n        }\n\n        return child;\n      });\n\n      map.set(copy.key, copy);\n\n      newNode = copy;\n      node = nextParent;\n    }\n\n    if (newNode == null) {\n      items = items.filter(c => c !== node);\n    }\n\n    return {\n      items: items.map(item => {\n        if (item === node) {\n          return newNode;\n        }\n\n        return item;\n      }),\n      nodeMap: map\n    };\n  }\n\n  function addNode(node: TreeNode<T>, map: Map<Key, TreeNode<T>>) {\n    map.set(node.key, node);\n    for (let child of node.children) {\n      addNode(child, map);\n    }\n  }\n\n  function deleteNode(node: TreeNode<T>, map: Map<Key, TreeNode<T>>) {\n    map.delete(node.key);\n    for (let child of node.children) {\n      deleteNode(child, map);\n    }\n  }\n\n  return {\n    items,\n    selectedKeys,\n    setSelectedKeys,\n    getItem(key: Key) {\n      return nodeMap.get(key);\n    },\n    insert(parentKey: Key | null, index: number, ...values: T[]) {\n      setItems(({items, nodeMap: originalMap}) => {\n        let {items: newNodes, nodeMap: newMap} = buildTree(values, originalMap, parentKey);\n\n        // If parentKey is null, insert into the root.\n        if (parentKey == null) {\n          return {\n            items: [\n              ...items.slice(0, index),\n              ...newNodes,\n              ...items.slice(index)\n            ],\n            nodeMap: newMap\n          };\n        }\n\n        // Otherwise, update the parent node and its ancestors.\n        return updateTree(items, parentKey, parentNode => ({\n          key: parentNode.key,\n          parentKey: parentNode.parentKey,\n          value: parentNode.value,\n          children: [\n            ...parentNode.children.slice(0, index),\n            ...newNodes,\n            ...parentNode.children.slice(index)\n          ]\n        }), newMap);\n      });\n    },\n    insertBefore(key: Key, ...values: T[]): void {\n      let node = nodeMap.get(key);\n      if (!node) {\n        return;\n      }\n\n      let parentNode = nodeMap.get(node.parentKey);\n      let nodes = parentNode ? parentNode.children : items;\n      let index = nodes.indexOf(node);\n      this.insert(parentNode?.key, index, ...values);\n    },\n    insertAfter(key: Key, ...values: T[]): void {\n      let node = nodeMap.get(key);\n      if (!node) {\n        return;\n      }\n\n      let parentNode = nodeMap.get(node.parentKey);\n      let nodes = parentNode ? parentNode.children : items;\n      let index = nodes.indexOf(node);\n      this.insert(parentNode?.key, index + 1, ...values);\n    },\n    prepend(parentKey: Key | null, ...values: T[]) {\n      this.insert(parentKey, 0, ...values);\n    },\n    append(parentKey: Key | null, ...values: T[]) {\n      if (parentKey == null) {\n        this.insert(null, items.length, ...values);\n      } else {\n        let parentNode = nodeMap.get(parentKey);\n        if (!parentNode) {\n          return;\n        }\n\n        this.insert(parentKey, parentNode.children.length, ...values);\n      }\n    },\n    remove(...keys: Key[]) {\n      if (keys.length === 0) {\n        return;\n      }\n\n      let newItems = items;\n      let prevMap = nodeMap;\n      let newTree;\n      for (let key of keys) {\n        newTree = updateTree(newItems, key, () => null, prevMap);\n        prevMap = newTree.nodeMap;\n        newItems = newTree.items;\n      }\n\n      setItems(newTree);\n\n      let selection = new Set(selectedKeys);\n      for (let key of selectedKeys) {\n        if (!newTree.nodeMap.has(key)) {\n          selection.delete(key);\n        }\n      }\n\n      setSelectedKeys(selection);\n    },\n    removeSelectedItems() {\n      this.remove(...selectedKeys);\n    },\n    move(key: Key, toParentKey: Key | null, index: number) {\n      setItems(({items, nodeMap: originalMap}) => {\n        let node = originalMap.get(key);\n        if (!node) {\n          return {items, nodeMap: originalMap};\n        }\n\n        let {items: newItems, nodeMap: newMap} = updateTree(items, key, () => null, originalMap);\n\n\n        const movedNode = {\n          ...node,\n          parentKey: toParentKey\n        };\n\n        // If parentKey is null, insert into the root.\n        if (toParentKey == null) {\n          newMap.set(movedNode.key, movedNode);\n          return {items: [\n            ...newItems.slice(0, index),\n            movedNode,\n            ...newItems.slice(index)\n          ], nodeMap: newMap};\n        }\n\n        // Otherwise, update the parent node and its ancestors.\n        return updateTree(newItems, toParentKey, parentNode => ({\n          key: parentNode.key,\n          parentKey: parentNode.parentKey,\n          value: parentNode.value,\n          children: [\n            ...parentNode.children.slice(0, index),\n            movedNode,\n            ...parentNode.children.slice(index)\n          ]\n        }), newMap);\n      });\n    },\n    update(oldKey: Key, newValue: T) {\n      setItems(({items, nodeMap: originalMap}) => updateTree(items, oldKey, oldNode => {\n        let node: TreeNode<T> = {\n          key: oldNode.key,\n          parentKey: oldNode.parentKey,\n          value: newValue,\n          children: null\n        };\n\n        let tree = buildTree(getChildren(newValue), originalMap, node.key);\n        node.children = tree.items;\n        return node;\n      }, originalMap));\n    }\n  };\n}\n"],"names":[],"version":3,"file":"useTreeData.main.js.map"}