yeet

node_modules/react-native-web/dist/exports/Image/index.js

@@ -0,0 +1,388 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+import createElement from '../createElement';
+import css from '../StyleSheet/css';
+import { getAssetByID } from '../../modules/AssetRegistry';
+import resolveShadowValue from '../StyleSheet/resolveShadowValue';
+import ImageLoader from '../../modules/ImageLoader';
+import PixelRatio from '../PixelRatio';
+import StyleSheet from '../StyleSheet';
+import TextAncestorContext from '../Text/TextAncestorContext';
+import View from '../View';
+import React, { forwardRef, useContext, useEffect, useRef, useState } from 'react';
+var ERRORED = 'ERRORED';
+var LOADED = 'LOADED';
+var LOADING = 'LOADING';
+var IDLE = 'IDLE';
+var _filterId = 0;
+var svgDataUriPattern = /^(data:image\/svg\+xml;utf8,)(.*)/;
+
+function createTintColorSVG(tintColor, id) {
+  return tintColor && id != null ? React.createElement("svg", {
+    style: {
+      position: 'absolute',
+      height: 0,
+      visibility: 'hidden',
+      width: 0
+    }
+  }, React.createElement("defs", null, React.createElement("filter", {
+    id: "tint-" + id,
+    suppressHydrationWarning: true
+  }, React.createElement("feFlood", {
+    floodColor: "" + tintColor,
+    key: tintColor
+  }), React.createElement("feComposite", {
+    in2: "SourceAlpha",
+    operator: "atop"
+  })))) : null;
+}
+
+function getFlatStyle(style, blurRadius, filterId) {
+  var flatStyle = _objectSpread({}, StyleSheet.flatten(style));
+
+  var filter = flatStyle.filter,
+      resizeMode = flatStyle.resizeMode,
+      shadowOffset = flatStyle.shadowOffset,
+      tintColor = flatStyle.tintColor; // Add CSS filters
+  // React Native exposes these features as props and proprietary styles
+
+  var filters = [];
+  var _filter = null;
+
+  if (filter) {
+    filters.push(filter);
+  } //
+
+
+  if (blurRadius) {
+    filters.push("blur(" + blurRadius + "px)");
+  }
+
+  if (shadowOffset) {
+    var shadowString = resolveShadowValue(flatStyle);
+
+    if (shadowString) {
+      filters.push("drop-shadow(" + shadowString + ")");
+    }
+  }
+
+  if (tintColor && filterId != null) {
+    filters.push("url(#tint-" + filterId + ")");
+  }
+
+  if (filters.length > 0) {
+    _filter = filters.join(' ');
+  } // These styles are converted to CSS filters applied to the
+  // element displaying the background image.
+
+
+  delete flatStyle.shadowColor;
+  delete flatStyle.shadowOpacity;
+  delete flatStyle.shadowOffset;
+  delete flatStyle.shadowRadius;
+  delete flatStyle.tintColor; // These styles are not supported on View
+
+  delete flatStyle.overlayColor;
+  delete flatStyle.resizeMode;
+  return [flatStyle, resizeMode, _filter, tintColor];
+}
+
+function resolveAssetDimensions(source) {
+  if (typeof source === 'number') {
+    var _getAssetByID = getAssetByID(source),
+        height = _getAssetByID.height,
+        width = _getAssetByID.width;
+
+    return {
+      height: height,
+      width: width
+    };
+  } else if (source != null && !Array.isArray(source) && typeof source === 'object') {
+    var _height = source.height,
+        _width = source.width;
+    return {
+      height: _height,
+      width: _width
+    };
+  }
+}
+
+function resolveAssetUri(source) {
+  var uri = null;
+
+  if (typeof source === 'number') {
+    // get the URI from the packager
+    var asset = getAssetByID(source);
+    var scale = asset.scales[0];
+
+    if (asset.scales.length > 1) {
+      var preferredScale = PixelRatio.get(); // Get the scale which is closest to the preferred scale
+
+      scale = asset.scales.reduce(function (prev, curr) {
+        return Math.abs(curr - preferredScale) < Math.abs(prev - preferredScale) ? curr : prev;
+      });
+    }
+
+    var scaleSuffix = scale !== 1 ? "@" + scale + "x" : '';
+    uri = asset ? asset.httpServerLocation + "/" + asset.name + scaleSuffix + "." + asset.type : '';
+  } else if (typeof source === 'string') {
+    uri = source;
+  } else if (source && typeof source.uri === 'string') {
+    uri = source.uri;
+  }
+
+  if (uri) {
+    var match = uri.match(svgDataUriPattern); // inline SVG markup may contain characters (e.g., #, ") that need to be escaped
+
+    if (match) {
+      var prefix = match[1],
+          svg = match[2];
+      var encodedSvg = encodeURIComponent(svg);
+      return "" + prefix + encodedSvg;
+    }
+  }
+
+  return uri;
+}
+
+var Image = forwardRef(function (props, ref) {
+  var accessibilityLabel = props.accessibilityLabel,
+      blurRadius = props.blurRadius,
+      defaultSource = props.defaultSource,
+      draggable = props.draggable,
+      onError = props.onError,
+      onLayout = props.onLayout,
+      onLoad = props.onLoad,
+      onLoadEnd = props.onLoadEnd,
+      onLoadStart = props.onLoadStart,
+      pointerEvents = props.pointerEvents,
+      source = props.source,
+      style = props.style,
+      rest = _objectWithoutPropertiesLoose(props, ["accessibilityLabel", "blurRadius", "defaultSource", "draggable", "onError", "onLayout", "onLoad", "onLoadEnd", "onLoadStart", "pointerEvents", "source", "style"]);
+
+  if (process.env.NODE_ENV !== 'production') {
+    if (props.children) {
+      throw new Error('The <Image> component cannot contain children. If you want to render content on top of the image, consider using the <ImageBackground> component or absolute positioning.');
+    }
+  }
+
+  var _useState = useState(function () {
+    var uri = resolveAssetUri(source);
+
+    if (uri != null) {
+      var isLoaded = ImageLoader.has(uri);
+
+      if (isLoaded) {
+        return LOADED;
+      }
+    }
+
+    return IDLE;
+  }),
+      state = _useState[0],
+      updateState = _useState[1];
+
+  var _useState2 = useState({}),
+      layout = _useState2[0],
+      updateLayout = _useState2[1];
+
+  var hasTextAncestor = useContext(TextAncestorContext);
+  var hiddenImageRef = useRef(null);
+  var filterRef = useRef(_filterId++);
+  var requestRef = useRef(null);
+  var shouldDisplaySource = state === LOADED || state === LOADING && defaultSource == null;
+
+  var _getFlatStyle = getFlatStyle(style, blurRadius, filterRef.current),
+      flatStyle = _getFlatStyle[0],
+      _resizeMode = _getFlatStyle[1],
+      filter = _getFlatStyle[2],
+      tintColor = _getFlatStyle[3];
+
+  var resizeMode = props.resizeMode || _resizeMode || 'cover';
+  var selectedSource = shouldDisplaySource ? source : defaultSource;
+  var displayImageUri = resolveAssetUri(selectedSource);
+  var imageSizeStyle = resolveAssetDimensions(selectedSource);
+  var backgroundImage = displayImageUri ? "url(\"" + displayImageUri + "\")" : null;
+  var backgroundSize = getBackgroundSize(); // Accessibility image allows users to trigger the browser's image context menu
+
+  var hiddenImage = displayImageUri ? createElement('img', {
+    alt: accessibilityLabel || '',
+    classList: [classes.accessibilityImage],
+    draggable: draggable || false,
+    ref: hiddenImageRef,
+    src: displayImageUri
+  }) : null;
+
+  function getBackgroundSize() {
+    if (hiddenImageRef.current != null && (resizeMode === 'center' || resizeMode === 'repeat')) {
+      var _hiddenImageRef$curre = hiddenImageRef.current,
+          naturalHeight = _hiddenImageRef$curre.naturalHeight,
+          naturalWidth = _hiddenImageRef$curre.naturalWidth;
+      var height = layout.height,
+          width = layout.width;
+
+      if (naturalHeight && naturalWidth && height && width) {
+        var scaleFactor = Math.min(1, width / naturalWidth, height / naturalHeight);
+        var x = Math.ceil(scaleFactor * naturalWidth);
+        var y = Math.ceil(scaleFactor * naturalHeight);
+        return x + "px " + y + "px";
+      }
+    }
+  }
+
+  function handleLayout(e) {
+    if (resizeMode === 'center' || resizeMode === 'repeat' || onLayout) {
+      var _layout = e.nativeEvent.layout;
+      onLayout && onLayout(e);
+      updateLayout(_layout);
+    }
+  } // Image loading
+
+
+  useEffect(function () {
+    abortPendingRequest();
+    var uri = resolveAssetUri(source);
+
+    if (uri != null) {
+      updateState(LOADING);
+
+      if (onLoadStart) {
+        onLoadStart();
+      }
+
+      requestRef.current = ImageLoader.load(uri, function load(e) {
+        updateState(LOADED);
+
+        if (onLoad) {
+          onLoad(e);
+        }
+
+        if (onLoadEnd) {
+          onLoadEnd();
+        }
+      }, function error() {
+        updateState(ERRORED);
+
+        if (onError) {
+          onError({
+            nativeEvent: {
+              error: "Failed to load resource " + uri + " (404)"
+            }
+          });
+        }
+
+        if (onLoadEnd) {
+          onLoadEnd();
+        }
+      });
+    }
+
+    function abortPendingRequest() {
+      if (requestRef.current != null) {
+        ImageLoader.abort(requestRef.current);
+        requestRef.current = null;
+      }
+    }
+
+    return abortPendingRequest;
+  }, [source, requestRef, updateState, onError, onLoad, onLoadEnd, onLoadStart]);
+  return React.createElement(View, _extends({}, rest, {
+    accessibilityLabel: accessibilityLabel,
+    onLayout: handleLayout,
+    pointerEvents: pointerEvents,
+    ref: ref,
+    style: [styles.root, hasTextAncestor && styles.inline, imageSizeStyle, flatStyle]
+  }), React.createElement(View, {
+    style: [styles.image, resizeModeStyles[resizeMode], {
+      backgroundImage: backgroundImage,
+      filter: filter
+    }, backgroundSize != null && {
+      backgroundSize: backgroundSize
+    }],
+    suppressHydrationWarning: true
+  }), hiddenImage, createTintColorSVG(tintColor, filterRef.current));
+});
+Image.displayName = 'Image'; // $FlowFixMe
+
+Image.getSize = function (uri, success, failure) {
+  ImageLoader.getSize(uri, success, failure);
+}; // $FlowFixMe
+
+
+Image.prefetch = function (uri) {
+  return ImageLoader.prefetch(uri);
+}; // $FlowFixMe
+
+
+Image.queryCache = function (uris) {
+  return ImageLoader.queryCache(uris);
+};
+
+var classes = css.create({
+  accessibilityImage: _objectSpread({}, StyleSheet.absoluteFillObject, {
+    height: '100%',
+    opacity: 0,
+    width: '100%',
+    zIndex: -1
+  })
+});
+var styles = StyleSheet.create({
+  root: {
+    flexBasis: 'auto',
+    overflow: 'hidden',
+    zIndex: 0
+  },
+  inline: {
+    display: 'inline-flex'
+  },
+  image: _objectSpread({}, StyleSheet.absoluteFillObject, {
+    backgroundColor: 'transparent',
+    backgroundPosition: 'center',
+    backgroundRepeat: 'no-repeat',
+    backgroundSize: 'cover',
+    height: '100%',
+    width: '100%',
+    zIndex: -1
+  })
+});
+var resizeModeStyles = StyleSheet.create({
+  center: {
+    backgroundSize: 'auto'
+  },
+  contain: {
+    backgroundSize: 'contain'
+  },
+  cover: {
+    backgroundSize: 'cover'
+  },
+  none: {
+    backgroundPosition: '0 0',
+    backgroundSize: 'auto'
+  },
+  repeat: {
+    backgroundPosition: '0 0',
+    backgroundRepeat: 'repeat',
+    backgroundSize: 'auto'
+  },
+  stretch: {
+    backgroundSize: '100% 100%'
+  }
+});
+export default Image;