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

package/README.md

@@ -7,8 +7,8 @@
 ## Introduction
 tiptap is a headless wrapper around [ProseMirror](https://ProseMirror.net) – a toolkit for building rich text WYSIWYG editors, which is already in use at many well-known companies such as *New York Times*, *The Guardian* or *Atlassian*.
 
-## Offical Documentation
+## Official Documentation
 Documentation can be found on the [tiptap website](https://tiptap.dev).
 
 ## License
-tiptap is open-sourced software licensed under the [MIT license](https://github.com/ueberdosis/tiptap-next/blob/main/LICENSE.md).
+tiptap is open sourced software licensed under the [MIT license](https://github.com/ueberdosis/tiptap/blob/main/LICENSE.md).

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

@@ -1,13 +1,20 @@
 import { EditorState, Transaction } from 'prosemirror-state';
 import { Editor } from './Editor';
-import { SingleCommands, ChainedCommands, CanCommands, RawCommands, CommandProps } from './types';
-export default class CommandManager {
+import { AnyCommands, CanCommands, ChainedCommands, CommandProps, SingleCommands } from './types';
+export declare class CommandManager {
     editor: Editor;
-    commands: RawCommands;
-    constructor(editor: Editor, commands: RawCommands);
-    createCommands(): SingleCommands;
+    rawCommands: AnyCommands;
+    customState?: EditorState;
+    constructor(props: {
+        editor: Editor;
+        state?: EditorState;
+    });
+    get hasCustomState(): boolean;
+    get state(): EditorState;
+    get commands(): SingleCommands;
+    get chain(): () => ChainedCommands;
+    get can(): () => CanCommands;
     createChain(startTr?: Transaction, shouldDispatch?: boolean): ChainedCommands;
     createCan(startTr?: Transaction): CanCommands;
     buildProps(tr: Transaction, shouldDispatch?: boolean): CommandProps;
-    chainableState(tr: Transaction, state: EditorState): EditorState;
 }

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

@@ -1,23 +1,28 @@
-import { EditorState, Plugin, Transaction } from 'prosemirror-state';
+import { MarkType, NodeType, Schema } from 'prosemirror-model';
+import { EditorState, Plugin, PluginKey, Transaction } from 'prosemirror-state';
 import { EditorView } from 'prosemirror-view';
-import { Schema, Node } from 'prosemirror-model';
-import ExtensionManager from './ExtensionManager';
-import EventEmitter from './EventEmitter';
-import { EditorOptions, Content, CanCommands, ChainedCommands, SingleCommands, AnyObject } from './types';
+import { EventEmitter } from './EventEmitter';
+import { ExtensionManager } from './ExtensionManager';
 import * as extensions from './extensions';
+import { CanCommands, ChainedCommands, EditorEvents, EditorOptions, JSONContent, SingleCommands, TextSerializer } from './types';
 export { extensions };
 export interface HTMLElement {
     editor?: Editor;
 }
-export declare class Editor extends EventEmitter {
+export declare class Editor extends EventEmitter<EditorEvents> {
     private commandManager;
     extensionManager: ExtensionManager;
     private css;
     schema: Schema;
     view: EditorView;
     isFocused: boolean;
+    extensionStorage: Record<string, any>;
     options: EditorOptions;
     constructor(options?: Partial<EditorOptions>);
+    /**
+     * Returns the editor storage.
+     */
+    get storage(): Record<string, any>;
     /**
      * An object of all registered commands.
      */
@@ -62,9 +67,9 @@ export declare class Editor extends EventEmitter {
     /**
      * Unregister a ProseMirror plugin.
      *
-     * @param name The plugins name
+     * @param nameOrPluginKey The plugins name
      */
-    unregisterPlugin(name: string): void;
+    unregisterPlugin(nameOrPluginKey: string | PluginKey): void;
     /**
      * Creates an extension manager.
      */
@@ -85,13 +90,9 @@ export declare class Editor extends EventEmitter {
      * Creates all node views.
      */
     createNodeViews(): void;
-    /**
-     * Creates a ProseMirror document.
-     */
-    createDocument: (content: Content, parseOptions?: import("prosemirror-model").ParseOptions<any>) => Node;
     isCapturingTransaction: boolean;
     private capturedTransaction;
-    captureTransaction(fn: Function): Transaction<any> | null;
+    captureTransaction(fn: Function): Transaction | null;
     /**
      * The callback over which to send transactions (state updates) produced by the view.
      *
@@ -99,17 +100,9 @@ export declare class Editor extends EventEmitter {
      */
     private dispatchTransaction;
     /**
-     * Get attributes of the currently selected node.
-     *
-     * @param name Name of the node
+     * Get attributes of the currently selected node or mark.
      */
-    getNodeAttributes(name: string): AnyObject;
-    /**
-     * Get attributes of the currently selected mark.
-     *
-     * @param name Name of the mark
-     */
-    getMarkAttributes(name: string): AnyObject;
+    getAttributes(nameOrType: string | NodeType | MarkType): Record<string, any>;
     /**
      * Returns if the currently selected node or mark is active.
      *
@@ -121,17 +114,26 @@ export declare class Editor extends EventEmitter {
     /**
      * Get the document as JSON.
      */
-    getJSON(): AnyObject;
+    getJSON(): JSONContent;
     /**
      * Get the document as HTML.
      */
     getHTML(): string;
+    /**
+     * Get the document as text.
+     */
+    getText(options?: {
+        blockSeparator?: string;
+        textSerializers?: Record<string, TextSerializer>;
+    }): string;
     /**
      * Check if there is no content.
      */
-    isEmpty(): boolean;
+    get isEmpty(): boolean;
     /**
      * Get the number of characters for the current document.
+     *
+     * @deprecated
      */
     getCharacterCount(): number;
     /**

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

@@ -1,7 +1,11 @@
-export default class EventEmitter {
+declare type StringKeyOf<T> = Extract<keyof T, string>;
+declare type CallbackType<T extends Record<string, any>, EventName extends StringKeyOf<T>> = T[EventName] extends any[] ? T[EventName] : [T[EventName]];
+declare type CallbackFunction<T extends Record<string, any>, EventName extends StringKeyOf<T>> = (...props: CallbackType<T, EventName>) => any;
+export declare class EventEmitter<T extends Record<string, any>> {
     private callbacks;
-    on(event: string, fn: Function): this;
-    protected emit(event: string, ...args: any): this;
-    off(event: string, fn?: Function): this;
+    on<EventName extends StringKeyOf<T>>(event: EventName, fn: CallbackFunction<T, EventName>): this;
+    protected emit<EventName extends StringKeyOf<T>>(event: EventName, ...args: CallbackType<T, EventName>): this;
+    off<EventName extends StringKeyOf<T>>(event: EventName, fn?: CallbackFunction<T, EventName>): this;
     protected removeAllListeners(): void;
 }
+export {};

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

@@ -1,113 +1,178 @@
 import { Plugin, Transaction } from 'prosemirror-state';
-import { Command as ProseMirrorCommand } from 'prosemirror-commands';
-import { InputRule } from 'prosemirror-inputrules';
+import { ExtensionConfig } from '.';
 import { Editor } from './Editor';
+import { InputRule } from './InputRule';
+import { Mark } from './Mark';
 import { Node } from './Node';
-import { GlobalAttributes, RawCommands, ExtensionConfig } from './types';
+import { PasteRule } from './PasteRule';
+import { Extensions, GlobalAttributes, KeyboardShortcutCommand, ParentConfig, RawCommands } from './types';
 declare module '@tiptap/core' {
-    interface ExtensionConfig<Options = any> {
+    interface ExtensionConfig<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<ExtensionConfig<Options, Storage>>['addOptions'], undefined>;
+        }) => Options;
+        /**
+         * Default Storage
+         */
+        addStorage?: (this: {
+            name: string;
+            options: Options;
+            parent: Exclude<ParentConfig<ExtensionConfig<Options, Storage>>['addStorage'], undefined>;
+        }) => Storage;
         /**
          * Global attributes
          */
         addGlobalAttributes?: (this: {
+            name: string;
             options: Options;
+            storage: Storage;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addGlobalAttributes'];
         }) => GlobalAttributes | {};
         /**
          * Raw
          */
         addCommands?: (this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addCommands'];
         }) => Partial<RawCommands>;
         /**
          * Keyboard shortcuts
          */
         addKeyboardShortcuts?: (this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addKeyboardShortcuts'];
         }) => {
-            [key: string]: ProseMirrorCommand;
+            [key: string]: KeyboardShortcutCommand;
         };
         /**
          * Input rules
          */
         addInputRules?: (this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addInputRules'];
         }) => InputRule[];
         /**
          * Paste rules
          */
         addPasteRules?: (this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
-        }) => Plugin[];
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addPasteRules'];
+        }) => PasteRule[];
         /**
          * ProseMirror plugins
          */
         addProseMirrorPlugins?: (this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addProseMirrorPlugins'];
         }) => Plugin[];
+        /**
+         * Extensions
+         */
+        addExtensions?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addExtensions'];
+        }) => Extensions;
         /**
          * Extend Node Schema
          */
         extendNodeSchema?: ((this: {
+            name: string;
             options: Options;
-        }, extension: Node) => {
-            [key: string]: any;
-        }) | null;
+            storage: Storage;
+            parent: ParentConfig<ExtensionConfig<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<ExtensionConfig<Options, Storage>>['extendMarkSchema'];
+        }, extension: Mark) => Record<string, any>) | null;
+        /**
+         * The editor is not ready yet.
+         */
+        onBeforeCreate?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onBeforeCreate'];
+        }) => void) | null;
         /**
          * The editor is ready.
          */
         onCreate?: ((this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onCreate'];
         }) => void) | null;
         /**
          * The content has changed.
          */
         onUpdate?: ((this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onUpdate'];
         }) => void) | null;
         /**
          * The selection has changed.
          */
         onSelectionUpdate?: ((this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
-        }) => void) | null;
-        /**
-         * The view has changed.
-         */
-        onViewUpdate?: ((this: {
-            options: Options;
-            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onSelectionUpdate'];
         }) => void) | null;
         /**
          * The editor state has changed.
          */
         onTransaction?: ((this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onTransaction'];
         }, props: {
             transaction: Transaction;
         }) => void) | null;
@@ -115,8 +180,11 @@ declare module '@tiptap/core' {
          * The editor is focused.
          */
         onFocus?: ((this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onFocus'];
         }, props: {
             event: FocusEvent;
         }) => void) | null;
@@ -124,8 +192,11 @@ declare module '@tiptap/core' {
          * The editor isn’t focused anymore.
          */
         onBlur?: ((this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onBlur'];
         }, props: {
             event: FocusEvent;
         }) => void) | null;
@@ -133,18 +204,24 @@ declare module '@tiptap/core' {
          * The editor is destroyed.
          */
         onDestroy?: ((this: {
+            name: string;
             options: Options;
+            storage: Storage;
             editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onDestroy'];
         }) => void) | null;
     }
 }
-export declare class Extension<Options = any> {
-    #private;
+export declare class Extension<Options = any, Storage = any> {
     type: string;
-    config: ExtensionConfig;
+    name: string;
+    parent: Extension | null;
+    child: Extension | null;
     options: Options;
-    constructor(config: ExtensionConfig<Options>);
-    static create<O>(config: ExtensionConfig<O>): Extension<O>;
-    configure(options?: Partial<Options>): Extension<Options>;
-    extend<ExtendedOptions = Options>(extendedConfig: Partial<ExtensionConfig<ExtendedOptions>>): Extension<ExtendedOptions>;
+    storage: Storage;
+    config: ExtensionConfig;
+    constructor(config?: Partial<ExtensionConfig<Options, Storage>>);
+    static create<O = any, S = any>(config?: Partial<ExtensionConfig<O, S>>): Extension<O, S>;
+    configure(options?: Partial<Options>): Extension<Options, Storage>;
+    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig?: Partial<ExtensionConfig<ExtendedOptions, ExtendedStorage>>): Extension<ExtendedOptions, ExtendedStorage>;
 }

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

@@ -1,22 +1,18 @@
-import { Schema, Node as ProsemirrorNode } from 'prosemirror-model';
-import { EditorView, Decoration } from 'prosemirror-view';
+import { Schema } from 'prosemirror-model';
 import { Plugin } from 'prosemirror-state';
 import { Editor } from './Editor';
 import { Extensions, RawCommands } from './types';
-export default class ExtensionManager {
+export declare class ExtensionManager {
     editor: Editor;
     schema: Schema;
     extensions: Extensions;
+    splittableMarks: string[];
     constructor(extensions: Extensions, editor: Editor);
+    static resolve(extensions: Extensions): Extensions;
+    static flatten(extensions: Extensions): Extensions;
+    static sort(extensions: Extensions): Extensions;
     get commands(): RawCommands;
     get plugins(): Plugin[];
-    get attributes(): import("./types").ExtensionAttribute[];
-    get nodeViews(): {
-        [k: string]: (node: ProsemirrorNode, view: EditorView, getPos: (() => number) | boolean, decorations: Decoration[]) => {} | import("prosemirror-view").NodeView<any>;
-    };
-    get textSerializers(): {
-        [k: string]: (props: {
-            node: ProsemirrorNode;
-        }) => string | undefined;
-    };
+    get attributes(): import("@tiptap/core").ExtensionAttribute[];
+    get nodeViews(): any;
 }

package/dist/packages/core/src/InputRule.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 InputRuleMatch = {
+    index: number;
+    text: string;
+    replaceWith?: string;
+    match?: RegExpMatchArray;
+    data?: Record<string, any>;
+};
+export declare type InputRuleFinder = RegExp | ((text: string) => InputRuleMatch | null);
+export declare class InputRule {
+    find: InputRuleFinder;
+    handler: (props: {
+        state: EditorState;
+        range: Range;
+        match: ExtendedRegExpMatchArray;
+        commands: SingleCommands;
+        chain: () => ChainedCommands;
+        can: () => CanCommands;
+    }) => void | null;
+    constructor(config: {
+        find: InputRuleFinder;
+        handler: (props: {
+            state: EditorState;
+            range: Range;
+            match: ExtendedRegExpMatchArray;
+            commands: SingleCommands;
+            chain: () => ChainedCommands;
+            can: () => CanCommands;
+        }) => void | null;
+    });
+}
+/**
+ * Create an input rules plugin. When enabled, it will cause text
+ * input that matches any of the given rules to trigger the rule’s
+ * action.
+ */
+export declare function inputRulesPlugin(props: {
+    editor: Editor;
+    rules: InputRule[];
+}): Plugin;