@azure/communication-react 1.4.0 → 1.4.1-beta.1

package/dist/dist-esm/react-components/src/components/ModalClone/ModalClone.js

@@ -8,12 +8,9 @@
 import * as React from 'react';
 import { useBoolean, useMergedRefs, useConst, useSetTimeout, useId, useUnmount } from '@fluentui/react-hooks';
 import { allowOverscrollOnElement, allowScrollOnElement, AnimationVariables, classNamesFunction, DirectionalHint, elementContains, EventGroup, FocusTrapZone, getGlobalClassNames, getPropsWithDefaults, Icon, KeyCodes, Layer, memoizeFunction, mergeStyles, on, Overlay, Popup, ResponsiveMode, styled, useResponsiveMode, ZIndexes } from '@fluentui/react';
-import { useWindow } from '@fluentui/react-window-provider'; // @TODO - need to change this to a panel whenever the breakpoint is under medium (verify the spec)
+import { useWindow } from '@fluentui/react-window-provider';
 const animationDuration = AnimationVariables.durationValue2;
-const ZERO = {
-    x: 0,
-    y: 0
-};
+const ZERO = { x: 0, y: 0 };
 const DEFAULT_PROPS = {
     isOpen: false,
     isDarkOverlay: true,
@@ -85,7 +82,8 @@ const ModalBase = React.forwardRef((propsWithoutDefaults, ref) => {
         windowInnerHeight: win === null || win === void 0 ? void 0 : win.innerHeight,
         isDefaultDragHandle: dragOptions && !dragOptions.dragHandleSelector
     });
-    const mergedLayerProps = Object.assign(Object.assign({ eventBubblingEnabled: false }, layerProps), { onLayerDidMount: layerProps && layerProps.onLayerDidMount ? layerProps.onLayerDidMount : onLayerDidMount, insertFirst: isModeless, className: classNames.layer }); // Allow the user to scroll within the modal but not on the body
+    const mergedLayerProps = Object.assign(Object.assign({ eventBubblingEnabled: false }, layerProps), { onLayerDidMount: layerProps && layerProps.onLayerDidMount ? layerProps.onLayerDidMount : onLayerDidMount, insertFirst: isModeless, className: classNames.layer });
+    // Allow the user to scroll within the modal but not on the body
     const allowScrollOnModal = React.useCallback((elt) => {
         if (elt) {
             if (internalState.allowTouchBodyScroll) {
@@ -109,14 +107,9 @@ const ModalBase = React.forwardRef((propsWithoutDefaults, ref) => {
             }
             if (keepInBounds) {
                 // x/y are unavailable in IE, so use the equivalent left/top
-                internalState.minPosition = minDragPosition !== null && minDragPosition !== void 0 ? minDragPosition : {
-                    x: -modalRectangle.left,
-                    y: -modalRectangle.top
-                };
-                internalState.maxPosition = maxDragPosition !== null && maxDragPosition !== void 0 ? maxDragPosition : {
-                    x: modalRectangle.left,
-                    y: modalRectangle.top
-                }; // Make sure the initial co-ordinates are within clamp bounds.
+                internalState.minPosition = minDragPosition !== null && minDragPosition !== void 0 ? minDragPosition : { x: -modalRectangle.left, y: -modalRectangle.top };
+                internalState.maxPosition = maxDragPosition !== null && maxDragPosition !== void 0 ? maxDragPosition : { x: modalRectangle.left, y: modalRectangle.top };
+                // Make sure the initial co-ordinates are within clamp bounds.
                 setCoordinates({
                     x: getClampedAxis('x', coordinates.x),
                     y: getClampedAxis('y', coordinates.y)
@@ -152,9 +145,10 @@ const ModalBase = React.forwardRef((propsWithoutDefaults, ref) => {
         setModalMenuClose();
         internalState.isInKeyboardMoveMode = false;
     }, [internalState, setModalMenuClose]);
-    const handleDrag = React.useCallback(// eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const handleDrag = React.useCallback(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     (ev, dragData) => {
-        setCoordinates(prevValue => ({
+        setCoordinates((prevValue) => ({
             x: getClampedAxis('x', prevValue.x + dragData.delta.x),
             y: getClampedAxis('y', prevValue.y + dragData.delta.y)
         }));
@@ -190,49 +184,32 @@ const ModalBase = React.forwardRef((propsWithoutDefaults, ref) => {
                     /* eslint-disable no-fallthrough */
                     case KeyCodes.escape:
                         setCoordinates(internalState.lastSetCoordinates);
-                    case KeyCodes.enter:
-                        {
-                            // TODO: determine if fallthrough was intentional
-                            /* eslint-enable no-fallthrough */
-                            internalState.lastSetCoordinates = ZERO; // setIsInKeyboardMoveMode(false);
-                            break;
-                        }
-                    case KeyCodes.up:
-                        {
-                            setCoordinates(prevValue => ({
-                                x: prevValue.x,
-                                y: getClampedAxis('y', prevValue.y - delta)
-                            }));
-                            break;
-                        }
-                    case KeyCodes.down:
-                        {
-                            setCoordinates(prevValue => ({
-                                x: prevValue.x,
-                                y: getClampedAxis('y', prevValue.y + delta)
-                            }));
-                            break;
-                        }
-                    case KeyCodes.left:
-                        {
-                            setCoordinates(prevValue => ({
-                                x: getClampedAxis('x', prevValue.x - delta),
-                                y: prevValue.y
-                            }));
-                            break;
-                        }
-                    case KeyCodes.right:
-                        {
-                            setCoordinates(prevValue => ({
-                                x: getClampedAxis('x', prevValue.x + delta),
-                                y: prevValue.y
-                            }));
-                            break;
-                        }
-                    default:
-                        {
-                            handledEvent = false;
-                        }
+                    case KeyCodes.enter: {
+                        // TODO: determine if fallthrough was intentional
+                        /* eslint-enable no-fallthrough */
+                        internalState.lastSetCoordinates = ZERO;
+                        // setIsInKeyboardMoveMode(false);
+                        break;
+                    }
+                    case KeyCodes.up: {
+                        setCoordinates((prevValue) => ({ x: prevValue.x, y: getClampedAxis('y', prevValue.y - delta) }));
+                        break;
+                    }
+                    case KeyCodes.down: {
+                        setCoordinates((prevValue) => ({ x: prevValue.x, y: getClampedAxis('y', prevValue.y + delta) }));
+                        break;
+                    }
+                    case KeyCodes.left: {
+                        setCoordinates((prevValue) => ({ x: getClampedAxis('x', prevValue.x - delta), y: prevValue.y }));
+                        break;
+                    }
+                    case KeyCodes.right: {
+                        setCoordinates((prevValue) => ({ x: getClampedAxis('x', prevValue.x + delta), y: prevValue.y }));
+                        break;
+                    }
+                    default: {
+                        handledEvent = false;
+                    }
                 }
                 if (handledEvent) {
                     ev.preventDefault();
@@ -243,13 +220,9 @@ const ModalBase = React.forwardRef((propsWithoutDefaults, ref) => {
         internalState.lastSetCoordinates = coordinates;
         setModalMenuClose();
         internalState.isInKeyboardMoveMode = true;
-        internalState.events.on(win, 'keydown', handleKeyDown, true
-        /* useCapture */
-        );
+        internalState.events.on(win, 'keydown', handleKeyDown, true /* useCapture */);
         internalState.disposeOnKeyDown = () => {
-            internalState.events.off(win, 'keydown', handleKeyDown, true
-            /* useCapture */
-            );
+            internalState.events.off(win, 'keydown', handleKeyDown, true /* useCapture */);
             internalState.disposeOnKeyDown = undefined;
         };
     };
@@ -272,57 +245,56 @@ const ModalBase = React.forwardRef((propsWithoutDefaults, ref) => {
             }
         };
         if (!internalState.disposeOnKeyUp) {
-            internalState.events.on(win, 'keyup', handleKeyUp, true
-            /* useCapture */
-            );
+            internalState.events.on(win, 'keyup', handleKeyUp, true /* useCapture */);
             internalState.disposeOnKeyUp = () => {
-                internalState.events.off(win, 'keyup', handleKeyUp, true
-                /* useCapture */
-                );
+                internalState.events.off(win, 'keyup', handleKeyUp, true /* useCapture */);
                 internalState.disposeOnKeyUp = undefined;
             };
         }
     };
     React.useEffect(() => {
-        clearTimeout(internalState.onModalCloseTimer); // Opening the dialog
+        clearTimeout(internalState.onModalCloseTimer);
+        // Opening the dialog
         if (isOpen) {
             // This must be done after the modal content has rendered
             requestAnimationFrame(() => setTimeout(registerInitialModalPosition, 0));
-            setIsModalOpen(true); // Add a keyUp handler for all key up events once the dialog is open.
+            setIsModalOpen(true);
+            // Add a keyUp handler for all key up events once the dialog is open.
             if (dragOptions) {
                 registerForKeyUp();
             }
             internalState.hasBeenOpened = true;
             setIsVisible(true);
-        } // Closing the dialog
+        }
+        // Closing the dialog
         if (!isOpen && isModalOpen) {
             internalState.onModalCloseTimer = setTimeout(handleModalClose, parseFloat(animationDuration) * 1000);
             setIsVisible(false);
-        } // eslint-disable-next-line react-hooks/exhaustive-deps -- should only run if isModalOpen or isOpen mutates or if min/max drag bounds are updated.
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- should only run if isModalOpen or isOpen mutates or if min/max drag bounds are updated.
     }, [isModalOpen, isOpen, minDragPosition, maxDragPosition]);
     useUnmount(() => {
         internalState.events.dispose();
     });
     useComponentRef(props, focusTrapZone);
-    const modalContent = React.createElement(FocusTrapZone, { disabled: true, id: focusTrapZoneId, ref: focusTrapZoneElm, componentRef: focusTrapZone, className: classNames.main, elementToFocusOnDismiss: elementToFocusOnDismiss, isClickableOutsideFocusTrap: isModeless || isClickableOutsideFocusTrap || !isBlocking, ignoreExternalFocusing: ignoreExternalFocusing, forceFocusInsideTrap: forceFocusInsideTrap && !isModeless, firstFocusableSelector: firstFocusableSelector, focusPreviouslyFocusedInnerElement: true, onBlur: internalState.isInKeyboardMoveMode ? handleExitKeyboardMoveMode : undefined },
-        dragOptions && internalState.isInKeyboardMoveMode && React.createElement("div", { className: classNames.keyboardMoveIconContainer }, dragOptions.keyboardMoveIconProps ? React.createElement(Icon, Object.assign({}, dragOptions.keyboardMoveIconProps)) : React.createElement(Icon, { iconName: "move", className: classNames.keyboardMoveIcon })),
+    const modalContent = (React.createElement(FocusTrapZone, { disabled: true, id: focusTrapZoneId, ref: focusTrapZoneElm, componentRef: focusTrapZone, className: classNames.main, elementToFocusOnDismiss: elementToFocusOnDismiss, isClickableOutsideFocusTrap: isModeless || isClickableOutsideFocusTrap || !isBlocking, ignoreExternalFocusing: ignoreExternalFocusing, forceFocusInsideTrap: forceFocusInsideTrap && !isModeless, firstFocusableSelector: firstFocusableSelector, focusPreviouslyFocusedInnerElement: true, onBlur: internalState.isInKeyboardMoveMode ? handleExitKeyboardMoveMode : undefined },
+        dragOptions && internalState.isInKeyboardMoveMode && (React.createElement("div", { className: classNames.keyboardMoveIconContainer }, dragOptions.keyboardMoveIconProps ? (React.createElement(Icon, Object.assign({}, dragOptions.keyboardMoveIconProps))) : (React.createElement(Icon, { iconName: "move", className: classNames.keyboardMoveIcon })))),
         React.createElement("div", { ref: allowScrollOnModal, className: classNames.scrollableContent, "data-is-scrollable": true },
-            dragOptions && isModalMenuOpen && React.createElement(dragOptions.menu, { items: [{
-                        key: 'move',
-                        text: dragOptions.moveMenuItemText,
-                        onClick: handleEnterKeyboardMoveMode
-                    }, {
-                        key: 'close',
-                        text: dragOptions.closeMenuItemText,
-                        onClick: handleModalClose
-                    }], onDismiss: setModalMenuClose, alignTargetEdge: true, coverTarget: true, directionalHint: DirectionalHint.topLeftEdge, directionalHintFixed: true, shouldFocusOnMount: true, target: internalState.scrollableContent }),
-            children));
-    return ( // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    isModalOpen && modalResponsiveMode >= (responsiveMode || ResponsiveMode.small) && React.createElement(Layer, Object.assign({ ref: mergedRef }, mergedLayerProps),
-        React.createElement(Popup, { role: isAlertRole ? 'alertdialog' : 'dialog', ariaLabelledBy: titleAriaId, ariaDescribedBy: subtitleAriaId, shouldRestoreFocus: !ignoreExternalFocusing, "aria-modal": !isModeless },
+            dragOptions && isModalMenuOpen && (React.createElement(dragOptions.menu, { items: [
+                    { key: 'move', text: dragOptions.moveMenuItemText, onClick: handleEnterKeyboardMoveMode },
+                    { key: 'close', text: dragOptions.closeMenuItemText, onClick: handleModalClose }
+                ], onDismiss: setModalMenuClose, alignTargetEdge: true, coverTarget: true, directionalHint: DirectionalHint.topLeftEdge, directionalHintFixed: true, shouldFocusOnMount: true, target: internalState.scrollableContent })),
+            children)));
+    return (
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    (isModalOpen && modalResponsiveMode >= (responsiveMode || ResponsiveMode.small) && (React.createElement(Layer, Object.assign({ ref: mergedRef }, mergedLayerProps),
+        React.createElement(Popup, { role: isAlertRole ? 'alertdialog' : 'dialog', ariaLabelledBy: titleAriaId, ariaDescribedBy: subtitleAriaId, 
+            // onDismiss={onDismiss}
+            shouldRestoreFocus: !ignoreExternalFocusing, "aria-modal": !isModeless },
             React.createElement("div", { className: classNames.root, role: !isModeless ? 'document' : undefined },
-                !isModeless && React.createElement(Overlay, Object.assign({ "aria-hidden": true, isDarkThemed: isDarkOverlay, onClick: isBlocking ? undefined : onDismiss, allowTouchBodyScroll: allowTouchBodyScroll }, overlay)),
-                dragOptions ? React.createElement(DraggableZone, { handleSelector: dragOptions.dragHandleSelector || `#${focusTrapZoneId}`, preventDragSelector: "button", onStart: handleDragStart, onDragChange: handleDrag, onStop: handleDragStop, position: coordinates }, modalContent) : modalContent))) || null);
+                !isModeless && (React.createElement(Overlay, Object.assign({ "aria-hidden": true, isDarkThemed: isDarkOverlay, onClick: isBlocking ? undefined : onDismiss, allowTouchBodyScroll: allowTouchBodyScroll }, overlay))),
+                dragOptions ? (React.createElement(DraggableZone, { handleSelector: dragOptions.dragHandleSelector || `#${focusTrapZoneId}`, preventDragSelector: "button", onStart: handleDragStart, onDragChange: handleDrag, onStop: handleDragStop, position: coordinates }, modalContent)) : (modalContent)))))) ||
+        null);
 });
 ModalBase.displayName = 'ModalBase';
 const getDraggableZoneClassNames = memoizeFunction((className, isDragging) => {
@@ -348,7 +320,7 @@ const eventMapping = {
         move: 'mousemove',
         stop: 'mouseup'
     }
-}; // These are needed so that we can generalize the events
+};
 class DraggableZone extends React.Component {
     constructor(props) {
         super(props);
@@ -390,11 +362,15 @@ class DraggableZone extends React.Component {
             // Only handle left click for dragging
             if (typeof event.button === 'number' && event.button !== 0) {
                 return false;
-            } // If the target doesn't match the handleSelector OR
+            }
+            // If the target doesn't match the handleSelector OR
             // if the target does match the preventDragSelector, bail out
-            if (this.props.handleSelector && !this._matchesSelector(event.target, this.props.handleSelector) || this.props.preventDragSelector && this._matchesSelector(event.target, this.props.preventDragSelector)) {
+            if ((this.props.handleSelector && !this._matchesSelector(event.target, this.props.handleSelector)) ||
+                (this.props.preventDragSelector &&
+                    this._matchesSelector(event.target, this.props.preventDragSelector))) {
                 return;
-            } // Remember the touch identifier if this is a touch event so we can
+            }
+            // Remember the touch identifier if this is a touch event so we can
             // distinguish between individual touches in multitouch scenarios
             // by remembering which touch point we were given
             this._touchId = this._getTouchId(event);
@@ -407,13 +383,13 @@ class DraggableZone extends React.Component {
             this.setState({
                 isDragging: true,
                 lastPosition: position
-            }); // hook up the appropriate mouse/touch events to the body to ensure
+            });
+            // hook up the appropriate mouse/touch events to the body to ensure
             // smooth dragging
-            this._events = [on(document.body, this._currentEventType.move, this._onDrag, true
-                /* use capture phase */
-                ), on(document.body, this._currentEventType.stop, this._onDragStop, true
-                /* use capture phase */
-                )];
+            this._events = [
+                on(document.body, this._currentEventType.move, this._onDrag, true /* use capture phase */),
+                on(document.body, this._currentEventType.stop, this._onDragStop, true /* use capture phase */)
+            ];
             return;
         };
         this._onDrag = (event) => {
@@ -424,7 +400,8 @@ class DraggableZone extends React.Component {
             const position = this._getControlPosition(event);
             if (!position) {
                 return;
-            } // create the updated drag data from the position data
+            }
+            // create the updated drag data from the position data
             const updatedData = this._createUpdatedDragData(this._createDragDataFromPosition(position));
             const updatedPosition = updatedData.position;
             this.props.onDragChange && this.props.onDragChange(event, updatedData);
@@ -441,7 +418,8 @@ class DraggableZone extends React.Component {
             if (!position) {
                 return;
             }
-            const baseDragData = this._createDragDataFromPosition(position); // Set dragging to false and reset the lastPosition
+            const baseDragData = this._createDragDataFromPosition(position);
+            // Set dragging to false and reset the lastPosition
             this.setState({
                 isDragging: false,
                 lastPosition: undefined
@@ -451,27 +429,23 @@ class DraggableZone extends React.Component {
                 this.setState({
                     position: this.props.position
                 });
-            } // Remove event handlers
-            this._events.forEach(dispose => dispose());
+            }
+            // Remove event handlers
+            this._events.forEach((dispose) => dispose());
         };
         this.state = {
             isDragging: false,
-            position: this.props.position || {
-                x: 0,
-                y: 0
-            },
+            position: this.props.position || { x: 0, y: 0 },
             lastPosition: undefined
         };
     }
     componentDidUpdate(prevProps) {
         if (this.props.position && (!prevProps.position || this.props.position !== prevProps.position)) {
-            this.setState({
-                position: this.props.position
-            });
+            this.setState({ position: this.props.position });
         }
     }
     componentWillUnmount() {
-        this._events.forEach(dispose => dispose());
+        this._events.forEach((dispose) => dispose());
     }
     render() {
         const child = React.Children.only(this.props.children);
@@ -498,7 +472,8 @@ class DraggableZone extends React.Component {
      * @param event - The event to get offsets from
      */
     _getControlPosition(event) {
-        const touchObj = this._getActiveTouch(event); // did we get the right touch?
+        const touchObj = this._getActiveTouch(event);
+        // did we get the right touch?
         if (this._touchId !== undefined && !touchObj) {
             return undefined;
         }
@@ -513,14 +488,15 @@ class DraggableZone extends React.Component {
      * @param event - The event used to get the TouchList for the active touch point
      */
     _getActiveTouch(event) {
-        return event.targetTouches && this._findTouchInTouchList(event.targetTouches) || event.changedTouches && this._findTouchInTouchList(event.changedTouches);
+        return ((event.targetTouches && this._findTouchInTouchList(event.targetTouches)) ||
+            (event.changedTouches && this._findTouchInTouchList(event.changedTouches)));
     }
     /**
      * Get the initial touch identifier associated with the given event
      * @param event - The event that contains the TouchList
      */
     _getTouchId(event) {
-        const touch = event.targetTouches && event.targetTouches[0] || event.changedTouches && event.changedTouches[0];
+        const touch = (event.targetTouches && event.targetTouches[0]) || (event.changedTouches && event.changedTouches[0]);
         if (touch) {
             return touch.identifier;
         }
@@ -532,9 +508,9 @@ class DraggableZone extends React.Component {
     _matchesSelector(element, selector) {
         if (!element || element === document.body) {
             return false;
-        } // eslint-disable-next-line @typescript-eslint/ban-types
-        const matchesSelectorFn = element.matches || element.webkitMatchesSelector || element.msMatchesSelector;
-        /* for IE */
+        }
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        const matchesSelectorFn = element.matches || element.webkitMatchesSelector || element.msMatchesSelector; /* for IE */
         if (!matchesSelectorFn) {
             return false;
         }
@@ -560,14 +536,12 @@ class DraggableZone extends React.Component {
      * @param position The new position as part of the drag
      */
     _createDragDataFromPosition(position) {
-        const { lastPosition } = this.state; // If we have no lastPosition, use the given position
+        const { lastPosition } = this.state;
+        // If we have no lastPosition, use the given position
         // for last position
         if (lastPosition === undefined) {
             return {
-                delta: {
-                    x: 0,
-                    y: 0
-                },
+                delta: { x: 0, y: 0 },
                 lastPosition: position,
                 position
             };
@@ -609,7 +583,10 @@ const getStyles = (props) => {
     const { palette, effects, fonts } = theme;
     const classNames = getGlobalClassNames(globalClassNames, theme);
     return {
-        root: [classNames.root, fonts.medium, {
+        root: [
+            classNames.root,
+            fonts.medium,
+            {
                 backgroundColor: 'transparent',
                 position: isModeless ? 'absolute' : 'fixed',
                 height: '100%',
@@ -620,13 +597,22 @@ const getStyles = (props) => {
                 opacity: 0,
                 pointerEvents: 'none',
                 transition: `opacity ${animationDuration}`
-            }, topOffsetFixed && typeof modalRectangleTop === 'number' && hasBeenOpened && {
+            },
+            topOffsetFixed &&
+                typeof modalRectangleTop === 'number' &&
+                hasBeenOpened && {
                 alignItems: 'flex-start'
-            }, isOpen && classNames.isOpen, isVisible && {
+            },
+            isOpen && classNames.isOpen,
+            isVisible && {
                 opacity: 1,
                 pointerEvents: 'auto'
-            }, className],
-        main: [classNames.main, {
+            },
+            className
+        ],
+        main: [
+            classNames.main,
+            {
                 boxShadow: effects.elevation64,
                 borderRadius: effects.roundedCorner2,
                 backgroundColor: palette.white,
@@ -640,12 +626,20 @@ const getStyles = (props) => {
                 minWidth: '288px',
                 overflowY: 'auto',
                 zIndex: isModeless ? ZIndexes.Layer : undefined
-            }, topOffsetFixed && typeof modalRectangleTop === 'number' && hasBeenOpened && {
+            },
+            topOffsetFixed &&
+                typeof modalRectangleTop === 'number' &&
+                hasBeenOpened && {
                 top: modalRectangleTop
-            }, isDefaultDragHandle && {
+            },
+            isDefaultDragHandle && {
                 cursor: 'move'
-            }, containerClassName],
-        scrollableContent: [classNames.scrollableContent, {
+            },
+            containerClassName
+        ],
+        scrollableContent: [
+            classNames.scrollableContent,
+            {
                 overflowY: 'auto',
                 flexGrow: 1,
                 maxHeight: '100vh',
@@ -654,12 +648,18 @@ const getStyles = (props) => {
                         maxHeight: windowInnerHeight
                     }
                 }
-            }, scrollableContentClassName],
-        layer: isModeless && [layerClassName, classNames.layer, {
+            },
+            scrollableContentClassName
+        ],
+        layer: isModeless && [
+            layerClassName,
+            classNames.layer,
+            {
                 position: 'static',
                 width: 'unset',
                 height: 'unset'
-            }],
+            }
+        ],
         keyboardMoveIconContainer: {
             position: 'absolute',
             display: 'flex',