@tiptap/starter-kit 2.0.0-beta.103 → 2.0.0-beta.107

package/dist/demos/setup/helper.d.ts

@@ -0,0 +1,2 @@
+export declare function splitName(name: string): string[];
+export declare function debug(): void;

package/dist/demos/setup/react.d.ts

@@ -0,0 +1,3 @@
+import 'iframe-resizer/js/iframeResizer.contentWindow';
+import './style.scss';
+export default function init(name: string, source: any): void;

package/dist/demos/setup/vue.d.ts

@@ -0,0 +1,3 @@
+import 'iframe-resizer/js/iframeResizer.contentWindow';
+import './style.scss';
+export default function init(name: string, source: any): void;

package/dist/demos/src/Examples/Savvy/Vue/ColorHighlighter.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '@tiptap/core';
+export declare const ColorHighlighter: Extension<unknown>;

package/dist/demos/src/Examples/Savvy/Vue/SmilieReplacer.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '@tiptap/core';
+export declare const SmilieReplacer: Extension<unknown>;

package/dist/demos/src/Examples/Savvy/Vue/findColors.d.ts

@@ -0,0 +1,3 @@
+import { DecorationSet } from 'prosemirror-view';
+import { Node } from 'prosemirror-model';
+export default function (doc: Node): DecorationSet;

package/dist/demos/src/Experiments/CollaborationAnnotation/Vue/extension/AnnotationItem.d.ts

@@ -0,0 +1,10 @@
+export declare class AnnotationItem {
+    private decoration;
+    constructor(decoration: any);
+    get id(): any;
+    get from(): any;
+    get to(): any;
+    get data(): any;
+    get HTMLAttributes(): any;
+    toString(): string;
+}

package/dist/demos/src/Experiments/CollaborationAnnotation/Vue/extension/AnnotationPlugin.d.ts

@@ -0,0 +1,12 @@
+import * as Y from 'yjs';
+import { Plugin, PluginKey } from 'prosemirror-state';
+export declare const AnnotationPluginKey: PluginKey<any, any>;
+export interface AnnotationPluginOptions {
+    HTMLAttributes: {
+        [key: string]: any;
+    };
+    onUpdate: (items: [any?]) => {};
+    map: Y.Map<any>;
+    instance: string;
+}
+export declare const AnnotationPlugin: (options: AnnotationPluginOptions) => Plugin<any, any>;

package/dist/demos/src/Experiments/CollaborationAnnotation/Vue/extension/AnnotationState.d.ts

@@ -0,0 +1,27 @@
+import * as Y from 'yjs';
+import { EditorState, Transaction } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { AddAnnotationAction, UpdateAnnotationAction } from './collaboration-annotation';
+import { AnnotationItem } from './AnnotationItem';
+export interface AnnotationStateOptions {
+    HTMLAttributes: {
+        [key: string]: any;
+    };
+    map: Y.Map<any>;
+    instance: string;
+}
+export declare class AnnotationState {
+    options: AnnotationStateOptions;
+    decorations: DecorationSet<any>;
+    constructor(options: AnnotationStateOptions);
+    randomId(): string;
+    findAnnotation(id: string): Decoration<{
+        [key: string]: any;
+    }> | undefined;
+    addAnnotation(action: AddAnnotationAction, state: EditorState): void;
+    updateAnnotation(action: UpdateAnnotationAction): void;
+    deleteAnnotation(id: string): void;
+    annotationsAt(position: number): AnnotationItem[];
+    createDecorations(state: EditorState): void;
+    apply(transaction: Transaction, state: EditorState): this;
+}

package/dist/demos/src/Experiments/CollaborationAnnotation/Vue/extension/collaboration-annotation.d.ts

@@ -0,0 +1,49 @@
+import * as Y from 'yjs';
+import { Extension } from '@tiptap/core';
+export interface AddAnnotationAction {
+    type: 'addAnnotation';
+    data: any;
+    from: number;
+    to: number;
+}
+export interface UpdateAnnotationAction {
+    type: 'updateAnnotation';
+    id: string;
+    data: any;
+}
+export interface DeleteAnnotationAction {
+    type: 'deleteAnnotation';
+    id: string;
+}
+export interface AnnotationOptions {
+    HTMLAttributes: {
+        [key: string]: any;
+    };
+    /**
+     * An event listener which receives annotations for the current selection.
+     */
+    onUpdate: (items: [any?]) => {};
+    /**
+     * An initialized Y.js document.
+     */
+    document: Y.Doc | null;
+    /**
+     * Name of a Y.js map, can be changed to sync multiple fields with one Y.js document.
+     */
+    field: string;
+    /**
+     * A raw Y.js map, can be used instead of `document` and `field`.
+     */
+    map: Y.Map<any> | null;
+    instance: string;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        annotation: {
+            addAnnotation: (data: any) => ReturnType;
+            updateAnnotation: (id: string, data: any) => ReturnType;
+            deleteAnnotation: (id: string) => ReturnType;
+        };
+    }
+}
+export declare const CollaborationAnnotation: Extension<AnnotationOptions>;

package/dist/demos/src/Experiments/CollaborationAnnotation/Vue/extension/index.d.ts

@@ -0,0 +1,3 @@
+import { CollaborationAnnotation } from './collaboration-annotation';
+export * from './collaboration-annotation';
+export default CollaborationAnnotation;

package/dist/demos/src/Experiments/Details/Vue/details-summary.d.ts

@@ -0,0 +1,8 @@
+import { Node } from '@tiptap/core';
+export interface DetailsSummaryOptions {
+    HTMLAttributes: {
+        [key: string]: any;
+    };
+}
+declare const _default: Node<DetailsSummaryOptions>;
+export default _default;

package/dist/demos/src/Experiments/Details/Vue/details.d.ts

@@ -0,0 +1,26 @@
+import { Node } from '@tiptap/core';
+export interface DetailsOptions {
+    HTMLAttributes: {
+        [key: string]: any;
+    };
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        details: {
+            /**
+             * Set a details node
+             */
+            setDetails: () => ReturnType;
+            /**
+             * Toggle a details node
+             */
+            toggleDetails: () => ReturnType;
+            /**
+             * Unset a details node
+             */
+            unsetDetails: () => ReturnType;
+        };
+    }
+}
+declare const _default: Node<DetailsOptions>;
+export default _default;

package/dist/demos/src/Experiments/Embeds/Vue/iframe.d.ts

@@ -0,0 +1,21 @@
+import { Node } from '@tiptap/core';
+export interface IframeOptions {
+    allowFullscreen: boolean;
+    HTMLAttributes: {
+        [key: string]: any;
+    };
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        iframe: {
+            /**
+             * Add an iframe
+             */
+            setIframe: (options: {
+                src: string;
+            }) => ReturnType;
+        };
+    }
+}
+declare const _default: Node<IframeOptions>;
+export default _default;

package/dist/demos/src/Experiments/Figure/Vue/figure.d.ts

@@ -0,0 +1,29 @@
+import { Node } from '@tiptap/core';
+export interface FigureOptions {
+    HTMLAttributes: Record<string, any>;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        figure: {
+            /**
+             * Add a figure element
+             */
+            setFigure: (options: {
+                src: string;
+                alt?: string;
+                title?: string;
+                caption?: string;
+            }) => ReturnType;
+            /**
+             * Converts an image to a figure
+             */
+            imageToFigure: () => ReturnType;
+            /**
+             * Converts a figure to an image
+             */
+            figureToImage: () => ReturnType;
+        };
+    }
+}
+export declare const inputRegex: RegExp;
+export declare const Figure: Node<FigureOptions>;

package/dist/demos/src/Experiments/GenericFigure/Vue/figcaption.d.ts

@@ -0,0 +1,4 @@
+import { Node } from '@tiptap/core';
+export declare const Figcaption: Node<{
+    HTMLAttributes: {};
+}>;

package/dist/demos/src/Experiments/GenericFigure/Vue/figure.d.ts

@@ -0,0 +1,4 @@
+import { Node } from '@tiptap/core';
+export declare const Figure: Node<{
+    HTMLAttributes: {};
+}>;

package/dist/demos/src/Experiments/Linter/Vue/extension/Linter.d.ts

@@ -0,0 +1,6 @@
+import { Extension } from '@tiptap/core';
+import LinterPlugin from './LinterPlugin';
+export interface LinterOptions {
+    plugins: Array<typeof LinterPlugin>;
+}
+export declare const Linter: Extension<LinterOptions>;

package/dist/demos/src/Experiments/Linter/Vue/extension/LinterPlugin.d.ts

@@ -0,0 +1,15 @@
+import { Node as ProsemirrorNode } from 'prosemirror-model';
+export interface Result {
+    message: string;
+    from: number;
+    to: number;
+    fix?: Function;
+}
+export default class LinterPlugin {
+    protected doc: ProsemirrorNode<any>;
+    private results;
+    constructor(doc: ProsemirrorNode);
+    record(message: string, from: number, to: number, fix?: Function): void;
+    scan(): this;
+    getResults(): Result[];
+}

package/dist/demos/src/Experiments/Linter/Vue/extension/index.d.ts

@@ -0,0 +1,6 @@
+import { Linter } from './Linter';
+export * from './Linter';
+export default Linter;
+export { BadWords } from './plugins/BadWords';
+export { Punctuation } from './plugins/Punctuation';
+export { HeadingLevel } from './plugins/HeadingLevel';

package/dist/demos/src/Experiments/Linter/Vue/extension/plugins/BadWords.d.ts

@@ -0,0 +1,5 @@
+import LinterPlugin from '../LinterPlugin';
+export declare class BadWords extends LinterPlugin {
+    regex: RegExp;
+    scan(): this;
+}

package/dist/demos/src/Experiments/Linter/Vue/extension/plugins/HeadingLevel.d.ts

@@ -0,0 +1,6 @@
+import { EditorView } from 'prosemirror-view';
+import LinterPlugin, { Result as Issue } from '../LinterPlugin';
+export declare class HeadingLevel extends LinterPlugin {
+    fixHeader(level: number): ({ state, dispatch }: EditorView, issue: Issue) => void;
+    scan(): this;
+}

package/dist/demos/src/Experiments/Linter/Vue/extension/plugins/Punctuation.d.ts

@@ -0,0 +1,7 @@
+import { EditorView } from 'prosemirror-view';
+import LinterPlugin, { Result as Issue } from '../LinterPlugin';
+export declare class Punctuation extends LinterPlugin {
+    regex: RegExp;
+    fix(replacement: any): ({ state, dispatch }: EditorView, issue: Issue) => void;
+    scan(): this;
+}

package/dist/demos/src/Experiments/TrailingNode/Vue/trailing-node.d.ts

@@ -0,0 +1,11 @@
+import { Extension } from '@tiptap/core';
+/**
+ * Extension based on:
+ * - https://github.com/ueberdosis/tiptap/blob/v1/packages/tiptap-extensions/src/extensions/TrailingNode.js
+ * - https://github.com/remirror/remirror/blob/e0f1bec4a1e8073ce8f5500d62193e52321155b9/packages/prosemirror-trailing-node/src/trailing-node-plugin.ts
+ */
+export interface TrailingNodeOptions {
+    node: string;
+    notAfter: string[];
+}
+export declare const TrailingNode: Extension<TrailingNodeOptions>;

package/dist/demos/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfigExport;
+export default _default;

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

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

@@ -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 } from './types';
+import * as extensions from './extensions';
+export { extensions };
+export interface HTMLElement {
+    editor?: Editor;
+}
+export declare class Editor extends EventEmitter {
+    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 name 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,7 @@
+export default class EventEmitter {
+    private callbacks;
+    on(event: string, fn: Function): this;
+    protected emit(event: string, ...args: any): this;
+    off(event: string, fn?: Function): this;
+    protected removeAllListeners(): void;
+}

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

@@ -0,0 +1,193 @@
+import { Plugin, Transaction } from 'prosemirror-state';
+import { InputRule } from 'prosemirror-inputrules';
+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'];
+        }) => Plugin[];
+        /**
+         * 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>;
+}