@tiptap/core 2.0.0-beta.213 → 2.0.0-beta.215

package/dist/packages/core/src/Node.d.ts

@@ -0,0 +1,397 @@
+import { DOMOutputSpec, Node as ProseMirrorNode, NodeSpec, NodeType } from '@tiptap/pm/model';
+import { Plugin, Transaction } from '@tiptap/pm/state';
+import { NodeConfig } from '.';
+import { Editor } from './Editor';
+import { InputRule } from './InputRule';
+import { PasteRule } from './PasteRule';
+import { Attributes, Extensions, GlobalAttributes, KeyboardShortcutCommand, NodeViewRenderer, ParentConfig, RawCommands } from './types';
+declare module '@tiptap/core' {
+    interface NodeConfig<Options = any, Storage = any> {
+        [key: string]: any;
+        /**
+         * Name
+         */
+        name: string;
+        /**
+         * Priority
+         */
+        priority?: number;
+        /**
+         * Default options
+         */
+        defaultOptions?: Options;
+        /**
+         * Default Options
+         */
+        addOptions?: (this: {
+            name: string;
+            parent: Exclude<ParentConfig<NodeConfig<Options, Storage>>['addOptions'], undefined>;
+        }) => Options;
+        /**
+         * Default Storage
+         */
+        addStorage?: (this: {
+            name: string;
+            options: Options;
+            parent: Exclude<ParentConfig<NodeConfig<Options, Storage>>['addStorage'], undefined>;
+        }) => Storage;
+        /**
+         * Global attributes
+         */
+        addGlobalAttributes?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['addGlobalAttributes'];
+        }) => GlobalAttributes | {};
+        /**
+         * Raw
+         */
+        addCommands?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['addCommands'];
+        }) => Partial<RawCommands>;
+        /**
+         * Keyboard shortcuts
+         */
+        addKeyboardShortcuts?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['addKeyboardShortcuts'];
+        }) => {
+            [key: string]: KeyboardShortcutCommand;
+        };
+        /**
+         * Input rules
+         */
+        addInputRules?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['addInputRules'];
+        }) => InputRule[];
+        /**
+         * Paste rules
+         */
+        addPasteRules?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['addPasteRules'];
+        }) => PasteRule[];
+        /**
+         * ProseMirror plugins
+         */
+        addProseMirrorPlugins?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['addProseMirrorPlugins'];
+        }) => Plugin[];
+        /**
+         * Extensions
+         */
+        addExtensions?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['addExtensions'];
+        }) => Extensions;
+        /**
+         * Extend Node Schema
+         */
+        extendNodeSchema?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['extendNodeSchema'];
+        }, extension: Node) => Record<string, any>) | null;
+        /**
+         * Extend Mark Schema
+         */
+        extendMarkSchema?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['extendMarkSchema'];
+        }, extension: Node) => Record<string, any>) | null;
+        /**
+         * The editor is not ready yet.
+         */
+        onBeforeCreate?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['onBeforeCreate'];
+        }) => void) | null;
+        /**
+         * The editor is ready.
+         */
+        onCreate?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['onCreate'];
+        }) => void) | null;
+        /**
+         * The content has changed.
+         */
+        onUpdate?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['onUpdate'];
+        }) => void) | null;
+        /**
+         * The selection has changed.
+         */
+        onSelectionUpdate?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['onSelectionUpdate'];
+        }) => void) | null;
+        /**
+         * The editor state has changed.
+         */
+        onTransaction?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['onTransaction'];
+        }, props: {
+            transaction: Transaction;
+        }) => void) | null;
+        /**
+         * The editor is focused.
+         */
+        onFocus?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['onFocus'];
+        }, props: {
+            event: FocusEvent;
+        }) => void) | null;
+        /**
+         * The editor isn’t focused anymore.
+         */
+        onBlur?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['onBlur'];
+        }, props: {
+            event: FocusEvent;
+        }) => void) | null;
+        /**
+         * The editor is destroyed.
+         */
+        onDestroy?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['onDestroy'];
+        }) => void) | null;
+        /**
+         * Node View
+         */
+        addNodeView?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['addNodeView'];
+        }) => NodeViewRenderer) | null;
+        /**
+         * TopNode
+         */
+        topNode?: boolean;
+        /**
+         * Content
+         */
+        content?: NodeSpec['content'] | ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['content'];
+        }) => NodeSpec['content']);
+        /**
+         * Marks
+         */
+        marks?: NodeSpec['marks'] | ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['marks'];
+        }) => NodeSpec['marks']);
+        /**
+         * Group
+         */
+        group?: NodeSpec['group'] | ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['group'];
+        }) => NodeSpec['group']);
+        /**
+         * Inline
+         */
+        inline?: NodeSpec['inline'] | ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['inline'];
+        }) => NodeSpec['inline']);
+        /**
+         * Atom
+         */
+        atom?: NodeSpec['atom'] | ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['atom'];
+        }) => NodeSpec['atom']);
+        /**
+         * Selectable
+         */
+        selectable?: NodeSpec['selectable'] | ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['selectable'];
+        }) => NodeSpec['selectable']);
+        /**
+         * Draggable
+         */
+        draggable?: NodeSpec['draggable'] | ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['draggable'];
+        }) => NodeSpec['draggable']);
+        /**
+         * Code
+         */
+        code?: NodeSpec['code'] | ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['code'];
+        }) => NodeSpec['code']);
+        /**
+         * Whitespace
+         */
+        whitespace?: NodeSpec['whitespace'] | ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['whitespace'];
+        }) => NodeSpec['whitespace']);
+        /**
+         * Defining
+         */
+        defining?: NodeSpec['defining'] | ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['defining'];
+        }) => NodeSpec['defining']);
+        /**
+         * Isolating
+         */
+        isolating?: NodeSpec['isolating'] | ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['isolating'];
+        }) => NodeSpec['isolating']);
+        /**
+         * Parse HTML
+         */
+        parseHTML?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['parseHTML'];
+        }) => NodeSpec['parseDOM'];
+        /**
+         * Render HTML
+         */
+        renderHTML?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['renderHTML'];
+        }, props: {
+            node: ProseMirrorNode;
+            HTMLAttributes: Record<string, any>;
+        }) => DOMOutputSpec) | null;
+        /**
+         * Render Text
+         */
+        renderText?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['renderText'];
+        }, props: {
+            node: ProseMirrorNode;
+            pos: number;
+            parent: ProseMirrorNode;
+            index: number;
+        }) => string) | null;
+        /**
+         * Add Attributes
+         */
+        addAttributes?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['addAttributes'];
+        }) => Attributes | {};
+    }
+}
+export declare class Node<Options = any, Storage = any> {
+    type: string;
+    name: string;
+    parent: Node | null;
+    child: Node | null;
+    options: Options;
+    storage: Storage;
+    config: NodeConfig;
+    constructor(config?: Partial<NodeConfig<Options, Storage>>);
+    static create<O = any, S = any>(config?: Partial<NodeConfig<O, S>>): Node<O, S>;
+    configure(options?: Partial<Options>): Node<Options, Storage>;
+    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig?: Partial<NodeConfig<ExtendedOptions, ExtendedStorage>>): Node<ExtendedOptions, ExtendedStorage>;
+}

package/dist/packages/core/src/NodeView.d.ts

@@ -0,0 +1,27 @@
+import { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import { Decoration, NodeView as ProseMirrorNodeView } from '@tiptap/pm/view';
+import { Editor as CoreEditor } from './Editor';
+import { Node } from './Node';
+import { NodeViewRendererOptions, NodeViewRendererProps } from './types';
+export declare class NodeView<Component, NodeEditor extends CoreEditor = CoreEditor, Options extends NodeViewRendererOptions = NodeViewRendererOptions> implements ProseMirrorNodeView {
+    component: Component;
+    editor: NodeEditor;
+    options: Options;
+    extension: Node;
+    node: ProseMirrorNode;
+    decorations: Decoration[];
+    getPos: any;
+    isDragging: boolean;
+    constructor(component: Component, props: NodeViewRendererProps, options?: Partial<Options>);
+    mount(): void;
+    get dom(): HTMLElement;
+    get contentDOM(): HTMLElement | null;
+    onDragStart(event: DragEvent): void;
+    stopEvent(event: Event): boolean;
+    ignoreMutation(mutation: MutationRecord | {
+        type: 'selection';
+        target: Element;
+    }): boolean;
+    updateAttributes(attributes: {}): void;
+    deleteNode(): void;
+}

package/dist/packages/core/src/PasteRule.d.ts

@@ -0,0 +1,42 @@
+import { EditorState, Plugin } from '@tiptap/pm/state';
+import { Editor } from './Editor';
+import { CanCommands, ChainedCommands, ExtendedRegExpMatchArray, Range, SingleCommands } from './types';
+export declare type PasteRuleMatch = {
+    index: number;
+    text: string;
+    replaceWith?: string;
+    match?: RegExpMatchArray;
+    data?: Record<string, any>;
+};
+export declare type PasteRuleFinder = RegExp | ((text: string) => PasteRuleMatch[] | null | undefined);
+export declare class PasteRule {
+    find: PasteRuleFinder;
+    handler: (props: {
+        state: EditorState;
+        range: Range;
+        match: ExtendedRegExpMatchArray;
+        commands: SingleCommands;
+        chain: () => ChainedCommands;
+        can: () => CanCommands;
+    }) => void | null;
+    constructor(config: {
+        find: PasteRuleFinder;
+        handler: (props: {
+            state: EditorState;
+            range: Range;
+            match: ExtendedRegExpMatchArray;
+            commands: SingleCommands;
+            chain: () => ChainedCommands;
+            can: () => CanCommands;
+        }) => void | null;
+    });
+}
+/**
+ * Create an paste rules plugin. When enabled, it will cause pasted
+ * text that matches any of the given rules to trigger the rule’s
+ * action.
+ */
+export declare function pasteRulesPlugin(props: {
+    editor: Editor;
+    rules: PasteRule[];
+}): Plugin[];

package/dist/packages/core/src/Tracker.d.ts

@@ -0,0 +1,11 @@
+import { Transaction } from '@tiptap/pm/state';
+export interface TrackerResult {
+    position: number;
+    deleted: boolean;
+}
+export declare class Tracker {
+    transaction: Transaction;
+    currentStep: number;
+    constructor(transaction: Transaction);
+    map(position: number): TrackerResult;
+}

package/dist/packages/core/src/commands/blur.d.ts

@@ -0,0 +1,12 @@
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        blur: {
+            /**
+             * Removes focus from the editor.
+             */
+            blur: () => ReturnType;
+        };
+    }
+}
+export declare const blur: RawCommands['blur'];

package/dist/packages/core/src/commands/clearContent.d.ts

@@ -0,0 +1,12 @@
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        clearContent: {
+            /**
+             * Clear the whole document.
+             */
+            clearContent: (emitUpdate?: boolean) => ReturnType;
+        };
+    }
+}
+export declare const clearContent: RawCommands['clearContent'];

package/dist/packages/core/src/commands/clearNodes.d.ts

@@ -0,0 +1,12 @@
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        clearNodes: {
+            /**
+             * Normalize nodes to a simple paragraph.
+             */
+            clearNodes: () => ReturnType;
+        };
+    }
+}
+export declare const clearNodes: RawCommands['clearNodes'];

package/dist/packages/core/src/commands/command.d.ts

@@ -0,0 +1,12 @@
+import { Command, RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        command: {
+            /**
+             * Define a command inline.
+             */
+            command: (fn: (props: Parameters<Command>[0]) => boolean) => ReturnType;
+        };
+    }
+}
+export declare const command: RawCommands['command'];

package/dist/packages/core/src/commands/createParagraphNear.d.ts

@@ -0,0 +1,12 @@
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        createParagraphNear: {
+            /**
+             * Create a paragraph nearby.
+             */
+            createParagraphNear: () => ReturnType;
+        };
+    }
+}
+export declare const createParagraphNear: RawCommands['createParagraphNear'];

package/dist/packages/core/src/commands/deleteCurrentNode.d.ts

@@ -0,0 +1,12 @@
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        deleteCurrentNode: {
+            /**
+             * Delete the node that currently has the selection anchor.
+             */
+            deleteCurrentNode: () => ReturnType;
+        };
+    }
+}
+export declare const deleteCurrentNode: RawCommands['deleteCurrentNode'];

package/dist/packages/core/src/commands/deleteNode.d.ts

@@ -0,0 +1,13 @@
+import { NodeType } from '@tiptap/pm/model';
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        deleteNode: {
+            /**
+             * Delete a node.
+             */
+            deleteNode: (typeOrName: string | NodeType) => ReturnType;
+        };
+    }
+}
+export declare const deleteNode: RawCommands['deleteNode'];

package/dist/packages/core/src/commands/deleteRange.d.ts

@@ -0,0 +1,12 @@
+import { Range, RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        deleteRange: {
+            /**
+             * Delete a given range.
+             */
+            deleteRange: (range: Range) => ReturnType;
+        };
+    }
+}
+export declare const deleteRange: RawCommands['deleteRange'];

package/dist/packages/core/src/commands/deleteSelection.d.ts

@@ -0,0 +1,12 @@
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        deleteSelection: {
+            /**
+             * Delete the selection, if there is one.
+             */
+            deleteSelection: () => ReturnType;
+        };
+    }
+}
+export declare const deleteSelection: RawCommands['deleteSelection'];

package/dist/packages/core/src/commands/enter.d.ts

@@ -0,0 +1,12 @@
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        enter: {
+            /**
+             * Trigger enter.
+             */
+            enter: () => ReturnType;
+        };
+    }
+}
+export declare const enter: RawCommands['enter'];

package/dist/packages/core/src/commands/exitCode.d.ts

@@ -0,0 +1,12 @@
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        exitCode: {
+            /**
+             * Exit from a code block.
+             */
+            exitCode: () => ReturnType;
+        };
+    }
+}
+export declare const exitCode: RawCommands['exitCode'];

package/dist/packages/core/src/commands/extendMarkRange.d.ts

@@ -0,0 +1,13 @@
+import { MarkType } from '@tiptap/pm/model';
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        extendMarkRange: {
+            /**
+             * Extends the text selection to the current mark.
+             */
+            extendMarkRange: (typeOrName: string | MarkType, attributes?: Record<string, any>) => ReturnType;
+        };
+    }
+}
+export declare const extendMarkRange: RawCommands['extendMarkRange'];

package/dist/packages/core/src/commands/first.d.ts

@@ -0,0 +1,12 @@
+import { Command, CommandProps, RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        first: {
+            /**
+             * Runs one command after the other and stops at the first which returns true.
+             */
+            first: (commands: Command[] | ((props: CommandProps) => Command[])) => ReturnType;
+        };
+    }
+}
+export declare const first: RawCommands['first'];

package/dist/packages/core/src/commands/focus.d.ts

@@ -0,0 +1,14 @@
+import { FocusPosition, RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        focus: {
+            /**
+             * Focus the editor at the given position.
+             */
+            focus: (position?: FocusPosition, options?: {
+                scrollIntoView?: boolean;
+            }) => ReturnType;
+        };
+    }
+}
+export declare const focus: RawCommands['focus'];