@atlaskit/editor-plugin-table 12.2.7 → 12.3.1

package/dist/types-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/pm-plugins/utils/dom.d.ts

@@ -30,12 +30,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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/pm-plugins/view-mode-sort/index.d.ts

@@ -10,10 +10,10 @@ 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-ts4.5/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,

package/dist/types-ts4.5/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 {};