@prosekit/core 0.7.6 → 0.7.8

package/dist/{chunk-MOSGJZHV.js → chunk-UKHJHMFE.js}

@@ -59,6 +59,42 @@ var Priority = /* @__PURE__ */ ((Priority2) => {
   return Priority2;
 })(Priority || {});
 
+// src/utils/type-assertion.ts
+import { Fragment, Mark, ProseMirrorNode, Slice } from "@prosekit/pm/model";
+import {
+  AllSelection,
+  NodeSelection,
+  Selection,
+  TextSelection
+} from "@prosekit/pm/state";
+function isProseMirrorNode(node) {
+  return node instanceof ProseMirrorNode;
+}
+function isMark(mark) {
+  return mark instanceof Mark;
+}
+function isFragment(fragment) {
+  return fragment instanceof Fragment;
+}
+function isSlice(slice) {
+  return slice instanceof Slice;
+}
+function isSelection(sel) {
+  return sel instanceof Selection;
+}
+function isTextSelection(sel) {
+  return sel instanceof TextSelection;
+}
+function isNodeSelection(sel) {
+  return sel instanceof NodeSelection;
+}
+function isAllSelection(sel) {
+  return sel instanceof AllSelection;
+}
+function isNotNullish(value) {
+  return value != null;
+}
+
 // src/facets/facet.ts
 var facetCount = 0;
 var Facet = class {
@@ -113,11 +149,6 @@ function toReversed(arr) {
   return (_b = (_a = arr.toReversed) == null ? void 0 : _a.call(arr)) != null ? _b : [...arr].reverse();
 }
 
-// src/utils/is-not-null.ts
-function isNotNull(value) {
-  return value != null;
-}
-
 // src/facets/facet-node.ts
 function zip5(a, b, mapper) {
   return [
@@ -208,7 +239,7 @@ var FacetNode = class {
     }
     if (this.facet.singleton) {
       const reducer = (_a = this.reducers)[_b = 2 /* default */] || (_a[_b] = this.facet.reducer);
-      const input = inputs.filter(isNotNull).flat();
+      const input = inputs.filter(isNotNullish).flat();
       output[2 /* default */] = reducer(input);
     } else {
       for (let pri = 0; pri < 5; pri++) {
@@ -441,7 +472,7 @@ function htmlFromJSON(json, options) {
 }
 
 // src/extensions/default-state.ts
-import { Selection } from "@prosekit/pm/state";
+import { Selection as Selection3 } from "@prosekit/pm/state";
 
 // src/facets/state.ts
 var stateFacet = defineFacet({
@@ -480,31 +511,78 @@ var stateFacet = defineFacet({
   parent: rootFacet
 });
 
+// src/utils/editor-content.ts
+import { Selection as Selection2 } from "@prosekit/pm/state";
+
+// src/utils/is-object.ts
+function isObject(v) {
+  return typeof v === "object" && v != null;
+}
+
+// src/utils/is-element.ts
+var ELEMENT_NODE = 1;
+function isElement(el) {
+  return isObject(el) && el.nodeType === ELEMENT_NODE && typeof el.nodeName === "string";
+}
+
+// src/utils/editor-content.ts
+function getEditorContentJSON(schema, content) {
+  if (typeof content === "string") {
+    return jsonFromHTML(content, { schema });
+  } else if (isElement(content)) {
+    return jsonFromElement(content, { schema });
+  } else {
+    return content;
+  }
+}
+function getEditorContentNode(schema, content) {
+  if (isProseMirrorNode(content)) {
+    return content;
+  }
+  return schema.nodeFromJSON(getEditorContentJSON(schema, content));
+}
+function getEditorContentDoc(schema, content) {
+  const doc = getEditorContentNode(schema, content);
+  assert(
+    doc.type.schema === schema,
+    "Document schema does not match editor schema"
+  );
+  assert(
+    doc.type === schema.topNodeType,
+    `Document type does not match editor top node type. Expected ${schema.topNodeType.name}, got ${doc.type.name}`
+  );
+  return doc;
+}
+function getEditorSelection(doc, selection) {
+  if (isSelection(selection)) {
+    assert(selection.$head.doc === doc, "Selection and doc do not match");
+    return selection;
+  }
+  if (selection === "start") {
+    return Selection2.atStart(doc);
+  }
+  if (selection === "end") {
+    return Selection2.atEnd(doc);
+  }
+  return Selection2.fromJSON(doc, selection);
+}
+
 // src/extensions/default-state.ts
 function defineDefaultState({
+  defaultSelection,
+  defaultContent,
   defaultDoc,
-  defaultHTML,
-  defaultSelection
+  defaultHTML
 }) {
-  if (defaultHTML && defaultDoc) {
-    throw new ProseKitError(
-      "Only one of defaultHTML and defaultDoc can be provided"
-    );
-  }
+  const defaultDocContent = defaultContent || defaultDoc || defaultHTML;
   return defineFacetPayload(stateFacet, [
     ({ schema }) => {
       const config = {};
-      if (defaultHTML) {
-        if (typeof defaultHTML === "string") {
-          defaultDoc = jsonFromHTML(defaultHTML, { schema });
-        } else {
-          defaultDoc = jsonFromElement(defaultHTML, { schema });
-        }
-      }
-      if (defaultDoc) {
-        config.doc = schema.nodeFromJSON(defaultDoc);
+      if (defaultDocContent) {
+        const json = getEditorContentJSON(schema, defaultDocContent);
+        config.doc = schema.nodeFromJSON(json);
         if (defaultSelection) {
-          config.selection = Selection.fromJSON(config.doc, defaultSelection);
+          config.selection = Selection3.fromJSON(config.doc, defaultSelection);
         }
       }
       return config;
@@ -556,29 +634,6 @@ function isMarkActive(state, type, attrs) {
   }
 }
 
-// src/utils/type-assertion.ts
-import { Mark, ProseMirrorNode } from "@prosekit/pm/model";
-import {
-  AllSelection,
-  NodeSelection,
-  TextSelection
-} from "@prosekit/pm/state";
-function isProseMirrorNode(node) {
-  return node instanceof ProseMirrorNode;
-}
-function isMark(mark) {
-  return mark instanceof Mark;
-}
-function isTextSelection(sel) {
-  return sel instanceof TextSelection;
-}
-function isNodeSelection(sel) {
-  return sel instanceof NodeSelection;
-}
-function isAllSelection(sel) {
-  return sel instanceof AllSelection;
-}
-
 // src/facets/union-extension.ts
 var UnionExtensionImpl = class extends BaseExtension {
   /**
@@ -646,6 +701,7 @@ function deepEquals(a, b) {
 
 // src/editor/action.ts
 import "@prosekit/pm/model";
+import mapValues from "just-map-values";
 
 // src/utils/attrs-match.ts
 function attrsMatch(nodeOrMark, attrs) {
@@ -673,28 +729,32 @@ function isNodeActive(state, type, attrs) {
 
 // src/editor/action.ts
 function createNodeActions(schema, getState, createNode = defaultCreateNode) {
-  const builders = {};
-  for (const type of Object.values(schema.nodes)) {
-    const builder = (...args) => buildNode(type, args, createNode);
-    builder.isActive = (attrs) => {
-      const state = getState();
-      return state ? isNodeActive(state, type, attrs) : false;
-    };
-    builders[type.name] = builder;
-  }
-  return builders;
+  return mapValues(
+    schema.nodes,
+    (type) => createNodeAction(type, getState, createNode)
+  );
+}
+function createNodeAction(type, getState, createNode) {
+  const action = (...args) => buildNode(type, args, createNode);
+  action.isActive = (attrs) => {
+    const state = getState();
+    return state ? isNodeActive(state, type, attrs) : false;
+  };
+  return action;
 }
 function createMarkActions(schema, getState, applyMark = defaultApplyMark) {
-  const builders = {};
-  for (const type of Object.values(schema.marks)) {
-    const builder = (...args) => buildMark(type, args, applyMark);
-    builder.isActive = (attrs) => {
-      const state = getState();
-      return state ? isMarkActive(state, type, attrs) : false;
-    };
-    builders[type.name] = builder;
-  }
-  return builders;
+  return mapValues(
+    schema.marks,
+    (type) => createMarkAction(type, getState, applyMark)
+  );
+}
+function createMarkAction(type, getState, applyMark) {
+  const action = (...args) => buildMark(type, args, applyMark);
+  action.isActive = (attrs) => {
+    const state = getState();
+    return state ? isMarkActive(state, type, attrs) : false;
+  };
+  return action;
 }
 function buildMark(type, args, applyMark) {
   const [attrs, children] = normalizeArgs(args);
@@ -702,7 +762,7 @@ function buildMark(type, args, applyMark) {
   return applyMark(mark, flattenChildren(type.schema, children));
 }
 var defaultApplyMark = (mark, children) => {
-  return children.map((child) => child.mark([mark]));
+  return children.map((node) => node.mark(mark.addToSet(node.marks)));
 };
 function buildNode(type, args, createNode) {
   const [attrs, children] = normalizeArgs(args);
@@ -750,27 +810,24 @@ function isNodeChild(value) {
 
 // src/editor/editor.ts
 function setupEditorExtension(options) {
-  const { defaultDoc, defaultHTML, defaultSelection } = options;
-  if (defaultDoc || defaultHTML) {
+  if (options.defaultContent || options.defaultDoc || options.defaultHTML) {
     return union([
       options.extension,
-      defineDefaultState({
-        defaultDoc,
-        defaultHTML,
-        defaultSelection
-      })
+      defineDefaultState(options)
     ]);
   }
   return options.extension;
 }
 function createEditor(options) {
   const extension = setupEditorExtension(options);
-  return Editor.create(new EditorInstance(extension));
+  const instance = new EditorInstance(extension);
+  return new Editor(instance);
 }
 var EditorInstance = class {
   constructor(extension) {
     this.view = null;
     this.commands = {};
+    this.afterMounted = [];
     this.getState = () => {
       var _a;
       return ((_a = this.view) == null ? void 0 : _a.state) || this.directEditorProps.state;
@@ -798,6 +855,21 @@ var EditorInstance = class {
       this.directEditorProps.state = state;
     }
   }
+  setContent(content, selection) {
+    const doc = getEditorContentDoc(this.schema, content);
+    doc.check();
+    const sel = getEditorSelection(doc, selection || "start");
+    const oldState = this.getState();
+    if (doc.eq(oldState.doc) && (!selection || sel.eq(oldState.selection))) {
+      return;
+    }
+    const newState = EditorState2.create({
+      doc,
+      selection: sel,
+      plugins: oldState.plugins
+    });
+    this.updateState(newState);
+  }
   updateExtension(extension, add) {
     var _a, _b, _c, _d;
     const view = this.view;
@@ -829,19 +901,33 @@ var EditorInstance = class {
       }
     }
   }
+  use(extension) {
+    if (!this.mounted) {
+      let canceled = false;
+      let lazyRemove = null;
+      const lazyCreate = () => {
+        if (!canceled) {
+          lazyRemove = this.use(extension);
+        }
+      };
+      this.afterMounted.push(lazyCreate);
+      return () => {
+        canceled = true;
+        lazyRemove == null ? void 0 : lazyRemove();
+      };
+    }
+    this.updateExtension(extension, true);
+    return () => this.updateExtension(extension, false);
+  }
   mount(place) {
     if (this.view) {
       throw new ProseKitError("Editor is already mounted");
     }
-    if (!place) {
-      throw new ProseKitError("Can't mount editor without a place");
-    }
     this.view = new EditorView({ mount: place }, this.directEditorProps);
+    this.afterMounted.forEach((callback) => callback());
   }
   unmount() {
-    if (!this.view) {
-      throw new ProseKitError("Editor is not mounted yet");
-    }
+    if (!this.view) return;
     this.directEditorProps.state = this.view.state;
     this.view.destroy();
     this.view = null;
@@ -891,25 +977,81 @@ var EditorInstance = class {
     delete this.commands[name];
   }
 };
-var Editor = class _Editor {
+var Editor = class {
   /**
    * @internal
    */
   constructor(instance) {
-    this.afterMounted = [];
-    this.instance = instance;
-    this.mount = this.mount.bind(this);
-    this.unmount = this.unmount.bind(this);
-    this.use = this.use.bind(this);
-  }
-  /**
-   * @internal
-   */
-  static create(instance) {
+    /**
+     * Mount the editor to the given HTML element.
+     * Pass `null` or `undefined` to unmount the editor.
+     */
+    this.mount = (place) => {
+      if (place) {
+        this.instance.mount(place);
+      } else {
+        this.instance.unmount();
+      }
+    };
+    /**
+     * Unmount the editor. This is equivalent to `mount(null)`.
+     */
+    this.unmount = () => {
+      this.instance.unmount();
+    };
+    /**
+     * Focus the editor.
+     */
+    this.focus = () => {
+      var _a;
+      (_a = this.instance.view) == null ? void 0 : _a.focus();
+    };
+    /**
+     * Blur the editor.
+     */
+    this.blur = () => {
+      var _a;
+      (_a = this.instance.view) == null ? void 0 : _a.dom.blur();
+    };
+    /**
+     * Register an extension to the editor. Return a function to unregister the
+     * extension.
+     */
+    this.use = (extension) => {
+      return this.instance.use(extension);
+    };
+    /**
+     * Update the editor's state.
+     *
+     * @remarks
+     *
+     * This is an advanced method. Use it only if you have a specific reason to
+     * directly manipulate the editor's state.
+     */
+    this.updateState = (state) => {
+      this.instance.updateState(state);
+    };
+    /**
+     * Update the editor's document and selection.
+     *
+     * @param content - The new document to set. It can be one of the following:
+     *   - A ProseMirror node instance
+     *   - A ProseMirror node JSON object
+     *   - An HTML string
+     *   - An HTML element instance
+     * @param selection - Optional. Specifies the new selection. It can be one of the following:
+     *   - A ProseMirror selection instance
+     *   - A ProseMirror selection JSON object
+     *   - The string "start" (to set selection at the beginning, default value)
+     *   - The string "end" (to set selection at the end)
+     */
+    this.setContent = (content, selection) => {
+      return this.instance.setContent(content, selection);
+    };
     if (!(instance instanceof EditorInstance)) {
       throw new TypeError("Invalid EditorInstance");
     }
-    return new _Editor(instance);
+    this.instance = instance;
   }
   /**
    * Whether the editor is mounted.
@@ -929,68 +1071,6 @@ var Editor = class _Editor {
   get schema() {
     return this.instance.schema;
   }
-  /**
-   * Whether the editor is focused.
-   */
-  get focused() {
-    var _a, _b;
-    return (_b = (_a = this.instance.view) == null ? void 0 : _a.hasFocus()) != null ? _b : false;
-  }
-  /**
-   * Mount the editor to the given HTML element.
-   * Pass `null` or `undefined` to unmount the editor.
-   */
-  mount(place) {
-    if (!place) {
-      return this.unmount();
-    }
-    this.instance.mount(place);
-    this.afterMounted.forEach((callback) => callback());
-  }
-  /**
-   * Unmount the editor. This is equivalent to `mount(null)`.
-   */
-  unmount() {
-    if (this.mounted) {
-      this.instance.unmount();
-    }
-  }
-  /**
-   * Focus the editor.
-   */
-  focus() {
-    var _a;
-    (_a = this.instance.view) == null ? void 0 : _a.focus();
-  }
-  /**
-   * Blur the editor.
-   */
-  blur() {
-    var _a;
-    (_a = this.instance.view) == null ? void 0 : _a.dom.blur();
-  }
-  /**
-   * Register an extension to the editor. Return a function to unregister the
-   * extension.
-   */
-  use(extension) {
-    if (!this.mounted) {
-      let canceled = false;
-      let lazyRemove = null;
-      const lazyCreate = () => {
-        if (!canceled) {
-          lazyRemove = this.use(extension);
-        }
-      };
-      this.afterMounted.push(lazyCreate);
-      return () => {
-        canceled = true;
-        lazyRemove == null ? void 0 : lazyRemove();
-      };
-    }
-    this.instance.updateExtension(extension, true);
-    return () => this.instance.updateExtension(extension, false);
-  }
   /**
    * The editor's current state.
    */
@@ -998,15 +1078,11 @@ var Editor = class _Editor {
     return this.instance.getState();
   }
   /**
-   * Update the editor's state.
-   *
-   * @remarks
-   *
-   * This is an advanced method. Use it only if you have a specific reason to
-   * directly manipulate the editor's state.
+   * Whether the editor is focused.
    */
-  updateState(state) {
-    this.instance.updateState(state);
+  get focused() {
+    var _a, _b;
+    return (_b = (_a = this.instance.view) == null ? void 0 : _a.hasFocus()) != null ? _b : false;
   }
   /**
    * All {@link CommandAction}s defined by the editor.
@@ -1037,12 +1113,21 @@ export {
   isNodeActive,
   Priority,
   toReversed,
-  isNotNull,
+  isProseMirrorNode,
+  isMark,
+  isFragment,
+  isSlice,
+  isSelection,
+  isTextSelection,
+  isNodeSelection,
+  isAllSelection,
+  isNotNullish,
   defineFacet,
   rootFacet,
   schemaFacet,
   defineFacetPayload,
   stateFacet,
+  isElement,
   jsonFromState,
   stateFromJSON,
   jsonFromNode,
@@ -1057,11 +1142,6 @@ export {
   defineDefaultState,
   isMarkAbsent,
   isMarkActive,
-  isProseMirrorNode,
-  isMark,
-  isTextSelection,
-  isNodeSelection,
-  isAllSelection,
   createNodeActions,
   createMarkActions,
   union,

package/dist/prosekit-core-test.js

@@ -4,11 +4,12 @@ import {
   assert,
   createMarkActions,
   createNodeActions,
+  isProseMirrorNode,
   setupEditorExtension
-} from "./chunk-MOSGJZHV.js";
+} from "./chunk-UKHJHMFE.js";
 
 // src/test/test-editor.ts
-import { EditorState, NodeSelection, TextSelection } from "@prosekit/pm/state";
+import { NodeSelection, TextSelection } from "@prosekit/pm/state";
 
 // src/test/test-builder.ts
 var createNodeForTest = (type, attrs, children) => {
@@ -53,7 +54,7 @@ var createNodeForTest = (type, attrs, children) => {
 };
 var applyMarkForTest = (mark, children) => {
   return children.map((node) => {
-    const newNode = node.mark([mark]);
+    const newNode = node.mark(mark.addToSet(node.marks));
     newNode.tags = node.tags;
     return newNode;
   });
@@ -85,6 +86,12 @@ var TestEditorInstance = class extends EditorInstance {
     this.nodes = createNodeActions(this.schema, this.getState, createNodeForTest);
     this.marks = createMarkActions(this.schema, this.getState, applyMarkForTest);
   }
+  setContent(content, selection) {
+    return super.setContent(
+      content,
+      isProseMirrorNode(content) && !selection ? getSelection(content) : selection
+    );
+  }
 };
 var TestEditor = class extends Editor {
   constructor(instance) {
@@ -104,21 +111,7 @@ var TestEditor = class extends Editor {
    * ```
    */
   set(doc) {
-    assert(
-      doc.type.schema === this.schema,
-      "Document schema does not match editor schema"
-    );
-    assert(
-      doc.type === this.schema.topNodeType,
-      "Document type does not match editor top node type"
-    );
-    const selection = getSelection(doc);
-    const state = EditorState.create({
-      doc,
-      selection,
-      plugins: this.state.plugins
-    });
-    this.updateState(state);
+    return this.setContent(doc);
   }
   dispatchEvent(event) {
     this.view.dispatchEvent(event);
@@ -126,7 +119,8 @@ var TestEditor = class extends Editor {
 };
 function createTestEditor(options) {
   const extension = setupEditorExtension(options);
-  return new TestEditor(new TestEditorInstance(extension));
+  const instance = new TestEditorInstance(extension);
+  return new TestEditor(instance);
 }
 export {
   createTestEditor

package/dist/prosekit-core.d.ts

@@ -142,11 +142,15 @@ export { SimplifyUnion } from './_tsup-dts-rollup';
 export { assert } from './_tsup-dts-rollup';
 export { canUseRegexLookbehind } from './_tsup-dts-rollup';
 export { clsx } from './_tsup-dts-rollup';
+export { collectChildren } from './_tsup-dts-rollup';
 export { collectNodes } from './_tsup-dts-rollup';
 export { NodeContent } from './_tsup-dts-rollup';
 export { containsInlineNode } from './_tsup-dts-rollup';
 export { defaultBlockAt } from './_tsup-dts-rollup';
 export { isApple } from './_tsup-dts-rollup';
+export { findParentNode } from './_tsup-dts-rollup';
+export { FindParentNodeResult } from './_tsup-dts-rollup';
+export { findParentNodeOfType } from './_tsup-dts-rollup';
 export { _getId } from './_tsup-dts-rollup';
 export { getMarkType } from './_tsup-dts-rollup';
 export { getNodeType } from './_tsup-dts-rollup';
@@ -171,9 +175,12 @@ 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 { isFragment } from './_tsup-dts-rollup';
 export { isMark } from './_tsup-dts-rollup';
 export { isNodeSelection } from './_tsup-dts-rollup';
 export { isProseMirrorNode } from './_tsup-dts-rollup';
+export { isSelection } from './_tsup-dts-rollup';
+export { isSlice } from './_tsup-dts-rollup';
 export { isTextSelection } from './_tsup-dts-rollup';
 export { withSkipCodeBlock } from './_tsup-dts-rollup';
 export { OBJECT_REPLACEMENT_CHARACTER } from './_tsup-dts-rollup';