@atlaskit/editor-plugin-table 5.0.0 → 5.2.0

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

@@ -0,0 +1,29 @@
+import type { TableLayout } from '@atlaskit/adf-schema';
+import type { GetEditorContainerWidth } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+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, }: {
+    minWidth: number;
+    maxSize: number;
+    table: PMNode;
+    tableRef: HTMLTableElement;
+    start: number;
+    domAtPos: (pos: number) => {
+        node: Node;
+        offset: number;
+    };
+}) => ResizeState;
+export declare const updateColgroup: (state: ResizeState, tableRef: HTMLElement) => void;
+export declare const getTotalWidth: ({ cols }: ResizeState) => number;
+export declare const adjustColumnsWidths: (resizeState: ResizeState, maxSize: number) => ResizeState;
+export declare const evenAllColumnsWidths: (resizeState: ResizeState) => ResizeState;
+export declare const evenSelectedColumnsWidths: (resizeState: ResizeState, rect: Rect) => ResizeState;
+export declare const bulkColumnsResize: (resizeState: ResizeState, columnsIndexes: number[], sourceColumnIndex: number) => ResizeState;
+export declare const areColumnsEven: (resizeState: ResizeState) => boolean;
+export declare const normaliseTableLayout: (input: string | undefined | null) => TableLayout;
+export declare const getNewResizeStateFromSelectedColumns: (rect: Rect, state: EditorState, domAtPos: (pos: number) => {
+    node: Node;
+    offset: number;
+}, getEditorContainerWidth: GetEditorContainerWidth) => ResizeStateWithAnalytics | undefined;

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

@@ -0,0 +1,21 @@
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { DomAtPos } from '@atlaskit/editor-prosemirror/utils';
+import type { ResizeState } from '../utils/types';
+export interface ScaleOptions {
+    node: PMNode;
+    prevNode: PMNode;
+    start: number;
+    containerWidth?: number;
+    previousContainerWidth?: number;
+    parentWidth?: number;
+    layoutChanged?: boolean;
+    isBreakoutEnabled?: boolean;
+    isFullWidthModeEnabled?: boolean;
+    isTableResizingEnabled?: boolean;
+}
+export declare const scale: (tableRef: HTMLTableElement, options: ScaleOptions, domAtPos: DomAtPos) => ResizeState | undefined;
+export declare const scaleWithParent: (tableRef: HTMLTableElement, parentWidth: number, table: PMNode, start: number, domAtPos: DomAtPos) => ResizeState;
+export declare function scaleTableTo(state: ResizeState, maxSize: number): ResizeState;
+export declare const previewScaleTable: (tableRef: HTMLTableElement | null | undefined, options: ScaleOptions, domAtPos: DomAtPos) => void;
+export declare const scaleTable: (tableRef: HTMLTableElement | null | undefined, options: ScaleOptions, domAtPos: DomAtPos) => (tr: Transaction) => Transaction;

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

@@ -0,0 +1,22 @@
+import { ContentNodeWithPos } from '@atlaskit/editor-prosemirror/utils';
+import { ColumnState } from './column-state';
+export interface ResizeState {
+    cols: ColumnState[];
+    widths: number[];
+    maxSize: number;
+    overflow: boolean;
+    tableWidth: number;
+}
+export interface ResizeStateWithAnalytics {
+    resizeState: ResizeState;
+    table: ContentNodeWithPos;
+    changed: boolean;
+    attributes: {
+        position: number;
+        count: number;
+        totalRowCount: number;
+        totalColumnCount: number;
+        widthsBefore: number[];
+        widthsAfter: number[];
+    };
+}

package/dist/types-ts4.5/plugins/table/pm-plugins/table-resizing/utils/unit-to-number.d.ts

@@ -0,0 +1 @@
+export declare const unitToNumber: (unit: string | null) => number;

package/dist/types-ts4.5/plugins/table/pm-plugins/table-selection-keymap.d.ts

@@ -0,0 +1,5 @@
+import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type tablePlugin from '../index';
+export declare function tableSelectionKeymapPlugin(editorSelectionAPI: ExtractInjectionAPI<typeof tablePlugin>['selection'] | undefined): SafePlugin;
+export default tableSelectionKeymapPlugin;

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

@@ -0,0 +1,17 @@
+/**
+ * A plugin for handle table custom widths
+ * Has login to scan the document, add width value to table's width attribute when necessary
+ * Also holds resizing state to hide / show table controls
+ */
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+type TableWidthPluginState = {
+    resizing: boolean;
+};
+export declare const pluginKey: PluginKey<TableWidthPluginState>;
+declare const createPlugin: (dispatch: Dispatch, dispatchAnalyticsEvent: DispatchAnalyticsEvent, fullWidthEnabled: boolean) => SafePlugin<{
+    resizing: boolean;
+}>;
+export { createPlugin };

package/dist/types-ts4.5/plugins/table/reducer.d.ts

@@ -0,0 +1,3 @@
+import type { TablePluginAction, TablePluginState } from './types';
+declare const _default: (pluginState: TablePluginState, action: TablePluginAction) => TablePluginState;
+export default _default;

package/dist/types-ts4.5/plugins/table/toolbar.d.ts

@@ -0,0 +1,36 @@
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { Command, FloatingToolbarDropdown, FloatingToolbarHandler, FloatingToolbarItem, GetEditorContainerWidth, GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { Rect } from '@atlaskit/editor-tables/table-map';
+import type { PluginConfig, ToolbarMenuConfig, ToolbarMenuContext, ToolbarMenuState } from './types';
+export declare const messages: {
+    tableOptions: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    headerRow: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    headerColumn: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    numberedColumn: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    collapseTable: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export declare const getToolbarMenuConfig: (config: ToolbarMenuConfig, state: ToolbarMenuState, { formatMessage }: ToolbarMenuContext, editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => FloatingToolbarItem<Command>;
+export declare const getToolbarCellOptionsConfig: (editorState: EditorState, editorView: EditorView | undefined | null, initialSelectionRect: Rect, { formatMessage }: ToolbarMenuContext, getEditorContainerWidth: GetEditorContainerWidth, editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => FloatingToolbarDropdown<Command>;
+export declare const getToolbarConfig: (getEditorContainerWidth: GetEditorContainerWidth, editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null, getEditorFeatureFlags: GetEditorFeatureFlags, getEditorView: () => EditorView | null) => (config: PluginConfig) => FloatingToolbarHandler;

package/dist/types-ts4.5/plugins/table/transforms/column-width.d.ts

@@ -0,0 +1,37 @@
+import type { GetEditorContainerWidth } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { ContentNodeWithPos } from '@atlaskit/editor-prosemirror/utils';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { ResizeState } from '../pm-plugins/table-resizing/utils';
+/**
+ * Given a new ResizeState object, create a transaction that replaces and updates the table node based on new state.
+ * @param resizeState
+ * @param table
+ * @param start
+ * @returns
+ */
+export declare const updateColumnWidths: (resizeState: ResizeState, table: PMNode, start: number) => (tr: Transaction) => Transaction;
+/**
+ * This function is called when user inserts/deletes a column in a table to;
+ * - rescale all columns (if the table did not overflow before the insertion)
+ * - and update column widths.
+ *
+ * This is done manually to avoid a multi-dispatch in TableComponent. See [ED-8288].
+ * @param table
+ * @param view
+ * @returns Updated transaction with rescaled columns for a given table
+ */
+export declare const rescaleColumnsNew: () => (table: ContentNodeWithPos, view: EditorView | undefined) => (tr: Transaction) => Transaction;
+/**
+ * This function is called when user inserts/deletes a column in a table to;
+ * - rescale all columns (if the table did not overflow before the insertion)
+ * - and update column widths.
+ *
+ * This is done manually to avoid a multi-dispatch in TableComponent. See [ED-8288].
+ * @param table
+ * @param view
+ * @returns Updated transaction with rescaled columns for a given table
+ */
+export declare const rescaleColumnsOld: (getEditorContainerWidth: GetEditorContainerWidth) => (table: ContentNodeWithPos, view: EditorView | undefined) => (tr: Transaction) => Transaction;
+export declare const rescaleColumns: (getEditorContainerWidth?: GetEditorContainerWidth) => (table: ContentNodeWithPos, view: EditorView | undefined) => (tr: Transaction) => Transaction;

package/dist/types-ts4.5/plugins/table/transforms/delete-columns.d.ts

@@ -0,0 +1,4 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { Rect } from '@atlaskit/editor-tables/table-map';
+export declare const deleteColumns: (rect: Rect, allowCustomStep: boolean, view?: EditorView) => (tr: Transaction) => Transaction;

package/dist/types-ts4.5/plugins/table/transforms/delete-rows.d.ts

@@ -0,0 +1,3 @@
+import { Transaction } from '@atlaskit/editor-prosemirror/state';
+import { Rect } from '@atlaskit/editor-tables/table-map';
+export declare const deleteRows: (rect: Rect, isHeaderRowRequired?: boolean) => (tr: Transaction) => Transaction;

package/dist/types-ts4.5/plugins/table/transforms/fix-tables.d.ts

@@ -0,0 +1,9 @@
+import { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { Transaction } from '@atlaskit/editor-prosemirror/state';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+import { ReportInvalidNodeAttrs } from '../types';
+export declare const removeExtraneousColumnWidths: (node: PMNode, basePos: number, tr: Transaction, reportInvalidTableCellSpanAttrs?: ReportInvalidNodeAttrs) => boolean;
+export declare const fixTables: (tr: Transaction, reportInvalidTableCellSpanAttrs?: ReportInvalidNodeAttrs) => Transaction | undefined;
+export declare const fixAutoSizedTable: (view: EditorView, tableNode: PMNode, tableRef: HTMLTableElement, tablePos: number, opts: {
+    containerWidth: number;
+}) => Transaction;

package/dist/types-ts4.5/plugins/table/transforms/index.d.ts

@@ -0,0 +1,6 @@
+export { fixTables, fixAutoSizedTable } from './fix-tables';
+export { mergeCells, canMergeCells, mergeEmptyColumns } from './merge';
+export { deleteColumns } from './delete-columns';
+export { deleteRows } from './delete-rows';
+export { updateColumnWidths } from './column-width';
+export { replaceSelectedTable } from './replace-table';

package/dist/types-ts4.5/plugins/table/transforms/merge.d.ts

@@ -0,0 +1,5 @@
+import { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare function mergeCells(tr: Transaction): Transaction;
+export declare function canMergeCells(tr: Transaction): boolean;
+export declare function mergeEmptyColumns(table: PMNode): PMNode | null;

package/dist/types-ts4.5/plugins/table/transforms/replace-table.d.ts

@@ -0,0 +1,5 @@
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { Slice } from '@atlaskit/editor-prosemirror/model';
+import { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare const replaceSelectedTable: (state: EditorState, content: string | Slice, inputMethod: INPUT_METHOD.KEYBOARD | INPUT_METHOD.CLIPBOARD, editorAnalyticsAPI?: EditorAnalyticsAPI) => Transaction;

package/dist/types-ts4.5/plugins/table/transforms/split.d.ts

@@ -0,0 +1,9 @@
+import { Transaction } from '@atlaskit/editor-prosemirror/state';
+/**
+ * Helper to split all the cells in a range of columns
+ * @param tr
+ * @param tablePos
+ * @param columnStart - Start of the rect included (rect.left)
+ * @param columnEnd - End of the rect not included (rect.right)
+ */
+export declare function splitCellsInColumns(tr: Transaction, tablePos: number, columnStart: number, columnEnd: number): Transaction;

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

@@ -0,0 +1,343 @@
+import type { IntlShape } from 'react-intl-next';
+import type { TableLayout } from '@atlaskit/adf-schema';
+import type { TableColumnOrdering } from '@atlaskit/custom-steps';
+import type { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import type { Rect } from '@atlaskit/editor-tables/table-map';
+import type tablePlugin from './index';
+export declare const RESIZE_HANDLE_AREA_DECORATION_GAP = 30;
+export type RowInsertPosition = 'TOP' | 'BOTTOM';
+export type PermittedLayoutsDescriptor = TableLayout[] | 'all';
+export type Cell = {
+    pos: number;
+    start: number;
+    node: PmNode;
+};
+export type CellTransform = (cell: Cell) => (tr: Transaction) => Transaction;
+export interface InsertRowOptions {
+    index: number;
+    moveCursorToInsertedRow: boolean;
+}
+export type PluginInjectionAPI = ExtractInjectionAPI<typeof tablePlugin>;
+export type InsertRowMethods = INPUT_METHOD.CONTEXT_MENU | INPUT_METHOD.BUTTON | INPUT_METHOD.SHORTCUT | INPUT_METHOD.KEYBOARD | INPUT_METHOD.FLOATING_TB;
+export interface PluginConfig {
+    advanced?: boolean;
+    allowBackgroundColor?: boolean;
+    allowColumnResizing?: boolean;
+    allowHeaderColumn?: boolean;
+    allowHeaderRow?: boolean;
+    allowMergeCells?: boolean;
+    allowNumberColumn?: boolean;
+    allowColumnSorting?: boolean;
+    allowAddColumnWithCustomStep?: boolean;
+    allowCollapse?: boolean;
+    isHeaderRowRequired?: boolean;
+    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'>;
+export interface TablePluginState {
+    editorHasFocus?: boolean;
+    hoveredColumns: number[];
+    hoveredRows: number[];
+    pluginConfig: PluginConfig;
+    isHeaderColumnEnabled: boolean;
+    isHeaderRowEnabled: boolean;
+    isNumberColumnEnabled?: boolean;
+    targetCellPosition?: number;
+    tableNode?: PmNode;
+    tableRef?: HTMLTableElement;
+    tablePos?: number;
+    tableWrapperTarget?: HTMLElement;
+    isContextualMenuOpen?: boolean;
+    isInDanger?: boolean;
+    insertColumnButtonIndex?: number;
+    insertRowButtonIndex?: number;
+    isFullWidthModeEnabled?: boolean;
+    layout?: TableLayout;
+    ordering?: TableColumnOrdering;
+    isResizeHandleWidgetAdded?: boolean;
+    resizeHandleRowIndex?: number;
+    resizeHandleColumnIndex?: number;
+    resizeHandleIncludeTooltip?: boolean;
+    isTableCollapsed?: boolean;
+    canCollapseTable?: boolean;
+    getIntl: () => IntlShape;
+    isBreakoutEnabled?: boolean;
+    wasFullWidthModeEnabled?: boolean;
+    isTableResizingEnabled?: boolean;
+    isDragAndDropEnabled?: boolean;
+}
+export type TablePluginAction = {
+    type: 'SET_EDITOR_FOCUS';
+    data: {
+        editorHasFocus: boolean;
+    };
+} | {
+    type: 'TOGGLE_HEADER_ROW';
+} | {
+    type: 'TOGGLE_HEADER_COLUMN';
+} | {
+    type: 'SORT_TABLE';
+    data: {
+        ordering: TableColumnOrdering;
+    };
+} | {
+    type: 'SET_TABLE_REF';
+    data: {
+        tableRef?: HTMLTableElement;
+        tableNode?: PmNode;
+        tableWrapperTarget?: HTMLElement;
+        layout: TableLayout;
+        isHeaderRowEnabled: boolean;
+        isHeaderColumnEnabled: boolean;
+    };
+} | {
+    type: 'HOVER_ROWS';
+    data: {
+        decorationSet: DecorationSet;
+        hoveredRows: number[];
+        isInDanger?: boolean;
+    };
+} | {
+    type: 'HOVER_CELLS';
+    data: {
+        decorationSet: DecorationSet;
+    };
+} | {
+    type: 'HOVER_COLUMNS';
+    data: {
+        decorationSet: DecorationSet;
+        hoveredColumns: number[];
+        isInDanger?: boolean;
+    };
+} | {
+    type: 'HOVER_TABLE';
+    data: {
+        decorationSet: DecorationSet;
+        hoveredRows: number[];
+        hoveredColumns: number[];
+        isInDanger?: boolean;
+    };
+} | {
+    type: 'ADD_RESIZE_HANDLE_DECORATIONS';
+    data: {
+        decorationSet: DecorationSet;
+        resizeHandleRowIndex: number;
+        resizeHandleColumnIndex: number;
+        resizeHandleIncludeTooltip: boolean;
+    };
+} | {
+    type: 'UPDATE_RESIZE_HANDLE_DECORATIONS';
+    data: {
+        decorationSet: DecorationSet;
+        resizeHandleRowIndex: number | undefined;
+        resizeHandleColumnIndex: number | undefined;
+        resizeHandleIncludeTooltip: boolean | undefined;
+    };
+} | {
+    type: 'REMOVE_RESIZE_HANDLE_DECORATIONS';
+    data: {
+        decorationSet: DecorationSet;
+    };
+} | {
+    type: 'CLEAR_HOVER_SELECTION';
+    data: {
+        decorationSet: DecorationSet;
+    };
+} | {
+    type: 'SHOW_RESIZE_HANDLE_LINE';
+    data: {
+        decorationSet: DecorationSet;
+    };
+} | {
+    type: 'HIDE_RESIZE_HANDLE_LINE';
+    data: {
+        decorationSet: DecorationSet;
+    };
+} | {
+    type: 'SET_TARGET_CELL_POSITION';
+    data: {
+        targetCellPosition?: number;
+    };
+} | {
+    type: 'SELECT_COLUMN';
+    data: {
+        targetCellPosition: number;
+        decorationSet: DecorationSet;
+    };
+} | {
+    type: 'SET_TABLE_LAYOUT';
+    data: {
+        layout: TableLayout;
+    };
+} | {
+    type: 'SHOW_INSERT_ROW_BUTTON';
+    data: {
+        insertRowButtonIndex: number;
+    };
+} | {
+    type: 'SHOW_INSERT_COLUMN_BUTTON';
+    data: {
+        insertColumnButtonIndex: number;
+    };
+} | {
+    type: 'HIDE_INSERT_COLUMN_OR_ROW_BUTTON';
+} | {
+    type: 'TOGGLE_CONTEXTUAL_MENU';
+};
+export type ColumnResizingPluginAction = {
+    type: 'SET_RESIZE_HANDLE_POSITION';
+    data: {
+        resizeHandlePos: number | null;
+    };
+} | {
+    type: 'STOP_RESIZING';
+} | {
+    type: 'SET_DRAGGING';
+    data: {
+        dragging: {
+            startX: number;
+            startWidth: number;
+        } | null;
+    };
+} | {
+    type: 'SET_LAST_CLICK';
+    data: {
+        lastClick: {
+            x: number;
+            y: number;
+            time: number;
+        } | null;
+    };
+};
+export declare enum TableDecorations {
+    ALL_CONTROLS_HOVER = "CONTROLS_HOVER",
+    ROW_CONTROLS_HOVER = "ROW_CONTROLS_HOVER",
+    COLUMN_CONTROLS_HOVER = "COLUMN_CONTROLS_HOVER",
+    TABLE_CONTROLS_HOVER = "TABLE_CONTROLS_HOVER",
+    CELL_CONTROLS_HOVER = "CELL_CONTROLS_HOVER",
+    COLUMN_CONTROLS_DECORATIONS = "COLUMN_CONTROLS_DECORATIONS",
+    COLUMN_SELECTED = "COLUMN_SELECTED",
+    COLUMN_RESIZING_HANDLE = "COLUMN_RESIZING_HANDLE",
+    COLUMN_RESIZING_HANDLE_WIDGET = "COLUMN_RESIZING_HANDLE_WIDGET",
+    COLUMN_RESIZING_HANDLE_LINE = "COLUMN_RESIZING_HANDLE_LINE",
+    LAST_CELL_ELEMENT = "LAST_CELL_ELEMENT"
+}
+export declare const TableCssClassName: {
+    COLUMN_CONTROLS: string;
+    COLUMN_CONTROLS_DECORATIONS: string;
+    COLUMN_SELECTED: string;
+    ROW_CONTROLS_WRAPPER: string;
+    ROW_CONTROLS: string;
+    ROW_CONTROLS_INNER: string;
+    ROW_CONTROLS_BUTTON_WRAP: string;
+    ROW_CONTROLS_BUTTON: string;
+    CONTROLS_BUTTON: string;
+    CONTROLS_BUTTON_ICON: string;
+    CONTROLS_INSERT_BUTTON: string;
+    CONTROLS_INSERT_BUTTON_INNER: string;
+    CONTROLS_INSERT_BUTTON_WRAP: string;
+    CONTROLS_INSERT_LINE: string;
+    CONTROLS_BUTTON_OVERLAY: string;
+    LAYOUT_BUTTON: string;
+    CONTROLS_INSERT_MARKER: string;
+    CONTROLS_INSERT_COLUMN: string;
+    CONTROLS_INSERT_ROW: string;
+    CONTROLS_DELETE_BUTTON_WRAP: string;
+    CONTROLS_DELETE_BUTTON: string;
+    CONTROLS_FLOATING_BUTTON_COLUMN: string;
+    CONTROLS_FLOATING_BUTTON_ROW: string;
+    CORNER_CONTROLS: string;
+    CORNER_CONTROLS_INSERT_ROW_MARKER: string;
+    CORNER_CONTROLS_INSERT_COLUMN_MARKER: string;
+    CONTROLS_CORNER_BUTTON: string;
+    NUMBERED_COLUMN: string;
+    NUMBERED_COLUMN_BUTTON: string;
+    HOVERED_COLUMN: string;
+    HOVERED_ROW: string;
+    HOVERED_TABLE: string;
+    HOVERED_CELL: string;
+    HOVERED_CELL_IN_DANGER: string;
+    HOVERED_CELL_ACTIVE: string;
+    HOVERED_CELL_WARNING: string;
+    HOVERED_DELETE_BUTTON: string;
+    WITH_CONTROLS: string;
+    RESIZING_PLUGIN: string;
+    RESIZE_CURSOR: string;
+    IS_RESIZING: string;
+    RESIZE_HANDLE: string;
+    RESIZE_HANDLE_DECORATION: string;
+    CONTEXTUAL_SUBMENU: string;
+    CONTEXTUAL_MENU_BUTTON_WRAP: string;
+    CONTEXTUAL_MENU_BUTTON: string;
+    CONTEXTUAL_MENU_BUTTON_FIXED: string;
+    CONTEXTUAL_MENU_ICON: string;
+    SELECTED_CELL: string;
+    NODEVIEW_WRAPPER: string;
+    TABLE_SELECTED: string;
+    TABLE_CELL: string;
+    TABLE_HEADER_CELL: string;
+    TABLE_STICKY: string;
+    TOP_LEFT_CELL: string;
+    LAST_ITEM_IN_CELL: string;
+    WITH_RESIZE_LINE: string;
+    WITH_RESIZE_LINE_LAST_COLUMN: string;
+    TABLE_CONTAINER: string;
+    TABLE_NODE_WRAPPER: string;
+    TABLE_LEFT_SHADOW: string;
+    TABLE_RIGHT_SHADOW: string;
+    TABLE_STICKY_SHADOW: string;
+    TABLE_STICKY_WRAPPER: string;
+    TABLE_STICKY_SCROLLBAR_CONTAINER: string;
+    TABLE_STICKY_SENTINEL_TOP: string;
+    TABLE_STICKY_SENTINEL_BOTTOM: string;
+    TABLE_STICKY_SCROLLBAR_SENTINEL_TOP: string;
+    TABLE_STICKY_SCROLLBAR_SENTINEL_BOTTOM: string;
+    TABLE_SHADOW_SENTINEL_LEFT: string;
+    TABLE_SHADOW_SENTINEL_RIGHT: string;
+    TABLE_CELL_NODEVIEW_CONTENT_DOM: string;
+    TABLE_CELL_WRAPPER: string;
+    TABLE_HEADER_CELL_WRAPPER: string;
+    TABLE_ROW_CONTROLS_WRAPPER: string;
+    TABLE_COLUMN_CONTROLS_DECORATIONS: string;
+    TABLE_RESIZER_CONTAINER: string;
+};
+export interface ToolbarMenuConfig {
+    allowHeaderRow?: boolean;
+    allowHeaderColumn?: boolean;
+    allowNumberColumn?: boolean;
+    allowCollapse?: boolean;
+}
+export interface ToolbarMenuState {
+    isHeaderRowEnabled?: boolean;
+    isHeaderColumnEnabled?: boolean;
+    isNumberColumnEnabled?: boolean;
+    isTableCollapsed?: boolean;
+    canCollapseTable?: boolean;
+}
+export interface ToolbarMenuContext {
+    formatMessage: IntlShape['formatMessage'];
+}
+export type ElementContentRects = {
+    [key: string]: ResizeObserverEntry['contentRect'];
+};
+export declare enum ShadowEvent {
+    SHOW_BEFORE_SHADOW = "showBeforeShadow",
+    SHOW_AFTER_SHADOW = "showAfterShadow"
+}
+export type ReportInvalidNodeAttrs = (invalidNodeAttrs: InvalidNodeAttr) => void;
+export type InvalidNodeAttr = {
+    nodeType: string;
+    attribute: string;
+    reason: string;
+    spanValue: number;
+    tableLocalId: string;
+};

package/dist/types-ts4.5/plugins/table/ui/ColumnResizeWidget/index.d.ts

@@ -0,0 +1,9 @@
+/** @jsx jsx */
+import React from 'react';
+type Props = {
+    startIndex: number;
+    endIndex: number;
+    includeTooltip?: boolean;
+};
+export declare const ColumnResizeWidget: React.FC<Props>;
+export {};

package/dist/types-ts4.5/plugins/table/ui/FloatingContextualButton/FixedButton.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { RowStickyState } from '../../pm-plugins/sticky-headers';
+export declare const BUTTON_WIDTH = 20;
+export interface Props {
+    children: React.ReactNode;
+    mountTo: HTMLElement;
+    offset: number;
+    stickyHeader: RowStickyState;
+    targetCellPosition: number;
+    targetCellRef: HTMLElement;
+    tableWrapper: HTMLElement;
+    isContextualMenuOpen: boolean | undefined;
+}
+interface CalcLeftPosData {
+    buttonWidth: number;
+    cellRectLeft: number;
+    cellRefWidth: number;
+    offset: number;
+}
+export declare const calcLeftPos: ({ buttonWidth, cellRectLeft, cellRefWidth, offset, }: CalcLeftPosData) => number;
+export declare const calcObserverTargetMargin: (tableWrapper: HTMLElement, fixedButtonRefCurrent: HTMLElement) => number;
+export declare const FixedButton: ({ children, isContextualMenuOpen, mountTo, offset, stickyHeader, tableWrapper, targetCellPosition, targetCellRef, }: Props) => React.ReactPortal;
+export default FixedButton;

package/dist/types-ts4.5/plugins/table/ui/FloatingContextualButton/index.d.ts

@@ -0,0 +1,21 @@
+import { jsx } from '@emotion/react';
+import { TableLayout } from '@atlaskit/adf-schema';
+import { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+import { RowStickyState } from '../../pm-plugins/sticky-headers';
+export interface Props {
+    editorView: EditorView;
+    tableWrapper?: HTMLElement;
+    tableNode?: PMNode;
+    targetCellPosition: number;
+    isContextualMenuOpen?: boolean;
+    mountPoint?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    layout?: TableLayout;
+    isNumberColumnEnabled?: boolean;
+    stickyHeader?: RowStickyState;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+}
+export default function (props: Props): jsx.JSX.Element;

package/dist/types-ts4.5/plugins/table/ui/FloatingContextualButton/styles.d.ts

@@ -0,0 +1,3 @@
+import { ThemeProps } from '@atlaskit/theme/types';
+export declare const tableFloatingCellButtonStyles: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
+export declare const tableFloatingCellButtonSelectedStyles: (props: ThemeProps) => import("@emotion/react").SerializedStyles;