@atlaskit/editor-core 183.0.0 → 183.0.6

package/dist/types-ts4.0/plugins/status/ui/statusPicker.d.ts

@@ -0,0 +1,55 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { ColorType as Color } from '@atlaskit/status/picker';
+import { StatusType } from '../plugin';
+export declare enum InputMethod {
+    blur = "blur",
+    escKey = "escKey",
+    enterKey = "enterKey"
+}
+export interface Props {
+    target: HTMLElement | null;
+    closeStatusPicker: () => void;
+    onSelect: (status: StatusType) => void;
+    onTextChanged: (status: StatusType, isNew: boolean) => void;
+    onEnter: (status: StatusType) => void;
+    isNew?: boolean;
+    defaultText?: string;
+    defaultColor?: Color;
+    defaultLocalId?: string;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    mountTo?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+}
+export interface State {
+    color: Color;
+    text: string;
+    localId?: string;
+    isNew?: boolean;
+}
+export declare class StatusPickerWithoutAnalytcs extends React.Component<Props, State> {
+    private startTime;
+    private inputMethod?;
+    private createStatusAnalyticsAndFireFunc;
+    constructor(props: Props);
+    private fireStatusPopupOpenedAnalytics;
+    private fireStatusPopupClosedAnalytics;
+    private reset;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: Readonly<Props>, prevState: Readonly<State>, _snapshot?: any): void;
+    private extractStateFromProps;
+    handleClickOutside: (event: Event) => void;
+    private handleEscapeKeydown;
+    render(): jsx.JSX.Element | null;
+    private onColorHover;
+    private onColorClick;
+    private onTextChanged;
+    private onEnter;
+    private handlePopupClick;
+}
+declare const _default: React.ForwardRefExoticComponent<Omit<Props, keyof import("@atlaskit/analytics-next").WithAnalyticsEventsProps> & React.RefAttributes<any>>;
+export default _default;

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

@@ -0,0 +1,5 @@
+import { Selection, Transaction } from 'prosemirror-state';
+import { StatusType } from './types';
+export declare const mayGetStatusAtSelection: (selection: Selection) => StatusType | null;
+export declare const isEmptyStatus: (node: StatusType) => boolean;
+export declare const setNodeSelectionNearPos: (tr: Transaction, pos: number) => Transaction;

package/dist/types-ts4.0/plugins/submit-editor/index.d.ts

@@ -0,0 +1,11 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { EditorView } from 'prosemirror-view';
+import { Dispatch } from '../../event-dispatcher';
+import type { EditorProps } from '../../types/editor-props';
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+export declare function createPlugin(eventDispatch: Dispatch, onSave?: (editorView: EditorView) => void): SafePlugin | undefined;
+declare type Config = EditorProps['onSave'];
+declare const submitEditorPlugin: NextEditorPlugin<'submitEditor', {
+    pluginConfiguration: Config | undefined;
+}>;
+export default submitEditorPlugin;

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

@@ -0,0 +1,16 @@
+import { NodeType, ResolvedPos, Schema } from 'prosemirror-model';
+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 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,6 @@
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import { TaskDecisionPluginOptions } from './types';
+declare const tasksAndDecisionsPlugin: NextEditorPlugin<'taskDecision', {
+    pluginConfiguration: TaskDecisionPluginOptions | undefined;
+}>;
+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,5 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { Dispatch, EventDispatcher } from '../../../event-dispatcher';
+import { PortalProviderAPI } from '../../../ui/PortalProvider';
+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;

package/dist/types-ts4.0/plugins/tasks-and-decisions/ui/Task/task-item-with-providers.d.ts

@@ -0,0 +1,27 @@
+import { Component, ReactElement } from 'react';
+import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import { ContentRef, TaskDecisionProvider } from '@atlaskit/task-decision';
+export interface Props {
+    taskId: string;
+    isDone: boolean;
+    contentRef?: ContentRef;
+    onChange?: (taskId: string, isChecked: boolean) => void;
+    showPlaceholder?: boolean;
+    placeholder?: string;
+    children?: ReactElement<any>;
+    taskDecisionProvider?: Promise<TaskDecisionProvider>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+}
+export interface State {
+    resolvedContextProvider?: ContextIdentifierProvider;
+}
+export default class TaskItemWithProviders extends Component<Props, State> {
+    static displayName: string;
+    state: State;
+    private mounted;
+    UNSAFE_componentWillMount(): void;
+    componentWillUnmount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    private updateContextIdentifierProvider;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,20 @@
+import React, { PureComponent } from 'react';
+import { EditorView } from 'prosemirror-view';
+import { WrappedComponentProps } from 'react-intl-next';
+export interface Props {
+    editorView?: EditorView;
+    isDisabled?: boolean;
+    isReducedSpacing?: boolean;
+}
+export interface State {
+    disabled: boolean;
+}
+export declare class ToolbarDecision extends PureComponent<Props & WrappedComponentProps, State> {
+    state: State;
+    render(): JSX.Element;
+    private handleInsertDecision;
+}
+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/ToolbarTask/index.d.ts

@@ -0,0 +1,20 @@
+import React, { PureComponent } from 'react';
+import { EditorView } from 'prosemirror-view';
+import { WrappedComponentProps } from 'react-intl-next';
+export interface Props {
+    editorView?: EditorView;
+    isDisabled?: boolean;
+    isReducedSpacing?: boolean;
+}
+export interface State {
+    disabled: boolean;
+}
+export declare class ToolbarTask extends PureComponent<Props & WrappedComponentProps, State> {
+    state: State;
+    render(): JSX.Element;
+    private handleInsertTask;
+}
+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/utils.d.ts

@@ -0,0 +1,4 @@
+import { Schema, Slice } from 'prosemirror-model';
+import { Selection } from 'prosemirror-state';
+export declare const transformSliceToDecisionList: (slice: Slice, schema: Schema) => Slice;
+export declare const normalizeTaskItemsSelection: (selection: Selection) => Selection;

package/dist/types-ts4.0/plugins/text-color/commands/change-color.d.ts

@@ -0,0 +1,2 @@
+import { Command } from '../../../types';
+export declare const changeColor: (color: string) => Command;

package/dist/types-ts4.0/plugins/text-color/commands/remove-color.d.ts

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

package/dist/types-ts4.0/plugins/text-color/commands/toggle-color.d.ts

@@ -0,0 +1,2 @@
+import { Command } from '../../../types';
+export declare const toggleColor: (color: string) => Command;

package/dist/types-ts4.0/plugins/text-color/index.d.ts

@@ -0,0 +1,13 @@
+import { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import type featureFlagsPlugin from '@atlaskit/editor-plugin-feature-flags';
+import { TextColorPluginConfig, pluginKey as textColorPluginKey, TextColorPluginState } from './pm-plugins/main';
+declare type Config = TextColorPluginConfig | boolean;
+declare const textColorPlugin: NextEditorPlugin<'textColor', {
+    pluginConfiguration: Config | undefined;
+    dependencies: [
+        typeof featureFlagsPlugin
+    ];
+}>;
+export { textColorPluginKey };
+export type { TextColorPluginState };
+export default textColorPlugin;

package/dist/types-ts4.0/plugins/text-color/pm-plugins/main.d.ts

@@ -0,0 +1,25 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import { Dispatch } from '../../../event-dispatcher';
+import { PaletteColor } from '../../../ui/ColorPalette/Palettes/type';
+export { DEFAULT_COLOR } from '../utils/color';
+export declare type TextColorPluginState = {
+    palette: Array<PaletteColor>;
+    defaultColor: string;
+    disabled?: boolean;
+    color: string | null;
+};
+declare type TextColorDefaultColor = {
+    color: string;
+    label: string;
+};
+export interface TextColorPluginConfig {
+    defaultColor?: TextColorDefaultColor;
+}
+export declare enum ACTIONS {
+    RESET_COLOR = 0,
+    SET_COLOR = 1,
+    DISABLE = 2
+}
+export declare const pluginKey: PluginKey<TextColorPluginState, any>;
+export declare function createPlugin(dispatch: Dispatch, pluginConfig?: TextColorPluginConfig): SafePlugin;

package/dist/types-ts4.0/plugins/text-color/ui/ToolbarTextColor/icon.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const EditorTextColorIcon: () => JSX.Element;

package/dist/types-ts4.0/plugins/text-color/ui/ToolbarTextColor/index.d.ts

@@ -0,0 +1,51 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { EditorView } from 'prosemirror-view';
+import { WrappedComponentProps } from 'react-intl-next';
+import { DispatchAnalyticsEvent } from '../../../analytics';
+import { TextColorPluginState } from '../../pm-plugins/main';
+import { FeatureFlags } from '@atlaskit/editor-common/types';
+export declare const messages: {
+    textColor: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export interface State {
+    isOpen: boolean;
+    isOpenedByKeyboard: boolean;
+}
+export interface Props {
+    pluginState: TextColorPluginState;
+    editorView: EditorView;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    isReducedSpacing?: boolean;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    disabled?: boolean;
+    featureFlags: FeatureFlags;
+}
+export declare class ToolbarTextColor extends React.Component<Props & WrappedComponentProps, State> {
+    state: State;
+    private toolbarItemRef;
+    changeColor: (color: string) => boolean;
+    render(): jsx.JSX.Element;
+    private onOpenChange;
+    private changeTextColor;
+    private toggleOpen;
+    private onKeyDown;
+    private handleOpenChange;
+    private hide;
+    private hideonEsc;
+    private getCommonAnalyticsAttributes;
+    private buildAnalyticsPalette;
+    private buildAnalyticsSelectColor;
+    private dispatchAnalyticsEvent;
+}
+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/text-color/ui/ToolbarTextColor/styles.d.ts

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

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

@@ -0,0 +1,6 @@
+import { EditorState } from 'prosemirror-state';
+export declare const DEFAULT_COLOR: {
+    color: string;
+    label: string;
+};
+export declare const getActiveColor: (state: EditorState) => string | null;

package/dist/types-ts4.0/plugins/text-color/utils/disabled.d.ts

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

package/dist/types-ts4.0/plugins/text-formatting/commands/clear-formatting.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '../../../types';
+import { INPUT_METHOD } from '../../analytics';
+export declare const FORMATTING_NODE_TYPES: string[];
+export declare const FORMATTING_MARK_TYPES: string[];
+export declare function clearFormattingWithAnalytics(inputMethod: INPUT_METHOD.TOOLBAR | INPUT_METHOD.SHORTCUT): Command;
+export declare function clearFormatting(inputMethod?: INPUT_METHOD.TOOLBAR | INPUT_METHOD.SHORTCUT): Command;

package/dist/types-ts4.0/plugins/text-formatting/commands/text-formatting.d.ts

@@ -0,0 +1,35 @@
+import { Command } from '../../../types';
+import { INPUT_METHOD } from '../../analytics';
+export declare const moveRight: () => Command;
+export declare const moveLeft: () => Command;
+export declare type InputMethodToolbar = INPUT_METHOD.TOOLBAR;
+export declare type InputMethodBasic = InputMethodToolbar | INPUT_METHOD.SHORTCUT | INPUT_METHOD.FORMATTING;
+export declare const toggleEm: () => Command;
+export declare const toggleEmWithAnalytics: ({ inputMethod, }: {
+    inputMethod: InputMethodBasic;
+}) => Command;
+export declare const toggleStrike: () => Command;
+export declare const toggleStrikeWithAnalytics: ({ inputMethod, }: {
+    inputMethod: InputMethodBasic;
+}) => Command;
+export declare const toggleStrong: () => Command;
+export declare const toggleStrongWithAnalytics: ({ inputMethod, }: {
+    inputMethod: InputMethodBasic;
+}) => Command;
+export declare const toggleUnderline: () => Command;
+export declare const toggleUnderlineWithAnalytics: ({ inputMethod, }: {
+    inputMethod: InputMethodBasic;
+}) => Command;
+export declare const toggleSuperscript: () => Command;
+export declare const toggleSuperscriptWithAnalytics: ({ inputMethod, }: {
+    inputMethod: InputMethodBasic;
+}) => Command;
+export declare const toggleSubscript: () => Command;
+export declare const toggleSubscriptWithAnalytics: ({ inputMethod, }: {
+    inputMethod: InputMethodBasic;
+}) => Command;
+export declare const toggleCode: () => Command;
+export declare const toggleCodeWithAnalytics: ({ inputMethod, }: {
+    inputMethod: InputMethodBasic;
+}) => Command;
+export declare const createInlineCodeFromTextInputWithAnalytics: (from: number, to: number, text: string) => Command;

package/dist/types-ts4.0/plugins/text-formatting/commands/transform-to-code.d.ts

@@ -0,0 +1,2 @@
+import { Transaction } from 'prosemirror-state';
+export declare const transformSmartCharsMentionsAndEmojis: (from: number, to: number, tr: Transaction) => void;

package/dist/types-ts4.0/plugins/text-formatting/index.d.ts

@@ -0,0 +1,6 @@
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import { TextFormattingOptions } from './types';
+declare const textFormatting: NextEditorPlugin<'textFormatting', {
+    pluginConfiguration: TextFormattingOptions | undefined;
+}>;
+export default textFormatting;

package/dist/types-ts4.0/plugins/text-formatting/pm-plugins/clear-formatting-keymap.d.ts

@@ -0,0 +1,3 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export declare function keymapPlugin(): SafePlugin;
+export default keymapPlugin;

package/dist/types-ts4.0/plugins/text-formatting/pm-plugins/clear-formatting.d.ts

@@ -0,0 +1,8 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import { Dispatch } from '../../../event-dispatcher';
+export interface ClearFormattingState {
+    formattingIsPresent?: boolean;
+}
+export declare const pluginKey: PluginKey<ClearFormattingState, any>;
+export declare const plugin: (dispatch: Dispatch) => SafePlugin<any, any>;

package/dist/types-ts4.0/plugins/text-formatting/pm-plugins/cursor.d.ts

@@ -0,0 +1,3 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+declare const _default: SafePlugin<any, any>;
+export default _default;

package/dist/types-ts4.0/plugins/text-formatting/pm-plugins/input-rule.d.ts

@@ -0,0 +1,23 @@
+import { Schema } from 'prosemirror-model';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { FeatureFlags } from '../../../types/feature-flags';
+declare enum ValidAutoformatChars {
+    STRONG = "__",
+    STRIKE = "~~",
+    STRONG_MARKDOWN = "**",
+    ITALIC_MARKDOWN = "*",
+    ITALIC = "_",
+    CODE = "`"
+}
+export declare const ValidCombinations: Record<ValidAutoformatChars, string[]>;
+declare class ReverseRegexExp extends RegExp {
+    exec(str: string): RegExpExecArray | null;
+}
+export declare const strongRegex1: ReverseRegexExp;
+export declare const strongRegex2: ReverseRegexExp;
+export declare const italicRegex1: ReverseRegexExp;
+export declare const italicRegex2: ReverseRegexExp;
+export declare const strikeRegex: ReverseRegexExp;
+export declare const codeRegex: ReverseRegexExp;
+export declare function inputRulePlugin(schema: Schema, featureFlags: FeatureFlags): SafePlugin | undefined;
+export default inputRulePlugin;

package/dist/types-ts4.0/plugins/text-formatting/pm-plugins/keymap.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from 'prosemirror-model';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export default function keymapPlugin(schema: Schema): SafePlugin;

package/dist/types-ts4.0/plugins/text-formatting/pm-plugins/main.d.ts

@@ -0,0 +1,7 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { Dispatch } from '../../../event-dispatcher';
+import { TextFormattingState } from '../types';
+import { pluginKey } from './plugin-key';
+export { pluginKey };
+export type { TextFormattingState };
+export declare const plugin: (dispatch: Dispatch) => SafePlugin<any, any>;

package/dist/types-ts4.0/plugins/text-formatting/pm-plugins/plugin-key.d.ts

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

package/dist/types-ts4.0/plugins/text-formatting/pm-plugins/smart-input-rule.d.ts

@@ -0,0 +1,3 @@
+import { FeatureFlags } from '../../../types/feature-flags';
+declare const _default: (featureFlags: FeatureFlags) => import("@atlaskit/editor-common/safe-plugin").SafePlugin<any, any>;
+export default _default;

package/dist/types-ts4.0/plugins/text-formatting/styles.d.ts

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