@tiptap/react 2.0.0-beta.91 → 2.0.0-beta.95

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

@@ -0,0 +1,27 @@
+import { Decoration, NodeView as ProseMirrorNodeView } from 'prosemirror-view';
+import { Node as ProseMirrorNode } from 'prosemirror-model';
+import { Editor as CoreEditor } from './Editor';
+import { Node } from './Node';
+import { NodeViewRendererProps, NodeViewRendererOptions } from './types';
+export declare class NodeView<Component, Editor extends CoreEditor = CoreEditor, Options extends NodeViewRendererOptions = NodeViewRendererOptions> implements ProseMirrorNodeView {
+    component: Component;
+    editor: Editor;
+    options: Options;
+    extension: Node;
+    node: ProseMirrorNode;
+    decorations: Decoration[];
+    getPos: any;
+    isDragging: boolean;
+    constructor(component: Component, props: NodeViewRendererProps, options?: Partial<Options>);
+    mount(): void;
+    get dom(): Element | null;
+    get contentDOM(): Element | 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 'prosemirror-state';
+import { Editor } from './Editor';
+import { Range, ExtendedRegExpMatchArray, SingleCommands, ChainedCommands, CanCommands } 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;
+    constructor(config: {
+        find: PasteRuleFinder;
+        handler: (props: {
+            state: EditorState;
+            range: Range;
+            match: ExtendedRegExpMatchArray;
+            commands: SingleCommands;
+            chain: () => ChainedCommands;
+            can: () => CanCommands;
+        }) => void;
+    });
+}
+/**
+ * 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 'prosemirror-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/deleteNode.d.ts

@@ -0,0 +1,13 @@
+import { NodeType } from 'prosemirror-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 { RawCommands, Range } 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 'prosemirror-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,12 @@
+import { RawCommands, FocusPosition } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        focus: {
+            /**
+             * Focus the editor at the given position.
+             */
+            focus: (position?: FocusPosition) => ReturnType;
+        };
+    }
+}
+export declare const focus: RawCommands['focus'];

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

@@ -0,0 +1,14 @@
+import { CommandProps, RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        forEach: {
+            /**
+             * Loop through an array of items.
+             */
+            forEach: <T>(items: T[], fn: (item: T, props: CommandProps & {
+                index: number;
+            }) => boolean) => ReturnType;
+        };
+    }
+}
+export declare const forEach: RawCommands['forEach'];

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

@@ -0,0 +1,16 @@
+import { ParseOptions } from 'prosemirror-model';
+import { RawCommands, Content } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        insertContent: {
+            /**
+             * Insert a node or string of HTML at the current position.
+             */
+            insertContent: (value: Content, options?: {
+                parseOptions?: ParseOptions;
+                updateSelection?: boolean;
+            }) => ReturnType;
+        };
+    }
+}
+export declare const insertContent: RawCommands['insertContent'];

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

@@ -0,0 +1,16 @@
+import { ParseOptions } from 'prosemirror-model';
+import { RawCommands, Content, Range } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        insertContentAt: {
+            /**
+             * Insert a node or string of HTML at a specific position.
+             */
+            insertContentAt: (position: number | Range, value: Content, options?: {
+                parseOptions?: ParseOptions;
+                updateSelection?: boolean;
+            }) => ReturnType;
+        };
+    }
+}
+export declare const insertContentAt: RawCommands['insertContentAt'];

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+import { NodeType } from 'prosemirror-model';
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        lift: {
+            /**
+             * Removes an existing wrap.
+             */
+            lift: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType;
+        };
+    }
+}
+export declare const lift: RawCommands['lift'];

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

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

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

@@ -0,0 +1,13 @@
+import { NodeType } from 'prosemirror-model';
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        liftListItem: {
+            /**
+             * Lift the list item into a wrapping list.
+             */
+            liftListItem: (typeOrName: string | NodeType) => ReturnType;
+        };
+    }
+}
+export declare const liftListItem: RawCommands['liftListItem'];

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

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

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

@@ -0,0 +1,13 @@
+import { NodeType, MarkType } from 'prosemirror-model';
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        resetAttributes: {
+            /**
+             * Resets some node attributes to the default value.
+             */
+            resetAttributes: (typeOrName: string | NodeType | MarkType, attributes: string | string[]) => ReturnType;
+        };
+    }
+}
+export declare const resetAttributes: RawCommands['resetAttributes'];

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+import { ParseOptions } from 'prosemirror-model';
+import { RawCommands, Content } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        setContent: {
+            /**
+             * Replace the whole document with new content.
+             */
+            setContent: (content: Content, emitUpdate?: boolean, parseOptions?: ParseOptions) => ReturnType;
+        };
+    }
+}
+export declare const setContent: RawCommands['setContent'];

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

@@ -0,0 +1,13 @@
+import { MarkType } from 'prosemirror-model';
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        setMark: {
+            /**
+             * Add a mark with new attributes.
+             */
+            setMark: (typeOrName: string | MarkType, attributes?: Record<string, any>) => ReturnType;
+        };
+    }
+}
+export declare const setMark: RawCommands['setMark'];

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

@@ -0,0 +1,12 @@
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        setMeta: {
+            /**
+             * Store a metadata property in the current transaction.
+             */
+            setMeta: (key: string, value: any) => ReturnType;
+        };
+    }
+}
+export declare const setMeta: RawCommands['setMeta'];

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

@@ -0,0 +1,13 @@
+import { NodeType } from 'prosemirror-model';
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        setNode: {
+            /**
+             * Replace a given range with a node.
+             */
+            setNode: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType;
+        };
+    }
+}
+export declare const setNode: RawCommands['setNode'];

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

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

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

@@ -0,0 +1,12 @@
+import { RawCommands, Range } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        setTextSelection: {
+            /**
+             * Creates a TextSelection.
+             */
+            setTextSelection: (position: number | Range) => ReturnType;
+        };
+    }
+}
+export declare const setTextSelection: RawCommands['setTextSelection'];

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

@@ -0,0 +1,13 @@
+import { NodeType } from 'prosemirror-model';
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        sinkListItem: {
+            /**
+             * Sink the list item down into an inner list.
+             */
+            sinkListItem: (typeOrName: string | NodeType) => ReturnType;
+        };
+    }
+}
+export declare const sinkListItem: RawCommands['sinkListItem'];

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

@@ -0,0 +1,14 @@
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        splitBlock: {
+            /**
+             * Forks a new node from an existing node.
+             */
+            splitBlock: (options?: {
+                keepMarks?: boolean;
+            }) => ReturnType;
+        };
+    }
+}
+export declare const splitBlock: RawCommands['splitBlock'];

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

@@ -0,0 +1,13 @@
+import { NodeType } from 'prosemirror-model';
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        splitListItem: {
+            /**
+             * Splits one list item into two list items.
+             */
+            splitListItem: (typeOrName: string | NodeType) => ReturnType;
+        };
+    }
+}
+export declare const splitListItem: RawCommands['splitListItem'];

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

@@ -0,0 +1,13 @@
+import { NodeType } from 'prosemirror-model';
+import { RawCommands } from '../types';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        toggleList: {
+            /**
+             * Toggle between different list types.
+             */
+            toggleList: (listTypeOrName: string | NodeType, itemTypeOrName: string | NodeType) => ReturnType;
+        };
+    }
+}
+export declare const toggleList: RawCommands['toggleList'];