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

package/lib/Button/ButtonBase.js

@@ -1,17 +1,8 @@
 import React from 'react';
 import { Pressable, Text, View, StyleSheet, Platform } from 'react-native';
-import { useThemeTokensCallback } from '../ThemeProvider';
 import { applyTextStyles, applyShadowToken } from '../ThemeProvider/utils';
 import buttonPropTypes from './propTypes';
-import { a11yProps, hrefAttrsProp, linkProps } from '../utils/propTypes';
-
-const getCursorStyle = (inactive, accessibilityRole) => {
-  if (inactive) return 'not-allowed'; // These roles should result in cursor: pointer but don't in current RNW releases
-
-  if (['checkbox', 'radio', 'switch'].includes(accessibilityRole)) return 'pointer'; // For everything else, let React Native Web figure it out internally
-
-  return undefined;
-};
+import { a11yProps, getCursorStyle, hrefAttrsProp, linkProps, resolvePressableState, resolvePressableTokens } from '../utils';
 
 const getOuterBorderOffset = ({
   outerBorderGap = 0,
@@ -94,7 +85,8 @@ const selectInnerContainerStyles = ({
   paddingTop,
   paddingBottom,
   shadow,
-  borderWidth
+  borderWidth,
+  minWidth
 }) => {
   // Subtract border width from padding so overall button width/height doesn't
   // jump around if the border width changes (avoiding NaN and negative padding)
@@ -106,6 +98,7 @@ const selectInnerContainerStyles = ({
     paddingTop: offsetBorder(paddingTop),
     paddingBottom: offsetBorder(paddingBottom),
     backgroundColor,
+    minWidth,
     ...applyShadowToken(shadow)
   };
 };
@@ -138,76 +131,83 @@ const selectTextStyles = ({
 
 const selectWebOnlyStyles = (inactive, themeTokens, {
   accessibilityRole
-}) => Platform.OS === 'web' ? {
-  // if it would overflow the container, wraps instead
-  maxWidth: `calc(100% + ${getOuterBorderOffset(themeTokens) * 2}px)`,
-  cursor: getCursorStyle(inactive, accessibilityRole),
-  outline: 'none' // removes the default browser :focus outline
+}) => {
+  return Platform.select({
+    web: {
+      // if it would overflow the container, wraps instead
+      maxWidth: `calc(100% + ${getOuterBorderOffset(themeTokens) * 2}px)`,
+      outline: 'none',
+      // removes the default browser :focus outline
+      ...getCursorStyle(inactive, accessibilityRole)
+    },
+    default: {}
+  });
+}; // TODO: see if this can be made into a generalised utility, ideally when
+// there is a stable, generic, generalised approach to within-component text
+
+
+const resolveChildren = (children, {
+  textStyles,
+  state
+}) => {
+  switch (typeof children) {
+    case 'function':
+      return children(state);
 
-} : {};
+    case 'string':
+      return /*#__PURE__*/React.createElement(Text, {
+        style: textStyles
+      }, children);
+
+    default:
+      return children;
+  }
+};
 
 const ButtonBase = ({
   href,
   hrefAttrs,
   children,
-  variant,
   onPress,
-  tokens,
+  tokens = {},
   disabled = false,
   // alias for inactive
   inactive = disabled,
   selected = false,
   ...rest
 }) => {
-  const getTokens = useThemeTokensCallback('Button', tokens, variant);
-
-  const getButtonState = ({
-    pressed,
-    focused,
-    hovered
-  }) => ({
-    pressed,
-    focus: focused,
-    hover: hovered,
+  const extraButtonState = {
     inactive,
     selected
-  });
+  };
 
-  const getTokensByPressableState = pressableState => getTokens(getButtonState(pressableState));
+  const resolveTokens = pressableState => resolvePressableTokens(tokens, pressableState, extraButtonState);
 
   const a11y = a11yProps.select(rest);
 
   const getPressableStyle = pressableState => {
-    const themeTokens = getTokensByPressableState(pressableState);
-    return [staticStyles.wrapper, selectWebOnlyStyles(inactive, themeTokens, a11y), selectOuterContainerStyles(themeTokens), selectOuterWidthStyles(themeTokens)];
+    const themeTokens = resolveTokens(pressableState);
+    return [staticStyles.row, selectWebOnlyStyles(inactive, themeTokens, a11y), selectOuterContainerStyles(themeTokens), selectOuterWidthStyles(themeTokens)];
   };
 
-  const handlePress = linkProps.handleHref({
-    href,
-    onPress
-  });
   return /*#__PURE__*/React.createElement(Pressable, Object.assign({
-    onPress: handlePress,
+    href: href,
+    onPress: linkProps.handleHref({
+      href,
+      onPress
+    }),
     style: getPressableStyle,
-    disabled: inactive,
-    href: href
+    disabled: inactive
   }, hrefAttrsProp.spread(hrefAttrs), a11y), pressableState => {
-    const themeTokens = getTokensByPressableState(pressableState);
+    const themeTokens = resolveTokens(pressableState);
     const containerStyles = selectInnerContainerStyles(themeTokens);
     const borderStyles = selectBorderStyles(themeTokens);
-    const textStyles = { ...selectTextStyles(themeTokens),
-      ...Platform.select({
-        // TODO: https://github.com/telus/universal-design-system/issues/487
-        web: {
-          transition: 'color 200ms'
-        }
-      })
-    }; // If the container has a width set, fill it instead of sizing from content.
+    const textStyles = [selectTextStyles(themeTokens), staticStyles.text]; // If the container has a width set, fill it instead of sizing from content.
     // If in future we support text alignments other than center, add here.
 
-    const stretchStyles = !!themeTokens.width && staticStyles.center;
+    const stretchStyles = themeTokens.width ? staticStyles.stretch : staticStyles.align;
     return /*#__PURE__*/React.createElement(View, {
-      style: [containerStyles, borderStyles, stretchStyles, Platform.select({
+      style: [containerStyles, borderStyles, stretchStyles, staticStyles.row, Platform.select({
         web: {
           maxWidth: '100%',
           // ensure overflowing content wraps
@@ -215,11 +215,12 @@ const ButtonBase = ({
           transition: 'background-color 200ms, border-color 200ms'
         }
       })]
-    }, typeof children === 'function' ? children({ ...getButtonState(pressableState),
+    }, resolveChildren(children, {
+      state: { ...resolvePressableState(pressableState, extraButtonState),
+        textStyles
+      },
       textStyles
-    }) : /*#__PURE__*/React.createElement(Text, {
-      style: textStyles
-    }, children));
+    }));
   });
 };
 
@@ -228,11 +229,24 @@ ButtonBase.propTypes = { ...a11yProps.types,
   ...linkProps.types
 };
 const staticStyles = StyleSheet.create({
-  wrapper: {
-    flexDirection: 'row' // ensures alignSelf is horizontal
-
+  row: {
+    // Apply all button alignment horizontally; no vertical stacking within a button
+    flexDirection: 'row'
+  },
+  text: {
+    flexGrow: 1,
+    // On native but not web, flexShrink here wraps text prematurely
+    ...Platform.select({
+      // TODO: https://github.com/telus/universal-design-system/issues/487
+      web: {
+        transition: 'color 200ms'
+      }
+    })
+  },
+  align: {
+    alignItems: 'center'
   },
-  center: {
+  stretch: {
     flex: 1,
     alignItems: 'center',
     justifyContent: 'center'

package/lib/Button/ButtonGroup.js

@@ -4,13 +4,13 @@ import { Platform } from 'react-native';
 import ButtonBase from './ButtonBase';
 import { StackWrap } from '../StackView';
 import { useViewport } from '../ViewportProvider';
-import { useThemeTokens } from '../ThemeProvider';
+import { useThemeTokens, useThemeTokensCallback } from '../ThemeProvider';
 import { a11yProps, pressProps, variantProp, getTokensPropType, selectTokens } from '../utils/propTypes';
 import { useMultipleInputValues } from '../utils/input';
+import { getPressHandlersWithArgs } from '../utils/pressability';
 
 const ButtonGroup = ({
   variant,
-  buttonVariant = {},
   tokens,
   items = [],
   values,
@@ -35,6 +35,7 @@ const ButtonGroup = ({
     direction,
     space
   } = themeTokens;
+  const getButtonTokens = useThemeTokensCallback('ButtonGroupItem', tokens, variant);
   const {
     currentValues,
     toggleOneValue
@@ -59,18 +60,13 @@ const ButtonGroup = ({
     id = label,
     accessibilityLabel
   }, index) => {
-    const isSelected = currentValues.includes(id); // Allow handlers to be passed down for blur, hover, focus, pressIn, etc
+    const isSelected = currentValues.includes(id); // Pass an object of relevant component state as first argument for any passed-in press handlers
 
-    const pressHandlers = Object.fromEntries(Object.entries(pressProps.select(rest)).map(([key, handler]) => ({
-      [key]: args => {
-        // Pass each handler data on this button and current selection
-        handler({
-          id,
-          label,
-          currentValues
-        }, ...args);
-      }
-    })));
+    const pressHandlers = getPressHandlersWithArgs(rest, [{
+      id,
+      label,
+      currentValues
+    }]);
 
     const handlePress = () => {
       if (pressHandlers.onPress) pressHandlers.onPress();
@@ -83,15 +79,7 @@ const ButtonGroup = ({
       },
       accessibilityRole: itemA11yRole,
       accessibilityLabel,
-      ...Platform.select({
-        web: {
-          // accessibilityPosInSet etc exists in React Native Web main branch
-          // but not in a release compatible with Expo etc; just use `aria-*`
-          'aria-setsize': items.length,
-          'aria-posinset': index + 1
-        },
-        default: {}
-      })
+      ...a11yProps.getPositionInSet(items.length, index)
     }; // Ensure button is direct child of group as MacOS voiceover only applies "X of Y" to
     // "radio" if it's a direct child of "radiogroup", even if aria-posinset etc exists
 
@@ -99,10 +87,7 @@ const ButtonGroup = ({
       key: id
     }, pressHandlers, {
       onPress: handlePress,
-      variant: {
-        component: 'ButtonGroup',
-        ...buttonVariant
-      },
+      tokens: getButtonTokens,
       selected: isSelected,
       inactive: inactive
     }, itemA11y), label);
@@ -113,7 +98,6 @@ ButtonGroup.propTypes = { ...a11yProps.propTypes,
   ...pressProps.propTypes,
   tokens: getTokensPropType('ButtonGroup'),
   variant: variantProp.propType,
-  buttonVariant: variantProp.propType,
 
   /**
    * The maximum number of items a user may select at once. Defaults to 1 and behaves

package/lib/Button/ButtonLink.js

@@ -2,6 +2,7 @@ import React from 'react';
 import ButtonBase from './ButtonBase';
 import buttonPropTypes from './propTypes';
 import { a11yProps, hrefAttrsProp, linkProps } from '../utils/propTypes';
+import { useThemeTokensCallback } from '../ThemeProvider';
 /**
  * `ButtonLink` is a component with the semantics and behaviour of a link, but with the visual appearance of a button.
  * ButtonLink is a block-level component and should not be used inline.
@@ -9,14 +10,18 @@ import { a11yProps, hrefAttrsProp, linkProps } from '../utils/propTypes';
 
 const ButtonLink = ({
   accessibilityRole = 'link',
+  tokens,
+  variant,
   ...props
 }) => {
   const {
     hrefAttrs,
     rest
   } = hrefAttrsProp.bundle(props);
+  const getTokens = useThemeTokensCallback('Button', tokens, variant);
   return /*#__PURE__*/React.createElement(ButtonBase, Object.assign({
     accessibilityRole: accessibilityRole,
+    tokens: getTokens,
     hrefAttrs: hrefAttrs
   }, rest));
 };

package/lib/Checkbox/Checkbox.js

@@ -0,0 +1,308 @@
+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
+
+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';
+
+const selectInputStyles = ({
+  iconBackgroundColor,
+  inputBorderColor,
+  inputBorderRadius,
+  inputBorderWidth,
+  inputBackgroundColor,
+  inputHeight,
+  inputOutlineColor,
+  inputOutlineWidth,
+  inputShadow,
+  inputWidth
+}, isChecked) => ({
+  borderColor: inputBorderColor,
+  borderWidth: inputBorderWidth,
+  borderRadius: inputBorderRadius,
+  backgroundColor: isChecked ? iconBackgroundColor : inputBackgroundColor,
+  outlineStyle: 'solid',
+  outlineColor: inputOutlineColor,
+  outlineWidth: inputOutlineWidth,
+  height: inputHeight,
+  width: inputWidth,
+  ...applyShadowToken(inputShadow)
+});
+
+const selectLabelStyles = ({
+  labelColor,
+  labelFontName,
+  labelFontSize,
+  labelFontWeight,
+  labelMarginLeft,
+  labelLineHeight
+}) => ({
+  marginLeft: labelMarginLeft,
+  ...applyTextStyles({
+    color: labelColor,
+    fontName: labelFontName,
+    fontWeight: labelFontWeight,
+    fontSize: labelFontSize,
+    lineHeight: labelLineHeight
+  })
+});
+
+const selectContainerStyles = ({
+  containerMarginBottom
+}) => ({
+  marginBottom: containerMarginBottom
+});
+
+const selectIconTokens = ({
+  iconColor,
+  iconSize
+}) => ({
+  color: iconColor,
+  size: iconSize
+});
+
+const selectFeedbackTokens = ({
+  feedbackMarginBottom,
+  feedbackMarginTop,
+  feedbackPosition
+}) => ({
+  feedbackPosition,
+  feedbackMarginBottom,
+  feedbackMarginTop
+});
+/**
+ * Basic Checkbox component.
+ *
+ * ## Component API
+ *
+ * Use `label` prop to provide a label for the checkbox.
+ * For a disabled `Checkbox` set the `inactive` prop to `true`.
+ *
+ * ### Controlled version
+ *
+ * If the checkbox is controlled from outside, it needs to receive `checked` and `onChange` props.
+ *
+ * ### Uncontrolled version
+ *
+ * In case of uncontrolled checkbox you can use `defaultChecked` prop to provide the initial value.
+ * Whenever the checkbox 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 checkbox to be a part of a group of
+ * checkboxes on a form.
+ *
+ * ### Validation and feedback
+ *
+ * You can use the `feedback` prop to provide a comment related to the checkbox element. If the comment
+ * is related to a validation error, the checkbox and the feedback can be styled accordingly by setting
+ * the `error` prop to `true` (can also be done without feedback).
+ *
+ * ## A11y guidelines
+ *
+ * Checkbox component accepts all the common accessibility props, but also sets some defaults, including
+ * accessibility role `'checkbox'` and accessibility state that depends on the other props (`checked`, `inactive`)
+ * or the internal state in case of uncontrolled checkbox.
+ *
+ */
+
+
+const Checkbox = ({
+  checked,
+  defaultChecked,
+  error = false,
+  feedback,
+  id,
+  inactive,
+  label,
+  name,
+  onChange,
+  tokens,
+  value,
+  variant,
+  ...rest
+}) => {
+  const {
+    currentValue: isChecked,
+    setValue: setIsChecked,
+    isControlled
+  } = useInputValue({
+    value: checked,
+    initialValue: defaultChecked,
+    onChange
+  }, 'useCheckboxValue');
+  const getTokens = useThemeTokensCallback('Checkbox', tokens, {
+    checked: isChecked,
+    inactive,
+    error,
+    ...variant
+  });
+  const defaultTokens = getTokens();
+  const {
+    feedbackMarginBottom,
+    feedbackMarginTop,
+    feedbackPosition
+  } = selectFeedbackTokens(defaultTokens);
+  const styles = StyleSheet.create({
+    feedbackContainer: {
+      marginTop: feedbackMarginTop,
+      marginBottom: feedbackMarginBottom
+    }
+  });
+
+  const handleChange = () => {
+    if (!inactive) {
+      setIsChecked(!isChecked);
+    }
+  };
+
+  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
+  }))));
+};
+
+Checkbox.propTypes = { ...a11yProps.propTypes,
+
+  /**
+   * Use `checked` for controlled Checkbox. For uncontrolled Checkbox, use the `defaultChecked` prop.
+   */
+  checked: PropTypes.bool,
+
+  /**
+   * Use `defaultChecked` to provide the initial value for an uncontrolled Checkbox.
+   */
+  defaultChecked: PropTypes.bool,
+
+  /**
+   * A detailed description of related validation error or additional instructions (depending on the `error` prop).
+   */
+  feedback: PropTypes.string,
+
+  /**
+   * Checkbox ID.
+   */
+  id: PropTypes.string,
+
+  /**
+   * Whether the corresponding input is disabled or active.
+   */
+  inactive: PropTypes.bool,
+
+  /**
+   * The label.
+   */
+  label: PropTypes.string,
+
+  /**
+   * Associate this checkbox 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 checkbox gets interacted with.
+   */
+  onChange: PropTypes.func,
+
+  /**
+   * Checkbox tokens.
+   */
+  tokens: getTokensPropType('Checkbox'),
+
+  /**
+   * Checkbox variant.
+   */
+  variant: variantProp.propType
+};
+export default Checkbox;
+const staticStyles = StyleSheet.create({
+  wrapper: {
+    backgroundColor: 'transparent'
+  },
+  container: {
+    flexDirection: 'row',
+    alignItems: 'center'
+  },
+  defaultInputStyles: {
+    alignItems: 'center',
+    justifyContent: 'center'
+  }
+});

package/lib/Checkbox/CheckboxInput.native.js

@@ -0,0 +1,6 @@
+/**
+ * There's no checkbox input on native platforms, so this is a noop.
+ */
+const CheckboxInput = () => null;
+
+export default CheckboxInput;

package/lib/Checkbox/CheckboxInput.web.js

@@ -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 CheckboxInput = /*#__PURE__*/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__*/React.createElement("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.bool,
+  defaultChecked: PropTypes.bool,
+  disabled: PropTypes.bool,
+  id: PropTypes.string.isRequired,
+  isControlled: PropTypes.bool.isRequired,
+  name: PropTypes.string,
+  onChange: PropTypes.func,
+  value: PropTypes.string
+};
+CheckboxInput.defaultProps = {
+  checked: undefined,
+  defaultChecked: undefined,
+  disabled: false,
+  name: undefined,
+  onChange: () => {},
+  value: undefined
+};
+export default CheckboxInput;

package/lib/Checkbox/index.js

@@ -0,0 +1,2 @@
+import Checkbox from './Checkbox';
+export default Checkbox;