@atlaskit/editor-plugin-table 12.3.0 → 12.3.2

package/dist/types/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/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/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/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/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/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/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/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/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;

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

@@ -4,15 +4,15 @@ import type { DomAtPos } from '@atlaskit/editor-prosemirror/utils';
 import type { PluginInjectionAPI } from '../../../types';
 import type { ResizeState } from '../utils/types';
 interface ScaleOptions {
-    node: PMNode;
-    prevNode: PMNode;
-    start: number;
     containerWidth?: number;
-    previousContainerWidth?: number;
-    parentWidth?: number;
-    layoutChanged?: boolean;
     isFullWidthModeEnabled?: boolean;
     isTableResizingEnabled?: boolean;
+    layoutChanged?: boolean;
+    node: PMNode;
+    parentWidth?: number;
+    previousContainerWidth?: number;
+    prevNode: PMNode;
+    start: number;
 }
 export declare function scaleTableTo(state: ResizeState, maxSize: number): ResizeState;
 export declare const previewScaleTable: (tableRef: HTMLTableElement | null | undefined, options: ScaleOptions, domAtPos: DomAtPos, isTableScalingEnabled?: boolean, isTableWithFixedColumnWidthsOptionEnabled?: boolean, isCommentEditor?: boolean) => void;

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

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

package/dist/types/pm-plugins/utils/analytics.d.ts

@@ -5,10 +5,10 @@ import type { Selection } from '@atlaskit/editor-prosemirror/state';
 import { TableMap } from '@atlaskit/editor-tables/table-map';
 import { findTable } from '@atlaskit/editor-tables/utils';
 export declare function getSelectedTableInfo(selection: Selection): {
-    table: ReturnType<typeof findTable> | undefined;
     map: TableMap | undefined;
-    totalRowCount: number;
+    table: ReturnType<typeof findTable> | undefined;
     totalColumnCount: number;
+    totalRowCount: number;
 };
 export declare function getSelectedCellInfo(selection: Selection): {
     totalRowCount: number;

package/dist/types/pm-plugins/utils/collapse.d.ts

@@ -2,15 +2,15 @@ import type { NodeType } from '@atlaskit/editor-prosemirror/model';
 import { NodeRange } from '@atlaskit/editor-prosemirror/model';
 import type { ReadonlyTransaction, Transaction } from '@atlaskit/editor-prosemirror/state';
 interface IsTableCollapsibleResult {
-    tableIsCollapsible: boolean;
-    range?: NodeRange;
     findWrappingRes?: // Ignored via go/ees005
     Array<{
-        type: NodeType;
         attrs?: {
             [key: string]: any;
         } | null;
+        type: NodeType;
     }> | null | undefined;
+    range?: NodeRange;
+    tableIsCollapsible: boolean;
 }
 /**
  * Checks whether we can wrap the selected table into an expand via

package/dist/types/pm-plugins/utils/column-controls.d.ts

@@ -3,8 +3,8 @@ import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import { TableMap } from '@atlaskit/editor-tables/table-map';
 export declare const getColumnsWidths: (view: EditorView) => Array<number | undefined>;
 export declare const getColumnDeleteButtonParams: (columnsWidths: Array<number | undefined>, selection: Selection) => {
-    left: number;
     indexes: number[];
+    left: number;
 } | null;
 export declare const colWidthsForRow: (tr: HTMLTableRowElement) => string;
 export declare const convertHTMLCellIndexToColumnIndex: (htmlColIndex: number, htmlRowIndex: number, tableMap: TableMap) => number;

package/dist/types/pm-plugins/utils/create.d.ts

@@ -1,14 +1,14 @@
 import type { Schema } from '@atlaskit/editor-prosemirror/model';
 export declare const createTableWithWidth: ({ isTableScalingEnabled, isTableAlignmentEnabled, isFullWidthModeEnabled, isCommentEditor, isChromelessEditor, isTableResizingEnabled, isNestedTable, createTableProps, }: {
-    isTableScalingEnabled?: boolean;
-    isTableAlignmentEnabled?: boolean;
-    isFullWidthModeEnabled?: boolean;
-    isCommentEditor?: boolean;
-    isChromelessEditor?: boolean;
-    isTableResizingEnabled?: boolean;
-    isNestedTable?: boolean;
     createTableProps?: {
-        rowsCount?: number;
         colsCount?: number;
+        rowsCount?: number;
     };
+    isChromelessEditor?: boolean;
+    isCommentEditor?: boolean;
+    isFullWidthModeEnabled?: boolean;
+    isNestedTable?: boolean;
+    isTableAlignmentEnabled?: boolean;
+    isTableResizingEnabled?: boolean;
+    isTableScalingEnabled?: boolean;
 }) => (schema: Schema) => import("prosemirror-model").Node;

package/dist/types/pm-plugins/utils/dom.d.ts

@@ -27,12 +27,12 @@ export declare const hasResizeHandler: ({ columnEndIndexTarget, target, }: {
     target: HTMLElement;
 }) => boolean;
 export type TableDOMElements = {
-    wrapper: HTMLDivElement;
     table: HTMLTableElement;
+    wrapper: HTMLDivElement;
 };
 export declare const getTree: (tr: HTMLTableRowElement) => TableDOMElements | null;
 export declare const getTop: (element: HTMLElement | Window | undefined) => number;
 export declare const findNearestCellIndexToPoint: (x: number, y: number) => {
-    row: number;
     col: number;
+    row: number;
 } | undefined;

package/dist/types/pm-plugins/utils/drag-menu.d.ts

@@ -11,9 +11,9 @@ export declare const getTargetIndex: (selectedIndexes: number[], direction: Drag
 export declare const canMove: (sourceType: DraggableType, direction: DraggableData["direction"], totalItemsOfSourceTypeCount: number, selection: Selection, selectionRect?: Rect) => boolean;
 export type DragMenuOptionIdType = 'add_row_above' | 'add_row_below' | 'add_column_left' | 'add_column_right' | 'distribute_columns' | 'clear_cells' | 'delete_row' | 'delete_column' | 'move_column_left' | 'move_column_right' | 'move_row_up' | 'move_row_down' | 'sort_column_asc' | 'sort_column_desc';
 export interface DragMenuConfig extends Omit<DropdownOptionT<Command>, 'icon'> {
-    id: DragMenuOptionIdType;
     icon?: React.ComponentType<React.PropsWithChildren<NewIconProps>>;
     iconFallback?: React.ComponentType<React.PropsWithChildren<NewIconProps>>;
+    id: DragMenuOptionIdType;
     keymap?: string;
 }
 export declare const getDragMenuConfig: (direction: TableDirection, getEditorContainerWidth: GetEditorContainerWidth, hasMergedCellsInTable: boolean, editorView: EditorView, api: PluginInjectionAPI | undefined | null, tableMap?: TableMap, index?: number, targetCellPosition?: number, selectionRect?: Rect, editorAnalyticsAPI?: EditorAnalyticsAPI, isHeaderRowRequired?: boolean, isTableScalingEnabled?: boolean, isTableFixedColumnWidthsOptionEnabled?: boolean, shouldUseIncreasedScalingPercent?: boolean, ariaNotifyPlugin?: (message: string, ariaLiveElementAttributes?: AriaLiveElementAttributes) => void, isCommentEditor?: boolean) => DragMenuConfig[];

package/dist/types/pm-plugins/utils/row-controls.d.ts

@@ -1,14 +1,14 @@
 import type { Schema } from '@atlaskit/editor-prosemirror/model';
 import type { Selection, Transaction } from '@atlaskit/editor-prosemirror/state';
 export interface RowParams {
-    startIndex: number;
     endIndex: number;
     height: number;
+    startIndex: number;
 }
 export declare const getRowHeights: (tableRef: HTMLTableElement) => number[];
 export declare const getRowDeleteButtonParams: (rowsHeights: Array<number | undefined>, selection: Selection, offsetTop?: number) => {
-    top: number;
     indexes: number[];
+    top: number;
 } | null;
 export declare const getRowsParams: (rowsHeights: Array<number | undefined>) => RowParams[];
 export declare const getRowClassNames: (index: number, selection: Selection, hoveredRows?: number[], isInDanger?: boolean, isResizing?: boolean) => string;

package/dist/types/pm-plugins/utils/snapping.d.ts

@@ -1,8 +1,8 @@
 import type { GuidelineConfig } from '@atlaskit/editor-common/guideline';
 export declare const calculateDefaultSnappings: (lengthOffset?: number) => number[];
 export type GuidelineExcludeConfig = {
-    innerGuidelines: boolean;
     breakoutPoints: boolean;
+    innerGuidelines: boolean;
 };
 export declare const calculateDefaultTablePreserveSnappings: (lengthOffset?: number, editorContainerWith?: number, exclude?: GuidelineExcludeConfig) => number[];
 export declare const defaultSnappingWidths: number[];

package/dist/types/pm-plugins/view-mode-sort/index.d.ts

@@ -10,6 +10,6 @@ import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import type tablePlugin from '../../tablePlugin';
 export declare const createPlugin: (api: ExtractInjectionAPI<typeof tablePlugin>, nodeViewPortalProviderAPI: PortalProviderAPI) => SafePlugin<{
     decorations: DecorationSet;
-    sort: import("./types").TableSortMeta;
     allTables: [string, import("prosemirror-model").Node, number][];
+    sort: import("./types").TableSortMeta;
 }>;

package/dist/types/pm-plugins/view-mode-sort/types.d.ts

@@ -2,17 +2,17 @@ import type { SortOrder } from '@atlaskit/editor-common/types';
 import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
 import type { DecorationSet } from '@atlaskit/editor-prosemirror/view';
 export type TableSortMeta = Record<string, {
+    direction: SortOrder;
     index: number;
     order: {
         index: number;
         value: number;
     }[];
-    direction: SortOrder;
 }>;
 export interface ViewModeSortPluginState {
+    allTables: HoverTableMeta[];
     decorations: DecorationSet;
     sort: TableSortMeta;
-    allTables: HoverTableMeta[];
 }
 type HoverTableMeta = [string, PMNode, number];
 export {};

package/dist/types/tablePluginType.d.ts

@@ -15,23 +15,23 @@ import type { UserIntentPlugin } from '@atlaskit/editor-plugin-user-intent';
 import type { WidthPlugin } from '@atlaskit/editor-plugin-width';
 import type { PluginConfig, TableSharedState } from './types';
 export interface TablePluginOptions {
-    tableOptions: PluginConfig;
-    dragAndDropEnabled?: boolean;
-    isTableScalingEnabled?: boolean;
     allowContextualMenu?: boolean;
+    dragAndDropEnabled?: boolean;
     fullWidthEnabled?: boolean;
-    wasFullWidthEnabled?: boolean;
     getEditorFeatureFlags?: GetEditorFeatureFlags;
-    isCommentEditor?: boolean;
     isChromelessEditor?: boolean;
+    isCommentEditor?: boolean;
+    isTableScalingEnabled?: boolean;
+    tableOptions: PluginConfig;
+    wasFullWidthEnabled?: boolean;
 }
 type InsertTableAction = (analyticsPayload: AnalyticsEventPayload) => Command;
 type MediaPlugin = NextEditorPlugin<'media', {
-    pluginConfiguration: any;
-    dependencies: any;
-    sharedState: any;
     actions: any;
     commands: any;
+    dependencies: any;
+    pluginConfiguration: any;
+    sharedState: any;
 }>;
 export type TablePluginActions = {
     insertTable: InsertTableAction;
@@ -56,10 +56,10 @@ export type TablePluginDependencies = [
     OptionalPlugin<UserIntentPlugin>
 ];
 export type TablePlugin = NextEditorPlugin<'table', {
-    pluginConfiguration: TablePluginOptions | undefined;
     actions: TablePluginActions;
-    sharedState?: TableSharedState;
     commands: TablePluginCommands;
     dependencies: TablePluginDependencies;
+    pluginConfiguration: TablePluginOptions | undefined;
+    sharedState?: TableSharedState;
 }>;
 export {};