@prosekit/core 0.3.1 → 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';
@@ -598,6 +600,20 @@ declare type DocChangeHandler = (view: EditorView, prevState: EditorState) => vo
 export { DocChangeHandler }
 export { DocChangeHandler as DocChangeHandler_alias_1 }
 
+/**
+ * @internal
+ */
+export declare class DOMDocumentNotFoundError extends ProseKitError {
+    constructor();
+}
+
+/** @public */
+declare type DOMDocumentOptions = {
+    document?: Document;
+};
+export { DOMDocumentOptions }
+export { DOMDocumentOptions as DOMDocumentOptions_alias_1 }
+
 /**
  * @internal
  */
@@ -620,6 +636,22 @@ export { DOMEventHandler as DOMEventHandler_alias_1 }
  */
 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 }
@@ -726,7 +758,25 @@ export { EditorOptions as EditorOptions_alias_1 }
  *
  * @internal
  */
-export declare function elementFromHTML(html: string): 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, options: JSONParserOptions & DOMSerializerOptions & DOMDocumentOptions): HTMLElement;
+export { elementFromJSON }
+export { elementFromJSON as elementFromJSON_alias_1 }
+
+/**
+ * Serialize a ProseMirror node to a HTML element.
+ *
+ * @public
+ */
+declare function elementFromNode(node: ProseMirrorNode, options?: DOMSerializerOptions & DOMDocumentOptions): HTMLElement;
+export { elementFromNode }
+export { elementFromNode as elementFromNode_alias_1 }
 
 declare type EmptyValue = undefined | null | EmptyObject;
 
@@ -890,6 +940,14 @@ declare interface FacetOptions<Input, Output> {
 export { FacetOptions }
 export { FacetOptions as FacetOptions_alias_1 }
 
+export declare function findBrowserDocument(options?: {
+    document?: Document;
+}): Document | undefined;
+
+export declare function findBrowserWindow(options?: {
+    document?: Document;
+}): (Window & typeof globalThis) | null | undefined;
+
 /**
  * A function that is called when the editor gains or loses focus.
  *
@@ -901,9 +959,13 @@ declare type FocusChangeHandler = (hasFocus: boolean) => void;
 export { FocusChangeHandler }
 export { FocusChangeHandler as FocusChangeHandler_alias_1 }
 
-export declare function getBrowserDocument(): Document | undefined;
+export declare function getBrowserDocument(options?: {
+    document?: Document;
+}): Document;
 
-export declare function getBrowserWindow(): (Window & typeof globalThis) | null | undefined;
+export declare function getBrowserWindow(options?: {
+    document?: Document;
+}): Window & typeof globalThis;
 
 export declare function getCustomSelection(state: EditorState, from?: number | null, to?: number | null): Selection_3;
 
@@ -938,6 +1000,29 @@ export declare type GroupedEntries<T extends Record<string, any>> = {
 
 export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): GroupedEntries<T>;
 
+/**
+ * @internal
+ */
+export declare function htmlFromElement(element: HTMLElement): string;
+
+/**
+ * Parse a ProseMirror document JSON object to a HTML string.
+ *
+ * @public
+ */
+declare function htmlFromJSON(json: NodeJSON, options: JSONParserOptions & DOMSerializerOptions & DOMDocumentOptions): string;
+export { htmlFromJSON }
+export { htmlFromJSON as htmlFromJSON_alias_1 }
+
+/**
+ * Serialize a ProseMirror node to a HTML string
+ *
+ * @public
+ */
+declare function htmlFromNode(node: ProseMirrorNode, options?: DOMSerializerOptions & DOMDocumentOptions): string;
+export { htmlFromNode }
+export { htmlFromNode as htmlFromNode_alias_1 }
+
 /**
  * Returns a command that inserts the given node at the current selection or at
  * the given position.
@@ -1032,20 +1117,18 @@ export { isTextSelection }
 export { isTextSelection as isTextSelection_alias_1 }
 
 /**
- * Parse a HTML element to a ProseMirror document JSON.
+ * Serialize a HTML element to a ProseMirror document JSON object.
  *
  * @public
  */
-declare function jsonFromElement(element: HTMLElement, schema: Schema): NodeJSON;
-export { jsonFromElement }
-export { jsonFromElement as jsonFromElement_alias_1 }
+export declare function jsonFromElement(element: DOMNode, options: DOMParserOptions & JSONParserOptions): NodeJSON;
 
 /**
- * Parse a HTML string to a ProseMirror document JSON.
+ * Parse a HTML string to a ProseMirror document JSON object.
  *
  * @public
  */
-declare function jsonFromHTML(html: string, schema: Schema): NodeJSON;
+declare function jsonFromHTML(html: string, options: DOMDocumentOptions & DOMParserOptions & JSONParserOptions): NodeJSON;
 export { jsonFromHTML }
 export { jsonFromHTML as jsonFromHTML_alias_1 }
 
@@ -1067,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 }
@@ -1199,7 +1289,7 @@ export declare type NodeContent = ProseMirrorNode | ProseMirrorFragment | NodeCo
  *
  * @public
  */
-declare function nodeFromElement(element: HTMLElement, schema: Schema): ProseMirrorNode;
+declare function nodeFromElement(element: DOMNode, options: DOMParserOptions & JSONParserOptions): ProseMirrorNode;
 export { nodeFromElement }
 export { nodeFromElement as nodeFromElement_alias_1 }
 
@@ -1208,7 +1298,7 @@ export { nodeFromElement as nodeFromElement_alias_1 }
  *
  * @public
  */
-declare function nodeFromHTML(html: string, schema: Schema): ProseMirrorNode;
+declare function nodeFromHTML(html: string, options: DOMParserOptions & JSONParserOptions & DOMDocumentOptions): ProseMirrorNode;
 export { nodeFromHTML }
 export { nodeFromHTML as nodeFromHTML_alias_1 }
 
@@ -1217,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 }
 
@@ -1469,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

@@ -99,7 +99,10 @@ export { _getId } from './_tsup-dts-rollup';
 export { getMarkType } from './_tsup-dts-rollup';
 export { getNodeType } from './_tsup-dts-rollup';
 export { isInCodeBlock } from './_tsup-dts-rollup';
-export { jsonFromElement } from './_tsup-dts-rollup';
+export { elementFromJSON } from './_tsup-dts-rollup';
+export { elementFromNode } from './_tsup-dts-rollup';
+export { htmlFromJSON } from './_tsup-dts-rollup';
+export { htmlFromNode } from './_tsup-dts-rollup';
 export { jsonFromHTML } from './_tsup-dts-rollup';
 export { jsonFromNode } from './_tsup-dts-rollup';
 export { jsonFromState } from './_tsup-dts-rollup';
@@ -107,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

@@ -15,6 +15,13 @@ var EditorNotFoundError = class extends ProseKitError {
     );
   }
 };
+var DOMDocumentNotFoundError = class extends ProseKitError {
+  constructor() {
+    super(
+      "Unable to find browser Document. When not in the browser environment, you need to pass a DOM Document."
+    );
+  }
+};
 
 // src/utils/get-mark-type.ts
 function getMarkType(schema, type) {
@@ -433,11 +440,11 @@ var stateFacet = Facet.defineRootFacet({
 });
 
 // src/utils/parse.ts
-import { DOMParser } from "@prosekit/pm/model";
+import { DOMParser, DOMSerializer } from "@prosekit/pm/model";
 import { EditorState } from "@prosekit/pm/state";
 
 // src/utils/get-dom-api.ts
-function getGlobalBrowserDocument() {
+function findGlobalBrowserDocument() {
   if (typeof document !== "undefined") {
     return document;
   }
@@ -445,7 +452,7 @@ function getGlobalBrowserDocument() {
     return globalThis.document;
   }
 }
-function getGlobalBrowserWindow() {
+function findGlobalBrowserWindow() {
   if (typeof window !== "undefined") {
     return window;
   }
@@ -453,49 +460,85 @@ function getGlobalBrowserWindow() {
     return globalThis.window;
   }
 }
-function getBrowserWindow() {
-  var _a;
-  const win = getGlobalBrowserWindow();
-  if (win) {
+function findBrowserDocument(options) {
+  var _a, _b, _c;
+  return (_c = (_a = options == null ? void 0 : options.document) != null ? _a : findGlobalBrowserDocument()) != null ? _c : (_b = findGlobalBrowserWindow()) == null ? void 0 : _b.document;
+}
+function findBrowserWindow(options) {
+  var _a, _b, _c, _d;
+  return (_d = (_b = (_a = options == null ? void 0 : options.document) == null ? void 0 : _a.defaultView) != null ? _b : findGlobalBrowserWindow()) != null ? _d : (_c = findBrowserDocument(options)) == null ? void 0 : _c.defaultView;
+}
+function getBrowserDocument(options) {
+  const doc = findBrowserDocument(options);
+  if (doc)
+    return doc;
+  throw new DOMDocumentNotFoundError();
+}
+function getBrowserWindow(options) {
+  const win = findBrowserWindow(options);
+  if (win)
     return win;
-  }
-  return (_a = getGlobalBrowserDocument()) == null ? void 0 : _a.defaultView;
+  throw new DOMDocumentNotFoundError();
 }
 
 // src/utils/parse.ts
-function nodeFromElement(element, schema) {
-  return DOMParser.fromSchema(schema).parse(element);
-}
-function jsonFromElement(element, schema) {
-  return jsonFromNode(nodeFromElement(element, schema));
+function jsonFromState(state) {
+  return state.toJSON();
 }
-function nodeFromHTML(html, schema) {
-  return nodeFromElement(elementFromHTML(html), schema);
+function stateFromJSON(json, options) {
+  return EditorState.fromJSON({ schema: options.schema }, json);
 }
-function jsonFromHTML(html, schema) {
-  return jsonFromElement(elementFromHTML(html), schema);
+function jsonFromNode(node) {
+  return node.toJSON();
 }
-function elementFromHTML(html) {
-  const win = getBrowserWindow();
-  if (!win) {
-    throw new ProseKitError(
-      "No Browser Document Found. You can only parse a HTML string in the browser environment."
+function nodeFromJSON(json, options) {
+  return options.schema.nodeFromJSON(json);
+}
+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 = Serializer.fromSchema(schema);
+  if (schema.topNodeType !== node.type) {
+    return serializer.serializeNode(node, { document: document2 });
+  } else {
+    return serializer.serializeFragment(
+      node.content,
+      { document: document2 },
+      document2.createElement("div")
     );
   }
+}
+function elementFromHTML(html, options) {
+  const win = getBrowserWindow(options);
   const parser = new win.DOMParser();
-  return parser.parseFromString(`<body>${html}</body>`, "text/html").body;
+  return parser.parseFromString(`<body><div>${html}</div></body>`, "text/html").body.firstElementChild;
 }
-function jsonFromState(state) {
-  return state.toJSON();
+function htmlFromElement(element) {
+  return element.outerHTML;
 }
-function jsonFromNode(node) {
-  return node.toJSON();
+function nodeFromHTML(html, options) {
+  return nodeFromElement(elementFromHTML(html, options), options);
+}
+function htmlFromNode(node, options) {
+  return elementFromNode(node, options).outerHTML;
+}
+function jsonFromElement(element, options) {
+  return jsonFromNode(nodeFromElement(element, options));
+}
+function elementFromJSON(json, options) {
+  return elementFromNode(nodeFromJSON(json, options), options);
 }
-function nodeFromJSON(json, schema) {
-  return schema.nodeFromJSON(json);
+function jsonFromHTML(html, options) {
+  return jsonFromElement(elementFromHTML(html, options), options);
 }
-function stateFromJSON(json, schema) {
-  return EditorState.fromJSON({ schema }, json);
+function htmlFromJSON(json, options) {
+  return htmlFromElement(elementFromJSON(json, options));
 }
 
 // src/extensions/default-state.ts
@@ -514,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) {
@@ -1975,9 +2018,13 @@ export {
   defineTripleClickOnHandler,
   defineUnmountHandler,
   defineUpdateHandler,
+  elementFromJSON,
+  elementFromNode,
   expandMark,
   getMarkType,
   getNodeType,
+  htmlFromJSON,
+  htmlFromNode,
   insertNode,
   isAllSelection,
   isInCodeBlock,
@@ -1985,7 +2032,6 @@ export {
   isNodeSelection,
   isProseMirrorNode,
   isTextSelection,
-  jsonFromElement,
   jsonFromHTML,
   jsonFromNode,
   jsonFromState,

package/package.json

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