@atlaskit/editor-common 107.28.2 → 107.30.0

package/dist/types/react-node-view/getInlineNodeViewProducer.d.ts

@@ -7,31 +7,31 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { Decoration, EditorView, NodeView } from '@atlaskit/editor-prosemirror/view';
 import type { PMPluginFactoryParams } from '../types';
 export type InlineNodeViewComponentProps = {
-    view: EditorView;
     getPos: () => GetPosReturn;
     node: PMNode;
+    view: EditorView;
 };
 type InlineNodeViewComponent<ExtraComponentProps> = React.ComponentType<React.PropsWithChildren<InlineNodeViewComponentProps & ExtraComponentProps>>;
 export type CreateNodeViewOptions<ExtraComponentProps> = {
-    nodeViewParams: NodeViewParams;
-    pmPluginFactoryParams: PMPluginFactoryParams;
     Component: InlineNodeViewComponent<ExtraComponentProps>;
     extraComponentProps: ExtraComponentProps;
     extraNodeViewProps?: Pick<NodeView, 'stopEvent'>;
+    nodeViewParams: NodeViewParams;
+    pmPluginFactoryParams: PMPluginFactoryParams;
 };
 export declare const inlineNodeViewClassname = "inlineNodeView";
 type NodeViewProducer = (node: PMNode, view: EditorView, getPos: () => GetPosReturn, decorations: readonly Decoration[]) => NodeView;
 type GetPosReturn = number | undefined;
 type NodeViewParams = {
+    decorations: Parameters<NodeViewProducer>[3];
+    getPos: () => GetPosReturn;
     node: Parameters<NodeViewProducer>[0];
     view: Parameters<NodeViewProducer>[1];
-    getPos: () => GetPosReturn;
-    decorations: Parameters<NodeViewProducer>[3];
 };
 export declare function getInlineNodeViewProducer<ExtraComponentProps>({ pmPluginFactoryParams, Component, extraComponentProps, extraNodeViewProps, }: {
-    pmPluginFactoryParams: PMPluginFactoryParams;
     Component: InlineNodeViewComponent<ExtraComponentProps>;
     extraComponentProps?: ExtraComponentProps;
     extraNodeViewProps?: Pick<NodeView, 'stopEvent'>;
+    pmPluginFactoryParams: PMPluginFactoryParams;
 }): NodeViewProducer;
 export {};

package/dist/types/react-node-view/index.d.ts

@@ -36,8 +36,8 @@ export default class ReactNodeView<P = ReactComponentProps> implements NodeView
     private renderReactComponent;
     createDomRef(): HTMLElement;
     getContentDOM(): {
-        dom: HTMLElement;
         contentDOM?: HTMLElement | null | undefined;
+        dom: HTMLElement;
     } | undefined;
     handleRef: (node: HTMLElement | null) => void;
     private _handleRef;

package/dist/types/resizer/BreakoutResizer.d.ts

@@ -5,23 +5,23 @@ import { type GuidelineConfig } from '../guideline';
 import { type EditorContainerWidth, type getPosHandlerNode } from '../types';
 type BreakoutSupportedNodes = 'layoutSection' | 'expand' | 'codeBlock';
 export declare const ignoreResizerMutations: (mutation: MutationRecord | {
-    type: "selection";
     target: Node;
+    type: "selection";
 }) => boolean;
 type BreakoutResizerProps = {
-    editorView: EditorView;
-    nodeType: BreakoutSupportedNodes;
-    getPos: getPosHandlerNode;
-    getRef?: (ref: HTMLElement | null) => void;
     disabled?: boolean;
-    getEditorWidth: () => EditorContainerWidth | undefined;
-    parentRef?: HTMLElement;
-    editorAnalyticsApi?: EditorAnalyticsAPI;
-    displayGuidelines?: (guidelines: GuidelineConfig[]) => void;
     displayGapCursor: (toggle: boolean) => boolean;
-    onResizeStart?: () => void;
+    displayGuidelines?: (guidelines: GuidelineConfig[]) => void;
     dynamicFullWidthGuidelineOffset?: number;
+    editorAnalyticsApi?: EditorAnalyticsAPI;
+    editorView: EditorView;
+    getEditorWidth: () => EditorContainerWidth | undefined;
+    getPos: getPosHandlerNode;
+    getRef?: (ref: HTMLElement | null) => void;
     hidden?: boolean;
+    nodeType: BreakoutSupportedNodes;
+    onResizeStart?: () => void;
+    parentRef?: HTMLElement;
 };
 /**
  * BreakoutResizer is a common component used to resize nodes that support the 'Breakout' mark, so it requires

package/dist/types/resizer/Resizer.d.ts

@@ -3,40 +3,32 @@ import type { CSSProperties } from 'react';
 import type { TooltipProps } from '@atlaskit/tooltip';
 import type { EnabledHandles, HandleAlignmentMethod, HandleHighlight, HandlePositioning, HandleResize, HandleResizeStart, HandleSize, HandleStyles, ResizerAppearance, Snap } from './types';
 export type ResizerProps = {
-    className?: string;
-    enable: EnabledHandles;
-    width?: number;
-    minWidth?: number | string;
-    maxWidth?: number | string;
-    snap?: Snap;
-    snapGap?: number;
-    resizeRatio?: number;
     appearance?: ResizerAppearance;
-    isHandleVisible?: boolean;
-    handleResizeStart: HandleResizeStart;
-    handleResize?: HandleResize;
-    handleResizeStop: HandleResize;
     /**
-     * This can be used to override the css class name applied to the resize handle.
+     * Access to the inner most element which wraps passed children
      */
-    handleClassName?: string;
+    childrenDOMRef?: (ref: HTMLElement | null) => void;
+    className?: string;
+    enable: EnabledHandles;
     /**
-     * This is used to override the style of resize handles wrapper.
+     * The handleAlignmentMethod is used in determining the vertical positioning of the resizer handle in relation to its children.
      */
-    handleWrapperStyle?: CSSProperties;
+    handleAlignmentMethod?: HandleAlignmentMethod;
     /**
-     * This property is used to override the style of one or more resize handles. Only the axis you specify will have
-     * its handle style overriden.
+     * This can be used to override the css class name applied to the resize handle.
      */
-    handleStyles?: HandleStyles;
+    handleClassName?: string;
     /**
-     * The handleAlignmentMethod is used in determining the vertical positioning of the resizer handle in relation to its children.
+     * The handleHighlight is used to determine how the handle looks when the users mouse hovers over the handle element.
      */
-    handleAlignmentMethod?: HandleAlignmentMethod;
+    handleHighlight?: HandleHighlight;
     /**
      * The handlePositioning is used to determine the horizontal position of the resizer handle in relation to its children.
      */
     handlePositioning?: HandlePositioning;
+    handleResize?: HandleResize;
+    handleResizeStart: HandleResizeStart;
+    handleResizeStop: HandleResize;
     /**
      * The handleSize is used to determine the width/height of the handle element.
      *
@@ -44,30 +36,38 @@ export type ResizerProps = {
      */
     handleSize?: HandleSize;
     /**
-     * The handleHighlight is used to determine how the handle looks when the users mouse hovers over the handle element.
+     * This property is used to override the style of one or more resize handles. Only the axis you specify will have
+     * its handle style overriden.
      */
-    handleHighlight?: HandleHighlight;
+    handleStyles?: HandleStyles;
     /**
      * The handle can display a tooltip when mouse hovers.
      */
     handleTooltipContent?: TooltipProps['content'];
     /**
-     * control if extended resize zone is needed, by default we apply it to the resizer
+     * This is used to override the style of resize handles wrapper.
      */
-    needExtendedResizeZone?: boolean;
+    handleWrapperStyle?: CSSProperties;
+    isHandleVisible?: boolean;
     /**
-     * Additional styles to be applied to the resizer component
+     * Children of the component, this is going to be display below the resizer
+     * useful for displaying a label such as size or layout
      */
-    style?: CSSProperties;
+    labelComponent?: React.ReactNode;
+    maxWidth?: number | string;
+    minWidth?: number | string;
     /**
-     * Access to the inner most element which wraps passed children
+     * control if extended resize zone is needed, by default we apply it to the resizer
      */
-    childrenDOMRef?: (ref: HTMLElement | null) => void;
+    needExtendedResizeZone?: boolean;
+    resizeRatio?: number;
+    snap?: Snap;
+    snapGap?: number;
     /**
-     * Children of the component, this is going to be display below the resizer
-     * useful for displaying a label such as size or layout
+     * Additional styles to be applied to the resizer component
      */
-    labelComponent?: React.ReactNode;
+    style?: CSSProperties;
+    width?: number;
 };
 type forwardRefType = {
     getResizerThumbEl: () => HTMLButtonElement | null;

package/dist/types/resizer/types.d.ts

@@ -3,8 +3,8 @@ export type EnabledHandles = {
     right?: boolean;
 };
 export type Dimensions = {
-    width: number;
     height: number;
+    width: number;
 };
 export type Position = {
     x: number;
@@ -17,8 +17,8 @@ export type Snap = {
 export type HandleResize = (newWidth: Position & Dimensions, delta: Dimensions) => void;
 export type HandleResizeStart = () => void;
 export type HandleStyles = {
-    right?: React.CSSProperties;
     left?: React.CSSProperties;
+    right?: React.CSSProperties;
 };
 export type HandleSize = 'small' | 'medium' | 'large' | 'clamped';
 export type HandleAlignmentMethod = 'center' | 'sticky';

package/dist/types/safe-plugin/index.d.ts

@@ -14,8 +14,8 @@ import type { SafePluginSpec } from '@atlaskit/editor-prosemirror/state';
  * @param {HTMLElement} params.dom - The DOM element to which the metadata attributes will be attached.
  */
 export declare const attachGenericProseMirrorMetadata: ({ nodeOrMark, dom, options, }: {
-    nodeOrMark: PMNode | PMMark;
     dom: HTMLElement;
+    nodeOrMark: PMNode | PMMark;
     options?: {
         anchrorId?: string;
     };

package/dist/types/selection/gap-cursor/actions.d.ts

@@ -5,7 +5,7 @@ export declare const setSelectionTopLevelBlocks: (tr: Transaction, event: React.
     left: number;
     top: number;
 }) => {
-    pos: number;
     inside: number;
+    pos: number;
 } | null | void, editorFocused: boolean) => void;
 export declare const setGapCursorAtPos: (position: number, side?: Side) => Command;

package/dist/types/selection/gap-cursor/selection.d.ts

@@ -20,8 +20,8 @@ export declare class GapCursorSelection extends Selection {
     static findFrom($pos: ResolvedPos, dir: number, mustMove?: boolean): GapCursorSelection | null;
     static fromJSON(doc: PMNode, json: {
         pos: number;
-        type: string;
         side: Side;
+        type: string;
     }): GapCursorSelection;
     map(doc: PMNode, mapping: Mapping): Selection;
     eq(other: Selection): boolean;

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

@@ -27,6 +27,6 @@ export declare function getRangeSelectionAnalyticsPayload(selection: Selection,
  */
 export declare const selectNode: (pos: number) => Command;
 export declare function createSelectionClickHandler(nodes: string[], isValidTarget: (target: HTMLElement) => boolean, options: {
-    useLongPressSelection: boolean;
     getNodeSelectionPos?: (state: EditorState, nodePos: number) => number;
+    useLongPressSelection: boolean;
 }): (view: EditorView, pos: number, node: PmNode, nodePos: number, event: MouseEvent, direct: boolean) => boolean;

package/dist/types/selection/types.d.ts

@@ -19,15 +19,15 @@ export interface SelectionPluginState {
     selectionRelativeToNode?: RelativeSelectionPos;
 }
 export type SetSelectionRelativeToNode = (props: {
-    selectionRelativeToNode?: RelativeSelectionPos;
     selection?: Selection | null;
+    selectionRelativeToNode?: RelativeSelectionPos;
 }) => (state: EditorState) => Transaction;
 export type EditorSelectionAPI = {
-    setSelectionRelativeToNode: SetSelectionRelativeToNode;
     getSelectionPluginState: (state: EditorState) => SelectionPluginState;
+    setSelectionRelativeToNode: SetSelectionRelativeToNode;
 };
 export type SelectionPluginOptions = LongPressSelectionPluginOptions;
 export type SelectionSharedState = {
-    selectionRelativeToNode?: RelativeSelectionPos | undefined;
     selection?: Selection | undefined;
+    selectionRelativeToNode?: RelativeSelectionPos | undefined;
 } | undefined;

package/dist/types/table/SortingIcon.d.ts

@@ -8,9 +8,9 @@ export declare enum StatusClassNames {
 }
 type SortingIconProps = {
     isSortingAllowed: boolean;
-    sortOrdered?: SortOrder;
     onClick: () => void;
     onKeyDown: (event: React.KeyboardEvent<HTMLElement>) => void;
+    sortOrdered?: SortOrder;
 } & WrappedComponentProps;
 declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<SortingIconProps>> & {
     WrappedComponent: import("react").ComponentType<SortingIconProps>;

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

@@ -2,8 +2,8 @@ import React from 'react';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { EditorAppearance } from '../types';
 export type EditorToolbarContextType = {
-    editorView: EditorView | null;
     editorAppearance?: EditorAppearance;
+    editorView: EditorView | null;
 };
 /**
  * Access editor specific config and state within a toolbar component

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

@@ -4,65 +4,65 @@ import type { AddNodeMarkStep, AddMarkStep, RemoveMarkStep, RemoveNodeMarkStep }
 import type { AnnotationManager } from '../../annotation';
 import type { AnnotationState, AnnotationUpdateEmitter } from './emitter';
 export type AnnotationByMatches = {
-    originalSelection: string;
-    numMatches: number;
+    isAnnotationAllowed?: boolean;
     matchIndex: number;
+    numMatches: number;
+    originalSelection: string;
     pos?: number;
-    isAnnotationAllowed?: boolean;
 };
 type ActionResult = {
-    step: RemoveMarkStep | RemoveNodeMarkStep;
     doc: JSONDocNode;
+    step: RemoveMarkStep | RemoveNodeMarkStep;
 } | false;
 export type AnnotationActionResult = ({
-    step: AddMarkStep | AddNodeMarkStep;
     doc: JSONDocNode;
     /** The list of types of all inline nodes, which were wrapped by annotation. */
     inlineNodeTypes?: string[];
+    step: AddMarkStep | AddNodeMarkStep;
     targetNodeType?: string;
 } & AnnotationByMatches) | false;
 export type InlineCommentSelectionComponentProps = {
     /**
-     * Range selected
+     * Call this function to surround the range with a HTML tag.
      */
-    range: Range | null;
+    applyDraftMode: (options: {
+        annotationId?: string;
+        keepNativeSelection?: boolean;
+    }) => AnnotationActionResult;
     /**
      * The draft range of a pre-committed annotation
      */
     draftRange?: Range | null;
     /**
-     * Renderer/Editor DOM element ancestors wrapping the selection.
+     * getAnnotationIndexMatch finds the { numMatch, matchIndex } tuple of the current selection
      */
-    wrapperDOM: HTMLElement;
+    getAnnotationIndexMatch?: () => AnnotationByMatches | false;
+    /** The list of types of all inline nodes, which were wrapped by annotation. */
+    inlineNodeTypes?: string[];
     /**
      * If it is possible to add an inline comment on this range
      */
     isAnnotationAllowed: boolean;
-    /**
-     * Creates an annotation mark in the document with the given id.
-     */
-    onCreate: (annotationId: AnnotationId) => AnnotationActionResult;
     /**
      * Indicates that a draft comment was discarded/cancelled
      */
     onClose: () => void;
     /**
-     * Call this function to surround the range with a HTML tag.
+     * Creates an annotation mark in the document with the given id.
      */
-    applyDraftMode: (options: {
-        annotationId?: string;
-        keepNativeSelection?: boolean;
-    }) => AnnotationActionResult;
+    onCreate: (annotationId: AnnotationId) => AnnotationActionResult;
+    /**
+     * Range selected
+     */
+    range: Range | null;
     /**
      * Call this function to remove the draft HTML tags created by the applyDraftMode
      */
     removeDraftMode: () => void;
     /**
-     * getAnnotationIndexMatch finds the { numMatch, matchIndex } tuple of the current selection
+     * Renderer/Editor DOM element ancestors wrapping the selection.
      */
-    getAnnotationIndexMatch?: () => AnnotationByMatches | false;
-    /** The list of types of all inline nodes, which were wrapped by annotation. */
-    inlineNodeTypes?: string[];
+    wrapperDOM: HTMLElement;
 };
 type AnnotationInfo = {
     id: AnnotationId;
@@ -89,58 +89,58 @@ export type InlineCommentViewComponentProps = {
 };
 export type InlineCommentHoverComponentProps = {
     /**
-     * Range selected
-     */
-    range: Range;
-    /**
-     * Is mouse within the range container
+     * Call this function to surround the range with a HTML tag.
      */
-    isWithinRange: boolean;
+    applyDraftMode: (options: {
+        annotationId?: string;
+        keepNativeSelection?: boolean;
+    }) => AnnotationActionResult;
     /**
-     * Renderer/Editor DOM element ancestors wrapping the selection.
+     * getAnnotationIndexMatch finds the { numMatch, matchIndex } tuple of the current selection
      */
-    wrapperDOM: HTMLElement;
+    getAnnotationIndexMatch?: () => AnnotationByMatches | false;
     /**
      * If it is possible to add an inline comment on this range
      */
     isAnnotationAllowed: boolean;
     /**
-     * Creates an annotation mark in the document with the given id.
+     * Is mouse within the range container
      */
-    onCreate: (annotationId: AnnotationId) => AnnotationActionResult;
+    isWithinRange: boolean;
     /**
      * Indicates that a draft comment was discarded/cancelled
      */
     onClose: () => void;
     /**
-     * Call this function to surround the range with a HTML tag.
+     * Creates an annotation mark in the document with the given id.
      */
-    applyDraftMode: (options: {
-        annotationId?: string;
-        keepNativeSelection?: boolean;
-    }) => AnnotationActionResult;
+    onCreate: (annotationId: AnnotationId) => AnnotationActionResult;
+    /**
+     * Range selected
+     */
+    range: Range;
     /**
      * Call this function to remove the draft HTML tags created by the applyDraftMode
      */
     removeDraftMode: () => void;
     /**
-     * getAnnotationIndexMatch finds the { numMatch, matchIndex } tuple of the current selection
+     * Renderer/Editor DOM element ancestors wrapping the selection.
      */
-    getAnnotationIndexMatch?: () => AnnotationByMatches | false;
+    wrapperDOM: HTMLElement;
 };
 interface AnnotationTypeProvider<Type> {
+    allowCommentsOnMedia?: boolean;
+    allowDraftMode?: boolean;
     getState: (annotationIds: string[], isNestedRender: boolean) => Promise<AnnotationState<Type>[]>;
     updateSubscriber?: AnnotationUpdateEmitter;
-    allowDraftMode?: boolean;
-    allowCommentsOnMedia?: boolean;
 }
 export type InlineCommentAnnotationProvider = AnnotationTypeProvider<AnnotationTypes.INLINE_COMMENT> & {
+    hoverComponent?: React.ComponentType<InlineCommentHoverComponentProps>;
     selectionComponent?: React.ComponentType<React.PropsWithChildren<InlineCommentSelectionComponentProps>>;
     viewComponent?: React.ComponentType<React.PropsWithChildren<InlineCommentViewComponentProps>>;
-    hoverComponent?: React.ComponentType<InlineCommentHoverComponentProps>;
 };
 export type AnnotationProviders = {
-    inlineComment: InlineCommentAnnotationProvider;
     annotationManager?: AnnotationManager;
+    inlineComment: InlineCommentAnnotationProvider;
 };
 export {};

package/dist/types/types/copy-button.d.ts

@@ -3,22 +3,22 @@ import type { MarkType, NodeType } from '@atlaskit/editor-prosemirror/model';
 import type { EditorState } from '@atlaskit/editor-prosemirror/state';
 import { type Command } from './command';
 export type MarkOptions = {
-    state: EditorState;
     formatMessage: IntlShape['formatMessage'];
-    nodeType?: undefined;
     markType: MarkType;
+    nodeType?: undefined;
+    onBlur?: Command;
+    onFocus?: Command;
     onMouseEnter?: undefined;
     onMouseLeave?: undefined;
-    onFocus?: Command;
-    onBlur?: Command;
+    state: EditorState;
 };
 export type NodeOptions = {
-    state: EditorState;
     formatMessage: IntlShape['formatMessage'];
-    nodeType: NodeType | Array<NodeType>;
     markType?: undefined;
+    nodeType: NodeType | Array<NodeType>;
+    onBlur?: Command;
+    onFocus?: Command;
     onMouseEnter?: Command;
     onMouseLeave?: Command;
-    onFocus?: Command;
-    onBlur?: Command;
+    state: EditorState;
 };

package/dist/types/types/doc-builder.d.ts

@@ -17,9 +17,9 @@ export type Refs = {
  * A standard ProseMirror Node that also tracks refs.
  */
 export interface RefsNode extends Node {
-    refs: Refs;
     ignoreContent?: boolean;
     originalAttributes?: unknown;
+    refs: Refs;
 }
 export type DocBuilder = (schema: Schema) => RefsNode;
 export {};

package/dist/types/types/editor-actions.d.ts

@@ -7,16 +7,16 @@ export type ContextUpdateHandler = (editorView: EditorView, eventDispatcher: Eve
 export type ReplaceRawValue = Node | object | string;
 export type GetResolvedEditorStateReason = 'publish' | 'draft-sync' | 'get-content';
 export interface EditorActionsOptions<T = any> {
-    focus(): boolean;
+    appendText(text: string): boolean;
     blur(): boolean;
     clear(): boolean;
-    getValue(): Promise<T | JSONDocNode | undefined>;
-    getNodeByLocalId(id: string): Node | undefined;
+    focus(): boolean;
     getNodeByFragmentLocalId(id: string): Node | undefined;
+    getNodeByLocalId(id: string): Node | undefined;
+    getResolvedEditorState(reason: GetResolvedEditorStateReason): Promise<ResolvedEditorState | undefined>;
     getSelectedNode(): Node | undefined;
+    getValue(): Promise<T | JSONDocNode | undefined>;
+    isDocumentEmpty(): boolean;
     replaceDocument(rawValue: any): boolean;
     replaceSelection(rawValue: ReplaceRawValue | Array<ReplaceRawValue>): boolean;
-    appendText(text: string): boolean;
-    isDocumentEmpty(): boolean;
-    getResolvedEditorState(reason: GetResolvedEditorStateReason): Promise<ResolvedEditorState | undefined>;
 }

package/dist/types/types/editor-container-width.d.ts

@@ -1,11 +1,4 @@
 export type EditorContainerWidth = {
-    /**
-     * Starts as offsetWidth of document body, and then
-     * updates to the editors content areas offsetWidth
-     * via the use of a contentComponent (via the
-     * container element prop).
-     */
-    width: number;
     /**
      * Starts as undefined, and then updates to the
      * clientWidth of the dom element the EditorView
@@ -15,5 +8,12 @@ export type EditorContainerWidth = {
      * context panel or editor widths change.
      */
     lineLength?: number;
+    /**
+     * Starts as offsetWidth of document body, and then
+     * updates to the editors content areas offsetWidth
+     * via the use of a contentComponent (via the
+     * container element prop).
+     */
+    width: number;
 };
 export type GetEditorContainerWidth = () => EditorContainerWidth;