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

package/lib/Radio/RadioGroup.js

@@ -0,0 +1,233 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _ViewportProvider = require("../ViewportProvider");
+
+var _ThemeProvider = require("../ThemeProvider");
+
+var _utils = require("../utils");
+
+var _StackView = require("../StackView");
+
+var _Radio = _interopRequireDefault(require("./Radio"));
+
+var _Fieldset = _interopRequireDefault(require("../Fieldset"));
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 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 = ({
+  tokens,
+  radioTokens,
+  variant,
+  items = [],
+  legend,
+  tooltip,
+  hint,
+  validation,
+  feedback,
+  initialCheckedId,
+  checkedId,
+  onChange,
+  readOnly,
+  name: inputGroupName,
+  inactive
+}) => {
+  const viewport = (0, _ViewportProvider.useViewport)();
+  const {
+    space,
+    fieldSpace
+  } = (0, _ThemeProvider.useThemeTokens)('RadioGroup', tokens, variant, {
+    viewport
+  });
+  const {
+    currentValue,
+    setValue
+  } = (0, _utils.useInputValue)({
+    value: checkedId,
+    initialValue: initialCheckedId,
+    onChange,
+    readOnly: readOnly || inactive
+  });
+  const radios = items.map(({
+    label,
+    id,
+    onChange: itemOnChange
+  }, index) => {
+    const radioId = id || "Radio[".concat(index, "]");
+
+    const handleChange = (...args) => {
+      if (typeof itemOnChange === 'function') itemOnChange(...args);
+      setValue(radioId);
+    };
+
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_Radio.default, {
+      id: radioId,
+      checked: currentValue === radioId,
+      onChange: handleChange,
+      inactive: inactive,
+      label: label,
+      name: inputGroupName,
+      tokens: radioTokens,
+      variant: variant
+    }, radioId);
+  });
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_Fieldset.default, {
+    name: inputGroupName,
+    legend: legend,
+    tooltip: tooltip,
+    hint: hint,
+    space: fieldSpace,
+    feedback: feedback,
+    inactive: inactive,
+    status: validation,
+    accessibilityRole: "radiogroup",
+    children: (0, _StackView.getStackedContent)(radios, {
+      space,
+      direction: 'column'
+    })
+  });
+};
+
+RadioGroup.propTypes = {
+  /**
+   * Optional theme token overrides for the outer RadioGroup component
+   */
+  tokens: (0, _utils.getTokensPropType)('RadioGroup'),
+
+  /**
+   * Optional theme token overrides for each inner Radio component
+   */
+  radioTokens: (0, _utils.getTokensPropType)('Radio'),
+
+  /**
+   * Theme variants, shared between both RadioGroup and Radio
+   */
+  variant: _utils.variantProp.propType,
+
+  /**
+   * Array of objects containing specifics for each Radio to be rendered in the group.
+   */
+  items: _propTypes.default.arrayOf(_propTypes.default.exact({
+    label: _propTypes.default.string,
+    id: _propTypes.default.string,
+    onChange: _propTypes.default.func
+  })),
+
+  /**
+   * Main text used to describe this group, used in Fieldset's Legend element.
+   */
+  legend: _propTypes.default.string,
+
+  /**
+   * Optional additional text giving more detail to help a user make a choice.
+   */
+  hint: _propTypes.default.string,
+
+  /**
+   * Optional tooltip text content to include alongside the legend and hint.
+   */
+  tooltip: _propTypes.default.string,
+
+  /**
+   * Current validation status of the group, passed to the feedback element if there is one.
+   */
+  validation: _propTypes.default.oneOf(['error', 'success']),
+
+  /**
+   * If provided, a Feedback element is rendered containing this text.
+   */
+  feedback: _propTypes.default.string,
+
+  /**
+   * If provided, the radio card with this id is selected on first render.
+   */
+  initialCheckedId: _propTypes.default.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.default.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.default.func,
+
+  /**
+   * If true, the radio cards cannot be selected by the user and simply show their current state.
+   */
+  readOnly: _propTypes.default.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.default.bool,
+
+  /**
+   * On Web, this is passed to the `name` attribute of the fieldset and each radio input.
+   */
+  name: _propTypes.default.string
+};
+var _default = RadioGroup;
+exports.default = _default;

package/lib/Radio/RadioInput.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * On Web we need to include an actual input but hide it.
+ */
+const RadioInput = /*#__PURE__*/(0, _react.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__*/(0, _jsxRuntime.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.default.bool,
+  defaultChecked: _propTypes.default.bool,
+  disabled: _propTypes.default.bool,
+  id: _propTypes.default.string,
+  isControlled: _propTypes.default.bool,
+  name: _propTypes.default.string,
+  onChange: _propTypes.default.func,
+  value: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number, _propTypes.default.bool])
+};
+RadioInput.defaultProps = {
+  checked: undefined,
+  defaultChecked: undefined,
+  disabled: false,
+  id: null,
+  isControlled: false,
+  name: undefined,
+  onChange: () => {},
+  value: undefined
+};
+var _default = RadioInput;
+exports.default = _default;

package/lib/Radio/RadioInput.native.js

@@ -1,6 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
 /**
  * There's no radio button input on native platforms, so this is a noop.
  */
 const RadioInput = () => null;
 
-export default RadioInput;
+var _default = RadioInput;
+exports.default = _default;

package/lib/Radio/index.js

@@ -1,2 +1,21 @@
-import Radio from './Radio';
-export default Radio;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "RadioGroup", {
+  enumerable: true,
+  get: function () {
+    return _RadioGroup.default;
+  }
+});
+exports.default = void 0;
+
+var _Radio = _interopRequireDefault(require("./Radio"));
+
+var _RadioGroup = _interopRequireDefault(require("./RadioGroup"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = _Radio.default;
+exports.default = _default;

package/lib/RadioCard/RadioCard.js

@@ -0,0 +1,240 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _StyleSheet = _interopRequireDefault(require("react-native-web/dist/cjs/exports/StyleSheet"));
+
+var _Text = _interopRequireDefault(require("react-native-web/dist/cjs/exports/Text"));
+
+var _View = _interopRequireDefault(require("react-native-web/dist/cjs/exports/View"));
+
+var _ThemeProvider = require("../ThemeProvider");
+
+var _utils = require("../utils");
+
+var _Card = require("../Card");
+
+var _StackView = _interopRequireDefault(require("../StackView"));
+
+var _RadioButton = _interopRequireWildcard(require("../Radio/RadioButton"));
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 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 = ({
+  tokens,
+  variant,
+  title,
+  children,
+  inactive,
+  defaultChecked,
+  checked,
+  name: inputName,
+  value,
+  id,
+  onChange,
+  ...rest
+}) => {
+  const {
+    currentValue: isChecked,
+    setValue: setIsChecked,
+    isControlled
+  } = (0, _utils.useInputValue)({
+    value: checked,
+    initialValue: defaultChecked,
+    onChange
+  });
+
+  const handleChange = () => {
+    if (!inactive && !isChecked) {
+      setIsChecked(true);
+    }
+  };
+
+  const a11y = _utils.a11yProps.select(rest);
+
+  const uniqueId = (0, _utils.useUniqueId)('RadioCard');
+  const inputId = id !== null && id !== void 0 ? id : uniqueId;
+  const getTokens = (0, _ThemeProvider.useThemeTokensCallback)('RadioCard', tokens, variant);
+
+  const getCardTokens = cardState => (0, _Card.selectPressableCardTokens)(getTokens(cardState));
+
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_Card.PressableCardBase, {
+    inactive: inactive,
+    checked: isChecked,
+    tokens: getCardTokens,
+    onPress: handleChange,
+    accessibilityRole: "radio",
+    accessibilityState: {
+      checked: isChecked,
+      disabled: inactive
+    },
+    ...a11y,
+    children: cardState => {
+      const {
+        radioSpace,
+        contentSpace,
+        ...themeTokens
+      } = getTokens(cardState);
+      const radioTokens = (0, _RadioButton.selectRadioButtonTokens)(themeTokens, 'radio');
+      const titleTokens = (0, _utils.selectTokens)('Typography', themeTokens);
+      const textStyle = (0, _ThemeProvider.applyTextStyles)(titleTokens);
+      return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_StackView.default, {
+        direction: "row",
+        space: radioSpace,
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+          style: [staticStyles.alignWithText, {
+            height: textStyle.lineHeight
+          }],
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_RadioButton.default, {
+            tokens: radioTokens,
+            isControlled: isControlled,
+            isChecked: isChecked,
+            inactive: inactive,
+            defaultChecked: defaultChecked,
+            inputId: inputId,
+            handleChange: handleChange,
+            name: inputName,
+            value: value
+          })
+        }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_StackView.default, {
+          direction: "column",
+          space: contentSpace,
+          children: [title && /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+            style: textStyle,
+            children: title
+          }), typeof children === 'function' ? children(cardState, textStyle) : children]
+        })]
+      });
+    }
+  });
+};
+
+RadioCard.propTypes = { ..._utils.a11yProps.propTypes,
+
+  /**
+   * Content to be displayed at the top of the card alongside the radio button
+   */
+  title: _propTypes.default.string,
+
+  /**
+   * Additional content to be displayed below the button.
+   */
+  children: _propTypes.default.oneOfType([_propTypes.default.node, _propTypes.default.func]),
+
+  /**
+   * Use `checked` for controlled Radio. For uncontrolled Radio, use the `defaultChecked` prop.
+   */
+  checked: _propTypes.default.bool,
+
+  /**
+   * Use `defaultChecked` to provide the initial value for an uncontrolled Radio.
+   */
+  defaultChecked: _propTypes.default.bool,
+
+  /**
+   * An optional radio button description.
+   */
+  description: _propTypes.default.string,
+
+  /**
+   * Radio card button ID.
+   */
+  id: _propTypes.default.string,
+
+  /**
+   * Whether the corresponding input is disabled or active.
+   */
+  inactive: _propTypes.default.bool,
+
+  /**
+   * The label.
+   */
+  label: _propTypes.default.string,
+
+  /**
+   * Associate this radio card with a group (set as the name attribute).
+   */
+  name: _propTypes.default.string,
+
+  /**
+   * Whether the underlying input triggered a validation error or not.
+   */
+  error: _propTypes.default.bool,
+
+  /**
+   * The value. Must be unique within the group.
+   */
+  value: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number, _propTypes.default.bool]),
+
+  /**
+   * Callback called when a controlled radio card gets interacted with.
+   */
+  onChange: _propTypes.default.func,
+
+  /**
+   * Radio card tokens.
+   */
+  tokens: (0, _utils.getTokensPropType)('RadioCard'),
+
+  /**
+   * Radio variant.
+   */
+  variant: _utils.variantProp.propType
+};
+
+const staticStyles = _StyleSheet.default.create({
+  alignWithText: {
+    justifyContent: 'center'
+  }
+});
+
+var _default = RadioCard;
+exports.default = _default;