@atlaskit/editor-core 183.0.0 → 183.0.6

package/dist/types-ts4.0/plugins/base/pm-plugins/decoration.d.ts

@@ -0,0 +1,16 @@
+import { NodeType } from 'prosemirror-model';
+import { Decoration } from 'prosemirror-view';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import { Command } from '../../../types';
+export declare const decorationStateKey: PluginKey<any, any>;
+export declare enum ACTIONS {
+    DECORATION_ADD = 0,
+    DECORATION_REMOVE = 1
+}
+export declare const hoverDecoration: (nodeType: NodeType | Array<NodeType>, add: boolean, className?: string) => Command;
+export declare type DecorationState = {
+    decoration?: Decoration;
+};
+declare const _default: () => SafePlugin<DecorationState, any>;
+export default _default;

package/dist/types-ts4.0/plugins/base/pm-plugins/disable-spell-checking.d.ts

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

package/dist/types-ts4.0/plugins/base/pm-plugins/filter-steps.d.ts

@@ -0,0 +1,4 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+declare const _default: (dispatchAnalyticsEvent: DispatchAnalyticsEvent) => SafePlugin<any, any>;
+export default _default;

package/dist/types-ts4.0/plugins/base/pm-plugins/fix-chrome-88-selection.d.ts

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

package/dist/types-ts4.0/plugins/base/pm-plugins/focus-handler.d.ts

@@ -0,0 +1,6 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import { Dispatch } from '../../../event-dispatcher';
+export declare const focusStateKey: PluginKey<any, any>;
+declare const _default: (dispatch: Dispatch) => SafePlugin<boolean, any>;
+export default _default;

package/dist/types-ts4.0/plugins/base/pm-plugins/frozen-editor.d.ts

@@ -0,0 +1,12 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import { DispatchAnalyticsEvent } from '../../analytics';
+import { InputTracking, BrowserFreezetracking } from '../../../types/performance-tracking';
+export declare const frozenEditorPluginKey: PluginKey<any, any>;
+export declare const DEFAULT_FREEZE_THRESHOLD = 600;
+export declare const NORMAL_SEVERITY_THRESHOLD = 2000;
+export declare const DEGRADED_SEVERITY_THRESHOLD = 3000;
+export declare const DEFAULT_TRACK_SEVERITY_THRESHOLD_NORMAL = 100;
+export declare const DEFAULT_TRACK_SEVERITY_THRESHOLD_DEGRADED = 500;
+declare const _default: (dispatchAnalyticsEvent: DispatchAnalyticsEvent, inputTracking?: InputTracking | undefined, browserFreezeTracking?: BrowserFreezetracking | undefined, ufo?: boolean | undefined) => SafePlugin<any, any>;
+export default _default;

package/dist/types-ts4.0/plugins/base/pm-plugins/inline-cursor-target.d.ts

@@ -0,0 +1,17 @@
+import { Decoration } from 'prosemirror-view';
+import { Node } from 'prosemirror-model';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+export declare const inlineCursorTargetStateKey: PluginKey<any, any>;
+export declare const isInlineNodeView: (node: Node | null | undefined) => boolean | null | undefined;
+export interface InlineCursorTargetState {
+    cursorTarget?: {
+        decorations: (Decoration | null)[];
+        positions: {
+            from: number;
+            to: number;
+        };
+    };
+}
+declare const _default: () => SafePlugin<InlineCursorTargetState, any>;
+export default _default;

package/dist/types-ts4.0/plugins/base/pm-plugins/newline-preserve-marks.d.ts

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

package/dist/types-ts4.0/plugins/base/pm-plugins/react-nodeview.d.ts

@@ -0,0 +1,13 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+declare type StateChangeHandler = (fromPos: number, toPos: number) => any;
+export declare class ReactNodeViewState {
+    private changeHandlers;
+    constructor();
+    subscribe(cb: StateChangeHandler): void;
+    unsubscribe(cb: StateChangeHandler): void;
+    notifyNewSelection(fromPos: number, toPos: number): void;
+}
+export declare const stateKey: PluginKey<ReactNodeViewState, any>;
+export declare const plugin: SafePlugin<ReactNodeViewState, any>;
+export {};

package/dist/types-ts4.0/plugins/base/pm-plugins/scroll-gutter.d.ts

@@ -0,0 +1,23 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { EditorView } from 'prosemirror-view';
+export declare const GUTTER_SIZE_IN_PX = 120;
+export declare const GUTTER_SIZE_MOBILE_IN_PX = 36;
+export declare const GUTTER_SELECTOR = "#editor-scroll-gutter";
+export declare type ScrollGutterPluginOptions = {
+    /** Element the page uses for scrolling */
+    getScrollElement?: (view: EditorView) => HTMLElement | null;
+    /**
+     * Whether to allow custom functionality to scroll to gutter element in
+     * plugin's handleScrollToSelection function
+     * Default is true
+     */
+    allowCustomScrollHandler?: boolean;
+    /**
+     * Persist scroll gutter when the mobile appearance is COMPACT
+     * Default is false
+     */
+    persistScrollGutter?: boolean;
+    gutterSize?: number;
+};
+declare const _default: (pluginOptions?: ScrollGutterPluginOptions) => SafePlugin<any, any> | undefined;
+export default _default;

package/dist/types-ts4.0/plugins/base/utils/frozen-editor.d.ts

@@ -0,0 +1,2 @@
+/** Allows the possibility of overriding interaction type values in unit tests via jest.mock or spyOn. */
+export declare const setInteractionType: <T>(value: T) => T;

package/dist/types-ts4.0/plugins/base/utils/input-latency-tracking.d.ts

@@ -0,0 +1,42 @@
+import { SEVERITY } from '@atlaskit/editor-common/utils';
+interface Opts {
+    dispatchAverage?: (data: {
+        mean: number;
+        median: number;
+        sampleSize: number;
+    }, severity: SEVERITY) => void;
+    dispatchSample?: (sample: number, severity: SEVERITY) => void;
+    onSampleStart?: () => void;
+    onSampleEnd?: (time: number, info: {
+        isSlow: boolean;
+        severity: SEVERITY;
+    }) => void;
+    onSlowInput?: (time: number) => void;
+    samplingRate: number;
+    slowThreshold: number;
+    normalThreshold: number;
+    degradedThreshold: number;
+}
+export default class InputLatencyTracker {
+    private samples;
+    private total;
+    private samplingRate;
+    private slowThreshold;
+    private normalThreshold;
+    private degradedThreshold;
+    private dispatchAverage;
+    private dispatchSample;
+    private onSampleStart;
+    private onSampleEnd;
+    private onSlowInput;
+    constructor({ samplingRate, slowThreshold, normalThreshold, degradedThreshold, dispatchAverage, dispatchSample, onSampleStart, onSampleEnd, onSlowInput, }: Opts);
+    start(): () => void;
+    flush(): void;
+    private dispatch;
+    private push;
+    private severity;
+    private getLast;
+    private getMean;
+    private getMedian;
+}
+export {};

package/dist/types-ts4.0/plugins/before-primaryToolbar/index.d.ts

@@ -0,0 +1,8 @@
+import { NextEditorPlugin } from '@atlaskit/editor-common/types';
+declare type Config = {
+    beforePrimaryToolbarComponents?: any;
+};
+declare const beforePrimaryToolbar: NextEditorPlugin<'beforePrimaryToolbar', {
+    pluginConfiguration: Config;
+}>;
+export default beforePrimaryToolbar;

package/dist/types-ts4.0/plugins/before-primaryToolbar/ui/BeforePrimaryToolbarWrapper.d.ts

@@ -0,0 +1,5 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+export declare const BeforePrimaryToolbarWrapper: (props: {
+    beforePrimaryToolbarComponents: any;
+}) => jsx.JSX.Element;

package/dist/types-ts4.0/plugins/block-type/commands/block-type.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '../../../types';
+import { HeadingLevelsAndNormalText } from '../types';
+import { INPUT_METHOD } from '../../analytics';
+export declare type InputMethod = INPUT_METHOD.TOOLBAR | INPUT_METHOD.INSERT_MENU | INPUT_METHOD.SHORTCUT | INPUT_METHOD.FORMATTING | INPUT_METHOD.KEYBOARD;
+export declare function setBlockType(name: string): Command;
+export declare function setBlockTypeWithAnalytics(name: string, inputMethod: InputMethod): Command;
+export declare function setNormalText(): Command;
+export declare function setNormalTextWithAnalytics(inputMethod: InputMethod): Command;
+export declare function setHeading(level: HeadingLevelsAndNormalText): Command;
+export declare const setHeadingWithAnalytics: (newHeadingLevel: HeadingLevelsAndNormalText, inputMethod: InputMethod) => Command;
+export declare function insertBlockType(name: string): Command;
+export declare const insertBlockTypesWithAnalytics: (name: string, inputMethod: InputMethod) => Command;
+export declare const cleanUpAtTheStartOfDocument: Command;

package/dist/types-ts4.0/plugins/block-type/commands/delete-and-move-cursor.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '../../../types';
+/**
+ * Fixes cursor position after delete for list/task in panel and table
+ *
+ * ED-13873 fixes a bug where after deleting a list the cursor would move
+ * to the cell to the right. Uses setSelection to position the cursor as expected after deleting.
+ *
+ * @param state EditorState<any>
+ * @param dispatch CommandDispatch
+ * @returns boolean
+ */
+export declare const deleteAndMoveCursor: Command;

package/dist/types-ts4.0/plugins/block-type/commands/delete-block-content.d.ts

@@ -0,0 +1,10 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { Command } from '../../../types';
+/**
+ * Prevent removing the block when deleting block content
+ *
+ * @param state EditorState<any>
+ * @param dispatch CommandDispatch
+ * @returns boolean
+ */
+export declare function deleteBlockContent(isNodeAWrappingBlockNode: (node?: PMNode | null) => boolean): Command;

package/dist/types-ts4.0/plugins/block-type/commands/index.d.ts

@@ -0,0 +1,6 @@
+export { cleanUpAtTheStartOfDocument, insertBlockType, insertBlockTypesWithAnalytics, setBlockType, setBlockTypeWithAnalytics, setHeading, setHeadingWithAnalytics, setNormalText, setNormalTextWithAnalytics, } from './block-type';
+export type { InputMethod } from './block-type';
+export { insertBlock } from './insert-block';
+export { isConvertableToCodeBlock, transformToCodeBlockAction, } from './transform-to-code-block';
+export { deleteAndMoveCursor } from './delete-and-move-cursor';
+export { deleteBlockContent } from './delete-block-content';

package/dist/types-ts4.0/plugins/block-type/commands/insert-block.d.ts

@@ -0,0 +1,5 @@
+import { NodeType } from 'prosemirror-model';
+import { EditorState, Transaction } from 'prosemirror-state';
+export declare const insertBlock: (state: EditorState, nodeType: NodeType, nodeName: string, start: number, end: number, attrs?: {
+    [key: string]: any;
+} | undefined) => Transaction | null;

package/dist/types-ts4.0/plugins/block-type/commands/transform-to-code-block.d.ts

@@ -0,0 +1,3 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+export declare function transformToCodeBlockAction(state: EditorState, start: number, attrs?: any): Transaction;
+export declare function isConvertableToCodeBlock(state: EditorState): boolean;

package/dist/types-ts4.0/plugins/block-type/index.d.ts

@@ -0,0 +1,8 @@
+import { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import { BlockTypePluginOptions } from './types';
+declare const blockTypePlugin: NextEditorPlugin<'blockType', {
+    pluginConfiguration: BlockTypePluginOptions | undefined;
+}>;
+export default blockTypePlugin;
+export { pluginKey } from './pm-plugins/main';
+export type { BlockTypeState } from './pm-plugins/main';

package/dist/types-ts4.0/plugins/block-type/messages.d.ts

@@ -0,0 +1,152 @@
+export declare const messages: {
+    normal: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading1: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading1Description: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading2: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading2Description: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading3: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading3Description: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading4: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading4Description: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading5: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading5Description: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading6: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    heading6Description: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    blockquote: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    blockquoteDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    codeblock: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    codeblockDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    infoPanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    infoPanelDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    notePanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    notePanelDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    successPanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    successPanelDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    warningPanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    warningPanelDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    errorPanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    errorPanelDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    customPanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    customPanelDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    other: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types-ts4.0/plugins/block-type/pm-plugins/input-rule.d.ts

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

package/dist/types-ts4.0/plugins/block-type/pm-plugins/keymap.d.ts

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

package/dist/types-ts4.0/plugins/block-type/pm-plugins/main.d.ts

@@ -0,0 +1,11 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import { BlockType } from '../types';
+export declare type BlockTypeState = {
+    currentBlockType: BlockType;
+    blockTypesDisabled: boolean;
+    availableBlockTypes: BlockType[];
+    availableWrapperBlockTypes: BlockType[];
+};
+export declare const pluginKey: PluginKey<BlockTypeState, any>;
+export declare const createPlugin: (dispatch: (eventName: string | PluginKey, data: any) => void, lastNodeMustBeParagraph?: boolean | undefined) => SafePlugin<any, any>;

package/dist/types-ts4.0/plugins/block-type/styles.d.ts

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

package/dist/types-ts4.0/plugins/block-type/types.d.ts

@@ -0,0 +1,43 @@
+import { AllowedBlockTypes } from '../../types/allowed-block-types';
+import { MessageDescriptor } from '../../types/i18n';
+import { NodeSpec } from 'prosemirror-model';
+export declare const NORMAL_TEXT: BlockType;
+export declare const HEADING_1: BlockType;
+export declare const HEADING_2: BlockType;
+export declare const HEADING_3: BlockType;
+export declare const HEADING_4: BlockType;
+export declare const HEADING_5: BlockType;
+export declare const HEADING_6: BlockType;
+export declare const BLOCK_QUOTE: BlockType;
+export declare const CODE_BLOCK: BlockType;
+export declare const PANEL: BlockType;
+export declare const OTHER: BlockType;
+export declare const TEXT_BLOCK_TYPES: BlockType[];
+export declare const WRAPPER_BLOCK_TYPES: BlockType[];
+export declare const ALL_BLOCK_TYPES: BlockType[];
+export declare const HEADINGS_BY_LEVEL: Record<number, BlockType>;
+export declare const HEADINGS_BY_NAME: {
+    [blockType: string]: BlockType;
+};
+export declare type BlockTypeName = 'normal' | 'heading1' | 'heading2' | 'heading3' | 'heading4' | 'heading5' | 'heading6' | 'blockquote' | 'codeblock' | 'panel' | 'notePanel' | 'successPanel' | 'warningPanel' | 'errorPanel' | 'other';
+export interface BlockType {
+    name: string;
+    title: MessageDescriptor;
+    nodeName: string;
+    tagName?: string;
+    level?: HeadingLevelsAndNormalText;
+}
+export declare type HeadingLevels = 1 | 2 | 3 | 4 | 5 | 6;
+export declare type NormalTextLevel = 0;
+export declare type HeadingLevelsAndNormalText = HeadingLevels | NormalTextLevel;
+export interface BlockTypeNode {
+    name: AllowedBlockTypes;
+    node: NodeSpec;
+}
+export interface BlockTypePluginOptions {
+    lastNodeMustBeParagraph?: boolean;
+    allowBlockType?: {
+        exclude?: Array<AllowedBlockTypes>;
+    };
+    isUndoRedoButtonsEnabled?: boolean;
+}

package/dist/types-ts4.0/plugins/block-type/ui/ToolbarBlockType/blocktype-button.d.ts

@@ -0,0 +1,23 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { MessageDescriptor } from '../../../../types/i18n';
+export interface BlockTypeButtonProps {
+    isSmall?: boolean;
+    isReducedSpacing?: boolean;
+    'aria-expanded': React.AriaAttributes['aria-expanded'];
+    selected: boolean;
+    disabled: boolean;
+    title: MessageDescriptor;
+    onClick(e: React.MouseEvent): void;
+    onKeyDown(e: React.KeyboardEvent): void;
+    formatMessage: WrappedComponentProps['intl']['formatMessage'];
+}
+export declare const messages: {
+    textStyles: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export declare const BlockTypeButton: React.StatelessComponent<BlockTypeButtonProps>;

package/dist/types-ts4.0/plugins/block-type/ui/ToolbarBlockType/index.d.ts

@@ -0,0 +1,29 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { BlockTypeState } from '../../pm-plugins/main';
+import { BlockType } from '../../types';
+import { MenuItem } from '@atlaskit/editor-common/ui-menu';
+import { EditorView } from 'prosemirror-view';
+export declare type DropdownItem = MenuItem & {
+    value: BlockType;
+};
+export interface Props {
+    isDisabled?: boolean;
+    isSmall?: boolean;
+    isReducedSpacing?: boolean;
+    pluginState: BlockTypeState;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    editorView?: EditorView;
+    setBlockType: (type: string) => void;
+}
+export interface State {
+    active: boolean;
+    isOpenedByKeyboard: boolean;
+}
+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/block-type/ui/ToolbarBlockType/styled.d.ts

@@ -0,0 +1,4 @@
+import { ThemeProps } from '@atlaskit/theme/types';
+export declare const blockTypeMenuItemStyle: (tagName: string, selected?: boolean | undefined) => (themeProps: ThemeProps) => import("@emotion/react").SerializedStyles;
+export declare const keyboardShortcut: import("@emotion/react").SerializedStyles;
+export declare const keyboardShortcutSelect: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.0/plugins/block-type/ui/ToolbarBlockType/toolbar-messages.d.ts

@@ -0,0 +1,7 @@
+export declare const toolbarMessages: {
+    textStyles: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

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

@@ -0,0 +1,2 @@
+import { Node as PMNode } from 'prosemirror-model';
+export declare const isNodeAWrappingBlockNode: (node?: PMNode<any> | null | undefined) => boolean;

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

@@ -0,0 +1,3 @@
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+declare const borderPlugin: NextEditorPlugin<'border'>;
+export default borderPlugin;

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

@@ -0,0 +1,2 @@
+import { Command } from '../../../types';
+export declare function removeBreakout(): Command;

package/dist/types-ts4.0/plugins/breakout/commands/set-breakout-mode.d.ts

@@ -0,0 +1,3 @@
+import { Command } from '../../../types';
+export declare type BreakoutMode = 'wide' | 'full-width' | 'center';
+export declare function setBreakoutMode(mode: BreakoutMode): Command;

package/dist/types-ts4.0/plugins/breakout/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const BreakoutCssClassName: {
+    BREAKOUT_MARK: string;
+    BREAKOUT_MARK_DOM: string;
+};

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

@@ -0,0 +1,8 @@
+import { NextEditorPlugin } from '@atlaskit/editor-common/types';
+interface BreakoutPluginOptions {
+    allowBreakoutButton?: boolean;
+}
+declare const breakoutPlugin: NextEditorPlugin<'breakout', {
+    pluginConfiguration: BreakoutPluginOptions | undefined;
+}>;
+export default breakoutPlugin;

package/dist/types-ts4.0/plugins/breakout/plugin-key.d.ts

@@ -0,0 +1,4 @@
+import { EditorState, PluginKey } from 'prosemirror-state';
+import { BreakoutPluginState } from './types';
+export declare const pluginKey: PluginKey<BreakoutPluginState, any>;
+export declare const getPluginState: (state: EditorState) => BreakoutPluginState;

package/dist/types-ts4.0/plugins/breakout/types.d.ts

@@ -0,0 +1,4 @@
+import { Node as PMNode } from 'prosemirror-model';
+export interface BreakoutPluginState {
+    breakoutNode: PMNode;
+}

package/dist/types-ts4.0/plugins/breakout/ui/LayoutButton.d.ts

@@ -0,0 +1,17 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { EditorView } from 'prosemirror-view';
+import { Node as PMNode } from 'prosemirror-model';
+interface Props {
+    editorView: EditorView;
+    mountPoint?: HTMLElement;
+    node: PMNode | null;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    handleClick?: Function;
+}
+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/breakout/utils/find-breakout-node.d.ts

@@ -0,0 +1,9 @@
+import { Selection } from 'prosemirror-state';
+import { ContentNodeWithPos } from 'prosemirror-utils';
+/**
+ * Find the nearest parent node to the selection that supports breakout, or if the nearest
+ * matching parent node is the doc, return undefined.
+ * For depth, if a node is selected and supports breakout, return the depth of the node.
+ * @param selection Current editor selection
+ */
+export declare function findSupportedNodeForBreakout(selection: Selection): ContentNodeWithPos | undefined;

package/dist/types-ts4.0/plugins/breakout/utils/get-breakout-mode.d.ts

@@ -0,0 +1,7 @@
+import { EditorState } from 'prosemirror-state';
+import { BreakoutMode } from '../commands/set-breakout-mode';
+/**
+ * Get the current mode of the breakout at the selection
+ * @param state Current EditorState
+ */
+export declare function getBreakoutMode(state: EditorState): BreakoutMode | undefined;

package/dist/types-ts4.0/plugins/breakout/utils/is-breakout-mark-allowed.d.ts

@@ -0,0 +1,9 @@
+import { EditorState } from 'prosemirror-state';
+/**
+ * Check if breakout should be allowed for the current selection. If a node is selected,
+ * can this node be broken out, if text, can the enclosing parent node be broken out.
+ *
+ * Currently breakout of a node is not possible if it's nested in anything but the document, however
+ * this logic supports this changing.
+ */
+export declare function isBreakoutMarkAllowed(state: EditorState): boolean;