@procore/core-react 12.29.0 → 12.31.0

package/dist/SuperSelect/useSuperSelect.js

@@ -3,6 +3,7 @@ function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArra
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
 function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
 function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
@@ -17,7 +18,6 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
 import { autoUpdate, flip, offset, size, useClick, useDismiss, useFloating, useInteractions, useListNavigation } from '@floating-ui/react';
 import { useId } from '@react-aria/utils';
 import debounce from 'lodash.debounce';
-import uniq from 'lodash.uniq';
 import React from 'react';
 import { ulid } from 'ulid';
 import { useI18nContext } from '../_hooks/I18n';
@@ -207,6 +207,32 @@ export function useSuperSelect(_ref3) {
     val = _React$useState2[0],
     setVal = _React$useState2[1];
   var value = value_ !== undefined ? value_ : val;
+
+  /**
+   * Tracks whether the "Select All" feature is currently active.
+   * When true, new options that appear will be automatically selected.
+   * This state is activated when all available options are selected and
+   * deactivated when any option is individually deselected.
+   */
+  var _React$useState3 = React.useState(false),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    isSelectAllActive = _React$useState4[0],
+    setIsSelectAllActive = _React$useState4[1];
+
+  /**
+   * Flag to prevent recursive auto-selection calls during state updates.
+   * Ensures that auto-selection logic doesn't trigger multiple times
+   * concurrently, which could cause performance issues or incorrect state.
+   */
+  var isProcessingAutoSelectionRef = React.useRef(false);
+
+  /**
+   * Stores a snapshot of previously available selectable options as a Map.
+   * Key: JSON stringified option value for fast lookups
+   * Value: The SuperSelectOption object
+   * Used to detect newly added options for auto-selection when Select All is active.
+   */
+  var previousSelectableOptionsRef = React.useRef(new Set());
   function setValue(v) {
     if (!value_) {
       setVal(v);
@@ -215,55 +241,202 @@ export function useSuperSelect(_ref3) {
       onChange(v);
     }
   }
+
+  /**
+   * Extracts all primitive values from an option, handling both single values and batch values.
+   * For batch options (arrays), returns all values flattened into a single array.
+   * For single options, wraps the value in an array for consistent processing.
+   *
+   * @param option - The option to extract values from
+   * @returns Array of primitive values contained in the option
+   */
+  var getOptionValuesFlat = React.useCallback(function (option) {
+    var optionValue = getOptionValue(option);
+    return Array.isArray(optionValue) ? optionValue : [optionValue];
+  }, [getOptionValue]);
+
+  /**
+   * Determines if all selectable options are currently selected.
+   * Uses early termination to improve performance when checking if all selectable options are selected.
+   *
+   * Performance optimizations:
+   * - Early exit if value count is less than options count
+   * - Uses early termination in the validation loop
+   *
+   * @param currentValue - Current selected values array
+   * @param currentSelectableOptions - Array of selectable options to check
+   * @returns true if all selectable options are selected, false otherwise
+   */
+  var checkIfAllSelectableOptionsSelected = React.useCallback(function (currentValue, currentSelectableOptions) {
+    if (!Array.isArray(currentValue) || currentSelectableOptions.length === 0) {
+      return false;
+    }
+
+    // Early exit if values count doesn't match options count
+    if (currentValue.length < currentSelectableOptions.length) {
+      return false;
+    }
+    var valueSet = new Set(currentValue);
+
+    // Use early termination for better performance
+    var _iterator = _createForOfIteratorHelper(currentSelectableOptions),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var option = _step.value;
+        var optionValues = getOptionValuesFlat(option);
+        if (!optionValues.every(function (val) {
+          return valueSet.has(val);
+        })) {
+          return false;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return true;
+  }, [getOptionValuesFlat]);
+
+  /**
+   * Performs automatic selection of newly added options when Select All is active.
+   *
+   * Algorithm:
+   * 1. Compares current options with previous snapshot to find new options
+   * 2. Automatically selects any newly detected options
+   * 3. Implements safeguards against recursive calls
+   *
+   * Performance considerations:
+   * - Single pass to build current options map and detect new ones
+   * - Set-based deduplication for efficient value management
+   *
+   * @param currentSelectableOptions - Current array of selectable options
+   * @param currentValue - Current selected values
+   */
+  var executeAutoSelection = React.useCallback(function (currentSelectableOptions, currentValue) {
+    // Early exit conditions for performance
+    if (!isSelectAllActive || !multiple || !Array.isArray(currentValue) || isProcessingAutoSelectionRef.current) {
+      return;
+    }
+    var currentOptionKeys = new Set();
+    var newlyAddedOptions = [];
+    var _iterator2 = _createForOfIteratorHelper(currentSelectableOptions),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _option = _step2.value;
+        var optionKey = JSON.stringify(getOptionValue(_option));
+        currentOptionKeys.add(optionKey);
+        if (!previousSelectableOptionsRef.current.has(optionKey)) {
+          newlyAddedOptions.push(_option);
+        }
+      }
+
+      // Update reference for next comparison
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    previousSelectableOptionsRef.current = currentOptionKeys;
+
+    // No new options to auto-select
+    if (newlyAddedOptions.length === 0) {
+      return;
+    }
+
+    // Set processing flag to prevent recursive calls
+    isProcessingAutoSelectionRef.current = true;
+    var currentValueSet = new Set(currentValue);
+    var newValuesToAdd = [];
+
+    // Collect new values that aren't already selected
+    for (var _i = 0, _newlyAddedOptions = newlyAddedOptions; _i < _newlyAddedOptions.length; _i++) {
+      var option = _newlyAddedOptions[_i];
+      var optionValues = getOptionValuesFlat(option);
+      var _iterator3 = _createForOfIteratorHelper(optionValues),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _val = _step3.value;
+          if (!currentValueSet.has(_val)) {
+            newValuesToAdd.push(_val);
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+
+    // Only update if there are new values to add
+    if (newValuesToAdd.length > 0) {
+      // Use Set for efficient deduplication
+      var combinedValueSet = new Set([].concat(_toConsumableArray(currentValue), newValuesToAdd));
+      setValue(Array.from(combinedValueSet));
+    }
+
+    // Reset processing flag
+    isProcessingAutoSelectionRef.current = false;
+  }, [isSelectAllActive, multiple, setValue, getOptionValuesFlat]);
+
+  // Debounced auto-selection for handling rapid option changes
+  var debouncedAutoSelection = React.useMemo(function () {
+    return debounce(executeAutoSelection, 50);
+  },
+  // Optimized 50ms debounce
+  [executeAutoSelection]);
   var navigationList = React.useRef([]);
   var virtuoso = React.useRef(null);
   var searchRef = React.useRef(null);
   var overlayId = useId(); // TODO use React 18 useId
   var listId = useId(); // TODO use React 18 useId
 
-  var _React$useState3 = React.useState(false),
-    _React$useState4 = _slicedToArray(_React$useState3, 2),
-    open = _React$useState4[0],
-    setOpen = _React$useState4[1];
   var _React$useState5 = React.useState(false),
     _React$useState6 = _slicedToArray(_React$useState5, 2),
-    pointer = _React$useState6[0],
-    setPointer = _React$useState6[1];
-  var _React$useState7 = React.useState(248),
+    open = _React$useState6[0],
+    setOpen = _React$useState6[1];
+  var _React$useState7 = React.useState(false),
     _React$useState8 = _slicedToArray(_React$useState7, 2),
-    width = _React$useState8[0],
-    setWidth = _React$useState8[1];
+    pointer = _React$useState8[0],
+    setPointer = _React$useState8[1];
   var _React$useState9 = React.useState(248),
     _React$useState0 = _slicedToArray(_React$useState9, 2),
-    maxHeight = _React$useState0[0],
-    setMaxHeight = _React$useState0[1];
-  var _React$useState1 = React.useState(0),
+    width = _React$useState0[0],
+    setWidth = _React$useState0[1];
+  var _React$useState1 = React.useState(248),
     _React$useState10 = _slicedToArray(_React$useState1, 2),
-    listHeight = _React$useState10[0],
-    setListHeight = _React$useState10[1];
+    maxHeight = _React$useState10[0],
+    setMaxHeight = _React$useState10[1];
   var _React$useState11 = React.useState(0),
     _React$useState12 = _slicedToArray(_React$useState11, 2),
-    searchHeight = _React$useState12[0],
-    setSearchHeight = _React$useState12[1];
+    listHeight = _React$useState12[0],
+    setListHeight = _React$useState12[1];
   var _React$useState13 = React.useState(0),
     _React$useState14 = _slicedToArray(_React$useState13, 2),
-    footerHeight = _React$useState14[0],
-    setFooterHeight = _React$useState14[1];
-  var listContainerHeight = Math.min(maxHeight - searchHeight - footerHeight + listContainerVerticalPadding, listHeight + listContainerVerticalPadding);
-  var _React$useState15 = React.useState(''),
+    searchHeight = _React$useState14[0],
+    setSearchHeight = _React$useState14[1];
+  var _React$useState15 = React.useState(0),
     _React$useState16 = _slicedToArray(_React$useState15, 2),
-    searchValue = _React$useState16[0],
-    setSearchValue_ = _React$useState16[1];
+    footerHeight = _React$useState16[0],
+    setFooterHeight = _React$useState16[1];
+  var listContainerHeight = Math.min(maxHeight - searchHeight - footerHeight + listContainerVerticalPadding, listHeight + listContainerVerticalPadding);
+  var _React$useState17 = React.useState(''),
+    _React$useState18 = _slicedToArray(_React$useState17, 2),
+    searchValue = _React$useState18[0],
+    setSearchValue_ = _React$useState18[1];
   var setSearchValue = debounce(setSearchValue_, 250); // TODO use React 18 useDeferredValue
 
-  var _React$useState17 = React.useState(null),
-    _React$useState18 = _slicedToArray(_React$useState17, 2),
-    activeMenuIndex = _React$useState18[0],
-    setActiveMenuIndex = _React$useState18[1];
   var _React$useState19 = React.useState(null),
     _React$useState20 = _slicedToArray(_React$useState19, 2),
-    activeTokenIndex = _React$useState20[0],
-    setActiveTokenIndex = _React$useState20[1];
+    activeMenuIndex = _React$useState20[0],
+    setActiveMenuIndex = _React$useState20[1];
+  var _React$useState21 = React.useState(null),
+    _React$useState22 = _slicedToArray(_React$useState21, 2),
+    activeTokenIndex = _React$useState22[0],
+    setActiveTokenIndex = _React$useState22[1];
   var components = _objectSpread(_objectSpread({}, defaultComponents), customComponents || {});
 
   // TODO #memogetters: consider having getOption... getter functions memoized by consumers
@@ -340,6 +513,63 @@ export function useSuperSelect(_ref3) {
   },
   // skip `getOptionLabel`, refer to TODO #memogetters
   [groupAndSortAlgorithm, formatBatchOption, searchValue, sourceOptions]);
+
+  /**
+   * Filtered list of options that can be selected (excludes disabled options and optgroups).
+   * Used for auto-selection logic to determine which options should be automatically
+   * selected when Select All is active and new options appear.
+   */
+  var selectableOptions = React.useMemo(function () {
+    var result = [];
+    var _iterator4 = _createForOfIteratorHelper(options),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var option = _step4.value;
+        if (isSelectableOption(option)) {
+          result.push(option);
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+    return result;
+  }, [options]);
+
+  /**
+   * Effect function that triggers auto-selection when conditions are met.
+   * Calls the debounced auto-selection logic when:
+   * - Select All is enabled
+   * - Multiple selection mode is active
+   * - Select All state is currently active
+   * - Current value is an array (multiple selection)
+   *
+   * The debouncing helps handle rapid option changes efficiently.
+   */
+  var autoSelectionEffect = React.useCallback(function () {
+    if (selectAllEnabled && multiple && isSelectAllActive && Array.isArray(value)) {
+      debouncedAutoSelection(selectableOptions, value);
+    }
+  }, [selectAllEnabled, multiple, isSelectAllActive, value, debouncedAutoSelection, selectableOptions]);
+
+  /**
+   * Effect that manages auto-selection behavior and cleanup.
+   * - Triggers auto-selection when dependencies change
+   * - Runs on every render when auto-selection conditions might have changed
+   */
+  React.useEffect(function () {
+    autoSelectionEffect();
+    return function () {
+      var _debouncedAutoSelecti;
+      // Cleanup debounced function
+      (_debouncedAutoSelecti = debouncedAutoSelection.cancel) === null || _debouncedAutoSelecti === void 0 ? void 0 : _debouncedAutoSelecti.call(debouncedAutoSelection);
+
+      // Reset processing flag
+      isProcessingAutoSelectionRef.current = false;
+    };
+  }, [autoSelectionEffect, debouncedAutoSelection]);
   var selectAllOption = _defineProperty({
     label: i18n.t('core.select.selectAll'),
     id: 'selectAll'
@@ -350,10 +580,10 @@ export function useSuperSelect(_ref3) {
     }
     return [selectAllOption].concat(_toConsumableArray(options));
   }, [selectAllEnabled, multiple, selectAllOption, options]);
-  var _React$useState21 = React.useState([]),
-    _React$useState22 = _slicedToArray(_React$useState21, 2),
-    draggableOptions = _React$useState22[0],
-    setDraggableOptions = _React$useState22[1];
+  var _React$useState23 = React.useState([]),
+    _React$useState24 = _slicedToArray(_React$useState23, 2),
+    draggableOptions = _React$useState24[0],
+    setDraggableOptions = _React$useState24[1];
   React.useEffect(function () {
     if (!draggable) {
       return;
@@ -428,7 +658,109 @@ export function useSuperSelect(_ref3) {
     var baseOptions = options;
     return baseOptions.findIndex(isSelectableOption) + (selectAllEnabled && multiple ? 1 : 0);
   }
-  function onSelect(option) {
+
+  // Helper functions for onSelect optimization
+  /**
+   * Handles the toggle behavior for the Select All option.
+   *
+   * Behavior:
+   * - If all options are selected: deselects all and deactivates Select All
+   * - If not all options are selected: selects all and activates Select All
+   *
+   * Performance optimizations:
+   * - Uses Set for efficient value deduplication
+   * - Leverages existing option checking logic
+   * - Calls optional onSelectAll callback for external handling
+   */
+  var handleSelectAllToggle = React.useCallback(function () {
+    var getIsSelected = getOptionIsSelected !== null && getOptionIsSelected !== void 0 ? getOptionIsSelected : defaultGetOptionIsSelected;
+    var allSelected = selectableOptions.every(function (opt) {
+      return getIsSelected(opt);
+    });
+    if (onSelectAll) {
+      onSelectAll(selectableOptions);
+    }
+    if (allSelected) {
+      setIsSelectAllActive(false);
+      setValue([]);
+    } else {
+      setIsSelectAllActive(true);
+      // Ensure we're working with an array for multiple selection
+      var currentValue = Array.isArray(value) ? value : [];
+      var valueSet = new Set(currentValue);
+      selectableOptions.forEach(function (opt) {
+        getOptionValuesFlat(opt).forEach(function (val) {
+          return valueSet.add(val);
+        });
+      });
+      setValue(Array.from(valueSet));
+    }
+  }, [getOptionIsSelected, selectableOptions, onSelectAll, setIsSelectAllActive, setValue, value, getOptionValuesFlat]);
+
+  /**
+   * Determines if Select All should be activated based on the new value.
+   * Select All activates when all selectable options become selected,
+   * but only if it wasn't already active (prevents unnecessary state changes).
+   *
+   * @param newValue - The new array of selected values to evaluate
+   * @returns true if Select All should be activated, false otherwise
+   */
+  var shouldActivateSelectAll = React.useCallback(function (newValue) {
+    return !isSelectAllActive && selectAllEnabled && newValue.length >= selectableOptions.length && checkIfAllSelectableOptionsSelected(newValue, selectableOptions);
+  }, [isSelectAllActive, selectAllEnabled, selectableOptions, checkIfAllSelectableOptionsSelected]);
+
+  /**
+   * Handles selection of batch options (options with multiple values).
+   * Adds all values from the batch option to the current selection
+   * and activates Select All if all options become selected.
+   *
+   * @param optionValue - Array of primitive values from the batch option
+   */
+  var handleBatchOptionSelection = React.useCallback(function (optionValue) {
+    // Ensure we're working with an array for multiple selection
+    var currentValue = Array.isArray(value) ? value : [];
+    var newValueSet = new Set([].concat(_toConsumableArray(currentValue), _toConsumableArray(optionValue)));
+    var newValue = Array.from(newValueSet);
+    setValue(newValue);
+    if (shouldActivateSelectAll(newValue)) {
+      setIsSelectAllActive(true);
+    }
+  }, [value, setValue, shouldActivateSelectAll, setIsSelectAllActive]);
+
+  /**
+   * Handles selection/deselection of individual options in multiple mode.
+   *
+   * Behavior:
+   * - If option is selected: removes it and deactivates Select All
+   * - If option is not selected: adds it and activates Select All if all options become selected
+   *
+   * @param optionValue - The primitive value of the option to toggle
+   */
+  var handleSingleOptionSelection = React.useCallback(function (optionValue) {
+    // Ensure we're working with an array for multiple selection
+    if (!Array.isArray(value)) {
+      return;
+    }
+    var valueIndex = value.indexOf(optionValue);
+    if (valueIndex >= 0) {
+      // Remove value
+      var newValue = value.filter(function (_, i) {
+        return i !== valueIndex;
+      });
+      setValue(newValue);
+      if (isSelectAllActive) {
+        setIsSelectAllActive(false);
+      }
+    } else {
+      // Add value
+      var _newValue = [].concat(_toConsumableArray(value), [optionValue]);
+      setValue(_newValue);
+      if (shouldActivateSelectAll(_newValue)) {
+        setIsSelectAllActive(true);
+      }
+    }
+  }, [value, setValue, isSelectAllActive, setIsSelectAllActive, shouldActivateSelectAll]);
+  var onSelect = React.useCallback(function (option) {
     if (getOptionIsDisabled(option)) {
       return;
     }
@@ -436,38 +768,16 @@ export function useSuperSelect(_ref3) {
     var isSelectAll = getOptionIsOptSelectAll(option);
     if (isMultiple(multiple, value)) {
       if (isSelectAll) {
-        var selectableOptions = options.filter(function (opt) {
-          return isSelectableOption(opt);
-        });
-
-        // Check if all options are already selected to determine if this is a deselect operation
-        var allOptionsSelected = selectableOptions.every(function (opt) {
-          var getIsSelected = getOptionIsSelected !== null && getOptionIsSelected !== void 0 ? getOptionIsSelected : defaultGetOptionIsSelected;
-          return getIsSelected(opt);
-        });
-        if (onSelectAll) {
-          onSelectAll(selectableOptions);
-        }
-
-        // Only add options if not all are selected (i.e., this is a select operation)
-        // If all options are selected, this is a deselect operation and we should clear
-        if (allOptionsSelected) {
-          setValue([]);
-        } else {
-          var optionValues = selectableOptions.flatMap(getOptionValue);
-          setValue(uniq([].concat(_toConsumableArray(value), _toConsumableArray(optionValues))));
-        }
+        handleSelectAllToggle();
       } else if (Array.isArray(optionValue)) {
-        setValue(uniq([].concat(_toConsumableArray(value), _toConsumableArray(optionValue))));
+        handleBatchOptionSelection(optionValue);
       } else {
-        setValue(value.includes(optionValue) ? value.filter(function (val) {
-          return val !== optionValue;
-        }) : [].concat(_toConsumableArray(value), [optionValue]));
+        handleSingleOptionSelection(optionValue);
       }
     } else {
       setValue(optionValue);
     }
-  }
+  }, [getOptionIsDisabled, getOptionValue, getOptionIsOptSelectAll, multiple, value, handleSelectAllToggle, handleBatchOptionSelection, handleSingleOptionSelection, setValue]);
   function onKeyboardSelect() {
     if (activeMenuIndex !== null) {
       // Select All must be included in the list for keyboard navigation to work properly.
@@ -686,6 +996,10 @@ export function useSuperSelect(_ref3) {
           setValue(value.filter(function (_, i) {
             return i !== index;
           }));
+          // Deactivate Select All if removing individual tokens while active
+          if (isSelectAllActive) {
+            setIsSelectAllActive(false);
+          }
         }
       }
     };
@@ -739,6 +1053,7 @@ export function useSuperSelect(_ref3) {
         // prevent the menu from closing
         e.stopPropagation();
         setActiveTokenIndex(null);
+        setIsSelectAllActive(false); // Reset Select All state when clearing
         setValue(multiple ? [] : null);
         setOpen(true);
       }
@@ -948,10 +1263,10 @@ export function useSuperSelect(_ref3) {
       value: getOptionValue,
       selectAll: {
         isSelectAllPartiallySelected: function isSelectAllPartiallySelected(options) {
-          return defaultGetOptionIsSelectAllPartiallySelected(options.filter(isSelectableOption), getOptionIsSelected !== null && getOptionIsSelected !== void 0 ? getOptionIsSelected : defaultGetOptionIsSelected, getOptionIsPartiallySelected !== null && getOptionIsPartiallySelected !== void 0 ? getOptionIsPartiallySelected : defaultGetOptionIsPartiallySelected);
+          return defaultGetOptionIsSelectAllPartiallySelected(options, getOptionIsSelected !== null && getOptionIsSelected !== void 0 ? getOptionIsSelected : defaultGetOptionIsSelected, getOptionIsPartiallySelected !== null && getOptionIsPartiallySelected !== void 0 ? getOptionIsPartiallySelected : defaultGetOptionIsPartiallySelected);
         },
         isSelectAllSelected: function isSelectAllSelected(options) {
-          return defaultGetOptionIsSelectAllSelected(options.filter(isSelectableOption), getOptionIsSelected !== null && getOptionIsSelected !== void 0 ? getOptionIsSelected : defaultGetOptionIsSelected);
+          return defaultGetOptionIsSelectAllSelected(options, getOptionIsSelected !== null && getOptionIsSelected !== void 0 ? getOptionIsSelected : defaultGetOptionIsSelected);
         }
       }
     },