@atlaskit/editor-plugin-table 12.2.7 → 12.3.1

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 {};

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

@@ -6,24 +6,24 @@ import type { RowStickyState } from '../../pm-plugins/sticky-headers/types';
 import type { PluginInjectionAPI } from '../../types';
 import type { CellSelectionType } from './types';
 export interface Props {
-    editorView: EditorView;
-    selection: Selection;
     api: PluginInjectionAPI | undefined | null;
-    tableRef?: HTMLTableElement;
-    mountPoint?: HTMLElement;
     boundariesElement?: HTMLElement;
+    editorAnalyticsAPI?: EditorAnalyticsAPI;
+    editorView: EditorView;
+    isNumberColumnEnabled?: boolean;
+    mountPoint?: HTMLElement;
     scrollableElement?: HTMLElement;
+    selection: Selection;
     stickyHeaders?: RowStickyState;
-    isNumberColumnEnabled?: boolean;
-    editorAnalyticsAPI?: EditorAnalyticsAPI;
+    tableRef?: HTMLTableElement;
 }
 interface State {
-    selectionType?: CellSelectionType;
-    left: number;
-    top: number;
     indexes: number[];
+    left: number;
     position?: string;
     scrollLeft: number;
+    selectionType?: CellSelectionType;
+    top: number;
 }
 declare class FloatingDeleteButton extends Component<Props, State> {
     static displayName: string;

package/dist/types/ui/FloatingDragMenu/DragMenu.d.ts

@@ -12,27 +12,27 @@ import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { PluginConfig, PluginInjectionAPI, TableDirection } from '../../types';
 type DragMenuProps = {
-    direction?: TableDirection;
-    index?: number;
-    target?: Element;
-    tableNode?: PmNode;
-    editorView: EditorView;
-    isOpen?: boolean;
-    targetCellPosition?: number;
-    pluginConfig?: PluginConfig;
-    getEditorContainerWidth: GetEditorContainerWidth;
     api: PluginInjectionAPI | undefined | null;
+    ariaNotifyPlugin?: (message: string, ariaLiveElementAttributes?: AriaLiveElementAttributes) => void;
+    boundariesElement?: HTMLElement;
+    direction?: TableDirection;
     editorAnalyticsAPI?: EditorAnalyticsAPI;
-    fitWidth?: number;
+    editorView: EditorView;
     fitHeight?: number;
+    fitWidth?: number;
+    getEditorContainerWidth: GetEditorContainerWidth;
+    index?: number;
+    isCommentEditor?: boolean;
+    isOpen?: boolean;
+    isTableFixedColumnWidthsOptionEnabled?: boolean;
+    isTableScalingEnabled?: boolean;
     mountPoint?: HTMLElement;
-    boundariesElement?: HTMLElement;
+    pluginConfig?: PluginConfig;
     scrollableElement?: HTMLElement;
-    isTableScalingEnabled?: boolean;
     shouldUseIncreasedScalingPercent?: boolean;
-    isTableFixedColumnWidthsOptionEnabled?: boolean;
-    ariaNotifyPlugin?: (message: string, ariaLiveElementAttributes?: AriaLiveElementAttributes) => void;
-    isCommentEditor?: boolean;
+    tableNode?: PmNode;
+    target?: Element;
+    targetCellPosition?: number;
 };
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<DragMenuProps & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<DragMenuProps & WrappedComponentProps>;

package/dist/types/ui/FloatingDragMenu/DropdownMenu.d.ts

@@ -1,36 +1,36 @@
 import React from 'react';
 import type { MenuItem } from '@atlaskit/editor-common/ui-menu';
 type DropdownMenuProps = {
-    items: Array<{
-        items: MenuItem[];
-    }>;
+    boundariesElement?: HTMLElement;
+    direction?: string;
     /**
      * use to toggle top level menu keyboard navigation and action keys
      * e.g. should be false if submenu is rendered as a child to avoid multiple keydown handlers
      */
     disableKeyboardHandling: boolean;
-    section: {
-        hasSeparator?: boolean;
-        title?: string;
-    };
+    fitHeight?: number;
+    fitWidth?: number;
+    handleClose: (focusTarget: 'editor' | 'handle') => void;
+    items: Array<{
+        items: MenuItem[];
+    }>;
+    mountPoint?: HTMLElement;
+    offset?: Array<number>;
     onItemActivated?: (attrs: {
         item: MenuItem;
         shouldCloseMenu?: boolean;
     }) => void;
-    handleClose: (focusTarget: 'editor' | 'handle') => void;
     onMouseEnter: (attrs: {
         item: MenuItem;
     }) => void;
     onMouseLeave: (attrs: {
         item: MenuItem;
     }) => void;
-    fitWidth?: number;
-    fitHeight?: number;
-    direction?: string;
-    offset?: Array<number>;
-    mountPoint?: HTMLElement;
-    boundariesElement?: HTMLElement;
     scrollableElement?: HTMLElement;
+    section: {
+        hasSeparator?: boolean;
+        title?: string;
+    };
 };
 export declare const DropdownMenu: ({ items, section, disableKeyboardHandling, onItemActivated, handleClose, onMouseEnter, onMouseLeave, fitWidth, fitHeight, direction, mountPoint, boundariesElement, scrollableElement, }: DropdownMenuProps) => React.JSX.Element;
 export {};

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

@@ -7,25 +7,25 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { RowStickyState } from '../../pm-plugins/sticky-headers/types';
 import type { PluginConfig, PluginInjectionAPI, TableDirection } from '../../types';
 interface Props {
-    editorView: EditorView;
-    isOpen: boolean;
-    tableRef?: HTMLTableElement;
-    tableNode?: PmNode;
-    mountPoint?: HTMLElement;
+    api: PluginInjectionAPI | undefined | null;
+    ariaNotifyPlugin?: (message: string, ariaLiveElementAttributes?: AriaLiveElementAttributes) => void;
     boundariesElement?: HTMLElement;
-    scrollableElement?: HTMLElement;
     direction?: TableDirection;
-    index?: number;
-    targetCellPosition?: number;
-    getEditorContainerWidth: GetEditorContainerWidth;
-    api: PluginInjectionAPI | undefined | null;
     editorAnalyticsAPI?: EditorAnalyticsAPI;
-    stickyHeaders?: RowStickyState;
-    pluginConfig?: PluginConfig;
-    isTableScalingEnabled?: boolean;
+    editorView: EditorView;
+    getEditorContainerWidth: GetEditorContainerWidth;
     getEditorFeatureFlags?: GetEditorFeatureFlags;
-    ariaNotifyPlugin?: (message: string, ariaLiveElementAttributes?: AriaLiveElementAttributes) => void;
+    index?: number;
     isCommentEditor?: boolean;
+    isOpen: boolean;
+    isTableScalingEnabled?: boolean;
+    mountPoint?: HTMLElement;
+    pluginConfig?: PluginConfig;
+    scrollableElement?: HTMLElement;
+    stickyHeaders?: RowStickyState;
+    tableNode?: PmNode;
+    tableRef?: HTMLTableElement;
+    targetCellPosition?: number;
 }
 declare const FloatingDragMenu: {
     ({ mountPoint, boundariesElement, scrollableElement, editorView, isOpen, tableNode, direction, index, targetCellPosition, getEditorContainerWidth, editorAnalyticsAPI, stickyHeaders, pluginConfig, isTableScalingEnabled, getEditorFeatureFlags, ariaNotifyPlugin, api, isCommentEditor, }: Props): React.JSX.Element | null;

package/dist/types/ui/FloatingInsertButton/InsertButton.d.ts

@@ -3,11 +3,11 @@ import React from 'react';
 import type { WrappedComponentProps } from 'react-intl-next';
 import type { TableDirection } from '../../types';
 interface ButtonProps {
-    type: TableDirection;
-    tableRef: HTMLElement;
-    onMouseDown: (event: SyntheticEvent<HTMLButtonElement>) => void;
     hasStickyHeaders: boolean;
     isChromelessEditor?: boolean;
+    onMouseDown: (event: SyntheticEvent<HTMLButtonElement>) => void;
+    tableRef: HTMLElement;
+    type: TableDirection;
 }
 export declare const DragAndDropInsertButton: React.FC<import("react-intl-next").WithIntlProps<ButtonProps & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<ButtonProps & WrappedComponentProps>;

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

@@ -6,26 +6,26 @@ import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { PluginInjectionAPI } from '../../types';
 export interface Props {
+    api: PluginInjectionAPI | undefined | null;
+    boundariesElement?: HTMLElement;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    editorAnalyticsAPI?: EditorAnalyticsAPI;
     editorView: EditorView;
     getEditorContainerWidth: GetEditorContainerWidth;
-    tableRef?: HTMLElement;
-    tableNode?: PmNode;
+    getEditorFeatureFlags?: GetEditorFeatureFlags;
+    hasStickyHeaders?: boolean;
     insertColumnButtonIndex?: number;
     insertRowButtonIndex?: number;
+    isChromelessEditor?: boolean;
+    isCommentEditor?: boolean;
+    isDragAndDropEnabled?: boolean;
     isHeaderColumnEnabled?: boolean;
     isHeaderRowEnabled?: boolean;
-    isDragAndDropEnabled?: boolean;
     isTableScalingEnabled?: boolean;
     mountPoint?: HTMLElement;
-    boundariesElement?: HTMLElement;
     scrollableElement?: HTMLElement;
-    hasStickyHeaders?: boolean;
-    api: PluginInjectionAPI | undefined | null;
-    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
-    editorAnalyticsAPI?: EditorAnalyticsAPI;
-    getEditorFeatureFlags?: GetEditorFeatureFlags;
-    isChromelessEditor?: boolean;
-    isCommentEditor?: boolean;
+    tableNode?: PmNode;
+    tableRef?: HTMLElement;
 }
 export declare class FloatingInsertButton extends React.Component<Props & WrappedComponentProps, any> {
     static displayName: string;

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

@@ -1,13 +1,13 @@
 import React from 'react';
 interface Props {
-    target: HTMLElement;
-    content: React.ReactNode;
     alignX?: 'left' | 'center' | 'right';
     alignY?: 'top' | 'bottom' | 'start';
-    zIndex?: number;
+    content: React.ReactNode;
     forcePlacement?: boolean;
-    stick?: boolean;
     offset?: [number, number];
+    stick?: boolean;
+    target: HTMLElement;
+    zIndex?: number;
 }
 export declare const FloatingToolbarLabel: React.MemoExoticComponent<(props: Props) => React.JSX.Element>;
 export {};

package/dist/types/ui/TableFloatingColumnControls/ColumnControls/index.d.ts

@@ -4,21 +4,21 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { TablePlugin } from '../../../tablePluginType';
 import type { CellHoverMeta } from '../../../types';
 interface ColumnControlsProps {
+    colWidths?: (number | undefined)[];
     editorView: EditorView;
-    tableActive?: boolean;
-    isInDanger?: boolean;
-    tableRef: HTMLTableElement;
+    getScrollOffset?: () => number;
+    hasHeaderColumn?: boolean;
     hoveredCell?: CellHoverMeta;
-    stickyTop?: number;
+    isDragging?: boolean;
+    isInDanger?: boolean;
+    isNumberColumnEnabled?: boolean;
+    isTableHovered?: boolean;
     localId?: string;
     rowHeights?: number[];
-    colWidths?: (number | undefined)[];
-    hasHeaderColumn?: boolean;
-    isTableHovered?: boolean;
+    stickyTop?: number;
+    tableActive?: boolean;
     tableContainerWidth?: number;
-    isNumberColumnEnabled?: boolean;
-    isDragging?: boolean;
-    getScrollOffset?: () => number;
+    tableRef: HTMLTableElement;
 }
 export declare const ColumnControls: ({ editorView, tableActive, tableRef, hoveredCell, stickyTop, localId, isInDanger, rowHeights, colWidths, isTableHovered, tableContainerWidth, isNumberColumnEnabled, isDragging, getScrollOffset, api, }: ColumnControlsProps & {
     api?: ExtractInjectionAPI<TablePlugin>;

package/dist/types/ui/TableFloatingColumnControls/ColumnDropTargets/ColumnDropTarget.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
 interface Props {
+    height?: number;
     index: number;
     localId?: string;
-    width?: number;
-    height?: number;
     marginTop?: number;
+    width?: number;
 }
 export declare const ColumnDropTarget: ({ index, localId, width, height, marginTop }: Props) => React.JSX.Element;
 export {};

package/dist/types/ui/TableFloatingColumnControls/ColumnDropTargets/index.d.ts

@@ -1,11 +1,11 @@
 import React from 'react';
 interface Props {
-    tableRef: HTMLTableElement;
-    tableHeight?: number;
-    localId?: string;
     colWidths?: (number | undefined)[];
-    isHeaderSticky?: boolean;
     getScrollOffset?: () => number;
+    isHeaderSticky?: boolean;
+    localId?: string;
+    tableHeight?: number;
+    tableRef: HTMLTableElement;
 }
 export declare const ColumnDropTargets: ({ tableRef, tableHeight, localId, colWidths, isHeaderSticky, getScrollOffset, }: Props) => React.JSX.Element | null;
 export {};

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

@@ -7,27 +7,27 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { RowStickyState } from '../../pm-plugins/sticky-headers/types';
 import type { CellHoverMeta, PluginInjectionAPI } from '../../types';
 interface Props {
+    api?: PluginInjectionAPI;
     editorView: EditorView;
     getEditorFeatureFlags: GetEditorFeatureFlags;
-    selection?: Selection;
-    tableRef?: HTMLTableElement;
     getNode: () => PmNode;
-    tableActive?: boolean;
-    isInDanger?: boolean;
+    getScrollOffset?: () => number;
     hasHeaderRow?: boolean;
     headerRowHeight?: number;
-    hoveredRows?: number[];
     hoveredCell?: CellHoverMeta;
+    hoveredRows?: number[];
+    isChromelessEditor?: boolean;
+    isInDanger?: boolean;
+    isNumberColumnEnabled?: boolean;
     isResizing?: boolean;
+    isTableHovered?: boolean;
     ordering?: TableColumnOrdering;
+    selection?: Selection;
     stickyHeader?: RowStickyState;
-    isTableHovered?: boolean;
+    tableActive?: boolean;
     tableContainerWidth?: number;
-    isNumberColumnEnabled?: boolean;
-    getScrollOffset?: () => number;
+    tableRef?: HTMLTableElement;
     tableWrapperHeight?: number;
-    api?: PluginInjectionAPI;
-    isChromelessEditor?: boolean;
 }
 declare const TableFloatingColumnControls: ({ editorView, tableRef, getNode, tableActive, hasHeaderRow, hoveredCell, isResizing, stickyHeader, selection, isInDanger, isTableHovered, tableContainerWidth, isNumberColumnEnabled, getScrollOffset, tableWrapperHeight, api, isChromelessEditor, }: Props) => React.JSX.Element | null;
 export default TableFloatingColumnControls;

package/dist/types/ui/TableFloatingControls/CornerControls/types.d.ts

@@ -1,11 +1,11 @@
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 export type CornerControlProps = {
     editorView: EditorView;
-    tableRef?: HTMLTableElement;
-    isInDanger?: boolean;
-    isResizing?: boolean;
     hoveredRows?: number[];
     isHeaderColumnEnabled?: boolean;
     isHeaderRowEnabled?: boolean;
+    isInDanger?: boolean;
+    isResizing?: boolean;
     stickyTop?: number;
+    tableRef?: HTMLTableElement;
 };

package/dist/types/ui/TableFloatingControls/FloatingControlsWithSelection.d.ts

@@ -3,18 +3,18 @@ import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { TablePlugin } from '../../tablePluginType';
 type FloatingControlsWithSelectionProps = {
+    api?: ExtractInjectionAPI<TablePlugin>;
     editorView: EditorView;
-    tableRef: HTMLTableElement;
-    isInDanger?: boolean;
-    isResizing?: boolean;
-    isHeaderRowEnabled?: boolean;
-    isHeaderColumnEnabled?: boolean;
     hoveredRows?: number[];
-    stickyTop?: number;
     hoverRows: (rows: number[]) => void;
+    isHeaderColumnEnabled?: boolean;
+    isHeaderRowEnabled?: boolean;
+    isInDanger?: boolean;
+    isResizing?: boolean;
     selectRow: (row: number, expand: boolean) => void;
+    stickyTop?: number;
     tableActive: boolean;
-    api?: ExtractInjectionAPI<TablePlugin>;
+    tableRef: HTMLTableElement;
 };
 export declare const FloatingControlsWithSelection: ({ editorView, tableRef, isInDanger, isResizing, isHeaderRowEnabled, isHeaderColumnEnabled, hoveredRows, stickyTop, hoverRows, selectRow, tableActive, api, }: FloatingControlsWithSelectionProps) => React.JSX.Element;
 export {};

package/dist/types/ui/TableFloatingControls/NumberColumn/index.d.ts

@@ -2,17 +2,17 @@ import React, { Component } from 'react';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 interface Props {
     editorView: EditorView;
-    tableRef: HTMLTableElement;
-    tableActive?: boolean;
-    hoverRows: (rows: number[], danger?: boolean) => void;
-    hoveredRows?: number[];
-    selectRow: (row: number, expand: boolean) => void;
-    updateCellHoverLocation: (rowIndex: number) => void;
     hasHeaderRow?: boolean;
+    hoveredRows?: number[];
+    hoverRows: (rows: number[], danger?: boolean) => void;
+    isDragAndDropEnabled?: boolean;
     isInDanger?: boolean;
     isResizing?: boolean;
+    selectRow: (row: number, expand: boolean) => void;
     stickyTop?: number;
-    isDragAndDropEnabled?: boolean;
+    tableActive?: boolean;
+    tableRef: HTMLTableElement;
+    updateCellHoverLocation: (rowIndex: number) => void;
 }
 export default class NumberColumn extends Component<Props, any> {
     render(): React.JSX.Element;

package/dist/types/ui/TableFloatingControls/RowControls/ClassicControls.d.ts

@@ -4,15 +4,15 @@ import type { Selection } from '@atlaskit/editor-prosemirror/state';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 export interface Props {
     editorView: EditorView;
-    tableRef: HTMLTableElement;
-    selectRow: (row: number, expand: boolean) => void;
-    hoverRows: (rows: number[], danger?: boolean) => void;
     hoveredRows?: number[];
+    hoverRows: (rows: number[], danger?: boolean) => void;
+    insertRowButtonIndex?: number;
     isInDanger?: boolean;
     isResizing?: boolean;
-    insertRowButtonIndex?: number;
-    stickyTop?: number;
     selection?: Selection;
+    selectRow: (row: number, expand: boolean) => void;
+    stickyTop?: number;
+    tableRef: HTMLTableElement;
 }
 export declare const RowControls: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps>> & {
     WrappedComponent: React.ComponentType<Props & WrappedComponentProps>;