@atlaskit/editor-core 210.1.6 → 210.1.7

package/dist/types/ui/Appearance/FullPage/MainToolbarWrapper.d.ts

@@ -4,10 +4,10 @@
  */
 import React from 'react';
 interface MainToolbarWrapperProps {
-    showKeyline: boolean;
-    twoLineEditorToolbar: boolean;
     children: React.ReactNode;
     'data-testid'?: string;
+    showKeyline: boolean;
+    twoLineEditorToolbar: boolean;
 }
 /**
  * Wrapper component for the main toolbar that handles feature flag based styling

package/dist/types/ui/Appearance/FullPage/types.d.ts

@@ -1,5 +1,5 @@
 export type ScrollContainerRefs = {
-    scrollContainer: HTMLDivElement | null;
-    contentArea: HTMLDivElement | null;
     containerArea: HTMLDivElement | null;
+    contentArea: HTMLDivElement | null;
+    scrollContainer: HTMLDivElement | null;
 };

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

@@ -5,9 +5,9 @@
 import React from 'react';
 import type { WrappedComponentProps } from 'react-intl-next';
 export interface Props {
-    text?: string;
-    onFocus?: (e: React.FocusEvent<HTMLInputElement>) => void;
     label?: string;
+    onFocus?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    text?: string;
 }
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<Props & WrappedComponentProps>;

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

@@ -1,12 +1,12 @@
 import React from 'react';
 import type Editor from '../../editor';
 export interface Props {
-    placeholder?: string;
     assistiveLabel?: string;
     children?: any;
     isExpanded?: boolean;
-    onFocus?: (e: React.FocusEvent<HTMLInputElement>) => void;
     onExpand?: () => void;
+    onFocus?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    placeholder?: string;
 }
 export type State = Object;
 export default class CollapsedEditor extends React.Component<Props, State> {

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

@@ -8,13 +8,13 @@ import { type Theme } from '@emotion/react';
 import type { EditorAppearance, FeatureFlags } from '@atlaskit/editor-common/types';
 export declare const linkStyles: SerializedStyles;
 type ContentStylesProps = {
-    theme?: Theme;
+    appearance?: EditorAppearance;
     colorMode?: 'light' | 'dark';
     featureFlags?: FeatureFlags;
-    viewMode?: 'view' | 'edit';
-    typographyTheme?: 'typography' | 'typography-adg3' | 'typography-modernized' | 'typography-refreshed';
     isScrollable?: boolean;
-    appearance?: EditorAppearance;
+    theme?: Theme;
+    typographyTheme?: 'typography' | 'typography-adg3' | 'typography-modernized' | 'typography-refreshed';
+    viewMode?: 'view' | 'edit';
 };
 export declare const placeholderStyles: SerializedStyles;
 type Props = ContentStylesProps & React.HTMLProps<HTMLDivElement>;

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

@@ -9,18 +9,18 @@ import type { OptionalPlugin, PublicPluginAPI } from '@atlaskit/editor-common/ty
 import { type ContextPanelPlugin } from '@atlaskit/editor-plugins/context-panel';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 export type Props = {
-    visible: boolean;
-    editorAPI: PublicPluginAPI<[OptionalPlugin<ContextPanelPlugin>]> | undefined;
     children?: React.ReactElement;
-    hasPadding?: boolean;
     customWidth?: number;
+    editorAPI: PublicPluginAPI<[OptionalPlugin<ContextPanelPlugin>]> | undefined;
+    hasPadding?: boolean;
+    visible: boolean;
 };
 export declare const panel: import("@emotion/react").SerializedStyles;
 export declare const content: import("@emotion/react").SerializedStyles;
 type SwappableContentAreaProps = {
-    pluginContent?: React.ReactNode;
     editorView?: EditorView;
     intl: IntlShape;
+    pluginContent?: React.ReactNode;
 } & Props;
 export declare const SwappableContentArea: React.FC<import("react-intl-next").WithIntlProps<SwappableContentAreaProps>> & {
     WrappedComponent: React.ComponentType<SwappableContentAreaProps>;

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

@@ -5,12 +5,12 @@
 import React from 'react';
 import type { EditorAppearance, FeatureFlags } from '@atlaskit/editor-common/types';
 export type EditorContentContainerProps = {
-    className?: string;
+    appearance?: EditorAppearance;
     children?: React.ReactNode;
+    className?: string;
     featureFlags?: FeatureFlags;
-    viewMode?: 'view' | 'edit';
     isScrollable?: boolean;
-    appearance?: EditorAppearance;
+    viewMode?: 'view' | 'edit';
 };
 /**
  * EditorContentStyles is a wrapper component that applies styles to its children

package/dist/types/ui/EditorContentContainer/styles/findReplaceStyles.d.ts

@@ -1,3 +1,2 @@
 export declare const findReplaceStyles: import("@emotion/react").SerializedStyles;
 export declare const findReplaceStylesNew: import("@emotion/react").SerializedStyles;
-export declare const findReplaceStylesNewNoImportant: import("@emotion/react").SerializedStyles;

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

@@ -11,20 +11,20 @@ import type { EditorAppearance, ReactHookFactory, UIComponentFactory } from '@at
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type EditorActions from '../../actions';
 export interface Props {
-    items?: UIComponentFactory[];
-    pluginHooks?: ReactHookFactory[];
-    editorView?: EditorView;
-    editorActions?: EditorActions;
-    eventDispatcher?: EventDispatcher;
-    providerFactory: ProviderFactory;
     appearance?: EditorAppearance;
-    popupsMountPoint?: HTMLElement;
-    popupsBoundariesElement?: HTMLElement;
-    popupsScrollableElement?: HTMLElement;
     containerElement: HTMLElement | null;
+    contentArea?: HTMLElement;
     disabled: boolean;
     dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
-    contentArea?: HTMLElement;
+    editorActions?: EditorActions;
+    editorView?: EditorView;
+    eventDispatcher?: EventDispatcher;
+    items?: UIComponentFactory[];
+    pluginHooks?: ReactHookFactory[];
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    providerFactory: ProviderFactory;
     wrapperElement: HTMLElement | null;
 }
 declare const PluginSlotComponent: React.MemoExoticComponent<({ items, editorView, editorActions, eventDispatcher, providerFactory, appearance, popupsMountPoint, popupsBoundariesElement, popupsScrollableElement, containerElement, disabled, dispatchAnalyticsEvent, wrapperElement, pluginHooks, }: Props) => jsx.JSX.Element | null>;

package/dist/types/ui/PluginSlot/mount-plugin-hooks.d.ts

@@ -2,9 +2,9 @@ import React from 'react';
 import type { ReactHookFactory } from '@atlaskit/editor-common/types';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 interface MountPluginHooksProps {
+    containerElement: HTMLElement | null;
     editorView: EditorView | undefined;
     pluginHooks: ReactHookFactory[] | undefined;
-    containerElement: HTMLElement | null;
 }
 export declare function MountPluginHooks({ pluginHooks, editorView, containerElement, }: MountPluginHooksProps): React.JSX.Element | null;
 export {};

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

@@ -13,10 +13,10 @@ import type { ToolbarProps } from './toolbar-types';
  */
 export declare const Toolbar: (props: ToolbarProps) => JSX.Element;
 type NewToolbarProps = Pick<ToolbarUIContextType, 'popupsMountPoint'> & Pick<EditorToolbarContextType, 'editorAppearance'> & {
-    toolbar: RegisterToolbar;
     components: RegisterComponent[];
-    editorView?: EditorView;
     editorAPI?: PublicPluginAPI<[ToolbarPlugin]>;
+    editorView?: EditorView;
+    toolbar: RegisterToolbar;
 };
 /**
  * Renders a primary toolbar, driven by components registed by `editor-plugin-toolbar`. `ToolbarModelRenderer` will just

package/dist/types/ui/Toolbar/ToolbarPortal.d.ts

@@ -4,17 +4,17 @@
  */
 import React from 'react';
 type ToolbarPortalContextValue = {
+    isActive: boolean;
     Portal: React.ComponentType<{
         children: React.ReactNode;
     }>;
-    isActive: boolean;
 };
 export declare const ToolbarPortalContextProvider: ({ children, portal, isActive, }: {
     children: React.ReactNode;
+    isActive: boolean;
     portal: React.ComponentType<{
         children: React.ReactNode;
     }>;
-    isActive: boolean;
 }) => JSX.Element;
 export declare const useToolbarPortal: () => ToolbarPortalContextValue | undefined;
 export declare const ToolbarPortalMountPoint: () => JSX.Element | null;

package/dist/types/ui/Toolbar/toolbar-types.d.ts

@@ -5,29 +5,29 @@ import type { EditorAppearance, ToolbarSize, ToolbarUIComponentFactory } from '@
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type EditorActions from '../../actions';
 export interface ToolbarBreakPoint {
-    width: number;
     size: ToolbarSize;
+    width: number;
 }
 export interface ToolbarProps {
-    items?: Array<ToolbarUIComponentFactory>;
-    editorView: EditorView;
+    appearance?: EditorAppearance;
+    containerElement: HTMLElement | null;
+    disabled: boolean;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
     editorActions?: EditorActions;
+    editorView: EditorView;
     eventDispatcher: EventDispatcher;
-    providerFactory: ProviderFactory;
-    appearance?: EditorAppearance;
-    popupsMountPoint?: HTMLElement;
+    hasMinWidth?: boolean;
+    items?: Array<ToolbarUIComponentFactory>;
     popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
     popupsScrollableElement?: HTMLElement;
-    disabled: boolean;
-    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    providerFactory: ProviderFactory;
     toolbarSize: ToolbarSize;
-    containerElement: HTMLElement | null;
-    hasMinWidth?: boolean;
     twoLineEditorToolbar?: boolean;
 }
 export type ToolbarWithSizeDetectorProps = Omit<ToolbarProps, 'toolbarSize'>;
 export interface ToolbarInnerProps extends ToolbarProps {
-    isToolbarReducedSpacing: boolean;
     isReducedSpacing?: boolean;
+    isToolbarReducedSpacing: boolean;
 }
 export declare const toolbarTestIdPrefix = "ak-editor-toolbar-button";

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

@@ -4,9 +4,9 @@ import { type ExtractInjectionAPI } from '@atlaskit/editor-common/types';
 import { type HelpDialogPlugin } from '@atlaskit/editor-plugins/help-dialog';
 import type { PositionType } from '@atlaskit/tooltip/types';
 interface Props {
+    editorApi?: ExtractInjectionAPI<HelpDialogPlugin> | undefined;
     title?: string;
     titlePosition?: PositionType;
-    editorApi?: ExtractInjectionAPI<HelpDialogPlugin> | undefined;
 }
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<Props & WrappedComponentProps>;

package/dist/types/utils/deprecation-warnings.d.ts

@@ -1,8 +1,8 @@
 export interface DeprecationWarning<Props> {
-    property: string;
+    condition?: (props: Props) => boolean;
     description?: string;
+    property: string;
     type?: string;
-    condition?: (props: Props) => boolean;
 }
 declare function deprecationWarnings<Props extends object>(className: string, props: Props, deprecations: Array<DeprecationWarning<Props>>): void;
 export default deprecationWarnings;

package/dist/types/utils/performance/components/RenderTracking.d.ts

@@ -2,9 +2,9 @@ import type { ACTION, ACTION_SUBJECT, FireAnalyticsCallback } from '@atlaskit/ed
 type RenderActions = ACTION.RE_RENDERED;
 type RenderActionSubjects = ACTION_SUBJECT.EDITOR | ACTION_SUBJECT.REACT_EDITOR_VIEW;
 export type RenderTrackingProps<ComponentProps> = {
-    componentProps: ComponentProps;
     action: RenderActions;
     actionSubject: RenderActionSubjects;
+    componentProps: ComponentProps;
     handleAnalyticsEvent: FireAnalyticsCallback;
     propsToIgnore?: Array<keyof ComponentProps>;
     useShallow?: boolean;

package/dist/types/utils/performance/plugin-performance-report.d.ts

@@ -4,15 +4,15 @@ export interface OutlierReport {
     viewUpdateOutlier: number | undefined;
 }
 export interface PluginPerformanceReportOptions {
-    usePerformanceMarks?: boolean;
+    outlierFactor: number;
+    outlierThreshold: number;
     samplingRate: number;
     slowThreshold: number;
-    outlierThreshold: number;
-    outlierFactor: number;
+    usePerformanceMarks?: boolean;
 }
 export type NodesCount = {
-    nodeCount: NodeCount;
     extensionNodeCount: NodeCount;
+    nodeCount: NodeCount;
 };
 export declare class PluginPerformanceReport {
     private entry;

package/dist/types/utils/performance/simple-measure-to-entries.d.ts

@@ -1,6 +1,6 @@
 interface Reading {
-    name: string;
     duration: number;
+    name: string;
     startTime: number;
 }
 type ObservationCallback = (entries: PerformanceObserverEntryList) => void;

package/dist/types/utils/performance/track-transactions.d.ts

@@ -10,8 +10,8 @@ interface MeasureHelpers {
     stopMeasure: (measureName: string, onMeasureComplete?: (duration: number, startTime: number) => void) => void;
 }
 interface SimpleEntry {
-    name: string;
     duration: number;
+    name: string;
     startTime: number;
 }
 type MeasureListener = (entry: SimpleEntry) => void;

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

@@ -8,9 +8,9 @@ export type EditorModule = {
     WithEditorActions: typeof EditorImports.WithEditorActions;
 } & EditorModules;
 export interface Props {
-    placeholder?: string;
     isExpanded?: boolean;
     onClickToExpand?: () => void;
+    placeholder?: string;
     renderEditor: (Editor: typeof EditorImports.Editor, modules: EditorModule) => JSX.Element;
 }
 export interface State {

package/dist/types-ts4.5/composable-editor/BaseThemeWrapper.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 type BaseThemeProps = {
-    children: React.ReactNode;
     baseFontSize?: number;
+    children: React.ReactNode;
 };
 export declare function BaseThemeWrapper({ baseFontSize, children }: BaseThemeProps): React.JSX.Element;
 export {};

package/dist/types-ts4.5/composable-editor/editor-internal.d.ts

@@ -10,24 +10,24 @@ import type EditorActions from '../actions';
 import { type EditorAppearanceComponentProps } from '../types';
 import type { EditorNextProps } from '../types/editor-props';
 interface InternalProps {
-    props: EditorNextProps;
-    handleAnalyticsEvent: FireAnalyticsCallback;
+    AppearanceComponent: React.ComponentType<React.PropsWithChildren<EditorAppearanceComponentProps<[
+    ]>>>;
     createAnalyticsEvent: CreateUIAnalyticsEvent;
-    handleSave: (view: EditorView) => void;
     editorActions: EditorActions;
+    handleAnalyticsEvent: FireAnalyticsCallback;
+    handleSave: (view: EditorView) => void;
     onEditorCreated: (instance: {
-        view: EditorView;
         eventDispatcher: EventDispatcher;
         transformer?: Transformer<string>;
+        view: EditorView;
     }) => void;
     onEditorDestroyed: (_instance: {
-        view: EditorView;
         transformer?: Transformer<string>;
+        view: EditorView;
     }) => void;
     preset: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>;
+    props: EditorNextProps;
     providerFactory: ProviderFactory;
-    AppearanceComponent: React.ComponentType<React.PropsWithChildren<EditorAppearanceComponentProps<[
-    ]>>>;
 }
 /**
  * EditorInternalComponent is used to capture the common component

package/dist/types-ts4.5/composable-editor/hooks/useProviders.d.ts

@@ -11,6 +11,9 @@ import type { EmojiProvider } from '@atlaskit/emoji';
 import type { MentionProvider } from '@atlaskit/mention/resource';
 import type { TaskDecisionProvider } from '@atlaskit/task-decision/types';
 interface UseProvidersProps {
+    autoformattingProvider: Promise<AutoformattingProvider> | undefined;
+    cardProvider: Promise<CardProvider> | undefined;
+    contextIdentifierProvider: Promise<ContextIdentifierProvider> | undefined;
     editorApi: PublicPluginAPI<[
         OptionalPlugin<ContextIdentifierPlugin>,
         OptionalPlugin<MediaPlugin>,
@@ -20,12 +23,9 @@ interface UseProvidersProps {
         OptionalPlugin<CustomAutoformatPlugin>,
         OptionalPlugin<TasksAndDecisionsPlugin>
     ]> | undefined;
-    contextIdentifierProvider: Promise<ContextIdentifierProvider> | undefined;
+    emojiProvider: Promise<EmojiProvider> | undefined;
     mediaProvider: Promise<MediaProvider> | undefined;
     mentionProvider: Promise<MentionProvider> | undefined;
-    cardProvider: Promise<CardProvider> | undefined;
-    emojiProvider: Promise<EmojiProvider> | undefined;
-    autoformattingProvider: Promise<AutoformattingProvider> | undefined;
     taskDecisionProvider: Promise<TaskDecisionProvider> | undefined;
 }
 /**

package/dist/types-ts4.5/create-editor/ErrorBoundary.d.ts

@@ -5,13 +5,13 @@ import type { FeatureFlags } from '@atlaskit/editor-common/types';
 import type { UserBrowserExtensionResults } from '@atlaskit/editor-common/utils';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 export type ErrorBoundaryProps = {
-    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    children: React.ReactNode;
     contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
     editorView?: EditorView;
-    rethrow?: boolean;
-    children: React.ReactNode;
-    featureFlags: FeatureFlags;
     errorTracking?: boolean;
+    featureFlags: FeatureFlags;
+    rethrow?: boolean;
 };
 export type ErrorBoundaryState = {
     error?: Error;

package/dist/types-ts4.5/create-editor/ReactEditorView/useDispatchTransaction.d.ts

@@ -5,9 +5,9 @@ import type { EditorViewStateUpdatedCallbackProps } from '../../types/editor-con
 import type { EditorOnChangeHandler } from '../../types/editor-onchange';
 type DispatchTransaction = (view: EditorView | undefined, tr: Transaction) => void;
 export declare const useDispatchTransaction: ({ onChange, dispatchAnalyticsEvent, onEditorViewUpdated, isRemoteReplaceDocumentTransaction, }: {
-    onChange: EditorOnChangeHandler | undefined;
     dispatchAnalyticsEvent: (payload: AnalyticsEventPayload) => void;
-    onEditorViewUpdated: (params: EditorViewStateUpdatedCallbackProps) => void;
     isRemoteReplaceDocumentTransaction?: (tr: Transaction) => boolean;
+    onChange: EditorOnChangeHandler | undefined;
+    onEditorViewUpdated: (params: EditorViewStateUpdatedCallbackProps) => void;
 }) => DispatchTransaction;
 export {};

package/dist/types-ts4.5/create-editor/ReactEditorView.d.ts

@@ -11,37 +11,37 @@ import { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { EditorConfig, EditorProps } from '../types';
 import type { EditorNextProps } from '../types/editor-props';
 export interface EditorViewProps extends WrappedComponentProps {
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    disabled?: boolean;
     editorProps: (EditorProps | EditorNextProps) & {
         preset?: EditorNextProps['preset'];
     };
-    createAnalyticsEvent?: CreateUIAnalyticsEvent;
-    providerFactory: ProviderFactory;
-    portalProviderAPI: PortalProviderAPI;
     nodeViewPortalProviderAPI: PortalProviderAPI;
-    disabled?: boolean;
-    render?: (props: {
-        editor: JSX.Element;
-        view?: EditorView;
-        config: EditorConfig;
-        eventDispatcher: EventDispatcher;
-        transformer?: Transformer<string>;
-        dispatchAnalyticsEvent: DispatchAnalyticsEvent;
-        editorRef: React.RefObject<HTMLDivElement>;
-        editorAPI: PublicPluginAPI<any> | undefined;
-    }) => JSX.Element;
     onEditorCreated: (instance: {
-        view: EditorView;
         config: EditorConfig;
         eventDispatcher: EventDispatcher;
         transformer?: Transformer<string>;
+        view: EditorView;
     }) => void;
     onEditorDestroyed: (instance: {
-        view: EditorView;
         config: EditorConfig;
         eventDispatcher: EventDispatcher;
         transformer?: Transformer<string>;
+        view: EditorView;
     }) => void;
+    portalProviderAPI: PortalProviderAPI;
     preset: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>;
+    providerFactory: ProviderFactory;
+    render?: (props: {
+        config: EditorConfig;
+        dispatchAnalyticsEvent: DispatchAnalyticsEvent;
+        editor: JSX.Element;
+        editorAPI: PublicPluginAPI<any> | undefined;
+        editorRef: React.RefObject<HTMLDivElement>;
+        eventDispatcher: EventDispatcher;
+        transformer?: Transformer<string>;
+        view?: EditorView;
+    }) => JSX.Element;
 }
 export declare function ReactEditorView(props: EditorViewProps): React.JSX.Element;
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<EditorViewProps>> & {

package/dist/types-ts4.5/create-editor/create-schema.d.ts

@@ -14,8 +14,8 @@ type toDOMType = (node: PMNode | PMMark) => DOMOutputSpec;
  * @returns {DOMOutputSpec} The modified DOMOutputSpec with additional metadata.
  */
 export declare const addMetadataAttributes: ({ nodeOrMark, domSpec, }: {
-    nodeOrMark: PMNode | PMMark;
     domSpec: DOMOutputSpec;
+    nodeOrMark: PMNode | PMMark;
 }) => DOMOutputSpec;
 /**
  * 🧱 Internal Helper Function: Editor FE Platform