@tiptap/core 2.5.0-beta.1 → 2.5.0-beta.3

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

@@ -1,44 +1,44 @@
-import { Fragment, Node, ResolvedPos } from '@tiptap/pm/model';
-import { Editor } from './Editor.js';
-import { Content, Range } from './types.js';
-export declare class NodePos {
-    private resolvedPos;
-    private isBlock;
-    private editor;
-    private get name();
-    constructor(pos: ResolvedPos, editor: Editor, isBlock?: boolean, node?: Node | null);
-    private currentNode;
-    get node(): Node;
-    get element(): HTMLElement;
-    actualDepth: number | null;
-    get depth(): number;
-    get pos(): number;
-    get content(): Fragment;
-    set content(content: Content);
-    get attributes(): {
-        [key: string]: any;
-    };
-    get textContent(): string;
-    get size(): number;
-    get from(): number;
-    get range(): Range;
-    get to(): number;
-    get parent(): NodePos | null;
-    get before(): NodePos | null;
-    get after(): NodePos | null;
-    get children(): NodePos[];
-    get firstChild(): NodePos | null;
-    get lastChild(): NodePos | null;
-    closest(selector: string, attributes?: {
-        [key: string]: any;
-    }): NodePos | null;
-    querySelector(selector: string, attributes?: {
-        [key: string]: any;
-    }): NodePos | null;
-    querySelectorAll(selector: string, attributes?: {
-        [key: string]: any;
-    }, firstItemOnly?: boolean): NodePos[];
-    setAttribute(attributes: {
-        [key: string]: any;
-    }): void;
-}
+import { Fragment, Node, ResolvedPos } from '@tiptap/pm/model';
+import { Editor } from './Editor.js';
+import { Content, Range } from './types.js';
+export declare class NodePos {
+    private resolvedPos;
+    private isBlock;
+    private editor;
+    private get name();
+    constructor(pos: ResolvedPos, editor: Editor, isBlock?: boolean, node?: Node | null);
+    private currentNode;
+    get node(): Node;
+    get element(): HTMLElement;
+    actualDepth: number | null;
+    get depth(): number;
+    get pos(): number;
+    get content(): Fragment;
+    set content(content: Content);
+    get attributes(): {
+        [key: string]: any;
+    };
+    get textContent(): string;
+    get size(): number;
+    get from(): number;
+    get range(): Range;
+    get to(): number;
+    get parent(): NodePos | null;
+    get before(): NodePos | null;
+    get after(): NodePos | null;
+    get children(): NodePos[];
+    get firstChild(): NodePos | null;
+    get lastChild(): NodePos | null;
+    closest(selector: string, attributes?: {
+        [key: string]: any;
+    }): NodePos | null;
+    querySelector(selector: string, attributes?: {
+        [key: string]: any;
+    }): NodePos | null;
+    querySelectorAll(selector: string, attributes?: {
+        [key: string]: any;
+    }, firstItemOnly?: boolean): NodePos[];
+    setAttribute(attributes: {
+        [key: string]: any;
+    }): void;
+}

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

@@ -1,31 +1,31 @@
-import { Node as ProseMirrorNode } from '@tiptap/pm/model';
-import { NodeView as ProseMirrorNodeView } from '@tiptap/pm/view';
-import { Editor as CoreEditor } from './Editor.js';
-import { Node } from './Node.js';
-import { DecorationWithType, NodeViewRendererOptions, NodeViewRendererProps } from './types.js';
-/**
- * Node views are used to customize the rendered DOM structure of a node.
- * @see https://tiptap.dev/guide/node-views
- */
-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: DecorationWithType[];
-    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;
-}
+import { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import { NodeView as ProseMirrorNodeView } from '@tiptap/pm/view';
+import { Editor as CoreEditor } from './Editor.js';
+import { Node } from './Node.js';
+import { DecorationWithType, NodeViewRendererOptions, NodeViewRendererProps } from './types.js';
+/**
+ * Node views are used to customize the rendered DOM structure of a node.
+ * @see https://tiptap.dev/guide/node-views
+ */
+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: DecorationWithType[];
+    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

@@ -1,50 +1,50 @@
-import { EditorState, Plugin } from '@tiptap/pm/state';
-import { Editor } from './Editor.js';
-import { CanCommands, ChainedCommands, ExtendedRegExpMatchArray, Range, SingleCommands } from './types.js';
-export declare type PasteRuleMatch = {
-    index: number;
-    text: string;
-    replaceWith?: string;
-    match?: RegExpMatchArray;
-    data?: Record<string, any>;
-};
-export declare type PasteRuleFinder = RegExp | ((text: string, event?: ClipboardEvent | null) => PasteRuleMatch[] | null | undefined);
-/**
- * Paste rules are used to react to pasted content.
- * @see https://tiptap.dev/guide/custom-extensions/#paste-rules
- */
-export declare class PasteRule {
-    find: PasteRuleFinder;
-    handler: (props: {
-        state: EditorState;
-        range: Range;
-        match: ExtendedRegExpMatchArray;
-        commands: SingleCommands;
-        chain: () => ChainedCommands;
-        can: () => CanCommands;
-        pasteEvent: ClipboardEvent | null;
-        dropEvent: DragEvent | null;
-    }) => void | null;
-    constructor(config: {
-        find: PasteRuleFinder;
-        handler: (props: {
-            can: () => CanCommands;
-            chain: () => ChainedCommands;
-            commands: SingleCommands;
-            dropEvent: DragEvent | null;
-            match: ExtendedRegExpMatchArray;
-            pasteEvent: ClipboardEvent | null;
-            range: Range;
-            state: EditorState;
-        }) => 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[];
+import { EditorState, Plugin } from '@tiptap/pm/state';
+import { Editor } from './Editor.js';
+import { CanCommands, ChainedCommands, ExtendedRegExpMatchArray, Range, SingleCommands } from './types.js';
+export type PasteRuleMatch = {
+    index: number;
+    text: string;
+    replaceWith?: string;
+    match?: RegExpMatchArray;
+    data?: Record<string, any>;
+};
+export type PasteRuleFinder = RegExp | ((text: string, event?: ClipboardEvent | null) => PasteRuleMatch[] | null | undefined);
+/**
+ * Paste rules are used to react to pasted content.
+ * @see https://tiptap.dev/guide/custom-extensions/#paste-rules
+ */
+export declare class PasteRule {
+    find: PasteRuleFinder;
+    handler: (props: {
+        state: EditorState;
+        range: Range;
+        match: ExtendedRegExpMatchArray;
+        commands: SingleCommands;
+        chain: () => ChainedCommands;
+        can: () => CanCommands;
+        pasteEvent: ClipboardEvent | null;
+        dropEvent: DragEvent | null;
+    }) => void | null;
+    constructor(config: {
+        find: PasteRuleFinder;
+        handler: (props: {
+            can: () => CanCommands;
+            chain: () => ChainedCommands;
+            commands: SingleCommands;
+            dropEvent: DragEvent | null;
+            match: ExtendedRegExpMatchArray;
+            pasteEvent: ClipboardEvent | null;
+            range: Range;
+            state: EditorState;
+        }) => 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

@@ -1,11 +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;
-}
+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

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

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

@@ -1,14 +1,14 @@
-import { RawCommands } from '../types.js';
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        clearContent: {
-            /**
-             * Clear the whole document.
-             * @param emitUpdate Whether to emit an update event.
-             * @example editor.commands.clearContent()
-             */
-            clearContent: (emitUpdate?: boolean) => ReturnType;
-        };
-    }
-}
-export declare const clearContent: RawCommands['clearContent'];
+import { RawCommands } from '../types.js';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        clearContent: {
+            /**
+             * Clear the whole document.
+             * @param emitUpdate Whether to emit an update event.
+             * @example editor.commands.clearContent()
+             */
+            clearContent: (emitUpdate?: boolean) => ReturnType;
+        };
+    }
+}
+export declare const clearContent: RawCommands['clearContent'];

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

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

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

@@ -1,18 +1,18 @@
-import { Command, RawCommands } from '../types.js';
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        command: {
-            /**
-             * Define a command inline.
-             * @param fn The command function.
-             * @example
-             * editor.commands.command(({ tr, state }) => {
-             *   ...
-             *   return true
-             * })
-             */
-            command: (fn: (props: Parameters<Command>[0]) => boolean) => ReturnType;
-        };
-    }
-}
-export declare const command: RawCommands['command'];
+import { Command, RawCommands } from '../types.js';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        command: {
+            /**
+             * Define a command inline.
+             * @param fn The command function.
+             * @example
+             * editor.commands.command(({ tr, state }) => {
+             *   ...
+             *   return true
+             * })
+             */
+            command: (fn: (props: Parameters<Command>[0]) => boolean) => ReturnType;
+        };
+    }
+}
+export declare const command: RawCommands['command'];

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

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

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

@@ -1,20 +1,20 @@
-import { RawCommands } from '../types.js';
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        cut: {
-            /**
-             * Cuts content from a range and inserts it at a given position.
-             * @param range The range to cut.
-             * @param range.from The start position of the range.
-             * @param range.to The end position of the range.
-             * @param targetPos The position to insert the content at.
-             * @example editor.commands.cut({ from: 1, to: 3 }, 5)
-             */
-            cut: ({ from, to }: {
-                from: number;
-                to: number;
-            }, targetPos: number) => ReturnType;
-        };
-    }
-}
-export declare const cut: RawCommands['cut'];
+import { RawCommands } from '../types.js';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        cut: {
+            /**
+             * Cuts content from a range and inserts it at a given position.
+             * @param range The range to cut.
+             * @param range.from The start position of the range.
+             * @param range.to The end position of the range.
+             * @param targetPos The position to insert the content at.
+             * @example editor.commands.cut({ from: 1, to: 3 }, 5)
+             */
+            cut: ({ from, to }: {
+                from: number;
+                to: number;
+            }, targetPos: number) => ReturnType;
+        };
+    }
+}
+export declare const cut: RawCommands['cut'];

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

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

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

@@ -1,15 +1,15 @@
-import { NodeType } from '@tiptap/pm/model';
-import { RawCommands } from '../types.js';
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        deleteNode: {
-            /**
-             * Delete a node with a given type or name.
-             * @param typeOrName The type or name of the node.
-             * @example editor.commands.deleteNode('paragraph')
-             */
-            deleteNode: (typeOrName: string | NodeType) => ReturnType;
-        };
-    }
-}
-export declare const deleteNode: RawCommands['deleteNode'];
+import { NodeType } from '@tiptap/pm/model';
+import { RawCommands } from '../types.js';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        deleteNode: {
+            /**
+             * Delete a node with a given type or name.
+             * @param typeOrName The type or name of the node.
+             * @example editor.commands.deleteNode('paragraph')
+             */
+            deleteNode: (typeOrName: string | NodeType) => ReturnType;
+        };
+    }
+}
+export declare const deleteNode: RawCommands['deleteNode'];

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

@@ -1,14 +1,14 @@
-import { Range, RawCommands } from '../types.js';
-declare module '@tiptap/core' {
-    interface Commands<ReturnType> {
-        deleteRange: {
-            /**
-             * Delete a given range.
-             * @param range The range to delete.
-             * @example editor.commands.deleteRange({ from: 1, to: 3 })
-             */
-            deleteRange: (range: Range) => ReturnType;
-        };
-    }
-}
-export declare const deleteRange: RawCommands['deleteRange'];
+import { Range, RawCommands } from '../types.js';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        deleteRange: {
+            /**
+             * Delete a given range.
+             * @param range The range to delete.
+             * @example editor.commands.deleteRange({ from: 1, to: 3 })
+             */
+            deleteRange: (range: Range) => ReturnType;
+        };
+    }
+}
+export declare const deleteRange: RawCommands['deleteRange'];

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

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

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

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

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

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