@atlaskit/editor-common 107.28.2 → 107.29.0

package/dist/types-ts4.5/ui-menu/DropdownMenu/types.d.ts

@@ -5,62 +5,62 @@ type SectionOptions = {
     title?: string;
 };
 export interface Props {
-    mountTo?: HTMLElement;
+    allowEnterDefaultBehavior?: boolean;
+    arrowKeyNavigationProviderOptions: ArrowKeyNavigationProviderOptions;
     boundariesElement?: HTMLElement;
-    scrollableElement?: HTMLElement;
+    children?: React.ReactNode;
+    disableArrowKeyNavigation?: boolean;
+    fitHeight?: number;
+    fitWidth?: number;
+    handleEscapeKeydown?: (e: KeyboardEvent) => void;
     isOpen?: boolean;
-    onOpenChange?: (attrs: any) => void;
+    items: Array<{
+        items: MenuItem[];
+    }>;
+    mountTo?: HTMLElement;
+    offset?: Array<number>;
     onItemActivated?: (attrs: {
         item: MenuItem;
         shouldCloseMenu?: boolean;
     }) => void;
     onMouseEnter?: (attrs: any) => void;
     onMouseLeave?: (attrs: any) => void;
-    fitWidth?: number;
-    fitHeight?: number;
-    offset?: Array<number>;
-    zIndex?: number;
-    items: Array<{
-        items: MenuItem[];
-    }>;
-    shouldUseDefaultRole?: boolean;
-    disableArrowKeyNavigation?: boolean;
-    shouldFocusFirstItem?: () => boolean;
-    arrowKeyNavigationProviderOptions: ArrowKeyNavigationProviderOptions;
+    onOpenChange?: (attrs: any) => void;
+    scrollableElement?: HTMLElement;
     section?: SectionOptions;
-    children?: React.ReactNode;
-    allowEnterDefaultBehavior?: boolean;
-    handleEscapeKeydown?: (e: KeyboardEvent) => void;
+    shouldFocusFirstItem?: () => boolean;
+    shouldUseDefaultRole?: boolean;
+    zIndex?: number;
 }
 export interface MenuItem {
-    key?: string;
+    'aria-expanded'?: React.AriaAttributes['aria-expanded'];
+    'aria-haspopup'?: React.AriaAttributes['aria-haspopup'];
+    'aria-keyshortcuts'?: React.AriaAttributes['aria-keyshortcuts'];
+    'aria-label'?: React.AriaAttributes['aria-label'];
+    className?: string;
     content: string | React.ReactChild | React.ReactFragment;
-    value: {
-        name: string;
-    };
-    shortcut?: string;
-    elemBefore?: React.ReactElement<any>;
+    'data-testid'?: string;
     elemAfter?: React.ReactElement<any>;
-    tooltipDescription?: string;
-    tooltipPosition?: string;
+    elemBefore?: React.ReactElement<any>;
+    handleRef?: any;
     isActive?: boolean;
     isDisabled?: boolean;
-    handleRef?: any;
-    className?: string;
-    'aria-label'?: React.AriaAttributes['aria-label'];
-    'aria-haspopup'?: React.AriaAttributes['aria-haspopup'];
-    'aria-keyshortcuts'?: React.AriaAttributes['aria-keyshortcuts'];
-    'data-testid'?: string;
+    key?: string;
     onClick?: () => void;
-    'aria-expanded'?: React.AriaAttributes['aria-expanded'];
+    shortcut?: string;
+    tooltipDescription?: string;
+    tooltipPosition?: string;
+    value: {
+        name: string;
+    };
     wrapperTabIndex?: number | null;
 }
 export interface State {
-    target?: HTMLElement;
     popupPlacement: [
         string,
         string
     ];
     selectionIndex: number;
+    target?: HTMLElement;
 }
 export {};

package/dist/types-ts4.5/ui-menu/ToolbarArrowKeyNavigationProvider/index.d.ts

@@ -22,13 +22,13 @@ export declare const KeyDownHandlerContext: React.Context<KeyDownHandlerContext>
  * @returns
  */
 export declare const ToolbarArrowKeyNavigationProvider: ({ children, editorView, childComponentSelector, handleEscape, disableArrowKeyNavigation, isShortcutToFocusToolbar, editorAppearance, useStickyToolbar, intl, }: {
+    childComponentSelector: string;
     children: ReactNode;
+    disableArrowKeyNavigation?: boolean;
+    editorAppearance?: EditorAppearance;
     editorView?: EditorView;
-    childComponentSelector: string;
     handleEscape?: (event: KeyboardEvent) => void;
-    disableArrowKeyNavigation?: boolean;
+    intl: IntlShape;
     isShortcutToFocusToolbar?: (event: KeyboardEvent) => boolean;
-    editorAppearance?: EditorAppearance;
     useStickyToolbar?: UseStickyToolbarType;
-    intl: IntlShape;
 }) => jsx.JSX.Element;

package/dist/types-ts4.5/ui-menu/ToolbarButton/index.d.ts

@@ -9,56 +9,56 @@ import { type TOOLBAR_ACTION_SUBJECT_ID } from '../../analytics';
 import { type Keymap } from '../../keymaps';
 import type { MenuItem } from '../DropdownMenu/types';
 export type Props = {
+    'aria-expanded'?: React.AriaAttributes['aria-expanded'];
+    'aria-haspopup'?: React.AriaAttributes['aria-haspopup'];
+    'aria-keyshortcuts'?: React.AriaAttributes['aria-keyshortcuts'];
+    'aria-label'?: React.AriaAttributes['aria-label'];
+    'aria-pressed'?: React.AriaAttributes['aria-pressed'];
     buttonId?: TOOLBAR_ACTION_SUBJECT_ID;
     className?: string;
+    'data-ds--level'?: string;
     disabled?: boolean;
     hideTooltip?: boolean;
     href?: string;
     iconAfter?: React.ReactElement<any>;
     iconBefore?: React.ReactElement<any>;
+    item?: MenuItem;
+    keymap?: Keymap;
     onClick?: (event: React.MouseEvent<HTMLElement>) => void;
     onItemClick?: (item: MenuItem) => void;
     onKeyDown?: (event: React.KeyboardEvent<HTMLElement>) => void;
     selected?: boolean;
     spacing?: 'default' | 'compact' | 'none';
     target?: string;
+    testId?: string;
     title?: React.ReactNode;
     titlePosition?: PositionType;
-    item?: MenuItem;
-    testId?: string;
-    keymap?: Keymap;
-    'aria-label'?: React.AriaAttributes['aria-label'];
-    'aria-expanded'?: React.AriaAttributes['aria-expanded'];
-    'aria-haspopup'?: React.AriaAttributes['aria-haspopup'];
-    'aria-pressed'?: React.AriaAttributes['aria-pressed'];
-    'aria-keyshortcuts'?: React.AriaAttributes['aria-keyshortcuts'];
-    'data-ds--level'?: string;
 } & Pick<ButtonProps, 'aria-label' | 'children' | 'onFocus' | 'onBlur' | 'onMouseEnter' | 'onMouseLeave' | 'aria-controls' | 'rel'>;
 export type ToolbarButtonRef = HTMLElement;
 declare const ToolbarButton: React.ForwardRefExoticComponent<{
+    'aria-expanded'?: React.AriaAttributes["aria-expanded"];
+    'aria-haspopup'?: React.AriaAttributes["aria-haspopup"];
+    'aria-keyshortcuts'?: React.AriaAttributes["aria-keyshortcuts"];
+    'aria-label'?: React.AriaAttributes["aria-label"];
+    'aria-pressed'?: React.AriaAttributes["aria-pressed"];
     buttonId?: TOOLBAR_ACTION_SUBJECT_ID;
     className?: string;
+    'data-ds--level'?: string;
     disabled?: boolean;
     hideTooltip?: boolean;
     href?: string;
     iconAfter?: React.ReactElement<any>;
     iconBefore?: React.ReactElement<any>;
+    item?: MenuItem;
+    keymap?: Keymap;
     onClick?: (event: React.MouseEvent<HTMLElement>) => void;
     onItemClick?: (item: MenuItem) => void;
     onKeyDown?: (event: React.KeyboardEvent<HTMLElement>) => void;
     selected?: boolean;
     spacing?: "default" | "compact" | "none";
     target?: string;
+    testId?: string;
     title?: React.ReactNode;
     titlePosition?: PositionType;
-    item?: MenuItem;
-    testId?: string;
-    keymap?: Keymap;
-    'aria-label'?: React.AriaAttributes["aria-label"];
-    'aria-expanded'?: React.AriaAttributes["aria-expanded"];
-    'aria-haspopup'?: React.AriaAttributes["aria-haspopup"];
-    'aria-pressed'?: React.AriaAttributes["aria-pressed"];
-    'aria-keyshortcuts'?: React.AriaAttributes["aria-keyshortcuts"];
-    'data-ds--level'?: string;
-} & Pick<ButtonProps, "onFocus" | "onBlur" | "children" | "rel" | "aria-controls" | "aria-label" | "onMouseEnter" | "onMouseLeave"> & React.RefAttributes<HTMLElement>>;
+} & Pick<ButtonProps, "onBlur" | "onFocus" | "children" | "rel" | "aria-controls" | "aria-label" | "onMouseEnter" | "onMouseLeave"> & React.RefAttributes<HTMLElement>>;
 export default ToolbarButton;

package/dist/types-ts4.5/ui-react/ReactEditorViewContext.d.ts

@@ -1,8 +1,8 @@
 import React from 'react';
 import { type EditorView } from '@atlaskit/editor-prosemirror/view';
 type ReactEditorViewContextProps = {
-    editorView?: EditorView;
     editorRef?: React.RefObject<HTMLDivElement>;
+    editorView?: EditorView;
     popupsMountPoint?: HTMLElement | undefined;
 };
 declare const ReactEditorViewContext: React.Context<ReactEditorViewContextProps>;

package/dist/types-ts4.5/ui-react/with-react-editor-view-outer-listeners.d.ts

@@ -2,17 +2,17 @@ import React from 'react';
 type SimpleEventHandler<T> = (event: T) => void;
 export declare const OutsideClickTargetRefContext: React.Context<(el: HTMLElement | null) => void>;
 export interface WithOutsideClickProps {
-    handleClickOutside?: SimpleEventHandler<MouseEvent>;
-    handleEscapeKeydown?: SimpleEventHandler<KeyboardEvent>;
-    handleEnterKeydown?: SimpleEventHandler<KeyboardEvent>;
-    targetRef?: any;
-    closeOnTab?: boolean;
     /**
      * Use when you want the click handler to call on the capture phase instead of during bubbling.
      * This is useful when you're in a popup with interative UI elements that may disappear on click
      * like when toggling UI states
      */
     captureClick?: boolean;
+    closeOnTab?: boolean;
+    handleClickOutside?: SimpleEventHandler<MouseEvent>;
+    handleEnterKeydown?: SimpleEventHandler<KeyboardEvent>;
+    handleEscapeKeydown?: SimpleEventHandler<KeyboardEvent>;
+    targetRef?: any;
 }
 export default function withReactEditorViewOuterListeners<P extends Object>(Component: React.ComponentType<React.PropsWithChildren<P>>): React.ComponentType<React.PropsWithChildren<P & WithOutsideClickProps>>;
 export {};

package/dist/types-ts4.5/user-preferences/persistence-api.d.ts

@@ -1,5 +1,13 @@
 import { type UserPreferences } from './user-preferences';
 export type PersistenceAPI = {
+    /**
+     * Get the initial user preferences synchronously
+     * This function is called on initialization
+     * If not provided, loadUserPreferences will be called instead
+     * @param userPreferences
+     * @returns
+     */
+    getInitialUserPreferences?: () => UserPreferences | undefined;
     /**
      * Loads the user preferences
      * @returns
@@ -12,12 +20,4 @@ export type PersistenceAPI = {
      * @returns
      */
     updateUserPreference: <K extends keyof UserPreferences>(key: K, value: UserPreferences[K]) => Promise<Pick<UserPreferences, K>>;
-    /**
-     * Get the initial user preferences synchronously
-     * This function is called on initialization
-     * If not provided, loadUserPreferences will be called instead
-     * @param userPreferences
-     * @returns
-     */
-    getInitialUserPreferences?: () => UserPreferences | undefined;
 };

package/dist/types-ts4.5/utils/breakout.d.ts

@@ -9,17 +9,17 @@ import { getBreakpoint } from '../ui/WidthProvider';
  *
  */
 export type BreakoutConstsType = {
-    padding: number;
-    defaultLayoutWidth: number;
-    wideScaleRatio: number;
-    fullWidthLayoutWidth: number;
-    wideLayoutWidth: number;
-    mapBreakpointToLayoutMaxWidth: typeof mapBreakpointToLayoutMaxWidth;
-    getBreakpoint: typeof getBreakpoint;
     calcBreakoutWidth: any;
     calcBreakoutWithCustomWidth: (breakoutConsts: BreakoutConstsType) => (mode: 'full-width' | 'wide', width: number | null, editorContainerWidth: number) => string;
     calcLineLength: (breakoutConsts: BreakoutConstsType) => () => number;
     calcWideWidth: (breakoutConsts: BreakoutConstsType) => (containerWidth?: number, maxWidth?: number, fallback?: string, padding?: number) => string;
+    defaultLayoutWidth: number;
+    fullWidthLayoutWidth: number;
+    getBreakpoint: typeof getBreakpoint;
+    mapBreakpointToLayoutMaxWidth: typeof mapBreakpointToLayoutMaxWidth;
+    padding: number;
+    wideLayoutWidth: number;
+    wideScaleRatio: number;
 };
 declare const breakoutConsts: BreakoutConstsType;
 export declare const absoluteBreakoutWidth: (layout: "full-width" | "wide" | string, containerWidth: number) => number;
@@ -29,16 +29,16 @@ export declare const calcBreakoutWidth: any;
 export declare const calcBreakoutWithCustomWidth: (mode: "full-width" | "wide", width: number | null, editorContainerWidth: number) => string;
 export declare function calculateBreakoutStyles({ mode, widthStateLineLength, widthStateWidth, }: {
     mode: BreakoutMarkAttrs['mode'];
-    /**
-     * offsetWidth of the content the editor is attached to.
-     * Expected to be retrieved via `WidthState.lineLength`.
-     */
-    widthStateWidth?: number;
     /**
      * clientWidth of the content area in the editor (ie. EditorPlugin contentComponents).
      * Expected to be retrieved via `WidthState.width`.
      */
     widthStateLineLength?: number;
+    /**
+     * offsetWidth of the content the editor is attached to.
+     * Expected to be retrieved via `WidthState.lineLength`.
+     */
+    widthStateWidth?: number;
 }): {
     type: "line-length-unknown";
     width: any;

package/dist/types-ts4.5/utils/calculate-toolbar-position.d.ts

@@ -3,9 +3,9 @@ import type { PopupPosition as Position } from '../ui';
 export declare const calculateToolbarPositionAboveSelection: (toolbarTitle: string) => (editorView: EditorView, nextPos: Position) => Position;
 export declare const calculateToolbarPositionTrackHead: (toolbarTitle: string) => (editorView: EditorView, nextPos: Position) => Position;
 export type CoordsAtPos = {
-    top: number;
     bottom: number;
     left: number;
     right: number;
+    top: number;
 };
 export declare const calculateToolbarPositionOnCellSelection: (toolbarTitle: string) => (editorView: EditorView, nextPos: Position) => Position;

package/dist/types-ts4.5/utils/compare-props.d.ts

@@ -1,6 +1,6 @@
 type ChangedData<T> = {
-    key: keyof T;
     difference?: any;
+    key: keyof T;
     maxDepthReached?: boolean;
     newValue?: any;
     oldValue?: any;
@@ -8,14 +8,14 @@ type ChangedData<T> = {
 };
 type Changed<T> = Array<ChangedData<T>>;
 export type PropsDifference<T> = {
-    removed: Array<keyof T>;
     added: Array<keyof T>;
     changed: Changed<T>;
+    removed: Array<keyof T>;
 };
 export type ShallowPropsDifference<T> = {
-    removed: Array<keyof T>;
     added: Array<keyof T>;
     changed: Array<keyof T>;
+    removed: Array<keyof T>;
 };
 export declare const getKeys: <T>(obj: T) => Array<keyof T>;
 export declare const getKeysAddedRemovedCommon: <T>(object1: T, object2: T) => {

package/dist/types-ts4.5/utils/count-nodes.d.ts

@@ -1,8 +1,8 @@
 import type { EditorState } from '@atlaskit/editor-prosemirror/state';
 type NodeCount = Record<string, number>;
 type NodesCount = {
-    nodeCount: NodeCount;
     extensionNodeCount: NodeCount;
+    nodeCount: NodeCount;
 };
 export declare function countNodes(state: EditorState): NodesCount;
 export {};

package/dist/types-ts4.5/utils/create-wrap-selection-transaction.d.ts

@@ -9,9 +9,9 @@ import { type EditorState } from '@atlaskit/editor-prosemirror/state';
  * content that is already inside a panel with another panel
  */
 export declare function createWrapSelectionTransaction({ state, type, nodeAttributes, }: {
+    nodeAttributes?: Record<string, any>;
     state: EditorState;
     type: NodeType;
-    nodeAttributes?: Record<string, any>;
 }): import("prosemirror-state").Transaction;
 export declare function getWrappingOptions(state: EditorState, type: NodeType, nodeAttributes?: Record<string, any>): {
     range: any;

package/dist/types-ts4.5/utils/editor-core-utils.d.ts

@@ -9,8 +9,8 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 export declare function isEmptyParagraph(node?: Node | null): boolean;
 export declare const stepHasSlice: (step: Step) => step is Step & {
     from: number;
-    to: number;
     slice: Slice;
+    to: number;
 };
 /**
  * Checks whether a given step is adding nodes of given nodeTypes

package/dist/types-ts4.5/utils/error-reporter.d.ts

@@ -2,8 +2,8 @@ export type ErrorReporterTags = {
     [key: string]: string;
 };
 export interface ErrorReportingHandler {
-    captureMessage: (msg: string, tags?: ErrorReporterTags) => void;
     captureException: (err: Error, tags?: ErrorReporterTags) => void;
+    captureMessage: (msg: string, tags?: ErrorReporterTags) => void;
 }
 export declare class ErrorReporter {
     private handlerStorage;

package/dist/types-ts4.5/utils/get-performance-options.d.ts

@@ -1,16 +1,16 @@
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import { type AnalyticsEventPayload } from '../analytics';
 export declare function getPerformanceOptions(view: EditorView): {
-    trackingEnabled: boolean;
     samplingRate: number;
     slowThreshold: number;
+    trackingEnabled: boolean;
 };
 export declare function startMeasureReactNodeViewRendered({ nodeTypeName }: {
     nodeTypeName: string;
 }): void;
 export declare function stopMeasureReactNodeViewRendered({ nodeTypeName, dispatchAnalyticsEvent, samplingRate, slowThreshold, }: {
-    nodeTypeName: string;
     dispatchAnalyticsEvent(payload: AnalyticsEventPayload): void;
+    nodeTypeName: string;
     samplingRate: number;
     slowThreshold: number;
 }): void;

package/dist/types-ts4.5/utils/hyperlink.d.ts

@@ -23,8 +23,8 @@ export declare function linkifyContent(schema: Schema): (slice: Slice) => Slice;
 export declare function getLinkDomain(url: string): string;
 export declare function isFromCurrentDomain(url: string): boolean;
 interface filepathMatch {
-    startIndex: number;
     endIndex: number;
+    startIndex: number;
 }
 export declare const findFilepaths: (text: string, offset?: number) => Array<filepathMatch>;
 export declare const isLinkInMatches: (linkStart: number, matchesList: Array<filepathMatch>) => boolean;

package/dist/types-ts4.5/utils/imageLoader.d.ts

@@ -1,12 +1,12 @@
 import React from 'react';
 import type { ComponentType } from 'react';
 export interface ImageLoaderProps {
-    url?: string;
+    imageStatus?: ImageStatus;
     onExternalImageLoaded?: (dimensions: {
-        width: number;
         height: number;
+        width: number;
     }) => void;
-    imageStatus?: ImageStatus;
+    url?: string;
 }
 export interface ImageLoaderState {
     imageStatus: ImageStatus;

package/dist/types-ts4.5/utils/input-rules.d.ts

@@ -6,10 +6,10 @@ import type { InputRuleHandler, InputRuleWrapper } from '../types';
 type GetPayload = AnalyticsEventPayload | ((state: EditorState, matchResult: RegExpExecArray) => AnalyticsEventPayload);
 export declare const inputRuleWithAnalytics: (getPayload: GetPayload, analyticsApi: EditorAnalyticsAPI | undefined) => (originalRule: InputRuleWrapper) => InputRuleWrapper;
 type WrappingRuleProps = {
-    match: RegExp;
-    nodeType: NodeType;
     getAttrs?: Record<string, any> | ((matchResult: RegExpExecArray) => Record<string, any>);
     joinPredicate?: (matchResult: RegExpExecArray, node: PMNode, joinScenario: JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST) => boolean;
+    match: RegExp;
+    nodeType: NodeType;
 };
 export declare const createWrappingJoinRule: ({ match, nodeType, getAttrs, joinPredicate, }: WrappingRuleProps) => InputRuleWrapper;
 export declare const createRule: (match: RegExp, handler: InputRuleHandler) => InputRuleWrapper;

package/dist/types-ts4.5/utils/macro.d.ts

@@ -4,7 +4,7 @@ export interface Params {
     type: 'image' | 'icon';
 }
 export declare const getExtensionLozengeData: ({ node, type, }: Params) => {
+    height?: number;
     url: string;
     width?: number;
-    height?: number;
 } | undefined;

package/dist/types-ts4.5/utils/page-element-counts.d.ts

@@ -3,10 +3,10 @@ export type PageElementCounts = {
     elements: {
         [key: string]: number;
     };
-    textFormats: {
+    macros: {
         [key: string]: number;
     };
-    macros: {
+    textFormats: {
         [key: string]: number;
     };
     unexpectedElements: {

package/dist/types-ts4.5/utils/performance/hooks/use-component-render-tracking/index.d.ts

@@ -1,9 +1,9 @@
 import { type PropsDifference, type ShallowPropsDifference } from '../../../compare-props';
 type PropsDiff<Props> = ShallowPropsDifference<Props> | PropsDifference<Props>;
 type OnRenderCb<Props = undefined> = ({ renderCount, propsDifference, }: {
-    renderCount: number;
-    propsDifference: PropsDiff<Props> | undefined;
     componentId: string;
+    propsDifference: PropsDiff<Props> | undefined;
+    renderCount: number;
 }) => void;
 export type UseComponentRenderTrackingArgs<Props = undefined> = {
     onRender: OnRenderCb<Props>;

package/dist/types-ts4.5/utils/performance/measure-render.d.ts

@@ -1,6 +1,6 @@
 type DistortedDurationMonitor = {
-    distortedDuration: boolean;
     cleanup: () => void;
+    distortedDuration: boolean;
 };
 /**
  * Monitors if a pages enters a visibility state which will lead to
@@ -38,8 +38,6 @@ measureName: string,
  * when the Document.visibilityState is visible.
  */
 onMeasureComplete: ({ duration, startTime, distortedDuration, }: {
-    duration: number;
-    startTime: number;
     /**
      * Will be true when the measurement takes place in a background tab or some
      * other case which results in the Document.visibilityState not being visible.
@@ -48,5 +46,7 @@ onMeasureComplete: ({ duration, startTime, distortedDuration, }: {
      * onMeasureComplete description for more details.
      */
     distortedDuration: boolean;
+    duration: number;
+    startTime: number;
 }) => void): void;
 export {};

package/dist/types-ts4.5/utils/performance/measure-tti.d.ts

@@ -9,6 +9,6 @@ export declare const TTI_FROM_INVOCATION_SEVERITY_THRESHOLD_DEFAULTS: {
     DEGRADED: number;
 };
 export declare function getTTISeverity(tti: number, ttiFromInvocation: number, ttiSeverityNormalThreshold?: number, ttiSeverityDegradedThreshold?: number, ttiFromInvocationSeverityNormalThreshold?: number, ttiFromInvocationSeverityDegradedThreshold?: number): {
-    ttiSeverity: SEVERITY;
     ttiFromInvocationSeverity: SEVERITY;
+    ttiSeverity: SEVERITY;
 };

package/dist/types-ts4.5/utils/plugin-state-factory.d.ts

@@ -4,8 +4,8 @@ import { type Command } from '../types';
 export type Reducer<PluginState, Action> = (state: PluginState, action: Action) => PluginState;
 type MapState<PluginState> = (tr: ReadonlyTransaction, pluginState: PluginState, editorState: EditorState) => PluginState;
 type SafePlugin<PluginState, Action, InitialState extends PluginState> = {
-    createPluginState: (dispatch: Dispatch, initialState: InitialState | ((state: EditorState) => InitialState)) => SafeStateField<PluginState>;
     createCommand: <A = Action>(action: A | ((state: Readonly<EditorState>) => A | false), transform?: (tr: Transaction, state: EditorState) => Transaction) => Command;
+    createPluginState: (dispatch: Dispatch, initialState: InitialState | ((state: EditorState) => InitialState)) => SafeStateField<PluginState>;
     getPluginState: (state: EditorState) => PluginState;
 };
 export declare function pluginFactory<PluginState, Action, InitialState extends PluginState>(pluginKey: PluginKey, reducer: Reducer<PluginState, Action>, options?: {

package/dist/types-ts4.5/utils/profiler/render-count.d.ts

@@ -1,10 +1,9 @@
 export declare const PROFILER_KEY = "__editorRenderCountProfiler";
 interface ComponentInstanceRenderCounter {
-    instanceId: string;
     count: number;
+    instanceId: string;
 }
 type ProfilerData = {
-    enabled: boolean;
     components?: {
         [componentId: string]: {
             [instanceId: string]: {
@@ -12,6 +11,7 @@ type ProfilerData = {
             };
         };
     };
+    enabled: boolean;
 };
 type RenderCountProfilerInstanceParams = {
     store: Object;
@@ -37,8 +37,8 @@ export declare class RenderCountProfiler {
     isEnabled(): boolean;
     setRenderCount({ componentId, renderCount, instanceId, }: {
         componentId: string;
-        renderCount: number;
         instanceId: string;
+        renderCount: number;
     }): void;
     getInstanceRenderCounters({ componentId, }: {
         componentId: string;

package/dist/types-ts4.5/utils/track-unsupported-content.d.ts

@@ -5,15 +5,15 @@ type DispatchAnalyticsEvent = (payload: UnsupportedContentPayload) => void;
 type DispatchAnalyticsEventTooltip = (payload: UnsupportedContentTooltipPayload) => void;
 export declare const findAndTrackUnsupportedContentNodes: (node: PMNode, schema: Schema, dispatchAnalyticsEvent: DispatchAnalyticsEvent, ancestorHierarchy?: string) => void;
 interface UnsupportedNode {
-    type: string;
     ancestry: string;
-    parentType: string;
-    marks: {
-        [key: string]: any;
-    }[];
     attrs: {
         [key: string]: any;
     };
+    marks: {
+        [key: string]: any;
+    }[];
+    parentType: string;
+    type: string;
 }
 export declare const fireUnsupportedEvent: (dispatchAnalyticsEvent: DispatchAnalyticsEvent, actionSubjectId: ACTION_SUBJECT_ID, unsupportedNode: UnsupportedNode, errorCode?: string) => void;
 export declare const trackUnsupportedContentTooltipDisplayedFor: (dispatchAnalyticsEvent: DispatchAnalyticsEventTooltip, unsupportedContentType: UnsupportedContentTooltipPayload["actionSubjectId"], originalNodeType?: string) => void;

package/dist/types-ts4.5/utils/unsupportedContent/get-unsupported-content-level-data.d.ts

@@ -10,10 +10,10 @@ type UnsupportedContentLevelThresholds = {
 };
 export type UnsupportedContentLevelsTracking = {
     enabled: boolean;
-    thresholds?: Partial<UnsupportedContentLevelThresholds>;
     samplingRates?: {
         [key: string]: number;
     };
+    thresholds?: Partial<UnsupportedContentLevelThresholds>;
 };
 export declare const UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS: {
     DEGRADED: number;

package/dist/types-ts4.5/utils/unsupportedContent/types.d.ts

@@ -8,8 +8,8 @@ type AEP<Action, ActionSubject, ActionSubjectID, Attributes, EventType> = {
 };
 type TrackAEP<Action, ActionSubject, ActionSubjectID, Attributes> = AEP<Action, ActionSubject, ActionSubjectID, Attributes, EVENT_TYPE.TRACK>;
 type UnsupportedContentEncounteredAEP = TrackAEP<ACTION.UNSUPPORTED_CONTENT_ENCOUNTERED, ACTION_SUBJECT.DOCUMENT, ACTION_SUBJECT_ID, {
-    unsupportedNode: Record<string, any>;
     errorCode?: String;
+    unsupportedNode: Record<string, any>;
 }>;
 export type UnsupportedContentPayload = UnsupportedContentEncounteredAEP;
 export type UnsupportedContentTooltipPayload = AEP<ACTION.UNSUPPORTED_TOOLTIP_VIEWED, ACTION_SUBJECT.TOOLTIP, ACTION_SUBJECT_ID.ON_UNSUPPORTED_BLOCK | ACTION_SUBJECT_ID.ON_UNSUPPORTED_INLINE, {

package/dist/types-ts4.5/utils/validator.d.ts

@@ -5,26 +5,26 @@ export declare const ADFStages: {
 };
 export type ADFStage = (typeof ADFStages)[keyof typeof ADFStages];
 export interface ADDoc {
-    version: 1;
-    type: 'doc';
     content: ADNode[];
+    type: 'doc';
+    version: 1;
 }
 export interface ADNode {
-    type: string;
     attrs?: any;
     content?: ADNode[];
     marks?: ADMark[];
     text?: string;
+    type: string;
 }
 export interface ADMark {
-    type: string;
     attrs?: any;
+    type: string;
 }
 export interface ADMarkSimple {
+    attrs?: any;
     type: {
         name: string;
     };
-    attrs?: any;
 }
 export declare const markOrder: string[];
 export declare const isSubSupType: (type: string) => type is "sub" | "sup";

package/dist/types-ts4.5/with-plugin-state/index.d.ts

@@ -23,8 +23,8 @@ export type PluginsConfig = {
 };
 export interface Props<P extends NamedPluginKeys> {
     debounce?: boolean;
-    eventDispatcher?: EventDispatcher;
     editorView?: EditorView;
+    eventDispatcher?: EventDispatcher;
     plugins: P;
     render: (pluginState: NamedPluginStates<P>) => React.ReactElement | null;
 }