@react-stately/data 3.11.1-nightly.4440 → 3.11.1-nightly.4451

package/dist/import.mjs

@@ -505,33 +505,38 @@ function $f86e6c1ec7da6ebb$export$bc3384a35de93d66(options) {
  */ 
 function $be2ea0343af54212$export$d14e1352e21f4a16(options) {
     let { initialItems: initialItems = [], initialSelectedKeys: initialSelectedKeys, getKey: getKey = (item)=>item.id || item.key, getChildren: getChildren = (item)=>item.children } = options;
-    let map = (0, $d70Aq$useMemo)(()=>new Map(), []);
     // We only want to compute this on initial render.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    let initialNodes = (0, $d70Aq$useMemo)(()=>buildTree(initialItems), []);
-    let [items, setItems] = (0, $d70Aq$useState)(initialNodes);
+    let [tree, setItems] = (0, $d70Aq$useState)(()=>buildTree(initialItems, new Map()));
+    let { items: items, nodeMap: nodeMap } = tree;
     let [selectedKeys, setSelectedKeys] = (0, $d70Aq$useState)(new Set(initialSelectedKeys || []));
-    function buildTree(initialItems = [], parentKey) {
-        return initialItems.map((item)=>{
-            let node = {
-                key: getKey(item),
-                parentKey: parentKey,
-                value: item,
-                children: null
-            };
-            node.children = buildTree(getChildren(item), node.key);
-            map.set(node.key, node);
-            return node;
-        });
+    function buildTree(initialItems = [], map, parentKey) {
+        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) {
-        let node = map.get(key);
-        if (!node) return items;
+    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);
-        else addNode(newNode);
-        // Walk up the tree and update each parent to refer to the new chilren.
+        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 = {
@@ -551,35 +556,41 @@ function $be2ea0343af54212$export$d14e1352e21f4a16(options) {
             node = nextParent;
         }
         if (newNode == null) items = items.filter((c)=>c !== node);
-        return items.map((item)=>{
-            if (item === node) return newNode;
-            return item;
-        });
+        return {
+            items: items.map((item)=>{
+                if (item === node) return newNode;
+                return item;
+            }),
+            nodeMap: map
+        };
     }
-    function addNode(node) {
+    function addNode(node, map) {
         map.set(node.key, node);
-        for (let child of node.children)addNode(child);
+        for (let child of node.children)addNode(child, map);
     }
-    function deleteNode(node) {
+    function deleteNode(node, map) {
         map.delete(node.key);
-        for (let child of node.children)deleteNode(child);
+        for (let child of node.children)deleteNode(child, map);
     }
     return {
         items: items,
         selectedKeys: selectedKeys,
         setSelectedKeys: setSelectedKeys,
         getItem (key) {
-            return map.get(key);
+            return nodeMap.get(key);
         },
         insert (parentKey, index, ...values) {
-            setItems((items)=>{
-                let nodes = buildTree(values, parentKey);
+            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.slice(0, index),
-                    ...nodes,
-                    ...items.slice(index)
-                ];
+                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,
@@ -587,24 +598,24 @@ function $be2ea0343af54212$export$d14e1352e21f4a16(options) {
                         value: parentNode.value,
                         children: [
                             ...parentNode.children.slice(0, index),
-                            ...nodes,
+                            ...newNodes,
                             ...parentNode.children.slice(index)
                         ]
-                    }));
+                    }), newMap);
             });
         },
         insertBefore (key, ...values) {
-            let node = map.get(key);
+            let node = nodeMap.get(key);
             if (!node) return;
-            let parentNode = map.get(node.parentKey);
+            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 = map.get(key);
+            let node = nodeMap.get(key);
             if (!node) return;
-            let parentNode = map.get(node.parentKey);
+            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);
@@ -615,39 +626,52 @@ function $be2ea0343af54212$export$d14e1352e21f4a16(options) {
         append (parentKey, ...values) {
             if (parentKey == null) this.insert(null, items.length, ...values);
             else {
-                let parentNode = map.get(parentKey);
+                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;
-            for (let key of keys)newItems = updateTree(newItems, key, ()=>null);
-            setItems(newItems);
+            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 (!map.has(key)) selection.delete(key);
+            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)=>{
-                let node = map.get(key);
-                if (!node) return items;
-                items = updateTree(items, key, ()=>null);
+            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) return [
-                    ...items.slice(0, index),
-                    movedNode,
-                    ...items.slice(index)
-                ];
+                if (toParentKey == null) return {
+                    items: [
+                        ...newItems.slice(0, index),
+                        movedNode,
+                        ...newItems.slice(index)
+                    ],
+                    nodeMap: newMap
+                };
                 // Otherwise, update the parent node and its ancestors.
-                return updateTree(items, toParentKey, (parentNode)=>({
+                return updateTree(newItems, toParentKey, (parentNode)=>({
                         key: parentNode.key,
                         parentKey: parentNode.parentKey,
                         value: parentNode.value,
@@ -656,20 +680,21 @@ function $be2ea0343af54212$export$d14e1352e21f4a16(options) {
                             movedNode,
                             ...parentNode.children.slice(index)
                         ]
-                    }));
+                    }), newMap);
             });
         },
         update (oldKey, newValue) {
-            setItems((items)=>updateTree(items, oldKey, (oldNode)=>{
+            setItems(({ items: items, nodeMap: originalMap })=>updateTree(items, oldKey, (oldNode)=>{
                     let node = {
                         key: oldNode.key,
                         parentKey: oldNode.parentKey,
                         value: newValue,
                         children: null
                     };
-                    node.children = buildTree(getChildren(newValue), node.key);
+                    let tree = buildTree(getChildren(newValue), originalMap, node.key);
+                    node.children = tree.items;
                     return node;
-                }));
+                }, originalMap));
         }
     };
 }

package/dist/main.js

@@ -513,33 +513,38 @@ function $1cb48366e5c5533f$export$bc3384a35de93d66(options) {
  */ 
 function $2d16d1aab63a81f4$export$d14e1352e21f4a16(options) {
     let { initialItems: initialItems = [], initialSelectedKeys: initialSelectedKeys, getKey: getKey = (item)=>item.id || item.key, getChildren: getChildren = (item)=>item.children } = options;
-    let map = (0, $kdbv0$react.useMemo)(()=>new Map(), []);
     // We only want to compute this on initial render.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    let initialNodes = (0, $kdbv0$react.useMemo)(()=>buildTree(initialItems), []);
-    let [items, setItems] = (0, $kdbv0$react.useState)(initialNodes);
+    let [tree, setItems] = (0, $kdbv0$react.useState)(()=>buildTree(initialItems, new Map()));
+    let { items: items, nodeMap: nodeMap } = tree;
     let [selectedKeys, setSelectedKeys] = (0, $kdbv0$react.useState)(new Set(initialSelectedKeys || []));
-    function buildTree(initialItems = [], parentKey) {
-        return initialItems.map((item)=>{
-            let node = {
-                key: getKey(item),
-                parentKey: parentKey,
-                value: item,
-                children: null
-            };
-            node.children = buildTree(getChildren(item), node.key);
-            map.set(node.key, node);
-            return node;
-        });
+    function buildTree(initialItems = [], map, parentKey) {
+        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) {
-        let node = map.get(key);
-        if (!node) return items;
+    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);
-        else addNode(newNode);
-        // Walk up the tree and update each parent to refer to the new chilren.
+        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 = {
@@ -559,35 +564,41 @@ function $2d16d1aab63a81f4$export$d14e1352e21f4a16(options) {
             node = nextParent;
         }
         if (newNode == null) items = items.filter((c)=>c !== node);
-        return items.map((item)=>{
-            if (item === node) return newNode;
-            return item;
-        });
+        return {
+            items: items.map((item)=>{
+                if (item === node) return newNode;
+                return item;
+            }),
+            nodeMap: map
+        };
     }
-    function addNode(node) {
+    function addNode(node, map) {
         map.set(node.key, node);
-        for (let child of node.children)addNode(child);
+        for (let child of node.children)addNode(child, map);
     }
-    function deleteNode(node) {
+    function deleteNode(node, map) {
         map.delete(node.key);
-        for (let child of node.children)deleteNode(child);
+        for (let child of node.children)deleteNode(child, map);
     }
     return {
         items: items,
         selectedKeys: selectedKeys,
         setSelectedKeys: setSelectedKeys,
         getItem (key) {
-            return map.get(key);
+            return nodeMap.get(key);
         },
         insert (parentKey, index, ...values) {
-            setItems((items)=>{
-                let nodes = buildTree(values, parentKey);
+            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.slice(0, index),
-                    ...nodes,
-                    ...items.slice(index)
-                ];
+                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,
@@ -595,24 +606,24 @@ function $2d16d1aab63a81f4$export$d14e1352e21f4a16(options) {
                         value: parentNode.value,
                         children: [
                             ...parentNode.children.slice(0, index),
-                            ...nodes,
+                            ...newNodes,
                             ...parentNode.children.slice(index)
                         ]
-                    }));
+                    }), newMap);
             });
         },
         insertBefore (key, ...values) {
-            let node = map.get(key);
+            let node = nodeMap.get(key);
             if (!node) return;
-            let parentNode = map.get(node.parentKey);
+            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 = map.get(key);
+            let node = nodeMap.get(key);
             if (!node) return;
-            let parentNode = map.get(node.parentKey);
+            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);
@@ -623,39 +634,52 @@ function $2d16d1aab63a81f4$export$d14e1352e21f4a16(options) {
         append (parentKey, ...values) {
             if (parentKey == null) this.insert(null, items.length, ...values);
             else {
-                let parentNode = map.get(parentKey);
+                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;
-            for (let key of keys)newItems = updateTree(newItems, key, ()=>null);
-            setItems(newItems);
+            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 (!map.has(key)) selection.delete(key);
+            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)=>{
-                let node = map.get(key);
-                if (!node) return items;
-                items = updateTree(items, key, ()=>null);
+            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) return [
-                    ...items.slice(0, index),
-                    movedNode,
-                    ...items.slice(index)
-                ];
+                if (toParentKey == null) return {
+                    items: [
+                        ...newItems.slice(0, index),
+                        movedNode,
+                        ...newItems.slice(index)
+                    ],
+                    nodeMap: newMap
+                };
                 // Otherwise, update the parent node and its ancestors.
-                return updateTree(items, toParentKey, (parentNode)=>({
+                return updateTree(newItems, toParentKey, (parentNode)=>({
                         key: parentNode.key,
                         parentKey: parentNode.parentKey,
                         value: parentNode.value,
@@ -664,20 +688,21 @@ function $2d16d1aab63a81f4$export$d14e1352e21f4a16(options) {
                             movedNode,
                             ...parentNode.children.slice(index)
                         ]
-                    }));
+                    }), newMap);
             });
         },
         update (oldKey, newValue) {
-            setItems((items)=>updateTree(items, oldKey, (oldNode)=>{
+            setItems(({ items: items, nodeMap: originalMap })=>updateTree(items, oldKey, (oldNode)=>{
                     let node = {
                         key: oldNode.key,
                         parentKey: oldNode.parentKey,
                         value: newValue,
                         children: null
                     };
-                    node.children = buildTree(getChildren(newValue), node.key);
+                    let tree = buildTree(getChildren(newValue), originalMap, node.key);
+                    node.children = tree.items;
                     return node;
-                }));
+                }, originalMap));
         }
     };
 }