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

package/lib/utils/children.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapStringsInText = exports.unpackFragment = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _Text = _interopRequireDefault(require("react-native-web/dist/cjs/exports/Text"));
+
+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; }
+
+/**
+ * Unpacks top-level fragments, so that common compositional patterns such as the following examples
+ * can be iterated as flat siblings (as if they were `<Child1 /><Child2 /><Child3 />`):
+ *
+ * - Setting `children` as a property wrapped in a fragment:
+ *
+ * ```jsx
+ * args.children = <><Child1 /><Child2 /><Child3 /></>
+ * ```
+ *
+ * - Defining `children` as a variable wrapped in a fragment:
+ *
+ * ```jsx
+ * const content = <><Child1 /><Child2 /><Child3 /></>
+ * if (someCondition) return <SomeWrapper>{content}</SomeWrapper>
+ * ```
+ *
+ * - Using fragments at the top level of a JSX block for conditional rendering:
+ *
+ * ```jsx
+ * <Child1 />
+ * {someCondition && (
+ *   <>
+ *     <Child2 />
+ *     <Child3 />
+ *   </>
+ * )}
+ * ```
+ *
+ * @param {ReactChildren} child
+ * @returns {ReactChildren}
+ */
+const unpackFragment = child => {
+  var _child$props;
+
+  // If this level is a set of top-level siblings rather than one child, check each in turn
+  if (_react.Children.count(child) > 1) return _react.Children.map(child, unpackFragment); // When a fragment is found, unpack its children to the top level and check them
+
+  if ((child === null || child === void 0 ? void 0 : child.type) === _react.Fragment) return unpackFragment((_child$props = child.props) === null || _child$props === void 0 ? void 0 : _child$props.children); // Stop unpacking as soon as any non-fragment child is found
+
+  return child;
+};
+/**
+ * React Native on Native crashes if text content is rendered outside `<Text>`, and on web,
+ * text style inheritance isn't as expected.
+ *
+ * Call this function on children that may contain text (strings or numbers) at the top level,
+ * and any that are found will be wrapped in a React Native `<Text>` element with supplied props.
+ *
+ * Note that this does not wrap strings that are nested children of the top level children:
+ * `wrapStringsInText(<View>Some text</View>)` will not wrap the inner text and will still crash,
+ * but `wrapStringsInText(<>{someString}{anotherString}</>)` will wrap the strings in the fragment.
+ *
+ * @param {ReactChildren} children
+ * @param {TextProps} props
+ * @returns {ReactChildren}
+ */
+
+
+exports.unpackFragment = unpackFragment;
+
+const wrapStringsInText = (children, props = {}) => {
+  return _react.Children.map(unpackFragment(children), child => typeof child === 'string' || typeof child === 'number' ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_Text.default, { ...props,
+    children: child
+  }) : child);
+};
+
+exports.wrapStringsInText = wrapStringsInText;

package/lib/utils/index.js

@@ -1,4 +1,163 @@
-export * from './animation';
-export * from './input';
-export * from './propTypes';
-export * from './spacing';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  info: true,
+  useCopy: true,
+  useHash: true,
+  useSpacingScale: true,
+  useResponsiveProp: true,
+  useUniqueId: true
+};
+Object.defineProperty(exports, "info", {
+  enumerable: true,
+  get: function () {
+    return _info.default;
+  }
+});
+Object.defineProperty(exports, "useCopy", {
+  enumerable: true,
+  get: function () {
+    return _useCopy.default;
+  }
+});
+Object.defineProperty(exports, "useHash", {
+  enumerable: true,
+  get: function () {
+    return _useHash.default;
+  }
+});
+Object.defineProperty(exports, "useSpacingScale", {
+  enumerable: true,
+  get: function () {
+    return _useSpacingScale.default;
+  }
+});
+Object.defineProperty(exports, "useResponsiveProp", {
+  enumerable: true,
+  get: function () {
+    return _useResponsiveProp.default;
+  }
+});
+Object.defineProperty(exports, "useUniqueId", {
+  enumerable: true,
+  get: function () {
+    return _useUniqueId.default;
+  }
+});
+
+var _a11y = require("./a11y");
+
+Object.keys(_a11y).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _a11y[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _a11y[key];
+    }
+  });
+});
+
+var _animation = require("./animation");
+
+Object.keys(_animation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _animation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _animation[key];
+    }
+  });
+});
+
+var _children = require("./children");
+
+Object.keys(_children).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _children[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _children[key];
+    }
+  });
+});
+
+var _input = require("./input");
+
+Object.keys(_input).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _input[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _input[key];
+    }
+  });
+});
+
+var _pressability = require("./pressability");
+
+Object.keys(_pressability).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _pressability[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pressability[key];
+    }
+  });
+});
+
+var _propTypes = require("./propTypes");
+
+Object.keys(_propTypes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _propTypes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _propTypes[key];
+    }
+  });
+});
+
+var _info = _interopRequireDefault(require("./info"));
+
+var _useCopy = _interopRequireDefault(require("./useCopy"));
+
+var _useHash = _interopRequireDefault(require("./useHash"));
+
+var _useSpacingScale = _interopRequireDefault(require("./useSpacingScale"));
+
+var _useResponsiveProp = _interopRequireWildcard(require("./useResponsiveProp"));
+
+Object.keys(_useResponsiveProp).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useResponsiveProp[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useResponsiveProp[key];
+    }
+  });
+});
+
+var _useUniqueId = _interopRequireDefault(require("./useUniqueId"));
+
+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 }; }

package/lib/utils/info/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _platform = _interopRequireDefault(require("./platform"));
+
+var _versions = _interopRequireDefault(require("./versions"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// export an object accessed like info.platform.OS, info.version.uds, etc
+var _default = {
+  platform: _platform.default,
+  versions: _versions.default
+};
+exports.default = _default;

package/lib/utils/info/platform/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _Platform = _interopRequireDefault(require("react-native-web/dist/cjs/exports/Platform"));
+
+var _platform = _interopRequireDefault(require("./platform"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Allows consuming libraries that might not have a direct dependency on
+// React Native to check what the current platform is.
+// Particularly useful for validating Jest config: it is possible for Jest to
+// get configured such that Platform.OS returns a different mocked value to the
+// OS being used to select files by platform suffix (e.g. .web, .native).
+var _default = {
+  OS: _Platform.default.OS,
+  fileSuffix: _platform.default
+};
+exports.default = _default;

package/lib/utils/info/platform/platform.android.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = '.android';
+exports.default = _default;

package/lib/utils/info/platform/platform.ios.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = '.ios';
+exports.default = _default;

package/lib/utils/info/platform/platform.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = '.web (default)';
+exports.default = _default;

package/lib/utils/info/platform/platform.native.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// This shouldn't ever be chosen, as the more specific '.ios' and '.android' are available.
+// If this gets picked, either an unsupported React Native platform is being used somehow
+// (e.g. a native Windows app), or there's a serious config problem somewhere.
+var _default = '.native';
+exports.default = _default;

package/lib/utils/info/versions.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _package = _interopRequireDefault(require("../../../package.json"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Add more versions if they are useful e.g. theme schema version
+var _default = {
+  uds: _package.default.version
+};
+exports.default = _default;

package/lib/utils/input.js

@@ -1,4 +1,12 @@
-import { useCallback, useState } from 'react';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useMultipleInputValues = exports.useInputValue = void 0;
+
+var _react = require("react");
+
 const pluralHooks = ['useMultipleInputValues'];
 
 const validateProps = ({
@@ -15,29 +23,23 @@ const validateProps = ({
   const usageError = error => {
     // Errors inside hooks in React Native get incomplete stack traces pointing at parent component only.
     // Help devs out by telling them exactly which hook threw the error as well as why.
-    throw new Error(`${hookName} ${error}.
-
-Consumers of this hook must be one of:
-1. An "uncontrolled" component responding directly to user actions, with an optional \`initialValue${s}\` but no \`value${s}\` prop,
-2. A "controlled" component where an always-defined \`value${s}\` prop is managed by an \`onChange\` handler, with no \`initialValue${s}\`,
-3. A "read-only" component, with \`readOnly\` prop set as \`true\`.
-`);
+    throw new Error("".concat(hookName, " ").concat(error, ".\n\nConsumers of this hook must be one of:\n1. An \"uncontrolled\" component responding directly to user actions, with an optional `initialValue").concat(s, "` but no `value").concat(s, "` prop,\n2. A \"controlled\" component where an always-defined `value").concat(s, "` prop is managed by an `onChange` handler, with no `initialValue").concat(s, "`,\n3. A \"read-only\" component, with `readOnly` prop set as `true`.\n"));
   };
 
   if (value && !onChange && !readOnly) {
-    usageError(`has \`value${s}\` prop without \`onChange\` or \`readOnly\``);
+    usageError("has `value".concat(s, "` prop without `onChange` or `readOnly`"));
   }
 
   if (initialValue && value) {
-    usageError(`has both \`initialValue${s}\` and \`value${s}\``);
+    usageError("has both `initialValue".concat(s, "` and `value").concat(s, "`"));
   }
 
   if (isControlled && !isCurrentlyControlled) {
-    usageError(`stopped receiving \`value${s}\` from parent after delegating state management`);
+    usageError("stopped receiving `value".concat(s, "` from parent after delegating state management"));
   }
 
   if (!isControlled && isCurrentlyControlled) {
-    usageError(`started receiving \`value${s}\` from parent after starting managing own state`);
+    usageError("started receiving `value".concat(s, "` from parent after starting managing own state"));
   }
 };
 /**
@@ -49,24 +51,27 @@ Consumers of this hook must be one of:
  * management tools such as Formik and React Hooks Form.
  *
  * @param {object} props
- * @param {any} [props.value] - for a controlled input, the active values as set by a parent
- * @param {any} [props.initialValue] - for an uncontrolled input, the default active values
+ * @param {string|number|null} [props.value] - for a controlled input, the active values as set by a parent
+ * @param {string|number} [props.initialValue] - for an uncontrolled input, the default active values
  * @param {function} [props.onChange] - function called when values change (required for controlled inputs)
  * @param {boolean} [props.readOnly] - if true, stops the input values from changing
  *
  * @param {string} hookName - optional, used for tailoring error messages
  *
+ * @typedef {(oldValue: string|number|null) => string|number|null} UpdaterFunction - `setValue` takes a value or
+ *          a function returning a new value from the old value
  * @returns {{
- *   currentValue: any
- *   setValue: (value: any) => void
+ *   currentValue: string|number|null
+ *   setValue: (newValue: string|number|null|UpdaterFunction) => void
  *   resetValue: () => void
+ *   isControlled: bool
  * }}
  */
 
 
-export const useInputValue = (props = {}, hookName = 'useInputValue') => {
+const useInputValue = (props = {}, hookName = 'useInputValue') => {
   const isCurrentlyControlled = props.value !== undefined;
-  const [isControlled] = useState(isCurrentlyControlled);
+  const [isControlled] = (0, _react.useState)(isCurrentlyControlled);
   validateProps(props, {
     isControlled,
     isCurrentlyControlled
@@ -77,21 +82,29 @@ export const useInputValue = (props = {}, hookName = 'useInputValue') => {
     onChange,
     readOnly = false
   } = props;
-  const [ownValue, setOwnValue] = useState(!isControlled && initialValue);
+  const [ownValue, setOwnValue] = (0, _react.useState)(!isControlled && initialValue);
   const currentValue = isControlled ? value : ownValue; // Store the first valid value, for resetting input to default. If behaviour like Formik's `enableReinitialize`
   // is needed, add useEffect calling a set fn if !deepEqual(initializedValues, initialValues)
 
-  const [initializedValue] = useState(currentValue);
-  const setValue = useCallback(newValue => {
+  const valueRef = (0, _react.useRef)({
+    initial: currentValue,
+    value: currentValue
+  }); // Make current value accessible inside useCallback without rememoizing every time the value changes
+
+  valueRef.current.value = currentValue;
+  const setValue = (0, _react.useCallback)(arg => {
     if (readOnly) return;
-    if (onChange) onChange(newValue);
+    const newValue = typeof arg === 'function' ? arg(valueRef.current.value) : arg; // Only call onChange if the value actually changed
+
+    if (onChange && valueRef.current.value !== newValue) onChange(newValue);
     if (!isControlled) setOwnValue(newValue);
   }, [isControlled, onChange, readOnly]);
-  const resetValue = useCallback(() => setValue(initializedValue), [initializedValue, setValue]);
+  const resetValue = (0, _react.useCallback)(() => setValue(valueRef.current.initial), [setValue]);
   return {
     currentValue,
     setValue,
-    resetValue
+    resetValue,
+    isControlled
   };
 };
 /**
@@ -103,24 +116,29 @@ export const useInputValue = (props = {}, hookName = 'useInputValue') => {
  * management tools such as Formik and React Hooks Form.
  *
  * @param {object} props
- * @param {any[]} [props.values] - for a controlled input, the active values as set by a parent
- * @param {any[]} [props.initialValues] - for an uncontrolled input, the default active values
+ * @param {string[]|number[]} [props.values] - for a controlled input, the active values as set by a parent
+ * @param {string[]|number[]} [props.initialValues] - for an uncontrolled input, the default active values
  * @param {number?} [props.maxValues] - maximum number of values that may be selected at once (no limit if null)
  * @param {function} [props.onChange] - function called when values change (required for controlled inputs)
  * @param {boolean} [props.readOnly] - if true, stops the input values from changing
  *
  * @param {string} componentName - optional, used in error messages
  *
+ * @typedef {(oldValues: string[]|number[]) => string[]|number[]} UpdaterFunction - `setValues` takes values or
+ *          a function returning new values from old values
  * @returns {{
  *   currentValues: any
  *   resetValues: () => void
- *   setValues: (newValues: any[]) => void
+ *   setValues: (newValues: string[]|number[]|UpdaterFunction) => void
  *   toggleOneValue: (value: string|number) => void
  *   unsetValues: () => void
  * }}
  */
 
-export const useMultipleInputValues = ({
+
+exports.useInputValue = useInputValue;
+
+const useMultipleInputValues = ({
   values,
   initialValues,
   maxValues,
@@ -136,18 +154,18 @@ export const useMultipleInputValues = ({
     onChange,
     value: values,
     // if we're controlling our own state, always start with an array
-    initialValue: initialValues ?? (values === undefined ? [] : undefined)
+    initialValue: initialValues !== null && initialValues !== void 0 ? initialValues : values === undefined ? [] : undefined
   }, 'useMultipleInputValues');
-  const enforceMaxValues = useCallback(newValues => {
+  const enforceMaxValues = (0, _react.useCallback)(newValues => {
     if (!maxValues) return newValues;
     const excess = newValues.length - maxValues;
     return excess > 0 ? newValues.slice(excess) : newValues;
   }, [maxValues]);
   const currentValues = enforceMaxValues(currentValue);
-  const setValues = useCallback(newValues => setValue(enforceMaxValues(newValues)), [setValue, enforceMaxValues]);
+  const setValues = (0, _react.useCallback)(newValues => setValue(enforceMaxValues(newValues)), [setValue, enforceMaxValues]);
   const resetValues = resetValue;
-  const unsetValues = useCallback(() => setValues([]), [setValues]);
-  const toggleOneValue = useCallback(newValue => {
+  const unsetValues = (0, _react.useCallback)(() => setValues([]), [setValues]);
+  const toggleOneValue = (0, _react.useCallback)(newValue => {
     if (readOnly) return;
     setValues( // This will only work with primitive values (e.g. strings, numbers), swap for .some() and
     // a deepEqual() function if there's any use case for toggling stored objects or arrays.
@@ -160,4 +178,6 @@ export const useMultipleInputValues = ({
     toggleOneValue,
     unsetValues
   };
-};
+};
+
+exports.useMultipleInputValues = useMultipleInputValues;

package/lib/utils/pressability.js

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPressHandlersWithArgs = exports.resolvePressableTokens = exports.resolvePressableState = exports.getCursorStyle = void 0;
+
+var _Platform = _interopRequireDefault(require("react-native-web/dist/cjs/exports/Platform"));
+
+var _StyleSheet = _interopRequireDefault(require("react-native-web/dist/cjs/exports/StyleSheet"));
+
+var _propTypes = require("./propTypes");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * @typedef {import('react').ReactNode} ReactNode
+ */
+// These roles should result in cursor: pointer but don't in current RNW releases
+const shouldUseCursor = ['checkbox', 'radio', 'switch'];
+/**
+ * React Native Web has some built-in logic for applying cursor styles based on accessibility roles;
+ * however, it misses certain cases. This fills in known cases where widely used versions of RNW
+ * fail to apply an expected cursor style.
+ *
+ * @param {object} props
+ * @param {boolean} [props.inactive]
+ * @param {boolean} [props.disabled]
+ * @param {string} [props.accessibilityRole]
+ * @returns
+ */
+
+const getCursorStyle = ({
+  inactive,
+  disabled,
+  accessibilityRole
+}) => {
+  if (_Platform.default.OS !== 'web') return undefined;
+  if (inactive || disabled) return staticStyles.notAllowed;
+  if (shouldUseCursor.includes(accessibilityRole)) return staticStyles.pointer;
+  return undefined; // allows React Native Web's built-in logic to apply
+};
+/**
+ * @typedef {{ pressed: boolean, focused: boolean, hovered?: boolean }} PressableState
+ */
+
+/**
+ * Maps the state object given by the React Native `Pressable` component to the set of
+ * equivalent appearance names used in UDS.
+ *
+ * @param {PressableState} pressableState - state object passed by React Native's `<Pressable>` into
+ *   render functions passed to its `style` or `children` props.
+ * @param {object} [additionalState] - properties specific to the current component,
+ *   such as `inactive`, `selected`, etc.
+ * @returns {object}
+ */
+
+
+exports.getCursorStyle = getCursorStyle;
+
+const resolvePressableState = ({
+  pressed = false,
+  focused = false,
+  hovered = false
+} = {}, additionalState) => ({ ...additionalState,
+  focus: focused,
+  hover: hovered,
+  pressed
+});
+/**
+ * Takes a UDS `tokens` prop and, if it is a function, resolves it based on a state
+ * object passed from the React Native `Pressable` component and optional extra properties.
+ *
+ * @param {object|function} tokens - UDS system tokens prop
+ * @param {PressableState} pressableState - state object passed by React Native's `<Pressable>`
+ * @param {object} [additionalState] - properties specific to the current component
+ * @returns {object} - resolved tokens object
+ */
+
+
+exports.resolvePressableState = resolvePressableState;
+
+const resolvePressableTokens = (tokens, pressableState, additionalState) => {
+  if (typeof tokens !== 'function') return tokens;
+  const udsPressableState = resolvePressableState(pressableState, additionalState);
+  return tokens(udsPressableState);
+};
+
+exports.resolvePressableTokens = resolvePressableTokens;
+
+const staticStyles = _StyleSheet.default.create(_Platform.default.select({
+  web: {
+    notAllowed: {
+      cursor: 'not-allowed'
+    },
+    pointer: {
+      cursor: 'pointer'
+    }
+  },
+  default: {}
+}));
+/**
+ * From an object of props, extracts any platform-appropriate press handler functions and wraps
+ * them in a function that passes in some provided args. Allows components containing a Pressable
+ * to pass in press handlers that are then called with state or values that is otherwise internal.
+ */
+
+
+const getPressHandlersWithArgs = (pressableProps = {}, args = []) => {
+  // Allow handlers to be passed down for blur, hover, focus, pressIn, etc
+  const pressHandlers = Object.fromEntries(Object.entries(_propTypes.pressProps.selectHandlers(pressableProps)).map(([key, handler]) => ({
+    [key]: (...defaultArgs) => {
+      // Pass each handler data on this button and current selection
+      handler(...args, ...defaultArgs);
+    }
+  })));
+  return pressHandlers;
+};
+
+exports.getPressHandlersWithArgs = getPressHandlersWithArgs;