@atlaskit/editor-plugin-table 12.3.0 → 12.3.2

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

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

@@ -6,21 +6,21 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { TablePlugin } from '../../../tablePluginType';
 import type { CellHoverMeta } from '../../../types';
 type DragControlsProps = {
+    api?: ExtractInjectionAPI<TablePlugin>;
     editorView: EditorView;
-    tableRef: HTMLTableElement;
-    tableNode?: PmNode;
-    tableWidth: number;
-    tableActive?: boolean;
     hoveredCell?: CellHoverMeta;
+    hoverRows: (rows: number[], danger?: boolean) => void;
     isInDanger?: boolean;
-    isTableHovered?: boolean;
     isResizing?: boolean;
-    hoverRows: (rows: number[], danger?: boolean) => void;
+    isTableHovered?: boolean;
+    selection?: Selection;
     selectRow: (row: number, expand: boolean) => void;
     selectRows: (rowIndexes: number[]) => void;
+    tableActive?: boolean;
+    tableNode?: PmNode;
+    tableRef: HTMLTableElement;
+    tableWidth: number;
     updateCellHoverLocation: (rowIndex: number) => void;
-    api?: ExtractInjectionAPI<TablePlugin>;
-    selection?: Selection;
 };
 export declare const DragControls: ({ tableRef, tableNode, tableWidth, hoveredCell, tableActive, editorView, isInDanger, isResizing, isTableHovered, hoverRows, selectRow, selectRows, updateCellHoverLocation, api, selection, }: DragControlsProps) => React.JSX.Element | null;
 export declare const DragControlsWithSelection: ({ editorView, tableRef, tableNode, tableWidth, tableActive, hoveredCell, isInDanger, isTableHovered, isResizing, hoverRows, selectRow, selectRows, updateCellHoverLocation, api, }: Exclude<DragControlsProps, "selection">) => React.JSX.Element;

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

@@ -9,26 +9,26 @@ import type { TablePlugin } from '../../tablePluginType';
 import type { CellHoverMeta } from '../../types';
 interface TableFloatingControlsProps {
     editorView: EditorView;
-    selection?: Selection;
-    tableRef?: HTMLTableElement;
-    tableNode?: PmNode;
-    tableActive?: boolean;
-    isInDanger?: boolean;
-    isTableHovered?: boolean;
-    isResizing?: boolean;
-    isHeaderRowEnabled?: boolean;
-    isHeaderColumnEnabled?: boolean;
-    isNumberColumnEnabled?: boolean;
-    isDragAndDropEnabled?: boolean;
     hasHeaderRow?: boolean;
     headerRowHeight?: number;
-    hoveredRows?: number[];
     hoveredCell?: CellHoverMeta;
+    hoveredRows?: number[];
+    insertRowButtonIndex?: number;
+    isChromelessEditor?: boolean;
+    isDragAndDropEnabled?: boolean;
+    isHeaderColumnEnabled?: boolean;
+    isHeaderRowEnabled?: boolean;
+    isInDanger?: boolean;
+    isNumberColumnEnabled?: boolean;
+    isResizing?: boolean;
+    isTableHovered?: boolean;
     ordering?: TableColumnOrdering;
+    selection?: Selection;
     stickyHeader?: RowStickyState;
-    insertRowButtonIndex?: number;
+    tableActive?: boolean;
+    tableNode?: PmNode;
+    tableRef?: HTMLTableElement;
     tableWrapperWidth?: number;
-    isChromelessEditor?: boolean;
 }
 export declare const TableFloatingControls: ({ editorView, tableRef, tableNode, isInDanger, isResizing, isNumberColumnEnabled, isHeaderRowEnabled, isHeaderColumnEnabled, tableActive, hasHeaderRow, hoveredRows, stickyHeader, isDragAndDropEnabled, hoveredCell, isTableHovered, tableWrapperWidth, api, isChromelessEditor, }: TableFloatingControlsProps & {
     api?: ExtractInjectionAPI<TablePlugin>;

package/dist/types/ui/global-styles.d.ts

@@ -6,7 +6,7 @@ import { jsx } from '@emotion/react';
 import type { FeatureFlags } from '@atlaskit/editor-common/types';
 import type { PluginInjectionAPI } from '../types';
 export declare const GlobalStylesWrapper: ({ featureFlags, isDragAndDropEnabledOption, api, }: {
+    api?: PluginInjectionAPI;
     featureFlags: FeatureFlags | undefined;
     isDragAndDropEnabledOption?: boolean;
-    api?: PluginInjectionAPI;
 }) => jsx.JSX.Element;

package/dist/types-ts4.5/nodeviews/ExternalDropTargets.d.ts

@@ -3,7 +3,7 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 export declare const ExternalDropTargets: ({ editorView, node, getScrollOffset, getTableWrapperWidth, }: {
     editorView: EditorView;
-    node?: PMNode;
     getScrollOffset: () => number;
     getTableWrapperWidth: () => number;
+    node?: PMNode;
 }) => React.JSX.Element | null;

package/dist/types-ts4.5/nodeviews/TableComponent.d.ts

@@ -10,36 +10,36 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { CellHoverMeta, PluginInjectionAPI } from '../types';
 import type { TableOptions } from './types';
 interface ComponentProps {
-    view: EditorView;
-    getNode: () => PmNode;
     allowColumnResizing?: boolean;
-    eventDispatcher: EventDispatcher;
-    getPos: () => number | undefined;
-    options?: TableOptions;
-    contentDOM: (node: HTMLElement | null) => void;
-    containerWidth: EditorContainerWidth;
     allowControls?: boolean;
-    allowTableResizing?: boolean;
     allowTableAlignment?: boolean;
-    isHeaderRowEnabled: boolean;
-    isHeaderColumnEnabled: boolean;
-    isMediaFullscreen?: boolean;
-    isDragAndDropEnabled?: boolean;
-    isTableScalingEnabled?: boolean;
-    tableActive: boolean;
-    ordering?: TableColumnOrdering;
-    isResizing?: boolean;
-    getEditorFeatureFlags: GetEditorFeatureFlags;
+    allowTableResizing?: boolean;
+    containerWidth: EditorContainerWidth;
+    contentDOM: (node: HTMLElement | null) => void;
     dispatchAnalyticsEvent: DispatchAnalyticsEvent;
-    pluginInjectionApi?: PluginInjectionAPI;
+    eventDispatcher: EventDispatcher;
+    getEditorFeatureFlags: GetEditorFeatureFlags;
+    getNode: () => PmNode;
+    getPos: () => number | undefined;
+    hoveredCell?: CellHoverMeta;
+    hoveredRows?: number[];
     intl: IntlShape;
+    isDragAndDropEnabled?: boolean;
+    isHeaderColumnEnabled: boolean;
+    isHeaderRowEnabled: boolean;
     isInDanger?: boolean;
-    hoveredRows?: number[];
-    hoveredCell?: CellHoverMeta;
+    isMediaFullscreen?: boolean;
+    isResizing?: boolean;
     isTableHovered?: boolean;
+    isTableScalingEnabled?: boolean;
     isWholeTableInDanger?: boolean;
-    selection?: Selection;
     limitedMode?: boolean;
+    options?: TableOptions;
+    ordering?: TableColumnOrdering;
+    pluginInjectionApi?: PluginInjectionAPI;
+    selection?: Selection;
+    tableActive: boolean;
+    view: EditorView;
 }
 declare const _default: React.FC<import("react-intl-next").WithIntlProps<ComponentProps>> & {
     WrappedComponent: React.ComponentType<ComponentProps>;

package/dist/types-ts4.5/nodeviews/TableComponentWithSharedState.d.ts

@@ -8,19 +8,19 @@ import type { PluginInjectionAPI } from '../types';
 import type { TableOptions } from './types';
 type ForwardRef = (node: HTMLElement | null) => any;
 type TableComponentWithSharedStateProps = {
-    view: EditorView;
-    options?: TableOptions;
-    getNode: () => PmNode;
-    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
-    getEditorFeatureFlags: GetEditorFeatureFlags;
-    api?: PluginInjectionAPI;
-    eventDispatcher: EventDispatcher;
-    forwardRef: ForwardRef;
-    getPos: getPosHandlerNode;
     allowColumnResizing?: boolean;
     allowControls?: boolean;
     allowTableAlignment?: boolean;
     allowTableResizing?: boolean;
+    api?: PluginInjectionAPI;
+    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
+    eventDispatcher: EventDispatcher;
+    forwardRef: ForwardRef;
+    getEditorFeatureFlags: GetEditorFeatureFlags;
+    getNode: () => PmNode;
+    getPos: getPosHandlerNode;
+    options?: TableOptions;
+    view: EditorView;
 };
 /**
  * Use useSharedPluginState to control re-renders from plugin dependencies