@atlaskit/media-card 77.6.4 → 77.6.6

package/dist/cjs/card/v2/useFilePreview/helpers.js

@@ -1,64 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isBigger = exports.createRequestDimensions = void 0;
-exports.useCurrentValueRef = useCurrentValueRef;
-exports.usePrevious = usePrevious;
-var _react = require("react");
-/**
- * Checks if at least one of next dimensions is bigger than current
- * If a single dimension is undefined, returns false
- */
-var isBigger = exports.isBigger = function isBigger(current, next) {
-  var _ref = current || {},
-    currentWidth = _ref.width,
-    currentHeight = _ref.height;
-  var _ref2 = next || {},
-    nextWidth = _ref2.width,
-    nextHeight = _ref2.height;
-  if (!!currentWidth && !!currentHeight && !!nextWidth && !!nextHeight) {
-    var nextIsWider = currentWidth < nextWidth;
-    var nextIsHigher = currentHeight < nextHeight;
-    return nextIsHigher || nextIsWider;
-  } else {
-    return false;
-  }
-};
-
-/** Verifies if the current screen is retina display */
-function isRetina() {
-  var mediaQuery = '(-webkit-min-device-pixel-ratio: 1.5), (min--moz-device-pixel-ratio: 1.5), (-o-min-device-pixel-ratio: 3/2), (min-resolution: 1.5dppx)';
-  return window.devicePixelRatio > 1 || window.matchMedia && window.matchMedia(mediaQuery).matches;
-}
-var createRequestDimensions = exports.createRequestDimensions = function createRequestDimensions(dimensions) {
-  if (!dimensions) {
-    return;
-  }
-  var retinaFactor = isRetina() ? 2 : 1;
-  var width = dimensions.width,
-    height = dimensions.height;
-  var result = {};
-  if (width) {
-    result.width = width * retinaFactor;
-  }
-  if (height) {
-    result.height = height * retinaFactor;
-  }
-  return result;
-};
-
-/** Stores the provided value in a ref object to avoid "component rerenders" when the value is used as a hook dependency */
-function useCurrentValueRef(value) {
-  var ref = (0, _react.useRef)(value);
-  ref.current = value;
-  return ref;
-}
-function usePrevious(value) {
-  var ref = (0, _react.useRef)();
-  (0, _react.useEffect)(function () {
-    ref.current = value;
-  }, [value]);
-  return ref.current;
-}

package/dist/cjs/card/v2/useFilePreview/index.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "useFilePreview", {
-  enumerable: true,
-  get: function get() {
-    return _useFilePreview.useFilePreview;
-  }
-});
-var _useFilePreview = require("./useFilePreview");

package/dist/cjs/card/v2/useFilePreview/types.js

@@ -1,5 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});

package/dist/cjs/card/v2/useFilePreview/useFilePreview.js

@@ -1,460 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useFilePreview = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _mediaClient = require("@atlaskit/media-client");
-var _mediaClientReact = require("@atlaskit/media-client-react");
-var _mediaCommon = require("@atlaskit/media-common");
-var _react = require("react");
-var _errors = require("./errors");
-var _analytics = require("./analytics");
-var _helpers = require("./helpers");
-var _globalScope = require("./globalScope");
-var _getPreview = require("./getPreview");
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var useFilePreview = exports.useFilePreview = function useFilePreview(_ref) {
-  var _ref$resizeMode = _ref.resizeMode,
-    resizeMode = _ref$resizeMode === void 0 ? 'crop' : _ref$resizeMode,
-    identifier = _ref.identifier,
-    ssr = _ref.ssr,
-    dimensions = _ref.dimensions,
-    traceContext = _ref.traceContext,
-    previewDidRender = _ref.previewDidRender,
-    skipRemote = _ref.skipRemote,
-    mediaBlobUrlAttrs = _ref.mediaBlobUrlAttrs;
-  var mediaClient = (0, _mediaClientReact.useMediaClient)();
-  var _useState = (0, _react.useState)('loading'),
-    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
-    status = _useState2[0],
-    setStatus = _useState2[1];
-  var _useState3 = (0, _react.useState)(),
-    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
-    error = _useState4[0],
-    setError = _useState4[1];
-  var _useState5 = (0, _react.useState)(),
-    _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
-    nonCriticalError = _useState6[0],
-    setNonCriticalError = _useState6[1];
-  var _useState7 = (0, _react.useState)(false),
-    _useState8 = (0, _slicedToArray2.default)(_useState7, 2),
-    isBannedLocalPreview = _useState8[0],
-    setIsBannedLocalPreview = _useState8[1];
-  var wasResolvedUpfrontPreviewRef = (0, _react.useRef)(false);
-  var ssrReliabilityRef = (0, _react.useRef)(initialSsrReliability);
-  var requestDimensions = (0, _react.useMemo)(function () {
-    return dimensions ? (0, _helpers.createRequestDimensions)(dimensions) : undefined;
-  }, [dimensions]);
-  var requestDimensionsRef = (0, _helpers.useCurrentValueRef)(requestDimensions);
-  var prevRequestDimensions = (0, _helpers.usePrevious)(requestDimensions);
-  var imageURLParams = (0, _react.useMemo)(function () {
-    return _objectSpread(_objectSpread({
-      collection: identifier.collectionName,
-      mode: resizeMode === 'stretchy-fit' ? 'full-fit' : resizeMode
-    }, requestDimensions), {}, {
-      allowAnimated: true
-    });
-  }, [requestDimensions, identifier.collectionName, resizeMode]);
-  var previewInitializer = function previewInitializer() {
-    var fileImageMode = (0, _mediaClient.imageResizeModeToFileImageMode)(resizeMode);
-    var preview = _getPreview.mediaFilePreviewCache.get(identifier.id, fileImageMode);
-    if (preview) {
-      return preview;
-    }
-    if (ssr) {
-      var ssrData = (0, _globalScope.getSSRData)(identifier);
-      if (ssrData !== null && ssrData !== void 0 && ssrData.error) {
-        ssrReliabilityRef.current.server = _objectSpread({
-          status: 'fail'
-        }, ssrData.error);
-      }
-      if (!(ssrData !== null && ssrData !== void 0 && ssrData.dataURI)) {
-        try {
-          return (0, _getPreview.getSSRPreview)(ssr, mediaClient, identifier.id, imageURLParams, mediaBlobUrlAttrs);
-        } catch (e) {
-          ssrReliabilityRef.current[ssr] = _objectSpread({
-            status: 'fail'
-          }, (0, _analytics.extractErrorInfo)(e));
-        }
-      } else {
-        var _dimensions = ssrData.dimensions,
-          dataURI = ssrData.dataURI;
-        return {
-          dataURI: dataURI,
-          dimensions: _dimensions,
-          source: 'ssr-data'
-        };
-      }
-    }
-  };
-  var _useState9 = (0, _react.useState)(previewInitializer),
-    _useState10 = (0, _slicedToArray2.default)(_useState9, 2),
-    preview = _useState10[0],
-    setPreview = _useState10[1];
-  var prevPreview = (0, _helpers.usePrevious)(preview);
-  var _useFileState = (0, _mediaClientReact.useFileState)(identifier.id, {
-      skipRemote: skipRemote,
-      collectionName: identifier.collectionName,
-      occurrenceKey: identifier.occurrenceKey
-    }),
-    fileState = _useFileState.fileState;
-
-  //----------------------------------------------------------------
-  // Update status
-  //----------------------------------------------------------------
-
-  // TOOD: make a full hook reset (remount) on New identifier or client
-  (0, _react.useEffect)(function () {
-    setStatus('loading');
-  }, [identifier]);
-  var updateFileStateRef = (0, _helpers.useCurrentValueRef)(function () {
-    if (fileState) {
-      // do not update the status if the status is final
-      if (['complete', 'error', 'failed-processing'].includes(status)) {
-        return;
-      }
-      if (fileState.status !== 'error') {
-        var mediaType = 'mediaType' in fileState ? fileState.mediaType : undefined;
-        var isPreviewable = !!mediaType && ['audio', 'video', 'image', 'doc'].indexOf(mediaType) > -1;
-        var isPreviewableFileState = !!fileState.preview;
-        var isSupportedLocalPreview = mediaType === 'image' || mediaType === 'video';
-        var hasLocalPreview = !isBannedLocalPreview && isPreviewableFileState && isSupportedLocalPreview && !!fileState.mimeType && (0, _mediaCommon.isMimeTypeSupportedByBrowser)(fileState.mimeType);
-        var hasRemotePreview = (0, _mediaClient.isImageRepresentationReady)(fileState);
-        var hasPreview = hasLocalPreview || hasRemotePreview;
-        var newStatus;
-        switch (fileState.status) {
-          case 'uploading':
-          case 'failed-processing':
-          case 'processing':
-            newStatus = fileState.status;
-            break;
-          case 'processed':
-            if (!isPreviewable || !hasPreview) {
-              newStatus = 'complete';
-              break;
-            }
-            newStatus = 'loading-preview';
-            break;
-          default:
-            newStatus = 'loading';
-        }
-        setStatus(newStatus);
-      } else {
-        var e = new _mediaClientReact.MediaFileStateError(fileState.id, fileState.reason, fileState.message, fileState.details);
-        var errorReason = status === 'uploading' ? 'upload' : 'metadata-fetch';
-        setError(new _errors.MediaFilePreviewError(errorReason, e));
-        setStatus('error');
-      }
-    }
-  });
-  (0, _react.useEffect)(function () {
-    updateFileStateRef.current();
-  }, [fileState, updateFileStateRef]);
-  (0, _react.useEffect)(function () {
-    if (previewDidRender &&
-    // We should't complete if status is uploading
-    ['loading-preview', 'processing'].includes(status)) {
-      setStatus('complete');
-      // TODO MEX-788: add test for "do not remove the preview when unsubscribing".
-      setIsBannedLocalPreview(false); // CXP-2723 TODO: we might be able to remove this??
-    }
-  }, [previewDidRender, status]);
-
-  // CXP-2723 TODO: Create test cases for banning local preview after status is complete
-
-  //----------------------------------------------------------------
-  // Preview Fetch Helper
-  //----------------------------------------------------------------
-  var getAndCacheRemotePreviewRef = (0, _helpers.useCurrentValueRef)(function () {
-    return (0, _getPreview.getAndCacheRemotePreview)(mediaClient, identifier.id, requestDimensions || {}, imageURLParams, mediaBlobUrlAttrs, traceContext);
-  });
-
-  //----------------------------------------------------------------
-  // Cache SSR Preview
-  //----------------------------------------------------------------
-  (0, _react.useEffect)(function () {
-    if (!skipRemote && ssr && !!preview && (0, _getPreview.isSSRClientPreview)(preview)) {
-      // Since the SSR preview brings the token in the query params,
-      // We need to fetch the remote preview to be able to cache it,
-      getAndCacheRemotePreviewRef.current().catch(function () {
-        // No need to log this error.
-        // If preview fails, it will be refetched later
-        //TODO: test this catch
-        // https://product-fabric.atlassian.net/browse/MEX-1071
-      });
-    }
-  }, [preview, identifier, skipRemote, ssr, getAndCacheRemotePreviewRef]);
-
-  //----------------------------------------------------------------
-  // Refetch SRR Preview if dimensions from Server have changed and are bigger,
-  //----------------------------------------------------------------
-  (0, _react.useEffect)(function () {
-    // CXP-2813 TODO: This is called too many times if the refetch failed. Should be called only once
-    if (preview && !skipRemote && (0, _getPreview.isSSRDataPreview)(preview) && (0, _helpers.isBigger)(preview.dimensions, requestDimensions)) {
-      getAndCacheRemotePreviewRef.current().then(setPreview).catch(function (e) {
-        var wrappedError = (0, _errors.ensureMediaFilePreviewError)('remote-preview-fetch-ssr', e, true);
-        setNonCriticalError(wrappedError);
-      });
-    }
-  }, [getAndCacheRemotePreviewRef, identifier, preview, requestDimensions, skipRemote]);
-
-  //----------------------------------------------------------------
-  // Upfront Preview
-  //----------------------------------------------------------------
-  (0, _react.useEffect)(function () {
-    var resolveUpfrontPreview = /*#__PURE__*/function () {
-      var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
-        var fetchedDimensions, newPreview, areValidFetchedDimensions;
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              // We block any possible future call to this method regardless of the outcome (success or fail)
-              // If it fails, the normal preview fetch should occur after the file state is fetched anyways
-              wasResolvedUpfrontPreviewRef.current = true;
-              _context.prev = 1;
-              fetchedDimensions = _objectSpread({}, requestDimensions);
-              _context.next = 5;
-              return getAndCacheRemotePreviewRef.current();
-            case 5:
-              newPreview = _context.sent;
-              areValidFetchedDimensions = !(0, _helpers.isBigger)(fetchedDimensions, requestDimensionsRef.current); // If there are new and bigger dimensions in the props, and the upfront preview is still resolving,
-              // the fetched preview is no longer valid, and thus, we dismiss it
-              if (areValidFetchedDimensions) {
-                setPreview(newPreview);
-              }
-              _context.next = 12;
-              break;
-            case 10:
-              _context.prev = 10;
-              _context.t0 = _context["catch"](1);
-            case 12:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, null, [[1, 10]]);
-      }));
-      return function resolveUpfrontPreview() {
-        return _ref2.apply(this, arguments);
-      };
-    }();
-
-    // CXP-2723 TODO: `hadSSRPreview` is most likely redundant
-    var hadSSRPreview = ssr === 'client' && !!prevPreview && (0, _getPreview.isSSRClientPreview)(prevPreview);
-    if (!preview && !wasResolvedUpfrontPreviewRef.current && (!skipRemote || hadSSRPreview)) {
-      resolveUpfrontPreview();
-    }
-  }, [preview, requestDimensions, requestDimensionsRef, getAndCacheRemotePreviewRef, identifier, skipRemote, prevPreview, ssr]);
-
-  //----------------------------------------------------------------
-  // Fetch Preview
-  //----------------------------------------------------------------
-
-  var resolvePreviewRef = (0, _helpers.useCurrentValueRef)( /*#__PURE__*/function () {
-    var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(identifier, fileState) {
-      var filePreview, isRemotePreviewReady, mode, cachedPreview, dimensionsAreBigger, localPreview, remotePreview, wrappedError;
-      return _regenerator.default.wrap(function _callee2$(_context2) {
-        while (1) switch (_context2.prev = _context2.next) {
-          case 0:
-            filePreview = isBannedLocalPreview ? undefined : fileState.status !== 'error' && 'mimeType' in fileState && (0, _mediaCommon.isMimeTypeSupportedByBrowser)(fileState.mimeType) ? fileState.preview : undefined;
-            isRemotePreviewReady = (0, _mediaClient.isImageRepresentationReady)(fileState);
-            _context2.prev = 2;
-            mode = imageURLParams.mode;
-            cachedPreview = _getPreview.mediaFilePreviewCache.get(identifier.id, mode);
-            dimensionsAreBigger = (0, _helpers.isBigger)(cachedPreview === null || cachedPreview === void 0 ? void 0 : cachedPreview.dimensions, requestDimensions);
-            if (!(cachedPreview && !dimensionsAreBigger)) {
-              _context2.next = 8;
-              break;
-            }
-            return _context2.abrupt("return", cachedPreview);
-          case 8:
-            _context2.prev = 8;
-            if (!filePreview) {
-              _context2.next = 15;
-              break;
-            }
-            _context2.next = 12;
-            return (0, _getPreview.getAndCacheLocalPreview)(identifier.id, filePreview, requestDimensions || {}, mode, mediaBlobUrlAttrs);
-          case 12:
-            localPreview = _context2.sent;
-            setPreview(localPreview);
-            return _context2.abrupt("return");
-          case 15:
-            _context2.next = 22;
-            break;
-          case 17:
-            _context2.prev = 17;
-            _context2.t0 = _context2["catch"](8);
-            /**
-             * We report the error if:
-             * - local preview is supported and fails
-             * - local preview is unsupported and remote preview is NOT READY
-             *   i.e. the function was called for "no reason".
-             * We DON'T report the error if:
-             * - local preview is unsupported and remote preview IS READY
-             *   i.e. local preview is available and not supported,
-             *   but we are after the remote preview instead.
-             */
-            if (!(0, _errors.isUnsupportedLocalPreviewError)(_context2.t0) || (0, _errors.isUnsupportedLocalPreviewError)(_context2.t0) && !isRemotePreviewReady) {
-              // CXP-2723 TODO: We might have to wrap this error in MediaCardError
-              setNonCriticalError(_context2.t0);
-            }
-            /**
-             * No matter the reason why the local preview failed, we break the process
-             * if there is no remote preview available
-             */
-            if (isRemotePreviewReady) {
-              _context2.next = 22;
-              break;
-            }
-            throw _context2.t0;
-          case 22:
-            if (isRemotePreviewReady) {
-              _context2.next = 24;
-              break;
-            }
-            throw new _errors.MediaFilePreviewError('remote-preview-not-ready');
-          case 24:
-            _context2.next = 26;
-            return getAndCacheRemotePreviewRef.current();
-          case 26:
-            remotePreview = _context2.sent;
-            setPreview(remotePreview);
-            return _context2.abrupt("return");
-          case 31:
-            _context2.prev = 31;
-            _context2.t1 = _context2["catch"](2);
-            wrappedError = (0, _errors.ensureMediaFilePreviewError)('preview-fetch', _context2.t1); //  If remote preview fails, we set status 'error'
-            //  If local preview fails (i.e, no remote preview available),
-            //  we can stay in the same status until there is a remote preview available
-            //  If it's any other error we set status 'error'
-            if ((0, _errors.isLocalPreviewError)(wrappedError)) {
-              // This error should already been logged inside the getCardPreview. No need to log it here.
-              setIsBannedLocalPreview(true);
-            } else {
-              if (!['complete', 'error', 'failed-processing'].includes(status)) {
-                setStatus('error');
-                setError(wrappedError);
-              }
-            }
-          case 35:
-          case "end":
-            return _context2.stop();
-        }
-      }, _callee2, null, [[2, 31], [8, 17]]);
-    }));
-    return function (_x, _x2) {
-      return _ref3.apply(this, arguments);
-    };
-  }());
-  (0, _react.useEffect)(function () {
-    if (fileState && wasResolvedUpfrontPreviewRef.current && (0, _getPreview.isPreviewableStatus)(status, (0, _getPreview.extractFilePreviewStatus)(fileState, isBannedLocalPreview)) && (!preview || (0, _helpers.isBigger)(prevRequestDimensions, requestDimensions))) {
-      resolvePreviewRef.current(identifier, fileState);
-    }
-  }, [fileState, identifier, isBannedLocalPreview, prevRequestDimensions, preview, requestDimensions, resolvePreviewRef, status]);
-
-  //----------------------------------------------------------------
-  // RETURN
-  //----------------------------------------------------------------
-
-  var onImageError = (0, _react.useCallback)(function (newPreview) {
-    if (newPreview) {
-      var failedSSRObject = _objectSpread({
-        status: 'fail'
-      }, (0, _analytics.extractErrorInfo)(new _errors.ImageLoadError(newPreview.source)));
-      if ((0, _getPreview.isSSRClientPreview)(newPreview)) {
-        ssrReliabilityRef.current.client = failedSSRObject;
-      }
-
-      /*
-      If the preview failed and it comes from server (global scope / ssrData), it means that we have reused it in client and the error counts for both: server & client.
-      */
-
-      if ((0, _getPreview.isSSRDataPreview)(newPreview)) {
-        ssrReliabilityRef.current.server = failedSSRObject;
-        ssrReliabilityRef.current.client = failedSSRObject;
-      }
-    }
-
-    // If the dataURI has been replaced, we can dismiss this error
-    if ((newPreview === null || newPreview === void 0 ? void 0 : newPreview.dataURI) !== (preview === null || preview === void 0 ? void 0 : preview.dataURI)) {
-      return;
-    }
-    var error = new _errors.ImageLoadError(newPreview === null || newPreview === void 0 ? void 0 : newPreview.source);
-    var isLocal = newPreview && (0, _getPreview.isLocalPreview)(newPreview);
-    var isSSR = newPreview && ((0, _getPreview.isSSRClientPreview)(newPreview) || (0, _getPreview.isSSRDataPreview)(newPreview));
-    if (isLocal || isSSR) {
-      if (isLocal) {
-        setIsBannedLocalPreview(true);
-        setNonCriticalError(error);
-      }
-      var fileImageMode = (0, _mediaClient.imageResizeModeToFileImageMode)(resizeMode);
-      _getPreview.mediaFilePreviewCache.remove(identifier.id, fileImageMode);
-      setPreview(undefined);
-    } else {
-      if (!['complete', 'error', 'failed-processing'].includes(status)) {
-        setStatus('error');
-        setError(error);
-      }
-    }
-  }, [identifier.id, preview === null || preview === void 0 ? void 0 : preview.dataURI, resizeMode, status]);
-  var onImageLoad = (0, _react.useCallback)(function (newPreview) {
-    if (newPreview) {
-      if ((0, _getPreview.isSSRClientPreview)(newPreview) && ssrReliabilityRef.current.client.status === 'unknown') {
-        ssrReliabilityRef.current.client = {
-          status: 'success'
-        };
-      }
-
-      /*
-      If the image loads successfully and it comes from server (global scope / ssrData), it means that we have reused it in client and the success counts for both: server & client.
-      */
-
-      if ((0, _getPreview.isSSRDataPreview)(newPreview) && ssrReliabilityRef.current.server.status === 'unknown') {
-        ssrReliabilityRef.current.server = {
-          status: 'success'
-        };
-        ssrReliabilityRef.current.client = {
-          status: 'success'
-        };
-      }
-    }
-
-    // If the dataURI has been replaced, we can dismiss this callback
-    if ((newPreview === null || newPreview === void 0 ? void 0 : newPreview.dataURI) !== (preview === null || preview === void 0 ? void 0 : preview.dataURI)) {
-      return;
-    }
-  }, [preview === null || preview === void 0 ? void 0 : preview.dataURI]);
-
-  // FOR SSR
-  var getScriptProps = function getScriptProps() {
-    var _ssrReliabilityRef$cu;
-    return (0, _globalScope.generateScriptProps)(identifier, preview === null || preview === void 0 ? void 0 : preview.dataURI, requestDimensions, ((_ssrReliabilityRef$cu = ssrReliabilityRef.current.server) === null || _ssrReliabilityRef$cu === void 0 ? void 0 : _ssrReliabilityRef$cu.status) === 'fail' ? ssrReliabilityRef.current.server : undefined);
-  };
-
-  // CXP-2723 TODO: should consider simplifying our analytics, and how
-  // we might get rid of ssrReliabiltyRef from our hook
-  return {
-    preview: preview,
-    error: error,
-    nonCriticalError: nonCriticalError,
-    ssrReliabilityRef: ssrReliabilityRef,
-    onImageError: onImageError,
-    onImageLoad: onImageLoad,
-    getScriptProps: getScriptProps
-  };
-};
-var initialSsrReliability = {
-  server: {
-    status: 'unknown'
-  },
-  client: {
-    status: 'unknown'
-  }
-};

package/dist/es2019/card/v2/useFilePreview/analytics.js

@@ -1,44 +0,0 @@
-import { getMediaClientErrorReason, isRequestError } from '@atlaskit/media-client';
-import { isMediaFilePreviewError, getFileStateErrorReason, isMediaFileStateError } from './errors';
-export const getErrorTraceContext = error => {
-  if (isMediaFilePreviewError(error) && !!error.secondaryError) {
-    if (isRequestError(error.secondaryError)) {
-      var _error$secondaryError;
-      return (_error$secondaryError = error.secondaryError.metadata) === null || _error$secondaryError === void 0 ? void 0 : _error$secondaryError.traceContext;
-    } else if (isMediaFileStateError(error.secondaryError)) {
-      var _error$secondaryError2, _error$secondaryError3;
-      return (_error$secondaryError2 = error.secondaryError.details) === null || _error$secondaryError2 === void 0 ? void 0 : (_error$secondaryError3 = _error$secondaryError2.metadata) === null || _error$secondaryError3 === void 0 ? void 0 : _error$secondaryError3.traceContext;
-    }
-  }
-};
-export const getRenderErrorFailReason = error => {
-  if (isMediaFilePreviewError(error)) {
-    return error.primaryReason;
-  } else {
-    return 'nativeError';
-  }
-};
-export const getRenderErrorErrorReason = error => {
-  if (isMediaFilePreviewError(error) && error.secondaryError) {
-    const mediaClientReason = isMediaFileStateError(error.secondaryError) ? getFileStateErrorReason(error.secondaryError) : getMediaClientErrorReason(error.secondaryError);
-    if (mediaClientReason !== 'unknown') {
-      return mediaClientReason;
-    }
-  }
-  return 'nativeError';
-};
-export const getRenderErrorErrorDetail = error => {
-  if (isMediaFilePreviewError(error) && error.secondaryError) {
-    return error.secondaryError.message;
-  } else {
-    return error.message;
-  }
-};
-export const extractErrorInfo = (error, metadataTraceContext) => {
-  return {
-    failReason: getRenderErrorFailReason(error),
-    error: getRenderErrorErrorReason(error),
-    errorDetail: getRenderErrorErrorDetail(error),
-    metadataTraceContext: metadataTraceContext !== null && metadataTraceContext !== void 0 ? metadataTraceContext : getErrorTraceContext(error)
-  };
-};

package/dist/es2019/card/v2/useFilePreview/errors.js

@@ -1,90 +0,0 @@
-import { MediaFileStateError } from '@atlaskit/media-client-react';
-
-/**
- * Primary reason is logged through Data Portal.
- * Make sure all the values are whitelisted in Measure -> Event Regitry -> "mediaCardRender failed" event
- */
-
-export class MediaFilePreviewError extends Error {
-  constructor(primaryReason, secondaryError) {
-    super(primaryReason);
-    // https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#support-for-newtarget
-    this.primaryReason = primaryReason;
-    this.secondaryError = secondaryError;
-    Object.setPrototypeOf(this, new.target.prototype);
-
-    // https://v8.dev/docs/stack-trace-api
-    if ('captureStackTrace' in Error) {
-      Error.captureStackTrace(this, new.target);
-    }
-  }
-}
-export class LocalPreviewError extends MediaFilePreviewError {
-  constructor(primaryReason, secondaryError) {
-    super(primaryReason, secondaryError);
-    this.primaryReason = primaryReason;
-    this.secondaryError = secondaryError;
-  }
-}
-export class RemotePreviewError extends MediaFilePreviewError {
-  constructor(primaryReason, secondaryError) {
-    super(primaryReason, secondaryError);
-    this.primaryReason = primaryReason;
-    this.secondaryError = secondaryError;
-  }
-}
-export class SsrPreviewError extends MediaFilePreviewError {
-  constructor(primaryReason, secondaryError) {
-    super(primaryReason, secondaryError);
-    this.primaryReason = primaryReason;
-    this.secondaryError = secondaryError;
-  }
-}
-const getImageLoadPrimaryReason = source => {
-  switch (source) {
-    case 'cache-remote':
-      return 'cache-remote-uri';
-    case 'cache-local':
-      return 'cache-local-uri';
-    case 'external':
-      return 'external-uri';
-    case 'local':
-      return 'local-uri';
-    case 'remote':
-      return 'remote-uri';
-    // This fail reason will come from a bug, most likely.
-    default:
-      return `unknown-uri`;
-  }
-};
-export class ImageLoadError extends MediaFilePreviewError {
-  constructor(source) {
-    super(getImageLoadPrimaryReason(source));
-  }
-}
-export function isMediaFilePreviewError(err) {
-  return err instanceof MediaFilePreviewError;
-}
-export const isLocalPreviewError = err => err instanceof LocalPreviewError;
-export const isRemotePreviewError = err => err instanceof RemotePreviewError;
-export const isUnsupportedLocalPreviewError = err => isMediaFilePreviewError(err) && err.primaryReason === 'local-preview-unsupported';
-
-// In a try/catch statement, the error caught is the type of unknown.
-// We can use this helper to ensure that the error handled is the type of MediaFilePreviewError if unsure
-// If updatePrimaryReason is true, if it's a MediaFilePreviewError already, it will update it's primary reason
-export const ensureMediaFilePreviewError = (primaryReason, error, updatePrimaryReason) => {
-  if (isMediaFilePreviewError(error)) {
-    if (updatePrimaryReason && error.primaryReason !== primaryReason) {
-      return new MediaFilePreviewError(primaryReason, error.secondaryError);
-    }
-    return error;
-  }
-  return new MediaFilePreviewError(primaryReason, error);
-};
-export function isMediaFileStateError(err) {
-  return err instanceof MediaFileStateError;
-}
-export function getFileStateErrorReason(err) {
-  var _err$details$reason, _err$details;
-  return (_err$details$reason = (_err$details = err.details) === null || _err$details === void 0 ? void 0 : _err$details.reason) !== null && _err$details$reason !== void 0 ? _err$details$reason : 'unknown';
-}