@depup/react-native-web 0.21.2-depup.0

package/dist/cjs/exports/KeyboardAvoidingView/index.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+'use client';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var React = _interopRequireWildcard(require("react"));
+var _View = _interopRequireDefault(require("../View"));
+var _excluded = ["behavior", "contentContainerStyle", "keyboardVerticalOffset"];
+class KeyboardAvoidingView extends React.Component {
+  constructor() {
+    super(...arguments);
+    this.frame = null;
+    this.onLayout = event => {
+      this.frame = event.nativeEvent.layout;
+    };
+  }
+  relativeKeyboardHeight(keyboardFrame) {
+    var frame = this.frame;
+    if (!frame || !keyboardFrame) {
+      return 0;
+    }
+    var keyboardY = keyboardFrame.screenY - (this.props.keyboardVerticalOffset || 0);
+    return Math.max(frame.y + frame.height - keyboardY, 0);
+  }
+  onKeyboardChange(event) {}
+  render() {
+    var _this$props = this.props,
+      behavior = _this$props.behavior,
+      contentContainerStyle = _this$props.contentContainerStyle,
+      keyboardVerticalOffset = _this$props.keyboardVerticalOffset,
+      rest = (0, _objectWithoutPropertiesLoose2.default)(_this$props, _excluded);
+    return /*#__PURE__*/React.createElement(_View.default, (0, _extends2.default)({
+      onLayout: this.onLayout
+    }, rest));
+  }
+}
+var _default = exports.default = KeyboardAvoidingView;
+module.exports = exports.default;

package/dist/cjs/exports/LayoutAnimation/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _LayoutAnimation = _interopRequireDefault(require("../../vendor/react-native/LayoutAnimation"));
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+var _default = exports.default = _LayoutAnimation.default;
+module.exports = exports.default;

package/dist/cjs/exports/Linking/index.js

@@ -0,0 +1,109 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _invariant = _interopRequireDefault(require("fbjs/lib/invariant"));
+var _canUseDom = _interopRequireDefault(require("../../modules/canUseDom"));
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+var initialURL = _canUseDom.default ? window.location.href : '';
+class Linking {
+  constructor() {
+    this._eventCallbacks = {};
+  }
+  /**
+   * An object mapping of event name
+   * and all the callbacks subscribing to it
+   */
+  _dispatchEvent(event) {
+    for (var _len = arguments.length, data = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      data[_key - 1] = arguments[_key];
+    }
+    var listeners = this._eventCallbacks[event];
+    if (listeners != null && Array.isArray(listeners)) {
+      listeners.map(listener => {
+        listener(...data);
+      });
+    }
+  }
+
+  /**
+   * Adds a event listener for the specified event. The callback will be called when the
+   * said event is dispatched.
+   */
+  addEventListener(eventType, callback) {
+    var _this = this;
+    if (!_this._eventCallbacks[eventType]) {
+      _this._eventCallbacks[eventType] = [callback];
+    }
+    _this._eventCallbacks[eventType].push(callback);
+    return {
+      remove() {
+        var callbacks = _this._eventCallbacks[eventType];
+        var filteredCallbacks = callbacks.filter(c => c.toString() !== callback.toString());
+        _this._eventCallbacks[eventType] = filteredCallbacks;
+      }
+    };
+  }
+
+  /**
+   * Removes a previously added event listener for the specified event. The callback must
+   * be the same object as the one passed to `addEventListener`.
+   */
+  removeEventListener(eventType, callback) {
+    console.error("Linking.removeEventListener('" + eventType + "', ...): Method has been " + 'deprecated. Please instead use `remove()` on the subscription ' + 'returned by `Linking.addEventListener`.');
+    var callbacks = this._eventCallbacks[eventType];
+    var filteredCallbacks = callbacks.filter(c => c.toString() !== callback.toString());
+    this._eventCallbacks[eventType] = filteredCallbacks;
+  }
+  canOpenURL() {
+    return Promise.resolve(true);
+  }
+  getInitialURL() {
+    return Promise.resolve(initialURL);
+  }
+
+  /**
+   * Try to open the given url in a secure fashion. The method returns a Promise object.
+   * If a target is passed (including undefined) that target will be used, otherwise '_blank'.
+   * If the url opens, the promise is resolved. If not, the promise is rejected.
+   * Dispatches the `onOpen` event if `url` is opened successfully.
+   */
+  openURL(url, target) {
+    if (arguments.length === 1) {
+      target = '_blank';
+    }
+    try {
+      open(url, target);
+      this._dispatchEvent('onOpen', url);
+      return Promise.resolve();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  _validateURL(url) {
+    (0, _invariant.default)(typeof url === 'string', 'Invalid URL: should be a string. Was: ' + url);
+    (0, _invariant.default)(url, 'Invalid URL: cannot be empty');
+  }
+}
+var open = (url, target) => {
+  if (_canUseDom.default) {
+    var urlToOpen = new URL(url, window.location).toString();
+    if (urlToOpen.indexOf('tel:') === 0) {
+      window.location = urlToOpen;
+    } else {
+      window.open(urlToOpen, target, 'noopener');
+    }
+  }
+};
+var _default = exports.default = new Linking();
+module.exports = exports.default;

package/dist/cjs/exports/LogBox/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+/**
+ * Copyright (c) 2016-present, Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+var LogBox = {
+  ignoreLogs() {},
+  ignoreAllLogs() {},
+  uninstall() {},
+  install() {}
+};
+var _default = exports.default = LogBox;
+module.exports = exports.default;

package/dist/cjs/exports/Modal/ModalAnimation.js

@@ -0,0 +1,149 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _StyleSheet = _interopRequireDefault(require("../StyleSheet"));
+var _createElement = _interopRequireDefault(require("../createElement"));
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+var ANIMATION_DURATION = 250;
+function getAnimationStyle(animationType, visible) {
+  if (animationType === 'slide') {
+    return visible ? animatedSlideInStyles : animatedSlideOutStyles;
+  }
+  if (animationType === 'fade') {
+    return visible ? animatedFadeInStyles : animatedFadeOutStyles;
+  }
+  return visible ? styles.container : styles.hidden;
+}
+function ModalAnimation(props) {
+  var animationType = props.animationType,
+    children = props.children,
+    onDismiss = props.onDismiss,
+    onShow = props.onShow,
+    visible = props.visible;
+  var _React$useState = React.useState(false),
+    isRendering = _React$useState[0],
+    setIsRendering = _React$useState[1];
+  var wasVisible = React.useRef(false);
+  var wasRendering = React.useRef(false);
+  var isAnimated = animationType && animationType !== 'none';
+  var animationEndCallback = React.useCallback(e => {
+    if (e && e.currentTarget !== e.target) {
+      // If the event was generated for something NOT this element we
+      // should ignore it as it's not relevant to us
+      return;
+    }
+    if (visible) {
+      if (onShow) {
+        onShow();
+      }
+    } else {
+      setIsRendering(false);
+    }
+  }, [onShow, visible]);
+  React.useEffect(() => {
+    if (wasRendering.current && !isRendering && onDismiss) {
+      onDismiss();
+    }
+    wasRendering.current = isRendering;
+  }, [isRendering, onDismiss]);
+  React.useEffect(() => {
+    if (visible) {
+      setIsRendering(true);
+    }
+    if (visible !== wasVisible.current && !isAnimated) {
+      // Manually call `animationEndCallback` if no animation is used
+      animationEndCallback();
+    }
+    wasVisible.current = visible;
+  }, [isAnimated, visible, animationEndCallback]);
+  return isRendering || visible ? (0, _createElement.default)('div', {
+    style: isRendering ? getAnimationStyle(animationType, visible) : styles.hidden,
+    onAnimationEnd: animationEndCallback,
+    children
+  }) : null;
+}
+var styles = _StyleSheet.default.create({
+  container: {
+    position: 'fixed',
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    zIndex: 9999
+  },
+  animatedIn: {
+    animationDuration: ANIMATION_DURATION + "ms",
+    animationTimingFunction: 'cubic-bezier(0.215, 0.61, 0.355, 1)'
+  },
+  animatedOut: {
+    pointerEvents: 'none',
+    animationDuration: ANIMATION_DURATION + "ms",
+    animationTimingFunction: 'cubic-bezier(0.47, 0, 0.745, 0.715)'
+  },
+  fadeIn: {
+    opacity: 1,
+    animationKeyframes: {
+      '0%': {
+        opacity: 0
+      },
+      '100%': {
+        opacity: 1
+      }
+    }
+  },
+  fadeOut: {
+    opacity: 0,
+    animationKeyframes: {
+      '0%': {
+        opacity: 1
+      },
+      '100%': {
+        opacity: 0
+      }
+    }
+  },
+  slideIn: {
+    transform: 'translateY(0%)',
+    animationKeyframes: {
+      '0%': {
+        transform: 'translateY(100%)'
+      },
+      '100%': {
+        transform: 'translateY(0%)'
+      }
+    }
+  },
+  slideOut: {
+    transform: 'translateY(100%)',
+    animationKeyframes: {
+      '0%': {
+        transform: 'translateY(0%)'
+      },
+      '100%': {
+        transform: 'translateY(100%)'
+      }
+    }
+  },
+  hidden: {
+    opacity: 0
+  }
+});
+var animatedSlideInStyles = [styles.container, styles.animatedIn, styles.slideIn];
+var animatedSlideOutStyles = [styles.container, styles.animatedOut, styles.slideOut];
+var animatedFadeInStyles = [styles.container, styles.animatedIn, styles.fadeIn];
+var animatedFadeOutStyles = [styles.container, styles.animatedOut, styles.fadeOut];
+var _default = exports.default = ModalAnimation;
+module.exports = exports.default;

package/dist/cjs/exports/Modal/ModalContent.js

@@ -0,0 +1,75 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var React = _interopRequireWildcard(require("react"));
+var _View = _interopRequireDefault(require("../View"));
+var _StyleSheet = _interopRequireDefault(require("../StyleSheet"));
+var _canUseDom = _interopRequireDefault(require("../../modules/canUseDom"));
+var _excluded = ["active", "children", "onRequestClose", "transparent"];
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+var ModalContent = /*#__PURE__*/React.forwardRef((props, forwardedRef) => {
+  var active = props.active,
+    children = props.children,
+    onRequestClose = props.onRequestClose,
+    transparent = props.transparent,
+    rest = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+  React.useEffect(() => {
+    if (_canUseDom.default) {
+      var closeOnEscape = e => {
+        if (active && e.key === 'Escape') {
+          e.stopPropagation();
+          if (onRequestClose) {
+            onRequestClose();
+          }
+        }
+      };
+      document.addEventListener('keyup', closeOnEscape, false);
+      return () => document.removeEventListener('keyup', closeOnEscape, false);
+    }
+  }, [active, onRequestClose]);
+  var style = React.useMemo(() => {
+    return [styles.modal, transparent ? styles.modalTransparent : styles.modalOpaque];
+  }, [transparent]);
+  return /*#__PURE__*/React.createElement(_View.default, (0, _extends2.default)({}, rest, {
+    "aria-modal": true,
+    ref: forwardedRef,
+    role: active ? 'dialog' : null,
+    style: style
+  }), /*#__PURE__*/React.createElement(_View.default, {
+    style: styles.container
+  }, children));
+});
+var styles = _StyleSheet.default.create({
+  modal: {
+    position: 'fixed',
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0
+  },
+  modalTransparent: {
+    backgroundColor: 'transparent'
+  },
+  modalOpaque: {
+    backgroundColor: 'white'
+  },
+  container: {
+    top: 0,
+    flex: 1
+  }
+});
+var _default = exports.default = ModalContent;
+module.exports = exports.default;

package/dist/cjs/exports/Modal/ModalFocusTrap.js

@@ -0,0 +1,138 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _View = _interopRequireDefault(require("../View"));
+var _createElement = _interopRequireDefault(require("../createElement"));
+var _StyleSheet = _interopRequireDefault(require("../StyleSheet"));
+var _UIManager = _interopRequireDefault(require("../UIManager"));
+var _canUseDom = _interopRequireDefault(require("../../modules/canUseDom"));
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+/**
+ * This Component is used to "wrap" the modal we're opening
+ * so that changing focus via tab will never leave the document.
+ *
+ * This allows us to properly trap the focus within a modal
+ * even if the modal is at the start or end of a document.
+ */
+
+var FocusBracket = () => {
+  return (0, _createElement.default)('div', {
+    role: 'none',
+    tabIndex: 0,
+    style: styles.focusBracket
+  });
+};
+function attemptFocus(element) {
+  if (!_canUseDom.default) {
+    return false;
+  }
+  try {
+    element.focus();
+  } catch (e) {
+    // Do nothing
+  }
+  return document.activeElement === element;
+}
+function focusFirstDescendant(element) {
+  for (var i = 0; i < element.childNodes.length; i++) {
+    var child = element.childNodes[i];
+    if (attemptFocus(child) || focusFirstDescendant(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+function focusLastDescendant(element) {
+  for (var i = element.childNodes.length - 1; i >= 0; i--) {
+    var child = element.childNodes[i];
+    if (attemptFocus(child) || focusLastDescendant(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+var ModalFocusTrap = _ref => {
+  var active = _ref.active,
+    children = _ref.children;
+  var trapElementRef = React.useRef();
+  var focusRef = React.useRef({
+    trapFocusInProgress: false,
+    lastFocusedElement: null
+  });
+  React.useEffect(() => {
+    if (_canUseDom.default) {
+      var trapFocus = () => {
+        // We should not trap focus if:
+        // - The modal hasn't fully initialized with an HTMLElement ref
+        // - Focus is already in the process of being trapped (e.g., we're refocusing)
+        // - isTrapActive prop being falsey tells us to do nothing
+        if (trapElementRef.current == null || focusRef.current.trapFocusInProgress || !active) {
+          return;
+        }
+        try {
+          focusRef.current.trapFocusInProgress = true;
+          if (document.activeElement instanceof Node && !trapElementRef.current.contains(document.activeElement)) {
+            // To handle keyboard focusing we can make an assumption here.
+            // If you're tabbing through the focusable elements, the previously
+            // active element will either be the first or the last.
+            // If the previously selected element is the "first" descendant
+            // and we're leaving it - this means that we should be looping
+            // around to the other side of the modal.
+            var hasFocused = focusFirstDescendant(trapElementRef.current);
+            if (focusRef.current.lastFocusedElement === document.activeElement) {
+              hasFocused = focusLastDescendant(trapElementRef.current);
+            }
+            // If we couldn't focus a new element then we need to focus onto the trap target
+            if (!hasFocused && trapElementRef.current != null && document.activeElement) {
+              _UIManager.default.focus(trapElementRef.current);
+            }
+          }
+        } finally {
+          focusRef.current.trapFocusInProgress = false;
+        }
+        focusRef.current.lastFocusedElement = document.activeElement;
+      };
+
+      // Call the trapFocus callback at least once when this modal has been activated.
+      trapFocus();
+      document.addEventListener('focus', trapFocus, true);
+      return () => document.removeEventListener('focus', trapFocus, true);
+    }
+  }, [active]);
+
+  // To be fully compliant with WCAG we need to refocus element that triggered opening modal
+  // after closing it
+  React.useEffect(function () {
+    if (_canUseDom.default) {
+      var lastFocusedElementOutsideTrap = document.activeElement;
+      return function () {
+        if (lastFocusedElementOutsideTrap && document.contains(lastFocusedElementOutsideTrap)) {
+          _UIManager.default.focus(lastFocusedElementOutsideTrap);
+        }
+      };
+    }
+  }, []);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(FocusBracket, null), /*#__PURE__*/React.createElement(_View.default, {
+    ref: trapElementRef
+  }, children), /*#__PURE__*/React.createElement(FocusBracket, null));
+};
+var _default = exports.default = ModalFocusTrap;
+var styles = _StyleSheet.default.create({
+  focusBracket: {
+    outlineStyle: 'none'
+  }
+});
+module.exports = exports.default;

package/dist/cjs/exports/Modal/ModalPortal.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _reactDom = require("react-dom");
+var _canUseDom = _interopRequireDefault(require("../../modules/canUseDom"));
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+function ModalPortal(props) {
+  var children = props.children;
+  var elementRef = React.useRef(null);
+  if (_canUseDom.default && !elementRef.current) {
+    var element = document.createElement('div');
+    if (element && document.body) {
+      document.body.appendChild(element);
+      elementRef.current = element;
+    }
+  }
+  React.useEffect(() => {
+    if (_canUseDom.default) {
+      return () => {
+        if (document.body && elementRef.current) {
+          document.body.removeChild(elementRef.current);
+          elementRef.current = null;
+        }
+      };
+    }
+  }, []);
+  return elementRef.current && _canUseDom.default ? /*#__PURE__*/(0, _reactDom.createPortal)(children, elementRef.current) : null;
+}
+var _default = exports.default = ModalPortal;
+module.exports = exports.default;