@atlaskit/editor-core 172.2.0 → 172.2.1

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

@@ -0,0 +1,19 @@
+import { Component } from 'react';
+import { EditorView } from 'prosemirror-view';
+export interface Props {
+    editorView: EditorView;
+    tableRef?: HTMLTableElement;
+    isInDanger?: boolean;
+    isResizing?: boolean;
+    hoveredRows?: number[];
+    isHeaderColumnEnabled?: boolean;
+    isHeaderRowEnabled?: boolean;
+    stickyTop?: number;
+}
+export default class CornerControls extends Component<Props, any> {
+    render(): JSX.Element | null;
+    private isActive;
+    private clearHoverSelection;
+    private selectTable;
+    private hoverTable;
+}

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

@@ -0,0 +1,21 @@
+import { Component } from 'react';
+import { EditorView } from '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.0/plugins/table/ui/TableFloatingControls/RowControls/index.d.ts

@@ -0,0 +1,17 @@
+import { Component } from 'react';
+import { EditorView } from '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 default class RowControls extends Component<Props> {
+    render(): JSX.Element | null;
+    private clearHoverSelection;
+}

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

@@ -0,0 +1,40 @@
+import { Component } from 'react';
+import { Selection } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import type { TableColumnOrdering } from '@atlaskit/adf-schema/steps';
+import { RowStickyState } from '../../pm-plugins/sticky-headers';
+import type { GetEditorFeatureFlags } from '@atlaskit/editor-common/types';
+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;
+    tableHeight?: number;
+    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.0/plugins/table/ui/common-styles.d.ts

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

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

@@ -0,0 +1,39 @@
+/**
+ * Basic colors added to prevent content overflow in table cells.
+ */
+export declare const tableCellBackgroundColor: import("@atlaskit/theme").ThemedValue<string>;
+export declare const tableToolbarColor: import("@atlaskit/theme").ThemedValue<string>;
+export declare const tableTextColor: import("@atlaskit/theme").ThemedValue<"var(--ds-text-subtlest)">;
+export declare const tableBorderColor: import("@atlaskit/theme").ThemedValue<"var(--ds-border)">;
+export declare const tableFloatingControlsColor: "var(--ds-background-neutral)";
+export declare const tableCellSelectedColor: "var(--ds-blanket-selected)";
+export declare const tableToolbarSelectedColor: "var(--ds-background-selected-bold)";
+export declare const tableBorderSelectedColor: "var(--ds-border-selected)";
+export declare const tableCellDeleteColor: "var(--ds-blanket-danger)";
+export declare const tableBorderDeleteColor: "var(--ds-border-danger)";
+export declare const tableToolbarDeleteColor: "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;

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

@@ -0,0 +1,38 @@
+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;
+    };
+};
+export default _default;

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

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

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

@@ -0,0 +1,18 @@
+import { Selection } from 'prosemirror-state';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import type { AnalyticsEventPayload, AnalyticsEventPayloadCallback, EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { HigherOrderCommand } from '@atlaskit/editor-common/types';
+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;

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

@@ -0,0 +1,29 @@
+import { NodeType, NodeRange, Schema } from 'prosemirror-model';
+import { Transaction, ReadonlyTransaction } from 'prosemirror-state';
+interface IsTableCollapsibleResult<S extends Schema = any> {
+    tableIsCollapsible: boolean;
+    range?: NodeRange;
+    findWrappingRes?: Array<{
+        type: NodeType<S>;
+        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.0/plugins/table/utils/column-controls.d.ts

@@ -0,0 +1,10 @@
+import { Selection } from 'prosemirror-state';
+import { EditorView } from '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 | undefined, isResizing?: boolean | undefined) => string;
+export declare const colWidthsForRow: (colGroup: HTMLTableColElement | null, tr: HTMLTableRowElement) => string;

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

@@ -0,0 +1,16 @@
+import { Node as PmNode } from 'prosemirror-model';
+import { Selection, Transaction, ReadonlyTransaction } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { Cell, CellColumnPositioning, TableDecorations } from '../types';
+export declare const findColumnControlSelectedDecoration: (decorationSet: DecorationSet) => Decoration[];
+export declare const findControlsHoverDecoration: (decorationSet: DecorationSet) => Decoration[];
+export declare const createCellHoverDecoration: (cells: Cell[], type: 'warning') => Decoration[];
+export declare const createControlsHoverDecoration: (cells: Cell[], type: 'row' | 'column' | 'table', tr: Transaction | ReadonlyTransaction, danger?: boolean | undefined, selected?: boolean | undefined) => 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, columnEndIndexTarget: Omit<CellColumnPositioning, 'left'>) => [
+    Decoration[],
+    Decoration[]
+];
+export declare const createColumnLineResize: (selection: Selection, cellColumnPositioning: Omit<CellColumnPositioning, 'left'>) => Decoration[];

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

@@ -0,0 +1,20 @@
+import { 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, mouseMoveOptimization?: boolean | undefined, elementContentRects?: ElementContentRects | undefined, gapInPixels?: number | undefined) => 'left' | 'right' | null;
+export declare const getMousePositionVerticalRelativeByElement: (mouseEvent: MouseEvent) => 'top' | 'bottom' | null;
+export declare const updateResizeHandles: (tableRef?: HTMLElement | undefined) => void;
+export declare const hasResizeHandler: ({ columnEndIndexTarget, target, }: {
+    columnEndIndexTarget: number;
+    target: HTMLElement;
+}) => boolean;

package/dist/types-ts4.0/plugins/table/utils/get-allow-add-column-custom-step.d.ts

@@ -0,0 +1,2 @@
+import { EditorState } from 'prosemirror-state';
+export declare function getAllowAddColumnCustomStep(state: EditorState): boolean;

package/dist/types-ts4.0/plugins/table/utils/index.d.ts

@@ -0,0 +1,11 @@
+export { getSelectedColumnIndexes, getSelectedRowIndexes, normalizeSelection, isSelectionUpdated, } from './selection';
+export { findControlsHoverDecoration, createControlsHoverDecoration, createColumnControlsDecoration, createColumnSelectedDecoration, createCellHoverDecoration, updateDecorations, createResizeHandleDecoration, createColumnLineResize, } from './decoration';
+export { isIsolating, containsHeaderColumn, containsHeaderRow, checkIfHeaderColumnEnabled, checkIfHeaderRowEnabled, checkIfNumberColumnEnabled, isLayoutSupported, getTableWidth, tablesHaveDifferentColumnWidths, tablesHaveDifferentNoOfColumns, } from './nodes';
+export { unwrapContentFromTable, removeTableFromFirstChild, removeTableFromLastChild, transformSliceToRemoveOpenTable, transformSliceToCorrectEmptyTableCells, transformSliceToFixHardBreakProblemOnCopyFromCell, } from './paste';
+export { isCell, isCornerButton, isInsertRowButton, isColumnControlsDecorations, isTableControlsButton, isTableContainerOrWrapper, isRowControlsButton, getColumnOrRowIndex, getMousePositionHorizontalRelativeByElement, getMousePositionVerticalRelativeByElement, updateResizeHandles, isResizeHandleDecoration, hasResizeHandler, } from './dom';
+export { isColumnDeleteButtonVisible, getColumnDeleteButtonParams, getColumnClassNames, } from './column-controls';
+export { getRowHeights, isRowDeleteButtonVisible, getRowDeleteButtonParams, getRowsParams, getRowClassNames, copyPreviousRow, } from './row-controls';
+export type { RowParams } from './row-controls';
+export { getSelectedTableInfo, getSelectedCellInfo } from './analytics';
+export { getMergedCellsPositions } from './table';
+export { updatePluginStateDecorations } from './update-plugin-state-decorations';

package/dist/types-ts4.0/plugins/table/utils/nodes.d.ts

@@ -0,0 +1,12 @@
+import { Node as PmNode } from 'prosemirror-model';
+import { EditorState, Selection } from 'prosemirror-state';
+export declare const isIsolating: (node: PmNode) => boolean;
+export declare const containsHeaderColumn: (table: PmNode) => boolean;
+export declare const containsHeaderRow: (table: PmNode) => boolean;
+export declare const checkIfHeaderColumnEnabled: (selection: Selection) => boolean;
+export declare const checkIfHeaderRowEnabled: (selection: Selection) => boolean;
+export declare const checkIfNumberColumnEnabled: (selection: Selection) => boolean;
+export declare const isLayoutSupported: (state: EditorState) => boolean;
+export declare const getTableWidth: (node: PmNode) => number;
+export declare const tablesHaveDifferentColumnWidths: (currentTable: PmNode, previousTable: PmNode) => boolean;
+export declare const tablesHaveDifferentNoOfColumns: (currentTable: PmNode, previousTable: PmNode) => boolean;

package/dist/types-ts4.0/plugins/table/utils/paste.d.ts

@@ -0,0 +1,14 @@
+import { Fragment, Node as PMNode, Schema, Slice } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+export declare const unwrapContentFromTable: (maybeTable: PMNode) => PMNode | PMNode[];
+export declare const removeTableFromFirstChild: (node: PMNode, i: number) => PMNode | PMNode[];
+export declare const removeTableFromLastChild: (node: PMNode, i: number, fragment: Fragment) => PMNode | PMNode[];
+/**
+ * When we copy from a table cell with a hardBreak at the end,
+ * the slice generated will come with a hardBreak outside of the table.
+ * This code will look for that pattern and fix it.
+ */
+export declare const transformSliceToFixHardBreakProblemOnCopyFromCell: (slice: Slice, schema: Schema) => Slice;
+export declare const transformSliceToRemoveOpenTable: (slice: Slice, schema: Schema) => Slice;
+export declare const transformSliceToCorrectEmptyTableCells: (slice: Slice, schema: Schema) => Slice;
+export declare function isHeaderRowRequired(state: EditorState): boolean | undefined;

package/dist/types-ts4.0/plugins/table/utils/referentiality.d.ts

@@ -0,0 +1,2 @@
+import { EditorState } from 'prosemirror-state';
+export declare const isReferencedSource: (state: EditorState, localId: string) => boolean;

package/dist/types-ts4.0/plugins/table/utils/row-controls.d.ts

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

package/dist/types-ts4.0/plugins/table/utils/selection.d.ts

@@ -0,0 +1,6 @@
+import { Selection, Transaction } from 'prosemirror-state';
+import { Rect } from '@atlaskit/editor-tables/table-map';
+export declare const isSelectionUpdated: (oldSelection: Selection, newSelection?: Selection<any> | undefined) => boolean;
+export declare const normalizeSelection: (tr: Transaction) => Transaction;
+export declare const getSelectedColumnIndexes: (selectionRect: Rect) => number[];
+export declare const getSelectedRowIndexes: (selectionRect: Rect) => number[];

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

@@ -0,0 +1,4 @@
+import { Transaction } from 'prosemirror-state';
+import { Rect } from '@atlaskit/editor-tables/table-map';
+export declare const getMergedCellsPositions: (tr: Transaction) => number[];
+export declare const colsToRect: (cols: Array<number>, noOfRows: number) => Rect;

package/dist/types-ts4.0/plugins/table/utils/update-plugin-state-decorations.d.ts

@@ -0,0 +1,4 @@
+import { EditorState } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { TableDecorations } from '../types';
+export declare const updatePluginStateDecorations: (state: EditorState<any>, decorations: Decoration[], key: TableDecorations) => DecorationSet;

package/dist/types-ts4.0/plugins/tasks-and-decisions/commands.d.ts

@@ -0,0 +1,18 @@
+import { NodeType, ResolvedPos, Schema } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import { EditorState, Selection, Transaction } from 'prosemirror-state';
+import { Command } from '../../types';
+import { INPUT_METHOD } from '../analytics';
+import { TOOLBAR_MENU_TYPE } from '../insert-block/ui/ToolbarInsertBlock/types';
+import { AddItemTransactionCreator, TaskDecisionInputMethod, TaskDecisionListType } from './types';
+export declare const getListTypes: (listType: TaskDecisionListType, schema: Schema) => {
+    list: NodeType;
+    item: NodeType;
+};
+export declare const insertTaskDecision: (view: EditorView, listType: TaskDecisionListType, inputMethod?: INPUT_METHOD.FORMATTING | INPUT_METHOD.QUICK_INSERT | TOOLBAR_MENU_TYPE, listLocalId?: string | undefined, itemLocalId?: string | undefined) => Command;
+export declare const insertTaskDecisionAction: (state: EditorState, listType: TaskDecisionListType, inputMethod?: INPUT_METHOD.FORMATTING | INPUT_METHOD.QUICK_INSERT | TOOLBAR_MENU_TYPE, addItem?: AddItemTransactionCreator | undefined, listLocalId?: string | undefined, itemLocalId?: string | undefined) => Transaction;
+export declare const insertTaskDecisionCommand: (listType: TaskDecisionListType, inputMethod?: INPUT_METHOD.FORMATTING | INPUT_METHOD.QUICK_INSERT | TOOLBAR_MENU_TYPE, addItem?: AddItemTransactionCreator | undefined, listLocalId?: string | undefined, itemLocalId?: string | undefined) => Command;
+export declare const insertTaskDecisionWithAnalytics: (state: EditorState, listType: TaskDecisionListType, inputMethod: TaskDecisionInputMethod, addAndCreateList: AddItemTransactionCreator, addToList?: AddItemTransactionCreator | undefined, listLocalId?: string | undefined, itemLocalId?: string | undefined) => Transaction | null;
+export declare const isSupportedSourceNode: (schema: Schema, selection: Selection) => boolean;
+export declare const changeInDepth: (before: ResolvedPos, after: ResolvedPos) => number;
+export declare const createListAtSelection: (tr: Transaction, list: any, item: any, schema: Schema, state: EditorState, listLocalId?: string, itemLocalId?: string) => Transaction | null;

package/dist/types-ts4.0/plugins/tasks-and-decisions/index.d.ts

@@ -0,0 +1,4 @@
+import { EditorPlugin } from '../../types';
+import { TaskDecisionPluginOptions } from './types';
+declare const tasksAndDecisionsPlugin: ({ allowNestedTasks, consumeTabs, useLongPressSelection, }?: TaskDecisionPluginOptions) => EditorPlugin;
+export default tasksAndDecisionsPlugin;

package/dist/types-ts4.0/plugins/tasks-and-decisions/nodeviews/decisionItem.d.ts

@@ -0,0 +1,5 @@
+import { NodeView } from 'prosemirror-view';
+import { EventDispatcher } from '../../../event-dispatcher';
+import { getPosHandler } from '../../../nodeviews';
+import { PortalProviderAPI } from '../../../ui/PortalProvider';
+export declare const decisionItemNodeView: (portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher) => (node: any, view: any, getPos: getPosHandler) => NodeView;

package/dist/types-ts4.0/plugins/tasks-and-decisions/nodeviews/taskItem.d.ts

@@ -0,0 +1,9 @@
+import { NodeView } from 'prosemirror-view';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { EventDispatcher } from '../../../event-dispatcher';
+import { getPosHandler } from '../../../nodeviews';
+import { PortalProviderAPI } from '../../../ui/PortalProvider';
+export interface Props {
+    providerFactory: ProviderFactory;
+}
+export declare function taskItemNodeViewFactory(portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory): (node: any, view: any, getPos: getPosHandler) => NodeView;

package/dist/types-ts4.0/plugins/tasks-and-decisions/pm-plugins/commands.d.ts

@@ -0,0 +1,15 @@
+import { ResolvedPos } from 'prosemirror-model';
+import { Command } from '../../../types';
+export declare const liftSelection: Command;
+export declare const wrapSelectionInTaskList: Command;
+/**
+ * Tries to move the paragraph content near the given position into the taskItem or decisionItem
+ * before it.
+ *
+ * Looks backwards from the given position to find the "cut point" between the last taskItem and the
+ * following paragraph. Then tries to move the content from that paragraph into the taskItem.
+ *
+ * @param $pos Position at the end of, or anywhere in paragraph following, the last taskItem
+ * @see {joinToPreviousListItem}
+ */
+export declare const joinAtCut: ($pos: ResolvedPos) => Command;

package/dist/types-ts4.0/plugins/tasks-and-decisions/pm-plugins/helpers.d.ts

@@ -0,0 +1,54 @@
+import { Node, NodeType, ResolvedPos } from 'prosemirror-model';
+import { EditorState, Selection, Transaction } from 'prosemirror-state';
+export declare const isInsideTaskOrDecisionItem: (state: EditorState) => boolean;
+export declare const isActionOrDecisionList: (node: Node) => boolean;
+export declare const isActionOrDecisionItem: (node: Node) => boolean;
+export declare const isInsideTask: (state: EditorState) => boolean;
+export declare const isInsideDecision: (state: EditorState) => boolean;
+export declare const isTable: (node?: Node<any> | null | undefined) => Boolean;
+/**
+ * Creates a NodeRange around the given taskItem and the following
+ * ("nested") taskList, if one exists.
+ */
+export declare const getBlockRange: ($from: ResolvedPos, $to: ResolvedPos) => import("prosemirror-model").NodeRange<any> | null | undefined;
+/**
+ * Finds the distance between the current $from and the root of the taskList.
+ */
+export declare const getCurrentIndentLevel: (selection: Selection) => number | null;
+/**
+ * Finds the index of the current task item in relation to the closest taskList
+ */
+export declare const getTaskItemIndex: (state: EditorState) => number;
+/**
+ * Walk outwards from a position until we encounter the (inside) start of
+ * the next node, or reach the end of the document.
+ *
+ * @param $startPos Position to start walking from.
+ */
+export declare const walkOut: ($startPos: ResolvedPos) => ResolvedPos;
+/**
+ * Finds the height of a tree-like structure, given any position inside it.
+ *
+ * Traverses from the top of the tree to all leaf nodes, and returns the length
+ * of the longest path.
+ *
+ * This means you can use it with things like taskList, which
+ * do not nest themselves inside taskItems but rather as adjacent children.
+ *
+ * @param $pos Any position inside the tree.
+ * @param types The node types to consider traversable
+ */
+export declare const subtreeHeight: ($from: ResolvedPos, $to: ResolvedPos, types: NodeType[]) => number;
+/**
+ * Returns `true` if the taskItem or decisionItem has no text.
+ */
+export declare const isEmptyTaskDecision: (state: EditorState) => boolean;
+/**
+ * Lifts a taskItem and any directly following taskList
+ * (taskItem and its "nested children") out one level.
+ *
+ * @param tr Transaction to base steps on
+ * @param $from Start of range you want to lift
+ * @param $to End of range you want to lift (can be same as `$from`)
+ */
+export declare const liftBlock: (tr: Transaction, $from: ResolvedPos, $to: ResolvedPos) => Transaction | null;

package/dist/types-ts4.0/plugins/tasks-and-decisions/pm-plugins/input-rules.d.ts

@@ -0,0 +1,5 @@
+import { FeatureFlags } from '../../../types/feature-flags';
+import { Schema } from 'prosemirror-model';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export declare function inputRulePlugin(schema: Schema, featureFlags: FeatureFlags): SafePlugin;
+export default inputRulePlugin;

package/dist/types-ts4.0/plugins/tasks-and-decisions/pm-plugins/keymaps.d.ts

@@ -0,0 +1,9 @@
+import { Schema } from 'prosemirror-model';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { Command } from '../../../types';
+import { INPUT_METHOD } from '../../analytics';
+declare type IndentationInputMethod = INPUT_METHOD.KEYBOARD | INPUT_METHOD.TOOLBAR;
+export declare const getUnindentCommand: (inputMethod?: IndentationInputMethod) => Command;
+export declare const getIndentCommand: (inputMethod?: IndentationInputMethod) => Command;
+export declare function keymapPlugin(schema: Schema, allowNestedTasks?: boolean, consumeTabs?: boolean): SafePlugin | undefined;
+export default keymapPlugin;

package/dist/types-ts4.0/plugins/tasks-and-decisions/pm-plugins/main.d.ts

@@ -0,0 +1,11 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import { Dispatch, EventDispatcher } from '../../../event-dispatcher';
+import { PortalProviderAPI } from '../../../ui/PortalProvider';
+export interface TaskDecisionPluginState {
+    currentTaskDecisionItem: PMNode | undefined;
+    contextIdentifierProvider?: ContextIdentifierProvider;
+}
+export declare function createPlugin(portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, providerFactory: ProviderFactory, dispatch: Dispatch, useLongPressSelection?: boolean): SafePlugin<any, any>;

package/dist/types-ts4.0/plugins/tasks-and-decisions/pm-plugins/plugin-key.d.ts

@@ -0,0 +1,2 @@
+import { PluginKey } from 'prosemirror-state';
+export declare const stateKey: PluginKey<any, any>;

package/dist/types-ts4.0/plugins/tasks-and-decisions/styles.d.ts

@@ -0,0 +1 @@
+export declare const taskDecisionStyles: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.0/plugins/tasks-and-decisions/types.d.ts

@@ -0,0 +1,23 @@
+import { NodeType } from 'prosemirror-model';
+import { EditorState, Transaction } from 'prosemirror-state';
+import { INPUT_METHOD, USER_CONTEXT } from '../analytics';
+import { LongPressSelectionPluginOptions } from '../selection/types';
+export declare type TaskDecisionListType = 'taskList' | 'decisionList';
+export declare type TaskDecisionInputMethod = INPUT_METHOD.TOOLBAR | INPUT_METHOD.INSERT_MENU | INPUT_METHOD.QUICK_INSERT | INPUT_METHOD.FORMATTING | INPUT_METHOD.KEYBOARD;
+export declare type ContextData = {
+    objectId: string;
+    containerId: string;
+    userContext: USER_CONTEXT;
+};
+export declare type AddItemTransactionCreator = (opts: {
+    state: EditorState;
+    tr: Transaction;
+    list: NodeType;
+    item: NodeType;
+    listLocalId: string;
+    itemLocalId: string;
+}) => Transaction | null;
+export interface TaskDecisionPluginOptions extends LongPressSelectionPluginOptions {
+    allowNestedTasks?: boolean;
+    consumeTabs?: boolean;
+}

package/dist/types-ts4.0/plugins/tasks-and-decisions/ui/Decision/index.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+interface Props {
+    contentRef: any;
+    showPlaceholder?: boolean;
+}
+export declare class Decision extends React.Component<Props & WrappedComponentProps, {}> {
+    static displayName: string;
+    render(): JSX.Element;
+}
+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.0/plugins/tasks-and-decisions/ui/Task/index.d.ts

@@ -0,0 +1,26 @@
+import React, { PureComponent, ReactElement } from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { ContentRef } from '@atlaskit/task-decision';
+export interface TaskProps {
+    taskId: string;
+    isDone: boolean;
+    contentRef?: ContentRef;
+    onChange?: (taskId: string, isChecked: boolean) => void;
+    showPlaceholder?: boolean;
+    children?: ReactElement<any>;
+    providers?: ProviderFactory;
+    disabled?: boolean;
+}
+export declare class TaskItem extends PureComponent<TaskProps & WrappedComponentProps, {}> {
+    static displayName: string;
+    private providerFactory;
+    constructor(props: TaskProps & WrappedComponentProps);
+    componentWillUnmount(): void;
+    private renderWithProvider;
+    render(): JSX.Element;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<TaskProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<TaskProps & WrappedComponentProps<"intl">>;
+};
+export default _default;