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

package/src/Pagination/SideButton.jsx

@@ -1,36 +1,30 @@
 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
-  })
-
-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)
+import useCopy from '../utils/useCopy'
 
+const selectIconTokens = ({ color, iconSize, 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, href, copy, variant, tokens, ...props }) {
   const viewport = useViewport()
   const buttonVariant = { direction, viewport, ...variant }
@@ -38,11 +32,10 @@ function SideButton({ direction = 'previous', onPress, href, copy, variant, toke
 
   const getCopy = useCopy({ dictionary, copy })
 
-  const { icon: IconComponent } = getTokens(tokens, buttonVariant)
+  const { 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'
@@ -63,17 +56,19 @@ function SideButton({ direction = 'previous', onPress, href, copy, variant, toke
 
   return (
     <ButtonBase {...buttonProps} tokens={getButtonTokens}>
-      {(buttonState) => (
-        <View style={staticStyles.contentContainer}>
-          {direction === 'previous' && IconComponent && (
-            <IconComponent tokens={getIconTokens(buttonState)} />
-          )}
-          {showLabel && <Text style={getTextStyles(buttonState)}>{label}</Text>}
-          {direction === 'next' && IconComponent && (
-            <IconComponent tokens={getIconTokens(buttonState)} />
-          )}
-        </View>
-      )}
+      {({ textStyles, ...buttonState }) => {
+        const iconProps = { tokens: getIconTokens(buttonState) }
+        return (
+          <IconText
+            icon={icon}
+            space={1}
+            iconPosition={directionToSide[direction]}
+            iconProps={iconProps}
+          >
+            {showLabel && <Text style={textStyles}>{label}</Text>}
+          </IconText>
+        )
+      }}
     </ButtonBase>
   )
 }
@@ -85,9 +80,3 @@ SideButton.propTypes = {
 }
 
 export default SideButton
-
-const staticStyles = StyleSheet.create({
-  contentContainer: {
-    flexDirection: 'row'
-  }
-})

package/src/Radio/Radio.jsx

@@ -0,0 +1,270 @@
+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 (
+    <Pressable
+      disabled={inactive}
+      onPress={handleChange}
+      accessibilityRole="radio"
+      accessibilityState={{ checked: isChecked, disabled: inactive }}
+      {...accessibilityProps}
+    >
+      {({ focused: focus, hovered: hover, pressed }) => {
+        const stateTokens = getTokens({ focus, hover, pressed })
+
+        return (
+          <StackView space={0}>
+            <View style={[staticStyles.container, selectContainerStyles(stateTokens)]}>
+              <View
+                style={StyleSheet.flatten([
+                  staticStyles.defaultInputStyles,
+                  selectInputStyles(stateTokens, isChecked)
+                ])}
+                testID="Radio-Input"
+              >
+                {/* Add a real input on Web, skip on native platforms */}
+                <RadioInput
+                  checked={isChecked}
+                  defaultChecked={defaultChecked}
+                  disabled={inactive}
+                  id={inputId}
+                  isControlled={isControlled}
+                  name={name}
+                  value={value}
+                />
+                {isChecked && (
+                  <View style={selectCheckedStyles(stateTokens)} testID="Radio-Checked" />
+                )}
+              </View>
+              {Boolean(label) && (
+                <Text style={selectLabelStyles(stateTokens)}>
+                  <RadioLabel forId={inputId}>{label}</RadioLabel>
+                </Text>
+              )}
+            </View>
+            {Boolean(description) && (
+              <Text style={selectDescriptionStyles(getTokens())}>{description}</Text>
+            )}
+          </StackView>
+        )
+      }}
+    </Pressable>
+  )
+}
+
+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/src/Radio/RadioInput.native.jsx

@@ -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/src/Radio/RadioInput.web.jsx

@@ -0,0 +1,57 @@
+import React, { forwardRef } from 'react'
+import PropTypes from 'prop-types'
+
+/**
+ * On Web we need to include an actual input but hide it.
+ */
+const RadioInput = 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 (
+      <input
+        checked={isControlled ? checked : undefined}
+        defaultChecked={isControlled ? undefined : defaultChecked}
+        disabled={disabled}
+        hidden
+        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/src/Radio/index.js

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

package/src/Select/Group.native.jsx

@@ -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/src/Select/Group.web.jsx

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

package/src/Select/Item.native.jsx

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

package/src/Select/Item.web.jsx

@@ -0,0 +1,11 @@
+import React from 'react'
+import PropTypes from 'prop-types'
+
+const Item = ({ children, value }) => <option value={value}>{children}</option>
+
+export default Item
+
+Item.propTypes = {
+  children: PropTypes.string.isRequired,
+  value: PropTypes.string.isRequired
+}

package/src/Select/Picker.native.jsx

@@ -0,0 +1,95 @@
+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 = (
+    <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 (
+    <>
+      {Platform.OS === 'android' ? (
+        <View style={selectAndroidContainerStyles(style)}>{picker}</View>
+      ) : (
+        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/src/Select/Picker.web.jsx

@@ -0,0 +1,67 @@
+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 (
+    <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 && (
+        <option value={placeholder.value} disabled hidden>
+          {placeholder.label}
+        </option>
+      )}
+      {children}
+    </select>
+  )
+}
+
+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
+}