@primer/components 0.0.0-2021113144816 → 0.0.0-2021113174023

package/lib/hooks/useDialog.js

@@ -1,104 +1,80 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _react = require("react");
-
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
 const noop = () => null;
-
 function visible(el) {
-  return !el.hidden && (!el.type || el.type !== 'hidden') && (el.offsetWidth > 0 || el.offsetHeight > 0);
+    return !el.hidden && (!el.type || el.type !== 'hidden') && (el.offsetWidth > 0 || el.offsetHeight > 0);
 }
-
 function focusable(el) {
-  const inputEl = el;
-  return inputEl.tabIndex >= 0 && !inputEl.disabled && visible(inputEl);
+    const inputEl = el;
+    return inputEl.tabIndex >= 0 && !inputEl.disabled && visible(inputEl);
 }
-
-function useDialog({
-  modalRef,
-  overlayRef,
-  isOpen,
-  onDismiss = noop,
-  initialFocusRef,
-  closeButtonRef
-}) {
-  const onClickOutside = (0, _react.useCallback)(e => {
-    if (modalRef.current && overlayRef.current && !modalRef.current.contains(e.target) && overlayRef.current.contains(e.target)) {
-      onDismiss();
-    }
-  }, [onDismiss, modalRef, overlayRef]);
-  (0, _react.useEffect)(() => {
-    if (isOpen) {
-      document.addEventListener('click', onClickOutside);
-      return () => {
-        document.removeEventListener('click', onClickOutside);
-      };
-    }
-  }, [isOpen, onClickOutside]);
-  (0, _react.useEffect)(() => {
-    if (isOpen) {
-      if (initialFocusRef && initialFocusRef.current) {
-        initialFocusRef.current.focus();
-      } else if (closeButtonRef && closeButtonRef.current) {
-        closeButtonRef.current.focus();
-      }
-    }
-  }, [isOpen, initialFocusRef, closeButtonRef]);
-  const getFocusableItem = (0, _react.useCallback)((e, movement) => {
-    if (modalRef.current) {
-      const items = Array.from(modalRef.current.querySelectorAll('*')).filter(focusable);
-      if (items.length === 0) return;
-      e.preventDefault();
-      const focusedElement = document.activeElement;
-
-      if (!focusedElement) {
-        return;
-      }
-
-      const index = items.indexOf(focusedElement);
-      const offsetIndex = index + movement;
-      const fallbackIndex = movement === 1 ? 0 : items.length - 1;
-      const focusableItem = items[offsetIndex] || items[fallbackIndex];
-      return focusableItem;
-    }
-  }, [modalRef]);
-  const handleTab = (0, _react.useCallback)(e => {
-    const movement = e.shiftKey ? -1 : 1;
-    const focusableItem = getFocusableItem(e, movement);
-
-    if (!focusableItem) {
-      return;
-    }
-
-    focusableItem.focus();
-  }, [getFocusableItem]);
-  const onKeyDown = (0, _react.useCallback)(event => {
-    switch (event.key) {
-      case 'Tab':
-        handleTab(event);
-        break;
-
-      case 'Escape':
-        onDismiss();
-        event.stopPropagation();
-        break;
-    }
-  }, [handleTab, onDismiss]);
-
-  const getDialogProps = () => {
-    return {
-      onKeyDown
+function useDialog({ modalRef, overlayRef, isOpen, onDismiss = noop, initialFocusRef, closeButtonRef }) {
+    const onClickOutside = react_1.useCallback(e => {
+        if (modalRef.current &&
+            overlayRef.current &&
+            !modalRef.current.contains(e.target) &&
+            overlayRef.current.contains(e.target)) {
+            onDismiss();
+        }
+    }, [onDismiss, modalRef, overlayRef]);
+    react_1.useEffect(() => {
+        if (isOpen) {
+            document.addEventListener('click', onClickOutside);
+            return () => {
+                document.removeEventListener('click', onClickOutside);
+            };
+        }
+    }, [isOpen, onClickOutside]);
+    react_1.useEffect(() => {
+        if (isOpen) {
+            if (initialFocusRef && initialFocusRef.current) {
+                initialFocusRef.current.focus();
+            }
+            else if (closeButtonRef && closeButtonRef.current) {
+                closeButtonRef.current.focus();
+            }
+        }
+    }, [isOpen, initialFocusRef, closeButtonRef]);
+    const getFocusableItem = react_1.useCallback((e, movement) => {
+        if (modalRef.current) {
+            const items = Array.from(modalRef.current.querySelectorAll('*')).filter(focusable);
+            if (items.length === 0)
+                return;
+            e.preventDefault();
+            const focusedElement = document.activeElement;
+            if (!focusedElement) {
+                return;
+            }
+            const index = items.indexOf(focusedElement);
+            const offsetIndex = index + movement;
+            const fallbackIndex = movement === 1 ? 0 : items.length - 1;
+            const focusableItem = items[offsetIndex] || items[fallbackIndex];
+            return focusableItem;
+        }
+    }, [modalRef]);
+    const handleTab = react_1.useCallback(e => {
+        const movement = e.shiftKey ? -1 : 1;
+        const focusableItem = getFocusableItem(e, movement);
+        if (!focusableItem) {
+            return;
+        }
+        focusableItem.focus();
+    }, [getFocusableItem]);
+    const onKeyDown = react_1.useCallback(event => {
+        switch (event.key) {
+            case 'Tab':
+                handleTab(event);
+                break;
+            case 'Escape':
+                onDismiss();
+                event.stopPropagation();
+                break;
+        }
+    }, [handleTab, onDismiss]);
+    const getDialogProps = () => {
+        return { onKeyDown };
     };
-  };
-
-  return {
-    getDialogProps
-  };
+    return { getDialogProps };
 }
-
-var _default = useDialog;
-exports.default = _default;
+exports.default = useDialog;

package/lib/hooks/useFocusTrap.js

@@ -1,69 +1,52 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useFocusTrap = useFocusTrap;
-
-var _react = _interopRequireDefault(require("react"));
-
-var _focusTrap = require("../behaviors/focusTrap");
-
-var _useProvidedRefOrCreate = require("./useProvidedRefOrCreate");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFocusTrap = void 0;
+const react_1 = __importDefault(require("react"));
+const focusTrap_1 = require("../behaviors/focusTrap");
+const useProvidedRefOrCreate_1 = require("./useProvidedRefOrCreate");
 /**
  * Hook used to trap focus inside a container. Returns a ref that can be added to the container
  * that should trap focus.
  * @param settings {FocusTrapHookSettings}
  */
 function useFocusTrap(settings, dependencies = []) {
-  const containerRef = (0, _useProvidedRefOrCreate.useProvidedRefOrCreate)(settings === null || settings === void 0 ? void 0 : settings.containerRef);
-  const initialFocusRef = (0, _useProvidedRefOrCreate.useProvidedRefOrCreate)(settings === null || settings === void 0 ? void 0 : settings.initialFocusRef);
-  const disabled = settings === null || settings === void 0 ? void 0 : settings.disabled;
-
-  const abortController = _react.default.useRef();
-
-  const previousFocusedElement = _react.default.useRef(null); // If we are enabling a focus trap and haven't already stored the previously focused element
-  // go ahead an do that so we can restore later when the trap is disabled.
-
-
-  if (!previousFocusedElement.current && !(settings !== null && settings !== void 0 && settings.disabled)) {
-    previousFocusedElement.current = document.activeElement;
-  } // This function removes the event listeners that enable the focus trap and restores focus
-  // to the previously-focused element (if necessary).
-
-
-  function disableTrap() {
-    var _abortController$curr;
-
-    (_abortController$curr = abortController.current) === null || _abortController$curr === void 0 ? void 0 : _abortController$curr.abort();
-
-    if (settings !== null && settings !== void 0 && settings.restoreFocusOnCleanUp && previousFocusedElement.current instanceof HTMLElement) {
-      previousFocusedElement.current.focus();
-      previousFocusedElement.current = null;
+    const containerRef = useProvidedRefOrCreate_1.useProvidedRefOrCreate(settings?.containerRef);
+    const initialFocusRef = useProvidedRefOrCreate_1.useProvidedRefOrCreate(settings?.initialFocusRef);
+    const disabled = settings?.disabled;
+    const abortController = react_1.default.useRef();
+    const previousFocusedElement = react_1.default.useRef(null);
+    // If we are enabling a focus trap and haven't already stored the previously focused element
+    // go ahead an do that so we can restore later when the trap is disabled.
+    if (!previousFocusedElement.current && !settings?.disabled) {
+        previousFocusedElement.current = document.activeElement;
     }
-  }
-
-  _react.default.useEffect(() => {
-    if (containerRef.current instanceof HTMLElement) {
-      if (!disabled) {
-        var _initialFocusRef$curr;
-
-        abortController.current = (0, _focusTrap.focusTrap)(containerRef.current, (_initialFocusRef$curr = initialFocusRef.current) !== null && _initialFocusRef$curr !== void 0 ? _initialFocusRef$curr : undefined);
-        return () => {
-          disableTrap();
-        };
-      } else {
-        disableTrap();
-      }
+    // This function removes the event listeners that enable the focus trap and restores focus
+    // to the previously-focused element (if necessary).
+    function disableTrap() {
+        abortController.current?.abort();
+        if (settings?.restoreFocusOnCleanUp && previousFocusedElement.current instanceof HTMLElement) {
+            previousFocusedElement.current.focus();
+            previousFocusedElement.current = null;
+        }
     }
-  }, // eslint-disable-next-line react-hooks/exhaustive-deps
-  [containerRef, initialFocusRef, disabled, ...dependencies]);
-
-  return {
-    containerRef,
-    initialFocusRef
-  };
-}
+    react_1.default.useEffect(() => {
+        if (containerRef.current instanceof HTMLElement) {
+            if (!disabled) {
+                abortController.current = focusTrap_1.focusTrap(containerRef.current, initialFocusRef.current ?? undefined);
+                return () => {
+                    disableTrap();
+                };
+            }
+            else {
+                disableTrap();
+            }
+        }
+    }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [containerRef, initialFocusRef, disabled, ...dependencies]);
+    return { containerRef, initialFocusRef };
+}
+exports.useFocusTrap = useFocusTrap;

package/lib/hooks/useFocusZone.js

@@ -1,53 +1,57 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
 });
-exports.useFocusZone = useFocusZone;
-
-var _react = _interopRequireWildcard(require("react"));
-
-var _focusZone = require("../behaviors/focusZone");
-
-var _useProvidedRefOrCreate = require("./useProvidedRefOrCreate");
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFocusZone = void 0;
+const react_1 = __importStar(require("react"));
+const focusZone_1 = require("../behaviors/focusZone");
+const useProvidedRefOrCreate_1 = require("./useProvidedRefOrCreate");
 function useFocusZone(settings = {}, dependencies = []) {
-  const containerRef = (0, _useProvidedRefOrCreate.useProvidedRefOrCreate)(settings.containerRef);
-  const useActiveDescendant = !!settings.activeDescendantFocus;
-  const passedActiveDescendantRef = typeof settings.activeDescendantFocus === 'boolean' || !settings.activeDescendantFocus ? undefined : settings.activeDescendantFocus;
-  const activeDescendantControlRef = (0, _useProvidedRefOrCreate.useProvidedRefOrCreate)(passedActiveDescendantRef);
-  const disabled = settings.disabled;
-
-  const abortController = _react.default.useRef();
-
-  (0, _react.useEffect)(() => {
-    if (containerRef.current instanceof HTMLElement && (!useActiveDescendant || activeDescendantControlRef.current instanceof HTMLElement)) {
-      if (!disabled) {
-        var _activeDescendantCont;
-
-        const vanillaSettings = { ...settings,
-          activeDescendantControl: (_activeDescendantCont = activeDescendantControlRef.current) !== null && _activeDescendantCont !== void 0 ? _activeDescendantCont : undefined
-        };
-        abortController.current = (0, _focusZone.focusZone)(containerRef.current, vanillaSettings);
-        return () => {
-          var _abortController$curr;
-
-          (_abortController$curr = abortController.current) === null || _abortController$curr === void 0 ? void 0 : _abortController$curr.abort();
-        };
-      } else {
-        var _abortController$curr2;
-
-        (_abortController$curr2 = abortController.current) === null || _abortController$curr2 === void 0 ? void 0 : _abortController$curr2.abort();
-      }
-    }
-  }, // eslint-disable-next-line react-hooks/exhaustive-deps
-  [disabled, ...dependencies]);
-  return {
-    containerRef,
-    activeDescendantControlRef
-  };
-}
+    const containerRef = useProvidedRefOrCreate_1.useProvidedRefOrCreate(settings.containerRef);
+    const useActiveDescendant = !!settings.activeDescendantFocus;
+    const passedActiveDescendantRef = typeof settings.activeDescendantFocus === 'boolean' || !settings.activeDescendantFocus
+        ? undefined
+        : settings.activeDescendantFocus;
+    const activeDescendantControlRef = useProvidedRefOrCreate_1.useProvidedRefOrCreate(passedActiveDescendantRef);
+    const disabled = settings.disabled;
+    const abortController = react_1.default.useRef();
+    react_1.useEffect(() => {
+        if (containerRef.current instanceof HTMLElement &&
+            (!useActiveDescendant || activeDescendantControlRef.current instanceof HTMLElement)) {
+            if (!disabled) {
+                const vanillaSettings = {
+                    ...settings,
+                    activeDescendantControl: activeDescendantControlRef.current ?? undefined
+                };
+                abortController.current = focusZone_1.focusZone(containerRef.current, vanillaSettings);
+                return () => {
+                    abortController.current?.abort();
+                };
+            }
+            else {
+                abortController.current?.abort();
+            }
+        }
+    }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [disabled, ...dependencies]);
+    return { containerRef, activeDescendantControlRef };
+}
+exports.useFocusZone = useFocusZone;

package/lib/hooks/useOnEscapePress.js

@@ -1,28 +1,22 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.useOnEscapePress = void 0;
-
-var _react = require("react");
-
+const react_1 = require("react");
 const handlers = [];
 /**
  * Calls all handlers in reverse order
  * @param event The KeyboardEvent generated by the Escape keydown.
  */
-
 function handleEscape(event) {
-  if (event.key === 'Escape' && !event.defaultPrevented) {
-    for (let i = handlers.length - 1; i >= 0; --i) {
-      handlers[i](event); // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-
-      if (event.defaultPrevented) {
-        break;
-      }
+    if (event.key === 'Escape' && !event.defaultPrevented) {
+        for (let i = handlers.length - 1; i >= 0; --i) {
+            handlers[i](event);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (event.defaultPrevented) {
+                break;
+            }
+        }
     }
-  }
 }
 /**
  * Sets up a `keydown` listener on `window.document`. If
@@ -45,25 +39,20 @@ function handleEscape(event) {
  * `onEscape` callback for memoization. Omit this param if the callback is already
  * memoized. See `React.useCallback` for more info on memoization.
  */
-
-
 const useOnEscapePress = (onEscape, callbackDependencies = [onEscape]) => {
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  const escapeCallback = (0, _react.useCallback)(onEscape, callbackDependencies);
-  (0, _react.useEffect)(() => {
-    if (handlers.length === 0) {
-      document.addEventListener('keydown', handleEscape);
-    }
-
-    handlers.push(escapeCallback);
-    return () => {
-      handlers.splice(handlers.findIndex(h => h === escapeCallback), 1);
-
-      if (handlers.length === 0) {
-        document.removeEventListener('keydown', handleEscape);
-      }
-    };
-  }, [escapeCallback]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const escapeCallback = react_1.useCallback(onEscape, callbackDependencies);
+    react_1.useEffect(() => {
+        if (handlers.length === 0) {
+            document.addEventListener('keydown', handleEscape);
+        }
+        handlers.push(escapeCallback);
+        return () => {
+            handlers.splice(handlers.findIndex(h => h === escapeCallback), 1);
+            if (handlers.length === 0) {
+                document.removeEventListener('keydown', handleEscape);
+            }
+        };
+    }, [escapeCallback]);
 };
-
-exports.useOnEscapePress = useOnEscapePress;
+exports.useOnEscapePress = useOnEscapePress;

package/lib/hooks/useOnOutsideClick.jsx

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOnOutsideClick = void 0;
+const react_1 = require("react");
+// Because events are handled at the document level, we provide a mechanism for early return.
+const stopPropagation = true;
+/**
+ * Calls all handlers in reverse order
+ * @param event The MouseEvent generated by the click event.
+ */
+function handleClick(event) {
+    if (!event.defaultPrevented) {
+        for (const handler of Object.values(registry).reverse()) {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (handler(event) === stopPropagation || event.defaultPrevented) {
+                break;
+            }
+        }
+    }
+}
+const registry = {};
+function register(id, handler) {
+    registry[id] = handler;
+}
+function deregister(id) {
+    delete registry[id];
+}
+// For auto-incrementing unique identifiers for registered handlers.
+let handlerId = 0;
+const useOnOutsideClick = ({ containerRef, ignoreClickRefs, onClickOutside }) => {
+    const id = react_1.useMemo(() => handlerId++, []);
+    const handler = react_1.useCallback(event => {
+        // don't call click handler if the mouse event was triggered by an auxiliary button (right click/wheel button/etc)
+        if (event instanceof MouseEvent && event.button > 0) {
+            return stopPropagation;
+        }
+        // don't call handler if the click happened inside of the container
+        if (containerRef.current?.contains(event.target)) {
+            return stopPropagation;
+        }
+        // don't call handler if click happened on an ignored ref
+        if (ignoreClickRefs && ignoreClickRefs.some(({ current }) => current?.contains(event.target))) {
+            return stopPropagation;
+        }
+        onClickOutside(event);
+    }, [containerRef, ignoreClickRefs, onClickOutside]);
+    react_1.useEffect(() => {
+        if (Object.keys(registry).length === 0) {
+            // use capture to ensure we get all events
+            document.addEventListener('mousedown', handleClick, { capture: true });
+        }
+        register(id, handler);
+        return () => {
+            deregister(id);
+            if (Object.keys(registry).length === 0) {
+                document.removeEventListener('mousedown', handleClick, { capture: true });
+            }
+        };
+    }, [id, handler]);
+};
+exports.useOnOutsideClick = useOnOutsideClick;

package/lib/hooks/useOpenAndCloseFocus.js

@@ -1,36 +1,24 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOpenAndCloseFocus = void 0;
+const react_1 = require("react");
+const iterateFocusableElements_1 = require("../utils/iterateFocusableElements");
+function useOpenAndCloseFocus({ initialFocusRef, returnFocusRef, containerRef, preventFocusOnOpen }) {
+    react_1.useEffect(() => {
+        if (preventFocusOnOpen) {
+            return;
+        }
+        const returnRef = returnFocusRef.current;
+        if (initialFocusRef && initialFocusRef.current) {
+            initialFocusRef.current.focus();
+        }
+        else if (containerRef.current) {
+            const firstItem = iterateFocusableElements_1.iterateFocusableElements(containerRef.current).next().value;
+            firstItem?.focus();
+        }
+        return function () {
+            returnRef?.focus();
+        };
+    }, [initialFocusRef, returnFocusRef, containerRef, preventFocusOnOpen]);
+}
 exports.useOpenAndCloseFocus = useOpenAndCloseFocus;
-
-var _react = require("react");
-
-var _iterateFocusableElements = require("../utils/iterateFocusableElements");
-
-function useOpenAndCloseFocus({
-  initialFocusRef,
-  returnFocusRef,
-  containerRef,
-  preventFocusOnOpen
-}) {
-  (0, _react.useEffect)(() => {
-    if (preventFocusOnOpen) {
-      return;
-    }
-
-    const returnRef = returnFocusRef.current;
-
-    if (initialFocusRef && initialFocusRef.current) {
-      initialFocusRef.current.focus();
-    } else if (containerRef.current) {
-      const firstItem = (0, _iterateFocusableElements.iterateFocusableElements)(containerRef.current).next().value;
-      firstItem === null || firstItem === void 0 ? void 0 : firstItem.focus();
-    }
-
-    return function () {
-      returnRef === null || returnRef === void 0 ? void 0 : returnRef.focus();
-    };
-  }, [initialFocusRef, returnFocusRef, containerRef, preventFocusOnOpen]);
-}

package/lib/hooks/useOverlay.jsx

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOverlay = void 0;
+const useOnOutsideClick_1 = require("./useOnOutsideClick");
+const useOpenAndCloseFocus_1 = require("./useOpenAndCloseFocus");
+const useOnEscapePress_1 = require("./useOnEscapePress");
+const useProvidedRefOrCreate_1 = require("./useProvidedRefOrCreate");
+const useOverlay = ({ overlayRef: _overlayRef, returnFocusRef, initialFocusRef, onEscape, ignoreClickRefs, onClickOutside, preventFocusOnOpen }) => {
+    const overlayRef = useProvidedRefOrCreate_1.useProvidedRefOrCreate(_overlayRef);
+    useOpenAndCloseFocus_1.useOpenAndCloseFocus({ containerRef: overlayRef, returnFocusRef, initialFocusRef, preventFocusOnOpen });
+    useOnOutsideClick_1.useOnOutsideClick({ containerRef: overlayRef, ignoreClickRefs, onClickOutside });
+    useOnEscapePress_1.useOnEscapePress(onEscape);
+    return { ref: overlayRef };
+};
+exports.useOverlay = useOverlay;

package/lib/hooks/useProvidedRefOrCreate.js

@@ -1,14 +1,10 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useProvidedRefOrCreate = useProvidedRefOrCreate;
-
-var _react = _interopRequireDefault(require("react"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useProvidedRefOrCreate = void 0;
+const react_1 = __importDefault(require("react"));
 /**
  * There are some situations where we only want to create a new ref if one is not provided to a component
  * or hook as a prop. However, due to the `rules-of-hooks`, we cannot conditionally make a call to `React.useRef`
@@ -18,7 +14,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * @type TRef The type of the RefObject which should be created.
  */
 function useProvidedRefOrCreate(providedRef) {
-  const createdRef = _react.default.useRef(null);
-
-  return providedRef !== null && providedRef !== void 0 ? providedRef : createdRef;
-}
+    const createdRef = react_1.default.useRef(null);
+    return providedRef ?? createdRef;
+}
+exports.useProvidedRefOrCreate = useProvidedRefOrCreate;