@telus-uds/components-base 1.8.2 → 1.8.5

package/lib-module/Radio/Radio.js

@@ -0,0 +1,285 @@
+import React, { forwardRef } from 'react';
+import PropTypes from 'prop-types';
+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 RadioLabel from '../InputLabel/LabelContent';
+import RadioButton, { selectRadioButtonTokens } from './RadioButton';
+import { applyShadowToken, applyTextStyles, useThemeTokensCallback } from '../ThemeProvider';
+import { a11yProps, focusHandlerProps, getTokensPropType, selectSystemProps, useInputValue, useUniqueId, variantProp, viewProps } from '../utils';
+import StackView from '../StackView';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+const [selectProps, selectedSystemPropTypes] = selectSystemProps([a11yProps, focusHandlerProps, viewProps]);
+
+const selectContainerStyles = _ref => {
+  let {
+    containerBackgroundColor,
+    containerBorderRadius,
+    containerOpacity,
+    containerPaddingBottom,
+    containerPaddingLeft,
+    containerPaddingRight,
+    containerPaddingTop,
+    containerShadow
+  } = _ref;
+  return {
+    backgroundColor: containerBackgroundColor,
+    borderRadius: containerBorderRadius,
+    opacity: containerOpacity,
+    paddingBottom: containerPaddingBottom,
+    paddingLeft: containerPaddingLeft,
+    paddingRight: containerPaddingRight,
+    paddingTop: containerPaddingTop,
+    ...applyShadowToken(containerShadow)
+  };
+};
+
+const selectDescriptionStyles = _ref2 => {
+  let {
+    containerPaddingLeft = 0,
+    descriptionFontSize,
+    descriptionLineHeight,
+    descriptionMarginLeft,
+    inputSize,
+    labelMarginLeft = 0
+  } = _ref2;
+  return {
+    marginLeft: descriptionMarginLeft !== null && descriptionMarginLeft !== void 0 ? descriptionMarginLeft : containerPaddingLeft + inputSize + labelMarginLeft,
+    ...applyTextStyles({
+      fontSize: descriptionFontSize,
+      lineHeight: descriptionLineHeight
+    })
+  };
+};
+
+const selectLabelStyles = _ref3 => {
+  let {
+    labelColor,
+    labelFontName,
+    labelFontSize,
+    labelFontWeight,
+    labelMarginLeft,
+    labelLineHeight
+  } = _ref3;
+  return 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 = /*#__PURE__*/forwardRef((_ref4, ref) => {
+  let {
+    checked,
+    defaultChecked,
+    description,
+    error = false,
+    id,
+    inactive,
+    label,
+    name: inputName,
+    onChange,
+    tokens,
+    value,
+    variant,
+    ...rest
+  } = _ref4;
+  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 === null || event === void 0 ? void 0 : event.key) === ' ') handleChange(event);
+  };
+
+  const uniqueId = useUniqueId('radio');
+  const inputId = id !== null && id !== void 0 ? id : uniqueId;
+  return /*#__PURE__*/_jsx(Pressable, {
+    ref: ref,
+    disabled: inactive,
+    onKeyDown: handleKeyDown,
+    onPress: handleChange,
+    accessibilityRole: "radio",
+    accessibilityState: {
+      checked: isChecked,
+      disabled: inactive
+    },
+    ...selectProps(rest),
+    children: _ref5 => {
+      let {
+        focused: focus,
+        hovered: hover,
+        pressed
+      } = _ref5;
+      const stateTokens = getTokens({
+        focus,
+        hover,
+        pressed
+      });
+      const labelStyles = selectLabelStyles(stateTokens);
+      const alignWithLabel = label ? [staticStyles.alignWithLabel, {
+        height: labelStyles.lineHeight
+      }] : null;
+      return /*#__PURE__*/_jsxs(StackView, {
+        space: 0,
+        children: [/*#__PURE__*/_jsxs(View, {
+          style: [staticStyles.container, selectContainerStyles(stateTokens)],
+          children: [/*#__PURE__*/_jsx(View, {
+            style: alignWithLabel,
+            children: /*#__PURE__*/_jsx(RadioButton, {
+              tokens: selectRadioButtonTokens(stateTokens),
+              isControlled: isControlled,
+              isChecked: isChecked,
+              inactive: inactive,
+              defaultChecked: defaultChecked,
+              inputId: inputId,
+              handleChange: handleChange,
+              name: inputName,
+              value: value
+            })
+          }), Boolean(label) && /*#__PURE__*/_jsx(Text, {
+            style: labelStyles,
+            children: /*#__PURE__*/_jsx(RadioLabel, {
+              forId: inputId,
+              children: label
+            })
+          })]
+        }), Boolean(description) && /*#__PURE__*/_jsx(Text, {
+          style: selectDescriptionStyles(getTokens()),
+          children: description
+        })]
+      });
+    }
+  });
+});
+Radio.displayName = 'Radio';
+Radio.propTypes = { ...selectedSystemPropTypes,
+
+  /**
+   * 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'
+  },
+  alignWithLabel: {
+    alignSelf: 'flex-start',
+    justifyContent: 'center'
+  }
+});

package/lib-module/Radio/RadioButton.js

@@ -0,0 +1,138 @@
+import React, { forwardRef } from 'react';
+import PropTypes from 'prop-types';
+import Platform from "react-native-web/dist/exports/Platform";
+import StyleSheet from "react-native-web/dist/exports/StyleSheet";
+import View from "react-native-web/dist/exports/View";
+import RadioInput from './RadioInput';
+import { applyOuterBorder, resolveThemeTokens, validateThemeTokens } from '../ThemeProvider';
+import { a11yProps, getTokensSetPropType, selectSystemProps, selectTokens, viewProps } from '../utils';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+const [selectProps, selectedSystemPropTypes] = selectSystemProps([a11yProps, viewProps]); // 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 = _ref => {
+  let {
+    checkedBackgroundColor,
+    checkedSize
+  } = _ref;
+  return {
+    backgroundColor: checkedBackgroundColor,
+    borderRadius: checkedSize / 2,
+    height: checkedSize,
+    width: checkedSize
+  };
+};
+
+const selectInputStyles = _ref2 => {
+  let {
+    inputBackgroundColor,
+    inputBorderColor,
+    inputBorderWidth,
+    inputOutlineColor,
+    inputOutlineWidth,
+    inputSize
+  } = _ref2;
+  return {
+    borderColor: inputBorderColor,
+    borderRadius: getBorderRadius(inputSize),
+    borderWidth: inputBorderWidth,
+    backgroundColor: inputBackgroundColor,
+    height: inputSize,
+    width: inputSize,
+    ...Platform.select({
+      web: {
+        outlineStyle: 'solid',
+        outlineColor: inputOutlineColor,
+        outlineWidth: inputOutlineWidth
+      }
+    })
+  };
+};
+
+const selectOuterBorderStyles = _ref3 => {
+  let {
+    outerBorderColor,
+    outerBorderWidth,
+    outerBorderGap,
+    inputSize
+  } = _ref3;
+  return { ...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 = /*#__PURE__*/forwardRef((_ref4, ref) => {
+  let {
+    isChecked,
+    tokens,
+    inactive,
+    defaultChecked,
+    inputId,
+    isControlled,
+    handleChange,
+    name: inputName,
+    value,
+    ...rest
+  } = _ref4;
+  const themeTokens = validateThemeTokens(resolveThemeTokens(tokens, {
+    checked: isChecked
+  }), getTokensSetPropType(tokenKeys), 'RadioButton');
+  return /*#__PURE__*/_jsx(View, {
+    style: selectOuterBorderStyles(themeTokens),
+    ...selectProps(rest),
+    children: /*#__PURE__*/_jsxs(View, {
+      style: [staticStyles.defaultInputStyles, selectInputStyles(themeTokens, isChecked)],
+      testID: "Radio-Input",
+      children: [/*#__PURE__*/_jsx(RadioInput, {
+        ref: ref,
+        checked: isChecked,
+        defaultChecked: defaultChecked,
+        disabled: inactive,
+        id: inputId,
+        isControlled: isControlled,
+        onChange: handleChange,
+        name: inputName,
+        value: value
+      }), isChecked && /*#__PURE__*/_jsx(View, {
+        style: selectCheckedStyles(themeTokens),
+        testID: "Radio-Checked"
+      })]
+    })
+  });
+});
+RadioButton.displayName = 'RadioButton';
+RadioButton.propTypes = { ...selectedSystemPropTypes,
+  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/lib-module/Radio/RadioGroup.js

@@ -0,0 +1,243 @@
+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 { a11yProps, containUniqueFields, focusHandlerProps, getTokensPropType, selectSystemProps, useInputValue, variantProp, viewProps } from '../utils';
+import { getStackedContent } from '../StackView';
+import Radio from './Radio';
+import Fieldset from '../Fieldset';
+import { jsx as _jsx } from "react/jsx-runtime";
+const [selectProps, selectedSystemPropTypes] = selectSystemProps([a11yProps, viewProps]);
+const [selectItemProps, selectedItemPropTypes] = selectSystemProps([a11yProps, focusHandlerProps, viewProps]);
+/**
+ * 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 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 = /*#__PURE__*/forwardRef((_ref, ref) => {
+  let {
+    copy = 'en',
+    tokens,
+    radioTokens,
+    variant,
+    items = [],
+    legend,
+    tooltip,
+    hint,
+    validation,
+    feedback,
+    initialCheckedId,
+    checkedId,
+    onChange,
+    readOnly,
+    name: inputGroupName,
+    inactive,
+    ...rest
+  } = _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 uniqueFields = ['id', 'label'];
+
+  if (!containUniqueFields(items, uniqueFields)) {
+    throw new Error("RadioGroup items must have unique ".concat(uniqueFields.join(', ')));
+  }
+
+  const radios = items.map((_ref2, index) => {
+    let {
+      label,
+      id,
+      onChange: itemOnChange,
+      ref: itemRef,
+      ...itemRest
+    } = _ref2;
+    const radioId = id || "Radio[".concat(index, "]");
+    const isChecked = currentValue === radioId;
+
+    const handleChange = (newCheckedState, event) => {
+      if (typeof itemOnChange === 'function') itemOnChange(newCheckedState, event);
+      if (newCheckedState) setValue(radioId, event);
+    };
+
+    return /*#__PURE__*/_jsx(Radio, {
+      ref: itemRef,
+      id: radioId,
+      checked: isChecked,
+      onChange: handleChange,
+      inactive: inactive,
+      label: label,
+      name: inputGroupName,
+      tokens: radioTokens,
+      variant: variant,
+      ...selectItemProps(itemRest)
+    }, radioId);
+  });
+  return /*#__PURE__*/_jsx(Fieldset, {
+    copy: copy,
+    ref: ref,
+    name: inputGroupName,
+    legend: legend,
+    tooltip: tooltip,
+    hint: hint,
+    space: fieldSpace,
+    feedback: feedback,
+    inactive: inactive,
+    validation: validation,
+    accessibilityRole: "radiogroup",
+    ...selectProps(rest),
+    children: getStackedContent(radios, {
+      space,
+      direction: 'column'
+    })
+  });
+});
+RadioGroup.displayName = 'RadioGroup';
+RadioGroup.propTypes = { ...selectedSystemPropTypes,
+
+  /**
+   * Whether the English or French copy will be used (e.g. for accessibility labels).
+   */
+  copy: PropTypes.oneOf(['en', 'fr']),
+
+  /**
+   * 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({ ...selectedItemPropTypes,
+    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 with this id is selected on first render.
+   */
+  initialCheckedId: PropTypes.string,
+
+  /**
+   * If not undefined, the radio 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 radios cannot be selected by the user and simply show their current state.
+   */
+  readOnly: PropTypes.bool,
+
+  /**
+   * If true, the radios 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;