@tiptap/extension-list-item 2.5.0-beta.2 → 2.5.0-beta.3

package/dist/index.cjs

@@ -4,40 +4,40 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var core = require('@tiptap/core');
 
-/**
- * This extension allows you to create list items.
- * @see https://www.tiptap.dev/api/nodes/list-item
- */
-const ListItem = core.Node.create({
-    name: 'listItem',
-    addOptions() {
-        return {
-            HTMLAttributes: {},
-            bulletListTypeName: 'bulletList',
-            orderedListTypeName: 'orderedList',
-        };
-    },
-    content: 'paragraph block*',
-    defining: true,
-    parseHTML() {
-        return [
-            {
-                tag: 'li',
-            },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['li', core.mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
-    addKeyboardShortcuts() {
-        return {
-            Enter: () => this.editor.commands.splitListItem(this.name),
-            Tab: () => this.editor.commands.sinkListItem(this.name),
-            'Shift-Tab': () => this.editor.commands.liftListItem(this.name),
-        };
-    },
+/**
+ * This extension allows you to create list items.
+ * @see https://www.tiptap.dev/api/nodes/list-item
+ */
+const ListItem = core.Node.create({
+    name: 'listItem',
+    addOptions() {
+        return {
+            HTMLAttributes: {},
+            bulletListTypeName: 'bulletList',
+            orderedListTypeName: 'orderedList',
+        };
+    },
+    content: 'paragraph block*',
+    defining: true,
+    parseHTML() {
+        return [
+            {
+                tag: 'li',
+            },
+        ];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['li', core.mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+    },
+    addKeyboardShortcuts() {
+        return {
+            Enter: () => this.editor.commands.splitListItem(this.name),
+            Tab: () => this.editor.commands.sinkListItem(this.name),
+            'Shift-Tab': () => this.editor.commands.liftListItem(this.name),
+        };
+    },
 });
 
 exports.ListItem = ListItem;
-exports["default"] = ListItem;
+exports.default = ListItem;
 //# sourceMappingURL=index.cjs.map

package/dist/index.js

@@ -1,37 +1,37 @@
 import { Node, mergeAttributes } from '@tiptap/core';
 
-/**
- * This extension allows you to create list items.
- * @see https://www.tiptap.dev/api/nodes/list-item
- */
-const ListItem = Node.create({
-    name: 'listItem',
-    addOptions() {
-        return {
-            HTMLAttributes: {},
-            bulletListTypeName: 'bulletList',
-            orderedListTypeName: 'orderedList',
-        };
-    },
-    content: 'paragraph block*',
-    defining: true,
-    parseHTML() {
-        return [
-            {
-                tag: 'li',
-            },
-        ];
-    },
-    renderHTML({ HTMLAttributes }) {
-        return ['li', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-    },
-    addKeyboardShortcuts() {
-        return {
-            Enter: () => this.editor.commands.splitListItem(this.name),
-            Tab: () => this.editor.commands.sinkListItem(this.name),
-            'Shift-Tab': () => this.editor.commands.liftListItem(this.name),
-        };
-    },
+/**
+ * This extension allows you to create list items.
+ * @see https://www.tiptap.dev/api/nodes/list-item
+ */
+const ListItem = Node.create({
+    name: 'listItem',
+    addOptions() {
+        return {
+            HTMLAttributes: {},
+            bulletListTypeName: 'bulletList',
+            orderedListTypeName: 'orderedList',
+        };
+    },
+    content: 'paragraph block*',
+    defining: true,
+    parseHTML() {
+        return [
+            {
+                tag: 'li',
+            },
+        ];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['li', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+    },
+    addKeyboardShortcuts() {
+        return {
+            Enter: () => this.editor.commands.splitListItem(this.name),
+            Tab: () => this.editor.commands.sinkListItem(this.name),
+            'Shift-Tab': () => this.editor.commands.liftListItem(this.name),
+        };
+    },
 });
 
 export { ListItem, ListItem as default };

package/dist/index.umd.js

@@ -4,42 +4,42 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@tiptap/extension-list-item"] = {}, global.core));
 })(this, (function (exports, core) { 'use strict';
 
-  /**
-   * This extension allows you to create list items.
-   * @see https://www.tiptap.dev/api/nodes/list-item
-   */
-  const ListItem = core.Node.create({
-      name: 'listItem',
-      addOptions() {
-          return {
-              HTMLAttributes: {},
-              bulletListTypeName: 'bulletList',
-              orderedListTypeName: 'orderedList',
-          };
-      },
-      content: 'paragraph block*',
-      defining: true,
-      parseHTML() {
-          return [
-              {
-                  tag: 'li',
-              },
-          ];
-      },
-      renderHTML({ HTMLAttributes }) {
-          return ['li', core.mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
-      },
-      addKeyboardShortcuts() {
-          return {
-              Enter: () => this.editor.commands.splitListItem(this.name),
-              Tab: () => this.editor.commands.sinkListItem(this.name),
-              'Shift-Tab': () => this.editor.commands.liftListItem(this.name),
-          };
-      },
+  /**
+   * This extension allows you to create list items.
+   * @see https://www.tiptap.dev/api/nodes/list-item
+   */
+  const ListItem = core.Node.create({
+      name: 'listItem',
+      addOptions() {
+          return {
+              HTMLAttributes: {},
+              bulletListTypeName: 'bulletList',
+              orderedListTypeName: 'orderedList',
+          };
+      },
+      content: 'paragraph block*',
+      defining: true,
+      parseHTML() {
+          return [
+              {
+                  tag: 'li',
+              },
+          ];
+      },
+      renderHTML({ HTMLAttributes }) {
+          return ['li', core.mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+      },
+      addKeyboardShortcuts() {
+          return {
+              Enter: () => this.editor.commands.splitListItem(this.name),
+              Tab: () => this.editor.commands.sinkListItem(this.name),
+              'Shift-Tab': () => this.editor.commands.liftListItem(this.name),
+          };
+      },
   });
 
   exports.ListItem = ListItem;
-  exports["default"] = ListItem;
+  exports.default = ListItem;
 
   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 {};