@react-stately/selection 3.7.0 → 3.9.2

package/dist/module.js

@@ -1,532 +1,372 @@
-import { useControlledState } from "@react-stately/utils";
-import { useMemo, useRef, useState } 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.
- */
-
-/**
- * A Selection is a special Set containing Keys, which also has an anchor
- * and current selected key for use when range selecting.
- */
-class $c91e86e24f2dc9a2182dcc2674c58c$export$Selection extends Set {
-  constructor(keys, anchorKey, currentKey) {
-    super(keys);
-    this.anchorKey = void 0;
-    this.currentKey = void 0;
-
-    if (keys instanceof $c91e86e24f2dc9a2182dcc2674c58c$export$Selection) {
-      this.anchorKey = anchorKey || keys.anchorKey;
-      this.currentKey = currentKey || keys.currentKey;
-    } else {
-      this.anchorKey = anchorKey;
-      this.currentKey = currentKey;
-    }
-  }
+import {useRef as $f0goU$useRef, useState as $f0goU$useState, useMemo as $f0goU$useMemo} from "react";
+import {useControlledState as $f0goU$useControlledState} from "@react-stately/utils";
 
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+var $ec35bdc00c823be9$exports = {};
+
+$parcel$export($ec35bdc00c823be9$exports, "useMultipleSelectionState", () => $ec35bdc00c823be9$export$253fe78d46329472);
+
+class $84eb7a4250035b1f$export$52baac22726c72bf extends Set {
+    constructor(keys, anchorKey, currentKey){
+        super(keys);
+        if (keys instanceof $84eb7a4250035b1f$export$52baac22726c72bf) {
+            this.anchorKey = anchorKey || keys.anchorKey;
+            this.currentKey = currentKey || keys.currentKey;
+        } else {
+            this.anchorKey = anchorKey;
+            this.currentKey = currentKey;
+        }
+    }
 }
 
-/**
- * Manages state for multiple selection and focus in a collection.
- */
-export function useMultipleSelectionState(props) {
-  let {
-    selectionMode = 'none',
-    disallowEmptySelection
-  } = props; // We want synchronous updates to `isFocused` and `focusedKey` after their setters are called.
-  // But we also need to trigger a react re-render. So, we have both a ref (sync) and state (async).
-
-  let isFocusedRef = useRef(false);
-  let [, setFocused] = useState(false);
-  let focusedKeyRef = useRef(null);
-  let childFocusStrategyRef = useRef(null);
-  let [, setFocusedKey] = useState(null);
-  let selectedKeysProp = useMemo(() => $c86d35e876e048ac11515eee40c7$var$convertSelection(props.selectedKeys), [props.selectedKeys]);
-  let defaultSelectedKeys = useMemo(() => $c86d35e876e048ac11515eee40c7$var$convertSelection(props.defaultSelectedKeys, new $c91e86e24f2dc9a2182dcc2674c58c$export$Selection()), [props.defaultSelectedKeys]);
-  let [selectedKeys, setSelectedKeys] = useControlledState(selectedKeysProp, defaultSelectedKeys, props.onSelectionChange);
-  let disabledKeysProp = useMemo(() => props.disabledKeys ? new Set(props.disabledKeys) : new Set(), [props.disabledKeys]);
-  return {
-    selectionMode,
-    disallowEmptySelection,
-
-    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) {
-      if (childFocusStrategy === void 0) {
-        childFocusStrategy = 'first';
-      }
 
-      focusedKeyRef.current = k;
-      childFocusStrategyRef.current = childFocusStrategy;
-      setFocusedKey(k);
-    },
 
-    selectedKeys,
-    setSelectedKeys,
-    disabledKeys: disabledKeysProp
-  };
+function $ec35bdc00c823be9$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 $c86d35e876e048ac11515eee40c7$var$convertSelection(selection, defaultValue) {
-  if (!selection) {
-    return defaultValue;
-  }
-
-  return selection === 'all' ? 'all' : new $c91e86e24f2dc9a2182dcc2674c58c$export$Selection(selection);
+function $ec35bdc00c823be9$export$253fe78d46329472(props) {
+    let { selectionMode: selectionMode = 'none' , disallowEmptySelection: disallowEmptySelection , allowDuplicateSelectionEvents: allowDuplicateSelectionEvents  } = props;
+    // We want synchronous updates to `isFocused` and `focusedKey` after their setters are called.
+    // But we also need to trigger a react re-render. So, we have both a ref (sync) and state (async).
+    let isFocusedRef = $f0goU$useRef(false);
+    let [, setFocused] = $f0goU$useState(false);
+    let focusedKeyRef = $f0goU$useRef(null);
+    let childFocusStrategyRef = $f0goU$useRef(null);
+    let [, setFocusedKey] = $f0goU$useState(null);
+    let selectedKeysProp = $f0goU$useMemo(()=>$ec35bdc00c823be9$var$convertSelection(props.selectedKeys)
+    , [
+        props.selectedKeys
+    ]);
+    let defaultSelectedKeys = $f0goU$useMemo(()=>$ec35bdc00c823be9$var$convertSelection(props.defaultSelectedKeys, new $84eb7a4250035b1f$export$52baac22726c72bf())
+    , [
+        props.defaultSelectedKeys
+    ]);
+    let [selectedKeys, setSelectedKeys] = $f0goU$useControlledState(selectedKeysProp, defaultSelectedKeys, props.onSelectionChange);
+    let disabledKeysProp = $f0goU$useMemo(()=>props.disabledKeys ? new Set(props.disabledKeys) : new Set()
+    , [
+        props.disabledKeys
+    ]);
+    let [selectionBehavior, setSelectionBehavior] = $f0goU$useState(props.selectionBehavior || 'toggle');
+    // If the selectionBehavior prop is set to replace, but the current state is toggle (e.g. due to long press
+    // to enter selection mode on touch), and the selection becomes empty, reset the selection behavior.
+    if (props.selectionBehavior === 'replace' && selectionBehavior === 'toggle' && typeof selectedKeys === 'object' && selectedKeys.size === 0) setSelectionBehavior('replace');
+    return {
+        selectionMode: selectionMode,
+        disallowEmptySelection: disallowEmptySelection,
+        selectionBehavior: selectionBehavior,
+        setSelectionBehavior: 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: selectedKeys,
+        setSelectedKeys (keys) {
+            if (allowDuplicateSelectionEvents || !$ec35bdc00c823be9$var$equalSets(keys, selectedKeys)) setSelectedKeys(keys);
+        },
+        disabledKeys: disabledKeysProp
+    };
+}
+function $ec35bdc00c823be9$var$convertSelection(selection, defaultValue) {
+    if (!selection) return defaultValue;
+    return selection === 'all' ? 'all' : new $84eb7a4250035b1f$export$52baac22726c72bf(selection);
 }
 
-/**
- * An interface for reading and updating multiple selection state.
- */
-export class SelectionManager {
-  constructor(collection, state, options) {
-    var _options$allowsCellSe;
 
-    this.collection = void 0;
-    this.state = void 0;
-    this.allowsCellSelection = void 0;
-    this._isSelectAll = void 0;
-    this.collection = collection;
-    this.state = state;
-    this.allowsCellSelection = (_options$allowsCellSe = options == null ? void 0 : options.allowsCellSelection) != null ? _options$allowsCellSe : false;
-    this._isSelectAll = null;
-  }
-  /**
-   * The type of selection that is allowed in the collection.
-   */
+var $1c74ece56c82b9c4$exports = {};
 
+$parcel$export($1c74ece56c82b9c4$exports, "SelectionManager", () => $1c74ece56c82b9c4$export$6c8a5aaad13c9852);
 
-  get selectionMode() {
-    return this.state.selectionMode;
-  }
-  /**
+class $1c74ece56c82b9c4$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;
-  }
-  /**
+   */ 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;
-  }
-  /**
+   */ get isFocused() {
+        return this.state.isFocused;
+    }
+    /**
    * Sets whether the collection is focused.
-   */
-
-
-  setFocused(isFocused) {
-    this.state.setFocused(isFocused);
-  }
-  /**
+   */ 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;
-  }
-  /**
+   */ 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) {
-    this.state.setFocusedKey(key, childFocusStrategy);
-  }
-  /**
+   */ setFocusedKey(key, childFocusStrategy) {
+        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;
-  }
-  /**
+   */ 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;
-  }
-  /**
+   */ get rawSelection() {
+        return this.state.selectedKeys;
+    }
+    /**
    * Returns whether a key is selected.
-   */
-
-
-  isSelected(key) {
-    if (this.state.selectionMode === 'none') {
-      return false;
+   */ isSelected(key) {
+        if (this.state.selectionMode === 'none') return false;
+        key = this.getKey(key);
+        return this.state.selectedKeys === 'all' ? !this.state.disabledKeys.has(key) : this.state.selectedKeys.has(key);
     }
-
-    key = this.getKey(key);
-    return this.state.selectedKeys === 'all' ? !this.state.disabledKeys.has(key) : this.state.selectedKeys.has(key);
-  }
-  /**
+    /**
    * 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;
+   */ get isEmpty() {
+        return this.state.selectedKeys !== 'all' && this.state.selectedKeys.size === 0;
     }
-
-    if (this._isSelectAll != null) {
-      return this._isSelectAll;
+    /**
+   * 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;
     }
-
-    let allKeys = this.getSelectAllKeys();
-    let selectedKeys = this.state.selectedKeys;
-    this._isSelectAll = allKeys.every(k => selectedKeys.has(k));
-    return this._isSelectAll;
-  }
-
-  get firstSelectedKey() {
-    var _first;
-
-    let first = null;
-
-    for (let key of this.state.selectedKeys) {
-      let item = this.collection.getItem(key);
-
-      if (!first || (item == null ? void 0 : item.index) < first.index) {
-        first = item;
-      }
+    get firstSelectedKey() {
+        let first = null;
+        for (let key of this.state.selectedKeys){
+            let item = this.collection.getItem(key);
+            if (!first || (item === null || item === void 0 ? void 0 : item.index) < first.index) first = item;
+        }
+        return first === null || first === void 0 ? void 0 : first.key;
     }
-
-    return (_first = first) == null ? void 0 : _first.key;
-  }
-
-  get lastSelectedKey() {
-    var _last;
-
-    let last = null;
-
-    for (let key of this.state.selectedKeys) {
-      let item = this.collection.getItem(key);
-
-      if (!last || (item == null ? void 0 : item.index) > last.index) {
-        last = item;
-      }
+    get lastSelectedKey() {
+        let last = null;
+        for (let key of this.state.selectedKeys){
+            let item = this.collection.getItem(key);
+            if (!last || (item === null || item === void 0 ? void 0 : item.index) > last.index) last = item;
+        }
+        return last === null || last === void 0 ? void 0 : last.key;
     }
-
-    return (_last = last) == null ? void 0 : _last.key;
-  }
-  /**
+    /**
    * Extends the selection to the given key.
-   */
-
-
-  extendSelection(toKey) {
-    toKey = this.getKey(toKey);
-    let selection; // Only select the one key if coming from a select all.
-
-    if (this.state.selectedKeys === 'all') {
-      selection = new $c91e86e24f2dc9a2182dcc2674c58c$export$Selection([toKey], toKey, toKey);
-    } else {
-      let selectedKeys = this.state.selectedKeys;
-      let anchorKey = selectedKeys.anchorKey || toKey;
-      selection = new $c91e86e24f2dc9a2182dcc2674c58c$export$Selection(selectedKeys, anchorKey, toKey);
-
-      for (let key of this.getKeyRange(anchorKey, selectedKeys.currentKey || toKey)) {
-        selection.delete(key);
-      }
-
-      for (let key of this.getKeyRange(toKey, anchorKey)) {
-        if (!this.state.disabledKeys.has(key)) {
-          selection.add(key);
+   */ extendSelection(toKey) {
+        if (this.selectionMode === 'none') return;
+        if (this.selectionMode === 'single') {
+            this.replaceSelection(toKey);
+            return;
         }
-      }
-    }
-
-    this.state.setSelectedKeys(selection);
-  }
-
-  getKeyRange(from, to) {
-    let fromItem = this.collection.getItem(from);
-    let toItem = this.collection.getItem(to);
-
-    if (fromItem && toItem) {
-      if (fromItem.index <= toItem.index) {
-        return this.getKeyRangeInternal(from, to);
-      }
-
-      return this.getKeyRangeInternal(to, from);
+        toKey = this.getKey(toKey);
+        let selection;
+        // Only select the one key if coming from a select all.
+        if (this.state.selectedKeys === 'all') selection = new $84eb7a4250035b1f$export$52baac22726c72bf([
+            toKey
+        ], toKey, toKey);
+        else {
+            let selectedKeys = this.state.selectedKeys;
+            let anchorKey = selectedKeys.anchorKey || toKey;
+            selection = new $84eb7a4250035b1f$export$52baac22726c72bf(selectedKeys, anchorKey, toKey);
+            for (let key of this.getKeyRange(anchorKey, selectedKeys.currentKey || toKey))selection.delete(key);
+            for (let key1 of this.getKeyRange(toKey, anchorKey))if (!this.state.disabledKeys.has(key1)) selection.add(key1);
+        }
+        this.state.setSelectedKeys(selection);
     }
-
-    return [];
-  }
-
-  getKeyRangeInternal(from, to) {
-    let keys = [];
-    let key = from;
-
-    while (key) {
-      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);
+    getKeyRange(from, to) {
+        let fromItem = this.collection.getItem(from);
+        let toItem = this.collection.getItem(to);
+        if (fromItem && toItem) {
+            if (fromItem.index <= toItem.index) return this.getKeyRangeInternal(from, to);
+            return this.getKeyRangeInternal(to, from);
+        }
+        return [];
     }
-
-    return [];
-  }
-
-  getKey(key) {
-    let item = this.collection.getItem(key);
-
-    if (!item) {
-      // ¯\_(ツ)_/¯
-      return key;
-    } // If cell selection is allowed, just return the key.
-
-
-    if (item.type === 'cell' && this.allowsCellSelection) {
-      return key;
-    } // Find a parent item to select
-
-
-    while (item.type !== 'item' && item.parentKey) {
-      item = this.collection.getItem(item.parentKey);
+    getKeyRangeInternal(from, to) {
+        let keys = [];
+        let key = from;
+        while(key){
+            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 [];
     }
-
-    if (!item || item.type !== 'item') {
-      return null;
+    getKey(key) {
+        let item = this.collection.getItem(key);
+        if (!item) // ¯\_(ツ)_/¯
+        return key;
+        // If cell selection is allowed, just return the key.
+        if (item.type === 'cell' && this.allowsCellSelection) return key;
+        // Find a parent item to select
+        while(item.type !== 'item' && item.parentKey != null)item = this.collection.getItem(item.parentKey);
+        if (!item || item.type !== 'item') return null;
+        return item.key;
     }
-
-    return item.key;
-  }
-  /**
+    /**
    * Toggles whether the given key is selected.
-   */
-
-
-  toggleSelection(key) {
-    key = this.getKey(key);
-
-    if (key == null) {
-      return;
-    }
-
-    let keys = new $c91e86e24f2dc9a2182dcc2674c58c$export$Selection(this.state.selectedKeys === 'all' ? this.getSelectAllKeys() : this.state.selectedKeys);
-
-    if (keys.has(key)) {
-      keys.delete(key); // TODO: move anchor to last selected key...
-      // Does `current` need to move here too?
-    } else {
-      keys.add(key);
-      keys.anchorKey = key;
-      keys.currentKey = key;
-    }
-
-    if (this.disallowEmptySelection && keys.size === 0) {
-      return;
+   */ toggleSelection(key) {
+        if (this.selectionMode === 'none') return;
+        if (this.selectionMode === 'single' && !this.isSelected(key)) {
+            this.replaceSelection(key);
+            return;
+        }
+        key = this.getKey(key);
+        if (key == null) return;
+        let keys = new $84eb7a4250035b1f$export$52baac22726c72bf(this.state.selectedKeys === 'all' ? this.getSelectAllKeys() : this.state.selectedKeys);
+        if (keys.has(key)) keys.delete(key);
+        else {
+            keys.add(key);
+            keys.anchorKey = key;
+            keys.currentKey = key;
+        }
+        if (this.disallowEmptySelection && keys.size === 0) return;
+        this.state.setSelectedKeys(keys);
     }
-
-    this.state.setSelectedKeys(keys);
-  }
-  /**
+    /**
    * Replaces the selection with only the given key.
-   */
-
-
-  replaceSelection(key) {
-    key = this.getKey(key);
-
-    if (key == null) {
-      return;
+   */ replaceSelection(key) {
+        if (this.selectionMode === 'none') return;
+        key = this.getKey(key);
+        if (key == null) return;
+        this.state.setSelectedKeys(new $84eb7a4250035b1f$export$52baac22726c72bf([
+            key
+        ], key, key));
     }
-
-    this.state.setSelectedKeys(new $c91e86e24f2dc9a2182dcc2674c58c$export$Selection([key], key, key));
-  }
-  /**
+    /**
    * Replaces the selection with the given keys.
-   */
-
-
-  setSelectedKeys(keys) {
-    if (this.selectionMode === 'none') {
-      return;
-    }
-
-    let selection = new $c91e86e24f2dc9a2182dcc2674c58c$export$Selection();
-
-    for (let key of keys) {
-      key = this.getKey(key);
-
-      if (key != null) {
-        selection.add(key);
-
-        if (this.selectionMode === 'single') {
-          break;
+   */ setSelectedKeys(keys) {
+        if (this.selectionMode === 'none') return;
+        let selection = new $84eb7a4250035b1f$export$52baac22726c72bf();
+        for (let key of keys){
+            key = this.getKey(key);
+            if (key != null) {
+                selection.add(key);
+                if (this.selectionMode === 'single') break;
+            }
         }
-      }
+        this.state.setSelectedKeys(selection);
     }
-
-    this.state.setSelectedKeys(selection);
-  }
-
-  getSelectAllKeys() {
-    let keys = [];
-
-    let addKeys = key => {
-      while (key) {
-        if (!this.state.disabledKeys.has(key)) {
-          let item = this.collection.getItem(key);
-
-          if (item.type === 'item') {
-            keys.push(key);
-          } // Add child keys. If cell selection is allowed, then include item children too.
-
-
-          if (item.hasChildNodes && (this.allowsCellSelection || item.type !== 'item')) {
-            addKeys([...item.childNodes][0].key);
-          }
-        }
-
-        key = this.collection.getKeyAfter(key);
-      }
-    };
-
-    addKeys(this.collection.getFirstKey());
-    return keys;
-  }
-  /**
+    getSelectAllKeys() {
+        let keys = [];
+        let addKeys = (key)=>{
+            while(key){
+                if (!this.state.disabledKeys.has(key)) {
+                    let item = this.collection.getItem(key);
+                    if (item.type === 'item') keys.push(key);
+                    // Add child keys. If cell selection is allowed, then include item children too.
+                    if (item.hasChildNodes && (this.allowsCellSelection || item.type !== 'item')) addKeys([
+                        ...item.childNodes
+                    ][0].key);
+                }
+                key = this.collection.getKeyAfter(key);
+            }
+        };
+        addKeys(this.collection.getFirstKey());
+        return keys;
+    }
+    /**
    * Selects all items in the collection.
-   */
-
-
-  selectAll() {
-    if (this.selectionMode === 'multiple') {
-      this.state.setSelectedKeys('all');
+   */ selectAll() {
+        if (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 $c91e86e24f2dc9a2182dcc2674c58c$export$Selection());
+   */ clearSelection() {
+        if (!this.disallowEmptySelection && (this.state.selectedKeys === 'all' || this.state.selectedKeys.size > 0)) this.state.setSelectedKeys(new $84eb7a4250035b1f$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;
+   */ toggleSelectAll() {
+        if (this.isSelectAll) this.clearSelection();
+        else this.selectAll();
     }
-
-    if (this.selectionMode === 'single') {
-      if (this.isSelected(key) && !this.disallowEmptySelection) {
+    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')) // if touch or virtual (VO) then we just want to toggle, otherwise it's impossible to multi select because they don't have modifier keys
         this.toggleSelection(key);
-      } else {
-        this.replaceSelection(key);
-      }
-    } else if (e && e.shiftKey) {
-      this.extendSelection(key);
-    } else {
-      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;
-    } // Check if the set of keys match.
-
+   */ isSelectionEqual(selection) {
+        if (selection === this.state.selectedKeys) return true;
+        // Check if the set of keys match.
+        let selectedKeys = this.selectedKeys;
+        if (selection.size !== selectedKeys.size) return false;
+        for (let key of selection){
+            if (!selectedKeys.has(key)) return false;
+        }
+        for (let key2 of selectedKeys){
+            if (!selection.has(key2)) return false;
+        }
+        return true;
+    }
+    canSelectItem(key) {
+        if (this.state.selectionMode === 'none' || this.state.disabledKeys.has(key)) return false;
+        let item = this.collection.getItem(key);
+        if (!item || item.type === 'cell' && !this.allowsCellSelection) return false;
+        return true;
+    }
+    constructor(collection, state, options){
+        this.collection = collection;
+        this.state = state;
+        var ref;
+        this.allowsCellSelection = (ref = options === null || options === void 0 ? void 0 : options.allowsCellSelection) !== null && ref !== void 0 ? ref : false;
+        this._isSelectAll = null;
+    }
+}
 
-    let selectedKeys = this.selectedKeys;
 
-    if (selection.size !== selectedKeys.size) {
-      return false;
-    }
+var $8702775bc7287a50$exports = {};
 
-    for (let key of selection) {
-      if (!selectedKeys.has(key)) {
-        return false;
-      }
-    }
 
-    for (let key of selectedKeys) {
-      if (!selection.has(key)) {
-        return false;
-      }
-    }
 
-    return true;
-  }
 
-}
+export {$ec35bdc00c823be9$export$253fe78d46329472 as useMultipleSelectionState, $1c74ece56c82b9c4$export$6c8a5aaad13c9852 as SelectionManager};
 //# sourceMappingURL=module.js.map