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

package/lib/Checkbox/Checkbox.js

@@ -1,17 +1,44 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import { Pressable, StyleSheet, Text, View } from 'react-native';
-import CheckboxInput from './CheckboxInput'; // @todo move `LabelContent` outside of the `InputLabel` and fix
-// the issue with the cursor not being pointer on Web
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _Pressable = _interopRequireDefault(require("react-native-web/dist/cjs/exports/Pressable"));
+
+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 _CheckboxInput = _interopRequireDefault(require("./CheckboxInput"));
+
+var _LabelContent = _interopRequireDefault(require("../InputLabel/LabelContent"));
+
+var _Feedback = _interopRequireDefault(require("../Feedback"));
+
+var _StackView = _interopRequireDefault(require("../StackView"));
+
+var _ThemeProvider = require("../ThemeProvider");
+
+var _utils = require("../utils");
 
-import CheckboxLabel from '../InputLabel/LabelContent';
-import Feedback from '../Feedback';
-import StackView from '../StackView';
-import { applyShadowToken, applyTextStyles, useThemeTokensCallback } from '../ThemeProvider';
-import { getTokensPropType, useInputValue, variantProp } from '../utils';
-import { a11yProps } from '../utils/propTypes';
-import useUniqueId from '../utils/useUniqueId';
+var _propTypes2 = require("../utils/propTypes");
 
+var _useUniqueId = _interopRequireDefault(require("../utils/useUniqueId"));
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// @todo move `LabelContent` outside of the `InputLabel` and fix
+// the issue with the cursor not being pointer on Web
 const selectInputStyles = ({
   iconBackgroundColor,
   inputBorderColor,
@@ -33,7 +60,7 @@ const selectInputStyles = ({
   outlineWidth: inputOutlineWidth,
   height: inputHeight,
   width: inputWidth,
-  ...applyShadowToken(inputShadow)
+  ...(0, _ThemeProvider.applyShadowToken)(inputShadow)
 });
 
 const selectLabelStyles = ({
@@ -45,7 +72,7 @@ const selectLabelStyles = ({
   labelLineHeight
 }) => ({
   marginLeft: labelMarginLeft,
-  ...applyTextStyles({
+  ...(0, _ThemeProvider.applyTextStyles)({
     color: labelColor,
     fontName: labelFontName,
     fontWeight: labelFontWeight,
@@ -54,16 +81,12 @@ const selectLabelStyles = ({
   })
 });
 
-const selectContainerStyles = ({
-  containerMarginBottom
-}) => ({
-  marginBottom: containerMarginBottom
-});
-
 const selectIconTokens = ({
+  icon,
   iconColor,
   iconSize
 }) => ({
+  icon,
   color: iconColor,
   size: iconSize
 });
@@ -133,12 +156,12 @@ const Checkbox = ({
     currentValue: isChecked,
     setValue: setIsChecked,
     isControlled
-  } = useInputValue({
+  } = (0, _utils.useInputValue)({
     value: checked,
     initialValue: defaultChecked,
     onChange
   }, 'useCheckboxValue');
-  const getTokens = useThemeTokensCallback('Checkbox', tokens, {
+  const getTokens = (0, _ThemeProvider.useThemeTokensCallback)('Checkbox', tokens, {
     checked: isChecked,
     inactive,
     error,
@@ -150,7 +173,8 @@ const Checkbox = ({
     feedbackMarginTop,
     feedbackPosition
   } = selectFeedbackTokens(defaultTokens);
-  const styles = StyleSheet.create({
+
+  const styles = _StyleSheet.default.create({
     feedbackContainer: {
       marginTop: feedbackMarginTop,
       marginBottom: feedbackMarginBottom
@@ -163,137 +187,149 @@ const Checkbox = ({
     }
   };
 
-  const accessibilityProps = a11yProps.select(rest);
-  const uniqueId = useUniqueId('checkbox');
-  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 `Checkbox` component on Web
-  // (namely, change on key pressed) is pending RNW upgrade
-  // (see https://github.com/necolas/react-native-web/issues/1950)
-
-  return /*#__PURE__*/React.createElement(View, {
-    style: staticStyles.wrapper
-  }, /*#__PURE__*/React.createElement(StackView, {
-    direction: feedbackPosition === 'top' ? 'column-reverse' : 'column',
-    space: 0
-  }, /*#__PURE__*/React.createElement(Pressable, Object.assign({
-    disabled: inactive,
-    onPress: handleChange,
-    accessibilityRole: "checkbox",
-    accessibilityState: {
-      checked: isChecked,
-      disabled: inactive
-    }
-  }, accessibilityProps), ({
-    focused: focus,
-    hovered: hover,
-    pressed
-  }) => {
-    const {
-      icon: IconComponent,
-      ...stateTokens
-    } = getTokens({
-      focus,
-      hover,
-      pressed
-    });
-    const iconTokens = selectIconTokens(stateTokens);
-    return /*#__PURE__*/React.createElement(View, {
-      style: [staticStyles.container, selectContainerStyles(stateTokens)]
-    }, /*#__PURE__*/React.createElement(View, {
-      style: StyleSheet.flatten([staticStyles.defaultInputStyles, selectInputStyles(stateTokens, isChecked)]),
-      testID: "Checkbox-Input"
-    }, /*#__PURE__*/React.createElement(CheckboxInput, {
-      checked: isChecked,
-      defaultChecked: defaultChecked,
-      disabled: inactive,
-      id: inputId,
-      isControlled: isControlled,
-      name: name,
-      value: value
-    }), isChecked && IconComponent && /*#__PURE__*/React.createElement(IconComponent, {
-      tokens: iconTokens,
-      testID: "Checkbox-Icon"
-    })), Boolean(label) && /*#__PURE__*/React.createElement(Text, {
-      style: selectLabelStyles(stateTokens)
-    }, /*#__PURE__*/React.createElement(CheckboxLabel, {
-      forId: inputId
-    }, label)));
-  }), Boolean(feedback) && /*#__PURE__*/React.createElement(View, {
-    style: styles.feedbackContainer
-  }, /*#__PURE__*/React.createElement(Feedback, {
-    title: feedback,
-    variant: {
-      icon: error === true
-    },
-    validation: error === true ? 'error' : undefined
-  }))));
+  const handleKeyDown = e => {
+    // The expected keyboard shortcut for activating a checkbox is the Space key
+    if ((e === null || e === void 0 ? void 0 : e.key) === ' ') handleChange();
+  };
+
+  const accessibilityProps = _propTypes2.a11yProps.select(rest);
+
+  const uniqueId = (0, _useUniqueId.default)('checkbox');
+  const inputId = id !== null && id !== void 0 ? id : uniqueId;
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+    style: staticStyles.wrapper,
+    children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_StackView.default, {
+      direction: feedbackPosition === 'top' ? 'column-reverse' : 'column',
+      space: 0,
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_Pressable.default, {
+        disabled: inactive,
+        onKeyDown: handleKeyDown,
+        onPress: handleChange,
+        accessibilityRole: "checkbox",
+        accessibilityState: {
+          checked: isChecked,
+          disabled: inactive
+        },
+        ...accessibilityProps,
+        children: ({
+          focused: focus,
+          hovered: hover,
+          pressed
+        }) => {
+          const {
+            icon: IconComponent,
+            ...stateTokens
+          } = getTokens({
+            focus,
+            hover,
+            pressed
+          });
+          const iconTokens = selectIconTokens(stateTokens);
+          return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, {
+            style: staticStyles.container,
+            children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)(_View.default, {
+              style: _StyleSheet.default.flatten([staticStyles.defaultInputStyles, selectInputStyles(stateTokens, isChecked)]),
+              testID: "Checkbox-Input",
+              children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_CheckboxInput.default, {
+                checked: isChecked,
+                defaultChecked: defaultChecked,
+                disabled: inactive,
+                id: inputId,
+                isControlled: isControlled,
+                name: name,
+                value: value
+              }), isChecked && IconComponent && /*#__PURE__*/(0, _jsxRuntime.jsx)(IconComponent, { ...iconTokens,
+                testID: "Checkbox-Icon"
+              })]
+            }), Boolean(label) && /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, {
+              style: selectLabelStyles(stateTokens),
+              children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_LabelContent.default, {
+                forId: inputId,
+                children: label
+              })
+            })]
+          });
+        }
+      }), Boolean(feedback) && /*#__PURE__*/(0, _jsxRuntime.jsx)(_View.default, {
+        style: styles.feedbackContainer,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_Feedback.default, {
+          title: feedback,
+          variant: {
+            icon: error === true
+          },
+          validation: error === true ? 'error' : undefined
+        })
+      })]
+    })
+  });
 };
 
-Checkbox.propTypes = { ...a11yProps.propTypes,
+Checkbox.propTypes = { ..._propTypes2.a11yProps.propTypes,
 
   /**
    * Use `checked` for controlled Checkbox. For uncontrolled Checkbox, use the `defaultChecked` prop.
    */
-  checked: PropTypes.bool,
+  checked: _propTypes.default.bool,
 
   /**
    * Use `defaultChecked` to provide the initial value for an uncontrolled Checkbox.
    */
-  defaultChecked: PropTypes.bool,
+  defaultChecked: _propTypes.default.bool,
 
   /**
    * A detailed description of related validation error or additional instructions (depending on the `error` prop).
    */
-  feedback: PropTypes.string,
+  feedback: _propTypes.default.string,
 
   /**
    * Checkbox ID.
    */
-  id: PropTypes.string,
+  id: _propTypes.default.string,
 
   /**
    * Whether the corresponding input is disabled or active.
    */
-  inactive: PropTypes.bool,
+  inactive: _propTypes.default.bool,
 
   /**
    * The label.
    */
-  label: PropTypes.string,
+  label: _propTypes.default.string,
 
   /**
    * Associate this checkbox with a group (set as the name attribute).
    */
-  name: PropTypes.string,
+  name: _propTypes.default.string,
 
   /**
    * Whether the underlying input triggered a validation error or not.
    */
-  error: PropTypes.bool,
+  error: _propTypes.default.bool,
 
   /**
    * The value. Must be unique within the group.
    */
-  value: PropTypes.oneOfType([PropTypes.string, PropTypes.number, PropTypes.bool]),
+  value: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number, _propTypes.default.bool]),
 
   /**
    * Callback called when a controlled checkbox gets interacted with.
    */
-  onChange: PropTypes.func,
+  onChange: _propTypes.default.func,
 
   /**
    * Checkbox tokens.
    */
-  tokens: getTokensPropType('Checkbox'),
+  tokens: (0, _utils.getTokensPropType)('Checkbox'),
 
   /**
    * Checkbox variant.
    */
-  variant: variantProp.propType
+  variant: _utils.variantProp.propType
 };
-export default Checkbox;
-const staticStyles = StyleSheet.create({
+var _default = Checkbox;
+exports.default = _default;
+
+const staticStyles = _StyleSheet.default.create({
   wrapper: {
     backgroundColor: 'transparent'
   },

package/lib/Checkbox/CheckboxGroup.js

@@ -0,0 +1,231 @@
+"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 _Checkbox = _interopRequireDefault(require("./Checkbox"));
+
+var _Fieldset = _interopRequireDefault(require("../Fieldset"));
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * A group of Checkboxs that behave as a fieldset. Use when users select any number of choices from options.
+ *
+ * ## Component API
+ *
+ * Use the `items` prop to pass an array of objects describing each Checkbox in the group:
+ *
+ *  - `label`: main text passed to CheckboxGroup's `label` prop
+ *  - `id`: identifier used to store which CheckboxGroup 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 CheckboxGroup 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
+ *
+ * CheckboxGroup accepts all the common accessibility props, and controls the accessibility state
+ * of children like Checkbox and Feedback based on current state.
+ *
+ * @example
+ * ```jsx
+ * <CheckboxGroup
+ *   initialCheckedId="check1"
+ *   items={[
+ *     { label: 'Checkbox 1', id: 'check1' },
+ *     { label: 'Checkbox 2', id: 'check2' },
+ *     { label: 'Checkbox 3', id: 'check3' }
+ *   ]}
+ *   legend="Checkboxes"
+ *   hint="Choose from these options"
+ * />
+ * ```
+ */
+const CheckboxGroup = ({
+  tokens,
+  radioTokens,
+  variant,
+  items = [],
+  legend,
+  tooltip,
+  hint,
+  validation,
+  feedback,
+  initialCheckedIds,
+  checkedIds,
+  onChange,
+  readOnly,
+  name: inputGroupName,
+  inactive
+}) => {
+  const viewport = (0, _ViewportProvider.useViewport)();
+  const {
+    space,
+    fieldSpace
+  } = (0, _ThemeProvider.useThemeTokens)('CheckboxGroup', tokens, variant, {
+    viewport
+  });
+  const {
+    currentValues,
+    toggleOneValue
+  } = (0, _utils.useMultipleInputValues)({
+    values: checkedIds,
+    initialValues: initialCheckedIds,
+    onChange,
+    readOnly: readOnly || inactive
+  });
+  const checkboxes = items.map(({
+    label,
+    id,
+    onChange: itemOnChange
+  }, index) => {
+    const checkboxId = id || "Checkbox[".concat(index, "]");
+
+    const handleChange = (...args) => {
+      if (typeof itemOnChange === 'function') itemOnChange(...args);
+      toggleOneValue(checkboxId);
+    };
+
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_Checkbox.default, {
+      id: checkboxId,
+      checked: currentValues.includes(checkboxId),
+      onChange: handleChange,
+      inactive: inactive,
+      label: label,
+      name: inputGroupName,
+      tokens: radioTokens,
+      variant: variant
+    }, checkboxId);
+  });
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_Fieldset.default, {
+    name: inputGroupName,
+    legend: legend,
+    tooltip: tooltip,
+    hint: hint,
+    space: fieldSpace,
+    feedback: feedback,
+    inactive: inactive,
+    status: validation,
+    children: (0, _StackView.getStackedContent)(checkboxes, {
+      space,
+      direction: 'column'
+    })
+  });
+};
+
+CheckboxGroup.propTypes = {
+  /**
+   * Optional theme token overrides for the outer CheckboxGroup component
+   */
+  tokens: (0, _utils.getTokensPropType)('CheckboxGroup'),
+
+  /**
+   * Optional theme token overrides for each inner Checkbox component
+   */
+  radioTokens: (0, _utils.getTokensPropType)('Checkbox'),
+
+  /**
+   * Theme variants, shared between both CheckboxGroup and Checkbox
+   */
+  variant: _utils.variantProp.propType,
+
+  /**
+   * Array of objects containing specifics for each Checkbox 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 checkboxed with this ids are selected on first render.
+   */
+  initialCheckedIds: _propTypes.default.arrayOf(_propTypes.default.string),
+
+  /**
+   * If not undefined, the checkboxes with these ids is selected, and the
+   * element's selection state will be controlled by its parent using the `onChange` function.
+   */
+  checkedIds: _propTypes.default.arrayOf(_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 checkbox 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 = CheckboxGroup;
+exports.default = _default;

package/lib/Checkbox/CheckboxInput.js

@@ -0,0 +1,74 @@
+"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 CheckboxInput = /*#__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: "checkbox",
+    value: value
+  });
+});
+CheckboxInput.displayName = 'CheckboxInput';
+CheckboxInput.propTypes = {
+  checked: _propTypes.default.bool,
+  defaultChecked: _propTypes.default.bool,
+  disabled: _propTypes.default.bool,
+  id: _propTypes.default.string.isRequired,
+  isControlled: _propTypes.default.bool.isRequired,
+  name: _propTypes.default.string,
+  onChange: _propTypes.default.func,
+  value: _propTypes.default.string
+};
+CheckboxInput.defaultProps = {
+  checked: undefined,
+  defaultChecked: undefined,
+  disabled: false,
+  name: undefined,
+  onChange: () => {},
+  value: undefined
+};
+var _default = CheckboxInput;
+exports.default = _default;

package/lib/Checkbox/CheckboxInput.native.js

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