@telus-uds/components-base 1.3.0 → 1.5.0

package/lib-module/Button/ButtonLink.js

@@ -0,0 +1,39 @@
+import React, { forwardRef } from 'react';
+import ButtonBase from './ButtonBase';
+import buttonPropTypes, { textAndA11yText } from './propTypes';
+import { a11yProps, hrefAttrsProp, linkProps } from '../utils/props';
+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.
+ */
+
+import { jsx as _jsx } from "react/jsx-runtime";
+const ButtonLink = /*#__PURE__*/forwardRef(({
+  accessibilityRole = 'link',
+  tokens,
+  variant,
+  dataSet,
+  ...props
+}, ref) => {
+  const {
+    hrefAttrs,
+    rest
+  } = hrefAttrsProp.bundle(props);
+  const getTokens = useThemeTokensCallback('Button', tokens, variant);
+  return /*#__PURE__*/_jsx(ButtonBase, {
+    ref: ref,
+    accessibilityRole: accessibilityRole,
+    tokens: getTokens,
+    hrefAttrs: hrefAttrs,
+    dataSet: dataSet,
+    ...rest
+  });
+});
+ButtonLink.displayName = 'ButtonLink';
+ButtonLink.propTypes = { ...a11yProps.types,
+  ...buttonPropTypes,
+  ...linkProps.types,
+  children: textAndA11yText
+};
+export default ButtonLink;

package/lib-module/Button/index.js

@@ -0,0 +1,4 @@
+import Button from './Button';
+import ButtonLink from './ButtonLink';
+import ButtonGroup from './ButtonGroup';
+export { Button, ButtonGroup, ButtonLink };

package/lib-module/Button/propTypes.js

@@ -0,0 +1,36 @@
+import PropTypes from 'prop-types';
+import ABBPropTypes from 'airbnb-prop-types';
+import { variantProp, getTokensPropType } from '../utils/props';
+import A11yText from '../A11yText';
+export const textAndA11yText = ABBPropTypes.childrenOf(PropTypes.oneOfType([ABBPropTypes.elementType(A11yText), PropTypes.string]));
+const buttonPropTypes = {
+  tokens: getTokensPropType('Button'),
+
+  /**
+   * If true, prevents the button from being pressed, changes the cursor (on web) and accessibility
+   * attributes to communicate this to the user, and applies `inactive: true` appearances from the theme
+   */
+  inactive: PropTypes.bool,
+
+  /**
+   * Alias for `inactive`
+   */
+  disabled: PropTypes.bool,
+
+  /**
+   * Button's children must be either:
+   *  - One or more text strings and / or A11yText components
+   *  - A render function with contents that responds to current button state by being passed an object of:
+   * ```
+   * { hovered<bool>, focused<bool>, pressed<bool>, inactive<bool>, selected<bool>, textStyles<RNStyle> }
+   * ```
+   */
+  children: PropTypes.oneOfType([PropTypes.func, textAndA11yText]).isRequired,
+
+  /**
+   * Function called when the button is pressed. Required unless the button has a href.
+   */
+  onPress: PropTypes.func,
+  variant: variantProp.propType
+};
+export default buttonPropTypes;

package/lib-module/Card/Card.js

@@ -0,0 +1,83 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { useThemeTokens } from '../ThemeProvider';
+import { getTokensPropType, variantProp } from '../utils';
+import { useViewport } from '../ViewportProvider';
+import { a11yProps, selectSystemProps, viewProps } from '../utils/props';
+import CardBase from './CardBase';
+import { jsx as _jsx } from "react/jsx-runtime";
+const [selectProps, selectedSystemPropTypes] = selectSystemProps([a11yProps, viewProps]);
+/**
+ * A basic card component, unstyled by default.
+ *
+ * ## Component API
+ *
+ * ### Background
+ *
+ * In order to control the background of a card, the following tokens are currently
+ * supported:
+ *
+ * - `backgroundColor`
+ *
+ * ### Border
+ *
+ * The following border tokens can be used:
+ *
+ * - `borderColor`
+ * - `borderRadius`
+ * - `borderWidth`
+ *
+ * ### Padding
+ *
+ * Please use the following tokens to control the padding:
+ *
+ * - `paddingBottom`
+ * - `paddingLeft`
+ * - `paddingRight`
+ * - `paddingTop`
+ *
+ * Note that various viewport sizes are supported as well.
+ *
+ * ### Shadow
+ *
+ * Feel free to use the following properties within the `shadow` token:
+ *
+ * - `inset`: boolean
+ * - `color`: string
+ * - `offsetX`: number
+ * - `offsetY`: number
+ * - `blur`: number
+ * - `spread`: number
+ *
+ * ## Accessibility
+ *
+ * Card supports all the common a11y props. Please remember that by marking a card as `accessible`
+ * you automatically make inaccessible its children, which may or may not be appropriate
+ * depending on what you are trying to achieve.
+ */
+
+const Card = ({
+  children,
+  tokens,
+  variant,
+  dataSet,
+  ...rest
+}) => {
+  const viewport = useViewport();
+  const themeTokens = useThemeTokens('Card', tokens, variant, {
+    viewport
+  });
+  return /*#__PURE__*/_jsx(CardBase, {
+    tokens: themeTokens,
+    dataSet: dataSet,
+    ...selectProps(rest),
+    children: children
+  });
+};
+
+Card.propTypes = { ...selectedSystemPropTypes,
+  children: PropTypes.node,
+  tokens: getTokensPropType('Card'),
+  variant: variantProp.propType
+};
+export default Card;

package/lib-module/Card/CardBase.js

@@ -0,0 +1,62 @@
+import React, { forwardRef } from 'react';
+import PropTypes from 'prop-types';
+import View from "react-native-web/dist/exports/View";
+import { applyShadowToken } from '../ThemeProvider';
+import { getTokensPropType } from '../utils';
+import { a11yProps, viewProps, selectSystemProps } from '../utils/props';
+import { jsx as _jsx } from "react/jsx-runtime";
+const [selectProps, selectedSystemPropTypes] = selectSystemProps([a11yProps, viewProps]); // Ensure explicit selection of tokens
+
+const selectStyles = ({
+  flex,
+  backgroundColor,
+  borderColor,
+  borderRadius,
+  borderWidth,
+  paddingBottom,
+  paddingLeft,
+  paddingRight,
+  paddingTop,
+  minWidth,
+  shadow
+}) => ({
+  flex,
+  backgroundColor,
+  borderColor,
+  borderRadius,
+  borderWidth,
+  paddingBottom,
+  paddingLeft,
+  paddingRight,
+  paddingTop,
+  minWidth,
+  ...applyShadowToken(shadow)
+});
+/**
+ * A themeless base component for Card which components can apply theme tokens to. Not
+ * intended to be used in apps or sites directly: build themed components on top of this.
+ */
+
+
+const CardBase = /*#__PURE__*/forwardRef(({
+  children,
+  tokens,
+  dataSet,
+  ...rest
+}, ref) => {
+  const cardStyle = selectStyles(typeof tokens === 'function' ? tokens() : tokens);
+  const props = selectProps(rest);
+  return /*#__PURE__*/_jsx(View, {
+    style: cardStyle,
+    dataSet: dataSet,
+    ref: ref,
+    ...props,
+    children: children
+  });
+});
+CardBase.displayName = 'CardBase';
+CardBase.propTypes = { ...selectedSystemPropTypes,
+  children: PropTypes.node,
+  tokens: getTokensPropType('Card')
+};
+export default CardBase;

package/lib-module/Card/PressableCardBase.js

@@ -0,0 +1,113 @@
+import React, { forwardRef } from 'react';
+import PropTypes from 'prop-types';
+import Pressable from "react-native-web/dist/exports/Pressable";
+import Platform from "react-native-web/dist/exports/Platform";
+import { useViewport } from '../ViewportProvider';
+import { applyOuterBorder, validateThemeTokens } from '../ThemeProvider';
+import { a11yProps, clickProps, getTokenNames, getTokensSetPropType, linkProps, resolvePressableState, resolvePressableTokens, selectSystemProps, selectTokens, variantProp, viewProps, withLinkRouter } from '../utils';
+import CardBase from './CardBase';
+import { jsx as _jsx } from "react/jsx-runtime";
+const [selectProps, selectedSystemPropTypes] = selectSystemProps([a11yProps, viewProps]);
+const tokenKeys = [...getTokenNames('Card'), // Outer border tokens. TODO: centralise common token sets like these as part of
+// https://github.com/telus/universal-design-system/issues/782
+'outerBorderColor', 'outerBorderWidth', 'outerBorderGap'];
+export const selectPressableCardTokens = tokens => Object.fromEntries(tokenKeys.map(key => [key, tokens[key]]));
+/**
+ * A pressable themeless base component that handles pressable states and passes tokens
+ * based on these to an outer border and a base Card component. Not intended to be used in
+ * apps or sites directly: build themed components on top of this.
+ */
+
+const PressableCardBase = /*#__PURE__*/forwardRef(({
+  children,
+  tokens,
+  checked,
+  validation,
+  inactive,
+  href,
+  hrefAttrs,
+  accessibilityRole = href ? 'link' : undefined,
+  ...rawRest
+}, ref) => {
+  const {
+    onPress,
+    ...rest
+  } = clickProps.toPressProps(rawRest);
+  const viewport = useViewport();
+  const additionalState = {
+    checked,
+    validation,
+    inactive,
+    viewport
+  };
+
+  const getCardState = pressableState => resolvePressableState(pressableState, additionalState);
+
+  const getTokens = pressableState => validateThemeTokens(resolvePressableTokens(tokens, pressableState, additionalState), getTokensSetPropType(tokenKeys, {
+    requireAll: true
+  }), 'PressableCard');
+
+  const getCardTokens = pressableState => selectTokens('Card', getTokens(pressableState));
+
+  const getOuterBorderStyle = pressableState => {
+    const {
+      flex,
+      minWidth,
+      outerBorderColor,
+      outerBorderGap = 0,
+      outerBorderWidth = 0,
+      borderRadius
+    } = getTokens(pressableState);
+    return {
+      flex,
+      minWidth: minWidth + outerBorderGap + outerBorderWidth,
+      ...applyOuterBorder({
+        outerBorderColor,
+        outerBorderGap,
+        outerBorderWidth,
+        borderRadius
+      }),
+      ...Platform.select({
+        web: {
+          outline: 'none'
+        }
+      })
+    };
+  };
+
+  const handleChange = linkProps.handleHref({
+    href,
+    onPress
+  });
+
+  const handleKeyDown = event => {
+    // The expected keyboard shortcut for selecting a focused item is the Space key
+    if ((event === null || event === void 0 ? void 0 : event.key) === ' ') handleChange(event);
+  };
+
+  return /*#__PURE__*/_jsx(Pressable, {
+    ref: ref,
+    href: href,
+    onPress: handleChange,
+    onKeyDown: handleKeyDown,
+    hrefAttrs: hrefAttrs,
+    style: getOuterBorderStyle,
+    ...selectProps({ ...rest,
+      accessibilityRole
+    }),
+    children: pressableState => /*#__PURE__*/_jsx(CardBase, {
+      tokens: getCardTokens(pressableState),
+      children: typeof children === 'function' ? children(getCardState(pressableState)) : children
+    })
+  });
+});
+PressableCardBase.displayName = 'PressableCardBase';
+PressableCardBase.propTypes = { ...selectedSystemPropTypes,
+  children: PropTypes.oneOfType([PropTypes.func, PropTypes.node]),
+  tokens: getTokensSetPropType(tokenKeys, {
+    requireAll: true,
+    allowFunction: true
+  }),
+  variant: variantProp.propType
+};
+export default withLinkRouter(PressableCardBase);

package/lib-module/Card/index.js

@@ -0,0 +1,4 @@
+import Card from './Card';
+export default Card;
+export { default as PressableCardBase } from './PressableCardBase';
+export * from './PressableCardBase';

package/lib-module/Checkbox/Checkbox.js

@@ -0,0 +1,321 @@
+import React, { forwardRef } from 'react';
+import PropTypes from 'prop-types';
+import Platform from "react-native-web/dist/exports/Platform";
+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 CheckboxInput from './CheckboxInput';
+import CheckboxLabel from '../InputLabel/LabelContent';
+import Feedback from '../Feedback';
+import StackView from '../StackView';
+import { applyShadowToken, applyTextStyles, useThemeTokensCallback } from '../ThemeProvider';
+import { a11yProps, getTokensPropType, selectSystemProps, useInputValue, variantProp, viewProps } from '../utils';
+import useUniqueId from '../utils/useUniqueId';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+const [selectProps, selectedSystemPropTypes] = selectSystemProps([a11yProps, viewProps]);
+
+const selectInputStyles = ({
+  iconBackgroundColor,
+  inputBorderColor,
+  inputBorderRadius,
+  inputBorderWidth,
+  inputBackgroundColor,
+  inputHeight,
+  inputOutlineColor,
+  inputOutlineWidth,
+  inputShadow,
+  inputWidth
+}, isChecked) => ({
+  borderColor: inputBorderColor,
+  borderWidth: inputBorderWidth,
+  borderRadius: inputBorderRadius,
+  backgroundColor: isChecked ? iconBackgroundColor : inputBackgroundColor,
+  height: inputHeight,
+  width: inputWidth,
+  ...applyShadowToken(inputShadow),
+  ...Platform.select({
+    web: {
+      outlineStyle: 'solid',
+      outlineColor: inputOutlineColor,
+      outlineWidth: inputOutlineWidth
+    }
+  })
+});
+
+const selectLabelStyles = ({
+  labelColor,
+  labelFontName,
+  labelFontSize,
+  labelFontWeight,
+  labelMarginLeft,
+  labelLineHeight
+}) => ({
+  marginLeft: labelMarginLeft,
+  ...applyTextStyles({
+    color: labelColor,
+    fontName: labelFontName,
+    fontWeight: labelFontWeight,
+    fontSize: labelFontSize,
+    lineHeight: labelLineHeight
+  })
+});
+
+const selectIconTokens = ({
+  icon,
+  iconColor,
+  iconSize
+}) => ({
+  icon,
+  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 = /*#__PURE__*/forwardRef(({
+  checked,
+  defaultChecked,
+  error = false,
+  feedback,
+  id,
+  inactive,
+  label,
+  name,
+  onChange,
+  tokens,
+  value,
+  variant,
+  ...rest
+}, ref) => {
+  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 = event => {
+    if (!inactive) {
+      setIsChecked(!isChecked, event);
+    }
+  };
+
+  const handleKeyDown = event => {
+    // The expected keyboard shortcut for activating a checkbox is the Space key
+    if ((event === null || event === void 0 ? void 0 : event.key) === ' ') handleChange(event);
+  };
+
+  const uniqueId = useUniqueId('checkbox');
+  const inputId = id ?? uniqueId;
+  return /*#__PURE__*/_jsx(View, {
+    style: staticStyles.wrapper,
+    ref: ref,
+    children: /*#__PURE__*/_jsxs(StackView, {
+      direction: feedbackPosition === 'top' ? 'column-reverse' : 'column',
+      space: 0,
+      children: [/*#__PURE__*/_jsx(Pressable, {
+        disabled: inactive,
+        onKeyDown: handleKeyDown,
+        onPress: handleChange,
+        accessibilityRole: "checkbox",
+        accessibilityState: {
+          checked: isChecked,
+          disabled: inactive
+        },
+        ...selectProps(rest),
+        children: ({
+          focused: focus,
+          hovered: hover,
+          pressed
+        }) => {
+          const {
+            icon: IconComponent,
+            ...stateTokens
+          } = getTokens({
+            focus,
+            hover,
+            pressed
+          });
+          const iconTokens = selectIconTokens(stateTokens);
+          return /*#__PURE__*/_jsxs(View, {
+            style: staticStyles.container,
+            children: [/*#__PURE__*/_jsxs(View, {
+              style: StyleSheet.flatten([staticStyles.defaultInputStyles, selectInputStyles(stateTokens, isChecked)]),
+              testID: "Checkbox-Input",
+              children: [/*#__PURE__*/_jsx(CheckboxInput, {
+                checked: isChecked,
+                defaultChecked: defaultChecked,
+                disabled: inactive,
+                id: inputId,
+                isControlled: isControlled,
+                name: name,
+                value: value
+              }), isChecked && IconComponent && /*#__PURE__*/_jsx(IconComponent, { ...iconTokens,
+                testID: "Checkbox-Icon"
+              })]
+            }), Boolean(label) && /*#__PURE__*/_jsx(Text, {
+              style: selectLabelStyles(stateTokens),
+              children: /*#__PURE__*/_jsx(CheckboxLabel, {
+                forId: inputId,
+                children: label
+              })
+            })]
+          });
+        }
+      }), Boolean(feedback) && /*#__PURE__*/_jsx(View, {
+        style: styles.feedbackContainer,
+        children: /*#__PURE__*/_jsx(Feedback, {
+          title: feedback,
+          variant: {
+            icon: error === true
+          },
+          validation: error === true ? 'error' : undefined
+        })
+      })]
+    })
+  });
+});
+Checkbox.displayName = 'Checkbox';
+Checkbox.propTypes = { ...selectedSystemPropTypes,
+
+  /**
+   * 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'
+  }
+});