@prosekit/core 0.3.2 → 0.4.0

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

@@ -6,6 +6,8 @@ import type { ConditionalExcept } from 'type-fest';
 import type { ContentMatch } from '@prosekit/pm/model';
 import type { DirectEditorProps } from '@prosekit/pm/view';
 import type { DOMEventMap } from '@prosekit/pm/view';
+import { DOMParser as DOMParser_2 } from '@prosekit/pm/model';
+import { DOMSerializer } from '@prosekit/pm/model';
 import { EditorState } from '@prosekit/pm/state';
 import type { EditorStateConfig } from '@prosekit/pm/state';
 import { EditorView } from '@prosekit/pm/view';
@@ -605,6 +607,13 @@ export declare class DOMDocumentNotFoundError extends ProseKitError {
     constructor();
 }
 
+/** @public */
+declare type DOMDocumentOptions = {
+    document?: Document;
+};
+export { DOMDocumentOptions }
+export { DOMDocumentOptions as DOMDocumentOptions_alias_1 }
+
 /**
  * @internal
  */
@@ -629,6 +638,20 @@ export declare type DOMEventPayload = [event: string, handler: DOMEventHandler];
 
 export declare type DOMNode = InstanceType<typeof window.Node>;
 
+/** @public */
+declare type DOMParserOptions = {
+    DOMParser?: typeof DOMParser_2;
+};
+export { DOMParserOptions }
+export { DOMParserOptions as DOMParserOptions_alias_1 }
+
+/** @public */
+declare type DOMSerializerOptions = {
+    DOMSerializer?: typeof DOMSerializer;
+};
+export { DOMSerializerOptions }
+export { DOMSerializerOptions as DOMSerializerOptions_alias_1 }
+
 declare type DoubleClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;
 export { DoubleClickHandler }
 export { DoubleClickHandler as DoubleClickHandler_alias_1 }
@@ -735,18 +758,14 @@ export { EditorOptions as EditorOptions_alias_1 }
  *
  * @internal
  */
-export declare function elementFromHTML(html: string, options?: {
-    document?: Document;
-}): HTMLElement;
+export declare function elementFromHTML(html: string, options?: DOMDocumentOptions): HTMLElement;
 
 /**
  * Parse a ProseMirror document JSON object to a HTML element.
  *
  * @public
  */
-declare function elementFromJSON(json: NodeJSON, schema: Schema, options?: {
-    document?: Document;
-}): HTMLElement;
+declare function elementFromJSON(json: NodeJSON, options: JSONParserOptions & DOMSerializerOptions & DOMDocumentOptions): HTMLElement;
 export { elementFromJSON }
 export { elementFromJSON as elementFromJSON_alias_1 }
 
@@ -755,9 +774,7 @@ export { elementFromJSON as elementFromJSON_alias_1 }
  *
  * @public
  */
-declare function elementFromNode(node: ProseMirrorNode, options?: {
-    document?: Document;
-}): HTMLElement;
+declare function elementFromNode(node: ProseMirrorNode, options?: DOMSerializerOptions & DOMDocumentOptions): HTMLElement;
 export { elementFromNode }
 export { elementFromNode as elementFromNode_alias_1 }
 
@@ -993,9 +1010,7 @@ export declare function htmlFromElement(element: HTMLElement): string;
  *
  * @public
  */
-declare function htmlFromJSON(json: NodeJSON, schema: Schema, options?: {
-    document?: Document;
-}): string;
+declare function htmlFromJSON(json: NodeJSON, options: JSONParserOptions & DOMSerializerOptions & DOMDocumentOptions): string;
 export { htmlFromJSON }
 export { htmlFromJSON as htmlFromJSON_alias_1 }
 
@@ -1004,7 +1019,7 @@ export { htmlFromJSON as htmlFromJSON_alias_1 }
  *
  * @public
  */
-declare function htmlFromNode(node: ProseMirrorNode): string;
+declare function htmlFromNode(node: ProseMirrorNode, options?: DOMSerializerOptions & DOMDocumentOptions): string;
 export { htmlFromNode }
 export { htmlFromNode as htmlFromNode_alias_1 }
 
@@ -1106,16 +1121,14 @@ export { isTextSelection as isTextSelection_alias_1 }
  *
  * @public
  */
-export declare function jsonFromElement(element: DOMNode, schema: Schema): NodeJSON;
+export declare function jsonFromElement(element: DOMNode, options: DOMParserOptions & JSONParserOptions): NodeJSON;
 
 /**
  * Parse a HTML string to a ProseMirror document JSON object.
  *
  * @public
  */
-declare function jsonFromHTML(html: string, schema: Schema, options?: {
-    document?: Document;
-}): NodeJSON;
+declare function jsonFromHTML(html: string, options: DOMDocumentOptions & DOMParserOptions & JSONParserOptions): NodeJSON;
 export { jsonFromHTML }
 export { jsonFromHTML as jsonFromHTML_alias_1 }
 
@@ -1137,6 +1150,13 @@ declare function jsonFromState(state: EditorState): StateJSON;
 export { jsonFromState }
 export { jsonFromState as jsonFromState_alias_1 }
 
+/** @public */
+declare type JSONParserOptions = {
+    schema: Schema;
+};
+export { JSONParserOptions }
+export { JSONParserOptions as JSONParserOptions_alias_1 }
+
 declare type KeyDownHandler = (view: EditorView, event: KeyboardEvent) => boolean | void;
 export { KeyDownHandler }
 export { KeyDownHandler as KeyDownHandler_alias_1 }
@@ -1269,7 +1289,7 @@ export declare type NodeContent = ProseMirrorNode | ProseMirrorFragment | NodeCo
  *
  * @public
  */
-declare function nodeFromElement(element: DOMNode, schema: Schema): ProseMirrorNode;
+declare function nodeFromElement(element: DOMNode, options: DOMParserOptions & JSONParserOptions): ProseMirrorNode;
 export { nodeFromElement }
 export { nodeFromElement as nodeFromElement_alias_1 }
 
@@ -1278,9 +1298,7 @@ export { nodeFromElement as nodeFromElement_alias_1 }
  *
  * @public
  */
-declare function nodeFromHTML(html: string, schema: Schema, options?: {
-    document?: Document;
-}): ProseMirrorNode;
+declare function nodeFromHTML(html: string, options: DOMParserOptions & JSONParserOptions & DOMDocumentOptions): ProseMirrorNode;
 export { nodeFromHTML }
 export { nodeFromHTML as nodeFromHTML_alias_1 }
 
@@ -1289,7 +1307,7 @@ export { nodeFromHTML as nodeFromHTML_alias_1 }
  *
  * @public
  */
-declare function nodeFromJSON(json: NodeJSON, schema: Schema): ProseMirrorNode;
+declare function nodeFromJSON(json: NodeJSON, options: JSONParserOptions): ProseMirrorNode;
 export { nodeFromJSON }
 export { nodeFromJSON as nodeFromJSON_alias_1 }
 
@@ -1541,7 +1559,7 @@ export declare const stateFacet: Facet<StatePayload, StatePayload>;
  *
  * @public
  */
-declare function stateFromJSON(json: StateJSON, schema: Schema): EditorState;
+declare function stateFromJSON(json: StateJSON, options: JSONParserOptions): EditorState;
 export { stateFromJSON }
 export { stateFromJSON as stateFromJSON_alias_1 }
 

package/dist/prosekit-core.d.ts

@@ -110,6 +110,10 @@ export { nodeFromElement } from './_tsup-dts-rollup';
 export { nodeFromHTML } from './_tsup-dts-rollup';
 export { nodeFromJSON } from './_tsup-dts-rollup';
 export { stateFromJSON } from './_tsup-dts-rollup';
+export { DOMDocumentOptions } from './_tsup-dts-rollup';
+export { DOMParserOptions } from './_tsup-dts-rollup';
+export { DOMSerializerOptions } from './_tsup-dts-rollup';
+export { JSONParserOptions } from './_tsup-dts-rollup';
 export { isAllSelection } from './_tsup-dts-rollup';
 export { isMark } from './_tsup-dts-rollup';
 export { isNodeSelection } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -485,27 +485,34 @@ function getBrowserWindow(options) {
 function jsonFromState(state) {
   return state.toJSON();
 }
-function stateFromJSON(json, schema) {
-  return EditorState.fromJSON({ schema }, json);
+function stateFromJSON(json, options) {
+  return EditorState.fromJSON({ schema: options.schema }, json);
 }
 function jsonFromNode(node) {
   return node.toJSON();
 }
-function nodeFromJSON(json, schema) {
-  return schema.nodeFromJSON(json);
+function nodeFromJSON(json, options) {
+  return options.schema.nodeFromJSON(json);
 }
-function nodeFromElement(element, schema) {
-  return DOMParser.fromSchema(schema).parse(element);
+function nodeFromElement(element, options) {
+  const Parser = options.DOMParser || DOMParser;
+  const schema = options.schema;
+  return Parser.fromSchema(schema).parse(element);
 }
 function elementFromNode(node, options) {
+  const Serializer = (options == null ? void 0 : options.DOMSerializer) || DOMSerializer;
+  const document2 = getBrowserDocument(options);
   const schema = node.type.schema;
-  const serializer = DOMSerializer.fromSchema(schema);
+  const serializer = Serializer.fromSchema(schema);
   if (schema.topNodeType !== node.type) {
-    return serializer.serializeNode(node, options);
+    return serializer.serializeNode(node, { document: document2 });
+  } else {
+    return serializer.serializeFragment(
+      node.content,
+      { document: document2 },
+      document2.createElement("div")
+    );
   }
-  const doc = getBrowserDocument();
-  const div = doc.createElement("div");
-  return serializer.serializeFragment(node.content, options, div);
 }
 function elementFromHTML(html, options) {
   const win = getBrowserWindow(options);
@@ -515,23 +522,23 @@ function elementFromHTML(html, options) {
 function htmlFromElement(element) {
   return element.outerHTML;
 }
-function nodeFromHTML(html, schema, options) {
-  return nodeFromElement(elementFromHTML(html, options), schema);
+function nodeFromHTML(html, options) {
+  return nodeFromElement(elementFromHTML(html, options), options);
 }
-function htmlFromNode(node) {
-  return elementFromNode(node).outerHTML;
+function htmlFromNode(node, options) {
+  return elementFromNode(node, options).outerHTML;
 }
-function jsonFromElement(element, schema) {
-  return jsonFromNode(nodeFromElement(element, schema));
+function jsonFromElement(element, options) {
+  return jsonFromNode(nodeFromElement(element, options));
 }
-function elementFromJSON(json, schema, options) {
-  return elementFromNode(nodeFromJSON(json, schema), options);
+function elementFromJSON(json, options) {
+  return elementFromNode(nodeFromJSON(json, options), options);
 }
-function jsonFromHTML(html, schema, options) {
-  return jsonFromElement(elementFromHTML(html, options), schema);
+function jsonFromHTML(html, options) {
+  return jsonFromElement(elementFromHTML(html, options), options);
 }
-function htmlFromJSON(json, schema, options) {
-  return htmlFromElement(elementFromJSON(json, schema, options));
+function htmlFromJSON(json, options) {
+  return htmlFromElement(elementFromJSON(json, options));
 }
 
 // src/extensions/default-state.ts
@@ -550,9 +557,9 @@ function defineDefaultState({
       const config = {};
       if (defaultHTML) {
         if (typeof defaultHTML === "string") {
-          defaultDoc = jsonFromHTML(defaultHTML, schema);
+          defaultDoc = jsonFromHTML(defaultHTML, { schema });
         } else {
-          defaultDoc = jsonFromElement(defaultHTML, schema);
+          defaultDoc = jsonFromElement(defaultHTML, { schema });
         }
       }
       if (defaultDoc) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "private": false,
   "author": {
     "name": "ocavue",