@telus-uds/components-base 0.0.2-prerelease.6 → 1.0.0

package/src/Progress/ProgressBarBackground.jsx

@@ -0,0 +1,36 @@
+import React, { forwardRef } from 'react'
+import { ImageBackground, StyleSheet } from 'react-native'
+
+import { variantProp } from '../utils'
+
+const inactiveBackground = `%3Csvg xmlns='http://www.w3.org/2000/svg' width='100%25' height='24'%3E%3Cdefs%3E%3Cpattern id='DisabledProgress7' patternUnits='userSpaceOnUse' width='8' height='8'%3E%3Crect width='8' height='8' fill='%23B2B9BF'%3E%3C/rect%3E%3Ccircle cx='4' cy='4' r='2' fill='%23676E73' stroke='%23676E73' stroke-width='0'%3E%3C/circle%3E%3Ccircle cx='0' cy='0' r='2' fill='%23676E73' stroke='%23676E73' stroke-width='0'%3E%3C/circle%3E%3Ccircle cx='0' cy='8' r='2' fill='%23676E73' stroke='%23676E73' stroke-width='0'%3E%3C/circle%3E%3Ccircle cx='8' cy='0' r='2' fill='%23676E73' stroke='%23676E73' stroke-width='0'%3E%3C/circle%3E%3Ccircle cx='8' cy='8' r='2' fill='%23676E73' stroke='%23676E73' stroke-width='0'%3E%3C/circle%3E%3C/pattern%3E%3C/defs%3E%3Cpath d='M 0 0 L 0 140 L 2000 2000 L 2000 0 Z' style='fill: url("%23DisabledProgress7");'%3E%3C/path%3E%3C/svg%3E`
+const negativeBackground = `%3Csvg xmlns='http://www.w3.org/2000/svg' width='100%25' height='24'%3E%3Cdefs%3E%3Cpattern id='NegativeProgress6' patternUnits='userSpaceOnUse' width='8' height='8'%3E%3Crect width='8' height='8' fill='%23C12335'%3E%3C/rect%3E%3Cpath d='M 0,8 l 8,-8 M -2,2 l 4,-4 M 6,10 l 4,-4' stroke-width='2' shape-rendering='auto' stroke='%23e7adb4' stroke-linecap='square'%3E%3C/path%3E%3C/pattern%3E%3C/defs%3E%3Cpath d='M 0 0 L 0 140 L 2000 2000 L 2000 0 Z' style='fill: url("%23NegativeProgress6");'%3E%3C/path%3E%3C/svg%3E`
+const ProgressBarBackground = forwardRef(({ variant }, ref) => {
+  let source = null
+  if (variant?.inactive) {
+    source = inactiveBackground
+  } else if (variant?.negative) {
+    source = negativeBackground
+  } else {
+    return null
+  }
+  return (
+    <ImageBackground
+      ref={ref}
+      source={{ uri: `data:image/svg+xml,${source}` }}
+      style={staticStyles.imageBackground}
+    />
+  )
+})
+ProgressBarBackground.displayName = 'ProgressBarBackground'
+
+ProgressBarBackground.propTypes = {
+  /**
+   * Progress bar variant.
+   */
+  variant: variantProp.propType
+}
+
+export default ProgressBarBackground
+
+const staticStyles = StyleSheet.create({ imageBackground: { height: '100%' } })

package/src/Progress/index.js

@@ -0,0 +1,6 @@
+import Progress from './Progress'
+import ProgressBar from './ProgressBar'
+
+Progress.Bar = ProgressBar
+
+export default Progress

package/src/Radio/Radio.jsx

@@ -0,0 +1,240 @@
+import React, { forwardRef } from 'react'
+import PropTypes from 'prop-types'
+import { Pressable, StyleSheet, Text, View } from 'react-native'
+
+// @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 RadioButton, { selectRadioButtonTokens } from './RadioButton'
+import { applyShadowToken, applyTextStyles, useThemeTokensCallback } from '../ThemeProvider'
+import { getTokensPropType, useInputValue, useUniqueId, variantProp } from '../utils'
+import { a11yProps } from '../utils/propTypes'
+import StackView from '../StackView'
+
+const selectContainerStyles = ({
+  containerBackgroundColor,
+  containerBorderRadius,
+  containerOpacity,
+  containerPaddingBottom,
+  containerPaddingLeft,
+  containerPaddingRight,
+  containerPaddingTop,
+  containerShadow
+}) => ({
+  backgroundColor: containerBackgroundColor,
+  borderRadius: containerBorderRadius,
+  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 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 = forwardRef(
+  (
+    {
+      checked,
+      defaultChecked,
+      description,
+      error = false,
+      id,
+      inactive,
+      label,
+      name: inputName,
+      onChange,
+      tokens,
+      value,
+      variant,
+      ...rest
+    },
+    ref
+  ) => {
+    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 = (event) => {
+      if (!inactive && !isChecked) {
+        setIsChecked(true, event)
+      }
+    }
+    const handleKeyDown = (event) => {
+      // The expected keyboard shortcut for activating a radio is the Space key
+      if (event?.key === ' ') handleChange(event)
+    }
+    const accessibilityProps = a11yProps.select(rest)
+    const uniqueId = useUniqueId('radio')
+    const inputId = id ?? uniqueId
+
+    return (
+      <Pressable
+        ref={ref}
+        disabled={inactive}
+        onKeyDown={handleKeyDown}
+        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)]}>
+                <RadioButton
+                  tokens={selectRadioButtonTokens(stateTokens)}
+                  isControlled={isControlled}
+                  isChecked={isChecked}
+                  inactive={inactive}
+                  defaultChecked={defaultChecked}
+                  inputId={inputId}
+                  handleChange={handleChange}
+                  name={inputName}
+                  value={value}
+                />
+                {Boolean(label) && (
+                  <Text style={selectLabelStyles(stateTokens)}>
+                    <RadioLabel forId={inputId}>{label}</RadioLabel>
+                  </Text>
+                )}
+              </View>
+              {Boolean(description) && (
+                <Text style={selectDescriptionStyles(getTokens())}>{description}</Text>
+              )}
+            </StackView>
+          )
+        }}
+      </Pressable>
+    )
+  }
+)
+Radio.displayName = 'Radio'
+
+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' }
+})

package/src/Radio/RadioButton.jsx

@@ -0,0 +1,142 @@
+import React, { forwardRef } from 'react'
+import PropTypes from 'prop-types'
+import { Platform, StyleSheet, View } from 'react-native'
+
+import RadioInput from './RadioInput'
+import { applyOuterBorder, resolveThemeTokens, validateThemeTokens } from '../ThemeProvider'
+import { getTokensSetPropType, selectTokens } from '../utils'
+
+// TODO: roll out a standard approach to token sets
+// https://github.com/telus/universal-design-system/issues/782
+const tokenKeys = [
+  'checkedBackgroundColor',
+  'checkedSize',
+  'inputBackgroundColor',
+  'inputBorderColor',
+  'inputBorderWidth',
+  'inputOutlineColor',
+  'inputOutlineWidth',
+  'inputSize',
+  'outerBorderColor',
+  'outerBorderWidth',
+  'outerBorderGap',
+  'inputSize'
+]
+
+export const selectRadioButtonTokens = (themeTokens, prefix) =>
+  selectTokens(tokenKeys, themeTokens, prefix)
+
+const getBorderRadius = (inputSize) => inputSize / 2
+
+const selectCheckedStyles = ({ checkedBackgroundColor, checkedSize }) => ({
+  backgroundColor: checkedBackgroundColor,
+  borderRadius: checkedSize / 2,
+  height: checkedSize,
+  width: checkedSize
+})
+
+const selectInputStyles = ({
+  inputBackgroundColor,
+  inputBorderColor,
+  inputBorderWidth,
+  inputOutlineColor,
+  inputOutlineWidth,
+  inputSize
+}) => ({
+  borderColor: inputBorderColor,
+  borderRadius: getBorderRadius(inputSize),
+  borderWidth: inputBorderWidth,
+  backgroundColor: inputBackgroundColor,
+  height: inputSize,
+  width: inputSize,
+  ...Platform.select({
+    web: {
+      outlineStyle: 'solid',
+      outlineColor: inputOutlineColor,
+      outlineWidth: inputOutlineWidth
+    }
+  })
+})
+
+const selectOuterBorderStyles = ({
+  outerBorderColor,
+  outerBorderWidth,
+  outerBorderGap,
+  inputSize
+}) => ({
+  ...applyOuterBorder({
+    outerBorderColor,
+    outerBorderWidth,
+    outerBorderGap,
+    borderRadius: getBorderRadius(inputSize)
+  })
+})
+
+/**
+ * The visual toggle of a radio input. Is not interactive on its own, should be used inside
+ * an interactive parent that passes down props when interacted with.
+ */
+const RadioButton = forwardRef(
+  (
+    {
+      isChecked,
+      tokens,
+      inactive,
+      defaultChecked,
+      inputId,
+      isControlled,
+      handleChange,
+      name: inputName,
+      value
+    },
+    ref
+  ) => {
+    const themeTokens = validateThemeTokens(
+      resolveThemeTokens(tokens, { checked: isChecked }),
+      getTokensSetPropType(tokenKeys),
+      'RadioButton'
+    )
+
+    return (
+      <View style={selectOuterBorderStyles(themeTokens)}>
+        <View
+          style={[staticStyles.defaultInputStyles, selectInputStyles(themeTokens, isChecked)]}
+          testID="Radio-Input"
+        >
+          {/* Add a real input on Web, skip on native platforms */}
+          <RadioInput
+            ref={ref}
+            checked={isChecked}
+            defaultChecked={defaultChecked}
+            disabled={inactive}
+            id={inputId}
+            isControlled={isControlled}
+            onChange={handleChange}
+            name={inputName}
+            value={value}
+          />
+          {isChecked && <View style={selectCheckedStyles(themeTokens)} testID="Radio-Checked" />}
+        </View>
+      </View>
+    )
+  }
+)
+RadioButton.displayName = 'RadioButton'
+
+RadioButton.propTypes = {
+  isChecked: PropTypes.bool,
+  tokens: getTokensSetPropType(tokenKeys, { allowFunction: true }),
+  inactive: PropTypes.bool,
+  defaultChecked: PropTypes.bool,
+  inputId: PropTypes.string,
+  isControlled: PropTypes.bool,
+  handleChange: PropTypes.func,
+  name: PropTypes.string,
+  value: PropTypes.bool
+}
+
+const staticStyles = StyleSheet.create({
+  defaultInputStyles: { alignItems: 'center', justifyContent: 'center' }
+})
+
+export default RadioButton

package/src/Radio/RadioGroup.jsx

@@ -0,0 +1,209 @@
+import React, { forwardRef } from 'react'
+import PropTypes from 'prop-types'
+import ABBPropTypes from 'airbnb-prop-types'
+
+import { useViewport } from '../ViewportProvider'
+import { useThemeTokens } from '../ThemeProvider'
+import { getTokensPropType, useInputValue, variantProp } from '../utils'
+import { getStackedContent } from '../StackView'
+import Radio from './Radio'
+import Fieldset from '../Fieldset'
+
+/**
+ * A group of Radios that behave as a radio group. Use when users select a single choice from mutually
+ * exclusive options.
+ *
+ * ## Component API
+ *
+ * Use the `items` prop to pass an array of objects describing each Radio in the group:
+ *
+ *  - `label`: main text passed to Radio's `label` prop
+ *  - `id`: identifier used to store which Radio is selected (uses `label` if undefinded)
+ *  - `onChange`: optional function called on selection, in addition to updating the group's selection state
+ *
+ * ### Controlled version
+ *
+ * If the selection state is controlled from outside, it needs to receive `checkedId` and `onChange` props.
+ *
+ * ### Uncontrolled version
+ *
+ * If the RadioGroup manages its own state, you can use `initialCheckedId` prop to provide the initial value.
+ * Whenever the radio card gets toggled, it calls the `onChange` callback with the new value (string).
+ *
+ * ### Use in forms
+ *
+ * For web forms, the `name` prop may be used to define the name of the group's `fieldset` and input elements.
+ *
+ * ### Validation
+ *
+ * Validation state may be set by passing 'error' or 'success' to the `validation` prop.
+ *
+ * ## A11y guidelines
+ *
+ * RadioGroup accepts all the common accessibility props, but also sets accessibility role `'radiogroup'`
+ * and controls the accessibility state of children like Radio and Feedback based on current state.
+ *
+ * @example
+ * ```jsx
+ * <RadioGroup
+ *   initialCheckedId="radio1"
+ *   items={[
+ *     { label: 'Radio 1', id: 'radio1' },
+ *     { label: 'Radio 2', id: 'radio2' },
+ *     { label: 'Radio 3', id: 'radio3' }
+ *   ]}
+ *   legend="Radios"
+ *   hint="Choose one option"
+ * />
+ * ```
+ */
+const RadioGroup = forwardRef(
+  (
+    {
+      tokens,
+      radioTokens,
+      variant,
+      items = [],
+      legend,
+      tooltip,
+      hint,
+      validation,
+      feedback,
+      initialCheckedId,
+      checkedId,
+      onChange,
+      readOnly,
+      name: inputGroupName,
+      inactive
+    },
+    ref
+  ) => {
+    const viewport = useViewport()
+
+    const { space, fieldSpace } = useThemeTokens('RadioGroup', tokens, variant, {
+      viewport
+    })
+
+    const { currentValue, setValue } = useInputValue({
+      value: checkedId,
+      initialValue: initialCheckedId,
+      onChange,
+      readOnly: readOnly || inactive
+    })
+    const radios = items.map(({ label, id, onChange: itemOnChange, ref: itemRef }, index) => {
+      const radioId = id || `Radio[${index}]`
+      const isChecked = currentValue === radioId
+      const handleChange = (newCheckedState, event) => {
+        if (typeof itemOnChange === 'function') itemOnChange(newCheckedState, event)
+        if (newCheckedState) setValue(radioId, event)
+      }
+      return (
+        <Radio
+          ref={itemRef}
+          key={radioId}
+          id={radioId}
+          checked={isChecked}
+          onChange={handleChange}
+          inactive={inactive}
+          label={label}
+          name={inputGroupName}
+          tokens={radioTokens}
+          variant={variant}
+        />
+      )
+    })
+
+    return (
+      <Fieldset
+        ref={ref}
+        name={inputGroupName}
+        legend={legend}
+        tooltip={tooltip}
+        hint={hint}
+        space={fieldSpace}
+        feedback={feedback}
+        inactive={inactive}
+        validation={validation}
+        accessibilityRole="radiogroup"
+      >
+        {getStackedContent(radios, { space, direction: 'column' })}
+      </Fieldset>
+    )
+  }
+)
+RadioGroup.displayName = 'RadioGroup'
+
+RadioGroup.propTypes = {
+  /**
+   * Optional theme token overrides for the outer RadioGroup component
+   */
+  tokens: getTokensPropType('RadioGroup'),
+  /**
+   * Optional theme token overrides for each inner Radio component
+   */
+  radioTokens: getTokensPropType('Radio'),
+  /**
+   * Theme variants, shared between both RadioGroup and Radio
+   */
+  variant: variantProp.propType,
+  /**
+   * Array of objects containing specifics for each Radio to be rendered in the group.
+   */
+  items: PropTypes.arrayOf(
+    PropTypes.exact({
+      label: PropTypes.string,
+      id: PropTypes.string,
+      onChange: PropTypes.func,
+      ref: ABBPropTypes.ref()
+    })
+  ),
+  /**
+   * Main text used to describe this group, used in Fieldset's Legend element.
+   */
+  legend: PropTypes.string,
+  /**
+   * Optional additional text giving more detail to help a user make a choice.
+   */
+  hint: PropTypes.string,
+  /**
+   * Optional tooltip text content to include alongside the legend and hint.
+   */
+  tooltip: PropTypes.string,
+  /**
+   * Current validation status of the group, passed to the feedback element if there is one.
+   */
+  validation: PropTypes.oneOf(['error', 'success']),
+  /**
+   * If provided, a Feedback element is rendered containing this text.
+   */
+  feedback: PropTypes.string,
+  /**
+   * If provided, the radio card with this id is selected on first render.
+   */
+  initialCheckedId: PropTypes.string,
+  /**
+   * If not undefined, the radio card with this id is selected (or none is selected if `null`), and the
+   * element's selection state will be controlled by its parent using the `onChange` function.
+   */
+  checkedId: PropTypes.string,
+  /**
+   * Function to call on change in selection state. Is required if the selection state is controlled
+   * by a parent using checkedId and the input is not readOnly.
+   */
+  onChange: PropTypes.func,
+  /**
+   * If true, the radio cards cannot be selected by the user and simply show their current state.
+   */
+  readOnly: PropTypes.bool,
+  /**
+   * If true, the radio card cannot be interacted with, elements are set as `disabled` and if the
+   * theme supports `inactive` appearances rules, these are applied.
+   */
+  inactive: PropTypes.bool,
+  /**
+   * On Web, this is passed to the `name` attribute of the fieldset and each radio input.
+   */
+  name: PropTypes.string
+}
+
+export default RadioGroup

package/src/Radio/RadioInput.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/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/index.js

@@ -0,0 +1,5 @@
+import Radio from './Radio'
+
+export default Radio
+
+export { default as RadioGroup } from './RadioGroup'