@atlaskit/media-card 77.12.4 → 78.0.0

package/dist/esm/card/inlinePlayer.js

@@ -1,26 +1,16 @@
 import _extends from "@babel/runtime/helpers/extends";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
-import React from 'react';
-import { Component } from 'react';
+import React, { useRef, useState, useEffect } from 'react';
 import { globalMediaEventEmitter } from '@atlaskit/media-client';
 import { CustomMediaPlayer, InactivityDetector } from '@atlaskit/media-ui';
 import { defaultImageCardDimensions } from '../utils';
 import { CardLoading } from '../utils/lightCards/cardLoading';
 import { ProgressBar } from './ui/progressBar/progressBar';
-import { calcBreakpointSize } from './ui/styles';
-import { isValidPercentageUnit } from '../utils/isValidPercentageUnit';
-import { getElementDimension } from '../utils/getElementDimension';
 import { InlinePlayerWrapper } from './inlinePlayerWrapper';
+import { useBreakpoint } from './useBreakpoint';
+import { useFileState, useMediaClient } from '@atlaskit/media-client-react';
 export var getPreferredVideoArtifact = function getPreferredVideoArtifact(fileState) {
   if (fileState.status === 'processed' || fileState.status === 'processing') {
     var artifacts = fileState.artifacts;
@@ -31,265 +21,191 @@ export var getPreferredVideoArtifact = function getPreferredVideoArtifact(fileSt
   }
   return undefined;
 };
-export var InlinePlayerBase = /*#__PURE__*/function (_Component) {
-  _inherits(InlinePlayerBase, _Component);
-  var _super = _createSuper(InlinePlayerBase);
-  function InlinePlayerBase() {
-    var _this;
-    _classCallCheck(this, InlinePlayerBase);
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    _this = _super.call.apply(_super, [this].concat(args));
-    _defineProperty(_assertThisInitialized(_this), "state", {});
-    _defineProperty(_assertThisInitialized(_this), "divRef", /*#__PURE__*/React.createRef());
-    _defineProperty(_assertThisInitialized(_this), "setFileSrc", function (fileSrc) {
-      _this.setState({
-        fileSrc: fileSrc
-      });
-    });
-    // Tries to use the binary artifact to provide something to play while the video is still processing
-    _defineProperty(_assertThisInitialized(_this), "setBinaryURL", /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      var _this$props, mediaClient, identifier, onError, id, collectionName, fileSrc;
-      return _regeneratorRuntime.wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
-          case 0:
-            _this$props = _this.props, mediaClient = _this$props.mediaClient, identifier = _this$props.identifier, onError = _this$props.onError;
-            id = identifier.id, collectionName = identifier.collectionName;
-            _context.prev = 2;
-            _context.next = 5;
-            return mediaClient.file.getFileBinaryURL(id, collectionName);
-          case 5:
-            fileSrc = _context.sent;
-            _this.setFileSrc(fileSrc);
-            _context.next = 12;
-            break;
-          case 9:
-            _context.prev = 9;
-            _context.t0 = _context["catch"](2);
-            if (onError && _context.t0 instanceof Error) {
-              onError(_context.t0);
-            }
-          case 12:
-          case "end":
-            return _context.stop();
-        }
-      }, _callee, null, [[2, 9]]);
-    })));
-    _defineProperty(_assertThisInitialized(_this), "unsubscribe", function () {
-      if (_this.subscription) {
-        _this.subscription.unsubscribe();
-      }
-    });
-    _defineProperty(_assertThisInitialized(_this), "revoke", function () {
-      var fileSrc = _this.state.fileSrc;
-      if (fileSrc) {
-        URL.revokeObjectURL(fileSrc);
-      }
-    });
-    _defineProperty(_assertThisInitialized(_this), "onDownloadClick", function () {
-      var _this$props2 = _this.props,
-        mediaClient = _this$props2.mediaClient,
-        identifier = _this$props2.identifier;
-      var id = identifier.id,
-        collectionName = identifier.collectionName;
-      mediaClient.file.downloadBinary(id, undefined, collectionName);
-    });
-    _defineProperty(_assertThisInitialized(_this), "onFirstPlay", function () {
-      var identifier = _this.props.identifier;
-      globalMediaEventEmitter.emit('media-viewed', {
-        fileId: identifier.id,
-        viewingLevel: 'full'
-      });
-    });
-    _defineProperty(_assertThisInitialized(_this), "saveElementWidth", function () {
-      var dimensions = _this.props.dimensions;
-      if (!dimensions) {
-        return;
-      }
-      var width = dimensions.width;
-      if (width && isValidPercentageUnit(width) && !!_this.divRef.current) {
-        var elementWidth = getElementDimension(_this.divRef.current, 'width');
-        _this.setState({
-          elementWidth: elementWidth
-        });
-      }
-    });
-    return _this;
-  }
-  _createClass(InlinePlayerBase, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      var _this2 = this;
-      this.saveElementWidth();
-      var _this$props3 = this.props,
-        mediaClient = _this$props3.mediaClient,
-        identifier = _this$props3.identifier;
-      var id = identifier.id,
-        collectionName = identifier.collectionName;
-      this.revoke();
-      this.unsubscribe();
-      this.subscription = mediaClient.file.getFileState(id, {
-        collectionName: collectionName
-      }).subscribe({
-        next: function () {
-          var _next = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(fileState) {
-            var existingFileSrc, _yield$fileState$prev, value, fileSrc, artifactName, artifacts, _fileSrc, onError;
-            return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-              while (1) switch (_context2.prev = _context2.next) {
-                case 0:
-                  if (fileState.status === 'uploading') {
-                    _this2.setState({
-                      isUploading: true,
-                      progress: fileState.progress
-                    });
-                  } else {
-                    _this2.setState({
-                      isUploading: false
-                    });
-                  }
-                  existingFileSrc = _this2.state.fileSrc; // we want to reuse the existing fileSrc to prevent re renders
-                  if (!existingFileSrc) {
-                    _context2.next = 4;
-                    break;
-                  }
-                  return _context2.abrupt("return");
-                case 4:
-                  if (!(fileState.status !== 'error' && fileState.preview)) {
-                    _context2.next = 13;
-                    break;
-                  }
-                  _context2.next = 7;
-                  return fileState.preview;
-                case 7:
-                  _yield$fileState$prev = _context2.sent;
-                  value = _yield$fileState$prev.value;
-                  if (!(value instanceof Blob && value.type.indexOf('video/') === 0)) {
-                    _context2.next = 13;
-                    break;
-                  }
-                  fileSrc = URL.createObjectURL(value);
-                  _this2.setFileSrc(fileSrc);
-                  return _context2.abrupt("return");
-                case 13:
-                  if (!(fileState.status === 'processed' || fileState.status === 'processing')) {
-                    _context2.next = 30;
-                    break;
-                  }
-                  artifactName = getPreferredVideoArtifact(fileState);
-                  artifacts = fileState.artifacts;
-                  if (!(!artifactName || !artifacts)) {
-                    _context2.next = 19;
-                    break;
-                  }
-                  _this2.setBinaryURL();
-                  return _context2.abrupt("return");
-                case 19:
-                  _context2.prev = 19;
-                  _context2.next = 22;
-                  return mediaClient.file.getArtifactURL(artifacts, artifactName, collectionName);
-                case 22:
-                  _fileSrc = _context2.sent;
-                  _this2.setFileSrc(_fileSrc);
-                  _context2.next = 30;
-                  break;
-                case 26:
-                  _context2.prev = 26;
-                  _context2.t0 = _context2["catch"](19);
-                  onError = _this2.props.onError;
-                  if (onError && _context2.t0 instanceof Error) {
-                    onError(_context2.t0);
-                  }
-                case 30:
-                case "end":
-                  return _context2.stop();
+export var InlinePlayerBase = function InlinePlayerBase(_ref) {
+  var identifier = _ref.identifier,
+    onError = _ref.onError,
+    onClick = _ref.onClick,
+    _ref$dimensions = _ref.dimensions,
+    dimensions = _ref$dimensions === void 0 ? defaultImageCardDimensions : _ref$dimensions,
+    originalDimensions = _ref.originalDimensions,
+    selected = _ref.selected,
+    testId = _ref.testId,
+    forwardRef = _ref.forwardRef,
+    autoplay = _ref.autoplay,
+    cardPreview = _ref.cardPreview,
+    onFullscreenChange = _ref.onFullscreenChange,
+    videoControlsWrapperRef = _ref.videoControlsWrapperRef;
+  // === States ===
+  var _useState = useState(),
+    _useState2 = _slicedToArray(_useState, 2),
+    fileSrc = _useState2[0],
+    setFileSrc = _useState2[1];
+  var _useState3 = useState(),
+    _useState4 = _slicedToArray(_useState3, 2),
+    isUploading = _useState4[0],
+    setIsUploading = _useState4[1];
+  var _useState5 = useState(),
+    _useState6 = _slicedToArray(_useState5, 2),
+    progress = _useState6[0],
+    setProgress = _useState6[1];
+
+  // === Refs and Local Variables ===
+  var divRef = useRef(null);
+  var onErrorRef = useRef(onError);
+  onErrorRef.current = onError;
+  var id = identifier.id,
+    collectionName = identifier.collectionName,
+    occurrenceKey = identifier.occurrenceKey;
+  var breakpoint = useBreakpoint(dimensions === null || dimensions === void 0 ? void 0 : dimensions.width, divRef);
+  var mediaClient = useMediaClient();
+  var _useFileState = useFileState(id, {
+      collectionName: collectionName,
+      occurrenceKey: occurrenceKey
+    }),
+    fileState = _useFileState.fileState;
+  useEffect(function () {
+    var subscribeFileState = /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(fileState) {
+        var _yield$fileState$prev, value, newFileSrc, artifactName, artifacts, _newFileSrc, _newFileSrc2;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (fileState.status === 'uploading') {
+                setIsUploading(true);
+                setProgress(fileState.progress);
+              } else {
+                setIsUploading(false);
+              }
+
+              // We reuse the existing fileSrc to prevent re renders, therefore we only perform fileSrc updates when there isn't any
+              if (!fileSrc) {
+                _context.next = 3;
+                break;
+              }
+              return _context.abrupt("return");
+            case 3:
+              if (!(fileState.status !== 'error' && fileState.preview)) {
+                _context.next = 12;
+                break;
+              }
+              _context.next = 6;
+              return fileState.preview;
+            case 6:
+              _yield$fileState$prev = _context.sent;
+              value = _yield$fileState$prev.value;
+              if (!(value instanceof Blob && value.type.indexOf('video/') === 0)) {
+                _context.next = 12;
+                break;
               }
-            }, _callee2, null, [[19, 26]]);
-          }));
-          function next(_x) {
-            return _next.apply(this, arguments);
+              newFileSrc = URL.createObjectURL(value);
+              setFileSrc(newFileSrc);
+              return _context.abrupt("return");
+            case 12:
+              if (!(fileState.status === 'processed' || fileState.status === 'processing')) {
+                _context.next = 37;
+                break;
+              }
+              artifactName = getPreferredVideoArtifact(fileState);
+              artifacts = fileState.artifacts;
+              if (!(!artifactName || !artifacts)) {
+                _context.next = 27;
+                break;
+              }
+              _context.prev = 16;
+              _context.next = 19;
+              return mediaClient.file.getFileBinaryURL(id, collectionName);
+            case 19:
+              _newFileSrc = _context.sent;
+              setFileSrc(_newFileSrc);
+              _context.next = 26;
+              break;
+            case 23:
+              _context.prev = 23;
+              _context.t0 = _context["catch"](16);
+              if (onErrorRef.current && _context.t0 instanceof Error) {
+                onErrorRef.current(_context.t0);
+              }
+            case 26:
+              return _context.abrupt("return");
+            case 27:
+              _context.prev = 27;
+              _context.next = 30;
+              return mediaClient.file.getArtifactURL(artifacts, artifactName, collectionName);
+            case 30:
+              _newFileSrc2 = _context.sent;
+              setFileSrc(_newFileSrc2);
+              _context.next = 37;
+              break;
+            case 34:
+              _context.prev = 34;
+              _context.t1 = _context["catch"](27);
+              if (onErrorRef.current && _context.t1 instanceof Error) {
+                onErrorRef.current(_context.t1);
+              }
+            case 37:
+            case "end":
+              return _context.stop();
           }
-          return next;
-        }()
-      });
-    }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      this.unsubscribe();
-      this.revoke();
-    }
-  }, {
-    key: "breakpoint",
-    get: function get() {
-      var width = this.state.elementWidth || (this.props.dimensions ? this.props.dimensions.width : '') || defaultImageCardDimensions.width;
-      return calcBreakpointSize(parseInt("".concat(width), 10));
+        }, _callee, null, [[16, 23], [27, 34]]);
+      }));
+      return function subscribeFileState(_x) {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+    if (fileState) {
+      subscribeFileState(fileState);
     }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this3 = this;
-      var _this$props4 = this.props,
-        onClick = _this$props4.onClick,
-        dimensions = _this$props4.dimensions,
-        originalDimensions = _this$props4.originalDimensions,
-        selected = _this$props4.selected,
-        testId = _this$props4.testId,
-        identifier = _this$props4.identifier,
-        forwardRef = _this$props4.forwardRef,
-        autoplay = _this$props4.autoplay,
-        cardPreview = _this$props4.cardPreview,
-        onFullscreenChange = _this$props4.onFullscreenChange,
-        videoControlsWrapperRef = _this$props4.videoControlsWrapperRef;
-      var _this$state = this.state,
-        fileSrc = _this$state.fileSrc,
-        isUploading = _this$state.isUploading,
-        progress = _this$state.progress;
-      if (!fileSrc) {
-        return /*#__PURE__*/React.createElement(CardLoading, {
-          testId: testId,
-          dimensions: dimensions
+  }, [fileState, collectionName, fileSrc, id, mediaClient]);
+  useEffect(function () {
+    return function () {
+      fileSrc && URL.revokeObjectURL(fileSrc);
+    };
+  }, [fileSrc]);
+
+  // === Render ===
+  return fileSrc ? /*#__PURE__*/React.createElement(InlinePlayerWrapper, {
+    testId: testId || 'media-card-inline-player',
+    selected: {
+      selected: selected
+    },
+    onClick: onClick,
+    innerRef: forwardRef || undefined,
+    dimensions: dimensions
+  }, /*#__PURE__*/React.createElement(InactivityDetector, null, function (checkMouseMovement) {
+    return /*#__PURE__*/React.createElement(CustomMediaPlayer, {
+      type: "video",
+      src: fileSrc,
+      onFullscreenChange: onFullscreenChange,
+      fileId: id,
+      isAutoPlay: autoplay,
+      isHDAvailable: false,
+      onDownloadClick: function onDownloadClick() {
+        mediaClient.file.downloadBinary(id, undefined, collectionName);
+      },
+      onFirstPlay: function onFirstPlay() {
+        globalMediaEventEmitter.emit('media-viewed', {
+          fileId: id,
+          viewingLevel: 'full'
         });
-      }
-      return /*#__PURE__*/React.createElement(InlinePlayerWrapper, {
-        testId: testId || 'media-card-inline-player',
-        selected: {
-          selected: selected
-        },
-        onClick: onClick,
-        innerRef: forwardRef || undefined,
-        dimensions: dimensions
-      }, /*#__PURE__*/React.createElement(InactivityDetector, null, function (checkMouseMovement) {
-        return /*#__PURE__*/React.createElement(CustomMediaPlayer, {
-          type: "video",
-          src: fileSrc,
-          onFullscreenChange: onFullscreenChange,
-          fileId: identifier.id,
-          isAutoPlay: autoplay,
-          isHDAvailable: false,
-          onDownloadClick: _this3.onDownloadClick,
-          onFirstPlay: _this3.onFirstPlay,
-          lastWatchTimeConfig: {
-            contentId: identifier.id
-          },
-          originalDimensions: originalDimensions,
-          showControls: checkMouseMovement,
-          poster: cardPreview === null || cardPreview === void 0 ? void 0 : cardPreview.dataURI,
-          videoControlsWrapperRef: videoControlsWrapperRef
-        });
-      }), isUploading ? /*#__PURE__*/React.createElement(ProgressBar, {
-        progress: progress,
-        breakpoint: this.breakpoint,
-        positionBottom: true,
-        showOnTop: true
-      }) : null);
-    }
-  }]);
-  return InlinePlayerBase;
-}(Component);
-_defineProperty(InlinePlayerBase, "defaultProps", {
-  dimensions: defaultImageCardDimensions
-});
+      },
+      lastWatchTimeConfig: {
+        contentId: id
+      },
+      originalDimensions: originalDimensions,
+      showControls: checkMouseMovement,
+      poster: cardPreview === null || cardPreview === void 0 ? void 0 : cardPreview.dataURI,
+      videoControlsWrapperRef: videoControlsWrapperRef
+    });
+  }), isUploading && /*#__PURE__*/React.createElement(ProgressBar, {
+    progress: progress,
+    breakpoint: breakpoint,
+    positionBottom: true,
+    showOnTop: true
+  })) : /*#__PURE__*/React.createElement(CardLoading, {
+    testId: testId,
+    dimensions: dimensions
+  });
+};
 var InlinePlayerForwardRef = /*#__PURE__*/React.forwardRef(function (props, ref) {
   return /*#__PURE__*/React.createElement(InlinePlayerBase, _extends({}, props, {
     forwardRef: ref

package/dist/esm/card/media-card-analytics-error-boundary.js

@@ -83,7 +83,7 @@ var WrappedMediaCardAnalyticsErrorBoundary = /*#__PURE__*/function (_React$Compo
 }(React.Component);
 _defineProperty(WrappedMediaCardAnalyticsErrorBoundary, "displayName", 'MediaCardAnalyticsErrorBoundary');
 var packageName = "@atlaskit/media-card";
-var packageVersion = "77.12.4";
+var packageVersion = "78.0.0";
 var MediaCardAnalyticsErrorBoundary = withMediaAnalyticsContext({
   packageVersion: packageVersion,
   packageName: packageName,

package/dist/esm/card/{v2/svgView → svgView}/svgView.js

@@ -4,17 +4,17 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { jsx } from '@emotion/react';
 import React, { useState, useRef } from 'react';
 import { withAnalyticsEvents } from '@atlaskit/analytics-next';
-import { createAndFireMediaCardEvent } from '../../../utils/analytics';
-import { ImageRenderer } from '../../ui/imageRenderer/imageRenderer';
-import { ProgressBar } from '../../ui/progressBar/progressBar';
-import { Blanket } from '../../ui/blanket/blanket';
-import { Wrapper, ImageContainer } from '../../ui/wrapper';
-import { fileCardImageViewSelector } from '../../classnames';
-import { useBreakpoint } from '../../useBreakpoint';
+import { createAndFireMediaCardEvent } from '../../utils/analytics';
+import { ImageRenderer } from '../ui/imageRenderer/imageRenderer';
+import { ProgressBar } from '../ui/progressBar/progressBar';
+import { Blanket } from '../ui/blanket/blanket';
+import { Wrapper, ImageContainer } from '../ui/wrapper';
+import { fileCardImageViewSelector } from '../classnames';
+import { useBreakpoint } from '../useBreakpoint';
 import MediaSvg from '@atlaskit/media-svg';
 import { calculateSvgDimensions } from './helpers';
-import OpenMediaViewerButton from '../../ui/openMediaViewerButton/openMediaViewerButton';
-import { MediaCardError } from '../../../errors';
+import OpenMediaViewerButton from '../ui/openMediaViewerButton/openMediaViewerButton';
+import { MediaCardError } from '../../errors';
 import { getErrorReason } from './errors';
 export var convertResizeMode = function convertResizeMode(resizeMode) {
   switch (resizeMode) {

package/dist/esm/inline/loader.js

@@ -103,7 +103,7 @@ var MediaInlineCardLoader = /*#__PURE__*/function (_React$PureComponent) {
         ErrorBoundary = _this$state.ErrorBoundary;
       var analyticsContext = {
         packageVersion: "@atlaskit/media-card",
-        packageName: "77.12.4",
+        packageName: "78.0.0",
         componentName: 'mediaInlineCard',
         component: 'mediaInlineCard'
       };

package/dist/esm/utils/ufoExperiences.js

@@ -7,7 +7,7 @@ import { extractErrorInfo, getRenderErrorRequestMetadata } from './analytics';
 import { MediaCardError } from '../errors';
 import { getMediaEnvironment, getMediaRegion } from '@atlaskit/media-client';
 var packageName = "@atlaskit/media-card";
-var packageVersion = "77.12.4";
+var packageVersion = "78.0.0";
 var concurrentExperience;
 var getExperience = function getExperience(id) {
   if (!concurrentExperience) {

package/dist/types/card/card.d.ts

@@ -1,68 +1,7 @@
-import React, { Component } from 'react';
-import { type UIAnalyticsEvent, type WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
-import { type FileIdentifier, type FileState, type MediaSubscription } from '@atlaskit/media-client';
+import { type WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import React from 'react';
 import { type WrappedComponentProps } from 'react-intl-next';
-import { type CardAction } from './actions';
-import { type CardProps, type CardState, type CardStatus } from '../types';
-export type CardBaseProps = CardProps & WithAnalyticsEventsProps & Partial<WrappedComponentProps> & {
-    dateOverride?: number;
-};
-export declare class CardBase extends Component<CardBaseProps, CardState> {
-    private internalOccurrenceKey;
-    private hasBeenMounted;
-    private mediaViewerButtonRef;
-    private fileStateFlags;
-    private ssrReliability;
-    private timeElapsedTillCommenced;
-    subscription?: MediaSubscription;
-    private ssrData?;
-    private traceContext;
-    static defaultProps: Partial<CardProps>;
-    constructor(props: CardBaseProps);
-    private getSSRPreview;
-    componentDidMount(): void;
-    componentDidUpdate(prevProps: CardProps, prevState: CardState): void;
-    componentWillUnmount(): void;
-    updateStateForIdentifier(identifier: FileIdentifier): void;
-    private getImageURLParams;
-    private getMediaBlobUrlAttrs;
-    private getCardPreviewParams;
-    private setCacheSSRPreview;
-    private refetchSSRPreview;
-    private resolveUpfrontPreview;
-    private fetchAndCacheRemotePreview;
-    private resolvePreview;
-    updateFileStateFlag(fileState?: FileState): void;
-    subscribeInternalFile(identifier: FileIdentifier): void;
-    private get requestedDimensions();
-    private get metadata();
-    private get fileAttributes();
-    private getPerformanceAttributes;
-    private logSSRImageError;
-    private onImageError;
-    private onImageLoad;
-    private fireOperationalEvent;
-    private fireAbortedEvent;
-    private fireCommencedEvent;
-    private fireCopiedEvent;
-    private fireScreenEvent;
-    private fireNonCriticalErrorEvent;
-    private safeSetState;
-    unsubscribe: () => void;
-    get actions(): CardAction[];
-    onCardViewClick: (event: React.MouseEvent<HTMLDivElement | HTMLButtonElement>, analyticsEvent?: UIAnalyticsEvent) => void;
-    onInlinePlayerError: (e: Error) => void;
-    setRef: (cardRef: HTMLDivElement | null) => void;
-    setMediaViewerButtonRef: (buttonRef: HTMLButtonElement | null) => void;
-    renderInlinePlayer: () => JSX.Element;
-    onMediaViewerClose: () => void;
-    private onDisplayImage;
-    renderMediaViewer: () => React.ReactPortal | undefined;
-    renderCard: (withCallbacks?: boolean, cardStatusOverride?: CardStatus, izLazyOverride?: boolean) => JSX.Element;
-    private storeSSRData;
-    render(): JSX.Element;
-    private onCardInViewport;
-    onClick: (event: React.MouseEvent<HTMLDivElement | HTMLButtonElement>, analyticsEvent?: UIAnalyticsEvent) => void;
-    onMouseEnter: (event: React.MouseEvent<HTMLDivElement>) => void;
-}
+import { type CardProps } from '../types';
+export type CardBaseProps = CardProps & WithAnalyticsEventsProps & Partial<WrappedComponentProps>;
+export declare const CardBase: ({ identifier, ...otherProps }: CardBaseProps & WrappedComponentProps) => JSX.Element;
 export declare const Card: React.ComponentType<CardBaseProps>;

package/dist/types/card/cardLoader.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
-import type { CardWithMediaClientConfigProps } from './types';
+import { type CardWithMediaClientConfigProps } from './types';
 declare const CardLoader: React.FC<CardWithMediaClientConfigProps>;
 export default CardLoader;