@atlaskit/editor-plugin-card 7.4.7 → 7.4.9

package/dist/types/types/index.d.ts

@@ -15,20 +15,19 @@ export type DatasourceNode = Omit<Node, 'attrs'> & {
     readonly attrs: DatasourceAdf['attrs'] & Partial<RichMediaAttributes>;
 };
 export type CardInfo = {
-    title?: string;
-    url?: string;
     id?: string;
     pos: number;
+    title?: string;
+    url?: string;
 };
 export type Request = {
     /**
-     * The position of the link in the doc this request for upgrade is for
-     */
-    pos: number;
-    /**
-     * The URL of the link being upgraded/resolved
+     * Analytics action to be used when disaptching
+     * analytics events once the link is successfully/unsuccessfully
+     * resolved. Preserves the users "intent" ie was this a link
+     * being inserted or updated?
      */
-    url: string;
+    analyticsAction?: ACTION;
     /**
      * The requested appearance to upgrade to
      */
@@ -40,11 +39,9 @@ export type Request = {
      */
     compareLinkText: boolean;
     /**
-     * Analytics input method which preserves "how" the change
-     * has occured. Used when analytics are dispatched after the link
-     * is successfully/unsuccessfully resolved.
+     * The position of the link in the doc this request for upgrade is for
      */
-    source: CardReplacementInputMethod;
+    pos: number;
     /**
      * The previous appearance of the link
      * This is necessary when tracking an update of a link
@@ -52,13 +49,6 @@ export type Request = {
      * replacing with a hyperlink and queueing it for upgrade
      */
     previousAppearance?: CardAppearance | 'url';
-    /**
-     * Analytics action to be used when disaptching
-     * analytics events once the link is successfully/unsuccessfully
-     * resolved. Preserves the users "intent" ie was this a link
-     * being inserted or updated?
-     */
-    analyticsAction?: ACTION;
     /**
      * Describes if the requested `appearance` MUST be returned by the card provider
      * when resolving the link, because the request is associated with the user intent
@@ -66,12 +56,22 @@ export type Request = {
      * should not be affected by "default appearances" or "user preferences"
      */
     shouldReplaceLink?: boolean;
+    /**
+     * Analytics input method which preserves "how" the change
+     * has occured. Used when analytics are dispatched after the link
+     * is successfully/unsuccessfully resolved.
+     */
+    source: CardReplacementInputMethod;
     /**
      * Source UI that triggered this step if relevant
      * Primarily for transfering link picker UI event from initial UI action
      * through to the end of the link queue/request saga
      */
     sourceEvent?: UIAnalyticsEvent | null | undefined;
+    /**
+     * The URL of the link being upgraded/resolved
+     */
+    url: string;
 };
 /**
  * Each key in the stash is URL.
@@ -81,57 +81,57 @@ type DatasourceStash = Record<string, {
     views: DatasourceAdfView[];
 }>;
 export type CardPluginState = {
-    requests: Request[];
-    provider: CardProvider | null;
+    allowBlockCards?: boolean;
+    allowEmbeds?: boolean;
     cards: CardInfo[];
-    datasourceStash: DatasourceStash;
-    showLinkingToolbar: boolean;
-    smartLinkEvents?: SmartLinkEvents;
-    editorAppearance?: EditorAppearance;
-    showDatasourceModal: boolean;
     datasourceModalType?: DatasourceModalType;
+    datasourceStash: DatasourceStash;
     datasourceTableRef?: HTMLElement;
-    layout?: DatasourceTableLayout;
+    editorAppearance?: EditorAppearance;
     inlineCardAwarenessCandidatePosition?: number;
+    layout?: DatasourceTableLayout;
     overlayCandidatePosition?: number;
+    provider: CardProvider | null;
     removeOverlay?: () => void;
+    requests: Request[];
     selectedInlineLinkPosition?: number;
-    allowEmbeds?: boolean;
-    allowBlockCards?: boolean;
+    showDatasourceModal: boolean;
+    showLinkingToolbar: boolean;
+    smartLinkEvents?: SmartLinkEvents;
 };
 export type CardPluginOptions = CardOptions & {
+    cardPluginEvents?: EditorCardPluginEvents<CardPluginEvent>;
+    CompetitorPrompt?: React.ComponentType<{
+        linkType?: string;
+        sourceUrl: string;
+    }>;
+    disableFloatingToolbar?: boolean;
     editorAppearance?: EditorAppearance;
     fullWidthMode?: boolean;
+    isPageSSRed?: boolean;
     linkPicker?: LinkPickerOptions;
-    cardPluginEvents?: EditorCardPluginEvents<CardPluginEvent>;
     lpLinkPicker?: boolean;
-    disableFloatingToolbar?: boolean;
     onClickCallback?: OnClickCallback;
-    isPageSSRed?: boolean;
-    CompetitorPrompt?: React.ComponentType<{
-        sourceUrl: string;
-        linkType?: string;
-    }>;
 };
 export type SetProvider = {
-    type: 'SET_PROVIDER';
     provider: CardProvider | null;
+    type: 'SET_PROVIDER';
 };
 export type Queue = {
-    type: 'QUEUE';
     requests: Request[];
+    type: 'QUEUE';
 };
 export type Resolve = {
     type: 'RESOLVE';
     url: string;
 };
 export type Register = {
-    type: 'REGISTER';
     info: CardInfo;
+    type: 'REGISTER';
 };
 export type RemoveCard = {
-    type: 'REMOVE_CARD';
     info: Partial<CardInfo>;
+    type: 'REMOVE_CARD';
 };
 export type ShowLinkToolbar = {
     type: 'SHOW_LINK_TOOLBAR';
@@ -140,43 +140,43 @@ export type HideLinkToolbar = {
     type: 'HIDE_LINK_TOOLBAR';
 };
 export type ShowDatasourceModal = {
-    type: 'SHOW_DATASOURCE_MODAL';
     modalType: DatasourceModalType;
+    type: 'SHOW_DATASOURCE_MODAL';
 };
 export type HideDatasourceModal = {
     type: 'HIDE_DATASOURCE_MODAL';
 };
 export type RegisterSmartCardEvents = {
-    type: 'REGISTER_EVENTS';
     smartLinkEvents: SmartLinkEvents;
+    type: 'REGISTER_EVENTS';
 };
 export type SetDatasourceTableRef = {
-    type: 'SET_DATASOURCE_TABLE_REF';
     datasourceTableRef?: HTMLElement;
+    type: 'SET_DATASOURCE_TABLE_REF';
 };
 export type SetCardLayout = {
-    type: 'SET_CARD_LAYOUT';
     layout: DatasourceTableLayout;
+    type: 'SET_CARD_LAYOUT';
 };
 export type SetCardLayoutAndDatasourceTableRef = {
-    type: 'SET_CARD_LAYOUT_AND_DATASOURCE_TABLE_REF';
-    layout: DatasourceTableLayout;
     datasourceTableRef?: HTMLElement;
+    layout: DatasourceTableLayout;
+    type: 'SET_CARD_LAYOUT_AND_DATASOURCE_TABLE_REF';
 };
 type ClearOverlayCandidate = {
     type: 'CLEAR_OVERLAY_CANDIDATE';
 };
 type RegisterRemoveOverlayOnInsertedLink = {
-    type: 'REGISTER_REMOVE_OVERLAY_ON_INSERTED_LINK';
     callback: () => void;
     info?: Register['info'];
+    type: 'REGISTER_REMOVE_OVERLAY_ON_INSERTED_LINK';
 };
 export type SetDatasourceStash = {
-    type: 'SET_DATASOURCE_STASH';
     datasourceStash: {
         url: string;
         views: DatasourceAdfView[];
     };
+    type: 'SET_DATASOURCE_STASH';
 };
 export type RemoveDatasourceStash = {
     type: 'REMOVE_DATASOURCE_STASH';

package/dist/types/ui/AwarenessWrapper/index.d.ts

@@ -1,15 +1,15 @@
 import { jsx } from '@emotion/react';
 import type { SmartCardProps } from '../../nodeviews/genericCard';
 type AwarenessWrapperProps = {
+    children: JSX.Element;
     isInserted?: boolean;
+    isOverlayEnabled?: boolean;
+    isPulseEnabled?: boolean;
     isResolvedViewRendered?: boolean;
-    children: JSX.Element;
+    isSelected?: boolean;
     markMostRecentlyInsertedLink: (isLinkMostRecentlyInserted: boolean) => void;
     setOverlayHoveredStyles: (isHovered: boolean) => void;
     url: string;
-    isOverlayEnabled?: boolean;
-    isPulseEnabled?: boolean;
-    isSelected?: boolean;
 } & Partial<SmartCardProps>;
 export declare const AwarenessWrapper: ({ cardContext, children, getPos, isInserted, isOverlayEnabled, isSelected, isResolvedViewRendered, isPulseEnabled, markMostRecentlyInsertedLink, pluginInjectionApi, setOverlayHoveredStyles, url, appearance, }: AwarenessWrapperProps) => jsx.JSX.Element;
 export {};

package/dist/types/ui/ConfigureOverlay/index.d.ts

@@ -1,11 +1,11 @@
 import { jsx } from '@emotion/react';
 import { type EditorView } from '@atlaskit/editor-prosemirror/view';
 declare const OverlayWrapper: ({ view, targetElementPos, children, isHoveredCallback: hoverCallback, onOpenLinkClick, }: {
-    view: EditorView;
-    targetElementPos: number | undefined;
     children: JSX.Element;
     /** Fired when the mouse enters or leaves the overlay button */
     isHoveredCallback: (isHovered: boolean) => void;
     onOpenLinkClick: (event: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => void;
+    targetElementPos: number | undefined;
+    view: EditorView;
 }) => jsx.JSX.Element;
 export default OverlayWrapper;

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

@@ -5,13 +5,13 @@ import type { EditorState } from '@atlaskit/editor-prosemirror/state';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import { type CardContext } from '@atlaskit/link-provider';
 export interface DatasourceAppearanceButtonProps {
-    intl: IntlShape;
+    cardContext?: CardContext;
     editorAnalyticsApi?: EditorAnalyticsAPI;
-    url: string;
-    editorView?: EditorView;
     editorState: EditorState;
-    cardContext?: CardContext;
-    selected?: boolean;
+    editorView?: EditorView;
     inputMethod: string;
+    intl: IntlShape;
+    selected?: boolean;
+    url: string;
 }
 export declare const DatasourceAppearanceButton: ({ intl, editorAnalyticsApi, url, editorView, editorState, selected, inputMethod, }: DatasourceAppearanceButtonProps) => jsx.JSX.Element;

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

@@ -3,11 +3,11 @@ import type { IntlShape } from 'react-intl-next';
 import type { Command } from '@atlaskit/editor-common/types';
 interface Props {
     allowDatasource?: boolean;
+    dispatchCommand: (command: Command) => void;
+    inputMethod: string;
     intl: IntlShape;
-    url: string;
     selected: boolean;
-    inputMethod: string;
-    dispatchCommand: (command: Command) => void;
+    url: string;
 }
 export declare const datasourceDisplayInformation: {
     title: {

package/dist/types/ui/DatasourceModal/index.d.ts

@@ -4,9 +4,9 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { CardContext } from '@atlaskit/link-provider';
 import type { ModalTypeToComponentMap } from './ModalWithState';
 type DatasourceModalProps = {
-    view: EditorView;
-    editorAnalyticsApi?: EditorAnalyticsAPI;
     cardContext?: CardContext;
+    editorAnalyticsApi?: EditorAnalyticsAPI;
+    view: EditorView;
 } & ModalTypeToComponentMap;
 export declare const DatasourceModal: ({ view, cardContext, datasourceId: defaultDatasourceId, componentType: Component, }: DatasourceModalProps) => React.JSX.Element | null;
 export {};

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

@@ -9,15 +9,15 @@ import type { Node } from '@atlaskit/editor-prosemirror/model';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { cardPlugin } from '../cardPlugin';
 export type EditLinkToolbarProps = {
-    view: EditorView;
-    providerFactory: ProviderFactory;
-    url: string | undefined;
-    text: string;
-    node: Node;
-    onSubmit?: (href: string, text?: string, inputMethod?: LinkInputType, analytic?: UIAnalyticsEvent | null | undefined) => void;
-    linkPickerOptions?: LinkPickerOptions;
     forceFocusSelector: ForceFocusSelector | undefined;
+    linkPickerOptions?: LinkPickerOptions;
     lpLinkPicker: boolean;
+    node: Node;
+    onSubmit?: (href: string, text?: string, inputMethod?: LinkInputType, analytic?: UIAnalyticsEvent | null | undefined) => void;
+    providerFactory: ProviderFactory;
+    text: string;
+    url: string | undefined;
+    view: EditorView;
 };
 export declare function HyperlinkAddToolbarWithState({ linkPickerOptions, onSubmit, displayText, displayUrl, providerFactory, view, onCancel, invokeMethod, lpLinkPicker, onClose, onEscapeCallback, onClickAwayCallback, }: HyperlinkAddToolbarProps): React.JSX.Element;
 export declare class EditLinkToolbar extends React.Component<EditLinkToolbarProps> {
@@ -28,10 +28,10 @@ export declare class EditLinkToolbar extends React.Component<EditLinkToolbarProp
 }
 export declare const getEditLinkCallback: (editorAnalyticsApi: EditorAnalyticsAPI | undefined, scrollIntoView: boolean) => Command;
 export declare const buildEditLinkToolbar: ({ providerFactory, node, pluginInjectionApi, linkPicker, lpLinkPicker, }: {
-    providerFactory: ProviderFactory;
-    node: Node;
-    pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined;
     linkPicker?: LinkPickerOptions;
     lpLinkPicker: boolean;
+    node: Node;
+    pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined;
+    providerFactory: ProviderFactory;
 }) => FloatingToolbarItem<Command>;
 export declare const editLinkToolbarConfig: (showLinkingToolbar: boolean, lpLinkPicker?: boolean) => Partial<FloatingToolbarConfig>;

package/dist/types/ui/EditToolbarButton/EditToolbarButtonPresentation.d.ts

@@ -1,9 +1,9 @@
 import { jsx } from '@emotion/react';
 import type { EditDatasourceToolbarButtonWithCommonProps, EditVariant } from './types';
 interface EditToolbarPresentationProps extends EditDatasourceToolbarButtonWithCommonProps {
-    extensionKey?: string;
     datasourceId?: string;
     editVariant: EditVariant;
+    extensionKey?: string;
 }
 declare const EditToolbarButtonPresentation: ({ datasourceId, currentAppearance, editorAnalyticsApi, editVariant, editorView, extensionKey, onLinkEditClick, intl, }: EditToolbarPresentationProps) => jsx.JSX.Element | null;
 export default EditToolbarButtonPresentation;

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

@@ -7,11 +7,11 @@ import type { CardContext } from '@atlaskit/link-provider';
 import { type CardType } from '../../types';
 export type EditVariant = 'none' | 'edit-link' | 'edit-datasource' | 'edit-dropdown';
 export interface EditDatasourceToolbarButtonWithCommonProps {
-    intl: IntlShape;
-    onLinkEditClick: Command;
+    currentAppearance?: CardType;
     editorAnalyticsApi?: EditorAnalyticsAPI;
     editorView?: EditorView;
-    currentAppearance?: CardType;
+    intl: IntlShape;
+    onLinkEditClick: Command;
 }
 export interface EditDatasourceToolbarButtonWithUrlProps extends EditDatasourceToolbarButtonWithCommonProps {
     cardContext?: CardContext;
@@ -24,7 +24,7 @@ export interface EditDatasourceToolbarButtonWithDatasourceIdProps extends EditDa
 }
 export type EditDatasourceToolbarButtonProps = EditDatasourceToolbarButtonWithCommonProps & {
     cardContext?: CardContext;
-    url?: string;
     datasourceId?: string;
     node?: Node;
+    url?: string;
 };

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

@@ -1,8 +1,8 @@
 import React from 'react';
 import { type EditorView } from '@atlaskit/editor-prosemirror/view';
 export type EditorAnalyticsContextProps = {
-    editorView?: EditorView;
     children: React.ReactNode;
+    editorView?: EditorView;
 };
 /**
  * Provides location attribute to child events

package/dist/types/ui/EditorLinkingPlatformAnalytics/common.d.ts

@@ -3,15 +3,15 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { EditorCardPluginEvents } from '../analytics/create-events-queue';
 import type { CardPluginEvent } from '../analytics/types';
 export type AnalyticsBindingsProps = {
-    editorView: EditorView;
     cardPluginEvents: EditorCardPluginEvents<CardPluginEvent>;
+    editorView: EditorView;
 };
 type EventMetadata = {
     action?: string;
     inputMethod?: string;
-    sourceEvent?: unknown;
     isRedo?: boolean;
     isUndo?: boolean;
+    sourceEvent?: unknown;
 };
 export declare const getMethod: (metadata: EventMetadata) => string | undefined;
 export declare const getUpdateType: (metadata: EventMetadata) => string | undefined;

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

@@ -7,12 +7,12 @@ import type { EditorState } from '@atlaskit/editor-prosemirror/state';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import { type CardPlugin } from '../cardPluginType';
 export interface HyperlinkToolbarAppearanceProps {
-    intl: IntlShape;
-    editorState: EditorState;
-    url: string;
-    editorView?: EditorView;
     cardOptions?: CardOptions;
     editorAnalyticsApi: EditorAnalyticsAPI | undefined;
     editorPluginApi: ExtractInjectionAPI<CardPlugin> | undefined;
+    editorState: EditorState;
+    editorView?: EditorView;
+    intl: IntlShape;
+    url: string;
 }
 export declare function HyperlinkToolbarAppearance(props: HyperlinkToolbarAppearanceProps): React.JSX.Element | null;

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

@@ -1,7 +1,7 @@
 import type { Command, FloatingToolbarCustom, FloatingToolbarItem } from '@atlaskit/editor-common/types';
 import type { HyperlinkToolbarAppearanceProps } from './HyperlinkToolbarAppearance';
 export declare const getCustomHyperlinkAppearanceDropdown: ({ url, intl, editorAnalyticsApi, editorPluginApi, settingsConfig, cardOptions, allowDatasource, isDatasourceView, }: Omit<HyperlinkToolbarAppearanceProps, "editorState"> & {
-    settingsConfig: FloatingToolbarItem<Command>;
     allowDatasource?: boolean;
     isDatasourceView?: boolean;
+    settingsConfig: FloatingToolbarItem<Command>;
 }) => FloatingToolbarCustom<Command>;

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

@@ -5,14 +5,14 @@ import type { cardPlugin } from '../../index';
 export declare const DATASOURCE_TABLE_LAYOUTS: readonly ["full-width", "center", "wide"];
 export type DatasourceTableLayout = (typeof DATASOURCE_TABLE_LAYOUTS)[number];
 export type LayoutButtonProps = {
-    mountPoint?: HTMLElement;
     boundariesElement?: HTMLElement;
-    scrollableElement?: HTMLElement;
-    targetElement?: HTMLElement;
+    intl: IntlShape;
     layout?: DatasourceTableLayout;
+    mountPoint?: HTMLElement;
     onLayoutChange?: (layout: DatasourceTableLayout) => void;
+    scrollableElement?: HTMLElement;
+    targetElement?: HTMLElement;
     testId?: string;
-    intl: IntlShape;
 };
 export interface LayoutButtonWrapperProps extends Pick<LayoutButtonProps, 'mountPoint' | 'boundariesElement' | 'scrollableElement'> {
     api: ExtractInjectionAPI<typeof cardPlugin> | undefined;

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

@@ -6,16 +6,16 @@ import type { EditorState } from '@atlaskit/editor-prosemirror/state';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { CardContext } from '@atlaskit/link-provider';
 export interface LinkToolbarAppearanceProps {
-    intl: IntlShape;
-    editorAnalyticsApi: EditorAnalyticsAPI | undefined;
+    allowBlockCards?: boolean;
+    allowEmbeds?: boolean;
     currentAppearance?: CardAppearance;
+    editorAnalyticsApi: EditorAnalyticsAPI | undefined;
     editorState: EditorState;
     editorView?: EditorView;
-    url?: string;
-    allowEmbeds?: boolean;
-    allowBlockCards?: boolean;
-    showUpgradeDiscoverability?: boolean;
+    intl: IntlShape;
     isDatasourceView?: boolean;
+    showUpgradeDiscoverability?: boolean;
+    url?: string;
 }
 export declare class LinkToolbarAppearance extends React.Component<LinkToolbarAppearanceProps, Object> {
     renderDropdown: (view?: EditorView, cardContext?: CardContext) => React.JSX.Element | null;

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

@@ -2,13 +2,13 @@ import React from 'react';
 import type { Command, FloatingToolbarDropdown, FloatingToolbarItem } from '@atlaskit/editor-common/types';
 import { type LinkToolbarAppearanceProps } from './LinkToolbarAppearance';
 type Props = LinkToolbarAppearanceProps & {
+    allowDatasource?: boolean;
     dispatchCommand: (command: Command) => void;
     settingsConfig: FloatingToolbarItem<Command>;
-    allowDatasource?: boolean;
 };
 export declare const LinkAppearanceMenu: ({ url, intl, currentAppearance, editorState, allowEmbeds, allowBlockCards, allowDatasource, editorAnalyticsApi, isDatasourceView, dispatchCommand, settingsConfig, }: Props) => React.JSX.Element | null;
 export declare const getLinkAppearanceDropdown: ({ url, intl, currentAppearance, editorState, allowEmbeds, allowBlockCards, allowDatasource, editorAnalyticsApi, showUpgradeDiscoverability, isDatasourceView, settingsConfig, }: LinkToolbarAppearanceProps & {
-    settingsConfig: FloatingToolbarItem<Command>;
     allowDatasource?: boolean;
+    settingsConfig: FloatingToolbarItem<Command>;
 }) => FloatingToolbarDropdown<Command>;
 export {};

package/dist/types/ui/OpenPreviewButton/index.d.ts

@@ -3,9 +3,9 @@ import { type IntlShape } from 'react-intl-next';
 import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 type OpenPreviewPanelToolbarButtonProps = {
-    node: PMNode;
-    intl: IntlShape;
     editorAnalyticsApi?: EditorAnalyticsAPI;
+    intl: IntlShape;
+    node: PMNode;
 };
 export declare const OpenPreviewPanelToolbarButton: ({ node, intl, }: OpenPreviewPanelToolbarButtonProps) => React.JSX.Element | null;
 export {};

package/dist/types/ui/Pulse/index.d.ts

@@ -5,6 +5,12 @@ export interface PulseProps {
      * The component around which the Pulse should be displayed
      */
     children: JSX.Element;
+    /**
+     * Indicates when the feature is considered discovered. If "start" is passed, local storage key will be invalidated
+     * as soon as the animation starts. If "iteration" is passed (the default one), it will be invalidated after the first iteration
+     */
+    discoveryMode?: PulseDiscoveryMode;
+    isInline?: boolean;
     /**
      * The key that is used in local storage to identify the descoverability of a feature where the Pulse is used
      */
@@ -13,13 +19,7 @@ export interface PulseProps {
      * The time in ms after which the key in local storage will be considered expired and the Pulse will be shown again
      */
     localStorageKeyExpirationInMs?: number;
-    /**
-     * Indicates when the feature is considered discovered. If "start" is passed, local storage key will be invalidated
-     * as soon as the animation starts. If "iteration" is passed (the default one), it will be invalidated after the first iteration
-     */
-    discoveryMode?: PulseDiscoveryMode;
     shouldShowPulse?: boolean;
     testId?: string;
-    isInline?: boolean;
 }
 export declare const DiscoveryPulse: ({ children, localStorageKey, localStorageKeyExpirationInMs, discoveryMode, shouldShowPulse, testId, isInline, }: PulseProps) => React.JSX.Element;

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

@@ -11,10 +11,10 @@ type State = {
     resizedPctWidth?: number;
 };
 export type Props = Omit<ResizerProps, 'height' | 'width'> & {
-    width?: number;
-    height?: number;
     aspectRatio: number;
+    height?: number;
     isResizeDisabled?: boolean;
+    width?: number;
 };
 export default class ResizableEmbedCard extends React.Component<Props, State> {
     static defaultProps: {

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

@@ -1,8 +1,8 @@
 import React from 'react';
 import type { EditorAnalyticsContextProps } from './EditorAnalyticsContext';
 type ToolbarViewedEventProps = {
-    url?: string;
     display: string | null;
+    url?: string;
 };
 /**
  * Provides analytics context and card context

package/dist/types/ui/analytics/create-events-queue.d.ts

@@ -1,9 +1,9 @@
 export type Subscriber<T> = (event: T) => void;
 export type EditorCardPluginEvents<T> = {
-    push: (...events: T[]) => void;
-    subscribe: (listener: Subscriber<T>) => () => void;
     flush: () => void;
     getSize: () => number;
+    push: (...events: T[]) => void;
+    subscribe: (listener: Subscriber<T>) => () => void;
 };
 /**
  * Simple mechanism to defer event related callbacks

package/dist/types/ui/analytics/events-from-tr.d.ts

@@ -7,8 +7,8 @@ export declare const findChanged: (tr: Transaction | ReadonlyTransaction, state:
     removed: Entity[];
     inserted: Entity[];
     updated: ({
-        removed: Entity;
         inserted: Entity;
+        removed: Entity;
     } | {
         inserted: Entity;
         previous: {

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

@@ -1,17 +1,17 @@
 import type { Node } from '@atlaskit/editor-prosemirror/model';
 export type Entity = {
-    pos: number;
     node: Node;
     nodeContext: string;
+    pos: number;
 };
 type Metadata<T = Object> = {
-    node: Node;
-    isUndo?: boolean;
-    isRedo?: boolean;
     action?: string;
     inputMethod?: string;
-    sourceEvent?: unknown;
+    isRedo?: boolean;
+    isUndo?: boolean;
+    node: Node;
     nodeContext?: string;
+    sourceEvent?: unknown;
 } & T;
 type UpdateMetadata = {
     previousDisplay?: string;
@@ -31,34 +31,34 @@ export declare enum EVENT_SUBJECT {
  * events can be derived from them / think of them in the same way
  */
 export type LinkCreatedEvent = {
+    data: Metadata;
     event: EVENT.CREATED;
     subject: EVENT_SUBJECT.LINK;
-    data: Metadata;
 };
 export type LinkUpdatedEvent = {
+    data: Metadata<UpdateMetadata>;
     event: EVENT.UPDATED;
     subject: EVENT_SUBJECT.LINK;
-    data: Metadata<UpdateMetadata>;
 };
 export type LinkDeletedEvent = {
+    data: Metadata;
     event: EVENT.DELETED;
     subject: EVENT_SUBJECT.LINK;
-    data: Metadata;
 };
 export type DatasourceCreatedEvent = {
+    data: Metadata;
     event: EVENT.CREATED;
     subject: EVENT_SUBJECT.DATASOURCE;
-    data: Metadata;
 };
 export type DatasourceUpdatedEvent = {
+    data: Metadata<UpdateMetadata>;
     event: EVENT.UPDATED;
     subject: EVENT_SUBJECT.DATASOURCE;
-    data: Metadata<UpdateMetadata>;
 };
 export type DatasourceDeletedEvent = {
+    data: Metadata;
     event: EVENT.DELETED;
     subject: EVENT_SUBJECT.DATASOURCE;
-    data: Metadata;
 };
 export type LinkEvent = LinkCreatedEvent | LinkUpdatedEvent | LinkDeletedEvent;
 export type DatasourceEvent = DatasourceCreatedEvent | DatasourceUpdatedEvent | DatasourceDeletedEvent;

package/dist/types/ui/analytics/utils.d.ts

@@ -10,7 +10,7 @@ export declare function getNodeSubject(node: Node): EVENT_SUBJECT | null;
 /**
  * Analytics appearance for link object
  */
-export declare function appearanceForLink(node: Node): "url" | import("@atlaskit/editor-common/provider-factory").CardAppearance;
+export declare function appearanceForLink(node: Node): import("@atlaskit/editor-common/provider-factory").CardAppearance | "url";
 export declare function getUrl(node: Node): string | undefined;
 export declare const getNodeContext: (doc: Node, pos: number) => string;
 export declare const findAtPositions: (tr: Transaction | ReadonlyTransaction, positions: number[]) => Entity[];