@tiptap/react 2.0.0-beta.8 → 2.0.0-beta.83

package/LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020, überdosis GbR
+Copyright (c) 2021, überdosis GbR
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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

@@ -0,0 +1,20 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+import { Editor } from './Editor';
+import { SingleCommands, ChainedCommands, CanCommands, AnyCommands, CommandProps } from './types';
+export default class CommandManager {
+    editor: Editor;
+    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;
+}

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

@@ -0,0 +1,140 @@
+import { EditorState, Plugin, PluginKey, Transaction } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { Schema, MarkType, NodeType } from 'prosemirror-model';
+import ExtensionManager from './ExtensionManager';
+import EventEmitter from './EventEmitter';
+import { EditorOptions, CanCommands, ChainedCommands, SingleCommands, TextSerializer, EditorEvents } from './types';
+import * as extensions from './extensions';
+export { extensions };
+export interface HTMLElement {
+    editor?: Editor;
+}
+export declare class Editor extends EventEmitter<EditorEvents> {
+    private commandManager;
+    extensionManager: ExtensionManager;
+    private css;
+    schema: Schema;
+    view: EditorView;
+    isFocused: boolean;
+    options: EditorOptions;
+    constructor(options?: Partial<EditorOptions>);
+    /**
+     * An object of all registered commands.
+     */
+    get commands(): SingleCommands;
+    /**
+     * Create a command chain to call multiple commands at once.
+     */
+    chain(): ChainedCommands;
+    /**
+     * Check if a command or a command chain can be executed. Without executing it.
+     */
+    can(): CanCommands;
+    /**
+     * Inject CSS styles.
+     */
+    private injectCSS;
+    /**
+     * Update editor options.
+     *
+     * @param options A list of options
+     */
+    setOptions(options?: Partial<EditorOptions>): void;
+    /**
+     * Update editable state of the editor.
+     */
+    setEditable(editable: boolean): void;
+    /**
+     * Returns whether the editor is editable.
+     */
+    get isEditable(): boolean;
+    /**
+     * Returns the editor state.
+     */
+    get state(): EditorState;
+    /**
+     * Register a ProseMirror plugin.
+     *
+     * @param plugin A ProseMirror plugin
+     * @param handlePlugins Control how to merge the plugin into the existing plugins.
+     */
+    registerPlugin(plugin: Plugin, handlePlugins?: (newPlugin: Plugin, plugins: Plugin[]) => Plugin[]): void;
+    /**
+     * Unregister a ProseMirror plugin.
+     *
+     * @param nameOrPluginKey The plugins name
+     */
+    unregisterPlugin(nameOrPluginKey: string | PluginKey): void;
+    /**
+     * Creates an extension manager.
+     */
+    private createExtensionManager;
+    /**
+     * Creates an command manager.
+     */
+    private createCommandManager;
+    /**
+     * Creates a ProseMirror schema.
+     */
+    private createSchema;
+    /**
+     * Creates a ProseMirror view.
+     */
+    private createView;
+    /**
+     * Creates all node views.
+     */
+    createNodeViews(): void;
+    isCapturingTransaction: boolean;
+    private capturedTransaction;
+    captureTransaction(fn: Function): Transaction<any> | null;
+    /**
+     * The callback over which to send transactions (state updates) produced by the view.
+     *
+     * @param transaction An editor state transaction
+     */
+    private dispatchTransaction;
+    /**
+     * Get attributes of the currently selected node or mark.
+     */
+    getAttributes(nameOrType: string | NodeType | MarkType): Record<string, any>;
+    /**
+     * Returns if the currently selected node or mark is active.
+     *
+     * @param name Name of the node or mark
+     * @param attributes Attributes of the node or mark
+     */
+    isActive(name: string, attributes?: {}): boolean;
+    isActive(attributes: {}): boolean;
+    /**
+     * Get the document as JSON.
+     */
+    getJSON(): Record<string, any>;
+    /**
+     * 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.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Get the number of characters for the current document.
+     */
+    getCharacterCount(): number;
+    /**
+     * Destroy the editor.
+     */
+    destroy(): void;
+    /**
+     * Check if the editor is already destroyed.
+     */
+    get isDestroyed(): boolean;
+}

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

@@ -0,0 +1,11 @@
+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 default class EventEmitter<T extends Record<string, any>> {
+    private callbacks;
+    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

@@ -0,0 +1,194 @@
+import { Plugin, Transaction } from 'prosemirror-state';
+import { InputRule } from './InputRule';
+import { PasteRule } from './PasteRule';
+import { Editor } from './Editor';
+import { Node } from './Node';
+import { Mark } from './Mark';
+import { Extensions, GlobalAttributes, RawCommands, ParentConfig, KeyboardShortcutCommand } from './types';
+import { ExtensionConfig } from '.';
+declare module '@tiptap/core' {
+    interface ExtensionConfig<Options = any> {
+        [key: string]: any;
+        /**
+         * Name
+         */
+        name: string;
+        /**
+         * Priority
+         */
+        priority?: number;
+        /**
+         * Default options
+         */
+        defaultOptions?: Options;
+        /**
+         * Global attributes
+         */
+        addGlobalAttributes?: (this: {
+            name: string;
+            options: Options;
+            parent: ParentConfig<ExtensionConfig<Options>>['addGlobalAttributes'];
+        }) => GlobalAttributes | {};
+        /**
+         * Raw
+         */
+        addCommands?: (this: {
+            name: string;
+            options: Options;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options>>['addCommands'];
+        }) => Partial<RawCommands>;
+        /**
+         * Keyboard shortcuts
+         */
+        addKeyboardShortcuts?: (this: {
+            name: string;
+            options: Options;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options>>['addKeyboardShortcuts'];
+        }) => {
+            [key: string]: KeyboardShortcutCommand;
+        };
+        /**
+         * Input rules
+         */
+        addInputRules?: (this: {
+            name: string;
+            options: Options;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options>>['addInputRules'];
+        }) => InputRule[];
+        /**
+         * Paste rules
+         */
+        addPasteRules?: (this: {
+            name: string;
+            options: Options;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options>>['addPasteRules'];
+        }) => PasteRule[];
+        /**
+         * ProseMirror plugins
+         */
+        addProseMirrorPlugins?: (this: {
+            name: string;
+            options: Options;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options>>['addProseMirrorPlugins'];
+        }) => Plugin[];
+        /**
+         * Extensions
+         */
+        addExtensions?: (this: {
+            name: string;
+            options: Options;
+            parent: ParentConfig<ExtensionConfig<Options>>['addExtensions'];
+        }) => Extensions;
+        /**
+         * Extend Node Schema
+         */
+        extendNodeSchema?: ((this: {
+            name: string;
+            options: Options;
+            parent: ParentConfig<ExtensionConfig<Options>>['extendNodeSchema'];
+        }, extension: Node) => Record<string, any>) | null;
+        /**
+         * Extend Mark Schema
+         */
+        extendMarkSchema?: ((this: {
+            name: string;
+            options: Options;
+            parent: ParentConfig<ExtensionConfig<Options>>['extendMarkSchema'];
+        }, extension: Mark) => Record<string, any>) | null;
+        /**
+         * The editor is not ready yet.
+         */
+        onBeforeCreate?: ((this: {
+            name: string;
+            options: Options;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options>>['onBeforeCreate'];
+        }) => void) | null;
+        /**
+         * The editor is ready.
+         */
+        onCreate?: ((this: {
+            name: string;
+            options: Options;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options>>['onCreate'];
+        }) => void) | null;
+        /**
+         * The content has changed.
+         */
+        onUpdate?: ((this: {
+            name: string;
+            options: Options;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options>>['onUpdate'];
+        }) => void) | null;
+        /**
+         * The selection has changed.
+         */
+        onSelectionUpdate?: ((this: {
+            name: string;
+            options: Options;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options>>['onSelectionUpdate'];
+        }) => void) | null;
+        /**
+         * The editor state has changed.
+         */
+        onTransaction?: ((this: {
+            name: string;
+            options: Options;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options>>['onTransaction'];
+        }, props: {
+            transaction: Transaction;
+        }) => void) | null;
+        /**
+         * The editor is focused.
+         */
+        onFocus?: ((this: {
+            name: string;
+            options: Options;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options>>['onFocus'];
+        }, props: {
+            event: FocusEvent;
+        }) => void) | null;
+        /**
+         * The editor isn’t focused anymore.
+         */
+        onBlur?: ((this: {
+            name: string;
+            options: Options;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options>>['onBlur'];
+        }, props: {
+            event: FocusEvent;
+        }) => void) | null;
+        /**
+         * The editor is destroyed.
+         */
+        onDestroy?: ((this: {
+            name: string;
+            options: Options;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options>>['onDestroy'];
+        }) => void) | null;
+    }
+}
+export declare class Extension<Options = any> {
+    type: string;
+    name: string;
+    parent: Extension | null;
+    child: Extension | null;
+    options: Options;
+    config: ExtensionConfig;
+    constructor(config?: Partial<ExtensionConfig<Options>>);
+    static create<O>(config?: Partial<ExtensionConfig<O>>): Extension<O>;
+    configure(options?: Partial<Options>): Extension<Options>;
+    extend<ExtendedOptions = Options>(extendedConfig?: Partial<ExtensionConfig<ExtendedOptions>>): Extension<ExtendedOptions>;
+}

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

@@ -0,0 +1,18 @@
+import { Schema } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+import { Editor } from './Editor';
+import { Extensions, RawCommands } from './types';
+export default 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("@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 { Range, ExtendedRegExpMatchArray, SingleCommands, ChainedCommands, CanCommands } 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;
+    constructor(config: {
+        find: InputRuleFinder;
+        handler: (props: {
+            state: EditorState;
+            range: Range;
+            match: ExtendedRegExpMatchArray;
+            commands: SingleCommands;
+            chain: () => ChainedCommands;
+            can: () => CanCommands;
+        }) => void;
+    });
+}
+/**
+ * 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;