@atlaskit/editor-common 74.0.0 → 74.1.0

package/dist/types/types/performance-tracking.d.ts

@@ -0,0 +1,343 @@
+export type TTITracking = {
+    /**
+     * @description Whether ttiTracking should be enabled
+     * @default: false
+     */
+    enabled: boolean;
+    /**
+     * @description Time between long tasks that tti measurement considers long enough to treat page as interactive in ms
+     * @default: 1000
+     */
+    ttiIdleThreshold?: number;
+    /**
+     * @description Time in [seconds] after which to stop tti measurements, used to prevent issues when page never becomes responsive, e.g. infinite loops in rendering / etc...
+     * @default: 60
+     */
+    ttiCancelTimeout?: number;
+    /**
+     * @description Control whether TTI severity is tracked. When this is false the severity is not recorded.
+     * @default false
+     */
+    trackSeverity?: boolean;
+    /**
+     * @description Control for calculating tti severity level (NORMAL/DEGRADED/BLOCKING). Depends on trackSeverity being true.
+     * @default 40000
+     */
+    ttiSeverityNormalThreshold?: number;
+    /**
+     * @description Control for calculating tti severity level (NORMAL/DEGRADED/BLOCKING). Depends on trackSeverity being true.
+     * @default 60000
+     */
+    ttiSeverityDegradedThreshold?: number;
+    /**
+     * @description Control for calculating ttiFromInvocation severity level (NORMAL/DEGRADED/BLOCKING). Depends on trackSeverity being true.
+     * @default 5000
+     */
+    ttiFromInvocationSeverityNormalThreshold?: number;
+    /**
+     * @description Control for calculating ttiFromInvocation severity level (NORMAL/DEGRADED/BLOCKING). Depends on trackSeverity being true.
+     * @default 8000
+     */
+    ttiFromInvocationSeverityDegradedThreshold?: number;
+};
+export type TransactionTracking = {
+    /**
+     * @description Whether transactionTracking should be enabled. When this is false no measurements are taken and no events are sent.
+     * @default false
+     **/
+    enabled: boolean;
+    /**
+     * @description Enable timing using browser performance API. This option has been added to verify memory leaks.
+     * @default false
+     **/
+    usePerformanceMarks?: boolean;
+    /**
+     * @description The nth transaction after which a `dispatchTransaction` event is sent. Depends on enabled being true.
+     * @default 100
+     **/
+    samplingRate?: number;
+    /**
+     * @description Transactions that need longer to dispatch than [slowThreshold]ms generate a `dispatchTransaction` event. Depends on enabled being true.
+     * @default 300
+     **/
+    slowThreshold?: number;
+    /**
+     * @description Transactions that need longer to dispatch than [outlierThreshold]ms AND have outlier plugins generate a `dispatchTransaction` event. Depends on enabled being true.
+     * @default 30
+     **/
+    outlierThreshold?: number;
+    /**
+     * @description The factor by which statistically significant outliers in plugin execution times are computed where t = p75 + (p75 - p25) * outlierFactor.
+     * @default 3
+     **/
+    outlierFactor?: number;
+};
+export type UITracking = {
+    /**
+     * @description Whether tracking of WithPluginState should be enabled. When this is false no measurements are taken and no events are sent.
+     * @default false
+     **/
+    enabled: boolean;
+    /**
+     * @description The nth re-render of WithPluginState after which an analytics event is sent. Depends on enabled being true.
+     * @default 100
+     **/
+    samplingRate?: number;
+    /**
+     * @description WithPluginState render that exceeds [slowThreshold]ms generate analytics event. Depends on enabled being true.
+     * @default 4
+     **/
+    slowThreshold?: number;
+};
+export type CatchAllTracking = {
+    /**
+     * @description Control whether a second operational event with a rough performance measurement is sent for every regular analytics event
+     * @default false
+     */
+    enabled: boolean;
+};
+export type NodeViewTracking = {
+    /**
+     * @description Control whether
+      NodeView performance is tracked. When this is false no measurements are taken and no events are sent.
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * @description The nth re-render of NodeView after which an analytics event is sent. Depends on enabled being true.
+     * @default false
+     */
+    samplingRate?: 100;
+    /**
+     * @description NodeView render that exceeds the threshold generate analytics event. Depends on enabled being true.
+     * @default 7
+     */
+    slowThreshold?: number;
+};
+export type BrowserFreezetracking = {
+    enabled?: boolean;
+    /**
+     * @description Control whether browser freeze interaction type is tracked. When this is false the interaction type is not recorded.
+     * @default false
+     */
+    trackInteractionType?: boolean;
+    /**
+     * @description Control whether browser freeze severity is tracked. When this is false the severity is not recorded.
+     * @default false
+     */
+    trackSeverity?: boolean;
+    /**
+     * @description Control for calculating severity level (NORMAL/DEGRADED/BLOCKING). Depends on severityTracking being true.
+     * @default 2000
+     */
+    severityNormalThreshold?: number;
+    /**
+     * @description Control for calculating severity level (NORMAL/DEGRADED/BLOCKING). Depends on severityTracking being true.
+     * @default 3000
+     */
+    severityDegradedThreshold?: number;
+};
+export type ProseMirrorRenderedTracking = {
+    enabled?: boolean;
+    /**
+     * @description Control whether proseMirror rendered event severity is tracked. When this is false the severity is not recorded.
+     * @default false
+     */
+    trackSeverity: boolean;
+    /**
+     * @description Control for calculating severity level (NORMAL/DEGRADED/BLOCKING). Depends on severityTracking being true.
+     * @default 2000
+     */
+    severityNormalThreshold: number;
+    /**
+     * @description Control for calculating severity level (NORMAL/DEGRADED/BLOCKING). Depends on severityTracking being true.
+     * @default 3000
+     */
+    severityDegradedThreshold: number;
+};
+export interface InputTracking {
+    /**
+     * @description Control whether samples of typing performance are taken. When this is false no measurements are taken and no events are sent.
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * @description Control whether samples of typing performance are taken. Depends on enabled being true.
+     * @default false
+     */
+    countNodes?: boolean;
+    /**
+     * @description Control for which nth transaction a typing performance sample is taken. Depends on enabled being true.
+     * @default 100
+     */
+    samplingRate?: number;
+    /**
+     * @description input events that exceed [slowThreshold]ms generate analytics event. Depends on enabled being true.
+     * @default 300
+     */
+    slowThreshold?: number;
+    /**
+     * @description input events that exceed [freezeThreshold]ms generate analytics event. Depends on enabled being true.
+     * @default 600
+     */
+    freezeThreshold?: number;
+    /**
+     * @description Control whether input tracking severity is tracked. When this is false the severity is not recorded.
+     * @default false
+     */
+    trackSeverity?: boolean;
+    /**
+     * @description Control for calculating severity level (NORMAL/DEGRADED/BLOCKING). Depends on severityTracking being true.
+     * @default 100
+     */
+    severityNormalThreshold?: number;
+    /**
+     * @description Control for calculating severity level (NORMAL/DEGRADED/BLOCKING). Depends on severityTracking being true.
+     * @default 500
+     */
+    severityDegradedThreshold?: number;
+    /**
+     * @description Track individual keypress processing time when multiple keypress happened in one frame.
+     * @default false
+     */
+    trackSingleKeypress?: boolean;
+    /**
+     * @description Track keypress processing time including browser rendering time.
+     * @default false
+     */
+    trackRenderingTime?: boolean;
+}
+export type ContentRetrievalTracking = {
+    /**
+     * @description Control whether editor content retrieval success and failure events are dispatched.
+     * When this is false no events are sampled or sent.
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * @description Control how frequently/at what rate successful editor content retrieval events are dispatched.
+     * @default 100
+     */
+    successSamplingRate?: number;
+    /**
+     * @description Control how frequently/at what rate failed editor content retrieval events are dispatched.
+     * @default 100
+     */
+    failureSamplingRate?: number;
+    /**
+     * @description Control whether the failed editor content retrieval event includes the error stack trace.
+     * @default false
+     */
+    reportErrorStack?: boolean;
+};
+export type OnChangeCallbackTracking = {
+    /**
+     * @description Whether onChange callback tracking should be enabled. Requires TransactionTracking
+     * to be enabled.
+     * @default: false
+     */
+    enabled: boolean;
+};
+export type OnEditorReadyCallbackTracking = {
+    /**
+     * @description Control whether onEditorReady callback tracking should be enabled.
+     * @default false
+     */
+    enabled: boolean;
+};
+export type PasteTracking = {
+    /**
+     * @description Control whether paste tracking should be enabled.
+     * @default false
+     */
+    enabled: boolean;
+};
+export type RenderTracking = {
+    /**
+     * @description Control whether editor render tracking should be enabled.
+     * @default false
+     */
+    editor: {
+        enabled: boolean;
+        useShallow?: boolean;
+    };
+    reactEditorView: {
+        enabled: boolean;
+        useShallow?: boolean;
+    };
+};
+export type StartedTracking = {
+    /**
+     * @description Control whether editor.started event tracking should be enabled
+     */
+    enabled?: boolean;
+};
+export type ErrorTracking = {
+    /**
+     * @description Control whether editor.unhandledErrorCaught crash events tracking should be enabled
+     */
+    enabled?: boolean;
+};
+export type PerformanceTracking = {
+    /**
+     * @description Control whether measurements for all analytics events are performed
+     */
+    catchAllTracking?: CatchAllTracking;
+    /**
+     * @description Control whether time to interactive is tracked
+     */
+    ttiTracking?: TTITracking;
+    /**
+     * @description Control whether transactions are tracked
+     */
+    inputTracking?: InputTracking;
+    /**
+     * @description Control whether transactions are tracked
+     */
+    transactionTracking?: TransactionTracking;
+    /**
+     * @description Control whether editor ui is tracked
+     */
+    uiTracking?: UITracking;
+    /**
+     * @description Control whether nodeviews are tracked
+     */
+    nodeViewTracking?: NodeViewTracking;
+    /**
+     * @description Control whether browser freezes / long tasks are tracked
+     */
+    bFreezeTracking?: BrowserFreezetracking;
+    /**
+     * @description Control whether proseMirror rendered event is tracked
+     */
+    proseMirrorRenderedTracking?: ProseMirrorRenderedTracking;
+    /**
+     * @description Control whether editor content retrieval events are tracked
+     */
+    contentRetrievalTracking?: ContentRetrievalTracking;
+    /**
+     * @description Control onChange callback is tracked. Requires TransactionTracking to be enabled,
+     * and uses the sampling rate in TransactionTracking.
+     */
+    onChangeCallbackTracking?: OnChangeCallbackTracking;
+    /**
+     * @description Control whether onEditorReady callback is tracked.
+     */
+    onEditorReadyCallbackTracking?: OnEditorReadyCallbackTracking;
+    /**
+     * @description Control whether paste is tracked.
+     */
+    pasteTracking?: PasteTracking;
+    /**
+     * @description Control whether render of different component is tracked.
+     */
+    renderTracking?: RenderTracking;
+    /**
+     * @description Control whether the editor.started event is tracked.
+     */
+    startedTracking?: StartedTracking;
+    /**
+     * @description Control whether top-level Editor errors caught by ErrorBoundary are tracked.
+     */
+    errorTracking?: ErrorTracking;
+};

package/dist/types/types/plugin-factory.d.ts

@@ -8,7 +8,7 @@ import type { PortalProviderAPI } from '../ui/PortalProvider';
 import type { ErrorReporter } from '../utils';
 import type { EditorReactContext } from './editor-react-context';
 import type { FeatureFlags } from './feature-flags';
-export declare type PMPluginFactoryParams = {
+export type PMPluginFactoryParams = {
     schema: Schema;
     dispatch: Dispatch;
     eventDispatcher: EventDispatcher;
@@ -20,8 +20,8 @@ export declare type PMPluginFactoryParams = {
     featureFlags: FeatureFlags;
     getIntl: () => IntlShape;
 };
-export declare type PMPluginFactory = (params: PMPluginFactoryParams) => SafePlugin | undefined;
-export declare type PMPlugin = {
+export type PMPluginFactory = (params: PMPluginFactoryParams) => SafePlugin | undefined;
+export type PMPlugin = {
     name: string;
     plugin: PMPluginFactory;
 };

package/dist/types/types/quick-insert.d.ts

@@ -2,21 +2,21 @@ import { IntlShape } from 'react-intl-next';
 import type { QuickInsertItem, QuickInsertProvider } from '../provider-factory';
 import type { EmptyStateHandler } from './empty-state-handler';
 export type { QuickInsertActionInsert, QuickInsertItem, QuickInsertProvider, } from '../provider-factory';
-export declare type QuickInsertOptions = boolean | {
+export type QuickInsertOptions = boolean | {
     provider: Promise<QuickInsertProvider>;
 };
-export declare type QuickInsertHandler = Array<QuickInsertItem> | ((intl: IntlShape) => Array<QuickInsertItem>);
-export declare type IconProps = {
+export type QuickInsertHandler = Array<QuickInsertItem> | ((intl: IntlShape) => Array<QuickInsertItem>);
+export type IconProps = {
     label?: string;
 };
-export declare type QuickInsertPluginState = {
+export type QuickInsertPluginState = {
     isElementBrowserModalOpen: boolean;
     lazyDefaultItems: () => QuickInsertItem[];
     providedItems?: QuickInsertItem[];
     provider?: QuickInsertProvider;
     emptyStateHandler?: EmptyStateHandler;
 };
-export declare type QuickInsertPluginStateKeys = keyof QuickInsertPluginState;
+export type QuickInsertPluginStateKeys = keyof QuickInsertPluginState;
 export interface QuickInsertPluginOptions {
     headless?: boolean;
     disableDefaultItems?: boolean;

package/dist/types/types/supported-browsers.d.ts

@@ -1,10 +1,10 @@
 declare const SupportedBrowsers: readonly ["ie", "gecko", "chrome", "safari"];
-export declare type Browsers = (typeof SupportedBrowsers)[number];
-export declare type Range = {
+export type Browsers = (typeof SupportedBrowsers)[number];
+export type Range = {
     minimum: number;
     maximum?: number;
 };
-export declare type DisableSpellcheckByBrowser = {
+export type DisableSpellcheckByBrowser = {
     [b in Browsers]?: Range;
 };
 export {};

package/dist/types/types/toolbar.d.ts

@@ -22,9 +22,9 @@ export declare enum ToolbarWidthsFullPage {
     M = 490,
     S = 410
 }
-export declare type ToolbarUiComponentFactoryParams = UiComponentFactoryParams & {
+export type ToolbarUiComponentFactoryParams = UiComponentFactoryParams & {
     toolbarSize: ToolbarSize;
     isToolbarReducedSpacing: boolean;
     isLastItem?: boolean;
 };
-export declare type ToolbarUIComponentFactory = (params: ToolbarUiComponentFactoryParams) => React.ReactElement<any> | null;
+export type ToolbarUIComponentFactory = (params: ToolbarUiComponentFactoryParams) => React.ReactElement<any> | null;

package/dist/types/types/type-ahead.d.ts

@@ -3,7 +3,7 @@ import { Fragment, Node as PMNode } from 'prosemirror-model';
 import { EditorState, Transaction } from 'prosemirror-state';
 import type { TypeAheadPayload } from '../analytics/types/type-ahead';
 import type { SelectItemMode, TypeAheadAvailableNodes } from '../type-ahead';
-declare type TypeAheadForceSelectProps = {
+type TypeAheadForceSelectProps = {
     query: string;
     items: Array<TypeAheadItem>;
     editorState: EditorState;
@@ -16,21 +16,21 @@ export interface TypeAheadStats {
         arrowDown: number;
     };
 }
-export declare type TypeAheadItemRenderProps = {
+export type TypeAheadItemRenderProps = {
     onClick: () => void;
     onHover: () => void;
     isSelected: boolean;
 };
-export declare type TypeAheadInsert = (node?: PMNode | Object | string | Fragment, opts?: {
+export type TypeAheadInsert = (node?: PMNode | Object | string | Fragment, opts?: {
     selectInlineNode?: boolean;
 }) => Transaction;
-export declare type TypeAheadSelectItem = (state: EditorState, item: TypeAheadItem, insert: TypeAheadInsert, meta: {
+export type TypeAheadSelectItem = (state: EditorState, item: TypeAheadItem, insert: TypeAheadInsert, meta: {
     mode: SelectItemMode;
     stats: TypeAheadStats;
     query: string;
     sourceListItem: Array<TypeAheadItem>;
 }) => Transaction | false;
-export declare type TypeAheadItem = {
+export type TypeAheadItem = {
     title: string;
     description?: string;
     keyshortcut?: string;
@@ -39,8 +39,8 @@ export declare type TypeAheadItem = {
     render?: (props: TypeAheadItemRenderProps) => React.ReactElement<TypeAheadItemRenderProps> | null;
     [key: string]: any;
 };
-export declare type TypeAheadForceSelect = (props: TypeAheadForceSelectProps) => TypeAheadItem | undefined;
-export declare type TypeAheadHandler = {
+export type TypeAheadForceSelect = (props: TypeAheadForceSelectProps) => TypeAheadItem | undefined;
+export type TypeAheadHandler = {
     id: TypeAheadAvailableNodes;
     /** Pattern that will trigger the TypeAhead */
     trigger: string;

package/dist/types/types/ui-components.d.ts

@@ -5,7 +5,7 @@ import type { EventDispatcher } from '../event-dispatcher';
 import type { ProviderFactory } from '../provider-factory';
 import type { EditorActionsOptions } from './editor-actions';
 import type { EditorAppearance } from './editor-appearance';
-export declare type UiComponentFactoryParams = {
+export type UiComponentFactoryParams = {
     editorView: EditorView;
     editorActions: EditorActionsOptions;
     eventDispatcher: EventDispatcher;
@@ -19,4 +19,4 @@ export declare type UiComponentFactoryParams = {
     disabled: boolean;
     wrapperElement: HTMLElement | null;
 };
-export declare type UIComponentFactory = (params: UiComponentFactoryParams) => React.ReactElement<any> | null;
+export type UIComponentFactory = (params: UiComponentFactoryParams) => React.ReactElement<any> | null;

package/dist/types/ufo/experience-store.d.ts

@@ -9,8 +9,8 @@ export declare enum EditorExperience {
     editSession = "editSession"
 }
 export declare const RELIABILITY_INTERVAL = 30000;
-declare type TypeOfEditorExperience = typeof EditorExperience;
-declare type ValueOfEditorExperience = TypeOfEditorExperience[keyof TypeOfEditorExperience];
+type TypeOfEditorExperience = typeof EditorExperience;
+type ValueOfEditorExperience = TypeOfEditorExperience[keyof TypeOfEditorExperience];
 export declare class ExperienceStore {
     private static stores;
     private experiences;

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

@@ -1,13 +1,13 @@
 import React from 'react';
 import { Breakpoints } from '../WidthProvider';
 export declare function mapBreakpointToLayoutMaxWidth(breakpoint: Breakpoints): 760 | 680;
-declare type BaseThemeWrapperProps = {
+type BaseThemeWrapperProps = {
     breakpoint: Breakpoints;
     children: React.ReactNode;
     baseFontSize?: number;
 };
 export declare function BaseThemeWrapper({ baseFontSize, children, }: BaseThemeWrapperProps): JSX.Element;
-declare type BaseThemeProps = {
+type BaseThemeProps = {
     children: React.ReactNode;
     baseFontSize?: number;
 };

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

@@ -2,7 +2,7 @@
 import React from 'react';
 import { jsx } from '@emotion/react';
 import { WrappedComponentProps } from 'react-intl-next';
-declare type Props = {
+type Props = {
     selected?: boolean;
     hasContent?: boolean;
     children?: React.ReactNode;

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

@@ -12,9 +12,9 @@ interface Props extends WithAnalyticsEventsProps {
     children?: ReactNode;
     id?: string;
 }
-export declare type OpenChangedEvent = {
+export type OpenChangedEvent = {
     isOpen: boolean;
     event: MouseEvent | KeyboardEvent;
 };
-declare const _default: import("react").ForwardRefExoticComponent<Pick<Omit<Props, keyof WithAnalyticsEventsProps> & import("react").RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "key" | "id" | "children" | "position" | "trigger" | "testId" | "analyticsContext" | "isOpen" | "onPositioned" | "onOpenChange" | "shouldFitContainer"> & import("react").RefAttributes<any>>;
+declare const _default: import("react").ForwardRefExoticComponent<Pick<Omit<Props, keyof WithAnalyticsEventsProps> & import("react").RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "key" | "id" | "children" | "position" | "trigger" | "testId" | "analyticsContext" | "isOpen" | "shouldFitContainer" | "onPositioned" | "onOpenChange"> & import("react").RefAttributes<any>>;
 export default _default;

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

@@ -1,6 +1,6 @@
 import React from 'react';
 import { ACTION, DispatchAnalyticsEvent, ErrorEventPayload } from '../../analytics';
-declare type ErrorCrashPayload = Extract<ErrorEventPayload, {
+type ErrorCrashPayload = Extract<ErrorEventPayload, {
     action: ACTION.EDITOR_CRASHED;
 }>;
 interface ErrorBoundaryProps {

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

@@ -5,11 +5,11 @@ export interface CardSurroundings {
     collectionName: string;
     list: Identifier[];
 }
-export declare type MentionEventHandler = (mentionId: string, text: string, event?: SyntheticEvent<HTMLSpanElement>) => void;
-export declare type CardEventClickHandler = (result: CardEvent | InlineCardEvent, surroundings?: CardSurroundings, analyticsEvent?: any) => void;
-export declare type LinkEventClickHandler = (event: SyntheticEvent<HTMLAnchorElement>, url?: string) => void;
-export declare type SmartCardEventClickHandler = (event: SyntheticEvent<HTMLAnchorElement>, url?: string) => void;
-export declare type OnUnhandledClickHandler = (event: React.MouseEvent) => void;
+export type MentionEventHandler = (mentionId: string, text: string, event?: SyntheticEvent<HTMLSpanElement>) => void;
+export type CardEventClickHandler = (result: CardEvent | InlineCardEvent, surroundings?: CardSurroundings, analyticsEvent?: any) => void;
+export type LinkEventClickHandler = (event: SyntheticEvent<HTMLAnchorElement>, url?: string) => void;
+export type SmartCardEventClickHandler = (event: SyntheticEvent<HTMLAnchorElement>, url?: string) => void;
+export type OnUnhandledClickHandler = (event: React.MouseEvent) => void;
 export interface MentionEventHandlers {
     onClick?: MentionEventHandler;
     onMouseEnter?: MentionEventHandler;

package/dist/types/ui/FloatingToolbar/Button.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { ButtonAppearance } from '../../types';
+export type { ButtonAppearance };
+export interface Props {
+    title?: string;
+    icon?: React.ReactElement<any>;
+    iconAfter?: React.ReactElement<any>;
+    onClick?: React.MouseEventHandler;
+    onKeyDown?: React.KeyboardEventHandler;
+    onMouseEnter?: <T>(event: React.MouseEvent<T>) => void;
+    onMouseLeave?: <T>(event: React.MouseEvent<T>) => void;
+    onFocus?: <T>(event: React.FocusEvent<T>) => void;
+    onBlur?: <T>(event: React.FocusEvent<T>) => void;
+    selected?: boolean;
+    disabled?: boolean;
+    appearance?: ButtonAppearance;
+    ariaHasPopup?: boolean | 'dialog' | 'menu' | 'listbox' | 'tree' | 'grid' | undefined;
+    ariaLabel?: string;
+    href?: string;
+    target?: string;
+    children?: React.ReactNode;
+    className?: string;
+    tooltipContent?: React.ReactNode;
+    testId?: string;
+    hideTooltipOnClick?: boolean;
+    tabIndex?: number | null | undefined;
+    areaControls?: string;
+}
+declare const _default: ({ title, icon, iconAfter, onClick, onKeyDown, onMouseEnter, onMouseLeave, onFocus, onBlur, selected, disabled, href, target, appearance, children, className, tooltipContent, testId, hideTooltipOnClick, ariaHasPopup, tabIndex, areaControls, ariaLabel, }: Props) => JSX.Element;
+export default _default;

package/dist/types/ui/FloatingToolbar/styles.d.ts

@@ -0,0 +1,20 @@
+export declare const iconOnlySpacing: {
+    '&&': {
+        padding: string;
+        /**
+          Increased specificity here because css for .hyperlink-open-link defined in
+          packages/editor/editor-core/src/ui/ContentStyles/index.tsx file
+          overrides padding left-right 2px with 4px.
+        */
+        '&&[href]': {
+            padding: string;
+        };
+    };
+    '& > span': {
+        margin: string;
+    };
+};
+export declare const getButtonStyles: (props: any) => {
+    background: any;
+    color: any;
+};

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

@@ -1,12 +1,12 @@
 import { Component, ReactNode } from 'react';
 import { Data } from 'popper.js';
-export declare type Props = {
+export type Props = {
     content: ReactNode | null;
     offset: string;
     position: string;
     onPositioned: () => void;
 };
-export declare type State = {
+export type State = {
     hasExtractedStyles: boolean;
     position?: string;
     transform?: string;

package/dist/types/ui/MediaSingle/grid.d.ts

@@ -1,9 +1,23 @@
+import { EditorState } from 'prosemirror-state';
 import { RichMediaLayout as MediaSingleLayout } from '@atlaskit/adf-schema';
+import { EditorContainerWidth } from '../../types';
 export declare const layoutSupportsWidth: (layout: MediaSingleLayout) => boolean;
 export declare function calcPxFromColumns(columns: number, lineLength: number, gridSize: number): number;
 export declare function calcColumnsFromPx(width: number, lineLength: number, gridSize: number): number;
 export declare function calcPxFromPct(pct: number, lineLength: number): number;
 export declare function calcPctFromPx(width: number, lineLength: number): number;
+export declare const wrappedLayouts: MediaSingleLayout[];
+export declare const calcMediaPxWidth: (opts: {
+    origWidth: number;
+    origHeight: number;
+    state: EditorState;
+    containerWidth: EditorContainerWidth;
+    layout?: MediaSingleLayout | undefined;
+    pctWidth?: number | undefined;
+    pos?: number | undefined;
+    resizedPctWidth?: number | undefined;
+    isFullWidthModeEnabled?: boolean | undefined;
+}) => number;
 export declare const snapToGrid: (gridWidth: number, width: number, height: number, lineLength: number, gridSize: number) => {
     height: number;
     width: number;

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

@@ -4,7 +4,6 @@ import { jsx } from '@emotion/react';
 import { RichMediaLayout as MediaSingleLayout, RichMediaLayout } from '@atlaskit/adf-schema';
 export declare const DEFAULT_IMAGE_WIDTH = 250;
 export declare const DEFAULT_IMAGE_HEIGHT = 200;
-export declare const wrappedLayouts: RichMediaLayout[];
 export interface Props {
     children: React.ReactNode;
     layout: MediaSingleLayout;
@@ -20,5 +19,5 @@ export interface Props {
     hasFallbackContainer?: boolean;
     handleMediaSingleRef?: React.RefObject<HTMLDivElement>;
 }
-export declare const shouldAddDefaultWrappedWidth: (layout: RichMediaLayout, width?: number | undefined, lineLength?: number | undefined) => boolean | 0 | undefined;
+export declare const shouldAddDefaultWrappedWidth: (layout: RichMediaLayout, width?: number, lineLength?: number) => boolean | 0 | undefined;
 export default function MediaSingle({ layout, width, height, containerWidth, isLoading, pctWidth, className, children: propsChildren, nodeType, fullWidthMode, lineLength, hasFallbackContainer, handleMediaSingleRef, }: Props): jsx.JSX.Element;