@atlaskit/editor-plugin-table 12.2.7 → 12.3.1

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

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

@@ -5,48 +5,48 @@ import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { PluginInjectionAPI } from '../types';
 type ResizableTableContainerProps = {
-    containerWidth: number;
-    lineLength: number;
-    node: PMNode;
     className: string;
+    containerWidth: number;
     editorView: EditorView;
     getPos: () => number | undefined;
-    tableRef: HTMLTableElement;
+    isChromelessEditor?: boolean;
+    isCommentEditor?: boolean;
     isResizing?: boolean;
-    isWindowResized?: boolean;
-    pluginInjectionApi?: PluginInjectionAPI;
-    tableWrapperHeight?: number;
-    isWholeTableInDanger?: boolean;
+    isTableAlignmentEnabled?: boolean;
     isTableScalingEnabled?: boolean;
     isTableWithFixedColumnWidthsOptionEnabled?: boolean;
-    isTableAlignmentEnabled?: boolean;
+    isWholeTableInDanger?: boolean;
+    isWindowResized?: boolean;
+    lineLength: number;
+    node: PMNode;
+    pluginInjectionApi?: PluginInjectionAPI;
     shouldUseIncreasedScalingPercent?: boolean;
-    isCommentEditor?: boolean;
-    isChromelessEditor?: boolean;
+    tableRef: HTMLTableElement;
+    tableWrapperHeight?: number;
 };
 export declare const ResizableTableContainer: React.FC<ResizableTableContainerProps & {
     children?: React.ReactNode | undefined;
 }>;
 type TableContainerProps = {
-    node: PMNode;
     className: string;
     containerWidth: EditorContainerWidth;
     editorView: EditorView;
     getPos: () => number | undefined;
-    tableRef: HTMLTableElement;
+    isChromelessEditor?: boolean;
+    isCommentEditor?: boolean;
     isNested: boolean;
     isResizing?: boolean;
-    isWindowResized?: boolean;
-    pluginInjectionApi?: PluginInjectionAPI;
-    tableWrapperHeight?: number;
-    isWholeTableInDanger?: boolean;
+    isTableAlignmentEnabled?: boolean;
     isTableResizingEnabled: boolean | undefined;
     isTableScalingEnabled?: boolean;
     isTableWithFixedColumnWidthsOptionEnabled?: boolean;
-    isTableAlignmentEnabled?: boolean;
+    isWholeTableInDanger?: boolean;
+    isWindowResized?: boolean;
+    node: PMNode;
+    pluginInjectionApi?: PluginInjectionAPI;
     shouldUseIncreasedScalingPercent?: boolean;
-    isCommentEditor?: boolean;
-    isChromelessEditor?: boolean;
+    tableRef: HTMLTableElement;
+    tableWrapperHeight?: number;
 };
 export declare const TableContainer: ({ children, node, className, containerWidth: { width: editorWidth, lineLength }, editorView, getPos, tableRef, isNested, tableWrapperHeight, isResizing, isWindowResized, pluginInjectionApi, isWholeTableInDanger, isTableResizingEnabled, isTableScalingEnabled, isTableWithFixedColumnWidthsOptionEnabled, isTableAlignmentEnabled, shouldUseIncreasedScalingPercent, isCommentEditor, isChromelessEditor, }: PropsWithChildren<TableContainerProps>) => React.JSX.Element;
 export {};

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

@@ -7,29 +7,29 @@ import type { Transaction } from '@atlaskit/editor-prosemirror/state';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { PluginInjectionAPI } from '../types';
 interface TableResizerProps {
-    width: number;
-    maxWidth: number | string;
+    attachAnalyticsEvent: (payload: TableEventPayload) => ((tr: Transaction) => boolean) | undefined;
     containerWidth: number;
-    lineLength: number;
-    updateWidth: (width: number) => void;
+    disabled?: boolean;
+    displayGapCursor: (toggle: boolean) => boolean;
+    displayGuideline: (guideline: GuidelineConfig[]) => boolean;
     editorView: EditorView;
     getPos: () => number | undefined;
-    node: PMNode;
-    tableRef: HTMLTableElement;
-    displayGuideline: (guideline: GuidelineConfig[]) => boolean;
-    attachAnalyticsEvent: (payload: TableEventPayload) => ((tr: Transaction) => boolean) | undefined;
-    displayGapCursor: (toggle: boolean) => boolean;
-    pluginInjectionApi?: PluginInjectionAPI;
+    isCommentEditor?: boolean;
+    isFullWidthModeEnabled?: boolean;
+    isTableAlignmentEnabled?: boolean;
     isTableScalingEnabled?: boolean;
     isTableWithFixedColumnWidthsOptionEnabled?: boolean;
-    isTableAlignmentEnabled?: boolean;
     isWholeTableInDanger?: boolean;
-    isFullWidthModeEnabled?: boolean;
-    shouldUseIncreasedScalingPercent?: boolean;
-    isCommentEditor?: boolean;
-    onResizeStop?: () => void;
+    lineLength: number;
+    maxWidth: number | string;
+    node: PMNode;
     onResizeStart?: () => void;
-    disabled?: boolean;
+    onResizeStop?: () => void;
+    pluginInjectionApi?: PluginInjectionAPI;
+    shouldUseIncreasedScalingPercent?: boolean;
+    tableRef: HTMLTableElement;
+    updateWidth: (width: number) => void;
+    width: number;
 }
 export declare const TableResizer: ({ children, width, maxWidth, containerWidth, lineLength, updateWidth, onResizeStop, onResizeStart, editorView, getPos, node, tableRef, displayGuideline, attachAnalyticsEvent, displayGapCursor, isTableScalingEnabled, isTableWithFixedColumnWidthsOptionEnabled, isTableAlignmentEnabled, isWholeTableInDanger, shouldUseIncreasedScalingPercent, pluginInjectionApi, isFullWidthModeEnabled, isCommentEditor, disabled, }: PropsWithChildren<TableResizerProps>) => React.JSX.Element;
 export {};

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

@@ -34,8 +34,8 @@ export default class TableRow extends TableNodeView<HTMLTableRowElement> impleme
     update(node: PMNode, ..._args: any[]): boolean;
     destroy(): void;
     ignoreMutation(mutationRecord: MutationRecord | {
-        type: 'selection';
         target: Node;
+        type: 'selection';
     }): boolean;
     /**
      * Methods

package/dist/types-ts4.5/nodeviews/table-node-views.d.ts

@@ -8,14 +8,14 @@ import type { PluginInjectionAPI } from '../types';
 import TableCell from './TableCell';
 import TableRow from './TableRow';
 type TableViewOptions = {
-    portalProviderAPI: PortalProviderAPI;
+    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
     eventDispatcher: EventDispatcher;
     getEditorContainerWidth: GetEditorContainerWidth;
     getEditorFeatureFlags: GetEditorFeatureFlags;
-    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
-    pluginInjectionApi?: PluginInjectionAPI;
-    isCommentEditor?: boolean;
     isChromelessEditor?: boolean;
+    isCommentEditor?: boolean;
+    pluginInjectionApi?: PluginInjectionAPI;
+    portalProviderAPI: PortalProviderAPI;
 };
 export declare const tableView: (options: TableViewOptions) => (node: PMNode, view: EditorView, getPos: () => number | undefined) => import("prosemirror-view").NodeView;
 type TableCellViewOptions = {

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

@@ -19,8 +19,8 @@ export default class TableView extends ReactNodeView<Props> {
     getEditorFeatureFlags: GetEditorFeatureFlags;
     constructor(props: Props);
     getContentDOM(): {
-        dom: HTMLElement;
         contentDOM?: HTMLElement;
+        dom: HTMLElement;
     };
     /**
      * Handles moving the table from ProseMirror's DOM structure into a React-rendered table node.
@@ -36,8 +36,8 @@ export default class TableView extends ReactNodeView<Props> {
     private hasHoveredRows;
     viewShouldUpdate(nextNode: PmNode): boolean;
     ignoreMutation(mutation: MutationRecord | {
-        type: 'selection';
         target: Node;
+        type: 'selection';
     }): boolean;
     destroy(): void;
 }

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

@@ -2,14 +2,14 @@ import type { GetEditorContainerWidth } from '@atlaskit/editor-common/types';
 import type { DOMOutputSpec, NodeSpec, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 type Config = {
     allowColumnResizing: boolean;
-    tableResizingEnabled: boolean;
     getEditorContainerWidth: GetEditorContainerWidth;
+    isChromelessEditor?: boolean;
+    isCommentEditor?: boolean;
+    isNested?: boolean;
     isNestingSupported?: boolean;
     isTableScalingEnabled?: boolean;
     shouldUseIncreasedScalingPercent?: boolean;
-    isCommentEditor?: boolean;
-    isChromelessEditor?: boolean;
-    isNested?: boolean;
+    tableResizingEnabled: boolean;
 };
 export declare const tableNodeSpecWithFixedToDOM: (config: Config) => NodeSpec & {
     toDOM: (node: PMNode) => DOMOutputSpec;

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

@@ -6,28 +6,28 @@ import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { PluginInjectionAPI } from '../types';
 export type TableOptions = {
-    isFullWidthModeEnabled?: boolean;
-    wasFullWidthModeEnabled?: boolean;
+    isChromelessEditor?: boolean;
+    isCommentEditor?: boolean;
     isDragAndDropEnabled?: boolean;
+    isFullWidthModeEnabled?: boolean;
     isTableScalingEnabled?: boolean;
-    isCommentEditor?: boolean;
-    isChromelessEditor?: boolean;
     shouldUseIncreasedScalingPercent?: boolean;
+    wasFullWidthModeEnabled?: boolean;
 };
 export interface Props {
-    node: PmNode;
-    view: EditorView;
     allowColumnResizing?: boolean;
-    allowTableResizing?: boolean;
-    allowTableAlignment?: boolean;
     allowControls?: boolean;
+    allowTableAlignment?: boolean;
+    allowTableResizing?: boolean;
     cellMinWidth?: number;
-    portalProviderAPI: PortalProviderAPI;
+    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
     eventDispatcher: EventDispatcher;
-    getPos: () => number | undefined;
-    options?: TableOptions;
     getEditorContainerWidth: GetEditorContainerWidth;
     getEditorFeatureFlags: GetEditorFeatureFlags;
-    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
+    getPos: () => number | undefined;
+    node: PmNode;
+    options?: TableOptions;
     pluginInjectionApi?: PluginInjectionAPI;
+    portalProviderAPI: PortalProviderAPI;
+    view: EditorView;
 }

package/dist/types-ts4.5/pm-plugins/analytics/actions.d.ts

@@ -7,12 +7,12 @@ export declare enum AnalyticPluginTypes {
     UpdateRowOrColumnMovedAndOverflowTrigger = 4
 }
 type UpdateRowOrColumnMovedAction = {
-    type: AnalyticPluginTypes.UpdateRowOrColumnMovedAction;
     data: RowOrColumnMovedState;
+    type: AnalyticPluginTypes.UpdateRowOrColumnMovedAction;
 };
 type RemoveRowOrColumnMovedAction = {
-    type: AnalyticPluginTypes.RemoveRowOrColumnMovedAction;
     data: undefined;
+    type: AnalyticPluginTypes.RemoveRowOrColumnMovedAction;
 };
 export type AnalyticPluginAction = UpdateRowOrColumnMovedAction | RemoveRowOrColumnMovedAction;
 export {};

package/dist/types-ts4.5/pm-plugins/analytics/types.d.ts

@@ -1,9 +1,9 @@
 export type ActionType = 'none' | 'addRowOrColumn' | 'copyOrCut' | 'pasted';
 export type RowOrColumnMovedState = {
-    type?: 'row' | 'column';
+    currentActions: Array<ActionType>;
     /** used to confirm if same number of cells was copied and pasted */
     numberOfCells?: number;
-    currentActions: Array<ActionType>;
+    type?: 'row' | 'column';
 };
 export type AnalyticPluginState = {
     rowOrColumnMoved: RowOrColumnMovedState;

package/dist/types-ts4.5/pm-plugins/commands/column-resize.d.ts

@@ -11,21 +11,21 @@ export declare const initiateKeyboardColumnResizing: ({ ariaNotify, getIntl, nod
     nodeViewPortalProviderAPI: PortalProviderAPI;
 }) => Command;
 export declare const activateNextResizeArea: ({ direction, ariaNotify, getIntl, nodeViewPortalProviderAPI, }: {
-    direction: Direction;
     ariaNotify?: (message: string, ariaLiveElementAttributes?: AriaLiveElementAttributes) => void;
+    direction: Direction;
     getIntl?: () => IntlShape;
     nodeViewPortalProviderAPI: PortalProviderAPI;
 }) => Command;
 export declare const changeColumnWidthByStep: ({ stepSize, getEditorContainerWidth, isTableScalingEnabled, isTableFixedColumnWidthsOptionEnabled, isCommentEditor, ariaNotify, api, getIntl, }: {
-    stepSize: number;
-    getEditorContainerWidth: GetEditorContainerWidth;
-    isTableScalingEnabled: boolean;
-    isTableFixedColumnWidthsOptionEnabled: boolean;
-    isCommentEditor: boolean;
     api: PluginInjectionAPI | undefined | null;
     ariaNotify?: (message: string, ariaLiveElementAttributes?: AriaLiveElementAttributes) => void;
+    getEditorContainerWidth: GetEditorContainerWidth;
     getIntl?: () => IntlShape;
+    isCommentEditor: boolean;
+    isTableFixedColumnWidthsOptionEnabled: boolean;
+    isTableScalingEnabled: boolean;
     originalTr?: Transaction;
+    stepSize: number;
 }) => Command;
 export declare const stopKeyboardColumnResizing: ({ ariaNotify, getIntl, originalTr, }: {
     ariaNotify?: (message: string, ariaLiveElementAttributes?: AriaLiveElementAttributes) => void;

package/dist/types-ts4.5/pm-plugins/commands/insert.d.ts

@@ -5,16 +5,16 @@ import type { Transaction } from '@atlaskit/editor-prosemirror/state';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { PluginInjectionAPI } from '../../types';
 type InsertTableWithNestingSupportCommand = (options: {
-    isTableScalingEnabled?: boolean;
-    isTableAlignmentEnabled?: boolean;
-    isFullWidthModeEnabled?: boolean;
-    isCommentEditor?: boolean;
-    isChromelessEditor?: boolean;
-    isTableResizingEnabled?: boolean;
     createTableProps?: {
-        rowsCount?: number;
         colsCount?: number;
+        rowsCount?: number;
     };
+    isChromelessEditor?: boolean;
+    isCommentEditor?: boolean;
+    isFullWidthModeEnabled?: boolean;
+    isTableAlignmentEnabled?: boolean;
+    isTableResizingEnabled?: boolean;
+    isTableScalingEnabled?: boolean;
 }, api: PluginInjectionAPI | undefined | null, analyticsPayload?: AnalyticsEventPayload) => EditorCommand;
 export declare function addColumnAt(api: PluginInjectionAPI | undefined | null, isTableScalingEnabled?: boolean, isTableFixedColumnWidthsOptionEnabled?: boolean, shouldUseIncreasedScalingPercent?: boolean, isCommentEditor?: boolean): (column: number, allowAddColumnCustomStep: boolean | undefined, view: EditorView | undefined) => (tr: Transaction) => Transaction;
 export declare const addColumnBefore: (api: PluginInjectionAPI | undefined | null, isTableScalingEnabled?: boolean, isTableFixedColumnWidthsOptionEnabled?: boolean, shouldUseIncreasedScalingPercent?: boolean, isCommentEditor?: boolean) => Command;

package/dist/types-ts4.5/pm-plugins/drag-and-drop/actions.d.ts

@@ -2,8 +2,8 @@ import type { DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import type { TableDirection } from '../../types';
 import type { DropTargetType } from './consts';
 interface DragAndDropAction<T, D> {
-    type: T;
     data: D;
+    type: T;
 }
 export declare const DragAndDropActionType: {
     readonly SET_DROP_TARGET: "SET_DROP_TARGET";
@@ -11,17 +11,17 @@ export declare const DragAndDropActionType: {
     readonly TOGGLE_DRAG_MENU: "TOGGLE_DRAG_MENU";
 };
 type DragAndDropSetDropTargetAction = DragAndDropAction<typeof DragAndDropActionType.SET_DROP_TARGET, {
-    type: DropTargetType;
-    index: number;
     decorationSet: DecorationSet;
+    index: number;
+    type: DropTargetType;
 }>;
 type DragAndDropClearDropTargetAction = DragAndDropAction<typeof DragAndDropActionType.CLEAR_DROP_TARGET, {
     decorationSet: DecorationSet;
 }>;
 type DragAndDropToggleDragMenuAction = DragAndDropAction<typeof DragAndDropActionType.TOGGLE_DRAG_MENU, {
-    isDragMenuOpen: boolean;
     direction: TableDirection;
     index: number;
+    isDragMenuOpen: boolean;
     isKeyboardModeActive: boolean;
 }>;
 export type DragAndDropPluginAction = DragAndDropSetDropTargetAction | DragAndDropClearDropTargetAction | DragAndDropToggleDragMenuAction;

package/dist/types-ts4.5/pm-plugins/drag-and-drop/types.d.ts

@@ -3,12 +3,12 @@ import type { TableDirection } from '../../types';
 import type { DropTargetType } from './consts';
 export interface DragAndDropPluginState {
     decorationSet: DecorationSet;
-    dropTargetType: DropTargetType;
-    dropTargetIndex: number;
-    isDragMenuOpen: boolean;
     dragMenuDirection?: TableDirection;
     dragMenuIndex: number;
+    dropTargetIndex: number;
+    dropTargetType: DropTargetType;
     isDragging: boolean;
+    isDragMenuOpen: boolean;
     isKeyboardModeActive: boolean;
 }
 export type TriggerType = 'mouse' | 'keyboard';

package/dist/types-ts4.5/pm-plugins/drag-and-drop/utils/autoscrollers.d.ts

@@ -1,7 +1,7 @@
 import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
 type AutoScrollerFactory = {
-    tableWrapper: HTMLElement;
     getNode: () => PmNode;
+    tableWrapper: HTMLElement;
 };
 export declare const autoScrollerFactory: ({ tableWrapper, getNode }: AutoScrollerFactory) => import("@atlaskit/pragmatic-drag-and-drop/types").CleanupFn[];
 export {};

package/dist/types-ts4.5/pm-plugins/safari-delete-composition-text-issue-workaround.d.ts

@@ -6,8 +6,8 @@
 import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
 interface SafariDeleteCompositionTextIssueWorkaroundPluginState {
-    renderSpan: boolean;
     decorations: DecorationSet;
+    renderSpan: boolean;
 }
 export declare const createPlugin: () => SafePlugin<SafariDeleteCompositionTextIssueWorkaroundPluginState>;
 export {};

package/dist/types-ts4.5/pm-plugins/sticky-headers/types.d.ts

@@ -1,8 +1,8 @@
 export type RowStickyState = {
-    pos: number;
-    top: number;
     padding: number;
+    pos: number;
     sticky: boolean;
+    top: number;
 };
 export type StickyPluginState = RowStickyState[];
 type UpdateSticky = {

package/dist/types-ts4.5/pm-plugins/table-resizing/commands.d.ts

@@ -6,15 +6,15 @@ import type { PluginInjectionAPI } from '../../types';
 import type { ResizeState } from './utils/types';
 export declare const evenColumns: ({ resizeState, table, start, event, api, }: {
     api: PluginInjectionAPI | undefined | null;
+    event: MouseEvent;
     resizeState: ResizeState;
-    table: PMNode;
     start: number;
-    event: MouseEvent;
+    table: PMNode;
 }) => Command;
 export declare const distributeColumnsWidths: (newResizeState: ResizeState, table: ContentNodeWithPos, api: PluginInjectionAPI | undefined | null) => Command;
 export declare const setResizeHandlePos: (resizeHandlePos: number | null) => Command;
 export declare const stopResizing: (tr?: Transaction) => Command;
 export declare const setDragging: (dragging: {
-    startX: number;
     startWidth: number;
+    startX: number;
 } | null, tr?: Transaction) => Command;

package/dist/types-ts4.5/pm-plugins/table-resizing/utils/column-state.d.ts

@@ -1,8 +1,8 @@
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 export interface ColumnState {
     index: number;
-    width: number;
     minWidth: number;
+    width: number;
 }
 export declare const getColumnStateFromDOM: (cells: HTMLElement[], index: number, minWidth: number) => ColumnState;
 export declare const getFreeSpace: (state: ColumnState) => number;

package/dist/types-ts4.5/pm-plugins/table-resizing/utils/misc.d.ts

@@ -8,11 +8,11 @@ export declare function getLayoutSize(tableLayout: 'default' | 'wide' | 'full-wi
 export declare function pointsAtCell($pos: ResolvedPos): false | PMNode | null;
 export declare function currentColWidth(view: EditorView, cellPos: number, { colspan, colwidth }: CellAttributes): number;
 interface getTableMaxWidthProps {
+    getEditorContainerWidth: GetEditorContainerWidth;
+    layout: 'default' | 'wide' | 'full-width';
+    state: EditorState;
     table: PMNode;
     tableStart: number;
-    state: EditorState;
-    layout: 'default' | 'wide' | 'full-width';
-    getEditorContainerWidth: GetEditorContainerWidth;
 }
 export declare const getTableMaxWidth: ({ table, tableStart, state, layout, getEditorContainerWidth, }: getTableMaxWidthProps) => number;
 /**

package/dist/types-ts4.5/pm-plugins/table-resizing/utils/resize-state.d.ts

@@ -4,18 +4,18 @@ import type { EditorState } from '@atlaskit/editor-prosemirror/state';
 import type { Rect } from '@atlaskit/editor-tables/table-map';
 import type { ResizeState, ResizeStateWithAnalytics } from './types';
 export declare const getResizeState: ({ minWidth, maxSize, table, tableRef, start, domAtPos, isTableScalingEnabled, shouldUseIncreasedScalingPercent, isCommentEditor, }: {
-    minWidth: number;
-    maxSize: number;
-    table: PMNode;
-    tableRef: HTMLTableElement | null;
-    start: number;
     domAtPos: (pos: number) => {
         node: Node;
         offset: number;
     };
+    isCommentEditor: boolean;
     isTableScalingEnabled: boolean;
+    maxSize: number;
+    minWidth: number;
     shouldUseIncreasedScalingPercent: boolean;
-    isCommentEditor: boolean;
+    start: number;
+    table: PMNode;
+    tableRef: HTMLTableElement | null;
 }) => ResizeState;
 export declare const updateColgroup: (state: ResizeState, tableRef: HTMLElement | null, tableNode?: PMNode, isTableScalingEnabled?: boolean, scalePercent?: number) => void;
 export declare const getTotalWidth: ({ cols }: ResizeState) => number;