@react-stately/collections 3.5.1 → 3.6.0

package/dist/import.mjs

@@ -0,0 +1,353 @@
+import $tyW6A$react, {useMemo as $tyW6A$useMemo, useRef as $tyW6A$useRef} from "react";
+import $tyW6A$swchelperssrc_define_propertymjs from "@swc/helpers/src/_define_property.mjs";
+
+/*
+ * 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.
+ */ /*
+ * 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 $c1d7fb2ec91bae71$var$Item(props) {
+    return null;
+}
+$c1d7fb2ec91bae71$var$Item.getCollectionNode = function* getCollectionNode(props, context) {
+    let { childItems: childItems , title: title , children: children  } = props;
+    let rendered = props.title || props.children;
+    let textValue = props.textValue || (typeof rendered === "string" ? rendered : "") || props["aria-label"] || "";
+    // suppressTextValueWarning is used in components like Tabs, which don't have type to select support.
+    if (!textValue && !(context === null || context === void 0 ? void 0 : context.suppressTextValueWarning)) console.warn("<Item> with non-plain text contents is unsupported by type to select for accessibility. Please add a `textValue` prop.");
+    yield {
+        type: "item",
+        props: props,
+        rendered: rendered,
+        textValue: textValue,
+        "aria-label": props["aria-label"],
+        hasChildNodes: $c1d7fb2ec91bae71$var$hasChildItems(props),
+        *childNodes () {
+            if (childItems) for (let child of childItems)yield {
+                type: "item",
+                value: child
+            };
+            else if (title) {
+                let items = [];
+                (0, $tyW6A$react).Children.forEach(children, (child)=>{
+                    items.push({
+                        type: "item",
+                        element: child
+                    });
+                });
+                yield* items;
+            }
+        }
+    };
+};
+function $c1d7fb2ec91bae71$var$hasChildItems(props) {
+    if (props.hasChildItems != null) return props.hasChildItems;
+    if (props.childItems) return true;
+    if (props.title && (0, $tyW6A$react).Children.count(props.children) > 0) return true;
+    return false;
+}
+// We don't want getCollectionNode to show up in the type definition
+let $c1d7fb2ec91bae71$export$6d08773d2e66f8f2 = $c1d7fb2ec91bae71$var$Item;
+
+
+/*
+ * 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 $9fc4852771d079eb$var$Section(props) {
+    return null;
+}
+$9fc4852771d079eb$var$Section.getCollectionNode = function* getCollectionNode(props) {
+    let { children: children , title: title , items: items  } = props;
+    yield {
+        type: "section",
+        props: props,
+        hasChildNodes: true,
+        rendered: title,
+        "aria-label": props["aria-label"],
+        *childNodes () {
+            if (typeof children === "function") {
+                if (!items) throw new Error("props.children was a function but props.items is missing");
+                for (let item of items)yield {
+                    type: "item",
+                    value: item,
+                    renderer: children
+                };
+            } else {
+                let items1 = [];
+                (0, $tyW6A$react).Children.forEach(children, (child)=>{
+                    items1.push({
+                        type: "item",
+                        element: child
+                    });
+                });
+                yield* items1;
+            }
+        }
+    };
+};
+// We don't want getCollectionNode to show up in the type definition
+let $9fc4852771d079eb$export$6e2c8f0811a474ce = $9fc4852771d079eb$var$Section;
+
+
+/*
+ * 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.
+ */ /*
+ * 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.
+ */ 
+
+class $eb2240fc39a57fa5$export$bf788dd355e3a401 {
+    build(props, context) {
+        this.context = context;
+        return $eb2240fc39a57fa5$var$iterable(()=>this.iterateCollection(props));
+    }
+    *iterateCollection(props) {
+        let { children: children , items: items  } = props;
+        if (typeof children === "function") {
+            if (!items) throw new Error("props.children was a function but props.items is missing");
+            for (let item of props.items)yield* this.getFullNode({
+                value: item
+            }, {
+                renderer: children
+            });
+        } else {
+            let items1 = [];
+            (0, $tyW6A$react).Children.forEach(children, (child)=>{
+                items1.push(child);
+            });
+            let index = 0;
+            for (let item1 of items1){
+                let nodes = this.getFullNode({
+                    element: item1,
+                    index: index
+                }, {});
+                for (let node of nodes){
+                    index++;
+                    yield node;
+                }
+            }
+        }
+    }
+    getKey(item, partialNode, state, parentKey) {
+        if (item.key != null) return item.key;
+        if (partialNode.type === "cell" && partialNode.key != null) return `${parentKey}${partialNode.key}`;
+        let v = partialNode.value;
+        if (v != null) {
+            var _v_key;
+            let key = (_v_key = v.key) !== null && _v_key !== void 0 ? _v_key : v.id;
+            if (key == null) throw new Error("No key found for item");
+            return key;
+        }
+        return parentKey ? `${parentKey}.${partialNode.index}` : `$.${partialNode.index}`;
+    }
+    getChildState(state, partialNode) {
+        return {
+            renderer: partialNode.renderer || state.renderer
+        };
+    }
+    *getFullNode(partialNode, state, parentKey, parentNode) {
+        // If there's a value instead of an element on the node, and a parent renderer function is available,
+        // use it to render an element for the value.
+        let element = partialNode.element;
+        if (!element && partialNode.value && state && state.renderer) {
+            let cached = this.cache.get(partialNode.value);
+            if (cached && (!cached.shouldInvalidate || !cached.shouldInvalidate(this.context))) {
+                cached.index = partialNode.index;
+                cached.parentKey = parentNode ? parentNode.key : null;
+                yield cached;
+                return;
+            }
+            element = state.renderer(partialNode.value);
+        }
+        // If there's an element with a getCollectionNode function on its type, then it's a supported component.
+        // Call this function to get a partial node, and recursively build a full node from there.
+        if ((0, $tyW6A$react).isValidElement(element)) {
+            let type = element.type;
+            if (typeof type !== "function" && typeof type.getCollectionNode !== "function") {
+                let name = typeof element.type === "function" ? element.type.name : element.type;
+                throw new Error(`Unknown element <${name}> in collection.`);
+            }
+            let childNodes = type.getCollectionNode(element.props, this.context);
+            let index = partialNode.index;
+            let result = childNodes.next();
+            while(!result.done && result.value){
+                let childNode = result.value;
+                partialNode.index = index;
+                let nodeKey = childNode.key;
+                if (!nodeKey) nodeKey = childNode.element ? null : this.getKey(element, partialNode, state, parentKey);
+                let nodes = this.getFullNode({
+                    ...childNode,
+                    key: nodeKey,
+                    index: index,
+                    wrapper: $eb2240fc39a57fa5$var$compose(partialNode.wrapper, childNode.wrapper)
+                }, this.getChildState(state, childNode), parentKey ? `${parentKey}${element.key}` : element.key, parentNode);
+                let children = [
+                    ...nodes
+                ];
+                for (let node of children){
+                    // Cache the node based on its value
+                    node.value = childNode.value || partialNode.value;
+                    if (node.value) this.cache.set(node.value, node);
+                    // The partial node may have specified a type for the child in order to specify a constraint.
+                    // Verify that the full node that was built recursively matches this type.
+                    if (partialNode.type && node.type !== partialNode.type) throw new Error(`Unsupported type <${$eb2240fc39a57fa5$var$capitalize(node.type)}> in <${$eb2240fc39a57fa5$var$capitalize(parentNode.type)}>. Only <${$eb2240fc39a57fa5$var$capitalize(partialNode.type)}> is supported.`);
+                    index++;
+                    yield node;
+                }
+                result = childNodes.next(children);
+            }
+            return;
+        }
+        // Ignore invalid elements
+        if (partialNode.key == null) return;
+        // Create full node
+        let builder = this;
+        let node1 = {
+            type: partialNode.type,
+            props: partialNode.props,
+            key: partialNode.key,
+            parentKey: parentNode ? parentNode.key : null,
+            value: partialNode.value,
+            level: parentNode ? parentNode.level + 1 : 0,
+            index: partialNode.index,
+            rendered: partialNode.rendered,
+            textValue: partialNode.textValue,
+            "aria-label": partialNode["aria-label"],
+            wrapper: partialNode.wrapper,
+            shouldInvalidate: partialNode.shouldInvalidate,
+            hasChildNodes: partialNode.hasChildNodes,
+            childNodes: $eb2240fc39a57fa5$var$iterable(function*() {
+                if (!partialNode.hasChildNodes) return;
+                let index = 0;
+                for (let child of partialNode.childNodes()){
+                    // Ensure child keys are globally unique by prepending the parent node's key
+                    if (child.key != null) // TODO: Remove this line entirely and enforce that users always provide unique keys.
+                    // Currently this line will have issues when a parent has a key `a` and a child with key `bc`
+                    // but another parent has key `ab` and its child has a key `c`. The combined keys would result in both
+                    // children having a key of `abc`.
+                    child.key = `${node1.key}${child.key}`;
+                    child.index = index;
+                    let nodes = builder.getFullNode(child, builder.getChildState(state, child), node1.key, node1);
+                    for (let node of nodes){
+                        index++;
+                        yield node;
+                    }
+                }
+            })
+        };
+        yield node1;
+    }
+    constructor(){
+        (0, $tyW6A$swchelperssrc_define_propertymjs)(this, "cache", new WeakMap());
+    }
+}
+// Wraps an iterator function as an iterable object, and caches the results.
+function $eb2240fc39a57fa5$var$iterable(iterator) {
+    let cache = [];
+    let iterable = null;
+    return {
+        *[Symbol.iterator] () {
+            for (let item of cache)yield item;
+            if (!iterable) iterable = iterator();
+            for (let item1 of iterable){
+                cache.push(item1);
+                yield item1;
+            }
+        }
+    };
+}
+function $eb2240fc39a57fa5$var$compose(outer, inner) {
+    if (outer && inner) return (element)=>outer(inner(element));
+    if (outer) return outer;
+    if (inner) return inner;
+}
+function $eb2240fc39a57fa5$var$capitalize(str) {
+    return str[0].toUpperCase() + str.slice(1);
+}
+
+
+
+function $7613b1592d41b092$export$6cd28814d92fa9c9(props, factory, context, invalidators = []) {
+    let builder = (0, $tyW6A$useMemo)(()=>new (0, $eb2240fc39a57fa5$export$bf788dd355e3a401)(), []);
+    let prev = (0, $tyW6A$useRef)(null);
+    return (0, $tyW6A$useMemo)(()=>{
+        let nodes = builder.build(props, context);
+        prev.current = factory(nodes, prev.current);
+        return prev.current;
+    // Don't invalidate when any prop changes, just the two we care about.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        builder,
+        props.children,
+        props.items,
+        context,
+        ...invalidators
+    ]);
+}
+
+
+/*
+ * 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.
+ */ const $453cc9f0df89c0a5$var$cache = new WeakMap();
+function $453cc9f0df89c0a5$export$77d5aafae4e095b2(collection) {
+    let count = $453cc9f0df89c0a5$var$cache.get(collection);
+    if (count != null) return count;
+    count = 0;
+    for (let item of collection)if (item.type === "section") count += $453cc9f0df89c0a5$export$77d5aafae4e095b2(item.childNodes);
+    else count++;
+    $453cc9f0df89c0a5$var$cache.set(collection, count);
+    return count;
+}
+
+
+
+
+export {$c1d7fb2ec91bae71$export$6d08773d2e66f8f2 as Item, $9fc4852771d079eb$export$6e2c8f0811a474ce as Section, $7613b1592d41b092$export$6cd28814d92fa9c9 as useCollection, $453cc9f0df89c0a5$export$77d5aafae4e095b2 as getItemCount};
+//# sourceMappingURL=module.js.map

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "@react-stately/collections",
-  "version": "3.5.1",
+  "version": "3.6.0",
   "description": "Spectrum UI components in React",
   "license": "Apache-2.0",
   "main": "dist/main.js",
   "module": "dist/module.js",
+  "exports": {
+    "types": "./dist/types.d.ts",
+    "import": "./dist/import.mjs",
+    "require": "./dist/main.js"
+  },
   "types": "dist/types.d.ts",
   "source": "src/index.ts",
   "files": [
@@ -17,7 +22,7 @@
     "url": "https://github.com/adobe/react-spectrum"
   },
   "dependencies": {
-    "@react-types/shared": "^3.16.0",
+    "@react-types/shared": "^3.17.0",
     "@swc/helpers": "^0.4.14"
   },
   "peerDependencies": {
@@ -26,5 +31,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5480d76bd815e239366f92852c76b6831ad2a4fd"
+  "gitHead": "a0efee84aa178cb1a202951dfd6d8de02b292307"
 }