@atlaskit/editor-plugin-table 0.0.0 → 0.0.1

package/dist/types/plugins/table/commands-with-analytics.d.ts

@@ -0,0 +1,26 @@
+import { Rect } from '@atlaskit/editor-tables/table-map';
+import type { Command } from '@atlaskit/editor-common/types';
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { InsertRowMethods, InsertRowOptions, RowInsertPosition } from './types';
+import { TableSortOrder as SortOrder } from '@atlaskit/adf-schema/steps';
+import { ResizeStateWithAnalytics } from './pm-plugins/table-resizing/utils';
+import type { GetEditorContainerWidth } from '@atlaskit/editor-common/types';
+export declare const emptyMultipleCellsWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => (inputMethod: INPUT_METHOD.CONTEXT_MENU | INPUT_METHOD.KEYBOARD | INPUT_METHOD.FLOATING_TB, targetCellPosition?: number | undefined) => Command;
+export declare const mergeCellsWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | null | undefined) => Command;
+export declare const splitCellWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => Command;
+export declare const setColorWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => (cellColor: string, targetCellPosition?: number | undefined) => Command;
+export declare const addRowAroundSelection: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => (side: RowInsertPosition) => Command;
+export declare const insertRowWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => (inputMethod: InsertRowMethods, options: InsertRowOptions) => Command;
+export declare const insertColumnWithAnalytics: (getEditorContainerWidth: GetEditorContainerWidth, editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => (inputMethod: INPUT_METHOD.CONTEXT_MENU | INPUT_METHOD.BUTTON | INPUT_METHOD.SHORTCUT | INPUT_METHOD.FLOATING_TB, position: number) => Command;
+export declare const deleteRowsWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => (inputMethod: INPUT_METHOD.CONTEXT_MENU | INPUT_METHOD.BUTTON | INPUT_METHOD.FLOATING_TB, rect: Rect, isHeaderRowRequired: boolean) => Command;
+export declare const deleteColumnsWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => (inputMethod: INPUT_METHOD.CONTEXT_MENU | INPUT_METHOD.BUTTON | INPUT_METHOD.FLOATING_TB, rect: Rect) => Command;
+export declare const deleteTableWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => Command;
+export declare const deleteTableIfSelectedWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => (inputMethod: INPUT_METHOD.FLOATING_TB | INPUT_METHOD.KEYBOARD) => Command;
+export declare const toggleHeaderRowWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => Command;
+export declare const toggleHeaderColumnWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => Command;
+export declare const toggleNumberColumnWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => Command;
+export declare const toggleTableLayoutWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => Command;
+export declare const sortColumnWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => (inputMethod: INPUT_METHOD.CONTEXT_MENU, columnIndex: number, sortOrder: SortOrder) => Command;
+export declare const distributeColumnsWidthsWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => (inputMethod: INPUT_METHOD.CONTEXT_MENU, { resizeState, table, attributes }: ResizeStateWithAnalytics) => Command;
+export declare const wrapTableInExpandWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => Command;

package/dist/types/plugins/table/create-plugin-config.d.ts

@@ -0,0 +1,2 @@
+import { PluginConfig } from './types';
+export declare const pluginConfig: (config?: PluginConfig) => PluginConfig;

package/dist/types/plugins/table/event-handlers.d.ts

@@ -0,0 +1,16 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { ElementContentRects } from './types';
+import type { GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+export declare const handleBlur: (view: EditorView, event: Event) => boolean;
+export declare const handleFocus: (view: EditorView, event: Event) => boolean;
+export declare const handleClick: (view: EditorView, event: Event) => boolean;
+export declare const handleMouseOver: (view: EditorView, mouseEvent: Event) => boolean;
+export declare const handleMouseDown: (_: EditorView, event: Event) => boolean;
+export declare const handleMouseOut: (view: EditorView, mouseEvent: Event) => boolean;
+export declare const handleMouseLeave: (view: EditorView, event: Event) => boolean;
+export declare const handleMouseMove: (getEditorFeatureFlags: GetEditorFeatureFlags) => (view: EditorView, event: Event, tableCellOptimization?: boolean | undefined, elementContentRects?: ElementContentRects | undefined) => boolean;
+export declare function handleTripleClick(view: EditorView, pos: number): boolean;
+export declare const handleCut: (oldTr: Transaction, oldState: EditorState, newState: EditorState, editorAnalyticsAPI?: EditorAnalyticsAPI | undefined) => Transaction;
+export declare const whenTableInFocus: (eventHandler: (view: EditorView, mouseEvent: Event, tableCellOptimization?: boolean | undefined, elementContentRects?: ElementContentRects | undefined) => boolean, elementContentRects?: ElementContentRects | undefined) => (view: EditorView, mouseEvent: Event) => boolean;

package/dist/types/plugins/table/handlers.d.ts

@@ -0,0 +1,3 @@
+import { Transaction, ReadonlyTransaction } from 'prosemirror-state';
+import { TablePluginState } from './types';
+export declare const handleDocOrSelectionChanged: (tr: Transaction | ReadonlyTransaction, pluginState: TablePluginState) => TablePluginState;

package/dist/types/plugins/table/index.d.ts

@@ -0,0 +1,18 @@
+import type { EditorPlugin } from '@atlaskit/editor-common/types';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { EditorSelectionAPI } from '@atlaskit/editor-common/selection';
+import { PluginConfig } from './types';
+import type { GetEditorContainerWidth, GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+interface TablePluginOptions {
+    tableOptions: PluginConfig;
+    breakoutEnabled?: boolean;
+    allowContextualMenu?: boolean;
+    fullWidthEnabled?: boolean;
+    wasFullWidthEnabled?: boolean;
+    editorAnalyticsAPI?: EditorAnalyticsAPI;
+    editorSelectionAPI?: EditorSelectionAPI;
+    getEditorContainerWidth?: GetEditorContainerWidth;
+    getEditorFeatureFlags?: GetEditorFeatureFlags;
+}
+declare const tablesPlugin: (options?: TablePluginOptions | undefined) => EditorPlugin;
+export default tablesPlugin;

package/dist/types/plugins/table/nodeviews/OverflowShadowsObserver.d.ts

@@ -0,0 +1,26 @@
+import { ShadowEvent } from '../types';
+export declare class OverflowShadowsObserver {
+    private tableIntersectionObserver?;
+    private updateShadowState;
+    private table;
+    private wrapper;
+    private firstCell;
+    private lastCell;
+    private getFirstCell;
+    private getLastCell;
+    private isSticky;
+    private stickyRowHeight;
+    constructor(updateShadowState: (shadowKey: ShadowEvent, value: boolean) => void, table: HTMLElement, wrapper: HTMLDivElement);
+    private init;
+    private checkIntersectionEvent;
+    private updateStickyShadowsHeightIfChanged;
+    private getStickyCell;
+    observeCells: (isSticky?: boolean | undefined, hasHeaderRow?: boolean | undefined) => void;
+    /**
+     * Takes a heightStyle if it can be computed in a less expensive manner,
+     * e.g. bounds on an IntersectionObserverEntry, otherwise proceed with
+     * reading it from sticky cell
+     */
+    updateStickyShadows: (stickyRowHeight?: number | undefined) => void;
+    dispose(): void;
+}

package/dist/types/plugins/table/nodeviews/TableComponent.d.ts

@@ -0,0 +1,72 @@
+import React from 'react';
+import { Node as PmNode } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import type { EditorContainerWidth } from '@atlaskit/editor-common/types';
+import { RowStickyState, StickyPluginState } from '../pm-plugins/sticky-headers';
+import type { GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+import { ColumnResizingPluginState, ShadowEvent } from '../types';
+import type { TableColumnOrdering } from '@atlaskit/adf-schema/steps';
+import type { TableOptions } from './types';
+import type { EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+export interface ComponentProps {
+    view: EditorView;
+    getNode: () => PmNode;
+    allowColumnResizing?: boolean;
+    eventDispatcher: EventDispatcher;
+    getPos: () => number;
+    options?: TableOptions;
+    contentDOM: (node: HTMLElement | null) => void;
+    containerWidth: EditorContainerWidth;
+    allowControls: boolean;
+    isHeaderRowEnabled: boolean;
+    isHeaderColumnEnabled: boolean;
+    isMediaFullscreen?: boolean;
+    tableActive: boolean;
+    ordering: TableColumnOrdering;
+    tableResizingPluginState?: ColumnResizingPluginState;
+    getEditorFeatureFlags: GetEditorFeatureFlags;
+}
+interface TableState {
+    scroll: number;
+    tableContainerWidth: string;
+    parentWidth?: number;
+    isLoading: boolean;
+    stickyHeader?: RowStickyState;
+    [ShadowEvent.SHOW_BEFORE_SHADOW]: boolean;
+    [ShadowEvent.SHOW_AFTER_SHADOW]: boolean;
+}
+declare class TableComponent extends React.Component<ComponentProps, TableState> {
+    static displayName: string;
+    state: TableState;
+    private wrapper?;
+    private table?;
+    private node;
+    private containerWidth?;
+    private layoutSize?;
+    private overflowShadowsObserver?;
+    constructor(props: ComponentProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: ComponentProps): void;
+    private updateShadows;
+    private updateShadowState;
+    onStickyState: (state: StickyPluginState) => void;
+    prevTableState: any;
+    render(): JSX.Element;
+    private getMarginLeft;
+    private handleScroll;
+    private handleTableResizing;
+    private scaleTable;
+    private handleAutoSize;
+    private handleWindowResize;
+    private updateTableContainerWidth;
+    private getParentNodeWidth;
+    private updateParentWidth;
+    private tableNodeLayoutSize;
+    private scaleTableDebounced;
+    private handleTableResizingDebounced;
+    private handleScrollDebounced;
+    private handleAutoSizeDebounced;
+    private handleWindowResizeDebounced;
+}
+export default TableComponent;

package/dist/types/plugins/table/nodeviews/__mocks__/OverflowShadowsObserver.d.ts

@@ -0,0 +1,9 @@
+import { OverridableMock } from './OverridableMock';
+export declare class OverflowShadowsObserver extends OverridableMock {
+    firstCell: HTMLElement | null;
+    lastCell: HTMLElement | null;
+    constructor(...inputs: any[]);
+    observeCells: any;
+    updateStickyShadows: any;
+    dispose: any;
+}

package/dist/types/plugins/table/nodeviews/__mocks__/OverridableMock.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class OverridableMock {
+    static mockOverrides: {
+        [key: string]: any;
+    };
+    constructor(...inputs: any[]);
+    getMock(key: string): any;
+    static setMock(thisKey: string, value: any): void;
+    static resetMocks(): void;
+}

package/dist/types/plugins/table/nodeviews/table.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="react" />
+import { Node as PmNode } from 'prosemirror-model';
+import { EditorView, NodeView } from 'prosemirror-view';
+import type { EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+import type { getPosHandler, getPosHandlerNode } from '@atlaskit/editor-common/types';
+import ReactNodeView from '@atlaskit/editor-common/react-node-view';
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+import type { GetEditorContainerWidth, GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+import { Props, TableOptions } from './types';
+declare type ForwardRef = (node: HTMLElement | null) => void;
+export default class TableView extends ReactNodeView<Props> {
+    private table;
+    private resizeObserver?;
+    private tableRenderOptimization?;
+    eventDispatcher?: EventDispatcher;
+    getPos: getPosHandlerNode;
+    constructor(props: Props);
+    getContentDOM(): {
+        dom: Node;
+        contentDOM?: Node | null | undefined;
+    };
+    setDomAttrs(node: PmNode): void;
+    getNode: () => PmNode<any>;
+    render(props: Props, forwardRef: ForwardRef): JSX.Element;
+    private hasHoveredRows;
+    viewShouldUpdate(nextNode: PmNode): boolean;
+    ignoreMutation(): boolean;
+    destroy(): void;
+}
+export declare const createTableView: (node: PmNode, view: EditorView, getPos: getPosHandler, portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, options: TableOptions, getEditorContainerWidth: GetEditorContainerWidth, getEditorFeatureFlags: GetEditorFeatureFlags) => NodeView;
+export {};

package/dist/types/plugins/table/nodeviews/tableCell.d.ts

@@ -0,0 +1,19 @@
+import { Node } from 'prosemirror-model';
+import { EditorView, NodeView } from 'prosemirror-view';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { getPosHandler } from '@atlaskit/editor-common/types';
+import type { GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+export default class TableCellNodeView implements NodeView {
+    node: Node;
+    dom: HTMLElement;
+    contentDOM: HTMLElement;
+    getPos: getPosHandler;
+    view: EditorView;
+    providerFactory?: ProviderFactory;
+    observer?: ResizeObserver;
+    mouseMoveOptimization?: boolean;
+    constructor(node: Node, view: EditorView, getPos: any, getEditorFeatureFlags: GetEditorFeatureFlags, observer?: ResizeObserver);
+    private updateNodeView;
+    update(node: Node): boolean;
+    destroy(): void;
+}

package/dist/types/plugins/table/nodeviews/types.d.ts

@@ -0,0 +1,23 @@
+import { Node as PmNode } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import type { GetEditorContainerWidth, GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+import { EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+export declare type TableOptions = {
+    isBreakoutEnabled?: boolean;
+    isFullWidthModeEnabled?: boolean;
+    wasFullWidthModeEnabled?: boolean;
+};
+export interface Props {
+    node: PmNode;
+    view: EditorView;
+    allowColumnResizing?: boolean;
+    cellMinWidth?: number;
+    portalProviderAPI: PortalProviderAPI;
+    eventDispatcher: EventDispatcher;
+    getPos: () => number;
+    options?: TableOptions;
+    tableRenderOptimization?: boolean;
+    getEditorContainerWidth: GetEditorContainerWidth;
+    getEditorFeatureFlags: GetEditorFeatureFlags;
+}

package/dist/types/plugins/table/nodeviews/update-overflow-shadows.d.ts

@@ -0,0 +1,8 @@
+import { EditorState } from 'prosemirror-state';
+import type { GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+export declare const updateShadowListForStickyStyles: (heightStyle: string, shadows: HTMLCollection) => void;
+/**
+ * Update overflow shadows for a given wrapper & table.
+ * if `overflowShadowOptimization` is enabled, this will exit early.
+ */
+export declare const updateOverflowShadows: (getEditorFeatureFlags: GetEditorFeatureFlags) => (editorState: EditorState, wrapper?: HTMLElement | null | undefined, table?: HTMLElement | null | undefined, rightShadows?: NodeListOf<HTMLElement> | null | undefined, leftShadows?: NodeListOf<HTMLElement> | null | undefined) => false | undefined;

package/dist/types/plugins/table/pm-plugins/decorations/plugin.d.ts

@@ -0,0 +1,7 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { EditorState, PluginKey, Transaction, ReadonlyTransaction } from 'prosemirror-state';
+import { DecorationSet } from 'prosemirror-view';
+export declare const pluginKey: PluginKey<any, any>;
+export declare const getDecorations: (state: EditorState) => DecorationSet;
+export declare const handleDocOrSelectionChanged: (tr: Transaction | ReadonlyTransaction, decorationSet: DecorationSet, oldState: EditorState) => DecorationSet;
+export declare const createPlugin: () => SafePlugin<any, any>;

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

@@ -0,0 +1,3 @@
+import { DecorationTransformer } from './types';
+export declare const maybeUpdateColumnControlsSelectedDecoration: DecorationTransformer;
+export declare const buildColumnControlsDecorations: DecorationTransformer;

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

@@ -0,0 +1,2 @@
+import { DecorationTransformer } from './types';
+export declare const buildColumnResizingDecorations: (columnEndIndex: number) => DecorationTransformer;

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

@@ -0,0 +1,2 @@
+import { DecorationTransformer } from './types';
+export declare const composeDecorations: (transformers: Array<DecorationTransformer>) => DecorationTransformer;

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

@@ -0,0 +1,3 @@
+export { buildColumnControlsDecorations, maybeUpdateColumnControlsSelectedDecoration, } from './column-controls';
+export { buildColumnResizingDecorations } from './column-resizing';
+export { composeDecorations } from './compose-decorations';

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

@@ -0,0 +1,6 @@
+import { ReadonlyTransaction, Transaction } from 'prosemirror-state';
+import { DecorationSet } from 'prosemirror-view';
+export declare type DecorationTransformer = ({ decorationSet, tr, }: {
+    decorationSet: DecorationSet;
+    tr: Transaction | ReadonlyTransaction;
+}) => DecorationSet;

package/dist/types/plugins/table/pm-plugins/default-table-selection.d.ts

@@ -0,0 +1,5 @@
+export declare const defaultTableSelection: {
+    hoveredColumns: never[];
+    hoveredRows: never[];
+    isInDanger: boolean;
+};

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

@@ -0,0 +1,5 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { GetEditorContainerWidth } from '@atlaskit/editor-common/types';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+export declare function keymapPlugin(getEditorContainerWidth: GetEditorContainerWidth, editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null): SafePlugin;
+export default keymapPlugin;

package/dist/types/plugins/table/pm-plugins/main.d.ts

@@ -0,0 +1,8 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { Dispatch, EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+import type { PortalProviderAPI } from '@atlaskit/editor-common/portal-provider';
+import { PluginConfig } from '../types';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { GetEditorContainerWidth, GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+export declare const createPlugin: (dispatchAnalyticsEvent: DispatchAnalyticsEvent, dispatch: Dispatch, portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, pluginConfig: PluginConfig, getEditorContainerWidth: GetEditorContainerWidth, getEditorFeatureFlags: GetEditorFeatureFlags, breakoutEnabled?: boolean | undefined, fullWidthModeEnabled?: boolean | undefined, previousFullWidthModeEnabled?: boolean | undefined, editorAnalyticsAPI?: EditorAnalyticsAPI | undefined) => SafePlugin<import("../types").TablePluginState, import("prosemirror-model").Schema<any, any>>;

package/dist/types/plugins/table/pm-plugins/plugin-factory.d.ts

@@ -0,0 +1 @@
+export declare const createPluginState: (dispatch: import("@atlaskit/editor-common/event-dispatcher").Dispatch<any>, initialState: import("../types").TablePluginState | ((state: import("prosemirror-state").EditorState<any>) => import("../types").TablePluginState)) => import("prosemirror-state").SafeStateField<import("../types").TablePluginState, import("prosemirror-model").Schema<any, any>>, createCommand: <A = import("../types").TablePluginAction>(action: A | ((state: Readonly<import("prosemirror-state").EditorState<any>>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction<any>, state: import("prosemirror-state").EditorState<any>) => import("prosemirror-state").Transaction<any>) | undefined) => import("@atlaskit/editor-common/types").Command, getPluginState: (state: import("prosemirror-state").EditorState<any>) => import("../types").TablePluginState;

package/dist/types/plugins/table/pm-plugins/plugin-key.d.ts

@@ -0,0 +1,3 @@
+import { PluginKey } from 'prosemirror-state';
+import { TablePluginState } from '../types';
+export declare const pluginKey: PluginKey<TablePluginState, any>;

package/dist/types/plugins/table/pm-plugins/safari-delayed-dom-selection-syncing-workaround.d.ts

@@ -0,0 +1,4 @@
+import { PluginKey } from 'prosemirror-state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export declare const tableSafariDelayedDomSelectionSyncingWorkaroundKey: PluginKey<any, any>;
+export declare const createPlugin: () => SafePlugin<any, any>;

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

@@ -0,0 +1,15 @@
+/**
+ * Fix an issue that composition text replacement in Safari removes empty nodes during text composition text deletion.
+ * https://github.com/ProseMirror/prosemirror/issues/934
+ * We will remove this plugin when Webkit fix the problem itself.
+ */
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import { DecorationSet } from 'prosemirror-view';
+interface SafariDeleteCompositionTextIssueWorkaroundPluginState {
+    renderSpan: boolean;
+    decorations: DecorationSet;
+}
+export declare const tableSafariDeleteCompositionTextIssueWorkaroundKey: PluginKey<SafariDeleteCompositionTextIssueWorkaroundPluginState, any>;
+export declare const createPlugin: () => SafePlugin<SafariDeleteCompositionTextIssueWorkaroundPluginState, any>;
+export {};

package/dist/types/plugins/table/pm-plugins/sticky-headers/commands.d.ts

@@ -0,0 +1,3 @@
+import { RowStickyState } from './types';
+export declare const updateStickyState: (rowState: RowStickyState) => import("@atlaskit/editor-common/types").Command;
+export declare const removeStickyState: (pos: number) => import("@atlaskit/editor-common/types").Command;

package/dist/types/plugins/table/pm-plugins/sticky-headers/index.d.ts

@@ -0,0 +1,6 @@
+export { createPlugin } from './plugin';
+export { pluginKey } from './plugin-key';
+export type { StickyPluginState, RowStickyState } from './types';
+export { findStickyHeaderForTable } from './util';
+export { updateStickyState, removeStickyState } from './commands';
+export { TableRowNodeView } from './nodeviews/tableRow';

package/dist/types/plugins/table/pm-plugins/sticky-headers/nodeviews/dom.d.ts

@@ -0,0 +1,6 @@
+export declare type TableDOMElements = {
+    wrapper: HTMLDivElement;
+    table: HTMLTableElement;
+};
+export declare const getTree: (tr: HTMLTableRowElement) => TableDOMElements | null;
+export declare const getTop: (element: HTMLElement | Window | undefined) => number;

package/dist/types/plugins/table/pm-plugins/sticky-headers/nodeviews/tableRow.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="lodash" />
+import { Node as PmNode } from 'prosemirror-model';
+import { EditorView, NodeView } from 'prosemirror-view';
+import { EventDispatcher } from '@atlaskit/editor-common/event-dispatcher';
+import { TablePluginState } from '../../../types';
+import { TableDOMElements } from './dom';
+import type { GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+export declare const supportedHeaderRow: (node: PmNode) => boolean;
+export declare class TableRowNodeView implements NodeView {
+    view: EditorView;
+    node: PmNode;
+    getPos: () => number;
+    eventDispatcher: EventDispatcher;
+    dom: HTMLTableRowElement;
+    contentDOM: HTMLElement;
+    isHeaderRow: boolean;
+    editorScrollableElement?: HTMLElement | Window;
+    colControlsOffset: number;
+    focused: boolean;
+    topPosEditorElement: number;
+    isSticky: boolean;
+    isTableInit: boolean;
+    lastTimePainted: number;
+    private intersectionObserver?;
+    private resizeObserver?;
+    private stickyHeadersOptimization;
+    private sentinels;
+    private stickyRowHeight?;
+    get tree(): TableDOMElements | null | undefined;
+    constructor(node: PmNode, view: EditorView, getPos: any, eventDispatcher: EventDispatcher, getEditorFeatureFlags: GetEditorFeatureFlags);
+    listening: boolean;
+    headerRowMouseScrollEnd: import("lodash").DebouncedFunc<() => void>;
+    headerRowMouseScroll: import("lodash").DebouncedFunc<() => void>;
+    subscribe(): void;
+    unsubscribe(): void;
+    private initObservers;
+    private createResizeObserver;
+    private createIntersectionObserver;
+    previousDomTop: number | undefined;
+    previousPadding: number | undefined;
+    latestDomTop: number | undefined;
+    nextFrame: number | undefined;
+    onScroll: () => void;
+    loop: () => void;
+    paint: (tree: TableDOMElements) => void;
+    update(node: PmNode, ..._args: any[]): boolean;
+    destroy(): void;
+    ignoreMutation(mutationRecord: MutationRecord | {
+        type: 'selection';
+        target: Element;
+    }): boolean;
+    onTablePluginState: (state: TablePluginState) => void;
+    onWidthPluginState: () => void;
+    shouldHeaderStick: (tree: TableDOMElements) => boolean;
+    makeHeaderRowSticky: (tree: TableDOMElements) => void;
+    makeRowHeaderNotSticky: (table: HTMLElement, isEditorDestroyed?: boolean) => void;
+    getWrapperoffset: (inverse?: boolean) => number;
+    getWrapperRefTop: (wrapper: HTMLElement) => number;
+    getScrolledTableTop: (wrapper: HTMLElement) => number;
+    getCurrentTableTop: (tree: TableDOMElements) => number;
+    padding: number;
+    top: number;
+    emitOn: (top: number, padding: number) => void;
+    emitOff: (isEditorDestroyed: boolean) => void;
+}

package/dist/types/plugins/table/pm-plugins/sticky-headers/plugin-key.d.ts

@@ -0,0 +1,3 @@
+import { PluginKey } from 'prosemirror-state';
+import { StickyPluginState } from './types';
+export declare const pluginKey: PluginKey<StickyPluginState, any>;

package/dist/types/plugins/table/pm-plugins/sticky-headers/plugin-state.d.ts

@@ -0,0 +1,3 @@
+import { StickyPluginAction, StickyPluginState } from './types';
+declare const createPluginState: (dispatch: import("@atlaskit/editor-common/event-dispatcher").Dispatch<any>, initialState: StickyPluginState | ((state: import("prosemirror-state").EditorState<any>) => StickyPluginState)) => import("prosemirror-state").SafeStateField<StickyPluginState, import("prosemirror-model").Schema<any, any>>, createCommand: <A = StickyPluginAction>(action: A | ((state: Readonly<import("prosemirror-state").EditorState<any>>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction<any>, state: import("prosemirror-state").EditorState<any>) => import("prosemirror-state").Transaction<any>) | undefined) => import("@atlaskit/editor-common/types").Command;
+export { createPluginState, createCommand };

package/dist/types/plugins/table/pm-plugins/sticky-headers/plugin.d.ts

@@ -0,0 +1,4 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+import { EventDispatcher, Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+export declare const createPlugin: (dispatch: Dispatch, eventDispatcher: EventDispatcher, initialState: (() => never[]) | undefined, getEditorFeatureFlags: GetEditorFeatureFlags) => SafePlugin<import("./types").StickyPluginState, import("prosemirror-model").Schema<any, any>>;

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

@@ -0,0 +1,16 @@
+export declare type RowStickyState = {
+    pos: number;
+    top: number;
+    padding: number;
+    sticky: boolean;
+};
+export declare type StickyPluginState = RowStickyState[];
+export declare type UpdateSticky = {
+    name: 'UPDATE';
+    state: RowStickyState;
+};
+export declare type RemoveSticky = {
+    name: 'REMOVE';
+    pos: number;
+};
+export declare type StickyPluginAction = UpdateSticky | RemoveSticky;

package/dist/types/plugins/table/pm-plugins/sticky-headers/util.d.ts

@@ -0,0 +1,2 @@
+import { StickyPluginState } from './types';
+export declare const findStickyHeaderForTable: (state: StickyPluginState, tablePos: number | undefined) => import("./types").RowStickyState | undefined;

package/dist/types/plugins/table/pm-plugins/table-local-id.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A plugin for ensuring tables always have unique local IDs, and to
+ * preserve/not regenerate them when they are being cut and paste around the
+ * document.
+ *
+ * More broadly, this plugin should be generalised so it can solve this ‘unique
+ * id’ problem across the codebase for any node, but for now this will live on
+ * its own solving only for tables.
+ *
+ * TODO: https://product-fabric.atlassian.net/browse/ED-12714
+ *
+ */
+import { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+interface TableLocalIdPluginState {
+    parsedForLocalIds: boolean;
+}
+/**
+ * Ensures uniqueness of `localId`s on tables being created or edited
+ */
+declare const createPlugin: (dispatch: Dispatch) => SafePlugin<TableLocalIdPluginState, any>;
+export { createPlugin };

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

@@ -0,0 +1,25 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+import type { Command } from '@atlaskit/editor-common/types';
+import type { DomAtPos } from 'prosemirror-utils';
+import { ResizeState, ScaleOptions } from './utils';
+import { ContentNodeWithPos } from 'prosemirror-utils';
+export declare const scaleTable: (tableRef: HTMLTableElement | null | undefined, options: ScaleOptions, domAtPos: DomAtPos) => Command;
+export declare const evenColumns: ({ resizeState, table, start, event, }: {
+    resizeState: ResizeState;
+    table: PMNode;
+    start: number;
+    event: MouseEvent;
+}) => Command;
+export declare const distributeColumnsWidths: (newResizeState: ResizeState, table: ContentNodeWithPos) => Command;
+export declare const setResizeHandlePos: (resizeHandlePos: number | null) => Command;
+export declare const stopResizing: (tr?: Transaction<any> | undefined) => Command;
+export declare const setDragging: (dragging: {
+    startX: number;
+    startWidth: number;
+} | null, tr?: Transaction<any> | undefined) => Command;
+export declare const setLastClick: (lastClick: {
+    x: number;
+    y: number;
+    time: number;
+} | null, transform?: ((tr: Transaction) => Transaction) | undefined) => Command;

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

@@ -0,0 +1,4 @@
+import { EditorView } from 'prosemirror-view';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { GetEditorContainerWidth, GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+export declare const handleMouseDown: (view: EditorView, event: MouseEvent, localResizeHandlePos: number, getEditorContainerWidth: GetEditorContainerWidth, getEditorFeatureFlags: GetEditorFeatureFlags, editorAnalyticsAPI?: EditorAnalyticsAPI | undefined) => boolean;

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

@@ -0,0 +1,3 @@
+export { createPlugin } from './plugin';
+export { scaleTable } from './commands';
+export { pluginKey } from './plugin-key';

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

@@ -0,0 +1,4 @@
+import { ColumnResizingPluginState } from '../../types';
+export declare const createCommand: <A = import("../../types").ColumnResizingPluginAction>(action: A | ((state: Readonly<import("prosemirror-state").EditorState<any>>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction<any>, state: import("prosemirror-state").EditorState<any>) => import("prosemirror-state").Transaction<any>) | undefined) => import("@atlaskit/editor-common/types").Command;
+export declare const createPluginState: (dispatch: import("@atlaskit/editor-common/event-dispatcher").Dispatch<any>, initialState: ColumnResizingPluginState | ((state: import("prosemirror-state").EditorState<any>) => ColumnResizingPluginState)) => import("prosemirror-state").SafeStateField<ColumnResizingPluginState, import("prosemirror-model").Schema<any, any>>;
+export declare const getPluginState: (state: import("prosemirror-state").EditorState<any>) => ColumnResizingPluginState;

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

@@ -0,0 +1,3 @@
+import { PluginKey } from 'prosemirror-state';
+import { ColumnResizingPluginState } from '../../types';
+export declare const pluginKey: PluginKey<ColumnResizingPluginState, any>;

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

@@ -0,0 +1,6 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { Dispatch } from '@atlaskit/editor-common/event-dispatcher';
+import { ColumnResizingPluginState } from '../../types';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { GetEditorContainerWidth, GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+export declare function createPlugin(dispatch: Dispatch<ColumnResizingPluginState>, { lastColumnResizable }: ColumnResizingPluginState, getEditorContainerWidth: GetEditorContainerWidth, getEditorFeatureFlags: GetEditorFeatureFlags, editorAnalyticsAPI?: EditorAnalyticsAPI): SafePlugin<ColumnResizingPluginState, import("prosemirror-model").Schema<any, any>>;

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

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

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

@@ -0,0 +1,8 @@
+import { Node as PmNode } from 'prosemirror-model';
+declare type Col = Array<string | {
+    [name: string]: string;
+}>;
+export declare const generateColgroup: (table: PmNode) => Col[];
+export declare const insertColgroupFromNode: (tableRef: HTMLTableElement, table: PmNode) => HTMLCollection;
+export declare const hasTableBeenResized: (table: PmNode) => boolean;
+export {};

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

@@ -0,0 +1,14 @@
+import { Node as PMNode } from 'prosemirror-model';
+export interface ColumnState {
+    index: number;
+    width: number;
+    minWidth: number;
+}
+export declare const getColumnStateFromDOM: (cells: HTMLElement[], index: number, minWidth: number) => ColumnState;
+export declare const getFreeSpace: (state: ColumnState) => number;
+export declare const getCellsRefsInColumn: (columnIndex: number, table: PMNode, tableStart: number, domAtPos: (pos: number) => {
+    node: Node;
+    offset: number;
+}) => HTMLElement[];
+export declare const calculateColumnWidth: (cells: HTMLElement[], calculateColumnWidthCb: (css: CSSStyleDeclaration, cellRef: HTMLElement, colSpan: number) => number) => number;
+export declare const addContainerLeftRightPadding: (amount: number, css: CSSStyleDeclaration) => number;