@telus-uds/components-base 1.24.0 → 1.24.2

package/lib-module/List/ListItem.js

@@ -1,5 +1,6 @@
 import React, { forwardRef } from 'react';
 import ListItemBase from './ListItemBase';
+import Typography from '../Typography';
 import { useThemeTokens } from '../ThemeProvider';
 import { variantProp } from '../utils';
 /**
@@ -7,19 +8,26 @@ import { variantProp } from '../utils';
  */
 
 import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
 const ListItem = /*#__PURE__*/forwardRef((_ref, ref) => {
   let {
     tokens,
     variant,
     children,
+    title,
     ...listItemProps
   } = _ref;
   const themeTokens = useThemeTokens('List', tokens, variant);
-  return /*#__PURE__*/_jsx(ListItemBase, {
+  return /*#__PURE__*/_jsxs(ListItemBase, {
     tokens: themeTokens,
     ref: ref,
     ...listItemProps,
-    children: children
+    children: [Boolean(title) && /*#__PURE__*/_jsx(Typography, {
+      variant: {
+        size: 'h4'
+      },
+      children: title
+    }), children]
   });
 });
 ListItem.displayName = 'ListItem';

package/lib-module/Radio/RadioGroup.js

@@ -145,8 +145,8 @@ const RadioGroup = /*#__PURE__*/forwardRef((_ref, ref) => {
     feedback: feedback,
     inactive: inactive,
     validation: validation,
-    showIcon: true,
     showErrorBorder: true,
+    showIcon: true,
     accessibilityRole: "radiogroup",
     ...selectProps(rest),
     children: getStackedContent(radios, {

package/lib-module/StackView/StackView.js

@@ -66,7 +66,9 @@ const StackView = /*#__PURE__*/forwardRef((_ref, ref) => {
   } = _ref;
   const viewport = useViewport();
   const direction = useResponsiveProp(directionProp, 'column');
-  const selectedProps = selectProps({ ...getA11yPropsFromHtmlTag(tag, accessibilityRole),
+  const selectedProps = selectProps({
+    accessibilityRole,
+    ...getA11yPropsFromHtmlTag(tag, accessibilityRole),
     ...rest
   });
   const content = getStackedContent(children, {

package/lib-module/StackView/StackWrapBox.js

@@ -51,7 +51,9 @@ const StackWrapBox = /*#__PURE__*/forwardRef((_ref, ref) => {
     viewport
   });
   const flexStyles = selectFlexStyles(themeTokens);
-  const selectedProps = selectProps({ ...getA11yPropsFromHtmlTag(tag, accessibilityRole),
+  const selectedProps = selectProps({
+    accessibilityRole,
+    ...getA11yPropsFromHtmlTag(tag, accessibilityRole),
     ...rest
   }); // Mimic CSS `gap` using box spacing on the side after a wrapped row then offsetting it on the last row.
 

package/lib-module/StackView/StackWrapGap.js

@@ -36,7 +36,9 @@ const StackWrapGap = /*#__PURE__*/forwardRef((_ref, ref) => {
     viewport
   });
   const flexStyles = selectFlexStyles(themeTokens);
-  const selectedProps = selectProps({ ...getA11yPropsFromHtmlTag(tag, accessibilityRole),
+  const selectedProps = selectProps({
+    accessibilityRole,
+    ...getA11yPropsFromHtmlTag(tag, accessibilityRole),
     ...rest
   });
   const size = useSpacingScale(space);

package/lib-module/ThemeProvider/utils/styles.js

@@ -45,9 +45,7 @@ export function applyTextStyles(_ref) {
     // Don't set undefined font families. May need some validation here that the font is available.
     // Android doesn't recognise font weights natively so apply custom font weights via `fontFamily`.
     styles.fontFamily = "".concat(fontName).concat(fontWeight).concat(fontStyle);
-  }
-
-  if (fontWeight) {
+  } else if (fontWeight) {
     // If using system default font, apply the font weight directly.
     // Font weight support in Android is limited to 'bold' or anything else === 'normal'.
     styles.fontWeight = Platform.OS === 'android' && Number(fontWeight) > 400 ? 'bold' : fontWeight;

package/lib-module/Tooltip/Tooltip.js

@@ -1,15 +1,13 @@
 import React, { forwardRef, useEffect, useRef, useState } from 'react';
-import Dimensions from "react-native-web/dist/exports/Dimensions";
 import Platform from "react-native-web/dist/exports/Platform";
 import Pressable from "react-native-web/dist/exports/Pressable";
 import StyleSheet from "react-native-web/dist/exports/StyleSheet";
 import Text from "react-native-web/dist/exports/Text";
 import View from "react-native-web/dist/exports/View";
-import PropTypes from 'prop-types';
+import propTypes from './shared';
+import { useFloating, arrow, offset, shift, flip, autoPlacement } from '../utils/floating-ui';
 import { applyShadowToken, applyTextStyles, useThemeTokens } from '../ThemeProvider';
-import { a11yProps, getTokensPropType, selectSystemProps, selectTokens, variantProp, viewProps } from '../utils';
-import Backdrop from './Backdrop';
-import getTooltipPosition from './getTooltipPosition';
+import { a11yProps, selectSystemProps, selectTokens, viewProps } from '../utils';
 import TooltipButton from '../TooltipButton';
 import useCopy from '../utils/useCopy';
 import dictionary from './dictionary';
@@ -47,20 +45,20 @@ const selectTooltipShadowStyles = _ref2 => {
   };
 };
 
-const selectTooltipPositionStyles = _ref3 => {
+const selectMobileTooltipPositionStyles = _ref3 => {
   let {
     top,
     left,
-    width
+    position
   } = _ref3;
   return {
     top,
     left,
-    width
+    position
   };
 };
 
-const selectArrowStyles = (_ref4, _ref5) => {
+const selectMobileArrowStyles = (_ref4, _ref5) => {
   let {
     backgroundColor,
     arrowWidth,
@@ -68,56 +66,31 @@ const selectArrowStyles = (_ref4, _ref5) => {
     shadow
   } = _ref4;
   let {
-    position,
-    width: tooltipWidth,
-    height: tooltipHeight
+    placement,
+    x: arrowX,
+    y: arrowY
   } = _ref5;
-  // the arrow width is actually a diagonal of the rectangle that we'll use as a tip
-  const rectangleSide = Math.sqrt(arrowWidth * arrowWidth / 2); // position the arrow at the side and center of the tooltip - this happens before rotation
-  // so we use the rectangle size as basis
-
-  const verticalOffset = -1 * rectangleSide / 2;
-  const horizontalOffset = rectangleSide / 2; // percentage-based absolute positioning doesn't act well on native, so we have to
-  // calculate the pixel values
-
-  const directionalStyles = {
-    above: {
-      bottom: verticalOffset,
-      left: tooltipWidth / 2 - horizontalOffset,
-      transform: [{
-        rotateZ: '45deg'
-      }]
-    },
-    below: {
-      top: verticalOffset,
-      left: tooltipWidth / 2 - horizontalOffset,
-      transform: [{
-        rotateZ: '-135deg'
-      }]
-    },
-    left: {
-      right: verticalOffset,
-      top: tooltipHeight / 2 - horizontalOffset,
-      transform: [{
-        rotateZ: '-45deg'
-      }]
-    },
-    right: {
-      left: verticalOffset,
-      top: tooltipHeight / 2 - horizontalOffset,
-      transform: [{
-        rotateZ: '135deg'
-      }]
-    }
-  };
+  const staticSide = {
+    top: 'bottom',
+    right: 'left',
+    bottom: 'top',
+    left: 'right'
+  }[placement.split('-')[0]];
   return {
     backgroundColor,
-    width: rectangleSide,
-    height: rectangleSide,
+    width: arrowWidth,
+    height: arrowWidth,
     borderBottomRightRadius: arrowBorderRadius,
     // this corner will be the arrow tip after rotation
+    transform: [{
+      rotateZ: '45deg'
+    }],
     ...applyShadowToken(shadow),
-    ...directionalStyles[position]
+    left: arrowX != null && arrowX,
+    top: arrowY != null && arrowY,
+    right: '',
+    bottom: '',
+    [staticSide]: '-4px'
   };
 };
 
@@ -155,40 +128,50 @@ const Tooltip = /*#__PURE__*/forwardRef((_ref6, ref) => {
     ...rest
   } = _ref6;
   const [isOpen, setIsOpen] = useState(false);
-  const controlRef = useRef();
-  const [controlLayout, setControlLayout] = useState(null);
+  const arrowRef = useRef();
   const [tooltipDimensions, setTooltipDimensions] = useState(null);
-  const [windowDimensions, setWindowDimensions] = useState(Dimensions.get('window'));
-  const [tooltipPosition, setTooltipPosition] = useState(null);
+  const positions = {
+    auto: undefined,
+    // Auto needs to specifically bet set to undefined
+    above: 'top',
+    right: 'right',
+    below: 'bottom',
+    left: 'left'
+  }; // "AutoPlacement" can't be used with "flip"
+
+  const additionalMiddleware = position !== 'auto' ? autoPlacement : flip;
+  const {
+    x,
+    y,
+    reference,
+    floating,
+    strategy,
+    placement,
+    middlewareData: {
+      arrow: arrowData = {}
+    }
+  } = useFloating({
+    placement: positions[position],
+    middleware: [shift(), additionalMiddleware(), offset(15), arrow({
+      element: arrowRef
+    })]
+  });
   const getCopy = useCopy({
     dictionary,
     copy
   });
   const themeTokens = useThemeTokens('Tooltip', tokens, variant);
-  const {
-    arrowWidth,
-    arrowOffset
-  } = themeTokens;
-  useEffect(() => {
-    const subscription = Dimensions.addEventListener('change', _ref7 => {
-      let {
-        window
-      } = _ref7;
-      setWindowDimensions(window);
-    });
-    return () => subscription === null || subscription === void 0 ? void 0 : subscription.remove();
-  });
 
   const toggleIsOpen = () => setIsOpen(!isOpen);
 
   const close = () => setIsOpen(false);
 
-  const getPressableState = _ref8 => {
+  const getPressableState = _ref7 => {
     let {
       pressed,
       hovered,
       focused
-    } = _ref8;
+    } = _ref7;
     return {
       pressed,
       hover: hovered,
@@ -196,7 +179,7 @@ const Tooltip = /*#__PURE__*/forwardRef((_ref6, ref) => {
     };
   };
 
-  const onTooltipLayout = _ref9 => {
+  const onTooltipLayout = _ref8 => {
     let {
       nativeEvent: {
         layout: {
@@ -204,7 +187,7 @@ const Tooltip = /*#__PURE__*/forwardRef((_ref6, ref) => {
           height
         }
       }
-    } = _ref9;
+    } = _ref8;
 
     if (tooltipDimensions === null || tooltipDimensions.width !== width || tooltipDimensions.height !== height) {
       setTooltipDimensions({
@@ -219,43 +202,10 @@ const Tooltip = /*#__PURE__*/forwardRef((_ref6, ref) => {
   };
 
   useEffect(() => {
-    if (isOpen) {
-      controlRef.current.measureInWindow((x, y, width, height) => {
-        setControlLayout({
-          x,
-          y,
-          width,
-          height
-        });
-      });
-    } else {
-      setControlLayout(null);
+    if (!isOpen) {
       setTooltipDimensions(null);
-      setTooltipPosition(null);
     }
   }, [isOpen]);
-  useEffect(() => {
-    setIsOpen(false);
-  }, [windowDimensions]);
-  useEffect(() => {
-    if (tooltipPosition !== null && !(tooltipPosition !== null && tooltipPosition !== void 0 && tooltipPosition.isNormalized) || !isOpen || controlLayout === null || tooltipDimensions == null) {
-      return;
-    }
-
-    const updatedPosition = getTooltipPosition(position, {
-      controlLayout,
-      tooltipDimensions,
-      windowDimensions,
-      arrowWidth,
-      arrowOffset
-    }); // avoid ending up in an infinite normalization loop
-
-    if (tooltipPosition !== null && tooltipPosition !== void 0 && tooltipPosition.isNormalized && updatedPosition.isNormalized) {
-      return;
-    }
-
-    setTooltipPosition(updatedPosition);
-  }, [isOpen, position, tooltipDimensions, controlLayout, windowDimensions, arrowWidth, arrowOffset, tooltipPosition]);
   const control = children !== undefined ? children : defaultControl;
   const pressableStyles = control === defaultControl ? Platform.select({
     web: {
@@ -271,67 +221,50 @@ const Tooltip = /*#__PURE__*/forwardRef((_ref6, ref) => {
   return /*#__PURE__*/_jsxs(View, {
     style: staticStyles.container,
     ...selectProps(rest),
+    ref: ref,
     children: [/*#__PURE__*/_jsx(Pressable, {
       onPress: toggleIsOpen,
-      ref: controlRef,
+      ref: reference,
       onBlur: close,
       style: pressableStyles,
       hitSlop: pressableHitSlop,
       accessibilityLabel: getCopy('a11yText'),
       accessibilityRole: "button",
       children: typeof control === 'function' ? pressableState => control(getPressableState(pressableState), variant) : control
-    }), isOpen && /*#__PURE__*/_jsx(Backdrop, {
-      onPress: close,
-      children: /*#__PURE__*/_jsxs(View, {
-        ref: ref,
-        style: [staticStyles.tooltip, selectTooltipShadowStyles(themeTokens), // applied separately so that it doesn't cover the arrow
-        tooltipPosition && selectTooltipPositionStyles(tooltipPosition), (tooltipPosition === null || (tooltipPosition === null || tooltipPosition === void 0 ? void 0 : tooltipPosition.isNormalized)) && staticStyles.tooltipHidden // visually hide the tooltip until we have a final measurement
-        ],
-        onLayout: onTooltipLayout,
-        accessibilityRole: "alert",
-        children: [/*#__PURE__*/_jsx(View, {
-          style: [staticStyles.arrow, tooltipPosition && selectArrowStyles(themeTokens, tooltipPosition)]
-        }), /*#__PURE__*/_jsx(View, {
-          style: selectTooltipStyles(themeTokens),
-          children: /*#__PURE__*/_jsx(Text, {
-            style: selectTextStyles(themeTokens),
-            children: content
-          })
-        })]
-      })
+    }), isOpen && /*#__PURE__*/_jsxs(View, {
+      ref: floating,
+      style: [selectTooltipShadowStyles(themeTokens), staticStyles.tooltip, // applied separately so that it doesn't cover the arrow
+      selectMobileTooltipPositionStyles({
+        position: strategy,
+        top: y !== null && y !== void 0 ? y : 0,
+        left: x !== null && x !== void 0 ? x : 0
+      })],
+      onLayout: onTooltipLayout,
+      accessibilityRole: "alert",
+      children: [/*#__PURE__*/_jsx(View, {
+        style: [staticStyles.arrow, selectMobileArrowStyles(themeTokens, { ...arrowData,
+          placement
+        })],
+        ref: arrowRef
+      }), /*#__PURE__*/_jsx(View, {
+        style: selectTooltipStyles(themeTokens),
+        children: /*#__PURE__*/_jsx(Text, {
+          style: selectTextStyles(themeTokens),
+          children: content
+        })
+      })]
     })]
   });
 });
 Tooltip.displayName = 'Tooltip';
 Tooltip.propTypes = { ...selectedSystemPropTypes,
-
-  /**
-   * Used to render the control (i.e. tooltip trigger). If a render function is used it will receive the
-   * pressable state and tooltip variant as an argument.
-   */
-  children: PropTypes.oneOfType([PropTypes.func, PropTypes.node]),
-
-  /**
-   * The message. Can be raw text or text components.
-   */
-  content: PropTypes.oneOfType([PropTypes.string, PropTypes.node]),
-
-  /**
-   * Select English or French copy for the accessible label.
-   */
-  copy: PropTypes.oneOf(['en', 'fr']),
-
-  /**
-   * Use to place the tooltip in a specific location (only if it fits within viewport).
-   */
-  position: PropTypes.oneOf(['auto', 'above', 'right', 'below', 'left']),
-  tokens: getTokensPropType('Tooltip'),
-  variant: variantProp.propType
+  ...propTypes
 };
 export default Tooltip;
 const staticStyles = StyleSheet.create({
   container: {
-    alignItems: 'flex-start'
+    alignItems: 'flex-start',
+    position: 'absolute'
   },
   tooltip: {
     position: 'absolute',
@@ -339,9 +272,6 @@ const staticStyles = StyleSheet.create({
     top: 0,
     left: 0
   },
-  tooltipHidden: {
-    opacity: 0
-  },
   arrow: {
     position: 'absolute'
   }