@atlaskit/renderer 108.1.1 → 108.1.3

package/dist/es2019/ui/Renderer/index.js

@@ -35,7 +35,7 @@ import { RenderTracking } from '../../react/utils/performance/RenderTracking';
 export const NORMAL_SEVERITY_THRESHOLD = 2000;
 export const DEGRADED_SEVERITY_THRESHOLD = 3000;
 const packageName = "@atlaskit/renderer";
-const packageVersion = "108.1.1";
+const packageVersion = "108.1.3";
 export class Renderer extends PureComponent {
   constructor(props) {
     super(props);

package/dist/es2019/ui/Renderer/style.js

@@ -548,8 +548,8 @@ export const rendererStyles = wrapperProps => theme => {
   })(themeProps)};
             border-right: 1px solid
               ${themed({
-    light: `var(--ds-border, ${akEditorTableBorder})`,
-    dark: `var(--ds-border, ${akEditorTableBorderDark})`
+    light: `var(--ds-background-accent-gray-subtler, ${akEditorTableBorder})`,
+    dark: `var(--ds-background-accent-gray-subtler, ${akEditorTableBorderDark})`
   })(themeProps)};
             width: ${akEditorTableNumberColumnWidth}px;
             text-align: center;
@@ -574,13 +574,13 @@ export const rendererStyles = wrapperProps => theme => {
 
         border-right: 1px solid
           ${themed({
-    light: `var(--ds-border, ${akEditorTableBorder})`,
-    dark: `var(--ds-border, ${akEditorTableBorderDark})`
+    light: `var(--ds-background-accent-gray-subtler, ${akEditorTableBorder})`,
+    dark: `var(--ds-background-accent-gray-subtler, ${akEditorTableBorderDark})`
   })(themeProps)};
         border-bottom: 1px solid
           ${themed({
-    light: `var(--ds-border, ${akEditorTableBorder})`,
-    dark: `var(--ds-border, ${akEditorTableBorderDark})`
+    light: `var(--ds-background-accent-gray-subtler, ${akEditorTableBorder})`,
+    dark: `var(--ds-background-accent-gray-subtler, ${akEditorTableBorderDark})`
   })(themeProps)};
 
         /* this is to compensate for the table border */
@@ -606,20 +606,20 @@ export const rendererStyles = wrapperProps => theme => {
       .sticky td {
         box-shadow: 0px 1px
             ${themed({
-    light: `var(--ds-border, ${akEditorTableBorder})`,
-    dark: `var(--ds-border, ${akEditorTableBorderDark})`
+    light: `var(--ds-background-accent-gray-subtler, ${akEditorTableBorder})`,
+    dark: `var(--ds-background-accent-gray-subtler, ${akEditorTableBorderDark})`
   })(themeProps)},
           0px -0.5px ${themed({
-    light: `var(--ds-border, ${akEditorTableBorder})`,
-    dark: `var(--ds-border, ${akEditorTableBorderDark})`
+    light: `var(--ds-background-accent-gray-subtler, ${akEditorTableBorder})`,
+    dark: `var(--ds-background-accent-gray-subtler, ${akEditorTableBorderDark})`
   })(themeProps)},
           inset -1px 0px ${themed({
-    light: `var(--ds-border, ${akEditorTableToolbar})`,
-    dark: `var(--ds-border, ${akEditorTableToolbarDark})`
+    light: `var(--ds-background-accent-gray-subtler, ${akEditorTableToolbar})`,
+    dark: `var(--ds-background-accent-gray-subtler, ${akEditorTableToolbarDark})`
   })(themeProps)},
           0px -1px ${themed({
-    light: `var(--ds-border, ${akEditorTableToolbar})`,
-    dark: `var(--ds-border, ${akEditorTableToolbarDark})`
+    light: `var(--ds-background-accent-gray-subtler, ${akEditorTableToolbar})`,
+    dark: `var(--ds-background-accent-gray-subtler, ${akEditorTableToolbarDark})`
   })(themeProps)};
       }
 

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/renderer",
-	"version": "108.1.1",
+	"version": "108.1.3",
 	"sideEffects": false
 }

package/dist/esm/react/nodes/blockCard.js

@@ -32,6 +32,12 @@ export default function BlockCard(props) {
     // Below is added for the future implementation of Linking Platform namespaced analytic context
     location: 'renderer'
   };
+  var onError = function onError(_ref2) {
+    var err = _ref2.err;
+    if (err) {
+      throw err;
+    }
+  };
   return /*#__PURE__*/React.createElement(AnalyticsContext, {
     data: analyticsData
   }, /*#__PURE__*/React.createElement("div", {
@@ -46,5 +52,7 @@ export default function BlockCard(props) {
     showActions: rendererAppearance !== 'mobile',
     platform: platform,
     showServerActions: showServerActions
-  }, cardProps)))));
+  }, cardProps, {
+    onError: onError
+  })))));
 }

package/dist/esm/react/nodes/embedCard.js

@@ -108,6 +108,12 @@ export default function EmbedCard(props) {
     }
     var lineLength = isFullWidth ? Math.min(akEditorFullWidthLayoutWidth, containerWidth - padding) : nonFullWidthSize;
     var uiMediaSingleStyles = layout === 'full-width' || layout === 'wide' ? uIMediaSingleLayoutStyles : '';
+    var onError = function onError(_ref3) {
+      var err = _ref3.err;
+      if (err) {
+        throw err;
+      }
+    };
     return jsx(CardErrorBoundary, _extends({
       unsupportedComponent: UnsupportedBlock
     }, cardProps), jsx(EmbedResizeMessageListener, {
@@ -139,7 +145,8 @@ export default function EmbedCard(props) {
     }, cardProps, {
       onResolve: onResolve,
       inheritDimensions: true,
-      embedIframeRef: embedIframeRef
+      embedIframeRef: embedIframeRef,
+      onError: onError
     })))))));
   }));
 }

package/dist/esm/react/nodes/inlineCard.js

@@ -43,6 +43,12 @@ var InlineCard = function InlineCard(props) {
       showServerActions: showServerActions
     }));
   }
+  var onError = function onError(_ref2) {
+    var err = _ref2.err;
+    if (err) {
+      throw err;
+    }
+  };
   return /*#__PURE__*/React.createElement(AnalyticsContext, {
     data: analyticsData
   }, /*#__PURE__*/React.createElement("span", {
@@ -62,7 +68,8 @@ var InlineCard = function InlineCard(props) {
         return;
       }
       props.smartCardStorage.set(data.url, data.title);
-    }
+    },
+    onError: onError
   })))));
 };
 export default withSmartCardStorage(InlineCard);

package/dist/esm/react/nodes/mediaInline.js

@@ -2,45 +2,121 @@ import _extends from "@babel/runtime/helpers/extends";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
-import React, { useEffect, useState } from 'react';
+import React, { useEffect, useState, useCallback } from 'react';
 import { MediaInlineCard } from '@atlaskit/media-card';
 import { MediaInlineCardErroredView, MediaInlineCardLoadingView, messages } from '@atlaskit/media-ui';
 import { WithProviders } from '@atlaskit/editor-common/provider-factory';
+import { getMediaClient } from '@atlaskit/media-client';
 import { getClipboardAttrs } from '../../ui/MediaCard';
 import { createIntl, injectIntl } from 'react-intl-next';
-export var RenderMediaInline = function RenderMediaInline(props) {
-  var mediaProvider = props.mediaProvider,
-    rendererAppearance = props.rendererAppearance;
+export var RenderMediaInline = function RenderMediaInline(_ref) {
+  var rendererAppearance = _ref.rendererAppearance,
+    intl = _ref.intl,
+    clipboardAttrs = _ref.clipboardAttrs,
+    mediaInlineProviders = _ref.mediaInlineProviders,
+    collectionName = _ref.collection,
+    featureFlags = _ref.featureFlags,
+    eventHandlers = _ref.eventHandlers,
+    identifier = _ref.identifier;
   var _useState = useState(),
     _useState2 = _slicedToArray(_useState, 2),
-    viewMediaClientConfigState = _useState2[0],
-    setViewMediaClientConfigState = _useState2[1];
+    contextIdentifierProvider = _useState2[0],
+    setContextIdentifierProvider = _useState2[1];
+  var _useState3 = useState(),
+    _useState4 = _slicedToArray(_useState3, 2),
+    viewMediaClientConfigState = _useState4[0],
+    setViewMediaClientConfigState = _useState4[1];
+  var _useState5 = useState(),
+    _useState6 = _slicedToArray(_useState5, 2),
+    fileState = _useState6[0],
+    setFileState = _useState6[1];
+  var updateContext = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(contextIdentifierProvider) {
+      var resolvedContextID;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!contextIdentifierProvider) {
+              _context.next = 5;
+              break;
+            }
+            _context.next = 3;
+            return contextIdentifierProvider;
+          case 3:
+            resolvedContextID = _context.sent;
+            setContextIdentifierProvider(resolvedContextID);
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function updateContext(_x) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+  var updateFileState = useCallback( /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(id, mediaClientConfig) {
+      var mediaClient, options, _fileState;
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            mediaClient = getMediaClient(mediaClientConfig, featureFlags);
+            options = {
+              collectionName: collectionName
+            };
+            _context2.prev = 2;
+            _context2.next = 5;
+            return mediaClient.file.getCurrentState(id, options);
+          case 5:
+            _fileState = _context2.sent;
+            setFileState(_fileState);
+            _context2.next = 11;
+            break;
+          case 9:
+            _context2.prev = 9;
+            _context2.t0 = _context2["catch"](2);
+          case 11:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, null, [[2, 9]]);
+    }));
+    return function (_x2, _x3) {
+      return _ref3.apply(this, arguments);
+    };
+  }(), [collectionName, featureFlags]);
   useEffect(function () {
+    var mediaProvider = mediaInlineProviders.mediaProvider,
+      contextIdentifierProvider = mediaInlineProviders.contextIdentifierProvider;
+    var id = clipboardAttrs.id;
     updateViewMediaClientConfigState(mediaProvider);
-  }, [mediaProvider]);
+    updateContext(contextIdentifierProvider);
+    id && viewMediaClientConfigState && updateFileState(id, viewMediaClientConfigState);
+  }, [mediaInlineProviders, contextIdentifierProvider, clipboardAttrs, viewMediaClientConfigState, updateFileState]);
   var updateViewMediaClientConfigState = /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(mediaProvider) {
+    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(mediaProvider) {
       var mediaClientConfig;
-      return _regeneratorRuntime.wrap(function _callee$(_context) {
-        while (1) switch (_context.prev = _context.next) {
+      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
           case 0:
             if (!mediaProvider) {
-              _context.next = 5;
+              _context3.next = 5;
               break;
             }
-            _context.next = 3;
+            _context3.next = 3;
             return mediaProvider;
           case 3:
-            mediaClientConfig = _context.sent;
+            mediaClientConfig = _context3.sent;
             setViewMediaClientConfigState(mediaClientConfig.viewMediaClientConfig);
           case 5:
           case "end":
-            return _context.stop();
+            return _context3.stop();
         }
-      }, _callee);
+      }, _callee3);
     }));
-    return function updateViewMediaClientConfigState(_x) {
-      return _ref.apply(this, arguments);
+    return function updateViewMediaClientConfigState(_x4) {
+      return _ref4.apply(this, arguments);
     };
   }();
 
@@ -55,58 +131,67 @@ export var RenderMediaInline = function RenderMediaInline(props) {
     });
   }
   var handleMediaInlineClick = function handleMediaInlineClick(result) {
-    var _props$eventHandlers, _props$eventHandlers$;
-    if ((_props$eventHandlers = props.eventHandlers) !== null && _props$eventHandlers !== void 0 && (_props$eventHandlers$ = _props$eventHandlers.media) !== null && _props$eventHandlers$ !== void 0 && _props$eventHandlers$.onClick) {
-      var _props$eventHandlers2, _props$eventHandlers3;
-      (_props$eventHandlers2 = props.eventHandlers) === null || _props$eventHandlers2 === void 0 ? void 0 : (_props$eventHandlers3 = _props$eventHandlers2.media) === null || _props$eventHandlers3 === void 0 ? void 0 : _props$eventHandlers3.onClick(result);
+    var _eventHandlers$media;
+    if (eventHandlers !== null && eventHandlers !== void 0 && (_eventHandlers$media = eventHandlers.media) !== null && _eventHandlers$media !== void 0 && _eventHandlers$media.onClick) {
+      var _eventHandlers$media2;
+      eventHandlers === null || eventHandlers === void 0 ? void 0 : (_eventHandlers$media2 = eventHandlers.media) === null || _eventHandlers$media2 === void 0 ? void 0 : _eventHandlers$media2.onClick(result);
     }
   };
   var shouldOpenMediaViewer = rendererAppearance !== 'mobile';
   var shouldDisplayToolTip = rendererAppearance !== 'mobile';
-  return /*#__PURE__*/React.createElement(MediaInlineCard, {
-    identifier: props.identifier,
+  var mediaProvider = mediaInlineProviders.mediaProvider;
+  var id = clipboardAttrs.id,
+    collection = clipboardAttrs.collection;
+  return /*#__PURE__*/React.createElement("span", _extends({}, getClipboardAttrs({
+    id: id,
+    collection: collection,
+    contextIdentifierProvider: contextIdentifierProvider,
+    fileState: fileState
+  }), {
+    "data-node-type": "mediaInline"
+  }), mediaProvider ? /*#__PURE__*/React.createElement(MediaInlineCard, {
+    identifier: identifier,
     onClick: handleMediaInlineClick,
     shouldOpenMediaViewer: shouldOpenMediaViewer,
     shouldDisplayToolTip: shouldDisplayToolTip,
     mediaClientConfig: viewMediaClientConfigState
-  });
+  }) : /*#__PURE__*/React.createElement(MediaInlineCardErroredView, {
+    message: (intl || createIntl({
+      locale: 'en'
+    })).formatMessage(messages.couldnt_load_file)
+  }));
 };
 var MediaInline = function MediaInline(props) {
   var collection = props.collection,
     id = props.id,
-    providers = props.providers,
+    providerFactory = props.providers,
     intl = props.intl,
-    rendererAppearance = props.rendererAppearance;
+    rendererAppearance = props.rendererAppearance,
+    featureFlags = props.featureFlags;
+  var clipboardAttrs = {
+    id: id,
+    collection: collection
+  };
   var identifier = {
     id: id,
     mediaItemType: 'file',
     collectionName: collection
   };
-  var defaultIntl = createIntl({
-    locale: 'en'
-  });
-  return /*#__PURE__*/React.createElement("span", _extends({}, getClipboardAttrs({
-    id: id,
-    collection: collection
-  }), {
-    "data-node-type": "mediaInline"
-  }), /*#__PURE__*/React.createElement(WithProviders, {
-    providers: ['mediaProvider'],
-    providerFactory: providers,
-    renderNode: function renderNode(providers) {
-      var mediaProvider = providers.mediaProvider;
-      if (!mediaProvider) {
-        return /*#__PURE__*/React.createElement(MediaInlineCardErroredView, {
-          message: (intl || defaultIntl).formatMessage(messages.couldnt_load_file)
-        });
-      }
+  return /*#__PURE__*/React.createElement(WithProviders, {
+    providers: ['mediaProvider', 'contextIdentifierProvider'],
+    providerFactory: providerFactory,
+    renderNode: function renderNode(mediaInlineProviders) {
       return /*#__PURE__*/React.createElement(RenderMediaInline, {
         identifier: identifier,
-        mediaProvider: mediaProvider,
+        clipboardAttrs: clipboardAttrs,
         eventHandlers: props.eventHandlers,
-        rendererAppearance: rendererAppearance
+        rendererAppearance: rendererAppearance,
+        intl: intl,
+        mediaInlineProviders: mediaInlineProviders,
+        collection: collection,
+        featureFlags: featureFlags
       });
     }
-  }));
+  });
 };
 export default injectIntl(MediaInline);

package/dist/esm/ui/MediaCard.js

@@ -319,7 +319,6 @@ export var MediaCardInternal = /*#__PURE__*/function (_Component) {
   }]);
   return MediaCardInternal;
 }(Component);
-
 // Needed for copy & paste
 export var getClipboardAttrs = function getClipboardAttrs(_ref2) {
   var id = _ref2.id,

package/dist/esm/ui/Renderer/index.js

@@ -45,7 +45,7 @@ import { RenderTracking } from '../../react/utils/performance/RenderTracking';
 export var NORMAL_SEVERITY_THRESHOLD = 2000;
 export var DEGRADED_SEVERITY_THRESHOLD = 3000;
 var packageName = "@atlaskit/renderer";
-var packageVersion = "108.1.1";
+var packageVersion = "108.1.3";
 export var Renderer = /*#__PURE__*/function (_PureComponent) {
   _inherits(Renderer, _PureComponent);
   var _super = _createSuper(Renderer);

package/dist/esm/ui/Renderer/style.js

@@ -103,29 +103,29 @@ export var rendererStyles = function rendererStyles(wrapperProps) {
       light: "var(--ds-background-neutral, ".concat(akEditorTableToolbar, ")"),
       dark: "var(--ds-background-neutral, ".concat(akEditorTableToolbarDark, ")")
     })(themeProps), themed({
-      light: "var(--ds-border, ".concat(akEditorTableBorder, ")"),
-      dark: "var(--ds-border, ".concat(akEditorTableBorderDark, ")")
+      light: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableBorder, ")"),
+      dark: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableBorderDark, ")")
     })(themeProps), akEditorTableNumberColumnWidth, themed({
       light: "var(--ds-text-subtlest, ".concat(colors.N200, ")"),
       dark: "var(--ds-text-subtlest, ".concat(colors.DN400, ")")
     })(themeProps), relativeFontSizeToBase16(fontSize()), RendererCssClassName.NUMBER_COLUMN, akEditorStickyHeaderZIndex, themed({
-      light: "var(--ds-border, ".concat(akEditorTableBorder, ")"),
-      dark: "var(--ds-border, ".concat(akEditorTableBorderDark, ")")
+      light: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableBorder, ")"),
+      dark: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableBorderDark, ")")
     })(themeProps), themed({
-      light: "var(--ds-border, ".concat(akEditorTableBorder, ")"),
-      dark: "var(--ds-border, ".concat(akEditorTableBorderDark, ")")
+      light: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableBorder, ")"),
+      dark: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableBorderDark, ")")
     })(themeProps), akEditorStickyHeaderZIndex, themed({
-      light: "var(--ds-border, ".concat(akEditorTableBorder, ")"),
-      dark: "var(--ds-border, ".concat(akEditorTableBorderDark, ")")
+      light: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableBorder, ")"),
+      dark: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableBorderDark, ")")
     })(themeProps), themed({
-      light: "var(--ds-border, ".concat(akEditorTableBorder, ")"),
-      dark: "var(--ds-border, ".concat(akEditorTableBorderDark, ")")
+      light: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableBorder, ")"),
+      dark: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableBorderDark, ")")
     })(themeProps), themed({
-      light: "var(--ds-border, ".concat(akEditorTableToolbar, ")"),
-      dark: "var(--ds-border, ".concat(akEditorTableToolbarDark, ")")
+      light: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableToolbar, ")"),
+      dark: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableToolbarDark, ")")
     })(themeProps), themed({
-      light: "var(--ds-border, ".concat(akEditorTableToolbar, ")"),
-      dark: "var(--ds-border, ".concat(akEditorTableToolbarDark, ")")
+      light: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableToolbar, ")"),
+      dark: "var(--ds-background-accent-gray-subtler, ".concat(akEditorTableToolbarDark, ")")
     })(themeProps), "var(--ds-radius-100, 3px)", blockNodesVerticalMargin, useGridRenderForCodeBlock(useBlockRenderForCodeBlock), getLightWeightCodeBlockStylesForRootRendererStyleSheet(), columnLayoutSharedStyle, "var(--ds-space-250, 20px)", "var(--ds-space-400, 32px)", gridMediumMaxWidth, blockNodesVerticalMargin, blockNodesVerticalMargin, blockNodesVerticalMargin, browser.safari ? codeBlockInListSafariFix : '');
   };
 };

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/renderer",
-	"version": "108.1.1",
+	"version": "108.1.3",
 	"sideEffects": false
 }

package/dist/types/react/nodes/fallback.d.ts

@@ -4,7 +4,6 @@ export type CardErrorBoundaryProps = {
 };
 export declare class CardErrorBoundary extends React.PureComponent<{
     url?: string;
-    data?: object;
     onClick?: (e: React.MouseEvent<HTMLElement>, url?: string) => void;
 } & CardErrorBoundaryProps> {
     state: {

package/dist/types/react/nodes/mediaInline.d.ts

@@ -1,23 +1,33 @@
 import React from 'react';
-import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { ContextIdentifierProvider, ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 import { FileIdentifier } from '@atlaskit/media-client';
-import { MediaProvider } from '../../ui/MediaCard';
-import { WrappedComponentProps } from 'react-intl-next';
+import { MediaProvider, ClipboardAttrs } from '../../ui/MediaCard';
+import { IntlShape, WrappedComponentProps } from 'react-intl-next';
 import type { EventHandlers } from '@atlaskit/editor-common/ui';
 import { RendererAppearance } from '../../ui/Renderer/types';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+type MediaInlineProviders = {
+    mediaProvider?: Promise<MediaProvider>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+};
 export type RenderMediaInlineProps = {
     identifier: FileIdentifier;
-    mediaProvider: Promise<MediaProvider>;
+    clipboardAttrs: ClipboardAttrs;
+    mediaInlineProviders: MediaInlineProviders;
+    intl?: IntlShape;
     children?: React.ReactNode;
+    collection?: string;
     eventHandlers?: EventHandlers;
     rendererAppearance?: RendererAppearance;
+    featureFlags?: MediaFeatureFlags;
 };
 export type MediaInlineProps = {
     id: string;
-    collection?: string;
     providers: ProviderFactory;
+    collection?: string;
     eventHandlers?: EventHandlers;
     rendererAppearance?: RendererAppearance;
+    featureFlags?: MediaFeatureFlags;
 };
 export declare const RenderMediaInline: React.FC<RenderMediaInlineProps>;
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<MediaInlineProps & WrappedComponentProps<"intl">>> & {

package/dist/types/ui/MediaCard.d.ts

@@ -64,14 +64,15 @@ export declare class MediaCardInternal extends Component<MediaCardProps, State>
     private getOnCardClickCallback;
     render(): JSX.Element | null;
 }
-export declare const getClipboardAttrs: ({ id, alt, collection, contextIdentifierProvider, originalDimensions, fileState, }: {
+export type ClipboardAttrs = {
     id: string;
-    alt?: string | undefined;
-    collection?: string | undefined;
-    contextIdentifierProvider?: ContextIdentifierProvider | undefined;
-    originalDimensions?: NumericalCardDimensions | undefined;
-    fileState?: FileState | undefined;
-}) => {
+    alt?: string;
+    collection?: string;
+    contextIdentifierProvider?: ContextIdentifierProvider;
+    originalDimensions?: NumericalCardDimensions;
+    fileState?: FileState;
+};
+export declare const getClipboardAttrs: ({ id, alt, collection, contextIdentifierProvider, originalDimensions, fileState, }: ClipboardAttrs) => {
     [key: string]: string | number | undefined;
 };
 export declare const MediaCard: React.ComponentClass<MediaCardProps & import("@atlaskit/editor-common/utils").ImageLoaderProps, any>;

package/dist/types-ts4.5/react/nodes/fallback.d.ts

@@ -4,7 +4,6 @@ export type CardErrorBoundaryProps = {
 };
 export declare class CardErrorBoundary extends React.PureComponent<{
     url?: string;
-    data?: object;
     onClick?: (e: React.MouseEvent<HTMLElement>, url?: string) => void;
 } & CardErrorBoundaryProps> {
     state: {

package/dist/types-ts4.5/react/nodes/mediaInline.d.ts

@@ -1,23 +1,33 @@
 import React from 'react';
-import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { ContextIdentifierProvider, ProviderFactory } from '@atlaskit/editor-common/provider-factory';
 import { FileIdentifier } from '@atlaskit/media-client';
-import { MediaProvider } from '../../ui/MediaCard';
-import { WrappedComponentProps } from 'react-intl-next';
+import { MediaProvider, ClipboardAttrs } from '../../ui/MediaCard';
+import { IntlShape, WrappedComponentProps } from 'react-intl-next';
 import type { EventHandlers } from '@atlaskit/editor-common/ui';
 import { RendererAppearance } from '../../ui/Renderer/types';
+import { MediaFeatureFlags } from '@atlaskit/media-common';
+type MediaInlineProviders = {
+    mediaProvider?: Promise<MediaProvider>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+};
 export type RenderMediaInlineProps = {
     identifier: FileIdentifier;
-    mediaProvider: Promise<MediaProvider>;
+    clipboardAttrs: ClipboardAttrs;
+    mediaInlineProviders: MediaInlineProviders;
+    intl?: IntlShape;
     children?: React.ReactNode;
+    collection?: string;
     eventHandlers?: EventHandlers;
     rendererAppearance?: RendererAppearance;
+    featureFlags?: MediaFeatureFlags;
 };
 export type MediaInlineProps = {
     id: string;
-    collection?: string;
     providers: ProviderFactory;
+    collection?: string;
     eventHandlers?: EventHandlers;
     rendererAppearance?: RendererAppearance;
+    featureFlags?: MediaFeatureFlags;
 };
 export declare const RenderMediaInline: React.FC<RenderMediaInlineProps>;
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<MediaInlineProps & WrappedComponentProps<"intl">>> & {

package/dist/types-ts4.5/ui/MediaCard.d.ts

@@ -64,14 +64,15 @@ export declare class MediaCardInternal extends Component<MediaCardProps, State>
     private getOnCardClickCallback;
     render(): JSX.Element | null;
 }
-export declare const getClipboardAttrs: ({ id, alt, collection, contextIdentifierProvider, originalDimensions, fileState, }: {
+export type ClipboardAttrs = {
     id: string;
-    alt?: string | undefined;
-    collection?: string | undefined;
-    contextIdentifierProvider?: ContextIdentifierProvider | undefined;
-    originalDimensions?: NumericalCardDimensions | undefined;
-    fileState?: FileState | undefined;
-}) => {
+    alt?: string;
+    collection?: string;
+    contextIdentifierProvider?: ContextIdentifierProvider;
+    originalDimensions?: NumericalCardDimensions;
+    fileState?: FileState;
+};
+export declare const getClipboardAttrs: ({ id, alt, collection, contextIdentifierProvider, originalDimensions, fileState, }: ClipboardAttrs) => {
     [key: string]: string | number | undefined;
 };
 export declare const MediaCard: React.ComponentClass<MediaCardProps & import("@atlaskit/editor-common/utils").ImageLoaderProps, any>;