@easypost/easy-ui 1.0.0-alpha.7 → 1.0.0-alpha.71

package/__chunks__/SelectionManager-DuX6geJg.js

@@ -0,0 +1,707 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+const React = require("react");
+const useControlledState = require("./useControlledState-mnKBd6Uc.js");
+class $eb2240fc39a57fa5$export$bf788dd355e3a401 {
+  build(props, context) {
+    this.context = context;
+    return $eb2240fc39a57fa5$var$iterable(() => this.iterateCollection(props));
+  }
+  *iterateCollection(props) {
+    let { children, items } = props;
+    if (React.isValidElement(children) && children.type === React.Fragment) yield* __yieldStar(this.iterateCollection({
+      children: children.props.children,
+      items
+    }));
+    else if (typeof children === "function") {
+      if (!items) throw new Error("props.children was a function but props.items is missing");
+      let index = 0;
+      for (let item of items) {
+        yield* __yieldStar(this.getFullNode({
+          value: item,
+          index
+        }, {
+          renderer: children
+        }));
+        index++;
+      }
+    } else {
+      let items2 = [];
+      React.Children.forEach(children, (child) => {
+        if (child) items2.push(child);
+      });
+      let index = 0;
+      for (let item of items2) {
+        let nodes = this.getFullNode({
+          element: item,
+          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 (React.isValidElement(partialNode.element) && partialNode.element.type === React.Fragment) {
+      let children = [];
+      React.Children.forEach(partialNode.element.props.children, (child) => {
+        children.push(child);
+      });
+      var _partialNode_index;
+      let index = (_partialNode_index = partialNode.index) !== null && _partialNode_index !== void 0 ? _partialNode_index : 0;
+      for (const child of children) yield* __yieldStar(this.getFullNode({
+        element: child,
+        index: index++
+      }, state, parentKey, parentNode));
+      return;
+    }
+    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 (React.isValidElement(element)) {
+      let type = element.type;
+      if (typeof type !== "function" && typeof type.getCollectionNode !== "function") {
+        let name = element.type;
+        throw new Error(`Unknown element <${name}> in collection.`);
+      }
+      let childNodes = type.getCollectionNode(element.props, this.context);
+      var _partialNode_index1;
+      let index = (_partialNode_index1 = partialNode.index) !== null && _partialNode_index1 !== void 0 ? _partialNode_index1 : 0;
+      let result = childNodes.next();
+      while (!result.done && result.value) {
+        let childNode = result.value;
+        partialNode.index = index;
+        var _childNode_key;
+        let nodeKey = (_childNode_key = childNode.key) !== null && _childNode_key !== void 0 ? _childNode_key : null;
+        if (nodeKey == null) nodeKey = childNode.element ? null : this.getKey(element, partialNode, state, parentKey);
+        let nodes = this.getFullNode(__spreadProps(__spreadValues({}, childNode), {
+          key: nodeKey,
+          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 node2 of children) {
+          var _childNode_value, _ref;
+          node2.value = (_ref = (_childNode_value = childNode.value) !== null && _childNode_value !== void 0 ? _childNode_value : partialNode.value) !== null && _ref !== void 0 ? _ref : null;
+          if (node2.value) this.cache.set(node2.value, node2);
+          var _parentNode_type;
+          if (partialNode.type && node2.type !== partialNode.type) throw new Error(`Unsupported type <${$eb2240fc39a57fa5$var$capitalize(node2.type)}> in <${$eb2240fc39a57fa5$var$capitalize((_parentNode_type = parentNode === null || parentNode === void 0 ? void 0 : parentNode.type) !== null && _parentNode_type !== void 0 ? _parentNode_type : "unknown parent type")}>. Only <${$eb2240fc39a57fa5$var$capitalize(partialNode.type)}> is supported.`);
+          index++;
+          yield node2;
+        }
+        result = childNodes.next(children);
+      }
+      return;
+    }
+    if (partialNode.key == null || partialNode.type == null) return;
+    let builder = this;
+    var _partialNode_value, _partialNode_textValue;
+    let node = {
+      type: partialNode.type,
+      props: partialNode.props,
+      key: partialNode.key,
+      parentKey: parentNode ? parentNode.key : null,
+      value: (_partialNode_value = partialNode.value) !== null && _partialNode_value !== void 0 ? _partialNode_value : null,
+      level: parentNode ? parentNode.level + 1 : 0,
+      index: partialNode.index,
+      rendered: partialNode.rendered,
+      textValue: (_partialNode_textValue = partialNode.textValue) !== null && _partialNode_textValue !== void 0 ? _partialNode_textValue : "",
+      "aria-label": partialNode["aria-label"],
+      wrapper: partialNode.wrapper,
+      shouldInvalidate: partialNode.shouldInvalidate,
+      hasChildNodes: partialNode.hasChildNodes || false,
+      childNodes: $eb2240fc39a57fa5$var$iterable(function* () {
+        if (!partialNode.hasChildNodes || !partialNode.childNodes) return;
+        let index = 0;
+        for (let child of partialNode.childNodes()) {
+          if (child.key != null)
+            child.key = `${node.key}${child.key}`;
+          let nodes = builder.getFullNode(__spreadProps(__spreadValues({}, child), {
+            index
+          }), builder.getChildState(state, child), node.key, node);
+          for (let node2 of nodes) {
+            index++;
+            yield node2;
+          }
+        }
+      })
+    };
+    yield node;
+  }
+  constructor() {
+    this.cache = /* @__PURE__ */ new WeakMap();
+  }
+}
+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 item of iterable) {
+        cache.push(item);
+        yield item;
+      }
+    }
+  };
+}
+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) {
+  let builder = React.useMemo(() => new $eb2240fc39a57fa5$export$bf788dd355e3a401(), []);
+  let { children, items, collection } = props;
+  let result = React.useMemo(() => {
+    if (collection) return collection;
+    let nodes = builder.build({
+      children,
+      items
+    }, context);
+    return factory(nodes);
+  }, [
+    builder,
+    children,
+    items,
+    collection,
+    context,
+    factory
+  ]);
+  return result;
+}
+function $c5a24bc478652b5f$export$1005530eda016c13(node, collection) {
+  if (typeof collection.getChildren === "function") return collection.getChildren(node.key);
+  return node.childNodes;
+}
+function $c5a24bc478652b5f$export$fbdeaa6a76694f71(iterable) {
+  return $c5a24bc478652b5f$export$5f3398f8733f90e2(iterable, 0);
+}
+function $c5a24bc478652b5f$export$5f3398f8733f90e2(iterable, index) {
+  if (index < 0) return void 0;
+  let i = 0;
+  for (let item of iterable) {
+    if (i === index) return item;
+    i++;
+  }
+}
+function $c5a24bc478652b5f$export$7475b2c64539e4cf(iterable) {
+  let lastItem = void 0;
+  for (let value of iterable) lastItem = value;
+  return lastItem;
+}
+function $c5a24bc478652b5f$export$8c434b3a7a4dad6(collection, a, b) {
+  if (a.parentKey === b.parentKey) return a.index - b.index;
+  let aAncestors = [
+    ...$c5a24bc478652b5f$var$getAncestors(collection, a),
+    a
+  ];
+  let bAncestors = [
+    ...$c5a24bc478652b5f$var$getAncestors(collection, b),
+    b
+  ];
+  let firstNonMatchingAncestor = aAncestors.slice(0, bAncestors.length).findIndex((a2, i) => a2 !== bAncestors[i]);
+  if (firstNonMatchingAncestor !== -1) {
+    a = aAncestors[firstNonMatchingAncestor];
+    b = bAncestors[firstNonMatchingAncestor];
+    return a.index - b.index;
+  }
+  if (aAncestors.findIndex((node) => node === b) >= 0) return 1;
+  else if (bAncestors.findIndex((node) => node === a) >= 0) return -1;
+  return -1;
+}
+function $c5a24bc478652b5f$var$getAncestors(collection, node) {
+  let parents = [];
+  let currNode = node;
+  while ((currNode === null || currNode === void 0 ? void 0 : currNode.parentKey) != null) {
+    currNode = collection.getItem(currNode.parentKey);
+    if (currNode) parents.unshift(currNode);
+  }
+  return parents;
+}
+class $e40ea825a81a3709$export$52baac22726c72bf extends Set {
+  constructor(keys, anchorKey, currentKey) {
+    super(keys);
+    if (keys instanceof $e40ea825a81a3709$export$52baac22726c72bf) {
+      this.anchorKey = anchorKey !== null && anchorKey !== void 0 ? anchorKey : keys.anchorKey;
+      this.currentKey = currentKey !== null && currentKey !== void 0 ? currentKey : keys.currentKey;
+    } else {
+      this.anchorKey = anchorKey !== null && anchorKey !== void 0 ? anchorKey : null;
+      this.currentKey = currentKey !== null && currentKey !== void 0 ? currentKey : null;
+    }
+  }
+}
+function $7af3f5b51489e0b5$var$equalSets(setA, setB) {
+  if (setA.size !== setB.size) return false;
+  for (let item of setA) {
+    if (!setB.has(item)) return false;
+  }
+  return true;
+}
+function $7af3f5b51489e0b5$export$253fe78d46329472(props) {
+  let { selectionMode = "none", disallowEmptySelection = false, allowDuplicateSelectionEvents, selectionBehavior: selectionBehaviorProp = "toggle", disabledBehavior = "all" } = props;
+  let isFocusedRef = React.useRef(false);
+  let [, setFocused] = React.useState(false);
+  let focusedKeyRef = React.useRef(null);
+  let childFocusStrategyRef = React.useRef(null);
+  let [, setFocusedKey] = React.useState(null);
+  let selectedKeysProp = React.useMemo(() => $7af3f5b51489e0b5$var$convertSelection(props.selectedKeys), [
+    props.selectedKeys
+  ]);
+  let defaultSelectedKeys = React.useMemo(() => $7af3f5b51489e0b5$var$convertSelection(props.defaultSelectedKeys, new $e40ea825a81a3709$export$52baac22726c72bf()), [
+    props.defaultSelectedKeys
+  ]);
+  let [selectedKeys, setSelectedKeys] = useControlledState.$458b0a5536c1a7cf$export$40bfa8c7b0832715(selectedKeysProp, defaultSelectedKeys, props.onSelectionChange);
+  let disabledKeysProp = React.useMemo(() => props.disabledKeys ? new Set(props.disabledKeys) : /* @__PURE__ */ new Set(), [
+    props.disabledKeys
+  ]);
+  let [selectionBehavior, setSelectionBehavior] = React.useState(selectionBehaviorProp);
+  if (selectionBehaviorProp === "replace" && selectionBehavior === "toggle" && typeof selectedKeys === "object" && selectedKeys.size === 0) setSelectionBehavior("replace");
+  let lastSelectionBehavior = React.useRef(selectionBehaviorProp);
+  React.useEffect(() => {
+    if (selectionBehaviorProp !== lastSelectionBehavior.current) {
+      setSelectionBehavior(selectionBehaviorProp);
+      lastSelectionBehavior.current = selectionBehaviorProp;
+    }
+  }, [
+    selectionBehaviorProp
+  ]);
+  return {
+    selectionMode,
+    disallowEmptySelection,
+    selectionBehavior,
+    setSelectionBehavior,
+    get isFocused() {
+      return isFocusedRef.current;
+    },
+    setFocused(f) {
+      isFocusedRef.current = f;
+      setFocused(f);
+    },
+    get focusedKey() {
+      return focusedKeyRef.current;
+    },
+    get childFocusStrategy() {
+      return childFocusStrategyRef.current;
+    },
+    setFocusedKey(k, childFocusStrategy = "first") {
+      focusedKeyRef.current = k;
+      childFocusStrategyRef.current = childFocusStrategy;
+      setFocusedKey(k);
+    },
+    selectedKeys,
+    setSelectedKeys(keys) {
+      if (allowDuplicateSelectionEvents || !$7af3f5b51489e0b5$var$equalSets(keys, selectedKeys)) setSelectedKeys(keys);
+    },
+    disabledKeys: disabledKeysProp,
+    disabledBehavior
+  };
+}
+function $7af3f5b51489e0b5$var$convertSelection(selection, defaultValue) {
+  if (!selection) return defaultValue;
+  return selection === "all" ? "all" : new $e40ea825a81a3709$export$52baac22726c72bf(selection);
+}
+class $d496c0a20b6e58ec$export$6c8a5aaad13c9852 {
+  /**
+  * The type of selection that is allowed in the collection.
+  */
+  get selectionMode() {
+    return this.state.selectionMode;
+  }
+  /**
+  * Whether the collection allows empty selection.
+  */
+  get disallowEmptySelection() {
+    return this.state.disallowEmptySelection;
+  }
+  /**
+  * The selection behavior for the collection.
+  */
+  get selectionBehavior() {
+    return this.state.selectionBehavior;
+  }
+  /**
+  * Sets the selection behavior for the collection.
+  */
+  setSelectionBehavior(selectionBehavior) {
+    this.state.setSelectionBehavior(selectionBehavior);
+  }
+  /**
+  * Whether the collection is currently focused.
+  */
+  get isFocused() {
+    return this.state.isFocused;
+  }
+  /**
+  * Sets whether the collection is focused.
+  */
+  setFocused(isFocused) {
+    this.state.setFocused(isFocused);
+  }
+  /**
+  * The current focused key in the collection.
+  */
+  get focusedKey() {
+    return this.state.focusedKey;
+  }
+  /** Whether the first or last child of the focused key should receive focus. */
+  get childFocusStrategy() {
+    return this.state.childFocusStrategy;
+  }
+  /**
+  * Sets the focused key.
+  */
+  setFocusedKey(key, childFocusStrategy) {
+    if (key == null || this.collection.getItem(key)) this.state.setFocusedKey(key, childFocusStrategy);
+  }
+  /**
+  * The currently selected keys in the collection.
+  */
+  get selectedKeys() {
+    return this.state.selectedKeys === "all" ? new Set(this.getSelectAllKeys()) : this.state.selectedKeys;
+  }
+  /**
+  * The raw selection value for the collection.
+  * Either 'all' for select all, or a set of keys.
+  */
+  get rawSelection() {
+    return this.state.selectedKeys;
+  }
+  /**
+  * Returns whether a key is selected.
+  */
+  isSelected(key) {
+    if (this.state.selectionMode === "none") return false;
+    let mappedKey = this.getKey(key);
+    if (mappedKey == null) return false;
+    return this.state.selectedKeys === "all" ? this.canSelectItem(mappedKey) : this.state.selectedKeys.has(mappedKey);
+  }
+  /**
+  * Whether the selection is empty.
+  */
+  get isEmpty() {
+    return this.state.selectedKeys !== "all" && this.state.selectedKeys.size === 0;
+  }
+  /**
+  * Whether all items in the collection are selected.
+  */
+  get isSelectAll() {
+    if (this.isEmpty) return false;
+    if (this.state.selectedKeys === "all") return true;
+    if (this._isSelectAll != null) return this._isSelectAll;
+    let allKeys = this.getSelectAllKeys();
+    let selectedKeys = this.state.selectedKeys;
+    this._isSelectAll = allKeys.every((k) => selectedKeys.has(k));
+    return this._isSelectAll;
+  }
+  get firstSelectedKey() {
+    let first = null;
+    for (let key of this.state.selectedKeys) {
+      let item = this.collection.getItem(key);
+      if (!first || item && $c5a24bc478652b5f$export$8c434b3a7a4dad6(this.collection, item, first) < 0) first = item;
+    }
+    var _first_key;
+    return (_first_key = first === null || first === void 0 ? void 0 : first.key) !== null && _first_key !== void 0 ? _first_key : null;
+  }
+  get lastSelectedKey() {
+    let last = null;
+    for (let key of this.state.selectedKeys) {
+      let item = this.collection.getItem(key);
+      if (!last || item && $c5a24bc478652b5f$export$8c434b3a7a4dad6(this.collection, item, last) > 0) last = item;
+    }
+    var _last_key;
+    return (_last_key = last === null || last === void 0 ? void 0 : last.key) !== null && _last_key !== void 0 ? _last_key : null;
+  }
+  get disabledKeys() {
+    return this.state.disabledKeys;
+  }
+  get disabledBehavior() {
+    return this.state.disabledBehavior;
+  }
+  /**
+  * Extends the selection to the given key.
+  */
+  extendSelection(toKey) {
+    if (this.selectionMode === "none") return;
+    if (this.selectionMode === "single") {
+      this.replaceSelection(toKey);
+      return;
+    }
+    let mappedToKey = this.getKey(toKey);
+    if (mappedToKey == null) return;
+    let selection;
+    if (this.state.selectedKeys === "all") selection = new $e40ea825a81a3709$export$52baac22726c72bf([
+      mappedToKey
+    ], mappedToKey, mappedToKey);
+    else {
+      let selectedKeys = this.state.selectedKeys;
+      var _selectedKeys_anchorKey;
+      let anchorKey = (_selectedKeys_anchorKey = selectedKeys.anchorKey) !== null && _selectedKeys_anchorKey !== void 0 ? _selectedKeys_anchorKey : mappedToKey;
+      selection = new $e40ea825a81a3709$export$52baac22726c72bf(selectedKeys, anchorKey, mappedToKey);
+      var _selectedKeys_currentKey;
+      for (let key of this.getKeyRange(anchorKey, (_selectedKeys_currentKey = selectedKeys.currentKey) !== null && _selectedKeys_currentKey !== void 0 ? _selectedKeys_currentKey : mappedToKey)) selection.delete(key);
+      for (let key of this.getKeyRange(mappedToKey, anchorKey)) if (this.canSelectItem(key)) selection.add(key);
+    }
+    this.state.setSelectedKeys(selection);
+  }
+  getKeyRange(from, to) {
+    let fromItem = this.collection.getItem(from);
+    let toItem = this.collection.getItem(to);
+    if (fromItem && toItem) {
+      if ($c5a24bc478652b5f$export$8c434b3a7a4dad6(this.collection, fromItem, toItem) <= 0) return this.getKeyRangeInternal(from, to);
+      return this.getKeyRangeInternal(to, from);
+    }
+    return [];
+  }
+  getKeyRangeInternal(from, to) {
+    var _this_layoutDelegate;
+    if ((_this_layoutDelegate = this.layoutDelegate) === null || _this_layoutDelegate === void 0 ? void 0 : _this_layoutDelegate.getKeyRange) return this.layoutDelegate.getKeyRange(from, to);
+    let keys = [];
+    let key = from;
+    while (key != null) {
+      let item = this.collection.getItem(key);
+      if (item && (item.type === "item" || item.type === "cell" && this.allowsCellSelection)) keys.push(key);
+      if (key === to) return keys;
+      key = this.collection.getKeyAfter(key);
+    }
+    return [];
+  }
+  getKey(key) {
+    let item = this.collection.getItem(key);
+    if (!item)
+      return key;
+    if (item.type === "cell" && this.allowsCellSelection) return key;
+    while (item && item.type !== "item" && item.parentKey != null) item = this.collection.getItem(item.parentKey);
+    if (!item || item.type !== "item") return null;
+    return item.key;
+  }
+  /**
+  * Toggles whether the given key is selected.
+  */
+  toggleSelection(key) {
+    if (this.selectionMode === "none") return;
+    if (this.selectionMode === "single" && !this.isSelected(key)) {
+      this.replaceSelection(key);
+      return;
+    }
+    let mappedKey = this.getKey(key);
+    if (mappedKey == null) return;
+    let keys = new $e40ea825a81a3709$export$52baac22726c72bf(this.state.selectedKeys === "all" ? this.getSelectAllKeys() : this.state.selectedKeys);
+    if (keys.has(mappedKey)) keys.delete(mappedKey);
+    else if (this.canSelectItem(mappedKey)) {
+      keys.add(mappedKey);
+      keys.anchorKey = mappedKey;
+      keys.currentKey = mappedKey;
+    }
+    if (this.disallowEmptySelection && keys.size === 0) return;
+    this.state.setSelectedKeys(keys);
+  }
+  /**
+  * Replaces the selection with only the given key.
+  */
+  replaceSelection(key) {
+    if (this.selectionMode === "none") return;
+    let mappedKey = this.getKey(key);
+    if (mappedKey == null) return;
+    let selection = this.canSelectItem(mappedKey) ? new $e40ea825a81a3709$export$52baac22726c72bf([
+      mappedKey
+    ], mappedKey, mappedKey) : new $e40ea825a81a3709$export$52baac22726c72bf();
+    this.state.setSelectedKeys(selection);
+  }
+  /**
+  * Replaces the selection with the given keys.
+  */
+  setSelectedKeys(keys) {
+    if (this.selectionMode === "none") return;
+    let selection = new $e40ea825a81a3709$export$52baac22726c72bf();
+    for (let key of keys) {
+      let mappedKey = this.getKey(key);
+      if (mappedKey != null) {
+        selection.add(mappedKey);
+        if (this.selectionMode === "single") break;
+      }
+    }
+    this.state.setSelectedKeys(selection);
+  }
+  getSelectAllKeys() {
+    let keys = [];
+    let addKeys = (key) => {
+      while (key != null) {
+        if (this.canSelectItem(key)) {
+          var _getFirstItem;
+          let item = this.collection.getItem(key);
+          if ((item === null || item === void 0 ? void 0 : item.type) === "item") keys.push(key);
+          var _getFirstItem_key;
+          if ((item === null || item === void 0 ? void 0 : item.hasChildNodes) && (this.allowsCellSelection || item.type !== "item")) addKeys((_getFirstItem_key = (_getFirstItem = $c5a24bc478652b5f$export$fbdeaa6a76694f71($c5a24bc478652b5f$export$1005530eda016c13(item, this.collection))) === null || _getFirstItem === void 0 ? void 0 : _getFirstItem.key) !== null && _getFirstItem_key !== void 0 ? _getFirstItem_key : null);
+        }
+        key = this.collection.getKeyAfter(key);
+      }
+    };
+    addKeys(this.collection.getFirstKey());
+    return keys;
+  }
+  /**
+  * Selects all items in the collection.
+  */
+  selectAll() {
+    if (!this.isSelectAll && this.selectionMode === "multiple") this.state.setSelectedKeys("all");
+  }
+  /**
+  * Removes all keys from the selection.
+  */
+  clearSelection() {
+    if (!this.disallowEmptySelection && (this.state.selectedKeys === "all" || this.state.selectedKeys.size > 0)) this.state.setSelectedKeys(new $e40ea825a81a3709$export$52baac22726c72bf());
+  }
+  /**
+  * Toggles between select all and an empty selection.
+  */
+  toggleSelectAll() {
+    if (this.isSelectAll) this.clearSelection();
+    else this.selectAll();
+  }
+  select(key, e) {
+    if (this.selectionMode === "none") return;
+    if (this.selectionMode === "single") {
+      if (this.isSelected(key) && !this.disallowEmptySelection) this.toggleSelection(key);
+      else this.replaceSelection(key);
+    } else if (this.selectionBehavior === "toggle" || e && (e.pointerType === "touch" || e.pointerType === "virtual"))
+      this.toggleSelection(key);
+    else this.replaceSelection(key);
+  }
+  /**
+  * Returns whether the current selection is equal to the given selection.
+  */
+  isSelectionEqual(selection) {
+    if (selection === this.state.selectedKeys) return true;
+    let selectedKeys = this.selectedKeys;
+    if (selection.size !== selectedKeys.size) return false;
+    for (let key of selection) {
+      if (!selectedKeys.has(key)) return false;
+    }
+    for (let key of selectedKeys) {
+      if (!selection.has(key)) return false;
+    }
+    return true;
+  }
+  canSelectItem(key) {
+    var _item_props;
+    if (this.state.selectionMode === "none" || this.state.disabledKeys.has(key)) return false;
+    let item = this.collection.getItem(key);
+    if (!item || (item === null || item === void 0 ? void 0 : (_item_props = item.props) === null || _item_props === void 0 ? void 0 : _item_props.isDisabled) || item.type === "cell" && !this.allowsCellSelection) return false;
+    return true;
+  }
+  isDisabled(key) {
+    var _this_collection_getItem_props, _this_collection_getItem;
+    return this.state.disabledBehavior === "all" && (this.state.disabledKeys.has(key) || !!((_this_collection_getItem = this.collection.getItem(key)) === null || _this_collection_getItem === void 0 ? void 0 : (_this_collection_getItem_props = _this_collection_getItem.props) === null || _this_collection_getItem_props === void 0 ? void 0 : _this_collection_getItem_props.isDisabled));
+  }
+  isLink(key) {
+    var _this_collection_getItem_props, _this_collection_getItem;
+    return !!((_this_collection_getItem = this.collection.getItem(key)) === null || _this_collection_getItem === void 0 ? void 0 : (_this_collection_getItem_props = _this_collection_getItem.props) === null || _this_collection_getItem_props === void 0 ? void 0 : _this_collection_getItem_props.href);
+  }
+  getItemProps(key) {
+    var _this_collection_getItem;
+    return (_this_collection_getItem = this.collection.getItem(key)) === null || _this_collection_getItem === void 0 ? void 0 : _this_collection_getItem.props;
+  }
+  constructor(collection, state, options) {
+    this.collection = collection;
+    this.state = state;
+    var _options_allowsCellSelection;
+    this.allowsCellSelection = (_options_allowsCellSelection = options === null || options === void 0 ? void 0 : options.allowsCellSelection) !== null && _options_allowsCellSelection !== void 0 ? _options_allowsCellSelection : false;
+    this._isSelectAll = null;
+    this.layoutDelegate = (options === null || options === void 0 ? void 0 : options.layoutDelegate) || null;
+  }
+}
+exports.$7613b1592d41b092$export$6cd28814d92fa9c9 = $7613b1592d41b092$export$6cd28814d92fa9c9;
+exports.$7af3f5b51489e0b5$export$253fe78d46329472 = $7af3f5b51489e0b5$export$253fe78d46329472;
+exports.$c5a24bc478652b5f$export$1005530eda016c13 = $c5a24bc478652b5f$export$1005530eda016c13;
+exports.$c5a24bc478652b5f$export$5f3398f8733f90e2 = $c5a24bc478652b5f$export$5f3398f8733f90e2;
+exports.$c5a24bc478652b5f$export$7475b2c64539e4cf = $c5a24bc478652b5f$export$7475b2c64539e4cf;
+exports.$c5a24bc478652b5f$export$fbdeaa6a76694f71 = $c5a24bc478652b5f$export$fbdeaa6a76694f71;
+exports.$d496c0a20b6e58ec$export$6c8a5aaad13c9852 = $d496c0a20b6e58ec$export$6c8a5aaad13c9852;