@telus-uds/components-base 0.0.2-prerelease.3 → 0.0.2-prerelease.7

package/lib/Pagination/SideButton.js

@@ -1,41 +1,31 @@
 import React from 'react';
-import { StyleSheet, View, Text, PixelRatio } from 'react-native';
+import { Text } from 'react-native';
 import PropTypes from 'prop-types';
 import ButtonBase from '../Button/ButtonBase';
-import { applyTextStyles, useThemeTokensCallback } from '../ThemeProvider';
+import { IconText } from '../Icon';
+import { useThemeTokensCallback } from '../ThemeProvider';
 import { useViewport } from '../ViewportProvider';
 import { copyPropTypes, hrefAttrsProp, linkProps, selectTokens } from '../utils';
 import dictionary from './dictionary';
-import useCopy from './useCopy';
-
-const selectTextStyles = ({
-  color,
-  fontName,
-  fontSize,
-  fontWeight,
-  lineHeight
-}) => applyTextStyles({
-  color,
-  fontName,
-  fontSize,
-  fontWeight,
-  lineHeight
-});
+import useCopy from '../utils/useCopy';
 
 const selectIconTokens = ({
   color,
   iconSize,
-  iconTranslateX
-}) => {
-  // Scale icon with text, but with a cap so text isn't squashed at large scales
-  const iconScale = Math.min(PixelRatio.getFontScale(), 2);
+  iconDisplace
+}, direction) => {
   return {
     color,
-    size: iconSize * iconScale,
-    translateX: iconTranslateX
+    size: iconSize,
+    translateX: iconDisplace * (direction === 'previous' ? -1 : 1)
   };
 };
 
+const directionToSide = {
+  previous: 'left',
+  next: 'right'
+};
+
 function SideButton({
   direction = 'previous',
   onPress,
@@ -57,14 +47,12 @@ function SideButton({
     copy
   });
   const {
-    icon: IconComponent
+    icon
   } = getTokens(tokens, buttonVariant);
 
   const getButtonTokens = buttonState => selectTokens('Button', getTokens(buttonState));
 
-  const getIconTokens = buttonState => selectIconTokens(getTokens(buttonState));
-
-  const getTextStyles = buttonState => selectTextStyles(getTokens(buttonState));
+  const getIconTokens = buttonState => selectIconTokens(getTokens(buttonState), direction);
 
   const label = direction === 'previous' ? getCopy('previousText') : getCopy('nextText');
   const showLabel = viewport !== 'sm' && viewport !== 'xs';
@@ -84,15 +72,22 @@ function SideButton({
   };
   return /*#__PURE__*/React.createElement(ButtonBase, Object.assign({}, buttonProps, {
     tokens: getButtonTokens
-  }), buttonState => /*#__PURE__*/React.createElement(View, {
-    style: staticStyles.contentContainer
-  }, direction === 'previous' && IconComponent && /*#__PURE__*/React.createElement(IconComponent, {
-    tokens: getIconTokens(buttonState)
-  }), showLabel && /*#__PURE__*/React.createElement(Text, {
-    style: getTextStyles(buttonState)
-  }, label), direction === 'next' && IconComponent && /*#__PURE__*/React.createElement(IconComponent, {
-    tokens: getIconTokens(buttonState)
-  })));
+  }), ({
+    textStyles,
+    ...buttonState
+  }) => {
+    const iconProps = {
+      tokens: getIconTokens(buttonState)
+    };
+    return /*#__PURE__*/React.createElement(IconText, {
+      icon: icon,
+      space: 1,
+      iconPosition: directionToSide[direction],
+      iconProps: iconProps
+    }, showLabel && /*#__PURE__*/React.createElement(Text, {
+      style: textStyles
+    }, label));
+  });
 }
 
 SideButton.propTypes = {
@@ -100,9 +95,4 @@ SideButton.propTypes = {
   copy: copyPropTypes,
   ...linkProps.types
 };
-export default SideButton;
-const staticStyles = StyleSheet.create({
-  contentContainer: {
-    flexDirection: 'row'
-  }
-});
+export default SideButton;

package/lib/Radio/Radio.js

@@ -0,0 +1,291 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Pressable, StyleSheet, Text, View } from 'react-native';
+import RadioInput from './RadioInput'; // @todo move `LabelContent` outside of the `InputLabel` and fix
+// the issue with the cursor not being pointer on Web
+
+import RadioLabel from '../InputLabel/LabelContent';
+import { applyShadowToken, applyTextStyles, useThemeTokensCallback } from '../ThemeProvider';
+import { getTokensPropType, useInputValue, useUniqueId, variantProp } from '../utils';
+import { a11yProps } from '../utils/propTypes';
+import StackView from '../StackView';
+
+const selectCheckedStyles = ({
+  checkedBackgroundColor,
+  checkedSize
+}) => ({
+  backgroundColor: checkedBackgroundColor,
+  borderRadius: checkedSize / 2,
+  height: checkedSize,
+  width: checkedSize
+});
+
+const selectContainerStyles = ({
+  containerBackgroundColor,
+  containerBorderRadius,
+  containerMarginBottom,
+  containerOpacity,
+  containerPaddingBottom,
+  containerPaddingLeft,
+  containerPaddingRight,
+  containerPaddingTop,
+  containerShadow
+}) => ({
+  backgroundColor: containerBackgroundColor,
+  borderRadius: containerBorderRadius,
+  marginBottom: containerMarginBottom,
+  opacity: containerOpacity,
+  paddingBottom: containerPaddingBottom,
+  paddingLeft: containerPaddingLeft,
+  paddingRight: containerPaddingRight,
+  paddingTop: containerPaddingTop,
+  ...applyShadowToken(containerShadow)
+});
+
+const selectDescriptionStyles = ({
+  containerPaddingLeft = 0,
+  descriptionFontSize,
+  descriptionLineHeight,
+  descriptionMarginLeft,
+  inputSize,
+  labelMarginLeft = 0
+}) => ({
+  marginLeft: descriptionMarginLeft ?? containerPaddingLeft + inputSize + labelMarginLeft,
+  ...applyTextStyles({
+    fontSize: descriptionFontSize,
+    lineHeight: descriptionLineHeight
+  })
+});
+
+const selectInputStyles = ({
+  inputBackgroundColor,
+  inputBorderColor,
+  inputBorderWidth,
+  inputOutlineColor,
+  inputOutlineWidth,
+  inputSize
+}) => ({
+  borderColor: inputBorderColor,
+  borderRadius: inputSize / 2,
+  borderWidth: inputBorderWidth,
+  backgroundColor: inputBackgroundColor,
+  height: inputSize,
+  outlineStyle: 'solid',
+  outlineColor: inputOutlineColor,
+  outlineWidth: inputOutlineWidth,
+  width: inputSize
+});
+
+const selectLabelStyles = ({
+  labelColor,
+  labelFontName,
+  labelFontSize,
+  labelFontWeight,
+  labelMarginLeft,
+  labelLineHeight
+}) => applyTextStyles({
+  color: labelColor,
+  fontName: labelFontName,
+  fontWeight: labelFontWeight,
+  fontSize: labelFontSize,
+  lineHeight: labelLineHeight,
+  marginLeft: labelMarginLeft
+});
+/**
+ * Basic Radio component.
+ *
+ * ## Component API
+ *
+ * Use `label` prop to provide a label for the radio button. For a disabled `Radio` set the `inactive` prop to `true`.
+ *
+ * ### Controlled version
+ *
+ * If the radio button is controlled from outside, it needs to receive `checked` and `onChange` props.
+ *
+ * ### Uncontrolled version
+ *
+ * In case of uncontrolled radio button you can use `defaultChecked` prop to provide the initial value.
+ * Whenever the radio button gets toggled, it calls the `onChange` callback with the new value (boolean).
+ *
+ * ### Using within forms
+ *
+ * You can pass `name` and `value` props if you need a particular radio button to be a part of a radio group
+ * on a form.
+ *
+ * ### Validation
+ *
+ * You can mark a radio button as failing validation by setting the `error` prop to `true`.
+ *
+ * ## A11y guidelines
+ *
+ * Radio component accepts all the common accessibility props, but also sets some defaults, including
+ * accessibility role `'radio'` and accessibility state that depends on the other props (`checked`, `inactive`)
+ * or the internal state in case of uncontrolled radio button.
+ *
+ */
+
+
+const Radio = ({
+  checked,
+  defaultChecked,
+  description,
+  error = false,
+  id,
+  inactive,
+  label,
+  name,
+  onChange,
+  tokens,
+  value,
+  variant,
+  ...rest
+}) => {
+  const {
+    currentValue: isChecked,
+    setValue: setIsChecked,
+    isControlled
+  } = useInputValue({
+    value: checked,
+    initialValue: defaultChecked,
+    onChange
+  }, 'useRadioValue');
+  const getTokens = useThemeTokensCallback('Radio', tokens, {
+    checked: isChecked,
+    inactive,
+    error,
+    ...variant
+  });
+
+  const handleChange = () => {
+    if (!inactive && !isChecked) {
+      setIsChecked(true);
+    }
+  };
+
+  const accessibilityProps = a11yProps.select(rest);
+  const uniqueId = useUniqueId('radio');
+  const inputId = id ?? uniqueId; // @todo our current version of React Native Web doesn't include
+  // keyboard support on `Pressable` (which starts with 0.15.3), so
+  // the complete accessibility of the `Radio` component on Web
+  // (namely, change on key pressed) is pending RNW upgrade
+  // (see https://github.com/necolas/react-native-web/issues/1950)
+
+  return /*#__PURE__*/React.createElement(Pressable, Object.assign({
+    disabled: inactive,
+    onPress: handleChange,
+    accessibilityRole: "radio",
+    accessibilityState: {
+      checked: isChecked,
+      disabled: inactive
+    }
+  }, accessibilityProps), ({
+    focused: focus,
+    hovered: hover,
+    pressed
+  }) => {
+    const stateTokens = getTokens({
+      focus,
+      hover,
+      pressed
+    });
+    return /*#__PURE__*/React.createElement(StackView, {
+      space: 0
+    }, /*#__PURE__*/React.createElement(View, {
+      style: [staticStyles.container, selectContainerStyles(stateTokens)]
+    }, /*#__PURE__*/React.createElement(View, {
+      style: StyleSheet.flatten([staticStyles.defaultInputStyles, selectInputStyles(stateTokens, isChecked)]),
+      testID: "Radio-Input"
+    }, /*#__PURE__*/React.createElement(RadioInput, {
+      checked: isChecked,
+      defaultChecked: defaultChecked,
+      disabled: inactive,
+      id: inputId,
+      isControlled: isControlled,
+      name: name,
+      value: value
+    }), isChecked && /*#__PURE__*/React.createElement(View, {
+      style: selectCheckedStyles(stateTokens),
+      testID: "Radio-Checked"
+    })), Boolean(label) && /*#__PURE__*/React.createElement(Text, {
+      style: selectLabelStyles(stateTokens)
+    }, /*#__PURE__*/React.createElement(RadioLabel, {
+      forId: inputId
+    }, label))), Boolean(description) && /*#__PURE__*/React.createElement(Text, {
+      style: selectDescriptionStyles(getTokens())
+    }, description));
+  });
+};
+
+Radio.propTypes = { ...a11yProps.propTypes,
+
+  /**
+   * Use `checked` for controlled Radio. For uncontrolled Radio, use the `defaultChecked` prop.
+   */
+  checked: PropTypes.bool,
+
+  /**
+   * Use `defaultChecked` to provide the initial value for an uncontrolled Radio.
+   */
+  defaultChecked: PropTypes.bool,
+
+  /**
+   * An optional radio button description.
+   */
+  description: PropTypes.string,
+
+  /**
+   * Radio button ID.
+   */
+  id: PropTypes.string,
+
+  /**
+   * Whether the corresponding input is disabled or active.
+   */
+  inactive: PropTypes.bool,
+
+  /**
+   * The label.
+   */
+  label: PropTypes.string,
+
+  /**
+   * Associate this radio button with a group (set as the name attribute).
+   */
+  name: PropTypes.string,
+
+  /**
+   * Whether the underlying input triggered a validation error or not.
+   */
+  error: PropTypes.bool,
+
+  /**
+   * The value. Must be unique within the group.
+   */
+  value: PropTypes.oneOfType([PropTypes.string, PropTypes.number, PropTypes.bool]),
+
+  /**
+   * Callback called when a controlled radio button gets interacted with.
+   */
+  onChange: PropTypes.func,
+
+  /**
+   * Radio tokens.
+   */
+  tokens: getTokensPropType('Radio'),
+
+  /**
+   * Radio variant.
+   */
+  variant: variantProp.propType
+};
+export default Radio;
+const staticStyles = StyleSheet.create({
+  container: {
+    flexDirection: 'row',
+    alignItems: 'center'
+  },
+  defaultInputStyles: {
+    alignItems: 'center',
+    justifyContent: 'center'
+  }
+});

package/lib/Radio/RadioInput.native.js

@@ -0,0 +1,6 @@
+/**
+ * There's no radio button input on native platforms, so this is a noop.
+ */
+const RadioInput = () => null;
+
+export default RadioInput;

package/lib/Radio/RadioInput.web.js

@@ -0,0 +1,59 @@
+import React, { forwardRef } from 'react';
+import PropTypes from 'prop-types';
+/**
+ * On Web we need to include an actual input but hide it.
+ */
+
+const RadioInput = /*#__PURE__*/forwardRef(({
+  checked,
+  defaultChecked,
+  disabled,
+  id,
+  isControlled,
+  name,
+  onChange,
+  value
+}, ref) => {
+  const handleClick = event => {
+    // Cancel the click dispatched via the label tag, since it's already wrapped
+    // in <Pressable>
+    event.preventDefault();
+    event.stopPropagation();
+  };
+
+  return /*#__PURE__*/React.createElement("input", {
+    checked: isControlled ? checked : undefined,
+    defaultChecked: isControlled ? undefined : defaultChecked,
+    disabled: disabled,
+    hidden: true,
+    id: id,
+    name: name,
+    onChange: onChange,
+    onClick: handleClick,
+    ref: ref,
+    type: "radio",
+    value: value
+  });
+});
+RadioInput.displayName = 'Radio';
+RadioInput.propTypes = {
+  checked: PropTypes.bool,
+  defaultChecked: PropTypes.bool,
+  disabled: PropTypes.bool,
+  id: PropTypes.string,
+  isControlled: PropTypes.bool,
+  name: PropTypes.string,
+  onChange: PropTypes.func,
+  value: PropTypes.oneOfType([PropTypes.string, PropTypes.number, PropTypes.bool])
+};
+RadioInput.defaultProps = {
+  checked: undefined,
+  defaultChecked: undefined,
+  disabled: false,
+  id: null,
+  isControlled: false,
+  name: undefined,
+  onChange: () => {},
+  value: undefined
+};
+export default RadioInput;

package/lib/Radio/index.js

@@ -0,0 +1,2 @@
+import Radio from './Radio';
+export default Radio;

package/lib/Select/Group.native.js

@@ -0,0 +1,14 @@
+import PropTypes from 'prop-types';
+import { componentPropType } from '../utils';
+
+const Group = ({
+  children
+}) => {
+  return children;
+};
+
+export default Group;
+Group.propTypes = {
+  children: componentPropType('Item'),
+  label: PropTypes.string.isRequired
+};

package/lib/Select/Group.web.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { componentPropType } from '../utils';
+
+const Group = ({
+  children,
+  label
+}) => {
+  return /*#__PURE__*/React.createElement("optgroup", {
+    label: label
+  }, children);
+};
+
+export default Group;
+Group.propTypes = {
+  children: componentPropType('Item'),
+  label: PropTypes.string.isRequired
+};

package/lib/Select/Item.native.js

@@ -0,0 +1,9 @@
+import PropTypes from 'prop-types';
+
+const Item = () => null;
+
+export default Item;
+Item.propTypes = {
+  children: PropTypes.string.isRequired,
+  value: PropTypes.string.isRequired
+};

package/lib/Select/Item.web.js

@@ -0,0 +1,15 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+
+const Item = ({
+  children,
+  value
+}) => /*#__PURE__*/React.createElement("option", {
+  value: value
+}, children);
+
+export default Item;
+Item.propTypes = {
+  children: PropTypes.string.isRequired,
+  value: PropTypes.string.isRequired
+};

package/lib/Select/Picker.native.js

@@ -0,0 +1,87 @@
+import React, { Children } from 'react';
+import PropTypes from 'prop-types';
+import { View, Platform } from 'react-native';
+import NativePicker from 'react-native-picker-select';
+import { a11yProps, componentPropType } from '../utils';
+import Group from './Group'; // styling of the native input is very limited, most of the styles have to be applied to an additional View
+
+const selectAndroidInputStyles = ({
+  height = 0,
+  paddingBottom = 0,
+  paddingTop = 0,
+  borderWidth = 0,
+  color
+}) => ({
+  height: height - paddingTop - paddingBottom - 2 * borderWidth,
+  color
+}); // the native input has a side padding of 8px, which can't be adjusted, so we have to account for that in the container
+
+
+const selectAndroidContainerStyles = ({
+  paddingLeft = 0,
+  paddingRight = 0,
+  ...rest
+}) => ({
+  paddingLeft: paddingLeft > 8 ? paddingLeft - 8 : 0,
+  paddingRight: paddingRight > 8 ? paddingRight - 8 : 0,
+  ...rest
+});
+
+const Picker = ({
+  value,
+  onChange,
+  onFocus,
+  onBlur,
+  style,
+  inactive,
+  children,
+  placeholder,
+  ...rest
+}) => {
+  // ungroup items, since there's no way to support groups on native
+  const flatChildren = Children.toArray(children).flatMap(child => {
+    if (child.type === Group) {
+      return child.props.children;
+    }
+
+    return child;
+  });
+  const items = flatChildren.map(({
+    props
+  }) => ({
+    label: props.children,
+    value: props.value
+  }));
+  const picker = /*#__PURE__*/React.createElement(NativePicker, {
+    touchableWrapperProps: a11yProps.select(rest),
+    onOpen: onFocus,
+    onClose: onBlur,
+    disabled: inactive,
+    items: items,
+    value: value,
+    onValueChange: onChange,
+    style: {
+      inputIOS: style,
+      inputAndroid: selectAndroidInputStyles(style)
+    },
+    placeholder: placeholder !== undefined ? placeholder : {}
+  });
+  return /*#__PURE__*/React.createElement(React.Fragment, null, Platform.OS === 'android' ? /*#__PURE__*/React.createElement(View, {
+    style: selectAndroidContainerStyles(style)
+  }, picker) : picker);
+};
+
+export default Picker;
+Picker.propTypes = {
+  value: PropTypes.string,
+  onChange: PropTypes.func,
+  onFocus: PropTypes.func,
+  onBlur: PropTypes.func,
+  style: PropTypes.object,
+  inactive: PropTypes.bool,
+  children: componentPropType(['Item', 'Group']),
+  placeholder: PropTypes.shape({
+    value: PropTypes.string,
+    label: PropTypes.string
+  })
+};

package/lib/Select/Picker.web.js

@@ -0,0 +1,63 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { componentPropType } from '../utils';
+
+const Picker = ({
+  value,
+  onChange,
+  onFocus,
+  onBlur,
+  onMouseOver,
+  onMouseOut,
+  style,
+  inactive,
+  children,
+  placeholder,
+  nativeID,
+  testID,
+  ...rest
+}) => {
+  const {
+    accessibilityLabel,
+    accessibilityDescribedBy,
+    accessibilityInvalid
+  } = rest;
+  return /*#__PURE__*/React.createElement("select", {
+    style: style,
+    onMouseOver: onMouseOver,
+    onMouseOut: onMouseOut,
+    onFocus: onFocus,
+    onBlur: onBlur,
+    disabled: inactive,
+    value: value || (placeholder !== undefined ? placeholder.value : undefined),
+    onChange: event => onChange(event.target.value),
+    id: nativeID,
+    "aria-label": accessibilityLabel,
+    "aria-describedby": accessibilityDescribedBy,
+    "aria-invalid": accessibilityInvalid,
+    "data-testid": testID
+  }, placeholder !== undefined && /*#__PURE__*/React.createElement("option", {
+    value: placeholder.value,
+    disabled: true,
+    hidden: true
+  }, placeholder.label), children);
+};
+
+export default Picker;
+Picker.propTypes = {
+  value: PropTypes.string,
+  onChange: PropTypes.func,
+  onFocus: PropTypes.func,
+  onBlur: PropTypes.func,
+  onMouseOver: PropTypes.func,
+  onMouseOut: PropTypes.func,
+  style: PropTypes.object,
+  inactive: PropTypes.bool,
+  children: componentPropType(['Item', 'Group']),
+  placeholder: PropTypes.shape({
+    value: PropTypes.string,
+    label: PropTypes.string
+  }),
+  nativeID: PropTypes.string,
+  testID: PropTypes.string
+};