@atlaskit/editor-plugin-table 12.3.0 → 12.3.2

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

@@ -17,9 +17,9 @@ export type RowInsertPosition = 'TOP' | 'BOTTOM';
  **/
 export type PermittedLayoutsDescriptor = TableLayout[] | 'all';
 export type Cell = {
+    node: PmNode;
     pos: number;
     start: number;
-    node: PmNode;
 };
 export type CellTransform = (cell: Cell) => (tr: Transaction) => Transaction;
 export interface InsertRowOptions {
@@ -35,44 +35,44 @@ export type PluginInjectionAPIWithA11y = ExtractInjectionAPI<TablePlugin> & {
     };
 };
 export type TableSharedStateInternal = Pick<TablePluginState, 'isFullWidthModeEnabled' | 'wasFullWidthModeEnabled' | 'isHeaderRowEnabled' | 'isHeaderColumnEnabled' | 'ordering' | 'isInDanger' | 'hoveredRows' | 'hoveredColumns' | 'hoveredCell' | 'isTableHovered' | 'tableNode' | 'widthToWidest' | 'tableRef' | 'tablePos' | 'targetCellPosition' | 'isContextualMenuOpen' | 'pluginConfig' | 'insertColumnButtonIndex' | 'insertRowButtonIndex' | 'isDragAndDropEnabled' | 'tableWrapperTarget' | 'isCellMenuOpenByKeyboard'> & {
-    isResizing: boolean;
-    isTableResizing?: boolean;
-    isWholeTableInDanger?: boolean;
-    resizingTableRef?: HTMLTableElement;
-    resizingTableLocalId?: string;
-    stickyHeader?: RowStickyState;
     dragMenuDirection?: TableDirection;
     dragMenuIndex?: number;
     isDragMenuOpen?: boolean;
+    isResizing: boolean;
     isSizeSelectorOpen?: boolean;
+    isTableResizing?: boolean;
+    isWholeTableInDanger?: boolean;
+    resizingTableLocalId?: string;
+    resizingTableRef?: HTMLTableElement;
     sizeSelectorTargetRef?: HTMLElement;
+    stickyHeader?: RowStickyState;
 };
 export type TableSharedState = Pick<TablePluginState, 'isFullWidthModeEnabled' | 'wasFullWidthModeEnabled'>;
 export type AlignmentOptions = 'center' | 'align-start';
 export type InsertRowMethods = INPUT_METHOD.CONTEXT_MENU | INPUT_METHOD.BUTTON | INPUT_METHOD.SHORTCUT | INPUT_METHOD.KEYBOARD | INPUT_METHOD.FLOATING_TB | INPUT_METHOD.TABLE_CONTEXT_MENU;
 export interface PluginConfig {
     advanced?: boolean;
+    allowAddColumnWithCustomStep?: boolean;
     allowBackgroundColor?: boolean;
+    allowCellOptionsInFloatingToolbar?: boolean;
+    allowCollapse?: boolean;
     allowColumnResizing?: boolean;
-    allowTableResizing?: boolean;
-    allowTableAlignment?: boolean;
+    allowColumnSorting?: boolean;
+    allowControls?: boolean;
+    allowDistributeColumns?: boolean;
     allowHeaderColumn?: boolean;
     allowHeaderRow?: boolean;
     allowMergeCells?: boolean;
-    allowNumberColumn?: boolean;
-    allowColumnSorting?: boolean;
-    allowAddColumnWithCustomStep?: boolean;
-    allowCollapse?: boolean;
     allowNestedTables?: boolean;
+    allowNumberColumn?: boolean;
+    allowTableAlignment?: boolean;
+    allowTableResizing?: boolean;
     isHeaderRowRequired?: boolean;
     /**
      * @deprecated {@link https://hello.atlassian.net/browse/ENGHEALTH-6877 Internal documentation for deprecation (no external access)}
      **/
     permittedLayouts?: PermittedLayoutsDescriptor;
-    allowControls?: boolean;
     stickyHeaders?: boolean;
-    allowCellOptionsInFloatingToolbar?: boolean;
-    allowDistributeColumns?: boolean;
 }
 export type { ColumnResizingPluginState } from '@atlaskit/editor-common/types';
 export type CellColumnPositioning = Pick<Rect, 'right' | 'left'>;
@@ -84,212 +84,212 @@ export interface WidthToWidest {
     [tableLocalId: string]: boolean;
 }
 export interface TablePluginState {
+    canCollapseTable?: boolean;
     editorHasFocus?: boolean;
+    getIntl: () => IntlShape;
+    hoveredCell: CellHoverMeta;
     hoveredColumns: number[];
     hoveredRows: number[];
-    hoveredCell: CellHoverMeta;
-    pluginConfig: PluginConfig;
+    insertColumnButtonIndex?: number;
+    insertRowButtonIndex?: number;
+    isCellMenuOpenByKeyboard?: boolean;
+    isContextualMenuOpen?: boolean;
+    isDragAndDropEnabled?: boolean;
+    isFullWidthModeEnabled?: boolean;
     isHeaderColumnEnabled: boolean;
     isHeaderRowEnabled: boolean;
-    isNumberColumnEnabled?: boolean;
-    targetCellPosition?: number;
-    tableNode?: PmNode;
-    tableRef?: HTMLTableElement;
-    tablePos?: number;
-    tableWrapperTarget?: HTMLElement;
-    isContextualMenuOpen?: boolean;
     isInDanger?: boolean;
+    isKeyboardResize?: boolean;
+    isNumberColumnEnabled?: boolean;
+    isResizeHandleWidgetAdded?: boolean;
+    isTableCollapsed?: boolean;
+    isTableHovered?: boolean;
+    isTableScalingEnabled?: boolean;
     isWholeTableInDanger?: boolean;
-    insertColumnButtonIndex?: number;
-    insertRowButtonIndex?: number;
-    isFullWidthModeEnabled?: boolean;
     ordering?: TableColumnOrdering;
-    isResizeHandleWidgetAdded?: boolean;
-    resizeHandleRowIndex?: number;
+    pluginConfig: PluginConfig;
     resizeHandleColumnIndex?: number;
     resizeHandleIncludeTooltip?: boolean;
-    isKeyboardResize?: boolean;
-    isTableCollapsed?: boolean;
-    canCollapseTable?: boolean;
-    widthToWidest?: WidthToWidest;
-    getIntl: () => IntlShape;
+    resizeHandleRowIndex?: number;
+    tableNode?: PmNode;
+    tablePos?: number;
+    tableRef?: HTMLTableElement;
+    tableWrapperTarget?: HTMLElement;
+    targetCellPosition?: number;
     wasFullWidthModeEnabled?: boolean;
-    isDragAndDropEnabled?: boolean;
-    isTableHovered?: boolean;
-    isTableScalingEnabled?: boolean;
-    isCellMenuOpenByKeyboard?: boolean;
+    widthToWidest?: WidthToWidest;
 }
 export type TablePluginAction = {
-    type: 'SET_EDITOR_FOCUS';
     data: {
         editorHasFocus: boolean;
     };
+    type: 'SET_EDITOR_FOCUS';
 } | {
     type: 'TOGGLE_HEADER_ROW';
 } | {
     type: 'TOGGLE_HEADER_COLUMN';
 } | {
-    type: 'SORT_TABLE';
     data: {
         ordering: TableColumnOrdering;
     };
+    type: 'SORT_TABLE';
 } | {
-    type: 'SET_TABLE_REF';
     data: {
-        tableRef?: HTMLTableElement;
+        isHeaderColumnEnabled: boolean;
+        isHeaderRowEnabled: boolean;
         tableNode?: PmNode;
+        tableRef?: HTMLTableElement;
         tableWrapperTarget?: HTMLElement;
-        isHeaderRowEnabled: boolean;
-        isHeaderColumnEnabled: boolean;
     };
+    type: 'SET_TABLE_REF';
 } | {
-    type: 'HOVER_ROWS';
     data: {
         decorationSet: DecorationSet;
         hoveredRows: number[];
         isInDanger?: boolean;
     };
+    type: 'HOVER_ROWS';
 } | {
-    type: 'HOVER_MERGED_CELLS';
     data: {
         decorationSet: DecorationSet;
     };
+    type: 'HOVER_MERGED_CELLS';
 } | {
-    type: 'HOVER_COLUMNS';
     data: {
         decorationSet: DecorationSet;
         hoveredColumns: number[];
         isInDanger?: boolean;
     };
+    type: 'HOVER_COLUMNS';
 } | {
-    type: 'HOVER_TABLE';
     data: {
         decorationSet: DecorationSet;
-        hoveredRows: number[];
         hoveredColumns: number[];
+        hoveredRows: number[];
         isInDanger?: boolean;
     };
+    type: 'HOVER_TABLE';
 } | {
-    type: 'START_KEYBOARD_COLUMN_RESIZE';
     data: {
         decorationSet: DecorationSet;
-        resizeHandleRowIndex: number;
+        isKeyboardResize?: boolean;
         resizeHandleColumnIndex: number;
         resizeHandleIncludeTooltip: boolean;
-        isKeyboardResize?: boolean;
+        resizeHandleRowIndex: number;
     };
+    type: 'START_KEYBOARD_COLUMN_RESIZE';
 } | {
-    type: 'ADD_RESIZE_HANDLE_DECORATIONS';
     data: {
         decorationSet: DecorationSet;
-        resizeHandleRowIndex: number;
+        isKeyboardResize?: boolean;
         resizeHandleColumnIndex: number;
         resizeHandleIncludeTooltip: boolean;
-        isKeyboardResize?: boolean;
+        resizeHandleRowIndex: number;
     };
+    type: 'ADD_RESIZE_HANDLE_DECORATIONS';
 } | {
-    type: 'UPDATE_RESIZE_HANDLE_DECORATIONS';
     data: {
         decorationSet: DecorationSet;
-        resizeHandleRowIndex: number | undefined;
         resizeHandleColumnIndex: number | undefined;
         resizeHandleIncludeTooltip: boolean | undefined;
+        resizeHandleRowIndex: number | undefined;
     };
+    type: 'UPDATE_RESIZE_HANDLE_DECORATIONS';
 } | {
-    type: 'UPDATE_TABLE_WIDTH_TO_WIDEST';
     data: {
         widthToWidest: WidthToWidest | undefined;
     };
+    type: 'UPDATE_TABLE_WIDTH_TO_WIDEST';
 } | {
-    type: 'REMOVE_RESIZE_HANDLE_DECORATIONS';
     data: {
         decorationSet: DecorationSet;
     };
+    type: 'REMOVE_RESIZE_HANDLE_DECORATIONS';
 } | {
-    type: 'STOP_KEYBOARD_COLUMN_RESIZE';
     data: {
         decorationSet: DecorationSet;
     };
+    type: 'STOP_KEYBOARD_COLUMN_RESIZE';
 } | {
-    type: 'CLEAR_HOVER_SELECTION';
     data: {
         decorationSet: DecorationSet;
     };
+    type: 'CLEAR_HOVER_SELECTION';
 } | {
-    type: 'SHOW_RESIZE_HANDLE_LINE';
     data: {
         decorationSet: DecorationSet;
     };
+    type: 'SHOW_RESIZE_HANDLE_LINE';
 } | {
-    type: 'HIDE_RESIZE_HANDLE_LINE';
     data: {
         decorationSet: DecorationSet;
     };
+    type: 'HIDE_RESIZE_HANDLE_LINE';
 } | {
-    type: 'HOVER_CELL';
     data: {
         hoveredCell: CellHoverMeta;
     };
+    type: 'HOVER_CELL';
 } | {
-    type: 'TABLE_HOVERED';
     data: {
         isTableHovered: boolean;
     };
+    type: 'TABLE_HOVERED';
 } | {
-    type: 'SET_TARGET_CELL_POSITION';
     data: {
         targetCellPosition?: number;
     };
+    type: 'SET_TARGET_CELL_POSITION';
 } | {
-    type: 'SELECT_COLUMN';
     data: {
-        targetCellPosition: number;
         decorationSet: DecorationSet;
+        targetCellPosition: number;
     };
+    type: 'SELECT_COLUMN';
 } | {
-    type: 'SHOW_INSERT_ROW_BUTTON';
     data: {
         insertRowButtonIndex: number;
     };
+    type: 'SHOW_INSERT_ROW_BUTTON';
 } | {
-    type: 'SHOW_INSERT_COLUMN_BUTTON';
     data: {
         insertColumnButtonIndex: number;
     };
+    type: 'SHOW_INSERT_COLUMN_BUTTON';
 } | {
     type: 'HIDE_INSERT_COLUMN_OR_ROW_BUTTON';
 } | {
     type: 'TOGGLE_CONTEXTUAL_MENU';
 } | {
-    type: 'SET_CELL_MENU_OPEN';
     data: {
         isCellMenuOpenByKeyboard: boolean;
     };
+    type: 'SET_CELL_MENU_OPEN';
 };
 export type ColumnResizingPluginAction = {
-    type: 'SET_RESIZE_HANDLE_POSITION';
     data: {
         resizeHandlePos: number | null;
     };
+    type: 'SET_RESIZE_HANDLE_POSITION';
 } | {
     type: 'STOP_RESIZING';
 } | {
-    type: 'SET_DRAGGING';
     data: {
         dragging: {
-            startX: number;
             startWidth: number;
+            startX: number;
         } | null;
     };
+    type: 'SET_DRAGGING';
 } | {
-    type: 'SET_LAST_CLICK';
     data: {
         lastClick: {
+            time: number;
             x: number;
             y: number;
-            time: number;
         } | null;
     };
+    type: 'SET_LAST_CLICK';
 };
 export declare enum TableDecorations {
     /** Classic controls */
@@ -433,18 +433,18 @@ export declare const TableCssClassName: {
     TABLE_RESIZER_CONTAINER: "pm-table-resizer-container";
 };
 export interface ToolbarMenuConfig {
-    allowHeaderRow?: boolean;
+    allowCollapse?: boolean;
     allowHeaderColumn?: boolean;
+    allowHeaderRow?: boolean;
     allowNumberColumn?: boolean;
-    allowCollapse?: boolean;
 }
 export interface ToolbarMenuState {
-    isHeaderRowEnabled?: boolean;
+    canCollapseTable?: boolean;
+    isDragAndDropEnabled?: boolean;
     isHeaderColumnEnabled?: boolean;
+    isHeaderRowEnabled?: boolean;
     isNumberColumnEnabled?: boolean;
     isTableCollapsed?: boolean;
-    canCollapseTable?: boolean;
-    isDragAndDropEnabled?: boolean;
 }
 export interface ToolbarMenuContext {
     formatMessage: IntlShape['formatMessage'];
@@ -455,8 +455,8 @@ export declare enum ShadowEvent {
 }
 export type ReportInvalidNodeAttrs = (invalidNodeAttrs: InvalidNodeAttr) => void;
 export type InvalidNodeAttr = {
-    nodeType: string;
     attribute: string;
+    nodeType: string;
     reason: string;
     spanValue: number;
     tableLocalId: string;
@@ -468,22 +468,25 @@ export type TableDirection = 'row' | 'column';
 export type DraggableType = 'table-row' | 'table-column';
 export type DraggableBehaviour = 'move' | 'clone';
 export interface DraggableSourceData extends Record<string, unknown> {
-    type: DraggableType;
-    localId: string;
     indexes: number[];
+    localId: string;
+    type: DraggableType;
 }
 export interface DraggableTargetData extends Record<string | symbol, unknown> {
-    type: DraggableType;
     localId: string;
     targetIndex: number;
+    type: DraggableType;
 }
 export interface DraggableData {
-    sourceType: DraggableType;
-    sourceLocalId: string;
+    behaviour: DraggableBehaviour;
+    /**
+     * This represents a hollistic movement direction; a value of 1 means the source->target index would shift in a positive direction.
+     * A value of 0 indicates that the target index is inside the the source indexes.
+     */
+    direction: 1 | -1 | 0;
     sourceIndexes: number[];
-    targetType: DraggableType;
-    targetLocalId: string;
-    targetIndex: number;
+    sourceLocalId: string;
+    sourceType: DraggableType;
     targetAdjustedIndex: number;
     targetClosestEdge: Edge;
     /**
@@ -491,16 +494,13 @@ export interface DraggableData {
      * mean that the item is being inserted before the index, and 'end would be after.
      */
     targetDirection: 'start' | 'end';
-    /**
-     * This represents a hollistic movement direction; a value of 1 means the source->target index would shift in a positive direction.
-     * A value of 0 indicates that the target index is inside the the source indexes.
-     */
-    direction: 1 | -1 | 0;
-    behaviour: DraggableBehaviour;
+    targetIndex: number;
+    targetLocalId: string;
+    targetType: DraggableType;
 }
 export type HandleTypes = 'hover' | 'selected';
 export interface MessageDescriptor {
-    id: string;
-    description: string;
     defaultMessage: string;
+    description: string;
+    id: string;
 }

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

@@ -4,9 +4,9 @@
  */
 import { jsx } from '@emotion/react';
 type Props = {
-    startIndex: number;
     endIndex: number;
     includeTooltip?: boolean;
+    startIndex: number;
 };
 export declare const ColumnResizeWidget: ({ startIndex, endIndex, includeTooltip }: Props) => jsx.JSX.Element;
 export {};

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

@@ -5,14 +5,14 @@ import { type EditorView } from '@atlaskit/editor-prosemirror/view';
 import { type TablePlugin, type TablePluginOptions } from '../tablePluginType';
 export type ContentComponentProps = {
     api: ExtractInjectionAPI<TablePlugin> | undefined;
-    editorView: EditorView;
+    defaultGetEditorContainerWidth: GetEditorContainerWidth;
+    defaultGetEditorFeatureFlags: GetEditorFeatureFlags;
     dispatchAnalyticsEvent: DispatchAnalyticsEvent | undefined;
+    editorView: EditorView;
+    isTableSelectorEnabled: boolean | undefined;
     options?: TablePluginOptions;
-    popupsMountPoint?: HTMLElement;
     popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
     popupsScrollableElement?: HTMLElement;
-    isTableSelectorEnabled: boolean | undefined;
-    defaultGetEditorContainerWidth: GetEditorContainerWidth;
-    defaultGetEditorFeatureFlags: GetEditorFeatureFlags;
 };
 export declare const ContentComponent: ({ api, editorView, dispatchAnalyticsEvent, options, popupsMountPoint, popupsBoundariesElement, popupsScrollableElement, isTableSelectorEnabled, defaultGetEditorContainerWidth, defaultGetEditorFeatureFlags, }: ContentComponentProps) => React.JSX.Element;

package/dist/types/ui/DragHandle/HandleIconComponent.d.ts

@@ -1,8 +1,8 @@
 import React from 'react';
 type HandleIconProps = {
     forceDefaultHandle: boolean;
-    isHandleHovered: boolean;
     hasMergedCells: boolean;
+    isHandleHovered: boolean;
 };
 export declare const HandleIconComponent: (props: HandleIconProps) => React.JSX.Element;
 export {};

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

@@ -8,22 +8,22 @@ import type { TablePlugin } from '../../tablePluginType';
 import type { CellHoverMeta, TableDirection } from '../../types';
 export type DragHandleAppearance = 'default' | 'selected' | 'disabled' | 'danger' | 'placeholder';
 type DragHandleProps = {
-    tableLocalId: string;
-    indexes: number[];
+    appearance?: DragHandleAppearance;
+    direction?: TableDirection;
+    editorView: EditorView;
     forceDefaultHandle?: boolean;
-    previewWidth?: number;
-    previewHeight?: number;
     hoveredCell?: CellHoverMeta;
-    direction?: TableDirection;
-    appearance?: DragHandleAppearance;
+    hoveredColumns?: number[];
+    hoveredRows?: number[];
+    indexes: number[];
+    isDragMenuTarget: boolean;
     onClick?: MouseEventHandler;
-    onMouseOver?: MouseEventHandler;
     onMouseOut?: MouseEventHandler;
+    onMouseOver?: MouseEventHandler;
+    previewHeight?: number;
+    previewWidth?: number;
+    tableLocalId: string;
     toggleDragMenu?: (trigger: TriggerType, event?: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
-    editorView: EditorView;
-    isDragMenuTarget: boolean;
-    hoveredColumns?: number[];
-    hoveredRows?: number[];
 };
 export declare const DragHandle: React.FC<import("react-intl-next").WithIntlProps<DragHandleProps & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<DragHandleProps & WrappedComponentProps>;

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

@@ -2,6 +2,6 @@ import React from 'react';
 import type { TableDirection } from '../../types';
 export declare const DragPreview: ({ direction, width, height, }: {
     direction: TableDirection;
-    width: number;
     height: number;
+    width: number;
 }) => React.JSX.Element;

package/dist/types/ui/FloatingContextualButton/FixedButton.d.ts

@@ -2,13 +2,13 @@ import React from 'react';
 import type { RowStickyState } from '../../pm-plugins/sticky-headers/types';
 interface Props {
     children: React.ReactNode;
+    isContextualMenuOpen: boolean | undefined;
     mountTo: HTMLElement;
     offset: number;
     stickyHeader: RowStickyState;
+    tableWrapper: HTMLElement;
     targetCellPosition: number;
     targetCellRef: HTMLElement;
-    tableWrapper: HTMLElement;
-    isContextualMenuOpen: boolean | undefined;
 }
 interface CalcLeftPosData {
     buttonWidth: number;

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

@@ -4,17 +4,17 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { RowStickyState } from '../../pm-plugins/sticky-headers/types';
 export interface Props {
+    boundariesElement?: HTMLElement;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
     editorView: EditorView;
-    tableWrapper?: HTMLElement;
-    tableNode?: PMNode;
-    targetCellPosition: number;
+    isCellMenuOpenByKeyboard?: boolean;
     isContextualMenuOpen?: boolean;
+    isNumberColumnEnabled?: boolean;
     mountPoint?: HTMLElement;
-    boundariesElement?: HTMLElement;
     scrollableElement?: HTMLElement;
-    isNumberColumnEnabled?: boolean;
     stickyHeader?: RowStickyState;
-    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
-    isCellMenuOpenByKeyboard?: boolean;
+    tableNode?: PMNode;
+    tableWrapper?: HTMLElement;
+    targetCellPosition: number;
 }
 export default function (props: Props): jsx.JSX.Element;

package/dist/types/ui/FloatingContextualMenu/ContextualMenu.d.ts

@@ -11,26 +11,26 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { Rect } from '@atlaskit/editor-tables/table-map';
 import type { PluginInjectionAPI } from '../../types';
 interface Props {
-    editorView: EditorView;
-    isOpen: boolean;
-    selectionRect: Rect;
-    targetCellPosition?: number;
-    mountPoint?: HTMLElement;
-    allowMergeCells?: boolean;
-    allowColumnSorting?: boolean;
     allowBackgroundColor?: boolean;
-    boundariesElement?: HTMLElement;
-    offset?: Array<number>;
+    allowColumnSorting?: boolean;
+    allowMergeCells?: boolean;
     api: PluginInjectionAPI | undefined | null;
+    boundariesElement?: HTMLElement;
     editorAnalyticsAPI?: EditorAnalyticsAPI;
+    editorView: EditorView;
     getEditorContainerWidth: GetEditorContainerWidth;
     getEditorFeatureFlags?: GetEditorFeatureFlags;
     isCellMenuOpenByKeyboard?: boolean;
     isCommentEditor?: boolean;
+    isOpen: boolean;
+    mountPoint?: HTMLElement;
+    offset?: Array<number>;
+    selectionRect: Rect;
+    targetCellPosition?: number;
 }
 interface State {
-    isSubmenuOpen: boolean;
     isOpenAllowed: boolean;
+    isSubmenuOpen: boolean;
 }
 export declare class ContextualMenu extends Component<Props & WrappedComponentProps, State> {
     state: State;

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

@@ -8,19 +8,19 @@ import type { GetEditorContainerWidth, GetEditorFeatureFlags } from '@atlaskit/e
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { PluginConfig, PluginInjectionAPI } from '../../types';
 interface Props {
-    editorView: EditorView;
-    isOpen: boolean;
-    getEditorContainerWidth: GetEditorContainerWidth;
     api: PluginInjectionAPI | undefined | null;
-    getEditorFeatureFlags?: GetEditorFeatureFlags;
-    targetCellPosition?: number;
-    mountPoint?: HTMLElement;
     boundariesElement?: HTMLElement;
-    scrollableElement?: HTMLElement;
-    pluginConfig?: PluginConfig;
     editorAnalyticsAPI?: EditorAnalyticsAPI;
+    editorView: EditorView;
+    getEditorContainerWidth: GetEditorContainerWidth;
+    getEditorFeatureFlags?: GetEditorFeatureFlags;
     isCellMenuOpenByKeyboard?: boolean;
     isCommentEditor?: boolean;
+    isOpen: boolean;
+    mountPoint?: HTMLElement;
+    pluginConfig?: PluginConfig;
+    scrollableElement?: HTMLElement;
+    targetCellPosition?: number;
 }
 declare const FloatingContextualMenu: {
     ({ mountPoint, boundariesElement, scrollableElement, editorView, isOpen, pluginConfig, editorAnalyticsAPI, getEditorContainerWidth, getEditorFeatureFlags, isCellMenuOpenByKeyboard, isCommentEditor, api, }: Props): jsx.JSX.Element | null;

package/dist/types/ui/FloatingDeleteButton/DeleteButton.d.ts

@@ -2,11 +2,11 @@ import type { SyntheticEvent } from 'react';
 import React from 'react';
 import type { MessageDescriptor, WrappedComponentProps } from 'react-intl-next';
 interface ButtonProps {
-    removeLabel: MessageDescriptor;
-    style?: object;
     onClick?: (event: SyntheticEvent) => void;
     onMouseEnter?: (event: SyntheticEvent) => void;
     onMouseLeave?: (event: SyntheticEvent) => void;
+    removeLabel: MessageDescriptor;
+    style?: object;
 }
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<ButtonProps & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<ButtonProps & WrappedComponentProps>;

package/dist/types/ui/FloatingDeleteButton/getPopUpOptions.d.ts

@@ -2,9 +2,9 @@ import type { PopupProps } from '@atlaskit/editor-common/ui';
 import type { CellSelectionType } from './types';
 interface GetPopupOptions {
     left: number;
-    top: number;
     selectionType?: CellSelectionType;
     tableWrapper: HTMLElement | null;
+    top: number;
 }
 export default function getPopupOptions({ left, top, selectionType, tableWrapper, }: GetPopupOptions): Partial<PopupProps>;
 export {};