@telus-uds/components-base 1.8.3 → 1.9.0

package/lib-module/Radio/RadioInput.js

@@ -0,0 +1,62 @@
+import React, { forwardRef } from 'react';
+import PropTypes from 'prop-types';
+/**
+ * On Web we need to include an actual input but hide it.
+ */
+
+import { jsx as _jsx } from "react/jsx-runtime";
+const RadioInput = /*#__PURE__*/forwardRef((_ref, ref) => {
+  let {
+    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__*/_jsx("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-module/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-module/Radio/index.js

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

package/lib-module/RadioCard/RadioCard.js

@@ -0,0 +1,219 @@
+import React, { forwardRef } from 'react';
+import PropTypes from 'prop-types';
+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 { useThemeTokensCallback, applyTextStyles } from '../ThemeProvider';
+import { a11yProps, focusHandlerProps, getTokensPropType, selectSystemProps, selectTokens, useInputValue, useUniqueId, variantProp, viewProps } from '../utils';
+import { PressableCardBase, selectPressableCardTokens } from '../Card';
+import StackView from '../StackView';
+import RadioButton, { selectRadioButtonTokens } from '../Radio/RadioButton';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+const [selectProps, selectedSystemPropTypes] = selectSystemProps([a11yProps, focusHandlerProps, viewProps]);
+/**
+ * A Card that behaves like a radio button. Use when users select a single choice from mutually exclusive options
+ * with need to show additional information for each option. The whole card is interactive as one item.
+ *
+ * ## Component API
+ *
+ * Use `title` prop to provide a main description, and `children` for additional content. Avoid including
+ * interactive elements within the RadioCard content.
+ *
+ * For a disabled `RadioCard`, set the `inactive` prop to `true`.
+ *
+ * ### Controlled version
+ *
+ * If the radio card is controlled from outside, it needs to receive `checked` and `onChange` props.
+ *
+ * ### Uncontrolled version
+ *
+ * In case of uncontrolled radio card you can use `defaultChecked` prop to provide the initial value.
+ * Whenever the radio card 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 card to be a part of a radio group
+ * on a form.
+ *
+ * ### Validation
+ *
+ * You can mark a radio card as failing validation by setting the `error` prop to `true`.
+ *
+ * ## A11y guidelines
+ *
+ * Radio card 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 RadioCard = /*#__PURE__*/forwardRef((_ref, ref) => {
+  let {
+    tokens,
+    variant,
+    title,
+    children,
+    inactive,
+    defaultChecked,
+    checked,
+    name: inputName,
+    value,
+    id,
+    onChange,
+    ...rest
+  } = _ref;
+  const {
+    currentValue: isChecked,
+    setValue: setIsChecked,
+    isControlled
+  } = useInputValue({
+    value: checked,
+    initialValue: defaultChecked,
+    onChange
+  });
+
+  const handleChange = event => {
+    if (!inactive && !isChecked) {
+      setIsChecked(true, event);
+    }
+  };
+
+  const uniqueId = useUniqueId('RadioCard');
+  const inputId = id !== null && id !== void 0 ? id : uniqueId;
+  const getTokens = useThemeTokensCallback('RadioCard', tokens, variant);
+
+  const getCardTokens = cardState => selectPressableCardTokens(getTokens(cardState));
+
+  return /*#__PURE__*/_jsx(PressableCardBase, {
+    ref: ref,
+    inactive: inactive,
+    checked: isChecked,
+    tokens: getCardTokens,
+    onPress: handleChange,
+    accessibilityRole: "radio",
+    accessibilityState: {
+      checked: isChecked,
+      disabled: inactive
+    },
+    ...selectProps(rest),
+    children: cardState => {
+      const {
+        radioSpace,
+        contentSpace,
+        ...themeTokens
+      } = getTokens(cardState);
+      const radioTokens = selectRadioButtonTokens(themeTokens, 'radio');
+      const titleTokens = selectTokens('Typography', themeTokens);
+      const textStyle = applyTextStyles(titleTokens);
+      return /*#__PURE__*/_jsxs(StackView, {
+        direction: "row",
+        space: radioSpace,
+        children: [/*#__PURE__*/_jsx(View, {
+          style: [staticStyles.alignWithText, {
+            height: textStyle.lineHeight
+          }],
+          children: /*#__PURE__*/_jsx(RadioButton, {
+            tokens: radioTokens,
+            isControlled: isControlled,
+            isChecked: isChecked,
+            inactive: inactive,
+            defaultChecked: defaultChecked,
+            inputId: inputId,
+            handleChange: handleChange,
+            name: inputName,
+            value: value
+          })
+        }), /*#__PURE__*/_jsxs(StackView, {
+          direction: "column",
+          space: contentSpace,
+          tokens: {
+            flexShrink: 1
+          },
+          children: [title && /*#__PURE__*/_jsx(Text, {
+            style: textStyle,
+            children: title
+          }), typeof children === 'function' ? children(cardState, textStyle) : children]
+        })]
+      });
+    }
+  });
+});
+RadioCard.displayName = 'RadioCard';
+RadioCard.propTypes = { ...selectedSystemPropTypes,
+
+  /**
+   * Content to be displayed at the top of the card alongside the radio button
+   */
+  title: PropTypes.string,
+
+  /**
+   * Additional content to be displayed below the button.
+   */
+  children: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
+
+  /**
+   * 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 card button ID.
+   */
+  id: PropTypes.string,
+
+  /**
+   * Whether the corresponding input is disabled or active.
+   */
+  inactive: PropTypes.bool,
+
+  /**
+   * The label.
+   */
+  label: PropTypes.string,
+
+  /**
+   * Associate this radio card 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 card gets interacted with.
+   */
+  onChange: PropTypes.func,
+
+  /**
+   * Radio card tokens.
+   */
+  tokens: getTokensPropType('RadioCard'),
+
+  /**
+   * Radio variant.
+   */
+  variant: variantProp.propType
+};
+const staticStyles = StyleSheet.create({
+  alignWithText: {
+    justifyContent: 'center'
+  }
+});
+export default RadioCard;

package/lib-module/RadioCard/RadioCardGroup.js

@@ -0,0 +1,250 @@
+import React, { forwardRef } from 'react';
+import PropTypes from 'prop-types';
+import { useViewport } from '../ViewportProvider';
+import { useThemeTokens } from '../ThemeProvider';
+import { a11yProps, containUniqueFields, focusHandlerProps, getTokensPropType, selectSystemProps, useInputValue, variantProp, viewProps } from '../utils';
+import StackView, { StackWrap } from '../StackView';
+import RadioCard from './RadioCard';
+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 Cards that behave as a radio button group. Use when users select a single choice from mutually
+ * exclusive options with need to show additional information for each option. The whole cards are each
+ * interactive as one item.
+ *
+ * ## Component API
+ *
+ * Use the `items` prop to pass an array of objects describing each RadioCard in the group:
+ *
+ *  - `title`: main text passed to RadioCard's `title` prop
+ *  - `content`: React content passed to RadioCard's `children` prop
+ *  - `id`: identifier used to store which RadioCard is selected (uses `title` 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 RadioCardGroup 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
+ *
+ * RadioCardGroup accepts all the common accessibility props, but also sets accessibility role `'radiogroup'`
+ * and controls the accessibility state of children like RadioCard and Feedback based on current state.
+ *
+ * @example
+ * ```jsx
+ * <RadioCardGroup
+ *   initialCheckedId="card1"
+ *   items={[
+ *     { title: 'Card 1', id: 'card1', content: <Typography>More info</Typography> },
+ *     { title: 'Card 2', id: 'card2', content: <Typography>Extra content</Typography> },
+ *     { title: 'Card 3', id: 'card3', content: <Typography>More content</Typography> }
+ *   ]}
+ *   legend="Cards"
+ *   hint="Choose a card to select"
+ * />
+ * ```
+ */
+
+const RadioCardGroup = /*#__PURE__*/forwardRef((_ref, ref) => {
+  let {
+    copy = 'en',
+    tokens,
+    radioCardTokens,
+    variant,
+    items = [],
+    legend,
+    tooltip,
+    hint,
+    validation,
+    feedback,
+    initialCheckedId,
+    checkedId,
+    onChange,
+    readOnly,
+    name: inputGroupName,
+    inactive,
+    ...rest
+  } = _ref;
+  const viewport = useViewport();
+  const {
+    space,
+    fieldSpace,
+    direction
+  } = useThemeTokens('RadioCardGroup', tokens, variant, {
+    viewport
+  });
+  const {
+    currentValue,
+    setValue
+  } = useInputValue({
+    value: checkedId,
+    initialValue: initialCheckedId,
+    onChange,
+    readOnly: readOnly || inactive
+  });
+  const StackContainer = direction === 'row' ? StackWrap : StackView; // Needs 'radiogroup' role on direct parent of radios for MacOS Voiceover's numbering to work,
+  // and also needs 'radiogroup' role on fieldset for correct description on focusing the set.
+  // TODO: test this on more web screen readers.
+
+  const uniqueFields = ['id'];
+
+  if (!containUniqueFields(items, uniqueFields)) {
+    throw new Error("RadioCardGroup items must have unique ".concat(uniqueFields.join(', ')));
+  }
+
+  return /*#__PURE__*/_jsx(Fieldset, {
+    copy: copy,
+    ref: ref,
+    name: inputGroupName,
+    legend: legend,
+    tooltip: tooltip,
+    hint: hint,
+    space: fieldSpace,
+    feedback: feedback,
+    inactive: inactive || readOnly,
+    validation: validation,
+    accessibilityRole: "radiogroup",
+    ...selectProps(rest),
+    children: props => /*#__PURE__*/_jsx(StackContainer, {
+      space: space,
+      accessibilityRole: "radiogroup",
+      children: items.map((_ref2, index) => {
+        let {
+          title,
+          content,
+          id,
+          onChange: itemOnChange,
+          ...itemRest
+        } = _ref2;
+        const cardId = id || "RadioCard[".concat(index, "]");
+
+        const handleChange = (newCheckedState, event) => {
+          if (typeof itemOnChange === 'function') itemOnChange(newCheckedState, event);
+          if (newCheckedState) setValue(cardId, event);
+        };
+
+        return /*#__PURE__*/_jsx(RadioCard, {
+          id: cardId,
+          checked: currentValue === cardId,
+          onChange: handleChange,
+          inactive: inactive,
+          title: title,
+          name: inputGroupName,
+          tokens: radioCardTokens,
+          variant: variant,
+          readOnly: readOnly,
+          ...selectItemProps(itemRest),
+          ...props,
+          children: content
+        }, cardId);
+      })
+    })
+  });
+});
+RadioCardGroup.displayName = 'RadioCardGroup';
+RadioCardGroup.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 RadioCardGroup component
+   */
+  tokens: getTokensPropType('RadioCardGroup'),
+
+  /**
+   * Optional theme token overrides for each inner RadioCard component
+   */
+  radioCardTokens: getTokensPropType('RadioCard'),
+
+  /**
+   * Theme variants, shared between both RadioCardGroup and RadioCard
+   */
+  variant: variantProp.propType,
+
+  /**
+   * Array of objects containing specifics for each RadioCard to be rendered in the group.
+   */
+  items: PropTypes.arrayOf(PropTypes.exact({ ...selectedItemPropTypes,
+    title: PropTypes.string,
+    content: PropTypes.node,
+    id: PropTypes.string,
+    onChange: PropTypes.func
+  })),
+
+  /**
+   * 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 RadioCardGroup;

package/lib-module/RadioCard/index.js

@@ -0,0 +1,3 @@
+import RadioCard from './RadioCard';
+export default RadioCard;
+export { default as RadioCardGroup } from './RadioCardGroup';