@atlaskit/editor-plugin-card 0.1.0

package/dist/types/pm-plugins/analytics/create-analytics-queue.d.ts

@@ -0,0 +1,10 @@
+import { LifecycleEvent, SmartLinkEventsNext } from '../../types';
+/**
+ * Simple mechanism to defer analytics related callbacks
+ */
+export declare const createAnalyticsQueue: (enabled?: boolean) => {
+    push: (...events: LifecycleEvent[]) => void;
+    flush: () => void;
+    setCallbacks: (callbacks: SmartLinkEventsNext) => void;
+    getSize: () => number;
+};

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

@@ -0,0 +1,17 @@
+import { EditorState, ReadonlyTransaction, Transaction } from 'prosemirror-state';
+import { LifecycleEvent } from '../../types';
+import { Link } from './types';
+export declare const findChangedLinks: (tr: Transaction | ReadonlyTransaction, state: EditorState) => {
+    removed: Link[];
+    inserted: Link[];
+    updated: ({
+        removed: Link;
+        inserted: Link;
+    } | {
+        inserted: Link;
+        previous: {
+            display?: string;
+        };
+    })[];
+};
+export declare function eventsFromTransaction(tr: ReadonlyTransaction, state: EditorState): LifecycleEvent[];

package/dist/types/pm-plugins/analytics/index.d.ts

@@ -0,0 +1,2 @@
+export { createAnalyticsQueue } from './create-analytics-queue';
+export { eventsFromTransaction } from './events-from-tr';

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

@@ -0,0 +1,12 @@
+import { Mark, Node } from 'prosemirror-model';
+export type Link = {
+    type: 'node';
+    pos: number;
+    node: Node;
+    nodeContext: string;
+} | {
+    type: 'mark';
+    pos: number;
+    mark: Mark;
+    nodeContext: string;
+};

package/dist/types/pm-plugins/analytics/utils.d.ts

@@ -0,0 +1,32 @@
+import { Node, Schema } from 'prosemirror-model';
+import { ReadonlyTransaction, Transaction } from 'prosemirror-state';
+import { Link } from './types';
+/**
+ * Whether a node is a "link" node, ie inline card, block card, embed card
+ * (but not a text node with a link mark)
+ */
+export declare function isLinkNode(node: Node): boolean;
+/**
+ * Analytics appearance for link object
+ */
+export declare function appearanceForLink(link: Link): "url" | import("@atlaskit/editor-common/provider-factory").CardAppearance;
+/**
+ * Determine if a node is considered to be a link
+ */
+export declare const isLink: (schema: Schema, node: Node) => boolean;
+/**
+ * Given a node, find all nodes and marks that are considered "links"
+ * @param state EditorState
+ * @param fragment Fragment to search
+ * @returns Array of nodes and marks found in the fragment that are "links"
+ */
+export declare function findLinksInNode(doc: Node, schema: Schema, node: Node, offset: number): Link[];
+export declare function getLinkUrl(link: Link): string | undefined;
+export declare const getLinkNodeContext: (doc: Node, pos: number) => string;
+export declare const linkObjectFromNode: (doc: Node, schema: Schema, node: Node, pos: number) => Link | undefined;
+export declare const findLinksAtPositions: (tr: Transaction | ReadonlyTransaction, positions: number[]) => Link[];
+/**
+ * Returns whether or not two sets of links appear to likely be the same set of links
+ * That they are in the same order and that both their hrefs and appearances match
+ */
+export declare const areSameLinks: (linksA: Link[], linksB: Link[]) => boolean;

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

@@ -0,0 +1,22 @@
+import { Node } from 'prosemirror-model';
+import { EditorState, Transaction } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import type { CreateUIAnalyticsEvent, UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { ACTION, EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { CardReplacementInputMethod } from '@atlaskit/editor-common/card';
+import { CardAdf, CardAppearance, DatasourceAdf } from '@atlaskit/editor-common/provider-factory';
+import type { Command } from '@atlaskit/editor-common/types';
+import type { InlineCardAdf } from '@atlaskit/smart-card';
+import { Request } from '../types';
+export declare const replaceQueuedUrlWithCard: (url: string, cardData: CardAdf | DatasourceAdf, analyticsAction?: ACTION, editorAnalyticsApi?: EditorAnalyticsAPI, createAnalyticsEvent?: CreateUIAnalyticsEvent) => Command;
+export declare const handleFallbackWithAnalytics: (request: Request, editorAnalyticsApi: EditorAnalyticsAPI | undefined) => Command;
+export declare const queueCardsFromChangedTr: (state: EditorState, tr: Transaction, source: CardReplacementInputMethod, analyticsAction?: ACTION, normalizeLinkText?: boolean, sourceEvent?: UIAnalyticsEvent | null | undefined) => Transaction;
+export declare const queueCardFromChangedTr: (state: EditorState, tr: Transaction, source: CardReplacementInputMethod, analyticsAction: ACTION, normalizeLinkText?: boolean, sourceEvent?: UIAnalyticsEvent | null | undefined, previousAppearance?: CardAppearance | 'url') => Transaction;
+export declare const convertHyperlinkToSmartCard: (state: EditorState, source: CardReplacementInputMethod, appearance: CardAppearance, normalizeLinkText?: boolean) => Transaction;
+export declare const changeSelectedCardToLink: (text?: string, href?: string, sendAnalytics?: boolean, node?: Node, pos?: number, editorAnalyticsApi?: EditorAnalyticsAPI) => Command;
+export declare const changeSelectedCardToLinkFallback: (text?: string, href?: string, sendAnalytics?: boolean, node?: Node, pos?: number, editorAnalyticsApi?: EditorAnalyticsAPI) => Command;
+export declare const updateCard: (href: string, sourceEvent?: UIAnalyticsEvent | null | undefined) => Command;
+export declare const changeSelectedCardToText: (text: string, editorAnalyticsApi: EditorAnalyticsAPI | undefined) => Command;
+export declare const setSelectedCardAppearance: (appearance: CardAppearance, editorAnalyticsApi: EditorAnalyticsAPI | undefined) => Command;
+export declare const updateExistingDatasource: (state: EditorState, node: Node, newAdf: DatasourceAdf | InlineCardAdf, view: EditorView) => void;
+export declare const insertDatasource: (state: EditorState, adf: DatasourceAdf | InlineCardAdf, view: EditorView) => void;

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

@@ -0,0 +1,3 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { FeatureFlags } from '@atlaskit/editor-common/types';
+export declare function cardKeymap(featureFlags: FeatureFlags): SafePlugin;

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

@@ -0,0 +1,6 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ExtractInjectionAPI, PMPluginFactoryParams } from '@atlaskit/editor-common/types';
+import type { cardPlugin } from '../index';
+import { CardPluginOptions, CardPluginState } from '../types';
+export { pluginKey } from './plugin-key';
+export declare const createPlugin: (options: CardPluginOptions, pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined) => (pmPluginFactoryParams: PMPluginFactoryParams) => SafePlugin<CardPluginState>;

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

@@ -0,0 +1,5 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { cardPlugin } from '../index';
+import { CardPluginOptions } from '../types';
+export declare const mountHyperlinkPlugin: (pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined, options: CardPluginOptions) => SafePlugin<any>;

package/dist/types/pm-plugins/plugin-key.d.ts

@@ -0,0 +1,3 @@
+import { PluginKey } from 'prosemirror-state';
+import { CardPluginState } from '../types';
+export declare const pluginKey: PluginKey<CardPluginState>;

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

@@ -0,0 +1,3 @@
+import { CardPluginAction, CardPluginState } from '../types';
+declare const _default: (state: CardPluginState, action: CardPluginAction) => CardPluginState;
+export default _default;

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

@@ -0,0 +1,2 @@
+import { Node } from 'prosemirror-model';
+export declare function shouldReplaceLink(node: Node, compareLinkText?: boolean, compareToUrl?: string): boolean;

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

@@ -0,0 +1,8 @@
+import { EditorView } from 'prosemirror-view';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { CardOptions } from '@atlaskit/editor-common/card';
+import { CardProvider, DatasourceAdf } from '@atlaskit/editor-common/provider-factory';
+import { Request } from '../../types';
+export declare const resolveWithProvider: (view: EditorView, provider: CardProvider, request: Request, options: CardOptions, editorAnalyticsApi: EditorAnalyticsAPI | undefined, createAnalyticsEvent: CreateUIAnalyticsEvent | undefined) => Promise<void | import("@atlaskit/linking-common").InlineCardAdf | import("@atlaskit/linking-common").BlockCardAdf | import("@atlaskit/linking-common").EmbedCardAdf | DatasourceAdf>;
+export declare const handleProvider: (_: 'cardProvider', provider: Promise<CardProvider> | undefined, view: EditorView) => void;

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

@@ -0,0 +1,31 @@
+import { EditorState, ReadonlyTransaction } from 'prosemirror-state';
+import { CardPluginState, Request } from '../../types';
+export declare const getPluginState: (editorState: EditorState) => CardPluginState | undefined;
+export declare const getPluginStateWithUpdatedPos: (pluginState: CardPluginState, tr: ReadonlyTransaction) => {
+    requests: {
+        pos: number;
+        url: string;
+        appearance: import("@atlaskit/editor-common/provider-factory").CardAppearance;
+        compareLinkText: boolean;
+        source: import("@atlaskit/editor-common/card").CardReplacementInputMethod;
+        previousAppearance?: "url" | import("@atlaskit/editor-common/provider-factory").CardAppearance | undefined;
+        analyticsAction?: import("@atlaskit/editor-common/analytics").ACTION | undefined;
+        shouldReplaceLink?: boolean | undefined;
+        sourceEvent?: import("@atlaskit/analytics-next").UIAnalyticsEvent | null | undefined;
+    }[];
+    cards: {
+        pos: number;
+        title?: string | undefined;
+        url?: string | undefined;
+    }[];
+    provider: import("@atlaskit/editor-common/provider-factory").CardProvider | null;
+    showLinkingToolbar: boolean;
+    smartLinkEvents?: import("@atlaskit/smart-card").SmartLinkEvents | undefined;
+    smartLinkEventsNext?: import("../../types").SmartLinkEventsNext | undefined;
+    editorAppearance?: import("@atlaskit/editor-common/types").EditorAppearance | undefined;
+    showDatasourceModal: boolean;
+    datasourceModalType?: "jira" | undefined;
+    datasourceTableRef?: HTMLElement | undefined;
+    layout?: import("../../ui/LayoutButton/types").DatasourceTableLayout | undefined;
+};
+export declare const getNewRequests: (oldState: CardPluginState | undefined, currentState: CardPluginState) => Request[];

package/dist/types/toolbar.d.ts

@@ -0,0 +1,9 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { CardOptions } from '@atlaskit/editor-common/card';
+import type { Command, ExtractInjectionAPI, FeatureFlags, FloatingToolbarHandler, LinkPickerOptions } from '@atlaskit/editor-common/types';
+import { CardPlatform } from '@atlaskit/smart-card';
+import type { cardPlugin } from './index';
+export declare const removeCard: (editorAnalyticsApi: EditorAnalyticsAPI | undefined) => Command;
+export declare const visitCardLink: (editorAnalyticsApi: EditorAnalyticsAPI | undefined) => Command;
+export declare const openLinkSettings: (editorAnalyticsApi: EditorAnalyticsAPI | undefined) => Command;
+export declare const floatingToolbar: (cardOptions: CardOptions, featureFlags: FeatureFlags, platform?: CardPlatform, linkPickerOptions?: LinkPickerOptions, pluginInjectionApi?: ExtractInjectionAPI<typeof cardPlugin>) => FloatingToolbarHandler;

package/dist/types/types.d.ts

@@ -0,0 +1,163 @@
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { ACTION } from '@atlaskit/editor-common/analytics';
+import type { CardOptions, CardReplacementInputMethod } from '@atlaskit/editor-common/card';
+import { CardAppearance, CardProvider } from '@atlaskit/editor-common/provider-factory';
+import type { DatasourceModalType, EditorAppearance, LinkPickerOptions } from '@atlaskit/editor-common/types';
+import { SmartLinkEvents } from '@atlaskit/smart-card';
+import { DatasourceTableLayout } from './ui/LayoutButton/types';
+export type CardInfo = {
+    title?: string;
+    url?: string;
+    pos: number;
+};
+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
+     */
+    url: string;
+    /**
+     * The requested appearance to upgrade to
+     */
+    appearance: CardAppearance;
+    /**
+     * Determines if the link should only be replaced after successful
+     * resolution if the link's text content still matches its href
+     * (ie has not been changed by the user since the resolve 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.
+     */
+    source: CardReplacementInputMethod;
+    /**
+     * The previous appearance of the link
+     * This is necessary when tracking an update of a link
+     * where the link begins as a smart card, then is updated by
+     * 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
+     * to explicitly change the link appearance to the target appearance (view switcher), and therefore
+     * should not be affected by "default appearances" or "user preferences"
+     */
+    shouldReplaceLink?: boolean;
+    /**
+     * 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;
+};
+export type Metadata<T = {}> = {
+    url: string;
+    display: string;
+    isUndo?: boolean;
+    isRedo?: boolean;
+    action?: string;
+    inputMethod?: string;
+    sourceEvent?: unknown;
+    nodeContext?: string;
+} & T;
+export type UpdateMetadata = {
+    previousDisplay?: string;
+};
+export type SmartLinkEventsNext = {
+    created: (metadata: Metadata) => void;
+    updated: (metadata: Metadata<UpdateMetadata>) => void;
+    deleted: (metadata: Metadata) => void;
+};
+export type LifecycleEventType = keyof SmartLinkEventsNext;
+/**
+ * Describes the shape of an event that will be stored
+ * in the Card state until it can be dispatched
+ * as a side-effect in a view update
+ */
+export type LifecycleEvent<Type extends keyof SmartLinkEventsNext = keyof SmartLinkEventsNext> = {
+    type: Type;
+    data: Parameters<SmartLinkEventsNext[Type]>[0];
+};
+export type CardPluginState = {
+    requests: Request[];
+    provider: CardProvider | null;
+    cards: CardInfo[];
+    showLinkingToolbar: boolean;
+    smartLinkEvents?: SmartLinkEvents;
+    smartLinkEventsNext?: SmartLinkEventsNext;
+    editorAppearance?: EditorAppearance;
+    showDatasourceModal: boolean;
+    datasourceModalType?: DatasourceModalType;
+    datasourceTableRef?: HTMLElement;
+    layout?: DatasourceTableLayout;
+};
+export type CardPluginOptions = CardOptions & {
+    editorAppearance?: EditorAppearance;
+    platform: 'mobile' | 'web';
+    fullWidthMode?: boolean;
+    linkPicker?: LinkPickerOptions;
+};
+export type SetProvider = {
+    type: 'SET_PROVIDER';
+    provider: CardProvider | null;
+};
+export type Queue = {
+    type: 'QUEUE';
+    requests: Request[];
+};
+export type Resolve = {
+    type: 'RESOLVE';
+    url: string;
+};
+export type Register = {
+    type: 'REGISTER';
+    info: CardInfo;
+};
+export type ShowLinkToolbar = {
+    type: 'SHOW_LINK_TOOLBAR';
+};
+export type HideLinkToolbar = {
+    type: 'HIDE_LINK_TOOLBAR';
+};
+export type ShowDatasourceModal = {
+    type: 'SHOW_DATASOURCE_MODAL';
+    modalType: DatasourceModalType;
+};
+export type HideDatasourceModal = {
+    type: 'HIDE_DATASOURCE_MODAL';
+};
+export type RegisterSmartCardEvents = {
+    type: 'REGISTER_EVENTS';
+    smartLinkEvents: SmartLinkEvents;
+};
+export type RegisterSmartCardEventsNext = {
+    type: 'REGISTER_EVENTS_NEXT';
+    smartLinkEvents: SmartLinkEventsNext;
+};
+export type SetDatasourceTableRef = {
+    type: 'SET_DATASOURCE_TABLE_REF';
+    datasourceTableRef?: HTMLElement;
+};
+export type SetCardLayout = {
+    type: 'SET_CARD_LAYOUT';
+    layout: DatasourceTableLayout;
+};
+export type SetCardLayoutAndDatasourceTableRef = {
+    type: 'SET_CARD_LAYOUT_AND_DATASOURCE_TABLE_REF';
+    layout: DatasourceTableLayout;
+    datasourceTableRef?: HTMLElement;
+};
+export type CardPluginAction = SetProvider | Queue | Resolve | Register | ShowLinkToolbar | HideLinkToolbar | ShowDatasourceModal | HideDatasourceModal | RegisterSmartCardEvents | RegisterSmartCardEventsNext | SetDatasourceTableRef | SetCardLayout | SetCardLayoutAndDatasourceTableRef;

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { EditorView } from 'prosemirror-view';
+import { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { cardPlugin } from '../../plugin';
+declare const ModalWithState: ({ api, editorView, }: {
+    api: ExtractInjectionAPI<typeof cardPlugin> | undefined;
+    editorView: EditorView;
+}) => JSX.Element | null;
+export default ModalWithState;

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { EditorView } from 'prosemirror-view';
+import { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { DatasourceModalType } from '@atlaskit/editor-common/types';
+type DatasourceModalProps = {
+    view: EditorView;
+    editorAnalyticsApi?: EditorAnalyticsAPI;
+    modalType?: DatasourceModalType;
+};
+export declare const DatasourceModal: ({ view, modalType }: DatasourceModalProps) => JSX.Element | null;
+export {};

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

@@ -0,0 +1,47 @@
+import React from 'react';
+import { Node } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { HyperlinkAddToolbarProps } from '@atlaskit/editor-common/link';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { Command, ExtractInjectionAPI, FloatingToolbarConfig, FloatingToolbarItem, LinkInputType, LinkPickerOptions } from '@atlaskit/editor-common/types';
+import { FeatureFlags } from '@atlaskit/editor-common/types';
+import type { ForceFocusSelector } from '@atlaskit/editor-plugin-floating-toolbar';
+import type { cardPlugin } from '../plugin';
+interface InjectionAPI {
+    pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined;
+}
+export type EditLinkToolbarProps = InjectionAPI & {
+    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;
+    featureFlags: FeatureFlags;
+    forceFocusSelector: ForceFocusSelector | undefined;
+};
+export declare function HyperlinkAddToolbarWithState({ linkPickerOptions, onSubmit, displayText, displayUrl, providerFactory, view, onCancel, invokeMethod, featureFlags, onClose, onEscapeCallback, onClickAwayCallback, pluginInjectionApi, }: HyperlinkAddToolbarProps & InjectionAPI): JSX.Element;
+export declare class EditLinkToolbar extends React.Component<EditLinkToolbarProps> {
+    componentDidUpdate(prevProps: EditLinkToolbarProps): void;
+    componentWillUnmount(): void;
+    /** Focus should move to the 'Edit link' button when the toolbar closes
+     * and not close the floating toolbar.
+     */
+    private handleEsc;
+    private hideLinkToolbar;
+    render(): JSX.Element;
+}
+export declare const editLink: (editorAnalyticsApi: EditorAnalyticsAPI | undefined) => Command;
+export declare const buildEditLinkToolbar: ({ providerFactory, node, linkPicker, featureFlags, pluginInjectionApi, }: {
+    providerFactory: ProviderFactory;
+    node: Node;
+    linkPicker?: LinkPickerOptions | undefined;
+    featureFlags: FeatureFlags;
+    pluginInjectionApi: ExtractInjectionAPI<typeof cardPlugin> | undefined;
+}) => FloatingToolbarItem<Command>;
+export declare const editLinkToolbarConfig: (showLinkingToolbar: boolean, lpLinkPicker: boolean) => Partial<FloatingToolbarConfig>;
+export declare const editDatasource: (node: Node, editorAnalyticsApi: EditorAnalyticsAPI | undefined) => Command;
+export {};

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

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+import { EditorView } from 'prosemirror-view';
+export declare const EditorSmartCardEvents: FC<{
+    editorView: EditorView;
+}>;

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { EditorView } from 'prosemirror-view';
+type AnalyticsBindingsProps = {
+    editorView: EditorView;
+};
+/**
+ * Binds the @atlaskit/link-analytics callbacks
+ * to the editor card plugin state events callbacks interfaces
+ */
+export declare const EventsBinding: ({ editorView }: AnalyticsBindingsProps) => null;
+export declare class EditorSmartCardEventsNext extends React.PureComponent<AnalyticsBindingsProps> {
+    static contextTypes: {
+        contextAdapter: PropTypes.Requireable<object>;
+    };
+    render(): JSX.Element | null;
+}
+export {};

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

@@ -0,0 +1,32 @@
+import { Component } from 'react';
+import { EditorState } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { IntlShape } from 'react-intl-next';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { CardOptions } from '@atlaskit/editor-common/card';
+import type { CardPluginActions } from '@atlaskit/editor-common/card';
+import { CardProvider, ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { CardPlatform } from '@atlaskit/smart-card';
+export interface HyperlinkToolbarAppearanceProps {
+    intl: IntlShape;
+    editorState: EditorState;
+    providerFactory: ProviderFactory;
+    url: string;
+    editorView?: EditorView;
+    platform?: CardPlatform;
+    cardOptions?: CardOptions;
+    editorAnalyticsApi: EditorAnalyticsAPI | undefined;
+    cardActions: CardPluginActions | undefined;
+}
+export interface HyperlinkToolbarAppearanceState {
+    supportedUrlsMap: Map<string, boolean>;
+}
+export declare class HyperlinkToolbarAppearance extends Component<HyperlinkToolbarAppearanceProps, HyperlinkToolbarAppearanceState> {
+    state: HyperlinkToolbarAppearanceState;
+    cardProvider?: CardProvider;
+    private getProvider;
+    private resolveUrl;
+    componentDidMount: () => Promise<void>;
+    UNSAFE_componentWillReceiveProps(nextProps: HyperlinkToolbarAppearanceProps): void;
+    render(): JSX.Element | null;
+}

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

@@ -0,0 +1,9 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { LayoutButtonProps, LayoutButtonWrapperProps } from './types';
+export declare const LayoutButton: React.FC<LayoutButtonProps>;
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<LayoutButtonWrapperProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<LayoutButtonWrapperProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,19 @@
+import { EditorView } from 'prosemirror-view';
+import { IntlShape } from 'react-intl-next';
+import { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { cardPlugin } from '../../index';
+export type DatasourceTableLayout = 'full-width' | 'center' | 'wide';
+export type LayoutButtonProps = {
+    mountPoint?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    targetElement?: HTMLElement;
+    layout: DatasourceTableLayout;
+    onLayoutChange?: (layout: DatasourceTableLayout) => void;
+    testId?: string;
+    intl: IntlShape;
+};
+export interface LayoutButtonWrapperProps extends Pick<LayoutButtonProps, 'mountPoint' | 'boundariesElement' | 'scrollableElement'> {
+    api: ExtractInjectionAPI<typeof cardPlugin> | undefined;
+    editorView: EditorView;
+}

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

@@ -0,0 +1,5 @@
+import { EditorView } from 'prosemirror-view';
+export declare const getDatasource: (editorView: EditorView) => import("prosemirror-utils").ContentNodeWithPos | {
+    node: undefined;
+    pos: undefined;
+};

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

@@ -0,0 +1,29 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { EditorState } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { IntlShape } from 'react-intl-next';
+import { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { CardPluginActions } from '@atlaskit/editor-common/card';
+import { CardAppearance } from '@atlaskit/editor-common/provider-factory';
+import { CardContext } from '@atlaskit/link-provider';
+import { CardPlatform } from '@atlaskit/smart-card';
+export interface LinkToolbarAppearanceProps {
+    intl: IntlShape;
+    editorAnalyticsApi: EditorAnalyticsAPI | undefined;
+    currentAppearance?: CardAppearance;
+    editorState: EditorState;
+    editorView?: EditorView;
+    url?: string;
+    allowEmbeds?: boolean;
+    allowBlockCards?: boolean;
+    platform?: CardPlatform;
+    cardActions: CardPluginActions | undefined;
+}
+export declare class LinkToolbarAppearance extends React.Component<LinkToolbarAppearanceProps, {}> {
+    static contextTypes: {
+        contextAdapter: PropTypes.Requireable<object>;
+    };
+    renderDropdown: (view?: EditorView, cardContext?: CardContext) => JSX.Element | null;
+    render(): JSX.Element | null;
+}

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

@@ -0,0 +1,61 @@
+/// <reference path="../../../../../../typings/prosemirror.d.ts" />
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { RichMediaLayout } from '@atlaskit/adf-schema';
+import { ResizerProps } from '@atlaskit/editor-common/ui';
+type State = {
+    offsetLeft: number;
+    resizedPctWidth?: number;
+};
+export type Props = Omit<ResizerProps, 'height' | 'width'> & {
+    width?: number;
+    height?: number;
+    aspectRatio: number;
+};
+export default class ResizableEmbedCard extends React.Component<Props, State> {
+    static defaultProps: {
+        aspectRatio: number;
+    };
+    state: State;
+    componentDidUpdate(): void;
+    get wrappedLayout(): boolean;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    /**
+     * When returning to center layout from a wrapped/aligned layout, it might actually
+     * be wide or full-width
+     */
+    checkLayout(oldLayout: RichMediaLayout, newLayout: RichMediaLayout): void;
+    calcNewSize: (newWidth: number, stop: boolean) => {
+        width: number | null;
+        layout: RichMediaLayout;
+    };
+    calcUnwrappedLayout: (pct: number, width: number) => 'center' | 'wide' | 'full-width';
+    get $pos(): import("prosemirror-model").ResolvedPos | null;
+    /**
+     * The maxmimum number of grid columns this node can resize to.
+     */
+    get gridWidth(): number;
+    calcOffsetLeft(): number;
+    calcColumnLeftOffset: () => number;
+    wrapper?: HTMLElement;
+    get wideLayoutWidth(): number;
+    calcSnapPoints(): number[];
+    calcPxWidth: (useLayout?: RichMediaLayout) => number;
+    get insideInlineLike(): boolean;
+    highlights: (newWidth: number, snapPoints: number[]) => string[] | number[];
+    /**
+     * Previously height of the box was controlled with paddingTop/paddingBottom trick inside Wrapper.
+     * It allowed height to be defined by a given percent ratio and so absolute value was defined by actual width.
+     * Also, it was part of styled component, which was fine because it was static through out life time of component.
+     *
+     * Now, two things changed:
+     * 1. If `height` is present we take it as actual height of the box, and hence we don't need
+     * (or even can't have, due to lack of width value) paddingTop trick.
+     * 2. Since `height` can be changing through out life time of a component, we can't have it as part of styled component,
+     * and hence we use `style` prop.
+     */
+    private getHeightDefiningComponent;
+    render(): jsx.JSX.Element;
+}
+export {};

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

@@ -0,0 +1,3 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+export declare const SmallerEditIcon: () => jsx.JSX.Element;

package/dist/types/utils.d.ts

@@ -0,0 +1,19 @@
+import { Node, NodeType } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { CardAppearance } from '@atlaskit/editor-common/provider-factory';
+import type { CardInfo } from './types';
+export declare const appearanceForNodeType: (spec: NodeType) => CardAppearance | undefined;
+export declare const selectedCardAppearance: (state: EditorState) => CardAppearance | undefined;
+export type TitleUrlPair = {
+    title?: string;
+    url?: string;
+};
+export declare const titleUrlPairFromNode: (node: Node) => TitleUrlPair;
+/**
+ * Merges the title and url from attributes and CardInfo from the resolved view, preferring the CardInfo.
+ * @param titleUrlPair title and url information from the node attributes
+ * @param info information stored in state from the resolved UI component view
+ */
+export declare const mergeCardInfo: (titleUrlPair: TitleUrlPair, info?: CardInfo) => TitleUrlPair;
+export declare const displayInfoForCard: (node: Node, info?: CardInfo) => TitleUrlPair;
+export declare const findCardInfo: (state: EditorState) => CardInfo | undefined;

package/dist/types-ts4.5/index.d.ts

@@ -0,0 +1,2 @@
+export { cardPlugin } from './plugin';
+export type { Request } from './types';