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

package/lib/utils/a11y/semantics.js

@@ -0,0 +1,173 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getA11yPropsFromHtmlTag = exports.getHeadingLevel = exports.textTags = exports.layoutTags = exports.supportedTags = exports.headingTags = exports.tagsToRoles = void 0;
+
+var _Platform = _interopRequireDefault(require("react-native-web/dist/cjs/exports/Platform"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * @typedef {import('react-native').AccessibilityRole} AccessibilityRole
+ */
+
+/**
+ * This is based on the role-to-tag mapping that React Native Web uses to set HTML tags.
+ * It's not exported in any way from RNW, so we need to keep this up-to-date manually.
+ * https://github.com/necolas/react-native-web/blob/master/packages/react-native-web/src/modules/AccessibilityUtil/propsToAccessibilityComponent.js
+ *
+ * Note: every role in this list is a web-only aria-role. There is no overlap between _these_ web tags
+ * or roles and native accessibilityRoles. Only h1, h2, h3 etc map to an RN equivalent ("heading").
+ *
+ * - RN "summary" native role maps to "region" aria-role, but setting `<section>`/"region" does not
+ *   set React Native's "summary" role, which has a much narrower use case.
+ * - `<Header>`/"Banner" also do not map to RN's "heading". Only h1 / h2 etc map to RN "heading".
+ *
+ * Therefore, all of these tags / roles default to no accessibilityRole in native apps. This is not wrong:
+ * in general, RN accessibilityRoles tend to be more about interaction and less about semantics than web roles.
+ *
+ * RNW's one-way mapping of React Native accessibilityRoles to web aria-roles:
+ * https://github.com/necolas/react-native-web/blob/master/packages/react-native-web/src/modules/AccessibilityUtil/propsToAriaRole.js
+ */
+// Adding `/** @type {const} */ ({...})` denotes object content as `readonly` in many IDEs
+// eslint-disable-next-line prettier/prettier
+const rolesToTags =
+/** @type {const} */
+{
+  article: 'article',
+  banner: 'header',
+  blockquote: 'blockquote',
+  code: 'code',
+  complementary: 'aside',
+  contentinfo: 'footer',
+  deletion: 'del',
+  emphasis: 'em',
+  figure: 'figure',
+  insertion: 'ins',
+  form: 'form',
+  list: 'ul',
+  listitem: 'li',
+  main: 'main',
+  navigation: 'nav',
+  region: 'section',
+  strong: 'strong',
+  // Add special cases that are in RNW's function logic but not in its mapping object
+  label: 'label' // eslint-disable-next-line prettier/prettier
+
+}; // Invert React Native Web's mapping, so a tag gets the role that gets that tag
+
+const tagsToRoles = Object.fromEntries(Object.entries(rolesToTags).map(([key, value]) => [value, key]));
+/**
+ * Heading HTML tags map to the "heading" accessibilityRole in native apps, which is similar
+ * to headings on web but without the expectation of a hierarchy of headings within one screen.
+ */
+// eslint-disable-next-line prettier/prettier
+
+exports.tagsToRoles = tagsToRoles;
+const headingTags =
+/** @type {const} */
+['h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
+/**
+ * @typedef {typeof headingTags[number]} HeadingTag
+ */
+
+/**
+ * All HTML tags that may be set via RNW accesibility props alone and therefore may be set using
+ * the getA11yPropsFromHtmlTag function without changing other behaviour.
+ *
+ * Of these, only headers (h1, h2, ...h5, h6) set a corresponding accessibilityRole in native apps ("heading").
+ */
+
+exports.headingTags = headingTags;
+const supportedTags = [...Object.keys(tagsToRoles), ...headingTags];
+/**
+ * Uses readonly mapping keys/values to generate static types for IDEs that support TS in JSDoc.
+ * @typedef {keyof rolesToTags} RoleWithTag
+ * @typedef {typeof rolesToTags[RoleWithTag] | typeof headingTags[number]} SupportedTag
+ */
+
+/**
+ * Subset of supported HTML tags that may be used with layout containers like Box.
+ *
+ * Of these, only headers (h1, h2, ...h5, h6) set a corresponding accessibilityRole in native apps ("heading").
+ */
+// eslint-disable-next-line prettier/prettier
+
+exports.supportedTags = supportedTags;
+const layoutTags =
+/** @type {const} */
+[...headingTags, 'article', 'aside', 'blockquote', 'footer', 'figure', 'form', 'header', 'ul', 'li', 'main', 'nav', 'section', 'label' // eslint-disable-next-line prettier/prettier
+];
+/**
+ * @typedef {typeof layoutTags[number]} LayoutTag
+ */
+
+/**
+ * Subset of supported HTML tags that may be used with text elements like Typography.
+ *
+ * Of these, only headers (h1, h2, ...h5, h6) set a corresponding accessibilityRole in native apps ("heading").
+ */
+// eslint-disable-next-line prettier/prettier
+
+exports.layoutTags = layoutTags;
+const textTags =
+/** @type {const} */
+[...headingTags, 'blockquote', 'code', 'del', 'em', 'ins', 'li', 'strong', 'label' // eslint-disable-next-line prettier/prettier
+];
+/**
+ * @typedef {typeof layoutTags[number]} TextTag
+ */
+
+/**
+ * If passed a heading tag string like 'h1', 'h2' etc, returns the heading number as a number
+ * ready for use in `accessibilityLevel` props and similar.
+ *
+ * @param {string} [tag] - HTML tag string; returns undefined if not a {@link HeadingTag}
+ * @returns {'1' | '2' | '3' | '4' | '5' | '6' | undefined}
+ */
+
+exports.textTags = textTags;
+
+const getHeadingLevel = tag => headingTags.includes(tag) ? Number(tag[1]) : undefined;
+/**
+ * Takes a supported HTML tag, and returns the accessibility props that, on web, make React Native Web
+ * render that tag.
+ *
+ * For cross-platform apps, a second argument may be passed with an [accessibilityRole](https://reactnative.dev/docs/accessibility#accessibilityrole)
+ * to use in native apps. Heading tags (h1, h2, ...h5, h6) map to "heading" role by default;
+ * no other supported semantic HTML tags have an equivalent native accessibilityRole.
+ *
+ * @param {SupportedTag} tag - HTML tag to use on web
+ * @param {AccessibilityRole | null} [nativeRole] - optional accessibilityRole for native apps
+ * @returns {{ accessibilityRole: string, accessibilityLevel?: string } | undefined}
+ */
+
+
+exports.getHeadingLevel = getHeadingLevel;
+
+const getA11yPropsFromHtmlTag = (tag, nativeRole) => {
+  // Allow cross-platform apps to set accessibilityRoles alongside a web tag without conflict
+  if (nativeRole !== undefined && _Platform.default.OS !== 'web') return {
+    accessibilityRole: nativeRole
+  };
+
+  if (tag) {
+    const accessibilityRole = tagsToRoles[tag];
+    if (accessibilityRole) return {
+      accessibilityRole
+    };
+    const accessibilityLevel = getHeadingLevel(tag);
+    if (accessibilityLevel) return {
+      accessibilityRole: 'header',
+      accessibilityLevel
+    };
+  } // If nothing matches or no tag supplied, return undefined and let component decide how to fall back.
+  // Note that return value may always be spread in objects (it is safe to spread undefined like { ...undefined })
+
+
+  return undefined;
+};
+
+exports.getA11yPropsFromHtmlTag = getA11yPropsFromHtmlTag;

package/lib/utils/a11y/textSize.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getMaxFontMultiplier = exports.scaleWithText = void 0;
+
+var _PixelRatio = _interopRequireDefault(require("react-native-web/dist/cjs/exports/PixelRatio"));
+
+var _Platform = _interopRequireDefault(require("react-native-web/dist/cjs/exports/Platform"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * When a user increases text size using device accessibility settings, some elements
+ * should also scale, such as icons alongside text and space between paragraphs.
+ *
+ * @param {number} [value] - the value to multiply; defaults to system default font size
+ * @param {number} [maxScale] - the maximum multiplier to apply; defaults to no maximum
+ */
+const scaleWithText = (value, maxScale = Infinity) => {
+  if (!value) return value;
+  const scale = Math.min(_PixelRatio.default.getFontScale(), maxScale) || 1;
+  return value * scale;
+};
+/**
+ * Native only, returns `undefined` on Web.
+ *
+ * Enforces `fontScaleCap` theme tokens as the maximum font size text can become
+ * after iOS or Android font scaling, to give consistent accessible maximum sizes
+ * that don't make the content unusable.
+ *
+ * The return value of this function can be used as a React Native `Text` element's
+ * `maxFontSizeMultiplier` prop value.
+ */
+
+
+exports.scaleWithText = scaleWithText;
+
+const getMaxFontMultiplier = ({
+  fontSize,
+  fontScaleCap
+}) => {
+  if (_Platform.default.OS === 'web' || !fontScaleCap || !fontSize) return undefined;
+  if (fontScaleCap <= fontSize) return 1;
+  return fontScaleCap / fontSize;
+};
+
+exports.getMaxFontMultiplier = getMaxFontMultiplier;

package/lib/utils/animation/index.js

@@ -1,2 +1,15 @@
-/* eslint-disable import/prefer-default-export */
-export { default as useVerticalExpandAnimation } from './useVerticalExpandAnimation';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useVerticalExpandAnimation", {
+  enumerable: true,
+  get: function () {
+    return _useVerticalExpandAnimation.default;
+  }
+});
+
+var _useVerticalExpandAnimation = _interopRequireDefault(require("./useVerticalExpandAnimation"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib/utils/animation/useVerticalExpandAnimation.js

@@ -1,34 +1,50 @@
-import { useEffect, useRef } from 'react';
-import { Animated, Easing, Platform } from 'react-native'; // TODO: systematise animations
-// https://github.com/telus/universal-design-system/issues/487
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = require("react");
+
+var _Animated = _interopRequireDefault(require("react-native-web/dist/cjs/exports/Animated"));
+
+var _Easing = _interopRequireDefault(require("react-native-web/dist/cjs/exports/Easing"));
 
+var _Platform = _interopRequireDefault(require("react-native-web/dist/cjs/exports/Platform"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// TODO: systematise animations
+// https://github.com/telus/universal-design-system/issues/487
 function useVerticalExpandAnimation({
   containerHeight,
   isExpanded,
   tokens
 }) {
-  const expandAnimatedValue = useRef(new Animated.Value(0)).current;
+  const expandAnimatedValue = (0, _react.useRef)(new _Animated.default.Value(0)).current;
   const {
     expandDuration,
     collapseDuration
   } = tokens;
-  useEffect(() => {
-    if (Platform.OS === 'web') {
+  (0, _react.useEffect)(() => {
+    if (_Platform.default.OS === 'web') {
       return;
     }
 
     const animationConfig = {
       duration: isExpanded ? expandDuration : collapseDuration,
-      easing: Easing.inOut(Easing.ease),
+      easing: _Easing.default.inOut(_Easing.default.ease),
       toValue: isExpanded ? containerHeight : 0,
       useNativeDriver: false
     };
-    Animated.timing(expandAnimatedValue, animationConfig).start();
+
+    _Animated.default.timing(expandAnimatedValue, animationConfig).start();
   }, [isExpanded, expandAnimatedValue, containerHeight, expandDuration, collapseDuration]);
   let containerStyles; // don't visually collapse the container until we have it measured
 
   if (containerHeight !== null) {
-    if (Platform.OS === 'web') {
+    if (_Platform.default.OS === 'web') {
       const transitionDuration = isExpanded ? expandDuration : collapseDuration;
       containerStyles = {
         transition: `height ${transitionDuration}ms ease-in-out`,
@@ -44,4 +60,5 @@ function useVerticalExpandAnimation({
   return containerStyles;
 }
 
-export default useVerticalExpandAnimation;
+var _default = useVerticalExpandAnimation;
+exports.default = _default;

package/lib/utils/children.js

@@ -0,0 +1,134 @@
+"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 _A11yText = _interopRequireDefault(require("../A11yText"));
+
+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;
+};
+
+exports.unpackFragment = unpackFragment;
+
+const isStringOrNumber = child => typeof child === 'string' || typeof child === 'number'; // Wrap an A11yText with neighouring text strings so it doesn't split them into multiple <Text>s
+
+
+const isWrapable = child => isStringOrNumber(child) || child.type === _A11yText.default;
+
+const combineKeys = childrenArray => childrenArray.reduce((newKey, child) => `${newKey}${child.key || ''}`, ''); // Group wrappable children for one `<Text>` parent, merging adjacent text nodes
+
+
+const wrapChild = (child, wrappedText) => {
+  const lastIndex = wrappedText.length - 1; // If possible, simplify content by combining text nodes into one string.
+  // jest-native's `.toHaveTextContent` is buggy about array of text nodes in <Text> elements.
+
+  if (lastIndex >= 0 && isStringOrNumber(child) && isStringOrNumber(wrappedText[lastIndex])) {
+    /* eslint-disable-next-line no-param-reassign */
+    wrappedText[lastIndex] = `${wrappedText[lastIndex]}${child}`;
+  } else {
+    wrappedText.push(child);
+  }
+};
+/**
+ * React Native on Native crashes if text content is rendered outside `<Text>`, and on web,
+ * text style inheritance behaves differently with text compared to regular HTML.
+ *
+ * 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 rendered top level children:
+ * `wrapStringsInText(<View>Some text</View>)` will not wrap the inner text and will still crash,
+ * but `wrapStringsInText(<>{someString}{anotherString}</>)` wraps the strings inside the fragment.
+ *
+ * @param {ReactChildren} children
+ * @param {TextProps} props
+ * @returns {ReactChildren}
+ */
+
+
+const wrapStringsInText = (children, textProps = {}) => {
+  const childrenArray = unpackFragment(_react.Children.toArray(children)); // Group adjacent wrapable children together in one Text element to create as few Text elements
+  // as possible, e.g. give <X>Text {someString}</X> one Text, same as <X>{`Text ${someString}`}</X>
+
+  const wrapables = [[]];
+  let wrapablesIndex = 0;
+  childrenArray.forEach(child => {
+    if (isWrapable(child)) {
+      // Make this child a child of the current `Text`
+      wrapChild(child, wrapables[wrapablesIndex]);
+    } else {
+      // Close current `Text` and start a new one after this child
+      wrapables.push(child, []);
+      wrapablesIndex += 2;
+    }
+  });
+  const items = wrapables.reduce((flatChildren, group, index) => {
+    // Skip nullish children and empty arrays
+    if (!group || Array.isArray(group) && !group.length) return flatChildren;
+    return [...flatChildren, Array.isArray(group) && group.some(child => isStringOrNumber(child)) ?
+    /*#__PURE__*/
+    // Wrap text nodes and their wrappable neighbours in Text with as stable a key as possible.
+    // Avoid one-item arrays because jest-native's `.toHaveTextContent` is buggy
+    // and sometimes fails to match text content in arrays.
+    (0, _jsxRuntime.jsx)(_Text.default, { ...textProps,
+      children: group.length === 1 ? group[0] : group
+    }, combineKeys(group) || index) : group];
+  }, []);
+  return items.length === 1 ? items[0] : items;
+};
+
+exports.wrapStringsInText = wrapStringsInText;

package/lib/utils/index.js

@@ -1,7 +1,163 @@
-export * from './animation';
-export * from './input';
-export * from './propTypes';
-export { default as useSpacingScale } from './useSpacingScale';
-export { default as useResponsiveProp } from './useResponsiveProp';
-export * from './useResponsiveProp';
-export { default as useUniqueId } from './useUniqueId';
+"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;