@atlaskit/editor-plugin-table 5.0.0 → 5.2.0

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

@@ -0,0 +1,87 @@
+/** @jsx jsx */
+import { Component } from 'react';
+import { jsx } from '@emotion/react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { GetEditorContainerWidth } from '@atlaskit/editor-common/types';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { Rect } from '@atlaskit/editor-tables/table-map';
+export declare const messages: {
+    cellBackground: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    mergeCells: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    splitCell: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    clearCells: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    sortColumnASC: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    sortColumnDESC: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    canNotSortTable: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    distributeColumns: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export interface Props {
+    editorView: EditorView;
+    isOpen: boolean;
+    selectionRect: Rect;
+    targetCellPosition?: number;
+    mountPoint?: HTMLElement;
+    allowMergeCells?: boolean;
+    allowColumnSorting?: boolean;
+    allowBackgroundColor?: boolean;
+    boundariesElement?: HTMLElement;
+    offset?: Array<number>;
+    editorAnalyticsAPI?: EditorAnalyticsAPI;
+    getEditorContainerWidth: GetEditorContainerWidth;
+}
+export interface State {
+    isSubmenuOpen: boolean;
+}
+export declare class ContextualMenu extends Component<Props & WrappedComponentProps, State> {
+    state: State;
+    static defaultProps: {
+        boundariesElement: HTMLElement | undefined;
+    };
+    render(): jsx.JSX.Element | null;
+    private handleSubMenuRef;
+    private createItems;
+    private onMenuItemActivated;
+    private toggleOpen;
+    private handleOpenChange;
+    private handleItemMouseEnter;
+    private handleItemMouseLeave;
+    private closeSubmenu;
+    private setColor;
+}
+declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: import("react").ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,23 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { GetEditorContainerWidth, GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { PluginConfig } from '../../types';
+export interface Props {
+    editorView: EditorView;
+    isOpen: boolean;
+    getEditorContainerWidth: GetEditorContainerWidth;
+    getEditorFeatureFlags?: GetEditorFeatureFlags;
+    targetCellPosition?: number;
+    mountPoint?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    pluginConfig?: PluginConfig;
+    editorAnalyticsAPI?: EditorAnalyticsAPI;
+}
+declare const FloatingContextualMenu: {
+    ({ mountPoint, boundariesElement, scrollableElement, editorView, isOpen, pluginConfig, editorAnalyticsAPI, getEditorContainerWidth, }: Props): jsx.JSX.Element | null;
+    displayName: string;
+};
+export default FloatingContextualMenu;

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

@@ -0,0 +1,2 @@
+export declare const cellColourPreviewStyles: (selectedColor: string) => import("@emotion/react").SerializedStyles;
+export declare const tablePopupStyles: import("@emotion/react").SerializedStyles;

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

@@ -0,0 +1,13 @@
+import React, { SyntheticEvent } from 'react';
+import { MessageDescriptor, WrappedComponentProps } from 'react-intl-next';
+export interface ButtonProps {
+    removeLabel: MessageDescriptor;
+    style?: object;
+    onClick?: (event: SyntheticEvent) => void;
+    onMouseEnter?: (event: SyntheticEvent) => void;
+    onMouseLeave?: (event: SyntheticEvent) => void;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<ButtonProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<ButtonProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,10 @@
+import type { PopupProps } from '@atlaskit/editor-common/ui';
+import { CellSelectionType } from './types';
+interface GetPopupOptions {
+    left: number;
+    top: number;
+    selectionType?: CellSelectionType;
+    tableWrapper: HTMLElement | null;
+}
+export default function getPopupOptions({ left, top, selectionType, tableWrapper, }: GetPopupOptions): Partial<PopupProps>;
+export {};

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

@@ -0,0 +1,54 @@
+import { Component } from 'react';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import type { Selection } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { RowStickyState } from '../../pm-plugins/sticky-headers';
+import type { CellSelectionType } from './types';
+export interface Props {
+    editorView: EditorView;
+    selection: Selection;
+    tableRef?: HTMLTableElement;
+    mountPoint?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    stickyHeaders?: RowStickyState;
+    isNumberColumnEnabled?: boolean;
+    editorAnalyticsAPI?: EditorAnalyticsAPI;
+}
+export interface State {
+    selectionType?: CellSelectionType;
+    left: number;
+    top: number;
+    indexes: number[];
+    position?: string;
+    scrollLeft: number;
+}
+export declare function getSelectionType(selection: Selection): 'column' | 'row' | undefined;
+declare class FloatingDeleteButton extends Component<Props, State> {
+    static displayName: string;
+    wrapper: HTMLElement | null;
+    constructor(props: Props);
+    shouldComponentUpdate(_: Props, nextState: State): boolean;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    updateWrapper: () => void;
+    componentWillUnmount(): void;
+    onWrapperScrolled: (e: Event) => void;
+    /**
+     * We derivate the button state from the properties passed.
+     * We do this in here because we need this information in different places
+     * and this prevent to do multiple width calculations in the same component.
+     */
+    static getDerivedStateFromProps(nextProps: Readonly<Props>, prevState: State): Partial<State> | null;
+    private handleMouseEnter;
+    private handleMouseLeave;
+    /**
+     *
+     *
+     * @private
+     * @memberof FloatingDeleteButton
+     */
+    private handleClick;
+    render(): JSX.Element | null;
+}
+export default FloatingDeleteButton;

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

@@ -0,0 +1 @@
+export type CellSelectionType = 'column' | 'row' | undefined;

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

@@ -0,0 +1,13 @@
+import type { SyntheticEvent } from 'react';
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+export interface ButtonProps {
+    type: 'row' | 'column';
+    tableRef: HTMLElement;
+    onMouseDown: (event: SyntheticEvent<HTMLButtonElement>) => void;
+    hasStickyHeaders: boolean;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<ButtonProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<ButtonProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,3 @@
+import type { PopupProps } from '@atlaskit/editor-common/ui';
+declare function getPopupOptions(type: 'column' | 'row', index: number, hasNumberedColumns: boolean, tableContainer: HTMLElement | null): Partial<PopupProps>;
+export default getPopupOptions;

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

@@ -0,0 +1,35 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+import type { GetEditorContainerWidth } from '@atlaskit/editor-common/types';
+import { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+export interface Props {
+    editorView: EditorView;
+    getEditorContainerWidth: GetEditorContainerWidth;
+    tableRef?: HTMLElement;
+    tableNode?: PmNode;
+    insertColumnButtonIndex?: number;
+    insertRowButtonIndex?: number;
+    isHeaderColumnEnabled?: boolean;
+    isHeaderRowEnabled?: boolean;
+    mountPoint?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    hasStickyHeaders?: boolean;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    editorAnalyticsAPI?: EditorAnalyticsAPI;
+}
+export declare class FloatingInsertButton extends React.Component<Props & WrappedComponentProps, any> {
+    static displayName: string;
+    constructor(props: Props & WrappedComponentProps);
+    render(): JSX.Element | null;
+    private getCellPosition;
+    private insertRow;
+    private insertColumn;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,21 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { TableLayout } from '@atlaskit/adf-schema';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+import { RowStickyState } from '../../pm-plugins/sticky-headers';
+export interface Props {
+    editorView: EditorView;
+    targetRef?: HTMLElement;
+    mountPoint?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    isResizing?: boolean;
+    layout?: TableLayout;
+    stickyHeader?: RowStickyState;
+    editorAnalyticsAPI?: EditorAnalyticsAPI;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+export interface Props {
+    editorView: EditorView;
+    tableRef?: HTMLTableElement;
+    isInDanger?: boolean;
+    isResizing?: boolean;
+    hoveredRows?: number[];
+    isHeaderColumnEnabled?: boolean;
+    isHeaderRowEnabled?: boolean;
+    stickyTop?: number;
+}
+export declare const CornerControls: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};

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

@@ -0,0 +1,21 @@
+import { Component } from 'react';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+export interface Props {
+    editorView: EditorView;
+    tableRef: HTMLTableElement;
+    tableActive?: boolean;
+    hoverRows: (rows: number[], danger?: boolean) => void;
+    hoveredRows?: number[];
+    selectRow: (row: number, expand: boolean) => void;
+    hasHeaderRow?: boolean;
+    isInDanger?: boolean;
+    isResizing?: boolean;
+    stickyTop?: number;
+}
+export default class NumberColumn extends Component<Props, any> {
+    render(): JSX.Element;
+    private hoverRows;
+    private selectRow;
+    private clearHoverSelection;
+    private getClassNames;
+}

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+export interface Props {
+    editorView: EditorView;
+    tableRef: HTMLTableElement;
+    selectRow: (row: number, expand: boolean) => void;
+    hoverRows: (rows: number[], danger?: boolean) => void;
+    hoveredRows?: number[];
+    isInDanger?: boolean;
+    isResizing?: boolean;
+    insertRowButtonIndex?: number;
+    stickyTop?: number;
+}
+export declare const RowControls: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};

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

@@ -0,0 +1,39 @@
+import { Component } from 'react';
+import type { TableColumnOrdering } from '@atlaskit/custom-steps';
+import type { GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+import type { Selection } from '@atlaskit/editor-prosemirror/state';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { RowStickyState } from '../../pm-plugins/sticky-headers';
+export interface Props {
+    editorView: EditorView;
+    getEditorFeatureFlags: GetEditorFeatureFlags;
+    selection?: Selection;
+    tableRef?: HTMLTableElement;
+    tableActive?: boolean;
+    isInDanger?: boolean;
+    isResizing?: boolean;
+    isHeaderRowEnabled?: boolean;
+    isHeaderColumnEnabled?: boolean;
+    isNumberColumnEnabled?: boolean;
+    hasHeaderRow?: boolean;
+    headerRowHeight?: number;
+    hoveredRows?: number[];
+    ordering?: TableColumnOrdering;
+    stickyHeader?: RowStickyState;
+}
+interface State {
+    tableHeight: number;
+}
+export default class TableFloatingControls extends Component<Props, State> {
+    static displayName: string;
+    private resizeObserver?;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    private tryInitResizeObserver;
+    shouldComponentUpdate(nextProps: Props, nextState: State): boolean;
+    componentWillUnmount(): void;
+    render(): JSX.Element | null;
+    private selectRow;
+    private hoverRows;
+}
+export {};

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

@@ -0,0 +1,9 @@
+import type { FeatureFlags } from '@atlaskit/editor-common/types';
+import type { ThemeProps } from '@atlaskit/theme/types';
+export declare const insertColumnButtonOffset: number;
+export declare const tableRowHeight = 44;
+export declare const tableStyles: (props: ThemeProps & {
+    featureFlags?: FeatureFlags;
+}) => import("@emotion/react").SerializedStyles;
+export declare const tableFullPageEditorStyles: import("@emotion/react").SerializedStyles;
+export declare const tableCommentEditorStyles: import("@emotion/react").SerializedStyles;

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

@@ -0,0 +1,50 @@
+/**
+ * Basic colors added to prevent content overflow in table cells.
+ */
+export declare const tableCellBackgroundColor: import("@atlaskit/theme").ThemedValue<"var(--ds-surface)">;
+export declare const tableHeaderCellBackgroundColor: import("@atlaskit/theme").ThemedValue<"var(--ds-background-accent-gray-subtlest)">;
+export declare const tableToolbarColor: import("@atlaskit/theme").ThemedValue<"var(--ds-background-neutral-subtle)">;
+export declare const tableTextColor: import("@atlaskit/theme").ThemedValue<"var(--ds-text-subtlest)">;
+export declare const tableBorderColor: import("@atlaskit/theme").ThemedValue<"var(--ds-background-accent-gray-subtler)">;
+export declare const tableFloatingControlsColor: "var(--ds-background-neutral)";
+export declare const tableCellSelectedColor: import("@atlaskit/theme").ThemedValue<"var(--ds-blanket-selected)">;
+export declare const tableToolbarSelectedColor: import("@atlaskit/theme").ThemedValue<"var(--ds-background-selected-pressed)">;
+export declare const tableBorderSelectedColor: import("@atlaskit/theme").ThemedValue<"var(--ds-border-focused)">;
+export declare const tableCellSelectedDeleteIconColor: import("@atlaskit/theme").ThemedValue<"var(--ds-icon-subtle)">;
+export declare const tableCellSelectedDeleteIconBackground: import("@atlaskit/theme").ThemedValue<"var(--ds-background-accent-gray-subtlest)">;
+export declare const tableCellDeleteColor: import("@atlaskit/theme").ThemedValue<"var(--ds-blanket-danger)">;
+export declare const tableBorderDeleteColor: import("@atlaskit/theme").ThemedValue<"var(--ds-border-danger)">;
+export declare const tableToolbarDeleteColor: import("@atlaskit/theme").ThemedValue<"var(--ds-background-danger-pressed)">;
+export declare const tableCellHoverDeleteIconColor: import("@atlaskit/theme").ThemedValue<"var(--ds-icon-inverse)">;
+export declare const tableCellHoverDeleteIconBackground: import("@atlaskit/theme").ThemedValue<"var(--ds-background-danger-bold)">;
+export declare const tableBorderRadiusSize = 3;
+export declare const tablePadding = 8;
+export declare const tableScrollbarOffset = 15;
+export declare const tableMarginFullWidthMode = 2;
+export declare const tableInsertColumnButtonSize = 20;
+export declare const tableDeleteButtonSize = 16;
+export declare const tableDeleteButtonOffset = 6;
+export declare const tableToolbarSize = 11;
+export declare const tableControlsSpacing: number;
+export declare const tableInsertColumnButtonOffset = 3;
+export declare const layoutButtonSize = 32;
+export declare const lineMarkerOffsetFromColumnControls = 13;
+export declare const lineMarkerSize = 4;
+export declare const columnControlsDecorationHeight = 25;
+export declare const columnControlsZIndex: number;
+export declare const columnControlsSelectedZIndex: number;
+export declare const columnResizeHandleZIndex: number;
+export declare const resizeHandlerAreaWidth: number;
+export declare const resizeLineWidth = 2;
+export declare const resizeHandlerZIndex: number;
+export declare const contextualMenuTriggerSize = 16;
+export declare const contextualMenuDropdownWidth = 180;
+export declare const stickyRowZIndex: number;
+export declare const stickyRowOffsetTop = 8;
+export declare const stickyHeaderBorderBottomWidth = 1;
+export declare const tableOverflowShadowWidth = 8;
+export declare const tableOverflowShadowWidthWide = 32;
+export declare const TABLE_SNAP_GAP = 9;
+export declare const TABLE_HIGHLIGHT_GAP = 10;
+export declare const TABLE_HIGHLIGHT_TOLERANCE = 2;
+export declare const STICKY_HEADER_TOGGLE_TOLERANCE_MS = 5;

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

@@ -0,0 +1,63 @@
+declare const _default: {
+    insertColumn: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    removeColumns: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    insertRow: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    removeRows: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    cellOptions: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    confirmDeleteLinkedModalOKButton: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    confirmDeleteLinkedModalMessage: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    confirmDeleteLinkedModalMessagePrefix: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    confirmModalCheckboxLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    deleteElementTitle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    unnamedSource: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    adjustColumns: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export default _default;

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

@@ -0,0 +1,15 @@
+import type { ThemeProps } from '@atlaskit/theme/types';
+export declare const InsertMarker: (props: ThemeProps, cssString?: string) => import("@emotion/react").SerializedStyles;
+export declare const HeaderButton: (props: ThemeProps, cssString?: string) => import("@emotion/react").SerializedStyles;
+export declare const HeaderButtonHover: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
+export declare const HeaderButtonDanger: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
+export declare const insertColumnButtonWrapper: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
+export declare const insertRowButtonWrapper: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
+export declare const columnControlsLineMarker: () => import("@emotion/react").SerializedStyles;
+export declare const DeleteButton: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
+export declare const OverflowShadow: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
+export declare const columnControlsDecoration: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
+export declare const hoveredDeleteButton: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
+export declare const hoveredCell: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
+export declare const hoveredWarningCell: import("@emotion/react").SerializedStyles;
+export declare const resizeHandle: (props: ThemeProps) => import("@emotion/react").SerializedStyles;

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

@@ -0,0 +1,45 @@
+import type { AnalyticsEventPayload, AnalyticsEventPayloadCallback, EditorAnalyticsAPI, TableEventPayload } from '@atlaskit/editor-common/analytics';
+import { HigherOrderCommand } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+export declare function getSelectedTableInfo(selection: Selection): {
+    table: import("prosemirror-utils").ContentNodeWithPos | undefined;
+    map: TableMap | undefined;
+    totalRowCount: number;
+    totalColumnCount: number;
+};
+export declare function getSelectedCellInfo(selection: Selection): {
+    totalRowCount: number;
+    totalColumnCount: number;
+    horizontalCells: number;
+    verticalCells: number;
+    totalCells: number;
+};
+export declare const withEditorAnalyticsAPI: (payload: AnalyticsEventPayload | AnalyticsEventPayloadCallback) => (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => HigherOrderCommand;
+interface UseMeasureFramerateConfig {
+    maxSamples?: number;
+    minFrames?: number;
+    minTimeMs?: number;
+    sampleRateMs?: number;
+    timeoutMs?: number;
+}
+export declare const generateResizedPayload: (props: {
+    originalNode: PMNode;
+    resizedNode: PMNode;
+}) => TableEventPayload;
+export declare const reduceResizeFrameRateSamples: (frameRateSamples: number[]) => number[];
+export declare const generateResizeFrameRatePayloads: (props: {
+    docSize: number;
+    frameRateSamples: number[];
+    originalNode: PMNode;
+}) => TableEventPayload[];
+/**
+ * Measures the framerate of a component over a given time period.
+ */
+export declare const useMeasureFramerate: (config?: UseMeasureFramerateConfig) => {
+    startMeasure: () => void;
+    endMeasure: () => number[];
+    countFrames: () => void;
+};
+export {};

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

@@ -0,0 +1,29 @@
+import { NodeRange, NodeType } from '@atlaskit/editor-prosemirror/model';
+import { ReadonlyTransaction, Transaction } from '@atlaskit/editor-prosemirror/state';
+interface IsTableCollapsibleResult {
+    tableIsCollapsible: boolean;
+    range?: NodeRange;
+    findWrappingRes?: Array<{
+        type: NodeType;
+        attrs?: {
+            [key: string]: any;
+        } | null;
+    }> | null | undefined;
+}
+/**
+ * Checks whether we can wrap the selected table into an expand via
+ * prosemirror-transform's `findWrapping` helper
+ */
+export declare const isTableCollapsible: (tr: Transaction | ReadonlyTransaction) => IsTableCollapsibleResult;
+/**
+ * Collapses the selected table into an expand given a transaction via
+ * `Transform.wrap`.
+ *
+ * Will return undefined if it cannot determine the relevant table from a
+ * selection, or if the table itself isn't collapsible.
+ *
+ * @param tr
+ * @returns Transaction | undefined
+ */
+export declare const collapseSelectedTable: (tr: Transaction) => Transaction | undefined;
+export {};

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

@@ -0,0 +1,10 @@
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+export declare const getColumnsWidths: (view: EditorView) => Array<number | undefined>;
+export declare const isColumnDeleteButtonVisible: (selection: Selection) => boolean;
+export declare const getColumnDeleteButtonParams: (columnsWidths: Array<number | undefined>, selection: Selection) => {
+    left: number;
+    indexes: number[];
+} | null;
+export declare const getColumnClassNames: (index: number, selection: Selection, hoveredColumns?: number[], isInDanger?: boolean, isResizing?: boolean) => string;
+export declare const colWidthsForRow: (tr: HTMLTableRowElement) => string;

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

@@ -0,0 +1,19 @@
+import type { IntlShape } from 'react-intl-next';
+import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
+import type { ReadonlyTransaction, Selection, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+import type { Cell, CellColumnPositioning } from '../types';
+import { TableDecorations } from '../types';
+export declare const findColumnControlSelectedDecoration: (decorationSet: DecorationSet) => Decoration[];
+export declare const findControlsHoverDecoration: (decorationSet: DecorationSet) => Decoration[];
+export declare const createCellHoverDecoration: (cells: Cell[]) => Decoration[];
+export declare const createControlsHoverDecoration: (cells: Cell[], type: 'row' | 'column' | 'table', tr: Transaction | ReadonlyTransaction, danger?: boolean, selected?: boolean) => Decoration[];
+export declare const createColumnSelectedDecoration: (tr: Transaction | ReadonlyTransaction) => Decoration[];
+export declare const createColumnControlsDecoration: (selection: Selection) => Decoration[];
+export declare const updateDecorations: (node: PmNode, decorationSet: DecorationSet, decorations: Decoration[], key: TableDecorations) => DecorationSet;
+export declare const createResizeHandleDecoration: (tr: Transaction | ReadonlyTransaction, rowIndexTarget: number, columnEndIndexTarget: Omit<CellColumnPositioning, 'left'>, includeTooltip: boolean | undefined, getIntl: () => IntlShape) => [
+    Decoration[],
+    Decoration[]
+];
+export declare const createColumnLineResize: (selection: Selection, cellColumnPositioning: Omit<CellColumnPositioning, 'left'>) => Decoration[];

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

@@ -0,0 +1,26 @@
+import type { ElementContentRects } from '../types';
+export declare const isCell: (node: HTMLElement | null) => boolean;
+export declare const isCornerButton: (node: HTMLElement | null) => boolean;
+export declare const isInsertRowButton: (node: HTMLElement | null) => boolean | HTMLElement | null;
+export declare const getColumnOrRowIndex: (target: HTMLElement) => [
+    number,
+    number
+];
+export declare const isColumnControlsDecorations: (node: HTMLElement | null) => boolean;
+export declare const isRowControlsButton: (node: HTMLElement | null) => boolean;
+export declare const isResizeHandleDecoration: (node: HTMLElement | null) => boolean;
+export declare const isTableControlsButton: (node: HTMLElement | null) => boolean;
+export declare const isTableContainerOrWrapper: (node: HTMLElement | null) => boolean;
+export declare const getMousePositionHorizontalRelativeByElement: (mouseEvent: MouseEvent, elementContentRects?: ElementContentRects, gapInPixels?: number) => 'left' | 'right' | null;
+export declare const getMousePositionVerticalRelativeByElement: (mouseEvent: MouseEvent) => 'top' | 'bottom' | null;
+export declare const updateResizeHandles: (tableRef?: HTMLElement) => void;
+export declare const hasResizeHandler: ({ columnEndIndexTarget, target, }: {
+    columnEndIndexTarget: number;
+    target: HTMLElement;
+}) => boolean;
+export type TableDOMElements = {
+    wrapper: HTMLDivElement;
+    table: HTMLTableElement;
+};
+export declare const getTree: (tr: HTMLTableRowElement) => TableDOMElements | null;
+export declare const getTop: (element: HTMLElement | Window | undefined) => number;