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

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

@@ -8,9 +8,12 @@
 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';
+import { useWindow } from '@fluentui/react-window-provider'; // @TODO - need to change this to a panel whenever the breakpoint is under medium (verify the spec)
 const animationDuration = AnimationVariables.durationValue2;
-const ZERO = { x: 0, y: 0 };
+const ZERO = {
+    x: 0,
+    y: 0
+};
 const DEFAULT_PROPS = {
     isOpen: false,
     isDarkOverlay: true,
@@ -82,8 +85,7 @@ 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) {
@@ -107,9 +109,14 @@ 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)
@@ -145,10 +152,9 @@ 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)
         }));
@@ -184,32 +190,49 @@ 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();
@@ -220,9 +243,13 @@ 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;
         };
     };
@@ -245,56 +272,57 @@ 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, 
-            // onDismiss={onDismiss}
-            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, 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) => {
@@ -320,7 +348,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);
@@ -362,15 +390,11 @@ 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);
@@ -383,13 +407,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) => {
@@ -400,8 +424,7 @@ 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);
@@ -418,8 +441,7 @@ 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
@@ -429,23 +451,27 @@ 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);
@@ -472,8 +498,7 @@ 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;
         }
@@ -488,15 +513,14 @@ 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;
         }
@@ -508,9 +532,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;
         }
@@ -536,12 +560,14 @@ 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
             };
@@ -583,10 +609,7 @@ 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%',
@@ -597,22 +620,13 @@ 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,
@@ -626,20 +640,12 @@ 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',
@@ -648,18 +654,12 @@ 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',