@tiptap/extension-table-row 2.5.0-beta.2 → 2.5.0-beta.4

package/dist/index.cjs

@@ -4,29 +4,29 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var core = require('@tiptap/core');
 
-/**
- * This extension allows you to create table rows.
- * @see https://www.tiptap.dev/api/nodes/table-row
- */
-const TableRow = core.Node.create({
-    name: 'tableRow',
-    addOptions() {
-        return {
-            HTMLAttributes: {},
-        };
-    },
-    content: '(tableCell | tableHeader)*',
-    tableRole: 'row',
-    parseHTML() {
-        return [
-            { tag: 'tr' },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['tr', core.mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
+/**
+ * This extension allows you to create table rows.
+ * @see https://www.tiptap.dev/api/nodes/table-row
+ */
+const TableRow = core.Node.create({
+    name: 'tableRow',
+    addOptions() {
+        return {
+            HTMLAttributes: {},
+        };
+    },
+    content: '(tableCell | tableHeader)*',
+    tableRole: 'row',
+    parseHTML() {
+        return [
+            { tag: 'tr' },
+        ];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['tr', core.mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+    },
 });
 
 exports.TableRow = TableRow;
-exports["default"] = TableRow;
+exports.default = TableRow;
 //# sourceMappingURL=index.cjs.map

package/dist/index.js

@@ -1,26 +1,26 @@
 import { Node, mergeAttributes } from '@tiptap/core';
 
-/**
- * This extension allows you to create table rows.
- * @see https://www.tiptap.dev/api/nodes/table-row
- */
-const TableRow = Node.create({
-    name: 'tableRow',
-    addOptions() {
-        return {
-            HTMLAttributes: {},
-        };
-    },
-    content: '(tableCell | tableHeader)*',
-    tableRole: 'row',
-    parseHTML() {
-        return [
-            { tag: 'tr' },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['tr', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
+/**
+ * This extension allows you to create table rows.
+ * @see https://www.tiptap.dev/api/nodes/table-row
+ */
+const TableRow = Node.create({
+    name: 'tableRow',
+    addOptions() {
+        return {
+            HTMLAttributes: {},
+        };
+    },
+    content: '(tableCell | tableHeader)*',
+    tableRole: 'row',
+    parseHTML() {
+        return [
+            { tag: 'tr' },
+        ];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['tr', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+    },
 });
 
 export { TableRow, TableRow as default };

package/dist/index.umd.js

@@ -4,31 +4,31 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@tiptap/extension-table-row"] = {}, global.core));
 })(this, (function (exports, core) { 'use strict';
 
-  /**
-   * This extension allows you to create table rows.
-   * @see https://www.tiptap.dev/api/nodes/table-row
-   */
-  const TableRow = core.Node.create({
-      name: 'tableRow',
-      addOptions() {
-          return {
-              HTMLAttributes: {},
-          };
-      },
-      content: '(tableCell | tableHeader)*',
-      tableRole: 'row',
-      parseHTML() {
-          return [
-              { tag: 'tr' },
-          ];
-      },
-      renderHTML({ HTMLAttributes }) {
-          return ['tr', core.mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-      },
+  /**
+   * This extension allows you to create table rows.
+   * @see https://www.tiptap.dev/api/nodes/table-row
+   */
+  const TableRow = core.Node.create({
+      name: 'tableRow',
+      addOptions() {
+          return {
+              HTMLAttributes: {},
+          };
+      },
+      content: '(tableCell | tableHeader)*',
+      tableRole: 'row',
+      parseHTML() {
+          return [
+              { tag: 'tr' },
+          ];
+      },
+      renderHTML({ HTMLAttributes }) {
+          return ['tr', core.mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+      },
   });
 
   exports.TableRow = TableRow;
-  exports["default"] = TableRow;
+  exports.default = TableRow;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 

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

@@ -0,0 +1,20 @@
+import { EditorState, Transaction } from '@tiptap/pm/state';
+import { Editor } from './Editor.js';
+import { AnyCommands, CanCommands, ChainedCommands, CommandProps, SingleCommands } from './types.js';
+export declare 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,161 @@
+import { MarkType, NodeType, Schema } from '@tiptap/pm/model';
+import { EditorState, Plugin, PluginKey, Transaction } from '@tiptap/pm/state';
+import { EditorView } from '@tiptap/pm/view';
+import { EventEmitter } from './EventEmitter.js';
+import { ExtensionManager } from './ExtensionManager.js';
+import { NodePos } from './NodePos.js';
+import { CanCommands, ChainedCommands, EditorEvents, EditorOptions, JSONContent, SingleCommands, TextSerializer } from './types.js';
+export * as extensions from './extensions/index.js';
+declare global {
+    interface HTMLElement {
+        editor?: Editor;
+    }
+}
+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.
+     */
+    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, emitUpdate?: 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;
+    /**
+     * Prepend class name to element.
+     */
+    prependClass(): void;
+    isCapturingTransaction: boolean;
+    private capturedTransaction;
+    captureTransaction(fn: Function): Transaction | 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(): 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.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Get the number of characters for the current document.
+     *
+     * @deprecated
+     */
+    getCharacterCount(): number;
+    /**
+     * Destroy the editor.
+     */
+    destroy(): void;
+    /**
+     * Check if the editor is already destroyed.
+     */
+    get isDestroyed(): boolean;
+    $node(selector: string, attributes?: {
+        [key: string]: any;
+    }): NodePos | null;
+    $nodes(selector: string, attributes?: {
+        [key: string]: any;
+    }): NodePos[] | null;
+    $pos(pos: number): NodePos;
+    get $doc(): NodePos;
+}

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

@@ -0,0 +1,11 @@
+type StringKeyOf<T> = Extract<keyof T, string>;
+type CallbackType<T extends Record<string, any>, EventName extends StringKeyOf<T>> = T[EventName] extends any[] ? T[EventName] : [T[EventName]];
+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<EventName extends StringKeyOf<T>>(event: EventName, fn: CallbackFunction<T, EventName>): this;
+    emit<EventName extends StringKeyOf<T>>(event: EventName, ...args: CallbackType<T, EventName>): this;
+    off<EventName extends StringKeyOf<T>>(event: EventName, fn?: CallbackFunction<T, EventName>): this;
+    removeAllListeners(): void;
+}
+export {};

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

@@ -0,0 +1,343 @@
+import { Plugin, Transaction } from '@tiptap/pm/state';
+import { Editor } from './Editor.js';
+import { ExtensionConfig } from './index.js';
+import { InputRule } from './InputRule.js';
+import { Mark } from './Mark.js';
+import { Node } from './Node.js';
+import { PasteRule } from './PasteRule.js';
+import { Extensions, GlobalAttributes, KeyboardShortcutCommand, ParentConfig, RawCommands } from './types.js';
+declare module '@tiptap/core' {
+    interface ExtensionConfig<Options = any, Storage = any> {
+        [key: string]: any;
+        /**
+         * The extension name - this must be unique.
+         * It will be used to identify the extension.
+         *
+         * @example 'myExtension'
+         */
+        name: string;
+        /**
+         * The priority of your extension. The higher, the later it will be called
+         * and will take precedence over other extensions with a lower priority.
+         * @default 1000
+         * @example 1001
+         */
+        priority?: number;
+        /**
+         * The default options for this extension.
+         * @example
+         * defaultOptions: {
+         *   myOption: 'foo',
+         *   myOtherOption: 10,
+         * }
+         */
+        defaultOptions?: Options;
+        /**
+         * This method will add options to this extension
+         * @see https://tiptap.dev/guide/custom-extensions#settings
+         * @example
+         * addOptions() {
+         *  return {
+         *    myOption: 'foo',
+         *    myOtherOption: 10,
+         * }
+         */
+        addOptions?: (this: {
+            name: string;
+            parent: Exclude<ParentConfig<ExtensionConfig<Options, Storage>>['addOptions'], undefined>;
+        }) => Options;
+        /**
+         * The default storage this extension can save data to.
+         * @see https://tiptap.dev/guide/custom-extensions#storage
+         * @example
+         * defaultStorage: {
+         *   prefetchedUsers: [],
+         *   loading: false,
+         * }
+         */
+        addStorage?: (this: {
+            name: string;
+            options: Options;
+            parent: Exclude<ParentConfig<ExtensionConfig<Options, Storage>>['addStorage'], undefined>;
+        }) => Storage;
+        /**
+         * This function adds globalAttributes to specific nodes.
+         * @see https://tiptap.dev/guide/custom-extensions#global-attributes
+         * @example
+         * addGlobalAttributes() {
+         *   return [
+         *     {
+                 // Extend the following extensions
+         *       types: [
+         *         'heading',
+         *         'paragraph',
+         *       ],
+         *       // … with those attributes
+         *       attributes: {
+         *         textAlign: {
+         *           default: 'left',
+         *           renderHTML: attributes => ({
+         *             style: `text-align: ${attributes.textAlign}`,
+         *           }),
+         *           parseHTML: element => element.style.textAlign || 'left',
+         *         },
+         *       },
+         *     },
+         *   ]
+         * }
+         */
+        addGlobalAttributes?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            extensions: (Node | Mark)[];
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addGlobalAttributes'];
+        }) => GlobalAttributes;
+        /**
+         * This function adds commands to the editor
+         * @see https://tiptap.dev/guide/custom-extensions#keyboard-shortcuts
+         * @example
+         * addCommands() {
+         *   return {
+         *     myCommand: () => ({ chain }) => chain().setMark('type', 'foo').run(),
+         *   }
+         * }
+         */
+        addCommands?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addCommands'];
+        }) => Partial<RawCommands>;
+        /**
+         * This function registers keyboard shortcuts.
+         * @see https://tiptap.dev/guide/custom-extensions#keyboard-shortcuts
+         * @example
+         * addKeyboardShortcuts() {
+         *   return {
+         *     'Mod-l': () => this.editor.commands.toggleBulletList(),
+         *   }
+         * },
+         */
+        addKeyboardShortcuts?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addKeyboardShortcuts'];
+        }) => {
+            [key: string]: KeyboardShortcutCommand;
+        };
+        /**
+         * This function adds input rules to the editor.
+         * @see https://tiptap.dev/guide/custom-extensions#input-rules
+         * @example
+         * addInputRules() {
+         *   return [
+         *     markInputRule({
+         *       find: inputRegex,
+         *       type: this.type,
+         *     }),
+         *   ]
+         * },
+         */
+        addInputRules?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addInputRules'];
+        }) => InputRule[];
+        /**
+         * This function adds paste rules to the editor.
+         * @see https://tiptap.dev/guide/custom-extensions#paste-rules
+         * @example
+         * addPasteRules() {
+         *   return [
+         *     markPasteRule({
+         *       find: pasteRegex,
+         *       type: this.type,
+         *     }),
+         *   ]
+         * },
+         */
+        addPasteRules?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addPasteRules'];
+        }) => PasteRule[];
+        /**
+         * This function adds Prosemirror plugins to the editor
+         * @see https://tiptap.dev/guide/custom-extensions#prosemirror-plugins
+         * @example
+         * addProseMirrorPlugins() {
+         *   return [
+         *     customPlugin(),
+         *   ]
+         * }
+         */
+        addProseMirrorPlugins?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addProseMirrorPlugins'];
+        }) => Plugin[];
+        /**
+         * This function adds additional extensions to the editor. This is useful for
+         * building extension kits.
+         * @example
+         * addExtensions() {
+         *   return [
+         *     BulletList,
+         *     OrderedList,
+         *     ListItem
+         *   ]
+         * }
+         */
+        addExtensions?: (this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['addExtensions'];
+        }) => Extensions;
+        /**
+         * This function extends the schema of the node.
+         * @example
+         * extendNodeSchema() {
+         *   return {
+         *     group: 'inline',
+         *     selectable: false,
+         *   }
+         * }
+         */
+        extendNodeSchema?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['extendNodeSchema'];
+        }, extension: Node) => Record<string, any>) | null;
+        /**
+         * This function extends the schema of the mark.
+         * @example
+         * extendMarkSchema() {
+         *   return {
+         *     group: 'inline',
+         *     selectable: false,
+         *   }
+         * }
+         */
+        extendMarkSchema?: ((this: {
+            name: string;
+            options: Options;
+            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;
+            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;
+        /**
+         * 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;
+        /**
+         * 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;
+        /**
+         * The editor is destroyed.
+         */
+        onDestroy?: ((this: {
+            name: string;
+            options: Options;
+            storage: Storage;
+            editor: Editor;
+            parent: ParentConfig<ExtensionConfig<Options, Storage>>['onDestroy'];
+        }) => void) | null;
+    }
+}
+/**
+ * The Extension class is the base class for all extensions.
+ * @see https://tiptap.dev/api/extensions#create-a-new-extension
+ */
+export declare class Extension<Options = any, Storage = any> {
+    type: string;
+    name: string;
+    parent: Extension | null;
+    child: Extension | null;
+    options: Options;
+    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<any, any>;
+    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig?: Partial<ExtensionConfig<ExtendedOptions, ExtendedStorage>>): Extension<ExtendedOptions, ExtendedStorage>;
+}