@amboss/design-system 1.20.4 → 1.21.0

package/build/esm/src/components/Sheet/Sheet.js

@@ -0,0 +1,300 @@
+import _extends from '@babel/runtime/helpers/extends';
+import _styled from '@emotion/styled/base';
+import React, { useState, useRef, useLayoutEffect, useEffect, useCallback } from 'react';
+import { createPortal } from 'react-dom';
+import { keyframes, Global } from '@emotion/react';
+import { FocusTrapWrapper } from '../../shared/FocusTrapWrapper.js';
+import { Container } from '../Container/Container.js';
+import { useDragDown } from '../../shared/useDragDown.js';
+
+// Duration of slidein animation of sheet container
+const ANIMATION_DURATION_ENTRY = 300;
+// Duration of slideout animation of sheet container
+const ANIMATION_DURATION_EXIT = 200; // duration
+// Duration of fade in/out animation of content container
+const ANIMATION_DURATION_CONTENT = 50;
+// Max height of sheet content relative to viewport height
+const MAX_HEIGHT_PERCENT = 80;
+// Min drag distance to close sheet
+const MIN_DRAG_DISTANCE = 150;
+const fadeOut = keyframes({
+  from: {
+    opacity: 1
+  },
+  to: {
+    opacity: 0
+  }
+});
+const fadeIn = keyframes({
+  from: {
+    opacity: 0
+  },
+  to: {
+    opacity: 1
+  }
+});
+const StyledContainer = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1olca0n3"
+} : {
+  target: "e1olca0n3",
+  label: "StyledContainer"
+})(_ref => {
+  let {
+    theme,
+    containerHeight,
+    isClosing,
+    dragOffset = 0,
+    prevVisibleState
+  } = _ref;
+  let animation;
+  if (containerHeight) {
+    const slideOut = keyframes({
+      from: {
+        transform: `translateY(${dragOffset}px)`
+      },
+      to: {
+        transform: `translateY(${containerHeight}px)`
+      }
+    });
+    const slideIn = keyframes({
+      from: {
+        transform: `translateY(${containerHeight}px)`
+      },
+      to: {
+        transform: `translateY(0px)`
+      }
+    });
+    if (isClosing) {
+      animation = `${ANIMATION_DURATION_EXIT}ms ease-out forwards ${slideOut}`;
+    } else if (!prevVisibleState) {
+      // set entry animation only for the first time after sheet is visible
+      animation = `${ANIMATION_DURATION_ENTRY}ms ease-out forwards ${slideIn}`;
+    }
+  }
+  return {
+    position: "fixed",
+    left: 0,
+    bottom: 0,
+    width: "100vw",
+    transformOrigin: "bottom",
+    animation,
+    boxSizing: "border-box",
+    zIndex: theme.variables.zIndex.modal,
+    // Remove bottom border radius of DS Container
+    "> div": {
+      borderBottomLeftRadius: 0,
+      borderBottomRightRadius: 0
+    }
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Sheet.tsx"],"names":[],"mappings":"AAuEwB","file":"Sheet.tsx","sourcesContent":["import React, {\n  useRef,\n  useLayoutEffect,\n  useState,\n  useEffect,\n  useCallback,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport { createPortal } from \"react-dom\";\nimport { keyframes, Global } from \"@emotion/react\";\nimport { FocusTrapWrapper } from \"../../shared/FocusTrapWrapper\";\nimport { Container } from \"../Container/Container\";\nimport { useDragDown } from \"../../shared/useDragDown\";\n\nexport type SheetProps = {\n  /* Id to associate with a trigger */\n  id?: string;\n  /** contents */\n  children: React.ReactNode;\n  /* Custom portal container to render sheet into */\n  portalContainer?: HTMLElement;\n  /* used to show / hide sheet */\n  isVisible: boolean;\n  \"data-e2e-test-id\"?: string;\n  /* Called when sheet needs to close, on escape, outside click, swipe down, etc. */\n  onClose: () => void;\n  /* Called when sheet is removed from DOM after exit animation. */\n  onUnmount?: () => void;\n  /* Controls whether Sheet closes on outside click */\n  dismissOnOutsideClick?: boolean;\n  /* Option for focus-trap, controls whether the first focuable item recieves focus */\n  disableInitialFocus?: boolean;\n  /* Option for focus-trap, controls whether the trigger should receive back the focus on popover close */\n  disableReturnFocusToTrigger?: boolean;\n};\n\n// Duration of slidein animation of sheet container\nconst ANIMATION_DURATION_ENTRY = 300;\n// Duration of slideout animation of sheet container\nconst ANIMATION_DURATION_EXIT = 200; // duration\n// Duration of fade in/out animation of content container\nconst ANIMATION_DURATION_CONTENT = 50;\n// Max height of sheet content relative to viewport height\nconst MAX_HEIGHT_PERCENT = 80;\n// Min drag distance to close sheet\nconst MIN_DRAG_DISTANCE = 150;\n\nconst fadeOut = keyframes({\n  from: {\n    opacity: 1,\n  },\n  to: {\n    opacity: 0,\n  },\n});\nconst fadeIn = keyframes({\n  from: {\n    opacity: 0,\n  },\n  to: {\n    opacity: 1,\n  },\n});\n\ntype StyledContainerProps = Partial<Pick<SheetProps, \"isVisible\">> & {\n  containerHeight?: number;\n  isClosing?: boolean;\n  dragOffset?: number;\n  prevVisibleState?: boolean;\n};\n\nconst StyledContainer = styled.div<StyledContainerProps>(\n  ({ theme, containerHeight, isClosing, dragOffset = 0, prevVisibleState }) => {\n    let animation;\n    if (containerHeight) {\n      const slideOut = keyframes({\n        from: {\n          transform: `translateY(${dragOffset}px)`,\n        },\n        to: {\n          transform: `translateY(${containerHeight}px)`,\n        },\n      });\n      const slideIn = keyframes({\n        from: {\n          transform: `translateY(${containerHeight}px)`,\n        },\n        to: {\n          transform: `translateY(0px)`,\n        },\n      });\n\n      if (isClosing) {\n        animation = `${ANIMATION_DURATION_EXIT}ms ease-out forwards ${slideOut}`;\n      } else if (!prevVisibleState) {\n        // set entry animation only for the first time after sheet is visible\n        animation = `${ANIMATION_DURATION_ENTRY}ms ease-out forwards ${slideIn}`;\n      }\n    }\n\n    return {\n      position: \"fixed\",\n      left: 0,\n      bottom: 0,\n      width: \"100vw\",\n      transformOrigin: \"bottom\",\n      animation,\n      boxSizing: \"border-box\",\n      zIndex: theme.variables.zIndex.modal,\n\n      // Remove bottom border radius of DS Container\n      \"> div\": {\n        borderBottomLeftRadius: 0,\n        borderBottomRightRadius: 0,\n      },\n    };\n  }\n);\n\ntype StyledContentContainerProps = {\n  isClosing?: boolean;\n};\n\nconst StyledContentContainer = styled.div<StyledContentContainerProps>(\n  ({ isClosing }) => {\n    const animation = isClosing\n      ? `${ANIMATION_DURATION_CONTENT}ms ease-out forwards ${fadeOut}`\n      : `${ANIMATION_DURATION_CONTENT}ms ease-out ${\n          ANIMATION_DURATION_ENTRY - ANIMATION_DURATION_CONTENT\n        }ms forwards ${fadeIn}`;\n\n    return {\n      overflow: \"auto\",\n      maxHeight: `${MAX_HEIGHT_PERCENT}vh`,\n      boxSizing: \"border-box\",\n      overscrollBehavior: \"none\",\n      opacity: 0,\n      animation,\n    };\n  }\n);\n\ntype StyledHandleContainerProps = {\n  isContentContainerScrolled?: boolean;\n};\nconst StyledHandleContainer = styled.div<StyledHandleContainerProps>(\n  ({ theme, isContentContainerScrolled }) => ({\n    padding: `${theme.variables.size.spacing.xs} 0`,\n    display: \"flex\",\n    justifyContent: \"center\",\n\n    ...(isContentContainerScrolled && {\n      boxShadow: theme.values.elevation.a,\n    }),\n  })\n);\n\nconst StyledHandle = styled.div(({ theme }) => ({\n  width: \"80px\",\n  height: \"4px\",\n  borderRadius: theme.variables.size.borderRadius.xs,\n  backgroundColor: theme.values.color.divider.primary,\n}));\n\nexport function Sheet({\n  id,\n  children,\n  isVisible,\n  onClose,\n  onUnmount,\n  portalContainer,\n  dismissOnOutsideClick = true,\n  disableInitialFocus,\n  disableReturnFocusToTrigger,\n  \"data-e2e-test-id\": dataE2eTestId,\n}: SheetProps): React.ReactElement {\n  const [isClosing, setClosing] = useState(false);\n  const [containerHeight, setContainerHeight] = useState(0);\n  const [isContentContainerScrolled, setContentContainerScrolled] =\n    useState(false);\n  const containerRef = useRef(null);\n  const contentContainerRef = useRef(null);\n  const prevVisibleState = useRef(isVisible);\n  const dragOffset = useRef(0);\n  const isDragStarted = useRef(false);\n\n  useLayoutEffect(() => {\n    if (isVisible && containerRef.current) {\n      const containerRect = containerRef.current.getBoundingClientRect();\n\n      setContainerHeight(containerRect.height);\n    }\n  }, [isVisible, children]);\n\n  useEffect(() => {\n    // Start closing sheet if previously opened\n    if (!isVisible && prevVisibleState.current) {\n      setClosing(true);\n    }\n    prevVisibleState.current = isVisible;\n  }, [isVisible]);\n\n  useEffect(() => {\n    if (isVisible && isClosing) {\n      // Sometimes, parent component can re-open sheet while it is still closing. To prevent this, we call onClose again\n      onClose();\n    }\n  }, [isVisible, isClosing, onClose]);\n\n  const handleDragStart = useCallback(() => {\n    requestAnimationFrame(() => {\n      if (contentContainerRef.current.scrollTop === 0) {\n        // Remove existing animation, otherwise transform doesn't work\n        containerRef.current.style.animation = \"none\";\n        containerRef.current.style.transition = \"transform 0.1s ease\";\n        containerRef.current.style.transform = \"translateY(0px)\";\n        dragOffset.current = 0;\n        isDragStarted.current = true;\n      }\n    });\n  }, [containerRef, contentContainerRef]);\n\n  const handleDrag = useCallback(\n    (_, offsetFromStart) => {\n      const containerCurrentHeight =\n        containerRef.current.getBoundingClientRect().height;\n\n      requestAnimationFrame(() => {\n        if (\n          isDragStarted.current &&\n          contentContainerRef.current.scrollTop === 0 &&\n          offsetFromStart < containerCurrentHeight\n        ) {\n          containerRef.current.style.transform = `translateY(${offsetFromStart}px)`;\n          dragOffset.current = offsetFromStart;\n        }\n      });\n    },\n    [containerRef, contentContainerRef]\n  );\n\n  const handleDragEnd = useCallback(\n    (_, offsetFromStart) => {\n      const containerCurrentHeight =\n        containerRef.current.getBoundingClientRect().height;\n      // Close sheet only when drag distance is a quarter of container height\n      const minDragDistance =\n        containerCurrentHeight < MIN_DRAG_DISTANCE * 2\n          ? containerCurrentHeight / 4\n          : MIN_DRAG_DISTANCE;\n\n      requestAnimationFrame(() => {\n        if (isDragStarted.current) {\n          if (\n            offsetFromStart >= minDragDistance &&\n            contentContainerRef.current.scrollTop === 0\n          ) {\n            onClose();\n          } else {\n            containerRef.current.style.transform = \"translateY(0px)\";\n            dragOffset.current = 0;\n          }\n        }\n        isDragStarted.current = false;\n      });\n    },\n    [containerRef, onClose]\n  );\n\n  const handleDragCancel = useCallback(() => {\n    requestAnimationFrame(() => {\n      if (isDragStarted.current) {\n        containerRef.current.style.transform = \"translateY(0px)\";\n        dragOffset.current = 0;\n      }\n      isDragStarted.current = false;\n    });\n  }, [containerRef]);\n\n  useDragDown({\n    ref: containerRef,\n    isVisible: isVisible && !isContentContainerScrolled,\n    onDragStart: handleDragStart,\n    onDrag: handleDrag,\n    onDragEnd: handleDragEnd,\n    onDragCancel: handleDragCancel,\n  });\n\n  const handleExitAnimationEnd = () => {\n    if (isClosing) {\n      setClosing(false);\n      dragOffset.current = 0;\n\n      if (onUnmount) {\n        onUnmount();\n      }\n    }\n  };\n\n  const handleContentContainerScroll = () => {\n    setContentContainerScrolled(\n      contentContainerRef.current && contentContainerRef.current.scrollTop !== 0\n    );\n  };\n\n  const showSheet = (isVisible || isClosing) && !(isVisible && isClosing);\n\n  if (!showSheet) return null;\n\n  const globalStyles = {\n    html: {\n      overflow: \"hidden\",\n      overscrollBehavior: \"none\",\n    },\n  };\n\n  const idProp = id\n    ? {\n        id,\n      }\n    : {};\n\n  const sheetElm = (\n    <>\n      <Global styles={globalStyles} />\n      <FocusTrapWrapper\n        focusTrapOptions={{\n          clickOutsideDeactivates: dismissOnOutsideClick,\n          escapeDeactivates: true,\n          preventScroll: true,\n          initialFocus: () => !disableInitialFocus,\n          returnFocusOnDeactivate: !disableReturnFocusToTrigger,\n          fallbackFocus: `[data-ds-id=\"Sheet\"]`,\n          onPostDeactivate: () => {\n            onClose();\n          },\n        }}\n      >\n        <StyledContainer\n          {...idProp} // eslint-disable-line react/jsx-props-no-spreading\n          data-e2e-test-id={dataE2eTestId}\n          data-ds-id=\"Sheet\"\n          isVisible={isVisible}\n          containerHeight={containerHeight}\n          isClosing={isClosing}\n          ref={containerRef}\n          dragOffset={dragOffset.current}\n          prevVisibleState={prevVisibleState.current}\n          onAnimationEnd={handleExitAnimationEnd}\n        >\n          <Container elevation={4}>\n            <StyledHandleContainer\n              isContentContainerScrolled={isContentContainerScrolled}\n            >\n              <StyledHandle />\n            </StyledHandleContainer>\n            <StyledContentContainer\n              isClosing={isClosing}\n              ref={contentContainerRef}\n              onScroll={handleContentContainerScroll}\n              onAnimationEnd={(evt) => evt.stopPropagation()}\n            >\n              {children}\n            </StyledContentContainer>\n          </Container>\n        </StyledContainer>\n      </FocusTrapWrapper>\n    </>\n  );\n\n  return createPortal(sheetElm, portalContainer || document.body);\n}\n"]} */");
+const StyledContentContainer = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1olca0n2"
+} : {
+  target: "e1olca0n2",
+  label: "StyledContentContainer"
+})(_ref2 => {
+  let {
+    isClosing
+  } = _ref2;
+  const animation = isClosing ? `${ANIMATION_DURATION_CONTENT}ms ease-out forwards ${fadeOut}` : `${ANIMATION_DURATION_CONTENT}ms ease-out ${ANIMATION_DURATION_ENTRY - ANIMATION_DURATION_CONTENT}ms forwards ${fadeIn}`;
+  return {
+    overflow: "auto",
+    maxHeight: `${MAX_HEIGHT_PERCENT}vh`,
+    boxSizing: "border-box",
+    overscrollBehavior: "none",
+    opacity: 0,
+    animation
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Sheet.tsx"],"names":[],"mappings":"AA2H+B","file":"Sheet.tsx","sourcesContent":["import React, {\n  useRef,\n  useLayoutEffect,\n  useState,\n  useEffect,\n  useCallback,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport { createPortal } from \"react-dom\";\nimport { keyframes, Global } from \"@emotion/react\";\nimport { FocusTrapWrapper } from \"../../shared/FocusTrapWrapper\";\nimport { Container } from \"../Container/Container\";\nimport { useDragDown } from \"../../shared/useDragDown\";\n\nexport type SheetProps = {\n  /* Id to associate with a trigger */\n  id?: string;\n  /** contents */\n  children: React.ReactNode;\n  /* Custom portal container to render sheet into */\n  portalContainer?: HTMLElement;\n  /* used to show / hide sheet */\n  isVisible: boolean;\n  \"data-e2e-test-id\"?: string;\n  /* Called when sheet needs to close, on escape, outside click, swipe down, etc. */\n  onClose: () => void;\n  /* Called when sheet is removed from DOM after exit animation. */\n  onUnmount?: () => void;\n  /* Controls whether Sheet closes on outside click */\n  dismissOnOutsideClick?: boolean;\n  /* Option for focus-trap, controls whether the first focuable item recieves focus */\n  disableInitialFocus?: boolean;\n  /* Option for focus-trap, controls whether the trigger should receive back the focus on popover close */\n  disableReturnFocusToTrigger?: boolean;\n};\n\n// Duration of slidein animation of sheet container\nconst ANIMATION_DURATION_ENTRY = 300;\n// Duration of slideout animation of sheet container\nconst ANIMATION_DURATION_EXIT = 200; // duration\n// Duration of fade in/out animation of content container\nconst ANIMATION_DURATION_CONTENT = 50;\n// Max height of sheet content relative to viewport height\nconst MAX_HEIGHT_PERCENT = 80;\n// Min drag distance to close sheet\nconst MIN_DRAG_DISTANCE = 150;\n\nconst fadeOut = keyframes({\n  from: {\n    opacity: 1,\n  },\n  to: {\n    opacity: 0,\n  },\n});\nconst fadeIn = keyframes({\n  from: {\n    opacity: 0,\n  },\n  to: {\n    opacity: 1,\n  },\n});\n\ntype StyledContainerProps = Partial<Pick<SheetProps, \"isVisible\">> & {\n  containerHeight?: number;\n  isClosing?: boolean;\n  dragOffset?: number;\n  prevVisibleState?: boolean;\n};\n\nconst StyledContainer = styled.div<StyledContainerProps>(\n  ({ theme, containerHeight, isClosing, dragOffset = 0, prevVisibleState }) => {\n    let animation;\n    if (containerHeight) {\n      const slideOut = keyframes({\n        from: {\n          transform: `translateY(${dragOffset}px)`,\n        },\n        to: {\n          transform: `translateY(${containerHeight}px)`,\n        },\n      });\n      const slideIn = keyframes({\n        from: {\n          transform: `translateY(${containerHeight}px)`,\n        },\n        to: {\n          transform: `translateY(0px)`,\n        },\n      });\n\n      if (isClosing) {\n        animation = `${ANIMATION_DURATION_EXIT}ms ease-out forwards ${slideOut}`;\n      } else if (!prevVisibleState) {\n        // set entry animation only for the first time after sheet is visible\n        animation = `${ANIMATION_DURATION_ENTRY}ms ease-out forwards ${slideIn}`;\n      }\n    }\n\n    return {\n      position: \"fixed\",\n      left: 0,\n      bottom: 0,\n      width: \"100vw\",\n      transformOrigin: \"bottom\",\n      animation,\n      boxSizing: \"border-box\",\n      zIndex: theme.variables.zIndex.modal,\n\n      // Remove bottom border radius of DS Container\n      \"> div\": {\n        borderBottomLeftRadius: 0,\n        borderBottomRightRadius: 0,\n      },\n    };\n  }\n);\n\ntype StyledContentContainerProps = {\n  isClosing?: boolean;\n};\n\nconst StyledContentContainer = styled.div<StyledContentContainerProps>(\n  ({ isClosing }) => {\n    const animation = isClosing\n      ? `${ANIMATION_DURATION_CONTENT}ms ease-out forwards ${fadeOut}`\n      : `${ANIMATION_DURATION_CONTENT}ms ease-out ${\n          ANIMATION_DURATION_ENTRY - ANIMATION_DURATION_CONTENT\n        }ms forwards ${fadeIn}`;\n\n    return {\n      overflow: \"auto\",\n      maxHeight: `${MAX_HEIGHT_PERCENT}vh`,\n      boxSizing: \"border-box\",\n      overscrollBehavior: \"none\",\n      opacity: 0,\n      animation,\n    };\n  }\n);\n\ntype StyledHandleContainerProps = {\n  isContentContainerScrolled?: boolean;\n};\nconst StyledHandleContainer = styled.div<StyledHandleContainerProps>(\n  ({ theme, isContentContainerScrolled }) => ({\n    padding: `${theme.variables.size.spacing.xs} 0`,\n    display: \"flex\",\n    justifyContent: \"center\",\n\n    ...(isContentContainerScrolled && {\n      boxShadow: theme.values.elevation.a,\n    }),\n  })\n);\n\nconst StyledHandle = styled.div(({ theme }) => ({\n  width: \"80px\",\n  height: \"4px\",\n  borderRadius: theme.variables.size.borderRadius.xs,\n  backgroundColor: theme.values.color.divider.primary,\n}));\n\nexport function Sheet({\n  id,\n  children,\n  isVisible,\n  onClose,\n  onUnmount,\n  portalContainer,\n  dismissOnOutsideClick = true,\n  disableInitialFocus,\n  disableReturnFocusToTrigger,\n  \"data-e2e-test-id\": dataE2eTestId,\n}: SheetProps): React.ReactElement {\n  const [isClosing, setClosing] = useState(false);\n  const [containerHeight, setContainerHeight] = useState(0);\n  const [isContentContainerScrolled, setContentContainerScrolled] =\n    useState(false);\n  const containerRef = useRef(null);\n  const contentContainerRef = useRef(null);\n  const prevVisibleState = useRef(isVisible);\n  const dragOffset = useRef(0);\n  const isDragStarted = useRef(false);\n\n  useLayoutEffect(() => {\n    if (isVisible && containerRef.current) {\n      const containerRect = containerRef.current.getBoundingClientRect();\n\n      setContainerHeight(containerRect.height);\n    }\n  }, [isVisible, children]);\n\n  useEffect(() => {\n    // Start closing sheet if previously opened\n    if (!isVisible && prevVisibleState.current) {\n      setClosing(true);\n    }\n    prevVisibleState.current = isVisible;\n  }, [isVisible]);\n\n  useEffect(() => {\n    if (isVisible && isClosing) {\n      // Sometimes, parent component can re-open sheet while it is still closing. To prevent this, we call onClose again\n      onClose();\n    }\n  }, [isVisible, isClosing, onClose]);\n\n  const handleDragStart = useCallback(() => {\n    requestAnimationFrame(() => {\n      if (contentContainerRef.current.scrollTop === 0) {\n        // Remove existing animation, otherwise transform doesn't work\n        containerRef.current.style.animation = \"none\";\n        containerRef.current.style.transition = \"transform 0.1s ease\";\n        containerRef.current.style.transform = \"translateY(0px)\";\n        dragOffset.current = 0;\n        isDragStarted.current = true;\n      }\n    });\n  }, [containerRef, contentContainerRef]);\n\n  const handleDrag = useCallback(\n    (_, offsetFromStart) => {\n      const containerCurrentHeight =\n        containerRef.current.getBoundingClientRect().height;\n\n      requestAnimationFrame(() => {\n        if (\n          isDragStarted.current &&\n          contentContainerRef.current.scrollTop === 0 &&\n          offsetFromStart < containerCurrentHeight\n        ) {\n          containerRef.current.style.transform = `translateY(${offsetFromStart}px)`;\n          dragOffset.current = offsetFromStart;\n        }\n      });\n    },\n    [containerRef, contentContainerRef]\n  );\n\n  const handleDragEnd = useCallback(\n    (_, offsetFromStart) => {\n      const containerCurrentHeight =\n        containerRef.current.getBoundingClientRect().height;\n      // Close sheet only when drag distance is a quarter of container height\n      const minDragDistance =\n        containerCurrentHeight < MIN_DRAG_DISTANCE * 2\n          ? containerCurrentHeight / 4\n          : MIN_DRAG_DISTANCE;\n\n      requestAnimationFrame(() => {\n        if (isDragStarted.current) {\n          if (\n            offsetFromStart >= minDragDistance &&\n            contentContainerRef.current.scrollTop === 0\n          ) {\n            onClose();\n          } else {\n            containerRef.current.style.transform = \"translateY(0px)\";\n            dragOffset.current = 0;\n          }\n        }\n        isDragStarted.current = false;\n      });\n    },\n    [containerRef, onClose]\n  );\n\n  const handleDragCancel = useCallback(() => {\n    requestAnimationFrame(() => {\n      if (isDragStarted.current) {\n        containerRef.current.style.transform = \"translateY(0px)\";\n        dragOffset.current = 0;\n      }\n      isDragStarted.current = false;\n    });\n  }, [containerRef]);\n\n  useDragDown({\n    ref: containerRef,\n    isVisible: isVisible && !isContentContainerScrolled,\n    onDragStart: handleDragStart,\n    onDrag: handleDrag,\n    onDragEnd: handleDragEnd,\n    onDragCancel: handleDragCancel,\n  });\n\n  const handleExitAnimationEnd = () => {\n    if (isClosing) {\n      setClosing(false);\n      dragOffset.current = 0;\n\n      if (onUnmount) {\n        onUnmount();\n      }\n    }\n  };\n\n  const handleContentContainerScroll = () => {\n    setContentContainerScrolled(\n      contentContainerRef.current && contentContainerRef.current.scrollTop !== 0\n    );\n  };\n\n  const showSheet = (isVisible || isClosing) && !(isVisible && isClosing);\n\n  if (!showSheet) return null;\n\n  const globalStyles = {\n    html: {\n      overflow: \"hidden\",\n      overscrollBehavior: \"none\",\n    },\n  };\n\n  const idProp = id\n    ? {\n        id,\n      }\n    : {};\n\n  const sheetElm = (\n    <>\n      <Global styles={globalStyles} />\n      <FocusTrapWrapper\n        focusTrapOptions={{\n          clickOutsideDeactivates: dismissOnOutsideClick,\n          escapeDeactivates: true,\n          preventScroll: true,\n          initialFocus: () => !disableInitialFocus,\n          returnFocusOnDeactivate: !disableReturnFocusToTrigger,\n          fallbackFocus: `[data-ds-id=\"Sheet\"]`,\n          onPostDeactivate: () => {\n            onClose();\n          },\n        }}\n      >\n        <StyledContainer\n          {...idProp} // eslint-disable-line react/jsx-props-no-spreading\n          data-e2e-test-id={dataE2eTestId}\n          data-ds-id=\"Sheet\"\n          isVisible={isVisible}\n          containerHeight={containerHeight}\n          isClosing={isClosing}\n          ref={containerRef}\n          dragOffset={dragOffset.current}\n          prevVisibleState={prevVisibleState.current}\n          onAnimationEnd={handleExitAnimationEnd}\n        >\n          <Container elevation={4}>\n            <StyledHandleContainer\n              isContentContainerScrolled={isContentContainerScrolled}\n            >\n              <StyledHandle />\n            </StyledHandleContainer>\n            <StyledContentContainer\n              isClosing={isClosing}\n              ref={contentContainerRef}\n              onScroll={handleContentContainerScroll}\n              onAnimationEnd={(evt) => evt.stopPropagation()}\n            >\n              {children}\n            </StyledContentContainer>\n          </Container>\n        </StyledContainer>\n      </FocusTrapWrapper>\n    </>\n  );\n\n  return createPortal(sheetElm, portalContainer || document.body);\n}\n"]} */");
+const StyledHandleContainer = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1olca0n1"
+} : {
+  target: "e1olca0n1",
+  label: "StyledHandleContainer"
+})(_ref3 => {
+  let {
+    theme,
+    isContentContainerScrolled
+  } = _ref3;
+  return {
+    padding: `${theme.variables.size.spacing.xs} 0`,
+    display: "flex",
+    justifyContent: "center",
+    ...(isContentContainerScrolled && {
+      boxShadow: theme.values.elevation.a
+    })
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Sheet.tsx"],"names":[],"mappings":"AAiJ8B","file":"Sheet.tsx","sourcesContent":["import React, {\n  useRef,\n  useLayoutEffect,\n  useState,\n  useEffect,\n  useCallback,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport { createPortal } from \"react-dom\";\nimport { keyframes, Global } from \"@emotion/react\";\nimport { FocusTrapWrapper } from \"../../shared/FocusTrapWrapper\";\nimport { Container } from \"../Container/Container\";\nimport { useDragDown } from \"../../shared/useDragDown\";\n\nexport type SheetProps = {\n  /* Id to associate with a trigger */\n  id?: string;\n  /** contents */\n  children: React.ReactNode;\n  /* Custom portal container to render sheet into */\n  portalContainer?: HTMLElement;\n  /* used to show / hide sheet */\n  isVisible: boolean;\n  \"data-e2e-test-id\"?: string;\n  /* Called when sheet needs to close, on escape, outside click, swipe down, etc. */\n  onClose: () => void;\n  /* Called when sheet is removed from DOM after exit animation. */\n  onUnmount?: () => void;\n  /* Controls whether Sheet closes on outside click */\n  dismissOnOutsideClick?: boolean;\n  /* Option for focus-trap, controls whether the first focuable item recieves focus */\n  disableInitialFocus?: boolean;\n  /* Option for focus-trap, controls whether the trigger should receive back the focus on popover close */\n  disableReturnFocusToTrigger?: boolean;\n};\n\n// Duration of slidein animation of sheet container\nconst ANIMATION_DURATION_ENTRY = 300;\n// Duration of slideout animation of sheet container\nconst ANIMATION_DURATION_EXIT = 200; // duration\n// Duration of fade in/out animation of content container\nconst ANIMATION_DURATION_CONTENT = 50;\n// Max height of sheet content relative to viewport height\nconst MAX_HEIGHT_PERCENT = 80;\n// Min drag distance to close sheet\nconst MIN_DRAG_DISTANCE = 150;\n\nconst fadeOut = keyframes({\n  from: {\n    opacity: 1,\n  },\n  to: {\n    opacity: 0,\n  },\n});\nconst fadeIn = keyframes({\n  from: {\n    opacity: 0,\n  },\n  to: {\n    opacity: 1,\n  },\n});\n\ntype StyledContainerProps = Partial<Pick<SheetProps, \"isVisible\">> & {\n  containerHeight?: number;\n  isClosing?: boolean;\n  dragOffset?: number;\n  prevVisibleState?: boolean;\n};\n\nconst StyledContainer = styled.div<StyledContainerProps>(\n  ({ theme, containerHeight, isClosing, dragOffset = 0, prevVisibleState }) => {\n    let animation;\n    if (containerHeight) {\n      const slideOut = keyframes({\n        from: {\n          transform: `translateY(${dragOffset}px)`,\n        },\n        to: {\n          transform: `translateY(${containerHeight}px)`,\n        },\n      });\n      const slideIn = keyframes({\n        from: {\n          transform: `translateY(${containerHeight}px)`,\n        },\n        to: {\n          transform: `translateY(0px)`,\n        },\n      });\n\n      if (isClosing) {\n        animation = `${ANIMATION_DURATION_EXIT}ms ease-out forwards ${slideOut}`;\n      } else if (!prevVisibleState) {\n        // set entry animation only for the first time after sheet is visible\n        animation = `${ANIMATION_DURATION_ENTRY}ms ease-out forwards ${slideIn}`;\n      }\n    }\n\n    return {\n      position: \"fixed\",\n      left: 0,\n      bottom: 0,\n      width: \"100vw\",\n      transformOrigin: \"bottom\",\n      animation,\n      boxSizing: \"border-box\",\n      zIndex: theme.variables.zIndex.modal,\n\n      // Remove bottom border radius of DS Container\n      \"> div\": {\n        borderBottomLeftRadius: 0,\n        borderBottomRightRadius: 0,\n      },\n    };\n  }\n);\n\ntype StyledContentContainerProps = {\n  isClosing?: boolean;\n};\n\nconst StyledContentContainer = styled.div<StyledContentContainerProps>(\n  ({ isClosing }) => {\n    const animation = isClosing\n      ? `${ANIMATION_DURATION_CONTENT}ms ease-out forwards ${fadeOut}`\n      : `${ANIMATION_DURATION_CONTENT}ms ease-out ${\n          ANIMATION_DURATION_ENTRY - ANIMATION_DURATION_CONTENT\n        }ms forwards ${fadeIn}`;\n\n    return {\n      overflow: \"auto\",\n      maxHeight: `${MAX_HEIGHT_PERCENT}vh`,\n      boxSizing: \"border-box\",\n      overscrollBehavior: \"none\",\n      opacity: 0,\n      animation,\n    };\n  }\n);\n\ntype StyledHandleContainerProps = {\n  isContentContainerScrolled?: boolean;\n};\nconst StyledHandleContainer = styled.div<StyledHandleContainerProps>(\n  ({ theme, isContentContainerScrolled }) => ({\n    padding: `${theme.variables.size.spacing.xs} 0`,\n    display: \"flex\",\n    justifyContent: \"center\",\n\n    ...(isContentContainerScrolled && {\n      boxShadow: theme.values.elevation.a,\n    }),\n  })\n);\n\nconst StyledHandle = styled.div(({ theme }) => ({\n  width: \"80px\",\n  height: \"4px\",\n  borderRadius: theme.variables.size.borderRadius.xs,\n  backgroundColor: theme.values.color.divider.primary,\n}));\n\nexport function Sheet({\n  id,\n  children,\n  isVisible,\n  onClose,\n  onUnmount,\n  portalContainer,\n  dismissOnOutsideClick = true,\n  disableInitialFocus,\n  disableReturnFocusToTrigger,\n  \"data-e2e-test-id\": dataE2eTestId,\n}: SheetProps): React.ReactElement {\n  const [isClosing, setClosing] = useState(false);\n  const [containerHeight, setContainerHeight] = useState(0);\n  const [isContentContainerScrolled, setContentContainerScrolled] =\n    useState(false);\n  const containerRef = useRef(null);\n  const contentContainerRef = useRef(null);\n  const prevVisibleState = useRef(isVisible);\n  const dragOffset = useRef(0);\n  const isDragStarted = useRef(false);\n\n  useLayoutEffect(() => {\n    if (isVisible && containerRef.current) {\n      const containerRect = containerRef.current.getBoundingClientRect();\n\n      setContainerHeight(containerRect.height);\n    }\n  }, [isVisible, children]);\n\n  useEffect(() => {\n    // Start closing sheet if previously opened\n    if (!isVisible && prevVisibleState.current) {\n      setClosing(true);\n    }\n    prevVisibleState.current = isVisible;\n  }, [isVisible]);\n\n  useEffect(() => {\n    if (isVisible && isClosing) {\n      // Sometimes, parent component can re-open sheet while it is still closing. To prevent this, we call onClose again\n      onClose();\n    }\n  }, [isVisible, isClosing, onClose]);\n\n  const handleDragStart = useCallback(() => {\n    requestAnimationFrame(() => {\n      if (contentContainerRef.current.scrollTop === 0) {\n        // Remove existing animation, otherwise transform doesn't work\n        containerRef.current.style.animation = \"none\";\n        containerRef.current.style.transition = \"transform 0.1s ease\";\n        containerRef.current.style.transform = \"translateY(0px)\";\n        dragOffset.current = 0;\n        isDragStarted.current = true;\n      }\n    });\n  }, [containerRef, contentContainerRef]);\n\n  const handleDrag = useCallback(\n    (_, offsetFromStart) => {\n      const containerCurrentHeight =\n        containerRef.current.getBoundingClientRect().height;\n\n      requestAnimationFrame(() => {\n        if (\n          isDragStarted.current &&\n          contentContainerRef.current.scrollTop === 0 &&\n          offsetFromStart < containerCurrentHeight\n        ) {\n          containerRef.current.style.transform = `translateY(${offsetFromStart}px)`;\n          dragOffset.current = offsetFromStart;\n        }\n      });\n    },\n    [containerRef, contentContainerRef]\n  );\n\n  const handleDragEnd = useCallback(\n    (_, offsetFromStart) => {\n      const containerCurrentHeight =\n        containerRef.current.getBoundingClientRect().height;\n      // Close sheet only when drag distance is a quarter of container height\n      const minDragDistance =\n        containerCurrentHeight < MIN_DRAG_DISTANCE * 2\n          ? containerCurrentHeight / 4\n          : MIN_DRAG_DISTANCE;\n\n      requestAnimationFrame(() => {\n        if (isDragStarted.current) {\n          if (\n            offsetFromStart >= minDragDistance &&\n            contentContainerRef.current.scrollTop === 0\n          ) {\n            onClose();\n          } else {\n            containerRef.current.style.transform = \"translateY(0px)\";\n            dragOffset.current = 0;\n          }\n        }\n        isDragStarted.current = false;\n      });\n    },\n    [containerRef, onClose]\n  );\n\n  const handleDragCancel = useCallback(() => {\n    requestAnimationFrame(() => {\n      if (isDragStarted.current) {\n        containerRef.current.style.transform = \"translateY(0px)\";\n        dragOffset.current = 0;\n      }\n      isDragStarted.current = false;\n    });\n  }, [containerRef]);\n\n  useDragDown({\n    ref: containerRef,\n    isVisible: isVisible && !isContentContainerScrolled,\n    onDragStart: handleDragStart,\n    onDrag: handleDrag,\n    onDragEnd: handleDragEnd,\n    onDragCancel: handleDragCancel,\n  });\n\n  const handleExitAnimationEnd = () => {\n    if (isClosing) {\n      setClosing(false);\n      dragOffset.current = 0;\n\n      if (onUnmount) {\n        onUnmount();\n      }\n    }\n  };\n\n  const handleContentContainerScroll = () => {\n    setContentContainerScrolled(\n      contentContainerRef.current && contentContainerRef.current.scrollTop !== 0\n    );\n  };\n\n  const showSheet = (isVisible || isClosing) && !(isVisible && isClosing);\n\n  if (!showSheet) return null;\n\n  const globalStyles = {\n    html: {\n      overflow: \"hidden\",\n      overscrollBehavior: \"none\",\n    },\n  };\n\n  const idProp = id\n    ? {\n        id,\n      }\n    : {};\n\n  const sheetElm = (\n    <>\n      <Global styles={globalStyles} />\n      <FocusTrapWrapper\n        focusTrapOptions={{\n          clickOutsideDeactivates: dismissOnOutsideClick,\n          escapeDeactivates: true,\n          preventScroll: true,\n          initialFocus: () => !disableInitialFocus,\n          returnFocusOnDeactivate: !disableReturnFocusToTrigger,\n          fallbackFocus: `[data-ds-id=\"Sheet\"]`,\n          onPostDeactivate: () => {\n            onClose();\n          },\n        }}\n      >\n        <StyledContainer\n          {...idProp} // eslint-disable-line react/jsx-props-no-spreading\n          data-e2e-test-id={dataE2eTestId}\n          data-ds-id=\"Sheet\"\n          isVisible={isVisible}\n          containerHeight={containerHeight}\n          isClosing={isClosing}\n          ref={containerRef}\n          dragOffset={dragOffset.current}\n          prevVisibleState={prevVisibleState.current}\n          onAnimationEnd={handleExitAnimationEnd}\n        >\n          <Container elevation={4}>\n            <StyledHandleContainer\n              isContentContainerScrolled={isContentContainerScrolled}\n            >\n              <StyledHandle />\n            </StyledHandleContainer>\n            <StyledContentContainer\n              isClosing={isClosing}\n              ref={contentContainerRef}\n              onScroll={handleContentContainerScroll}\n              onAnimationEnd={(evt) => evt.stopPropagation()}\n            >\n              {children}\n            </StyledContentContainer>\n          </Container>\n        </StyledContainer>\n      </FocusTrapWrapper>\n    </>\n  );\n\n  return createPortal(sheetElm, portalContainer || document.body);\n}\n"]} */");
+const StyledHandle = /*#__PURE__*/_styled("div", process.env.NODE_ENV === "production" ? {
+  target: "e1olca0n0"
+} : {
+  target: "e1olca0n0",
+  label: "StyledHandle"
+})(_ref4 => {
+  let {
+    theme
+  } = _ref4;
+  return {
+    width: "80px",
+    height: "4px",
+    borderRadius: theme.variables.size.borderRadius.xs,
+    backgroundColor: theme.values.color.divider.primary
+  };
+}, process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Sheet.tsx"],"names":[],"mappings":"AA6JqB","file":"Sheet.tsx","sourcesContent":["import React, {\n  useRef,\n  useLayoutEffect,\n  useState,\n  useEffect,\n  useCallback,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport { createPortal } from \"react-dom\";\nimport { keyframes, Global } from \"@emotion/react\";\nimport { FocusTrapWrapper } from \"../../shared/FocusTrapWrapper\";\nimport { Container } from \"../Container/Container\";\nimport { useDragDown } from \"../../shared/useDragDown\";\n\nexport type SheetProps = {\n  /* Id to associate with a trigger */\n  id?: string;\n  /** contents */\n  children: React.ReactNode;\n  /* Custom portal container to render sheet into */\n  portalContainer?: HTMLElement;\n  /* used to show / hide sheet */\n  isVisible: boolean;\n  \"data-e2e-test-id\"?: string;\n  /* Called when sheet needs to close, on escape, outside click, swipe down, etc. */\n  onClose: () => void;\n  /* Called when sheet is removed from DOM after exit animation. */\n  onUnmount?: () => void;\n  /* Controls whether Sheet closes on outside click */\n  dismissOnOutsideClick?: boolean;\n  /* Option for focus-trap, controls whether the first focuable item recieves focus */\n  disableInitialFocus?: boolean;\n  /* Option for focus-trap, controls whether the trigger should receive back the focus on popover close */\n  disableReturnFocusToTrigger?: boolean;\n};\n\n// Duration of slidein animation of sheet container\nconst ANIMATION_DURATION_ENTRY = 300;\n// Duration of slideout animation of sheet container\nconst ANIMATION_DURATION_EXIT = 200; // duration\n// Duration of fade in/out animation of content container\nconst ANIMATION_DURATION_CONTENT = 50;\n// Max height of sheet content relative to viewport height\nconst MAX_HEIGHT_PERCENT = 80;\n// Min drag distance to close sheet\nconst MIN_DRAG_DISTANCE = 150;\n\nconst fadeOut = keyframes({\n  from: {\n    opacity: 1,\n  },\n  to: {\n    opacity: 0,\n  },\n});\nconst fadeIn = keyframes({\n  from: {\n    opacity: 0,\n  },\n  to: {\n    opacity: 1,\n  },\n});\n\ntype StyledContainerProps = Partial<Pick<SheetProps, \"isVisible\">> & {\n  containerHeight?: number;\n  isClosing?: boolean;\n  dragOffset?: number;\n  prevVisibleState?: boolean;\n};\n\nconst StyledContainer = styled.div<StyledContainerProps>(\n  ({ theme, containerHeight, isClosing, dragOffset = 0, prevVisibleState }) => {\n    let animation;\n    if (containerHeight) {\n      const slideOut = keyframes({\n        from: {\n          transform: `translateY(${dragOffset}px)`,\n        },\n        to: {\n          transform: `translateY(${containerHeight}px)`,\n        },\n      });\n      const slideIn = keyframes({\n        from: {\n          transform: `translateY(${containerHeight}px)`,\n        },\n        to: {\n          transform: `translateY(0px)`,\n        },\n      });\n\n      if (isClosing) {\n        animation = `${ANIMATION_DURATION_EXIT}ms ease-out forwards ${slideOut}`;\n      } else if (!prevVisibleState) {\n        // set entry animation only for the first time after sheet is visible\n        animation = `${ANIMATION_DURATION_ENTRY}ms ease-out forwards ${slideIn}`;\n      }\n    }\n\n    return {\n      position: \"fixed\",\n      left: 0,\n      bottom: 0,\n      width: \"100vw\",\n      transformOrigin: \"bottom\",\n      animation,\n      boxSizing: \"border-box\",\n      zIndex: theme.variables.zIndex.modal,\n\n      // Remove bottom border radius of DS Container\n      \"> div\": {\n        borderBottomLeftRadius: 0,\n        borderBottomRightRadius: 0,\n      },\n    };\n  }\n);\n\ntype StyledContentContainerProps = {\n  isClosing?: boolean;\n};\n\nconst StyledContentContainer = styled.div<StyledContentContainerProps>(\n  ({ isClosing }) => {\n    const animation = isClosing\n      ? `${ANIMATION_DURATION_CONTENT}ms ease-out forwards ${fadeOut}`\n      : `${ANIMATION_DURATION_CONTENT}ms ease-out ${\n          ANIMATION_DURATION_ENTRY - ANIMATION_DURATION_CONTENT\n        }ms forwards ${fadeIn}`;\n\n    return {\n      overflow: \"auto\",\n      maxHeight: `${MAX_HEIGHT_PERCENT}vh`,\n      boxSizing: \"border-box\",\n      overscrollBehavior: \"none\",\n      opacity: 0,\n      animation,\n    };\n  }\n);\n\ntype StyledHandleContainerProps = {\n  isContentContainerScrolled?: boolean;\n};\nconst StyledHandleContainer = styled.div<StyledHandleContainerProps>(\n  ({ theme, isContentContainerScrolled }) => ({\n    padding: `${theme.variables.size.spacing.xs} 0`,\n    display: \"flex\",\n    justifyContent: \"center\",\n\n    ...(isContentContainerScrolled && {\n      boxShadow: theme.values.elevation.a,\n    }),\n  })\n);\n\nconst StyledHandle = styled.div(({ theme }) => ({\n  width: \"80px\",\n  height: \"4px\",\n  borderRadius: theme.variables.size.borderRadius.xs,\n  backgroundColor: theme.values.color.divider.primary,\n}));\n\nexport function Sheet({\n  id,\n  children,\n  isVisible,\n  onClose,\n  onUnmount,\n  portalContainer,\n  dismissOnOutsideClick = true,\n  disableInitialFocus,\n  disableReturnFocusToTrigger,\n  \"data-e2e-test-id\": dataE2eTestId,\n}: SheetProps): React.ReactElement {\n  const [isClosing, setClosing] = useState(false);\n  const [containerHeight, setContainerHeight] = useState(0);\n  const [isContentContainerScrolled, setContentContainerScrolled] =\n    useState(false);\n  const containerRef = useRef(null);\n  const contentContainerRef = useRef(null);\n  const prevVisibleState = useRef(isVisible);\n  const dragOffset = useRef(0);\n  const isDragStarted = useRef(false);\n\n  useLayoutEffect(() => {\n    if (isVisible && containerRef.current) {\n      const containerRect = containerRef.current.getBoundingClientRect();\n\n      setContainerHeight(containerRect.height);\n    }\n  }, [isVisible, children]);\n\n  useEffect(() => {\n    // Start closing sheet if previously opened\n    if (!isVisible && prevVisibleState.current) {\n      setClosing(true);\n    }\n    prevVisibleState.current = isVisible;\n  }, [isVisible]);\n\n  useEffect(() => {\n    if (isVisible && isClosing) {\n      // Sometimes, parent component can re-open sheet while it is still closing. To prevent this, we call onClose again\n      onClose();\n    }\n  }, [isVisible, isClosing, onClose]);\n\n  const handleDragStart = useCallback(() => {\n    requestAnimationFrame(() => {\n      if (contentContainerRef.current.scrollTop === 0) {\n        // Remove existing animation, otherwise transform doesn't work\n        containerRef.current.style.animation = \"none\";\n        containerRef.current.style.transition = \"transform 0.1s ease\";\n        containerRef.current.style.transform = \"translateY(0px)\";\n        dragOffset.current = 0;\n        isDragStarted.current = true;\n      }\n    });\n  }, [containerRef, contentContainerRef]);\n\n  const handleDrag = useCallback(\n    (_, offsetFromStart) => {\n      const containerCurrentHeight =\n        containerRef.current.getBoundingClientRect().height;\n\n      requestAnimationFrame(() => {\n        if (\n          isDragStarted.current &&\n          contentContainerRef.current.scrollTop === 0 &&\n          offsetFromStart < containerCurrentHeight\n        ) {\n          containerRef.current.style.transform = `translateY(${offsetFromStart}px)`;\n          dragOffset.current = offsetFromStart;\n        }\n      });\n    },\n    [containerRef, contentContainerRef]\n  );\n\n  const handleDragEnd = useCallback(\n    (_, offsetFromStart) => {\n      const containerCurrentHeight =\n        containerRef.current.getBoundingClientRect().height;\n      // Close sheet only when drag distance is a quarter of container height\n      const minDragDistance =\n        containerCurrentHeight < MIN_DRAG_DISTANCE * 2\n          ? containerCurrentHeight / 4\n          : MIN_DRAG_DISTANCE;\n\n      requestAnimationFrame(() => {\n        if (isDragStarted.current) {\n          if (\n            offsetFromStart >= minDragDistance &&\n            contentContainerRef.current.scrollTop === 0\n          ) {\n            onClose();\n          } else {\n            containerRef.current.style.transform = \"translateY(0px)\";\n            dragOffset.current = 0;\n          }\n        }\n        isDragStarted.current = false;\n      });\n    },\n    [containerRef, onClose]\n  );\n\n  const handleDragCancel = useCallback(() => {\n    requestAnimationFrame(() => {\n      if (isDragStarted.current) {\n        containerRef.current.style.transform = \"translateY(0px)\";\n        dragOffset.current = 0;\n      }\n      isDragStarted.current = false;\n    });\n  }, [containerRef]);\n\n  useDragDown({\n    ref: containerRef,\n    isVisible: isVisible && !isContentContainerScrolled,\n    onDragStart: handleDragStart,\n    onDrag: handleDrag,\n    onDragEnd: handleDragEnd,\n    onDragCancel: handleDragCancel,\n  });\n\n  const handleExitAnimationEnd = () => {\n    if (isClosing) {\n      setClosing(false);\n      dragOffset.current = 0;\n\n      if (onUnmount) {\n        onUnmount();\n      }\n    }\n  };\n\n  const handleContentContainerScroll = () => {\n    setContentContainerScrolled(\n      contentContainerRef.current && contentContainerRef.current.scrollTop !== 0\n    );\n  };\n\n  const showSheet = (isVisible || isClosing) && !(isVisible && isClosing);\n\n  if (!showSheet) return null;\n\n  const globalStyles = {\n    html: {\n      overflow: \"hidden\",\n      overscrollBehavior: \"none\",\n    },\n  };\n\n  const idProp = id\n    ? {\n        id,\n      }\n    : {};\n\n  const sheetElm = (\n    <>\n      <Global styles={globalStyles} />\n      <FocusTrapWrapper\n        focusTrapOptions={{\n          clickOutsideDeactivates: dismissOnOutsideClick,\n          escapeDeactivates: true,\n          preventScroll: true,\n          initialFocus: () => !disableInitialFocus,\n          returnFocusOnDeactivate: !disableReturnFocusToTrigger,\n          fallbackFocus: `[data-ds-id=\"Sheet\"]`,\n          onPostDeactivate: () => {\n            onClose();\n          },\n        }}\n      >\n        <StyledContainer\n          {...idProp} // eslint-disable-line react/jsx-props-no-spreading\n          data-e2e-test-id={dataE2eTestId}\n          data-ds-id=\"Sheet\"\n          isVisible={isVisible}\n          containerHeight={containerHeight}\n          isClosing={isClosing}\n          ref={containerRef}\n          dragOffset={dragOffset.current}\n          prevVisibleState={prevVisibleState.current}\n          onAnimationEnd={handleExitAnimationEnd}\n        >\n          <Container elevation={4}>\n            <StyledHandleContainer\n              isContentContainerScrolled={isContentContainerScrolled}\n            >\n              <StyledHandle />\n            </StyledHandleContainer>\n            <StyledContentContainer\n              isClosing={isClosing}\n              ref={contentContainerRef}\n              onScroll={handleContentContainerScroll}\n              onAnimationEnd={(evt) => evt.stopPropagation()}\n            >\n              {children}\n            </StyledContentContainer>\n          </Container>\n        </StyledContainer>\n      </FocusTrapWrapper>\n    </>\n  );\n\n  return createPortal(sheetElm, portalContainer || document.body);\n}\n"]} */");
+function Sheet(_ref5) {
+  let {
+    id,
+    children,
+    isVisible,
+    onClose,
+    onUnmount,
+    portalContainer,
+    dismissOnOutsideClick = true,
+    disableInitialFocus,
+    disableReturnFocusToTrigger,
+    "data-e2e-test-id": dataE2eTestId
+  } = _ref5;
+  const [isClosing, setClosing] = useState(false);
+  const [containerHeight, setContainerHeight] = useState(0);
+  const [isContentContainerScrolled, setContentContainerScrolled] = useState(false);
+  const containerRef = useRef(null);
+  const contentContainerRef = useRef(null);
+  const prevVisibleState = useRef(isVisible);
+  const dragOffset = useRef(0);
+  const isDragStarted = useRef(false);
+  useLayoutEffect(() => {
+    if (isVisible && containerRef.current) {
+      const containerRect = containerRef.current.getBoundingClientRect();
+      setContainerHeight(containerRect.height);
+    }
+  }, [isVisible, children]);
+  useEffect(() => {
+    // Start closing sheet if previously opened
+    if (!isVisible && prevVisibleState.current) {
+      setClosing(true);
+    }
+    prevVisibleState.current = isVisible;
+  }, [isVisible]);
+  useEffect(() => {
+    if (isVisible && isClosing) {
+      // Sometimes, parent component can re-open sheet while it is still closing. To prevent this, we call onClose again
+      onClose();
+    }
+  }, [isVisible, isClosing, onClose]);
+  const handleDragStart = useCallback(() => {
+    requestAnimationFrame(() => {
+      if (contentContainerRef.current.scrollTop === 0) {
+        // Remove existing animation, otherwise transform doesn't work
+        containerRef.current.style.animation = "none";
+        containerRef.current.style.transition = "transform 0.1s ease";
+        containerRef.current.style.transform = "translateY(0px)";
+        dragOffset.current = 0;
+        isDragStarted.current = true;
+      }
+    });
+  }, [containerRef, contentContainerRef]);
+  const handleDrag = useCallback((_, offsetFromStart) => {
+    const containerCurrentHeight = containerRef.current.getBoundingClientRect().height;
+    requestAnimationFrame(() => {
+      if (isDragStarted.current && contentContainerRef.current.scrollTop === 0 && offsetFromStart < containerCurrentHeight) {
+        containerRef.current.style.transform = `translateY(${offsetFromStart}px)`;
+        dragOffset.current = offsetFromStart;
+      }
+    });
+  }, [containerRef, contentContainerRef]);
+  const handleDragEnd = useCallback((_, offsetFromStart) => {
+    const containerCurrentHeight = containerRef.current.getBoundingClientRect().height;
+    // Close sheet only when drag distance is a quarter of container height
+    const minDragDistance = containerCurrentHeight < MIN_DRAG_DISTANCE * 2 ? containerCurrentHeight / 4 : MIN_DRAG_DISTANCE;
+    requestAnimationFrame(() => {
+      if (isDragStarted.current) {
+        if (offsetFromStart >= minDragDistance && contentContainerRef.current.scrollTop === 0) {
+          onClose();
+        } else {
+          containerRef.current.style.transform = "translateY(0px)";
+          dragOffset.current = 0;
+        }
+      }
+      isDragStarted.current = false;
+    });
+  }, [containerRef, onClose]);
+  const handleDragCancel = useCallback(() => {
+    requestAnimationFrame(() => {
+      if (isDragStarted.current) {
+        containerRef.current.style.transform = "translateY(0px)";
+        dragOffset.current = 0;
+      }
+      isDragStarted.current = false;
+    });
+  }, [containerRef]);
+  useDragDown({
+    ref: containerRef,
+    isVisible: isVisible && !isContentContainerScrolled,
+    onDragStart: handleDragStart,
+    onDrag: handleDrag,
+    onDragEnd: handleDragEnd,
+    onDragCancel: handleDragCancel
+  });
+  const handleExitAnimationEnd = () => {
+    if (isClosing) {
+      setClosing(false);
+      dragOffset.current = 0;
+      if (onUnmount) {
+        onUnmount();
+      }
+    }
+  };
+  const handleContentContainerScroll = () => {
+    setContentContainerScrolled(contentContainerRef.current && contentContainerRef.current.scrollTop !== 0);
+  };
+  const showSheet = (isVisible || isClosing) && !(isVisible && isClosing);
+  if (!showSheet) return null;
+  const globalStyles = {
+    html: {
+      overflow: "hidden",
+      overscrollBehavior: "none"
+    }
+  };
+  const idProp = id ? {
+    id
+  } : {};
+  const sheetElm = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Global, {
+    styles: globalStyles
+  }), /*#__PURE__*/React.createElement(FocusTrapWrapper, {
+    focusTrapOptions: {
+      clickOutsideDeactivates: dismissOnOutsideClick,
+      escapeDeactivates: true,
+      preventScroll: true,
+      initialFocus: () => !disableInitialFocus,
+      returnFocusOnDeactivate: !disableReturnFocusToTrigger,
+      fallbackFocus: `[data-ds-id="Sheet"]`,
+      onPostDeactivate: () => {
+        onClose();
+      }
+    }
+  }, /*#__PURE__*/React.createElement(StyledContainer, _extends({}, idProp, {
+    // eslint-disable-line react/jsx-props-no-spreading
+    "data-e2e-test-id": dataE2eTestId,
+    "data-ds-id": "Sheet",
+    isVisible: isVisible,
+    containerHeight: containerHeight,
+    isClosing: isClosing,
+    ref: containerRef,
+    dragOffset: dragOffset.current,
+    prevVisibleState: prevVisibleState.current,
+    onAnimationEnd: handleExitAnimationEnd
+  }), /*#__PURE__*/React.createElement(Container, {
+    elevation: 4
+  }, /*#__PURE__*/React.createElement(StyledHandleContainer, {
+    isContentContainerScrolled: isContentContainerScrolled
+  }, /*#__PURE__*/React.createElement(StyledHandle, null)), /*#__PURE__*/React.createElement(StyledContentContainer, {
+    isClosing: isClosing,
+    ref: contentContainerRef,
+    onScroll: handleContentContainerScroll,
+    onAnimationEnd: evt => evt.stopPropagation()
+  }, children)))));
+  return /*#__PURE__*/createPortal(sheetElm, portalContainer || document.body);
+}
+
+export { Sheet };
+//# sourceMappingURL=Sheet.js.map

package/build/esm/src/components/Sheet/Sheet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sheet.js","sources":["../../../../../src/components/Sheet/Sheet.tsx"],"sourcesContent":["import React, {\n  useRef,\n  useLayoutEffect,\n  useState,\n  useEffect,\n  useCallback,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport { createPortal } from \"react-dom\";\nimport { keyframes, Global } from \"@emotion/react\";\nimport { FocusTrapWrapper } from \"../../shared/FocusTrapWrapper\";\nimport { Container } from \"../Container/Container\";\nimport { useDragDown } from \"../../shared/useDragDown\";\n\nexport type SheetProps = {\n  /* Id to associate with a trigger */\n  id?: string;\n  /** contents */\n  children: React.ReactNode;\n  /* Custom portal container to render sheet into */\n  portalContainer?: HTMLElement;\n  /* used to show / hide sheet */\n  isVisible: boolean;\n  \"data-e2e-test-id\"?: string;\n  /* Called when sheet needs to close, on escape, outside click, swipe down, etc. */\n  onClose: () => void;\n  /* Called when sheet is removed from DOM after exit animation. */\n  onUnmount?: () => void;\n  /* Controls whether Sheet closes on outside click */\n  dismissOnOutsideClick?: boolean;\n  /* Option for focus-trap, controls whether the first focuable item recieves focus */\n  disableInitialFocus?: boolean;\n  /* Option for focus-trap, controls whether the trigger should receive back the focus on popover close */\n  disableReturnFocusToTrigger?: boolean;\n};\n\n// Duration of slidein animation of sheet container\nconst ANIMATION_DURATION_ENTRY = 300;\n// Duration of slideout animation of sheet container\nconst ANIMATION_DURATION_EXIT = 200; // duration\n// Duration of fade in/out animation of content container\nconst ANIMATION_DURATION_CONTENT = 50;\n// Max height of sheet content relative to viewport height\nconst MAX_HEIGHT_PERCENT = 80;\n// Min drag distance to close sheet\nconst MIN_DRAG_DISTANCE = 150;\n\nconst fadeOut = keyframes({\n  from: {\n    opacity: 1,\n  },\n  to: {\n    opacity: 0,\n  },\n});\nconst fadeIn = keyframes({\n  from: {\n    opacity: 0,\n  },\n  to: {\n    opacity: 1,\n  },\n});\n\ntype StyledContainerProps = Partial<Pick<SheetProps, \"isVisible\">> & {\n  containerHeight?: number;\n  isClosing?: boolean;\n  dragOffset?: number;\n  prevVisibleState?: boolean;\n};\n\nconst StyledContainer = styled.div<StyledContainerProps>(\n  ({ theme, containerHeight, isClosing, dragOffset = 0, prevVisibleState }) => {\n    let animation;\n    if (containerHeight) {\n      const slideOut = keyframes({\n        from: {\n          transform: `translateY(${dragOffset}px)`,\n        },\n        to: {\n          transform: `translateY(${containerHeight}px)`,\n        },\n      });\n      const slideIn = keyframes({\n        from: {\n          transform: `translateY(${containerHeight}px)`,\n        },\n        to: {\n          transform: `translateY(0px)`,\n        },\n      });\n\n      if (isClosing) {\n        animation = `${ANIMATION_DURATION_EXIT}ms ease-out forwards ${slideOut}`;\n      } else if (!prevVisibleState) {\n        // set entry animation only for the first time after sheet is visible\n        animation = `${ANIMATION_DURATION_ENTRY}ms ease-out forwards ${slideIn}`;\n      }\n    }\n\n    return {\n      position: \"fixed\",\n      left: 0,\n      bottom: 0,\n      width: \"100vw\",\n      transformOrigin: \"bottom\",\n      animation,\n      boxSizing: \"border-box\",\n      zIndex: theme.variables.zIndex.modal,\n\n      // Remove bottom border radius of DS Container\n      \"> div\": {\n        borderBottomLeftRadius: 0,\n        borderBottomRightRadius: 0,\n      },\n    };\n  }\n);\n\ntype StyledContentContainerProps = {\n  isClosing?: boolean;\n};\n\nconst StyledContentContainer = styled.div<StyledContentContainerProps>(\n  ({ isClosing }) => {\n    const animation = isClosing\n      ? `${ANIMATION_DURATION_CONTENT}ms ease-out forwards ${fadeOut}`\n      : `${ANIMATION_DURATION_CONTENT}ms ease-out ${\n          ANIMATION_DURATION_ENTRY - ANIMATION_DURATION_CONTENT\n        }ms forwards ${fadeIn}`;\n\n    return {\n      overflow: \"auto\",\n      maxHeight: `${MAX_HEIGHT_PERCENT}vh`,\n      boxSizing: \"border-box\",\n      overscrollBehavior: \"none\",\n      opacity: 0,\n      animation,\n    };\n  }\n);\n\ntype StyledHandleContainerProps = {\n  isContentContainerScrolled?: boolean;\n};\nconst StyledHandleContainer = styled.div<StyledHandleContainerProps>(\n  ({ theme, isContentContainerScrolled }) => ({\n    padding: `${theme.variables.size.spacing.xs} 0`,\n    display: \"flex\",\n    justifyContent: \"center\",\n\n    ...(isContentContainerScrolled && {\n      boxShadow: theme.values.elevation.a,\n    }),\n  })\n);\n\nconst StyledHandle = styled.div(({ theme }) => ({\n  width: \"80px\",\n  height: \"4px\",\n  borderRadius: theme.variables.size.borderRadius.xs,\n  backgroundColor: theme.values.color.divider.primary,\n}));\n\nexport function Sheet({\n  id,\n  children,\n  isVisible,\n  onClose,\n  onUnmount,\n  portalContainer,\n  dismissOnOutsideClick = true,\n  disableInitialFocus,\n  disableReturnFocusToTrigger,\n  \"data-e2e-test-id\": dataE2eTestId,\n}: SheetProps): React.ReactElement {\n  const [isClosing, setClosing] = useState(false);\n  const [containerHeight, setContainerHeight] = useState(0);\n  const [isContentContainerScrolled, setContentContainerScrolled] =\n    useState(false);\n  const containerRef = useRef(null);\n  const contentContainerRef = useRef(null);\n  const prevVisibleState = useRef(isVisible);\n  const dragOffset = useRef(0);\n  const isDragStarted = useRef(false);\n\n  useLayoutEffect(() => {\n    if (isVisible && containerRef.current) {\n      const containerRect = containerRef.current.getBoundingClientRect();\n\n      setContainerHeight(containerRect.height);\n    }\n  }, [isVisible, children]);\n\n  useEffect(() => {\n    // Start closing sheet if previously opened\n    if (!isVisible && prevVisibleState.current) {\n      setClosing(true);\n    }\n    prevVisibleState.current = isVisible;\n  }, [isVisible]);\n\n  useEffect(() => {\n    if (isVisible && isClosing) {\n      // Sometimes, parent component can re-open sheet while it is still closing. To prevent this, we call onClose again\n      onClose();\n    }\n  }, [isVisible, isClosing, onClose]);\n\n  const handleDragStart = useCallback(() => {\n    requestAnimationFrame(() => {\n      if (contentContainerRef.current.scrollTop === 0) {\n        // Remove existing animation, otherwise transform doesn't work\n        containerRef.current.style.animation = \"none\";\n        containerRef.current.style.transition = \"transform 0.1s ease\";\n        containerRef.current.style.transform = \"translateY(0px)\";\n        dragOffset.current = 0;\n        isDragStarted.current = true;\n      }\n    });\n  }, [containerRef, contentContainerRef]);\n\n  const handleDrag = useCallback(\n    (_, offsetFromStart) => {\n      const containerCurrentHeight =\n        containerRef.current.getBoundingClientRect().height;\n\n      requestAnimationFrame(() => {\n        if (\n          isDragStarted.current &&\n          contentContainerRef.current.scrollTop === 0 &&\n          offsetFromStart < containerCurrentHeight\n        ) {\n          containerRef.current.style.transform = `translateY(${offsetFromStart}px)`;\n          dragOffset.current = offsetFromStart;\n        }\n      });\n    },\n    [containerRef, contentContainerRef]\n  );\n\n  const handleDragEnd = useCallback(\n    (_, offsetFromStart) => {\n      const containerCurrentHeight =\n        containerRef.current.getBoundingClientRect().height;\n      // Close sheet only when drag distance is a quarter of container height\n      const minDragDistance =\n        containerCurrentHeight < MIN_DRAG_DISTANCE * 2\n          ? containerCurrentHeight / 4\n          : MIN_DRAG_DISTANCE;\n\n      requestAnimationFrame(() => {\n        if (isDragStarted.current) {\n          if (\n            offsetFromStart >= minDragDistance &&\n            contentContainerRef.current.scrollTop === 0\n          ) {\n            onClose();\n          } else {\n            containerRef.current.style.transform = \"translateY(0px)\";\n            dragOffset.current = 0;\n          }\n        }\n        isDragStarted.current = false;\n      });\n    },\n    [containerRef, onClose]\n  );\n\n  const handleDragCancel = useCallback(() => {\n    requestAnimationFrame(() => {\n      if (isDragStarted.current) {\n        containerRef.current.style.transform = \"translateY(0px)\";\n        dragOffset.current = 0;\n      }\n      isDragStarted.current = false;\n    });\n  }, [containerRef]);\n\n  useDragDown({\n    ref: containerRef,\n    isVisible: isVisible && !isContentContainerScrolled,\n    onDragStart: handleDragStart,\n    onDrag: handleDrag,\n    onDragEnd: handleDragEnd,\n    onDragCancel: handleDragCancel,\n  });\n\n  const handleExitAnimationEnd = () => {\n    if (isClosing) {\n      setClosing(false);\n      dragOffset.current = 0;\n\n      if (onUnmount) {\n        onUnmount();\n      }\n    }\n  };\n\n  const handleContentContainerScroll = () => {\n    setContentContainerScrolled(\n      contentContainerRef.current && contentContainerRef.current.scrollTop !== 0\n    );\n  };\n\n  const showSheet = (isVisible || isClosing) && !(isVisible && isClosing);\n\n  if (!showSheet) return null;\n\n  const globalStyles = {\n    html: {\n      overflow: \"hidden\",\n      overscrollBehavior: \"none\",\n    },\n  };\n\n  const idProp = id\n    ? {\n        id,\n      }\n    : {};\n\n  const sheetElm = (\n    <>\n      <Global styles={globalStyles} />\n      <FocusTrapWrapper\n        focusTrapOptions={{\n          clickOutsideDeactivates: dismissOnOutsideClick,\n          escapeDeactivates: true,\n          preventScroll: true,\n          initialFocus: () => !disableInitialFocus,\n          returnFocusOnDeactivate: !disableReturnFocusToTrigger,\n          fallbackFocus: `[data-ds-id=\"Sheet\"]`,\n          onPostDeactivate: () => {\n            onClose();\n          },\n        }}\n      >\n        <StyledContainer\n          {...idProp} // eslint-disable-line react/jsx-props-no-spreading\n          data-e2e-test-id={dataE2eTestId}\n          data-ds-id=\"Sheet\"\n          isVisible={isVisible}\n          containerHeight={containerHeight}\n          isClosing={isClosing}\n          ref={containerRef}\n          dragOffset={dragOffset.current}\n          prevVisibleState={prevVisibleState.current}\n          onAnimationEnd={handleExitAnimationEnd}\n        >\n          <Container elevation={4}>\n            <StyledHandleContainer\n              isContentContainerScrolled={isContentContainerScrolled}\n            >\n              <StyledHandle />\n            </StyledHandleContainer>\n            <StyledContentContainer\n              isClosing={isClosing}\n              ref={contentContainerRef}\n              onScroll={handleContentContainerScroll}\n              onAnimationEnd={(evt) => evt.stopPropagation()}\n            >\n              {children}\n            </StyledContentContainer>\n          </Container>\n        </StyledContainer>\n      </FocusTrapWrapper>\n    </>\n  );\n\n  return createPortal(sheetElm, portalContainer || document.body);\n}\n"],"names":["ANIMATION_DURATION_ENTRY","ANIMATION_DURATION_EXIT","ANIMATION_DURATION_CONTENT","MAX_HEIGHT_PERCENT","MIN_DRAG_DISTANCE","fadeOut","keyframes","from","opacity","to","fadeIn","StyledContainer","_styled","process","env","NODE_ENV","target","label","_ref","theme","containerHeight","isClosing","dragOffset","prevVisibleState","animation","slideOut","transform","slideIn","position","left","bottom","width","transformOrigin","boxSizing","zIndex","variables","modal","borderBottomLeftRadius","borderBottomRightRadius","StyledContentContainer","_ref2","overflow","maxHeight","overscrollBehavior","StyledHandleContainer","_ref3","isContentContainerScrolled","padding","size","spacing","xs","display","justifyContent","boxShadow","values","elevation","a","StyledHandle","_ref4","height","borderRadius","backgroundColor","color","divider","primary","Sheet","_ref5","id","children","isVisible","onClose","onUnmount","portalContainer","dismissOnOutsideClick","disableInitialFocus","disableReturnFocusToTrigger","dataE2eTestId","setClosing","useState","setContainerHeight","setContentContainerScrolled","containerRef","useRef","contentContainerRef","isDragStarted","useLayoutEffect","current","containerRect","getBoundingClientRect","useEffect","handleDragStart","useCallback","requestAnimationFrame","scrollTop","style","transition","handleDrag","_","offsetFromStart","containerCurrentHeight","handleDragEnd","minDragDistance","handleDragCancel","useDragDown","ref","onDragStart","onDrag","onDragEnd","onDragCancel","handleExitAnimationEnd","handleContentContainerScroll","showSheet","globalStyles","html","idProp","sheetElm","React","createElement","Fragment","Global","styles","FocusTrapWrapper","focusTrapOptions","clickOutsideDeactivates","escapeDeactivates","preventScroll","initialFocus","returnFocusOnDeactivate","fallbackFocus","onPostDeactivate","_extends","onAnimationEnd","Container","onScroll","evt","stopPropagation","createPortal","document","body"],"mappings":"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"}

package/build/esm/src/components/Toggletip/BasePopover.d.ts

@@ -1,17 +1,17 @@
 import React, { ReactElement } from "react";
 import type { TooltipContentProps } from "../Tooltip/TooltipContent";
 import { TooltipConditionalProps } from "../Tooltip/types";
-type BaseProps = Pick<TooltipContentProps, "placement" | "portalContainer" | "maxWidth" | "contentPadding" | "hideArrow" | "hasInvertedSubTheme"> & {
+type BaseProps = Pick<TooltipContentProps, "placement" | "portalContainer" | "maxWidth" | "contentPadding" | "hideArrow" | "hasInvertedSubTheme" | "defaultVerticalPlacement"> & {
     name?: string;
     content: ReactElement;
     "data-e2e-test-id"?: string;
     isVisible?: boolean;
-    onVisibilityChange?: (isVisible: boolean) => void;
+    onVisibilityChange?: (isVisible: boolean, reason: string) => void;
     dismissOnOutsideClick?: boolean;
     disableInitialFocus?: boolean;
     disableReturnFocusToTrigger?: boolean;
+    renderAsSheetOnMobile?: boolean;
 };
-export type BasePopoverProps = BaseProps;
-type BasePopoverInternalProps = BaseProps & TooltipConditionalProps & Pick<TooltipContentProps, "defaultVerticalPlacement">;
-export declare function BasePopover({ placement, content, children, contentPadding, maxWidth, externalTriggerRef, portalContainer, name, isVisible: isPopoverVisible, dismissOnOutsideClick, "data-e2e-test-id": dataE2eTestId, hasInvertedSubTheme, defaultVerticalPlacement, onVisibilityChange, disableInitialFocus, disableReturnFocusToTrigger, ...restContentProps }: BasePopoverInternalProps): React.ReactElement;
+export type BasePopoverProps = BaseProps & TooltipConditionalProps;
+export declare function BasePopover({ placement, content, children, contentPadding, maxWidth, externalTriggerRef, portalContainer, name, isVisible: isPopoverVisible, dismissOnOutsideClick, "data-e2e-test-id": dataE2eTestId, hasInvertedSubTheme, defaultVerticalPlacement, onVisibilityChange, disableInitialFocus, disableReturnFocusToTrigger, renderAsSheetOnMobile, ...restContentProps }: BasePopoverProps): React.ReactElement;
 export {};

package/build/esm/src/components/Toggletip/BasePopover.js

@@ -1,7 +1,9 @@
 import _extends from '@babel/runtime/helpers/extends';
 import React, { useMemo, useState, useRef, useCallback, useEffect } from 'react';
-import FocusTrap from 'focus-trap-react';
 import { TooltipContent } from '../Tooltip/TooltipContent.js';
+import { Sheet } from '../Sheet/Sheet.js';
+import { FocusTrapWrapper } from '../../shared/FocusTrapWrapper.js';
+import breakpoints from '../../../build-tokens/_breakpoints.json.js';
 
 const FocusTrapContent = /*#__PURE__*/React.forwardRef((_ref, ref) => {
   let {
@@ -11,6 +13,10 @@ const FocusTrapContent = /*#__PURE__*/React.forwardRef((_ref, ref) => {
     ref: ref
   }, children);
 });
+const VisibilityChangeReason = {
+  triggerClick: "triggerClick",
+  outsideClick: "outsideClick"
+};
 function BasePopover(_ref2) {
   let {
     placement = "auto",
@@ -29,24 +35,27 @@ function BasePopover(_ref2) {
     onVisibilityChange,
     disableInitialFocus = false,
     disableReturnFocusToTrigger = false,
+    renderAsSheetOnMobile = false,
     ...restContentProps
   } = _ref2;
   const tooltipId = useMemo(() => `DS${name}_${Math.floor(Date.now() * Math.random())}`, [name]);
   const [isVisible, setVisible] = useState(isPopoverVisible);
+  const [isMobileBreakPoint, setIsMobileBreakpoint] = useState(false);
   const internalTriggerRef = useRef(null);
   const triggerRef = externalTriggerRef || internalTriggerRef;
   const isOutsideClickOnTrigger = useRef(false);
-  const toggleVisibility = useCallback(status => {
+  const isPrevMobileBreakPointRef = useRef(false);
+  const toggleVisibility = useCallback((status, reason) => {
     setVisible(status);
     if (onVisibilityChange) {
-      onVisibilityChange(status);
+      onVisibilityChange(status, reason);
     }
   }, [onVisibilityChange]);
 
   // Outside click is also fired when the Popover is open and trigger is clicked. `isOutsideClickOnTrigger` saves this condition and we check for it so as to not toggle the Popover twice.
   const handleTriggerClick = useCallback(() => {
     if (!isOutsideClickOnTrigger.current) {
-      toggleVisibility(!isVisible);
+      toggleVisibility(!isVisible, VisibilityChangeReason.triggerClick);
     } else {
       // reset this value so that Popover can open in next click
       isOutsideClickOnTrigger.current = false;
@@ -58,9 +67,21 @@ function BasePopover(_ref2) {
     }
     return true;
   }, [triggerRef, isOutsideClickOnTrigger]);
+  const handleSheetClose = useCallback(() => {
+    toggleVisibility(false, "sheetClose");
+  }, [toggleVisibility]);
   useEffect(() => {
     setVisible(isPopoverVisible);
   }, [isPopoverVisible]);
+  useEffect(() => {
+    // Check if this is a mobile breakpoint
+    if (renderAsSheetOnMobile) {
+      setIsMobileBreakpoint(window.innerWidth <= breakpoints.medium.value);
+    }
+  }, [isVisible, renderAsSheetOnMobile]);
+  useEffect(() => {
+    isPrevMobileBreakPointRef.current = isMobileBreakPoint;
+  }, [isMobileBreakPoint]);
   useEffect(() => {
     let trigger;
     if (externalTriggerRef?.current && !children) {
@@ -100,7 +121,21 @@ function BasePopover(_ref2) {
       }
     }
   }) : null;
-  const contentElm = /*#__PURE__*/React.createElement(FocusTrap, {
+  if (isMobileBreakPoint) {
+    // render as Sheet
+    const sheetElm = /*#__PURE__*/React.createElement(Sheet, {
+      id: tooltipId,
+      isVisible: isVisible,
+      onClose: handleSheetClose,
+      dismissOnOutsideClick: dismissOnOutsideClick,
+      disableInitialFocus: disableInitialFocus,
+      disableReturnFocusToTrigger: disableReturnFocusToTrigger
+    }, content);
+    return /*#__PURE__*/React.createElement(React.Fragment, null, triggerElm, sheetElm);
+  }
+
+  // render as Popover
+  const contentElm = /*#__PURE__*/React.createElement(FocusTrapWrapper, {
     focusTrapOptions: {
       clickOutsideDeactivates: dismissOnOutsideClick && handleClickOutsideDeactivates,
       // de-active focus trap on outside click
@@ -109,8 +144,9 @@ function BasePopover(_ref2) {
       // de-activate focus trap on escape key
       fallbackFocus: `#${tooltipId}`,
       // set focus to tooltip content container if it has no focusable element
-      onDeactivate: () => {
-        toggleVisibility(false);
+      onPostDeactivate: () => {
+        const reason = isOutsideClickOnTrigger.current ? VisibilityChangeReason.triggerClick : VisibilityChangeReason.outsideClick;
+        toggleVisibility(false, reason);
       },
       preventScroll: true,
       initialFocus: () => !disableInitialFocus,