@atlaskit/editor-plugin-card 7.4.7 → 7.4.9

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @atlaskit/editor-plugin-card
 
+## 7.4.9
+
+### Patch Changes
+
+- [`ffc3ef708967c`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/ffc3ef708967c) -
+  [ux] Adds an optional disablePreviewPanel prop on a smartcard to allow consumers opt out of
+  opening Preview Panel by default when a smartlink is clicked.
+- Updated dependencies
+
+## 7.4.8
+
+### Patch Changes
+
+- [`265c1bf0cefa4`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/265c1bf0cefa4) -
+  Sorted type and interface props to improve Atlaskit docs
+- Updated dependencies
+
 ## 7.4.7
 
 ### Patch Changes

package/dist/cjs/nodeviews/inlineCard.js

@@ -38,7 +38,8 @@ var InlineCard = exports.InlineCard = /*#__PURE__*/(0, _react.memo)(function (_r
     showHoverPreview = _ref.showHoverPreview,
     hoverPreviewOptions = _ref.hoverPreviewOptions,
     isPageSSRed = _ref.isPageSSRed,
-    pluginInjectionApi = _ref.pluginInjectionApi;
+    pluginInjectionApi = _ref.pluginInjectionApi,
+    disablePreviewPanel = _ref.disablePreviewPanel;
   var _node$attrs = node.attrs,
     url = _node$attrs.url,
     data = _node$attrs.data;
@@ -123,7 +124,8 @@ var InlineCard = exports.InlineCard = /*#__PURE__*/(0, _react.memo)(function (_r
         actionOptions: actionOptions,
         isHovered: isHovered,
         showHoverPreview: showHoverPreview,
-        hoverPreviewOptions: hoverPreviewOptions
+        hoverPreviewOptions: hoverPreviewOptions,
+        disablePreviewPanel: disablePreviewPanel
       });
     }
     return /*#__PURE__*/_react.default.createElement(_smartCard.Card, {
@@ -138,9 +140,10 @@ var InlineCard = exports.InlineCard = /*#__PURE__*/(0, _react.memo)(function (_r
       actionOptions: actionOptions,
       isHovered: isHovered,
       showHoverPreview: showHoverPreview,
-      hoverPreviewOptions: hoverPreviewOptions
+      hoverPreviewOptions: hoverPreviewOptions,
+      disablePreviewPanel: disablePreviewPanel
     });
-  }, [url, data, onClick, scrollContainer, onResolve, onError, useAlternativePreloader, actionOptions, isHovered, showHoverPreview, hoverPreviewOptions, isPageSSRed]);
+  }, [url, data, onClick, scrollContainer, onResolve, onError, useAlternativePreloader, actionOptions, isHovered, showHoverPreview, hoverPreviewOptions, isPageSSRed, disablePreviewPanel]);
 
   // [WS-2307]: we only render card wrapped into a Provider when the value is ready,
   // otherwise if we got data, we can render the card directly since it doesn't need the Provider

package/dist/cjs/nodeviews/inlineCardWithAwareness.js

@@ -116,7 +116,8 @@ var InlineCardWithAwareness = exports.InlineCardWithAwareness = /*#__PURE__*/(0,
       cardContext: cardContext,
       isHovered: isHovered,
       isPageSSRed: isPageSSRed,
-      pluginInjectionApi: pluginInjectionApi
+      pluginInjectionApi: pluginInjectionApi,
+      disablePreviewPanel: true
     }));
   }, [isResolvedViewRendered, node, editorAppearance, view, getPos, useAlternativePreloader, actionOptions, onResolve, onClick, cardContext, isHovered, isPageSSRed, pluginInjectionApi]);
   var innerCardOriginal = (0, _react.useMemo)(function () {
@@ -200,7 +201,8 @@ var InlineCardWithAwareness = exports.InlineCardWithAwareness = /*#__PURE__*/(0,
             isHovered: isHovered,
             isPageSSRed: isPageSSRed,
             pluginInjectionApi: pluginInjectionApi,
-            showHoverPreview: mode === 'view' && showHoverPreview
+            showHoverPreview: mode === 'view' && showHoverPreview,
+            disablePreviewPanel: true
           }));
         } else {
           return /*#__PURE__*/_react.default.createElement(_inlineCard.InlineCard, {

package/dist/es2019/nodeviews/inlineCard.js

@@ -27,7 +27,8 @@ export const InlineCard = /*#__PURE__*/memo(({
   showHoverPreview,
   hoverPreviewOptions,
   isPageSSRed,
-  pluginInjectionApi
+  pluginInjectionApi,
+  disablePreviewPanel
 }) => {
   const {
     url,
@@ -119,7 +120,8 @@ export const InlineCard = /*#__PURE__*/memo(({
         actionOptions: actionOptions,
         isHovered: isHovered,
         showHoverPreview: showHoverPreview,
-        hoverPreviewOptions: hoverPreviewOptions
+        hoverPreviewOptions: hoverPreviewOptions,
+        disablePreviewPanel: disablePreviewPanel
       });
     }
     return /*#__PURE__*/React.createElement(SmartCard, {
@@ -134,9 +136,10 @@ export const InlineCard = /*#__PURE__*/memo(({
       actionOptions: actionOptions,
       isHovered: isHovered,
       showHoverPreview: showHoverPreview,
-      hoverPreviewOptions: hoverPreviewOptions
+      hoverPreviewOptions: hoverPreviewOptions,
+      disablePreviewPanel: disablePreviewPanel
     });
-  }, [url, data, onClick, scrollContainer, onResolve, onError, useAlternativePreloader, actionOptions, isHovered, showHoverPreview, hoverPreviewOptions, isPageSSRed]);
+  }, [url, data, onClick, scrollContainer, onResolve, onError, useAlternativePreloader, actionOptions, isHovered, showHoverPreview, hoverPreviewOptions, isPageSSRed, disablePreviewPanel]);
 
   // [WS-2307]: we only render card wrapped into a Provider when the value is ready,
   // otherwise if we got data, we can render the card directly since it doesn't need the Provider

package/dist/es2019/nodeviews/inlineCardWithAwareness.js

@@ -96,7 +96,8 @@ export const InlineCardWithAwareness = /*#__PURE__*/memo(({
       cardContext: cardContext,
       isHovered: isHovered,
       isPageSSRed: isPageSSRed,
-      pluginInjectionApi: pluginInjectionApi
+      pluginInjectionApi: pluginInjectionApi,
+      disablePreviewPanel: true
     }));
   }, [isResolvedViewRendered, node, editorAppearance, view, getPos, useAlternativePreloader, actionOptions, onResolve, onClick, cardContext, isHovered, isPageSSRed, pluginInjectionApi]);
   const innerCardOriginal = useMemo(() => /*#__PURE__*/React.createElement(InlineCard, {
@@ -179,7 +180,8 @@ export const InlineCardWithAwareness = /*#__PURE__*/memo(({
             isHovered: isHovered,
             isPageSSRed: isPageSSRed,
             pluginInjectionApi: pluginInjectionApi,
-            showHoverPreview: mode === 'view' && showHoverPreview
+            showHoverPreview: mode === 'view' && showHoverPreview,
+            disablePreviewPanel: true
           }));
         } else {
           return /*#__PURE__*/React.createElement(InlineCard, {

package/dist/esm/nodeviews/inlineCard.js

@@ -27,7 +27,8 @@ export var InlineCard = /*#__PURE__*/memo(function (_ref) {
     showHoverPreview = _ref.showHoverPreview,
     hoverPreviewOptions = _ref.hoverPreviewOptions,
     isPageSSRed = _ref.isPageSSRed,
-    pluginInjectionApi = _ref.pluginInjectionApi;
+    pluginInjectionApi = _ref.pluginInjectionApi,
+    disablePreviewPanel = _ref.disablePreviewPanel;
   var _node$attrs = node.attrs,
     url = _node$attrs.url,
     data = _node$attrs.data;
@@ -112,7 +113,8 @@ export var InlineCard = /*#__PURE__*/memo(function (_ref) {
         actionOptions: actionOptions,
         isHovered: isHovered,
         showHoverPreview: showHoverPreview,
-        hoverPreviewOptions: hoverPreviewOptions
+        hoverPreviewOptions: hoverPreviewOptions,
+        disablePreviewPanel: disablePreviewPanel
       });
     }
     return /*#__PURE__*/React.createElement(SmartCard, {
@@ -127,9 +129,10 @@ export var InlineCard = /*#__PURE__*/memo(function (_ref) {
       actionOptions: actionOptions,
       isHovered: isHovered,
       showHoverPreview: showHoverPreview,
-      hoverPreviewOptions: hoverPreviewOptions
+      hoverPreviewOptions: hoverPreviewOptions,
+      disablePreviewPanel: disablePreviewPanel
     });
-  }, [url, data, onClick, scrollContainer, onResolve, onError, useAlternativePreloader, actionOptions, isHovered, showHoverPreview, hoverPreviewOptions, isPageSSRed]);
+  }, [url, data, onClick, scrollContainer, onResolve, onError, useAlternativePreloader, actionOptions, isHovered, showHoverPreview, hoverPreviewOptions, isPageSSRed, disablePreviewPanel]);
 
   // [WS-2307]: we only render card wrapped into a Provider when the value is ready,
   // otherwise if we got data, we can render the card directly since it doesn't need the Provider

package/dist/esm/nodeviews/inlineCardWithAwareness.js

@@ -107,7 +107,8 @@ export var InlineCardWithAwareness = /*#__PURE__*/memo(function (_ref) {
       cardContext: cardContext,
       isHovered: isHovered,
       isPageSSRed: isPageSSRed,
-      pluginInjectionApi: pluginInjectionApi
+      pluginInjectionApi: pluginInjectionApi,
+      disablePreviewPanel: true
     }));
   }, [isResolvedViewRendered, node, editorAppearance, view, getPos, useAlternativePreloader, actionOptions, onResolve, onClick, cardContext, isHovered, isPageSSRed, pluginInjectionApi]);
   var innerCardOriginal = useMemo(function () {
@@ -191,7 +192,8 @@ export var InlineCardWithAwareness = /*#__PURE__*/memo(function (_ref) {
             isHovered: isHovered,
             isPageSSRed: isPageSSRed,
             pluginInjectionApi: pluginInjectionApi,
-            showHoverPreview: mode === 'view' && showHoverPreview
+            showHoverPreview: mode === 'view' && showHoverPreview,
+            disablePreviewPanel: true
           }));
         } else {
           return /*#__PURE__*/React.createElement(InlineCard, {

package/dist/types/cardPluginType.d.ts

@@ -15,10 +15,10 @@ import type { SelectionPlugin } from '@atlaskit/editor-plugin-selection';
 import type { WidthPlugin } from '@atlaskit/editor-plugin-width';
 import type { CardPluginOptions, CardPluginState } from './types';
 type DummyAnnotationPlugin = NextEditorPlugin<'annotation', {
-    sharedState: InlineCommentPluginState;
     actions: {
         setInlineCommentDraftState: (isDraft: boolean, inputMethod: INPUT_METHOD) => Command;
     };
+    sharedState: InlineCommentPluginState;
 }>;
 export type CardPluginDependencies = [
     OptionalPlugin<FeatureFlagsPlugin>,
@@ -35,9 +35,9 @@ export type CardPluginDependencies = [
     OptionalPlugin<BasePlugin>
 ];
 export type CardPlugin = NextEditorPlugin<'card', {
-    pluginConfiguration: CardPluginOptions | undefined;
+    actions: CardPluginActions;
     dependencies: CardPluginDependencies;
+    pluginConfiguration: CardPluginOptions | undefined;
     sharedState: CardPluginState | null;
-    actions: CardPluginActions;
 }>;
 export {};

package/dist/types/nodeviews/blockCard.d.ts

@@ -13,8 +13,8 @@ export declare class BlockCardComponent extends React.PureComponent<SmartCardPro
         id?: string;
     });
     onResolve: (data: {
-        url?: string;
         title?: string;
+        url?: string;
     }) => void;
     componentWillUnmount(): void;
     private removeCardDispatched;
@@ -37,16 +37,16 @@ export declare class BlockCard extends ReactNodeView<BlockCardNodeViewProps> {
     destroy(): void;
 }
 export interface BlockCardNodeViewProperties {
-    pmPluginFactoryParams: PMPluginFactoryParams;
     actionOptions: BlockCardNodeViewProps['actionOptions'];
-    pluginInjectionApi: BlockCardNodeViewProps['pluginInjectionApi'];
-    onClickCallback: BlockCardNodeViewProps['onClickCallback'];
     allowDatasource: boolean | undefined;
-    inlineCardViewProducer: ReturnType<typeof getInlineNodeViewProducer>;
-    isPageSSRed: BlockCardNodeViewProps['isPageSSRed'];
     CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
         linkType?: string;
+        sourceUrl: string;
     }>;
+    inlineCardViewProducer: ReturnType<typeof getInlineNodeViewProducer>;
+    isPageSSRed: BlockCardNodeViewProps['isPageSSRed'];
+    onClickCallback: BlockCardNodeViewProps['onClickCallback'];
+    pluginInjectionApi: BlockCardNodeViewProps['pluginInjectionApi'];
+    pmPluginFactoryParams: PMPluginFactoryParams;
 }
 export declare const blockCardNodeView: ({ pmPluginFactoryParams, actionOptions, pluginInjectionApi, onClickCallback, allowDatasource, inlineCardViewProducer, CompetitorPrompt, isPageSSRed, }: BlockCardNodeViewProperties) => (node: Node, view: EditorView, getPos: () => number | undefined, decorations: readonly Decoration[]) => import("prosemirror-view").NodeView | Datasource | BlockCard;

package/dist/types/nodeviews/datasource.d.ts

@@ -13,13 +13,13 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { Decoration, DecorationSource, EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { cardPlugin } from '../index';
 export interface DatasourceProps extends ReactComponentProps {
-    node: PMNode;
-    view: EditorView;
-    getPos: getPosHandler;
-    portalProviderAPI: PortalProviderAPI;
     eventDispatcher: EventDispatcher;
-    pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined;
+    getPos: getPosHandler;
     isNodeNested?: boolean;
+    node: PMNode;
+    pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined;
+    portalProviderAPI: PortalProviderAPI;
+    view: EditorView;
 }
 interface DatasourceComponentProps extends ReactComponentProps, Pick<DatasourceProps, 'node' | 'view' | 'getPos'> {
 }

package/dist/types/nodeviews/embedCard.d.ts

@@ -8,8 +8,8 @@ import type { cardPlugin } from '../index';
 import type { SmartCardProps } from './genericCard';
 export type EmbedCardState = {
     hasPreview: boolean;
-    liveHeight?: number;
     initialAspectRatio?: number;
+    liveHeight?: number;
 };
 export declare class EmbedCardComponent extends React.PureComponent<SmartCardProps & {
     id?: string;
@@ -22,9 +22,9 @@ export declare class EmbedCardComponent extends React.PureComponent<SmartCardPro
     state: EmbedCardState;
     private getPosSafely;
     onResolve: (data: {
-        url?: string;
-        title?: string;
         aspectRatio?: number;
+        title?: string;
+        url?: string;
     }) => void;
     updateSize: (pctWidth: number | null, layout: RichMediaLayout) => true | undefined;
     private getLineLength;
@@ -55,13 +55,13 @@ export declare class EmbedCard extends ReactNodeView<EmbedCardNodeViewProps> {
     destroy(): void;
 }
 export interface EmbedCardNodeViewProperties {
+    actionOptions: EmbedCardNodeViewProps['actionOptions'];
     allowResizing: EmbedCardNodeViewProps['allowResizing'];
+    CompetitorPrompt?: EmbedCardNodeViewProps['CompetitorPrompt'];
     fullWidthMode: EmbedCardNodeViewProps['fullWidthMode'];
-    pmPluginFactoryParams: PMPluginFactoryParams;
-    pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined;
-    actionOptions: EmbedCardNodeViewProps['actionOptions'];
-    onClickCallback: EmbedCardNodeViewProps['onClickCallback'];
     isPageSSRed: EmbedCardNodeViewProps['isPageSSRed'];
-    CompetitorPrompt?: EmbedCardNodeViewProps['CompetitorPrompt'];
+    onClickCallback: EmbedCardNodeViewProps['onClickCallback'];
+    pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined;
+    pmPluginFactoryParams: PMPluginFactoryParams;
 }
 export declare const embedCardNodeView: ({ allowResizing, fullWidthMode, pmPluginFactoryParams, pluginInjectionApi, actionOptions, onClickCallback, CompetitorPrompt, isPageSSRed, }: EmbedCardNodeViewProperties) => (node: PMNode, view: EditorView, getPos: () => number | undefined) => EmbedCard;

package/dist/types/nodeviews/genericCard.d.ts

@@ -16,40 +16,41 @@ export type EditorContext<T> = React.Context<T> & {
     value: T;
 };
 export interface CardNodeViewProps extends ReactComponentProps {
-    providerFactory?: ProviderFactory;
     eventDispatcher?: EventDispatcher;
+    providerFactory?: ProviderFactory;
 }
 export interface CardProps extends CardNodeViewProps {
+    __livePage?: boolean;
+    actionOptions?: BaseCardProps['actionOptions'];
+    allowResizing?: boolean;
     children?: React.ReactNode;
-    node: PMNode;
-    view: EditorView;
-    getPos: getPosHandler;
     dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
     eventDispatcher?: EventDispatcher;
-    allowResizing?: boolean;
     fullWidthMode?: boolean;
-    useAlternativePreloader?: boolean;
-    actionOptions?: BaseCardProps['actionOptions'];
-    pluginInjectionApi?: ExtractInjectionAPI<typeof cardPlugin>;
+    getPos: getPosHandler;
+    hoverPreviewOptions?: BaseCardProps['hoverPreviewOptions'];
+    node: PMNode;
     onClickCallback?: OnClickCallback;
+    pluginInjectionApi?: ExtractInjectionAPI<typeof cardPlugin>;
     showHoverPreview?: BaseCardProps['showHoverPreview'];
-    hoverPreviewOptions?: BaseCardProps['hoverPreviewOptions'];
-    __livePage?: boolean;
+    useAlternativePreloader?: boolean;
+    view: EditorView;
 }
 export interface SmartCardProps extends CardProps {
-    pluginInjectionApi?: ExtractInjectionAPI<typeof cardPlugin>;
-    cardContext?: EditorContext<CardContext | undefined>;
-    onClick?: EventHandler<MouseEvent | KeyboardEvent> | undefined;
-    onResolve?: (tr: Transaction, title?: string) => void;
-    isHovered?: boolean;
-    allowEmbeds?: boolean;
     allowBlockCards?: boolean;
-    enableInlineUpgradeFeatures?: boolean;
-    isPageSSRed?: boolean;
+    allowEmbeds?: boolean;
+    cardContext?: EditorContext<CardContext | undefined>;
     CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
         linkType?: string;
+        sourceUrl: string;
     }>;
+    disablePreviewPanel?: BaseCardProps['disablePreviewPanel'];
+    enableInlineUpgradeFeatures?: boolean;
+    isHovered?: boolean;
+    isPageSSRed?: boolean;
+    onClick?: EventHandler<MouseEvent | KeyboardEvent> | undefined;
+    onResolve?: (tr: Transaction, title?: string) => void;
+    pluginInjectionApi?: ExtractInjectionAPI<typeof cardPlugin>;
 }
 /**
  *

package/dist/types/nodeviews/inlineCard.d.ts

@@ -4,7 +4,7 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { Decoration, EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { SmartCardProps } from './genericCard';
 import { type InlineCardWithAwarenessProps } from './inlineCardWithAwareness';
-export declare const InlineCard: React.MemoExoticComponent<({ node, cardContext, actionOptions, useAlternativePreloader, view, getPos, onClick: propsOnClick, onResolve: onRes, isHovered, showHoverPreview, hoverPreviewOptions, isPageSSRed, pluginInjectionApi, }: SmartCardProps) => React.JSX.Element | null>;
+export declare const InlineCard: React.MemoExoticComponent<({ node, cardContext, actionOptions, useAlternativePreloader, view, getPos, onClick: propsOnClick, onResolve: onRes, isHovered, showHoverPreview, hoverPreviewOptions, isPageSSRed, pluginInjectionApi, disablePreviewPanel, }: SmartCardProps) => React.JSX.Element | null>;
 export type InlineCardNodeViewProps = Pick<SmartCardProps, 'useAlternativePreloader' | 'actionOptions' | 'allowEmbeds' | 'allowBlockCards' | 'enableInlineUpgradeFeatures' | 'pluginInjectionApi' | 'onClickCallback' | 'isPageSSRed' | 'CompetitorPrompt'>;
 /**
  *

package/dist/types/nodeviews/inlineCardWithAwareness.d.ts

@@ -1,8 +1,8 @@
 import React from 'react';
 import type { SmartCardProps } from './genericCard';
 export type InlineCardWithAwarenessProps = {
-    isPulseEnabled?: boolean;
     isOverlayEnabled?: boolean;
+    isPulseEnabled?: boolean;
     isSelected?: boolean;
 };
 export declare const InlineCardWithAwareness: React.MemoExoticComponent<({ node, cardContext, actionOptions, useAlternativePreloader, view, getPos, pluginInjectionApi, onClick, isPulseEnabled, isOverlayEnabled, isSelected, isPageSSRed, appearance, }: SmartCardProps & InlineCardWithAwarenessProps) => React.JSX.Element>;

package/dist/types/pm-plugins/actions.d.ts

@@ -16,8 +16,8 @@ export declare const setProvider: (cardProvider: CardProvider | null) => (tr: Tr
 export declare const setDatasourceTableRef: (datasourceTableRef?: HTMLElement) => (tr: Transaction) => Transaction;
 export declare const setCardLayout: (layout: DatasourceTableLayout) => (tr: Transaction) => Transaction;
 export declare const setCardLayoutAndDatasourceTableRef: ({ layout, datasourceTableRef, }: {
-    layout: DatasourceTableLayout;
     datasourceTableRef?: HTMLElement;
+    layout: DatasourceTableLayout;
 }) => (tr: Transaction) => Transaction;
 export declare const showLinkToolbar: (tr: Transaction) => Transaction;
 export declare const hideLinkToolbar: (tr: Transaction) => Transaction;

package/dist/types/pm-plugins/doc.d.ts

@@ -24,13 +24,13 @@ export type LinkNodes = {
 };
 export declare const getLinkNodeType: (appearance: CardAppearance, linkNodes: LinkNodes) => NodeType;
 type UpdateCardArgs = {
-    state: EditorState;
-    node: Node;
+    inputMethod?: string;
+    isDeletingConfig?: boolean;
     newAdf: DatasourceAdf | InlineCardAdf;
-    view: EditorView;
+    node: Node;
     sourceEvent?: UIAnalyticsEvent;
-    isDeletingConfig?: boolean;
-    inputMethod?: string;
+    state: EditorState;
+    view: EditorView;
 };
 export declare const updateCardViaDatasource: (args: UpdateCardArgs) => void;
 export declare const insertDatasource: (state: EditorState, adf: DatasourceAdf | InlineCardAdf, view: EditorView, sourceEvent?: UIAnalyticsEvent) => void;

package/dist/types/pm-plugins/util/state.d.ts

@@ -4,39 +4,39 @@ export declare const getPluginState: (editorState: EditorState) => CardPluginSta
 export declare const getPluginStateWithUpdatedPos: (pluginState: CardPluginState, tr: ReadonlyTransaction) => {
     requests: {
         pos: number;
-        url: string;
+        analyticsAction?: import("@atlaskit/editor-common/analytics").ACTION;
         appearance: import("@atlaskit/editor-common/provider-factory").CardAppearance;
         compareLinkText: boolean;
-        source: import("@atlaskit/editor-common/card").CardReplacementInputMethod;
         previousAppearance?: import("@atlaskit/editor-common/provider-factory").CardAppearance | "url";
-        analyticsAction?: import("@atlaskit/editor-common/analytics").ACTION;
         shouldReplaceLink?: boolean;
+        source: import("@atlaskit/editor-common/card").CardReplacementInputMethod;
         sourceEvent?: import("@atlaskit/analytics-next").UIAnalyticsEvent | null | undefined;
+        url: string;
     }[];
     cards: {
         pos: number;
+        id?: string;
         title?: string;
         url?: string;
-        id?: string;
     }[];
-    provider: import("@atlaskit/editor-common/provider-factory").CardProvider | null;
+    allowBlockCards?: boolean;
+    allowEmbeds?: boolean;
+    datasourceModalType?: import("@atlaskit/editor-common/types").DatasourceModalType;
     datasourceStash: {
         [x: string]: {
             views: import("@atlaskit/linking-common").DatasourceAdfView[];
         };
     };
-    showLinkingToolbar: boolean;
-    smartLinkEvents?: import("@atlaskit/smart-card").SmartLinkEvents;
-    editorAppearance?: import("@atlaskit/editor-common/types").EditorAppearance;
-    showDatasourceModal: boolean;
-    datasourceModalType?: import("@atlaskit/editor-common/types").DatasourceModalType;
     datasourceTableRef?: HTMLElement;
-    layout?: import("../../ui/LayoutButton/types").DatasourceTableLayout;
+    editorAppearance?: import("@atlaskit/editor-common/types").EditorAppearance;
     inlineCardAwarenessCandidatePosition?: number;
+    layout?: import("../../ui/LayoutButton/types").DatasourceTableLayout;
     overlayCandidatePosition?: number;
+    provider: import("@atlaskit/editor-common/provider-factory").CardProvider | null;
     removeOverlay?: () => void;
     selectedInlineLinkPosition?: number;
-    allowEmbeds?: boolean;
-    allowBlockCards?: boolean;
+    showDatasourceModal: boolean;
+    showLinkingToolbar: boolean;
+    smartLinkEvents?: import("@atlaskit/smart-card").SmartLinkEvents;
 };
 export declare const getNewRequests: (oldState: CardPluginState | undefined, currentState: CardPluginState) => Request[];