@workday/canvas-kit-react 9.0.0-alpha.368-next.6 → 9.0.0-alpha.382-next.2

package/dist/es6/popup/lib/hooks/useAssistiveHideSiblings.js

@@ -1,8 +1,3 @@
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
 import React from 'react';
 import { createElemPropsHook } from '@workday/canvas-kit-react/common';
 import { usePopupModel } from './usePopupModel';
@@ -17,21 +12,23 @@ import { usePopupModel } from './usePopupModel';
  *
  * This should be used on popup elements that need to hide content (i.e. Modals).
  */
-export var useAssistiveHideSiblings = createElemPropsHook(usePopupModel)(function (model) {
-    var visible = model.state.visibility !== 'hidden';
-    React.useEffect(function () {
+export const useAssistiveHideSiblings = createElemPropsHook(usePopupModel)(model => {
+    const visible = model.state.visibility !== 'hidden';
+    React.useEffect(() => {
         var _a, _b;
         if (!visible) {
             return;
         }
-        var siblings = __spreadArray([], (_b = (_a = model.state.stackRef.current) === null || _a === void 0 ? void 0 : _a.parentElement) === null || _b === void 0 ? void 0 : _b.children).filter(function (el) { return el !== model.state.stackRef.current; });
-        var prevAriaHidden = siblings.map(function (el) { return el.getAttribute('aria-hidden'); });
-        siblings.forEach(function (el) {
+        const siblings = [
+            ...(_b = (_a = model.state.stackRef.current) === null || _a === void 0 ? void 0 : _a.parentElement) === null || _b === void 0 ? void 0 : _b.children,
+        ].filter(el => el !== model.state.stackRef.current);
+        const prevAriaHidden = siblings.map(el => el.getAttribute('aria-hidden'));
+        siblings.forEach(el => {
             el.setAttribute('aria-hidden', 'true');
         });
-        return function () {
-            siblings.forEach(function (el, index) {
-                var prev = prevAriaHidden[index];
+        return () => {
+            siblings.forEach((el, index) => {
+                const prev = prevAriaHidden[index];
                 if (prev) {
                     el.setAttribute('aria-hidden', prev);
                 }

package/dist/es6/popup/lib/hooks/useBringToTopOnClick.js

@@ -11,25 +11,25 @@ import { usePopupModel } from './usePopupModel';
  *
  * This should be used on popup elements that are meant to persist (i.e. Windows).
  */
-export var useBringToTopOnClick = createElemPropsHook(usePopupModel)(function (model) {
-    var timer = React.useRef(-1);
-    var onClick = React.useCallback(function (event) {
+export const useBringToTopOnClick = createElemPropsHook(usePopupModel)(model => {
+    const timer = React.useRef(-1);
+    const onClick = React.useCallback((event) => {
         // requestAnimationFrame is used to control timing of when `bringToTop` is called.
         // https://github.com/Workday/canvas-kit/pull/670#discussion_r436158184
-        timer.current = requestAnimationFrame(function () {
+        timer.current = requestAnimationFrame(() => {
             var _a;
             if ((_a = model.state.stackRef.current) === null || _a === void 0 ? void 0 : _a.contains(event.target)) {
                 PopupStack.bringToTop(model.state.stackRef.current);
             }
         });
     }, [model.state.stackRef]);
-    var visible = model.state.visibility !== 'hidden';
-    React.useLayoutEffect(function () {
+    const visible = model.state.visibility !== 'hidden';
+    React.useLayoutEffect(() => {
         if (!visible) {
             return;
         }
         document.addEventListener('click', onClick);
-        return function () {
+        return () => {
             cancelAnimationFrame(timer.current);
             document.removeEventListener('click', onClick);
         };

package/dist/es6/popup/lib/hooks/useCloseOnEscape.js

@@ -9,21 +9,21 @@ import { usePopupModel } from './usePopupModel';
  * This should be used with popup elements that are dismissible like Tooltips, Modals, non-modal
  * dialogs, dropdown menus, etc.
  */
-export var useCloseOnEscape = createElemPropsHook(usePopupModel)(function (model) {
-    var onKeyDown = React.useCallback(function (event) {
+export const useCloseOnEscape = createElemPropsHook(usePopupModel)(model => {
+    const onKeyDown = React.useCallback((event) => {
         if ((event.key === 'Esc' || event.key === 'Escape') &&
             PopupStack.isTopmost(model.state.stackRef.current)) {
             model.events.hide(event);
         }
     }, [model.state.stackRef, model.events]);
-    var visible = model.state.visibility !== 'hidden';
+    const visible = model.state.visibility !== 'hidden';
     // `useLayoutEffect` for automation
-    React.useLayoutEffect(function () {
+    React.useLayoutEffect(() => {
         if (!visible) {
             return;
         }
         document.addEventListener('keydown', onKeyDown);
-        return function () {
+        return () => {
             document.removeEventListener('keydown', onKeyDown);
         };
     }, [onKeyDown, visible]);

package/dist/es6/popup/lib/hooks/useCloseOnFullscreenExit.js

@@ -7,20 +7,20 @@ import { usePopupModel } from './usePopupModel';
  * the entire screen. This should be added to popup types that are very context sensitive like
  * Tooltips.
  */
-export var useCloseOnFullscreenExit = createElemPropsHook(usePopupModel)(function (model) {
-    var handler = React.useCallback(function (event) {
+export const useCloseOnFullscreenExit = createElemPropsHook(usePopupModel)(model => {
+    const handler = React.useCallback((event) => {
         if (!screenfull.isFullscreen) {
             model.events.hide(event);
         }
     }, [model.events]);
-    var visible = model.state.visibility !== 'hidden';
-    React.useEffect(function () {
+    const visible = model.state.visibility !== 'hidden';
+    React.useEffect(() => {
         if (!visible) {
             return;
         }
         if (screenfull.isEnabled) {
             screenfull.on('change', handler);
-            return function () {
+            return () => {
                 screenfull.off('change', handler);
             };
         }

package/dist/es6/popup/lib/hooks/useCloseOnOutsideClick.js

@@ -12,14 +12,14 @@ import { usePopupModel } from './usePopupModel';
  * dropdown menus, etc. Tooltips and hierarchical menus should use
  * {@link useAlwaysCloseOnClickOutside} instead.
  */
-export var useCloseOnOutsideClick = createElemPropsHook(usePopupModel)(function (model) {
-    var onClick = React.useCallback(function (event) {
+export const useCloseOnOutsideClick = createElemPropsHook(usePopupModel)(model => {
+    const onClick = React.useCallback((event) => {
         if (!model.state.stackRef.current) {
             return;
         }
-        var elements = PopupStack.getElements()
-            .filter(function (e) { return e.getAttribute('data-behavior-click-outside-close') === 'topmost'; })
-            .sort(function (a, b) { return Number(a.style.zIndex) - Number(b.style.zIndex); });
+        const elements = PopupStack.getElements()
+            .filter(e => e.getAttribute('data-behavior-click-outside-close') === 'topmost')
+            .sort((a, b) => Number(a.style.zIndex) - Number(b.style.zIndex));
         if (elements.length &&
             elements[elements.length - 1] === model.state.stackRef.current &&
             // Use `PopupStack.contains` instead of `ref.current.contains` so that the application can
@@ -29,15 +29,15 @@ export var useCloseOnOutsideClick = createElemPropsHook(usePopupModel)(function
             model.events.hide(event);
         }
     }, [model.state.stackRef, model.events]);
-    var visible = model.state.visibility !== 'hidden';
-    React.useLayoutEffect(function () {
+    const visible = model.state.visibility !== 'hidden';
+    React.useLayoutEffect(() => {
         var _a;
         if (!visible) {
             return;
         }
         document.addEventListener('mousedown', onClick);
         (_a = model.state.stackRef.current) === null || _a === void 0 ? void 0 : _a.setAttribute('data-behavior-click-outside-close', 'topmost');
-        return function () {
+        return () => {
             document.removeEventListener('mousedown', onClick);
         };
     }, [model.state.stackRef, visible, onClick]);

package/dist/es6/popup/lib/hooks/useCloseOnTargetHidden.js

@@ -5,7 +5,7 @@ function getScrollParent(element) {
     if (element === document.body || !element.parentElement) {
         return element;
     }
-    var styles = getComputedStyle(element);
+    const styles = getComputedStyle(element);
     if (styles.overflowY === 'scroll' ||
         styles.overflowY === 'auto' ||
         styles.overflowX === 'scroll' ||
@@ -23,26 +23,26 @@ function getScrollParent(element) {
  *
  * This should be used with popup elements that are transitory like Tooltips and dropdown menus.
  */
-export var useCloseOnTargetHidden = createElemPropsHook(usePopupModel)(function (model) {
-    var visible = model.state.visibility !== 'hidden';
-    var callback = React.useCallback(function (entries) {
+export const useCloseOnTargetHidden = createElemPropsHook(usePopupModel)(model => {
+    const visible = model.state.visibility !== 'hidden';
+    const callback = React.useCallback(entries => {
         if (entries[0].intersectionRatio < 0.5) {
             model.events.hide();
         }
     }, [model.events]);
-    React.useLayoutEffect(function () {
+    React.useLayoutEffect(() => {
         if (!visible || !model.state.targetRef.current) {
             return;
         }
-        var target = model.state.targetRef.current;
-        var scrollParent = getScrollParent(target);
+        const target = model.state.targetRef.current;
+        const scrollParent = getScrollParent(target);
         // eslint-disable-next-line compat/compat
-        var observer = new IntersectionObserver(callback, {
+        const observer = new IntersectionObserver(callback, {
             root: scrollParent,
             threshold: 0.5,
         });
         observer.observe(model.state.targetRef.current);
-        return function () {
+        return () => {
             observer.disconnect();
         };
     }, [callback, model.state.targetRef, visible]);

package/dist/es6/popup/lib/hooks/useDisableBodyScroll.js

@@ -8,19 +8,19 @@ import { usePopupModel } from './usePopupModel';
  * This should be used with popup elements that hide all other content and force the user to accept
  * or dismiss the popup before continuing (i.e. Modals).
  */
-export var useDisableBodyScroll = createElemPropsHook(usePopupModel)(function (model) {
-    var visible = model.state.visibility !== 'hidden';
-    React.useLayoutEffect(function () {
+export const useDisableBodyScroll = createElemPropsHook(usePopupModel)(model => {
+    const visible = model.state.visibility !== 'hidden';
+    React.useLayoutEffect(() => {
         if (!visible) {
             return;
         }
-        var overflowY = document.body.style.overflowY;
-        var overflowX = document.body.style.overflowX;
-        var overflow = document.body.style.overflow;
+        const overflowY = document.body.style.overflowY;
+        const overflowX = document.body.style.overflowX;
+        const overflow = document.body.style.overflow;
         document.body.style.overflow = 'hidden';
         document.body.style.overflowY = 'hidden';
         document.body.style.overflowX = 'hidden';
-        return function () {
+        return () => {
             document.body.style.overflow = overflow;
             document.body.style.overflowY = overflowY;
             document.body.style.overflowX = overflowX;

package/dist/es6/popup/lib/hooks/useFocusRedirect.js

@@ -13,11 +13,11 @@ import { usePopupModel } from './usePopupModel';
  *
  * This should be used with non-modal dialogs.
  */
-export var useFocusRedirect = createElemPropsHook(usePopupModel)(function (model) {
-    var onKeyDown = React.useCallback(function (event) {
+export const useFocusRedirect = createElemPropsHook(usePopupModel)(model => {
+    const onKeyDown = React.useCallback((event) => {
         if (model.state.stackRef.current && event.key === 'Tab') {
-            var firstFocusableElement = getFirstFocusableElement(model.state.stackRef.current);
-            var lastFocusableElement = getLastFocusableElement(model.state.stackRef.current);
+            const firstFocusableElement = getFirstFocusableElement(model.state.stackRef.current);
+            const lastFocusableElement = getLastFocusableElement(model.state.stackRef.current);
             if (event.getModifierState('Shift') && document.activeElement === firstFocusableElement) {
                 event.preventDefault();
                 model.events.hide(event);
@@ -28,14 +28,14 @@ export var useFocusRedirect = createElemPropsHook(usePopupModel)(function (model
             }
         }
     }, [model.events, model.state.stackRef]);
-    var visible = model.state.visibility !== 'hidden';
+    const visible = model.state.visibility !== 'hidden';
     // `useLayoutEffect` for automation
-    React.useLayoutEffect(function () {
+    React.useLayoutEffect(() => {
         if (!visible) {
             return;
         }
         document.addEventListener('keydown', onKeyDown);
-        return function () {
+        return () => {
             document.removeEventListener('keydown', onKeyDown);
         };
     }, [visible, onKeyDown]);

package/dist/es6/popup/lib/hooks/useFocusTrap.js

@@ -11,20 +11,20 @@ import { usePopupModel } from './usePopupModel';
  *
  * This should be used on popup elements that need to hide content (i.e. Modals).
  */
-export var useFocusTrap = createElemPropsHook(usePopupModel)(function (model) {
-    var onKeyDown = React.useCallback(function (event) {
+export const useFocusTrap = createElemPropsHook(usePopupModel)(model => {
+    const onKeyDown = React.useCallback((event) => {
         if (model.state.stackRef.current) {
             tabTrappingKey(event, model.state.stackRef.current);
         }
     }, [model.state.stackRef]);
-    var visible = model.state.visibility !== 'hidden';
+    const visible = model.state.visibility !== 'hidden';
     // `useLayoutEffect` for automation
-    React.useLayoutEffect(function () {
+    React.useLayoutEffect(() => {
         if (!visible) {
             return;
         }
         document.addEventListener('keydown', onKeyDown);
-        return function () {
+        return () => {
             document.removeEventListener('keydown', onKeyDown);
         };
     }, [visible, onKeyDown]);

package/dist/es6/popup/lib/hooks/useInitialFocus.js

@@ -9,19 +9,19 @@ import { usePopupModel } from './usePopupModel';
  * This should be used for popups that have focusable elements inside, like Modals, non-modal
  * dialogs, menus, etc.
  */
-export var useInitialFocus = createElemPropsHook(usePopupModel)(function (model) {
-    var visible = model.state.visibility !== 'hidden';
+export const useInitialFocus = createElemPropsHook(usePopupModel)(model => {
+    const visible = model.state.visibility !== 'hidden';
     // Using `useEffect` instead of `useLayoutEffect` so that focus doesn't change _before_ PopperJS
     // has positioned the Popup. If we change focus before positioning, the browser will scroll to the
     // top of the page.
-    React.useEffect(function () {
+    React.useEffect(() => {
         var _a;
         if (visible && model.state.stackRef.current) {
-            var element_1 = ((_a = model.state.initialFocusRef) === null || _a === void 0 ? void 0 : _a.current) ||
+            const element = ((_a = model.state.initialFocusRef) === null || _a === void 0 ? void 0 : _a.current) ||
                 getFirstFocusableElement(model.state.stackRef.current);
-            assert(element_1, 'No focusable element was found. Please ensure popup has at least one focusable element');
-            requestAnimationFrame(function () {
-                changeFocus(element_1);
+            assert(element, 'No focusable element was found. Please ensure popup has at least one focusable element');
+            requestAnimationFrame(() => {
+                changeFocus(element);
             });
         }
     }, [model.state.initialFocusRef, model.state.stackRef, visible]);

package/dist/es6/popup/lib/hooks/usePopupCard.js

@@ -3,8 +3,7 @@ import { usePopupModel } from './usePopupModel';
 /**
  * Adds the necessary props to a {@link PopupCard Popup.Card} subcomponent.
  */
-export var usePopupCard = createElemPropsHook(usePopupModel)(function (_a) {
-    var state = _a.state;
+export const usePopupCard = createElemPropsHook(usePopupModel)(({ state }) => {
     return {
         role: 'dialog',
         'aria-labelledby': state.id,

package/dist/es6/popup/lib/hooks/usePopupCloseButton.js

@@ -5,8 +5,7 @@ import { usePopupModel } from './usePopupModel';
  * {@link PopupCloseButton Popup.CloseButton} subcomponent and
  * {@link PopupCloseIcon Popup.CloseIcon} subcomponent.
  */
-export var usePopupCloseButton = createElemPropsHook(usePopupModel)(function (_a) {
-    var events = _a.events;
+export const usePopupCloseButton = createElemPropsHook(usePopupModel)(({ events }) => {
     return {
         onClick: events.hide,
     };

package/dist/es6/popup/lib/hooks/usePopupHeading.js

@@ -3,8 +3,7 @@ import { usePopupModel } from './usePopupModel';
 /**
  * Adds the necessary props to the {@link PopupHeading Popup.Heading} subcomponent.
  */
-export var usePopupHeading = createElemPropsHook(usePopupModel)(function (_a) {
-    var state = _a.state;
+export const usePopupHeading = createElemPropsHook(usePopupModel)(({ state }) => {
     return {
         id: state.id,
     };

package/dist/es6/popup/lib/hooks/usePopupModel.js

@@ -1,78 +1,73 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import * as React from 'react';
 import { createModelHook } from '@workday/canvas-kit-react/common';
 import { useDisclosureModel } from '@workday/canvas-kit-react/disclosure';
 // eslint-disable-next-line no-empty-function
-var noop = function () { };
-export var usePopupModel = createModelHook({
+const noop = () => { };
+export const usePopupModel = createModelHook({
     // create enough of a model to use `Popup.Card` without a `Popup` container component.
     defaultContext: { state: {}, events: { show: noop, hide: noop } },
-    defaultConfig: __assign(__assign({}, useDisclosureModel.defaultConfig), { 
+    defaultConfig: {
+        ...useDisclosureModel.defaultConfig,
         /**
          * Optional reference to an element that should receive focus when a popup is hidden. If left
          * blank, focus will return to the `targetRef`
          */
-        returnFocusRef: undefined, 
+        returnFocusRef: undefined,
         /**
          * Optional reference to an element that should receive focus when a popup is shown. If left blank,
          * focus will be moved to the first focusable element inside the popup.
          */
-        initialFocusRef: undefined }),
+        initialFocusRef: undefined,
+    },
     requiredConfig: useDisclosureModel.requiredConfig,
-})(function (config) {
-    var stackRef = React.useRef(null);
-    var targetRef = React.useRef(null);
-    var _a = React.useState('bottom'), placement = _a[0], setPlacement = _a[1];
-    var disclosure = useDisclosureModel(config);
-    var state = __assign(__assign({}, disclosure.state), { 
+})(config => {
+    const stackRef = React.useRef(null);
+    const targetRef = React.useRef(null);
+    const [placement, setPlacement] = React.useState('bottom');
+    const disclosure = useDisclosureModel(config);
+    const state = {
+        ...disclosure.state,
         /**
          * Reference of the stack item used in the PopupStack. This value will be used in all
          * Popup-related behaviors.
          */
-        stackRef: stackRef,
+        stackRef,
         /**
          * Reference of the target element. This will point to the element that triggered the showing of a
          * Popup and is used in Popup-related behaviors.
          */
-        targetRef: targetRef, 
+        targetRef,
         /**
          * Optional reference to an element that should receive focus when a popup is shown. If left blank,
          * focus will be moved to the first focusable element inside the popup.
          */
-        initialFocusRef: config.initialFocusRef, 
+        initialFocusRef: config.initialFocusRef,
         /**
          * Optional reference to an element that should receive focus when a popup is hidden. If left
          * blank, focus will return to the `targetRef`
          */
-        returnFocusRef: config.returnFocusRef, 
+        returnFocusRef: config.returnFocusRef,
         /**
          * The placement chosen by the positioning Popper. This should get set prior to showing the popup
          * content.
          * @default 'bottom'
          */
-        placement: placement });
-    var events = __assign(__assign({}, disclosure.events), { 
+        placement,
+    };
+    const events = {
+        ...disclosure.events,
         /**
          * Called whenever a popup placement changes around a target. This is useful for animations that
          * depend on the placement chosen.
          */
-        updatePlacement: function (data) {
+        updatePlacement(data) {
             setPlacement(data.placement);
-        } });
+        },
+    };
     return {
-        state: state,
-        events: events,
+        state,
+        events,
     };
 });
 // create enough of a model to use `Popup.Card` without a `Popup` container component.
-export var PopupModelContext = usePopupModel.Context;
+export const PopupModelContext = usePopupModel.Context;

package/dist/es6/popup/lib/hooks/usePopupPopper.js

@@ -5,19 +5,18 @@ import React from 'react';
  * Adds the necessary props to a {@link Popper} component. Used by the
  * {@link PopupPopper Popup.Popper} subcomponent.
  */
-export var usePopupPopper = createElemPropsHook(usePopupModel)(function (_a, ref) {
-    var state = _a.state, events = _a.events;
-    var elementRef = useForkRef(ref, state.stackRef);
-    var onPlacementChange = React.useCallback(function (placement) {
+export const usePopupPopper = createElemPropsHook(usePopupModel)(({ state, events }, ref) => {
+    const elementRef = useForkRef(ref, state.stackRef);
+    const onPlacementChange = React.useCallback((placement) => {
         if (placement !== state.placement) {
             // only update if the placement has changed
-            events.updatePlacement({ placement: placement });
+            events.updatePlacement({ placement });
         }
     }, [events, state.placement]);
     return {
         open: state.visibility !== 'hidden',
         anchorElement: state.targetRef,
         ref: elementRef,
-        onPlacementChange: onPlacementChange,
+        onPlacementChange,
     };
 });

package/dist/es6/popup/lib/hooks/usePopupStack.js

@@ -43,36 +43,36 @@ import { useLocalRef, useIsRTL } from '@workday/canvas-kit-react/common';
  * by all ephemeral-type popups (like Tooltips, Select menus, etc). It will also add in clickOutside
  * detection.
  */
-export var usePopupStack = function (ref, target) {
-    var _a = useLocalRef(ref), elementRef = _a.elementRef, localRef = _a.localRef;
-    var isRTL = useIsRTL();
+export const usePopupStack = (ref, target) => {
+    const { elementRef, localRef } = useLocalRef(ref);
+    const isRTL = useIsRTL();
     // useState function input ensures we only create a container once.
-    var popupRef = React.useState(function () {
-        var container = PopupStack.createContainer();
+    const [popupRef] = React.useState(() => {
+        const container = PopupStack.createContainer();
         elementRef(container);
         return container;
-    })[0];
+    });
     // We useLayoutEffect to ensure proper timing of registration of the element to the popup stack.
     // Without this, the timing is unpredictable when mixed with other frameworks. Other frameworks
     // should also register as soon as the element is available
-    React.useLayoutEffect(function () {
+    React.useLayoutEffect(() => {
         if (popupRef !== localRef.current) {
-            throw Error("The 'ref' passed to usePopupStack should not be applied to a React element. This will cause a runtime error where the PopupStack and React compete for the element. Instead use ReactDOM.createPortal(<YourComponent />, ref.current)");
+            throw Error(`The 'ref' passed to usePopupStack should not be applied to a React element. This will cause a runtime error where the PopupStack and React compete for the element. Instead use ReactDOM.createPortal(<YourComponent />, ref.current)`);
         }
-        var targetEl = target
+        const targetEl = target
             ? 'current' in target
                 ? target.current || undefined
                 : target
             : undefined;
-        var element = localRef.current;
+        const element = localRef.current;
         PopupStack.add({ element: element, owner: targetEl });
-        return function () {
+        return () => {
             PopupStack.remove(element);
         };
     }, [localRef, target, popupRef]);
     // The direction will properly follow the theme via React context, but portals lose the `dir`
     // hierarchy, so we'll add it back here.
-    React.useLayoutEffect(function () {
+    React.useLayoutEffect(() => {
         var _a, _b;
         if (isRTL) {
             (_a = localRef.current) === null || _a === void 0 ? void 0 : _a.setAttribute('dir', 'rtl');

package/dist/es6/popup/lib/hooks/usePopupTarget.js

@@ -3,12 +3,11 @@ import { usePopupModel } from './usePopupModel';
 /**
  * Adds the necessary props to a {@link PopupTarget Popup.Target} subcomponent.
  */
-export var usePopupTarget = createElemPropsHook(usePopupModel)(function (_a, ref) {
-    var events = _a.events, state = _a.state;
-    var elementRef = useForkRef(ref, state.targetRef);
+export const usePopupTarget = createElemPropsHook(usePopupModel)(({ events, state }, ref) => {
+    const elementRef = useForkRef(ref, state.targetRef);
     return {
         ref: elementRef,
-        onClick: function (event) {
+        onClick: (event) => {
             // If we're wrapping a target component that doesn't handle ref forwarding, update the
             // `state.targetRef` manually. This ensures that custom target components don't need to handle
             // ref forwarding since ref forwarding is only really needed to programmatically open popups

package/dist/es6/popup/lib/hooks/usePopupTargetContext.js

@@ -3,12 +3,11 @@ import { usePopupModel } from './usePopupModel';
 /**
  * Adds the necessary props to a `Target` component. Used by the Popup.Target subcomponent.
  */
-export var usePopupTargetContext = createElemPropsHook(usePopupModel)(function (_a, ref) {
-    var events = _a.events, state = _a.state;
-    var elementRef = useForkRef(ref, state.targetRef);
+export const usePopupTargetContext = createElemPropsHook(usePopupModel)(({ events, state }, ref) => {
+    const elementRef = useForkRef(ref, state.targetRef);
     return {
         ref: elementRef,
-        onContextMenu: function (event) {
+        onContextMenu: (event) => {
             // If we're wrapping a target component that doesn't handle ref forwarding, update the
             // `state.targetRef` manually. This ensures that custom target components don't need to handle
             // ref forwarding since ref forwarding is only really needed to programmatically open popups