@atlaskit/editor-common 69.2.1 → 69.3.0

package/dist/types/react-node-view/index.d.ts

@@ -0,0 +1,52 @@
+import React from 'react';
+import { Node as PMNode } from 'prosemirror-model';
+import { Decoration, EditorView, NodeView } from 'prosemirror-view';
+import { EventDispatcher } from '../event-dispatcher';
+import type { PortalProviderAPI } from '../ui/PortalProvider';
+import { ForwardRef, getPosHandler, ReactComponentProps, shouldUpdate } from './types';
+export default class ReactNodeView<P = ReactComponentProps> implements NodeView {
+    private domRef?;
+    private contentDOMWrapper?;
+    private reactComponent?;
+    private portalProviderAPI;
+    private hasAnalyticsContext;
+    private _viewShouldUpdate?;
+    protected eventDispatcher?: EventDispatcher;
+    private hasIntlContext;
+    reactComponentProps: P;
+    view: EditorView;
+    getPos: getPosHandler;
+    contentDOM: Node | undefined;
+    node: PMNode;
+    constructor(node: PMNode, view: EditorView, getPos: getPosHandler, portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, reactComponentProps?: P, reactComponent?: React.ComponentType<any>, hasAnalyticsContext?: boolean, viewShouldUpdate?: shouldUpdate, hasIntlContext?: boolean);
+    /**
+     * This method exists to move initialization logic out of the constructor,
+     * so object can be initialized properly before calling render first time.
+     *
+     * Example:
+     * Instance properties get added to an object only after super call in
+     * constructor, which leads to some methods being undefined during the
+     * first render.
+     */
+    init(): this;
+    private renderReactComponent;
+    createDomRef(): HTMLElement;
+    getContentDOM(): {
+        dom: Node;
+        contentDOM?: Node | null | undefined;
+    } | undefined;
+    handleRef: (node: HTMLElement | null) => void;
+    private _handleRef;
+    render(props: P, forwardRef?: ForwardRef): React.ReactElement<any> | null;
+    update(node: PMNode, _decorations: Array<Decoration>, _innerDecorations?: Array<Decoration>, validUpdate?: (currentNode: PMNode, newNode: PMNode) => boolean): boolean;
+    viewShouldUpdate(nextNode: PMNode): boolean;
+    /**
+     * Copies the attributes from a ProseMirror Node to a DOM node.
+     * @param node The Prosemirror Node from which to source the attributes
+     */
+    setDomAttrs(node: PMNode, element: HTMLElement): void;
+    get dom(): HTMLElement | undefined;
+    destroy(): void;
+    private dispatchAnalyticsEvent;
+    static fromComponent(component: React.ComponentType<any>, portalProviderAPI: PortalProviderAPI, eventDispatcher: EventDispatcher, props?: ReactComponentProps, viewShouldUpdate?: (nextNode: PMNode) => boolean, hasIntlContext?: boolean): (node: PMNode, view: EditorView, getPos: getPosHandler) => ReactNodeView<ReactComponentProps>;
+}

package/dist/types/react-node-view/types.d.ts

@@ -0,0 +1,12 @@
+import type { Node as PMNode } from 'prosemirror-model';
+export interface ReactNodeProps {
+    selected: boolean;
+}
+export declare type ProsemirrorGetPosHandler = () => number;
+export declare type getPosHandler = getPosHandlerNode | boolean;
+export declare type getPosHandlerNode = () => number;
+export declare type ReactComponentProps = {
+    [key: string]: unknown;
+};
+export declare type ForwardRef = (node: HTMLElement | null) => void;
+export declare type shouldUpdate = (nextNode: PMNode) => boolean;

package/dist/types/selection/gap-cursor/selection.d.ts

@@ -0,0 +1,40 @@
+import { Node as PMNode, ResolvedPos, Slice } from 'prosemirror-model';
+import { Selection } from 'prosemirror-state';
+import { Mapping } from 'prosemirror-transform';
+export declare enum Side {
+    LEFT = "left",
+    RIGHT = "right"
+}
+export declare const JSON_ID = "gapcursor";
+export declare class GapCursorSelection extends Selection {
+    readonly side: Side;
+    readonly visible: boolean;
+    /**
+     * Construct a GapCursorSelection
+     * @param {ResolvedPos} $pos resolved position
+     * @param {Side} side side where the gap cursor is drawn
+     */
+    constructor($pos: ResolvedPos, side?: Side);
+    static valid($pos: ResolvedPos): boolean;
+    static findFrom($pos: ResolvedPos, dir: number, mustMove?: boolean): GapCursorSelection | null;
+    static fromJSON(doc: PMNode, json: {
+        pos: number;
+        type: string;
+        side: Side;
+    }): GapCursorSelection;
+    map(doc: PMNode, mapping: Mapping): Selection;
+    eq(other: Selection): boolean;
+    content(): Slice<any>;
+    getBookmark(): GapBookmark;
+    toJSON(): {
+        pos: number;
+        type: string;
+        side: Side;
+    };
+}
+export declare class GapBookmark {
+    private readonly pos;
+    constructor(pos: number);
+    map(mapping: any): GapBookmark;
+    resolve(doc: PMNode): GapCursorSelection | Selection;
+}

package/dist/types/selection/gap-cursor/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { isIgnored } from './is-ignored';
+export { isValidTargetNode } from './is-valid-target-node';

package/dist/types/selection/gap-cursor/utils/is-ignored.d.ts

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

package/dist/types/selection/gap-cursor/utils/is-valid-target-node.d.ts

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

package/dist/types/selection/index.d.ts

@@ -0,0 +1,5 @@
+export { RelativeSelectionPos } from './types';
+export type { SelectionPluginState, EditorSelectionAPI } from './types';
+export { GapCursorSelection, Side, JSON_ID, GapBookmark, } from './gap-cursor/selection';
+export { isIgnored, isValidTargetNode } from './gap-cursor/utils';
+export { isSelectionAtStartOfNode, isSelectionAtEndOfNode } from './utils';

package/dist/types/selection/types.d.ts

@@ -0,0 +1,26 @@
+import { EditorState, Selection, Transaction } from 'prosemirror-state';
+import { DecorationSet } from 'prosemirror-view';
+export declare enum RelativeSelectionPos {
+    Before = "Before",
+    Start = "Start",
+    Inside = "Inside",
+    End = "End"
+}
+export interface SelectionPluginState {
+    /** Selected node class decorations */
+    decorationSet: DecorationSet;
+    /** Selection the decorations were built for */
+    selection: Selection;
+    /**
+     * Relative position of selection to either its parent node or, if a NodeSelection, its own node
+     * Used to manage where the selection should go when using arrow keys
+     */
+    selectionRelativeToNode?: RelativeSelectionPos;
+}
+export declare type EditorSelectionAPI = {
+    setSelectionRelativeToNode: (props: {
+        selectionRelativeToNode?: RelativeSelectionPos;
+        selection?: Selection | null;
+    }) => (state: EditorState) => Transaction;
+    getSelectionPluginState: (state: EditorState) => SelectionPluginState;
+};

package/dist/types/selection/utils.d.ts

@@ -0,0 +1,4 @@
+import { ResolvedPos } from 'prosemirror-model';
+import { ContentNodeWithPos } from 'prosemirror-utils';
+export declare const isSelectionAtStartOfNode: ($pos: ResolvedPos, parentNode?: ContentNodeWithPos | undefined) => boolean;
+export declare const isSelectionAtEndOfNode: ($pos: ResolvedPos, parentNode?: ContentNodeWithPos | undefined) => boolean;

package/dist/types/styles/index.d.ts

@@ -19,3 +19,5 @@ export { tasksAndDecisionsStyles, TaskDecisionSharedCssClassName, } from './shar
 export { StatusSharedCssClassName } from './shared/status';
 export { smartCardSharedStyles, SmartCardSharedCssClassName, } from './shared/smart-card';
 export { CodeBlockSharedCssClassName, codeBlockSharedStyles, } from './shared/code-block';
+export { LAYOUT_SECTION_MARGIN, LAYOUT_COLUMN_PADDING } from './shared/layout';
+export { EXTENSION_PADDING, BODIED_EXT_PADDING } from './shared/extension';

package/dist/types/styles/shared/extension.d.ts

@@ -0,0 +1,2 @@
+export declare const EXTENSION_PADDING: number;
+export declare const BODIED_EXT_PADDING: number;

package/dist/types/styles/shared/layout.d.ts

@@ -0,0 +1,2 @@
+export declare const LAYOUT_SECTION_MARGIN: number;
+export declare const LAYOUT_COLUMN_PADDING: number;

package/dist/types/styles/shared/table.d.ts

@@ -20,6 +20,8 @@ export declare const TableSharedCssClassName: {
     TABLE_CELL_NODEVIEW_CONTENT_DOM: string;
     TABLE_CELL_WRAPPER: string;
     TABLE_HEADER_CELL_WRAPPER: string;
+    TABLE_ROW_CONTROLS_WRAPPER: string;
+    TABLE_COLUMN_CONTROLS_DECORATIONS: string;
 };
 declare const tableSharedStyle: (props: ThemeProps) => import("@emotion/react").SerializedStyles;
 export declare const calcTableWidth: (layout: TableLayout, containerWidth?: number | undefined, addControllerPadding?: boolean) => string;

package/dist/types/transforms/expand.d.ts

@@ -0,0 +1,5 @@
+import { Schema, Slice } from 'prosemirror-model';
+import { EditorState, Selection } from 'prosemirror-state';
+export declare const findExpand: (state: EditorState, selection?: Selection<any> | null | undefined) => import("prosemirror-utils").ContentNodeWithPos | undefined;
+export declare const transformSliceToRemoveOpenExpand: (slice: Slice, schema: Schema) => Slice;
+export declare const transformSliceNestedExpandToExpand: (slice: Slice, schema: Schema) => Slice;

package/dist/types/transforms/extension.d.ts

@@ -0,0 +1,6 @@
+import { Schema, Slice } from 'prosemirror-model';
+/**
+ * Lift content out of "open" top-level bodiedExtensions.
+ * Will not work if bodiedExtensions are nested, or when bodiedExtensions are not in the top level
+ */
+export declare const transformSliceToRemoveOpenBodiedExtension: (slice: Slice, schema: Schema) => Slice<any>;

package/dist/types/transforms/index.d.ts

@@ -0,0 +1,3 @@
+export { unwrapContentFromLayout, removeLayoutFromFirstChild, removeLayoutFromLastChild, transformSliceToRemoveOpenLayoutNodes, } from './layout';
+export { findExpand, transformSliceToRemoveOpenExpand, transformSliceNestedExpandToExpand, } from './expand';
+export { transformSliceToRemoveOpenBodiedExtension } from './extension';

package/dist/types/transforms/layout.d.ts

@@ -0,0 +1,15 @@
+import { Fragment, Node, Schema, Slice } from 'prosemirror-model';
+export declare function unwrapContentFromLayout(maybeLayoutSection: Node): Node | Node[];
+export declare function removeLayoutFromFirstChild(node: Node, i: number): Node<any> | Node<any>[];
+export declare function removeLayoutFromLastChild(node: Node, i: number, fragment: Fragment): Node<any> | Node<any>[];
+/**
+ * When we have a slice that cuts across a layoutSection/layoutColumn
+ * we can end up with unexpected behaviour on paste/drop where a user
+ * is able to add columns to a layoutSection. By 'lifting' any content
+ * inside an 'open' layoutSection/layoutColumn to the top level, we
+ * can ensure prevent this.
+ *
+ * We only care about slices with non-zero openStart / openEnd's here
+ * as we're totally fine for people to copy/paste a full layoutSection
+ */
+export declare function transformSliceToRemoveOpenLayoutNodes(slice: Slice, schema: Schema): Slice<any>;

package/dist/types/types/command.d.ts

@@ -0,0 +1,5 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+export declare type CommandDispatch = (tr: Transaction) => void;
+export declare type Command = (state: EditorState, dispatch?: CommandDispatch, view?: EditorView) => boolean;
+export declare type HigherOrderCommand = (command: Command) => Command;

package/dist/types/types/context-panel.d.ts

@@ -0,0 +1,3 @@
+import type React from 'react';
+import type { EditorState } from 'prosemirror-state';
+export declare type ContextPanelHandler = (state: EditorState) => React.ReactNode;

package/dist/types/types/editor-actions.d.ts

@@ -0,0 +1,19 @@
+import { Node } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import { ResolvedEditorState } from '../collab';
+import { EventDispatcher } from '../event-dispatcher';
+export declare type ContextUpdateHandler = (editorView: EditorView, eventDispatcher: EventDispatcher) => void;
+export interface EditorActionsOptions<T = any> {
+    focus(): boolean;
+    blur(): boolean;
+    clear(): boolean;
+    getValue(): Promise<T | JSONDocNode | undefined>;
+    getNodeByLocalId(id: string): Node | undefined;
+    getSelectedNode(): Node | undefined;
+    replaceDocument(rawValue: any): boolean;
+    replaceSelection(rawValue: Node | Object | string): boolean;
+    appendText(text: string): boolean;
+    isDocumentEmpty(): boolean;
+    getResolvedEditorState(): Promise<ResolvedEditorState | undefined>;
+}

package/dist/types/types/editor-appearance.d.ts

@@ -0,0 +1 @@
+export declare type EditorAppearance = 'comment' | 'full-page' | 'full-width' | 'chromeless' | 'mobile';

package/dist/types/types/editor-container-width.d.ts

@@ -0,0 +1,6 @@
+export declare type EditorContainerWidth = {
+    width: number;
+    containerWidth?: number;
+    lineLength?: number;
+};
+export declare type GetEditorContainerWidth = () => EditorContainerWidth;

package/dist/types/types/editor-plugin.d.ts

@@ -0,0 +1,61 @@
+import type { EditorState, Transaction } from 'prosemirror-state';
+import type { ContextPanelHandler } from './context-panel';
+import type { FloatingToolbarHandler } from './floating-toolbar';
+import type { PMPlugin } from './plugin-factory';
+import type { MarkConfig, NodeConfig } from './prosemirror-config';
+import type { QuickInsertHandler } from './quick-insert';
+import type { ToolbarUIComponentFactory } from './toolbar';
+import type { TypeAheadHandler } from './type-ahead';
+import type { UIComponentFactory } from './ui-components';
+export declare type PluginsOptions = {
+    [pluginName: string]: any;
+    quickInsert?: QuickInsertHandler;
+    typeAhead?: TypeAheadHandler;
+    floatingToolbar?: FloatingToolbarHandler;
+    contextPanel?: ContextPanelHandler;
+};
+declare type EditorViewStateUpdatedCallbackProps = {
+    readonly originalTransaction: Readonly<Transaction>;
+    readonly transactions: Transaction[];
+    readonly oldEditorState: Readonly<EditorState>;
+    readonly newEditorState: Readonly<EditorState>;
+};
+export interface EditorPlugin {
+    /**
+     * Name of a plugin, that other plugins can use to provide options to it or exclude via a preset.
+     */
+    name: string;
+    /**
+     * Options that will be passed to a plugin with a corresponding name if it exists and enabled.
+     */
+    pluginsOptions?: PluginsOptions;
+    /**
+     * List of ProseMirror-plugins. This is where we define which plugins will be added to EditorView (main-plugin, keybindings, input-rules, etc.).
+     */
+    pmPlugins?: (pluginOptions?: any) => Array<PMPlugin>;
+    /**
+     * List of Nodes to add to the schema.
+     */
+    nodes?: () => NodeConfig[];
+    /**
+     * List of Marks to add to the schema.
+     */
+    marks?: () => MarkConfig[];
+    /**
+     * Optional UI-component that lives inside the actual content-area (like mention-picker, floating toolbar for links, etc.)
+     */
+    contentComponent?: UIComponentFactory;
+    /**
+     * Optional UI-component that will be added to the toolbar at the top of the editor (doesn't exist in the compact-editor).
+     */
+    primaryToolbarComponent?: ToolbarUIComponentFactory;
+    /**
+     * Optional UI-component that will be added to the toolbar at the bottom right of the editor. (doesn't exist in the full-page editor)
+     * In compact mode this toolbar lives on the right-hand side of the editor.
+     */
+    secondaryToolbarComponent?: UIComponentFactory;
+    onEditorViewStateUpdated?: (props: EditorViewStateUpdatedCallbackProps) => void;
+}
+export declare type getPosHandler = getPosHandlerNode | boolean;
+export declare type getPosHandlerNode = () => number;
+export {};

package/dist/types/types/editor-react-context.d.ts

@@ -0,0 +1,6 @@
+import type { IntlShape } from 'react-intl-next';
+import type { UIAnalyticsEventHandler } from '@atlaskit/analytics-next';
+export declare type EditorReactContext = {
+    getAtlaskitAnalyticsEventHandlers: () => UIAnalyticsEventHandler[];
+    intl: IntlShape;
+};

package/dist/types/types/empty-state-handler.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare type EmptyStateHandler = (params: EmptyStateHandlerParams) => React.ReactElement<any> | null;
+export declare type EmptyStateHandlerParams = {
+    mode: string;
+    selectedCategory?: string;
+    searchTerm?: string;
+};