@tiptap/core 2.0.0-beta.2 → 2.0.0-beta.200

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

@@ -1,123 +1,187 @@
-import { DOMOutputSpec, NodeSpec, Node as ProseMirrorNode, NodeType } from 'prosemirror-model';
-import { Command as ProseMirrorCommand } from 'prosemirror-commands';
+import { DOMOutputSpec, Node as ProseMirrorNode, NodeSpec, NodeType } from 'prosemirror-model';
 import { Plugin, Transaction } from 'prosemirror-state';
-import { InputRule } from 'prosemirror-inputrules';
-import { Attributes, NodeViewRenderer, GlobalAttributes, RawCommands, NodeConfig } from './types';
+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> {
+    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]: ProseMirrorCommand;
+            [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;
-        }) => Plugin[];
+            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;
-        }, extension: Node) => {
-            [key: string]: any;
-        }) | null;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['extendNodeSchema'];
+        }, extension: Node) => Record<string, any>) | null;
         /**
          * Extend Mark Schema
          */
         extendMarkSchema?: ((this: {
+            name: string;
             options: Options;
-        }, extension: Node) => {
-            [key: string]: any;
-        }) | null;
+            storage: Storage;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['extendMarkSchema'];
+        }, extension: Node) => Record<string, any>) | null;
         /**
-         * The editor is ready.
+         * The editor is not ready yet.
          */
-        onCreate?: ((this: {
+        onBeforeCreate?: ((this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
             type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['onBeforeCreate'];
         }) => void) | null;
         /**
-         * The content has changed.
+         * The editor is ready.
          */
-        onUpdate?: ((this: {
+        onCreate?: ((this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
             type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['onCreate'];
         }) => void) | null;
         /**
-         * The selection has changed.
+         * The content has changed.
          */
-        onSelectionUpdate?: ((this: {
+        onUpdate?: ((this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
             type: NodeType;
+            parent: ParentConfig<NodeConfig<Options, Storage>>['onUpdate'];
         }) => void) | null;
         /**
-         * The view has changed.
+         * The selection has changed.
          */
-        onViewUpdate?: ((this: {
+        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;
@@ -125,9 +189,12 @@ declare module '@tiptap/core' {
          * 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;
@@ -135,9 +202,12 @@ declare module '@tiptap/core' {
          * 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;
@@ -145,17 +215,23 @@ declare module '@tiptap/core' {
          * 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
@@ -165,104 +241,157 @@ declare module '@tiptap/core' {
          * 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: {
-                [key: string]: any;
-            };
+            HTMLAttributes: Record<string, any>;
         }) => DOMOutputSpec) | null;
         /**
          * Render Text
          */
         renderText?: ((this: {
+            name: string;
             options: Options;
-            editor: Editor;
-            type: NodeType;
+            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> {
-    #private;
+export declare class Node<Options = any, Storage = any> {
     type: string;
-    config: NodeConfig;
+    name: string;
+    parent: Node | null;
+    child: Node | null;
     options: Options;
-    constructor(config: NodeConfig<Options>);
-    static create<O>(config: NodeConfig<O>): Node<O>;
-    configure(options?: Partial<Options>): Node<Options>;
-    extend<ExtendedOptions = Options>(extendedConfig: Partial<NodeConfig<ExtendedOptions>>): Node<ExtendedOptions>;
+    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 'prosemirror-model';
+import { Decoration, NodeView as ProseMirrorNodeView } from 'prosemirror-view';
+import { Editor as CoreEditor } from './Editor';
+import { Node } from './Node';
+import { NodeViewRendererOptions, NodeViewRendererProps } 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(): 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 'prosemirror-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 '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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,11 +1,11 @@
-import { Command, RawCommands } from '../types';
+import { RawCommands } from '../types';
 declare module '@tiptap/core' {
-    interface Commands {
+    interface Commands<ReturnType> {
         enter: {
             /**
              * Trigger enter.
              */
-            enter: () => Command;
+            enter: () => ReturnType;
         };
     }
 }

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

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