@prosekit/core 0.7.14 → 0.8.0

package/dist/_tsup-dts-rollup.d.ts

@@ -2,7 +2,6 @@ import { AllSelection } from '@prosekit/pm/state';
 import type { Attrs } from '@prosekit/pm/model';
 import { Command } from '@prosekit/pm/state';
 import type { ContentMatch } from '@prosekit/pm/model';
-import { config as default_alias_1 } from '@prosekit/dev/config-vitest';
 import type { DirectEditorProps } from '@prosekit/pm/view';
 import type { DOMEventMap } from '@prosekit/pm/view';
 import type { DOMOutputSpec } from '@prosekit/pm/model';
@@ -21,10 +20,8 @@ import type { Node as Node_2 } from '@prosekit/pm/model';
 import { NodeSelection } from '@prosekit/pm/state';
 import type { NodeSpec } from '@prosekit/pm/model';
 import type { NodeType } from '@prosekit/pm/model';
-import { NodeType as NodeType_2 } from 'prosemirror-model';
 import type { NodeView } from '@prosekit/pm/view';
 import type { NodeViewConstructor } from '@prosekit/pm/view';
-import { Options } from 'tsup';
 import { ParseOptions } from '@prosekit/pm/model';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
 import { ProseMirrorFragment } from '@prosekit/pm/model';
@@ -125,11 +122,6 @@ export { assert as assert_alias_1 }
  */
 export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
 
-/**
- * Utility function assert that two types are equal in tests.
- */
-export declare function assertTypeEqual_alias_1<T, U>(_val: IsEqual<T, U>): void;
-
 declare interface AttrOptions {
     attr: string;
     toDOM?: (value: unknown) => [key: string, value: string] | null | undefined;
@@ -190,7 +182,7 @@ export { BaseCommandsExtension as BaseCommandsExtension_alias_1 }
  * @internal
  */
 export declare abstract class BaseExtension<T extends ExtensionTyping = ExtensionTyping> implements Extension<T> {
-    extension: Extension | Extension[];
+    abstract extension: Extension | Extension[];
     priority?: Priority;
     _type?: T;
     private trees;
@@ -220,6 +212,8 @@ export { BaseKeymapExtension as BaseKeymapExtension_alias_1 }
  * Some basic props for custom node views.
  *
  * @deprecated - This is no longer needed. Use `CoreNodeViewUserOptions` from `@prosemirror-adapter/core` instead.
+ *
+ * @hidden
  */
 declare interface BaseNodeViewOptions {
     /**
@@ -242,12 +236,6 @@ declare interface BaseNodeViewOptions {
 export { BaseNodeViewOptions }
 export { BaseNodeViewOptions as BaseNodeViewOptions_alias_1 }
 
-declare type BoldExtension = Extension<{
-    Marks: {
-        bold: Attrs;
-    };
-}>;
-
 export declare function buildNode(type: NodeType, args: [Attrs | NodeChild | null | undefined, ...NodeChild[]], createNode: CreateNodeFunction): ProseMirrorNode;
 
 export declare function cache<T>(fn: () => T): () => T;
@@ -264,6 +252,18 @@ declare type ClickOnHandler = (view: EditorView, pos: number, node: Node_2, node
 export { ClickOnHandler }
 export { ClickOnHandler as ClickOnHandler_alias_1 }
 
+/**
+ * @internal
+ */
+declare interface ClipboardSerializerOptions {
+    serializeFragmentWrapper?: FunctionWrapper<SerializeFragmentFunction>;
+    serializeNodeWrapper?: FunctionWrapper<SerializeNodeFunction>;
+    nodesFromSchemaWrapper?: FunctionWrapper<NodesFromSchemaFunction>;
+    marksFromSchemaWrapper?: FunctionWrapper<MarksFromSchemaFunction>;
+}
+export { ClipboardSerializerOptions }
+export { ClipboardSerializerOptions as ClipboardSerializerOptions_alias_1 }
+
 /**
  * A utility for constructing `className` strings conditionally.
  *
@@ -275,14 +275,6 @@ declare const clsx: (...args: Array<string | boolean | null | undefined>) => str
 export { clsx }
 export { clsx as clsx_alias_1 }
 
-declare type CodeBlockExtension = Extension<{
-    Nodes: {
-        codeBlock: {
-            language: string;
-        };
-    };
-}>;
-
 /**
  * Collects all children of a node or a fragment, and returns them as an array.
  *
@@ -395,14 +387,10 @@ export { createTestEditor as createTestEditor_alias_1 }
 
 export declare function deepEquals<T>(a: T, b: T): boolean;
 
-export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
-
-export { default_alias_1 }
-
 /**
  * @internal
  */
-declare function defaultBlockAt(match: ContentMatch): NodeType_2 | null;
+declare function defaultBlockAt(match: ContentMatch): NodeType | null;
 export { defaultBlockAt }
 export { defaultBlockAt as defaultBlockAt_alias_1 }
 
@@ -481,6 +469,13 @@ declare function defineClickOnHandler(handler: ClickOnHandler): PlainExtension;
 export { defineClickOnHandler }
 export { defineClickOnHandler as defineClickOnHandler_alias_1 }
 
+/**
+ * @internal
+ */
+declare function defineClipboardSerializer(options: ClipboardSerializerOptions): Extension;
+export { defineClipboardSerializer }
+export { defineClipboardSerializer as defineClipboardSerializer_alias_1 }
+
 declare function defineCommands<T extends Record<string, CommandCreator> = Record<string, CommandCreator>>(commands: T): Extension<{
     Commands: {
         [K in keyof T]: Parameters<T[K]>;
@@ -502,6 +497,12 @@ export { defineDefaultState as defineDefaultState_alias_1 }
 
 /**
  * @public
+ *
+ * @deprecated Use the following import instead:
+ *
+ * ```ts
+ * import { defineDoc } from 'prosekit/extensions/doc'
+ * ```
  */
 declare function defineDoc(): DocExtension;
 export { defineDoc }
@@ -735,18 +736,17 @@ export { defineNodeViewFactory as defineNodeViewFactory_alias_1 }
  * @public
  *
  * Defines a paragraph node spec as the highest priority, because it should be the default block node for most cases.
+ *
+ * @deprecated Use the following import instead:
+ *
+ * ```ts
+ * import { defineParagraph } from 'prosekit/extensions/paragraph'
+ * ```
  */
 declare function defineParagraph(): ParagraphExtension;
 export { defineParagraph }
 export { defineParagraph as defineParagraph_alias_1 }
 
-/**
- * @public
- *
- * Defines a paragraph node spec.
- */
-export declare function defineParagraphSpec(): ParagraphSpecExtension;
-
 /**
  * @public
  *
@@ -779,17 +779,14 @@ declare function defineScrollToSelectionHandler(handler: ScrollToSelectionHandle
 export { defineScrollToSelectionHandler }
 export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_1 }
 
-/**
- * @internal
- */
-export declare function defineTestExtension(): Union<readonly [BaseCommandsExtension, PlainExtension, DocExtension, HistoryExtension, Extension<{
-Nodes: {
-paragraph: Attrs;
-};
-}>, TextExtension, BoldExtension, ItalicExtension, LinkExtension, HeadingExtension, CodeBlockExtension]>;
-
 /**
  * @public
+ *
+ * @deprecated Use the following import instead:
+ *
+ * ```ts
+ * import { defineText } from 'prosekit/extensions/text'
+ * ```
  */
 declare function defineText(): TextExtension;
 export { defineText }
@@ -872,6 +869,11 @@ export declare class DOMDocumentNotFoundError extends ProseKitError {
 
 /** @public */
 declare interface DOMDocumentOptions {
+    /**
+     * The Document object to use for DOM operations. If not provided, defaults to
+     * the current browser's document object. Useful for server-side rendering or
+     * testing environments.
+     */
     document?: Document;
 }
 export { DOMDocumentOptions }
@@ -910,7 +912,9 @@ export { DOMParserOptions as DOMParserOptions_alias_1 }
 
 /** @public */
 declare interface DOMSerializerOptions {
-    DOMSerializer?: typeof DOMSerializer;
+    DOMSerializer?: {
+        fromSchema: typeof DOMSerializer.fromSchema;
+    };
 }
 export { DOMSerializerOptions }
 export { DOMSerializerOptions as DOMSerializerOptions_alias_1 }
@@ -1002,6 +1006,14 @@ declare class Editor<E extends Extension = any> {
      *   - The string "end" (to set selection at the end)
      */
     setContent: (content: ProseMirrorNode | NodeJSON | string | HTMLElement, selection?: SelectionJSON | Selection_2 | "start" | "end") => void;
+    /**
+     * Return a JSON object representing the editor's current document.
+     */
+    getDocJSON: () => NodeJSON;
+    /**
+     * Return a HTML string representing the editor's current document.
+     */
+    getDocHTML: (options?: getDocHTMLOptions) => string;
     /**
      * Execute the given command. Return `true` if the command was successfully
      * executed, otherwise `false`.
@@ -1073,9 +1085,19 @@ export declare class EditorInstance {
     private afterMounted;
     constructor(extension: Extension);
     getState: () => EditorState;
+    private getDoc;
+    private getProp;
     updateState(state: EditorState): void;
     private dispatch;
     setContent(content: NodeJSON | string | HTMLElement | ProseMirrorNode, selection?: SelectionJSON | Selection_2 | 'start' | 'end'): void;
+    /**
+     * Return a JSON object representing the editor's current document.
+     */
+    getDocJSON: () => NodeJSON;
+    /**
+     * Return a HTML string representing the editor's current document.
+     */
+    getDocHTML: (options?: getDocHTMLOptions) => string;
     private updateExtension;
     use(extension: Extension): VoidFunction;
     mount(place: HTMLElement): void;
@@ -1146,6 +1168,13 @@ export declare function elementFromHTML(html: string, options?: DOMDocumentOptio
  * Parse a ProseMirror document JSON object to a HTML element.
  *
  * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const json = { type: 'doc', content: [{ type: 'paragraph' }] }
+ * const element = elementFromJSON(json, { schema: editor.schema })
+ * ```
  */
 declare function elementFromJSON(json: NodeJSON, options: JSONParserOptions & DOMSerializerOptions & DOMDocumentOptions): HTMLElement;
 export { elementFromJSON }
@@ -1155,6 +1184,13 @@ export { elementFromJSON as elementFromJSON_alias_1 }
  * Serialize a ProseMirror node to a HTML element.
  *
  * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const node = editor.state.doc
+ * const element = elementFromNode(node)
+ * ```
  */
 declare function elementFromNode(node: ProseMirrorNode, options?: DOMSerializerOptions & DOMDocumentOptions): HTMLElement;
 export { elementFromNode }
@@ -1432,6 +1468,8 @@ declare type FocusChangeHandler = (hasFocus: boolean) => void;
 export { FocusChangeHandler }
 export { FocusChangeHandler as FocusChangeHandler_alias_1 }
 
+declare type FunctionWrapper<T extends AnyFunction> = (fn: T) => T;
+
 export declare function getBrowserDocument(options?: {
     document?: Document;
 }): Document;
@@ -1442,6 +1480,12 @@ export declare function getBrowserWindow(options?: {
 
 export declare function getCustomSelection(state: EditorState, from?: number | null, to?: number | null): Selection_2;
 
+/**
+ * @public
+ */
+export declare interface getDocHTMLOptions extends DOMDocumentOptions {
+}
+
 export declare function getEditorContentDoc(schema: Schema, content: NodeJSON | string | HTMLElement | ProseMirrorNode): ProseMirrorNode;
 
 export declare function getEditorContentJSON(schema: Schema, content: NodeJSON | string | HTMLElement): NodeJSON;
@@ -1486,12 +1530,6 @@ export declare function groupEntries<T extends Record<string, any>>(entries: Obj
     [K in keyof T]?: T[K][];
 };
 
-declare type HeadingExtension = Extension<{
-    Nodes: {
-        heading: Attrs;
-    };
-}>;
-
 /**
  * @internal
  */
@@ -1537,6 +1575,13 @@ export declare function htmlFromElement(element: HTMLElement): string;
  * Parse a ProseMirror document JSON object to a HTML string.
  *
  * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const json = { type: 'doc', content: [{ type: 'paragraph' }] }
+ * const html = htmlFromJSON(json, { schema: editor.schema })
+ * ```
  */
 declare function htmlFromJSON(json: NodeJSON, options: JSONParserOptions & DOMSerializerOptions & DOMDocumentOptions): string;
 export { htmlFromJSON }
@@ -1546,6 +1591,13 @@ export { htmlFromJSON as htmlFromJSON_alias_1 }
  * Serialize a ProseMirror node to a HTML string
  *
  * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const node = document.getElementById('content')
+ * const html = htmlFromNode(node)
+ * ```
  */
 declare function htmlFromNode(node: ProseMirrorNode, options?: DOMSerializerOptions & DOMDocumentOptions): string;
 export { htmlFromNode }
@@ -1553,8 +1605,6 @@ export { htmlFromNode as htmlFromNode_alias_1 }
 
 export declare function includesMark(marks: readonly Mark[], markType: MarkType, attrs?: Attrs | null): boolean;
 
-export declare function inputText(input: string): Promise<void>;
-
 /**
  * Returns a command that inserts a default block after current selection or at
  * the given position.
@@ -1661,7 +1711,12 @@ declare function isAtBlockStart(state: EditorState, view?: EditorView): Resolved
 export { isAtBlockStart }
 export { isAtBlockStart as isAtBlockStart_alias_1 }
 
-export declare function isElement(el: unknown): el is Element;
+/**
+ * @internal
+ */
+declare function isElement(el: unknown): el is Element;
+export { isElement }
+export { isElement as isElement_alias_1 }
 
 /**
  * Checks if the given object is a `Fragment` instance.
@@ -1767,16 +1822,17 @@ declare function isTextSelection(sel: Selection_2): sel is TextSelection;
 export { isTextSelection }
 export { isTextSelection as isTextSelection_alias_1 }
 
-declare type ItalicExtension = Extension<{
-    Marks: {
-        italic: Attrs;
-    };
-}>;
-
 /**
  * Serialize a HTML element to a ProseMirror document JSON object.
  *
  * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const element = document.getElementById('content')
+ * const json = jsonFromElement(element, { schema: editor.schema })
+ * ```
  */
 export declare function jsonFromElement(element: DOMNode, options: DOMParserOptions & JSONParserOptions): NodeJSON;
 
@@ -1784,6 +1840,13 @@ export declare function jsonFromElement(element: DOMNode, options: DOMParserOpti
  * Parse a HTML string to a ProseMirror document JSON object.
  *
  * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const html = '<p>Hello, world!</p>'
+ * const json = jsonFromHTML(html, { schema: editor.schema })
+ * ```
  */
 declare function jsonFromHTML(html: string, options: DOMDocumentOptions & DOMParserOptions & JSONParserOptions): NodeJSON;
 export { jsonFromHTML }
@@ -1793,6 +1856,13 @@ export { jsonFromHTML as jsonFromHTML_alias_1 }
  * Return a JSON object representing this node.
  *
  * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const node = editor.state.doc
+ * const json = jsonFromNode(node)
+ * ```
  */
 declare function jsonFromNode(node: ProseMirrorNode): NodeJSON;
 export { jsonFromNode }
@@ -1802,6 +1872,13 @@ export { jsonFromNode as jsonFromNode_alias_1 }
  * Return a JSON object representing this state.
  *
  * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const state = editor.state
+ * const json = jsonFromState(state)
+ * ```
  */
 declare function jsonFromState(state: EditorState): StateJSON;
 export { jsonFromState }
@@ -1809,6 +1886,9 @@ export { jsonFromState as jsonFromState_alias_1 }
 
 /** @public */
 declare interface JSONParserOptions {
+    /**
+     * The editor schema to use.
+     */
     schema: Schema;
 }
 export { JSONParserOptions }
@@ -1845,16 +1925,6 @@ declare type KeyPressHandler = (view: EditorView, event: KeyboardEvent) => boole
 export { KeyPressHandler }
 export { KeyPressHandler as KeyPressHandler_alias_1 }
 
-declare interface LinkAttrs {
-    href: string;
-}
-
-declare type LinkExtension = Extension<{
-    Marks: {
-        link: LinkAttrs;
-    };
-}>;
-
 /**
  * A function for creating a mark with optional attributes and any number of
  * children.
@@ -1913,6 +1983,8 @@ declare type MarkBuilder = MarkAction;
 export { MarkBuilder }
 export { MarkBuilder as MarkBuilder_alias_1 }
 
+declare type MarksFromSchemaFunction = typeof DOMSerializer.marksFromSchema;
+
 /**
  * @public
  */
@@ -2080,6 +2152,12 @@ export { NodeContent as NodeContent_alias_1 }
  * Parse a HTML element to a ProseMirror node.
  *
  * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const element = document.getElementById('content')
+ * const node = nodeFromElement(element, { schema: editor.schema })
  */
 declare function nodeFromElement(element: DOMNode, options: DOMParserOptions & JSONParserOptions): ProseMirrorNode;
 export { nodeFromElement }
@@ -2089,6 +2167,12 @@ export { nodeFromElement as nodeFromElement_alias_1 }
  * Parse a HTML string to a ProseMirror node.
  *
  * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const html = '<p>Hello, world!</p>'
+ * const node = nodeFromHTML(html, { schema: editor.schema })
  */
 declare function nodeFromHTML(html: string, options: DOMParserOptions & JSONParserOptions & DOMDocumentOptions): ProseMirrorNode;
 export { nodeFromHTML }
@@ -2098,6 +2182,13 @@ export { nodeFromHTML as nodeFromHTML_alias_1 }
  * Parse a JSON object to a ProseMirror node.
  *
  * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const json = { type: 'doc', content: [{ type: 'paragraph' }] }
+ * const node = nodeFromJSON(json, { schema: editor.schema })
+ * ```
  */
 declare function nodeFromJSON(json: NodeJSON, options: JSONParserOptions): ProseMirrorNode;
 export { nodeFromJSON }
@@ -2121,6 +2212,8 @@ declare interface NodeJSON {
 export { NodeJSON }
 export { NodeJSON as NodeJSON_alias_1 }
 
+declare type NodesFromSchemaFunction = typeof DOMSerializer.nodesFromSchema;
+
 /**
  * @public
  */
@@ -2206,6 +2299,12 @@ export declare function objectEqual<T>(a: T, b: T): boolean;
 
 /**
  * @internal
+ *
+ * @deprecated Use the following import instead:
+ *
+ * ```ts
+ * import type { ParagraphExtension } from 'prosekit/extensions/paragraph'
+ * ```
  */
 declare type ParagraphExtension = ParagraphSpecExtension;
 export { ParagraphExtension }
@@ -2402,6 +2501,10 @@ declare interface SelectionJSON {
 export { SelectionJSON }
 export { SelectionJSON as SelectionJSON_alias_1 }
 
+declare type SerializeFragmentFunction = typeof DOMSerializer.prototype.serializeFragment;
+
+declare type SerializeNodeFunction = typeof DOMSerializer.prototype.serializeNode;
+
 /**
  * Returns a command that tries to set the selected textblocks to the given node
  * type with the given attributes.
@@ -2470,57 +2573,6 @@ export declare type Setter<T> = (value: T) => void;
  */
 export declare function setupEditorExtension<E extends Extension>(options: EditorOptions<E>): E;
 
-/**
- * @internal
- */
-export declare function setupTest(): {
-    editor: TestEditor<Union<readonly [BaseCommandsExtension, PlainExtension, DocExtension, HistoryExtension, Extension<{
-    Nodes: {
-    paragraph: Attrs;
-    };
-    }>, TextExtension, BoldExtension, ItalicExtension, LinkExtension, HeadingExtension, CodeBlockExtension]>>;
-    m: ToMarkAction<SimplifyDeeper<    {
-    bold: {
-    readonly [x: string]: any;
-    };
-    italic: {
-    readonly [x: string]: any;
-    };
-    link: {
-    href: string;
-    };
-    }>>;
-    n: {
-        p: NodeAction<    {
-        readonly [x: string]: any;
-        }>;
-        doc: NodeAction<    {
-        readonly [x: string]: any;
-        }>;
-        paragraph: NodeAction<    {
-        readonly [x: string]: any;
-        }>;
-        text: NodeAction<    {
-        readonly [x: string]: any;
-        }>;
-        heading: NodeAction<    {
-        readonly [x: string]: any;
-        }>;
-        codeBlock: NodeAction<    {
-        language: string;
-        }>;
-    };
-};
-
-/**
- * @internal
- */
-export declare function setupTestFromExtension<E extends Extension>(extension: E): {
-    editor: TestEditor<E>;
-    n: ExtractNodeActions<E>;
-    m: ExtractMarkActions<E>;
-};
-
 /**
  * @internal
  */
@@ -2543,6 +2595,13 @@ export declare const stateFacet: Facet<StatePayload, RootPayload>;
  * Parse a JSON object to a ProseMirror state.
  *
  * @public
+ *
+ * @example
+ *
+ * ```ts
+ * const json = { state: { type: 'doc', content: [{ type: 'paragraph' }], selection: { type: 'text', from: 1, to: 1 } } }
+ * const state = stateFromJSON(json, { schema: editor.schema })
+ * ```
  */
 declare function stateFromJSON(json: StateJSON, options: JSONParserOptions): EditorState;
 export { stateFromJSON }