@prosekit/core 0.7.5 → 0.7.7

package/dist/{chunk-M267LRMB.js → chunk-MDJ2B4IL.js}

@@ -440,8 +440,35 @@ function htmlFromJSON(json, options) {
   return htmlFromElement(elementFromJSON(json, options));
 }
 
+// src/utils/type-assertion.ts
+import { Mark, ProseMirrorNode } from "@prosekit/pm/model";
+import {
+  AllSelection,
+  NodeSelection,
+  TextSelection,
+  Selection
+} from "@prosekit/pm/state";
+function isProseMirrorNode(node) {
+  return node instanceof ProseMirrorNode;
+}
+function isMark(mark) {
+  return mark instanceof Mark;
+}
+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;
+}
+
 // 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 +507,74 @@ var stateFacet = defineFacet({
   parent: rootFacet
 });
 
-// src/extensions/default-state.ts
-function defineDefaultState({
-  defaultDoc,
-  defaultHTML,
-  defaultSelection
-}) {
-  if (defaultHTML && defaultDoc) {
-    throw new ProseKitError(
-      "Only one of defaultHTML and defaultDoc can be provided"
-    );
+// 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(options) {
+  const { defaultSelection, defaultContent, defaultDoc, defaultHTML } = options;
+  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 +626,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 {
   /**
@@ -610,12 +657,10 @@ var UnionExtensionImpl = class extends BaseExtension {
 };
 
 // src/editor/union.ts
-function union(extension) {
-  const array = Array.isArray(extension) ? extension : [extension];
-  assert(array.length > 0, "At least one extension is required");
-  return new UnionExtensionImpl(
-    array
-  );
+function union(...exts) {
+  const extensions = exts.flat();
+  assert(extensions.length > 0, "At least one extension is required");
+  return new UnionExtensionImpl(extensions);
 }
 
 // src/editor/editor.ts
@@ -648,6 +693,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) {
@@ -675,28 +721,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);
@@ -704,7 +754,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);
@@ -752,27 +802,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;
@@ -800,6 +847,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;
@@ -831,19 +893,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;
@@ -893,25 +969,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.
@@ -931,68 +1063,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.
    */
@@ -1000,15 +1070,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.
@@ -1045,6 +1111,7 @@ export {
   schemaFacet,
   defineFacetPayload,
   stateFacet,
+  isElement,
   jsonFromState,
   stateFromJSON,
   jsonFromNode,
@@ -1056,14 +1123,15 @@ export {
   elementFromJSON,
   jsonFromHTML,
   htmlFromJSON,
-  defineDefaultState,
-  isMarkAbsent,
-  isMarkActive,
   isProseMirrorNode,
   isMark,
+  isSelection,
   isTextSelection,
   isNodeSelection,
   isAllSelection,
+  defineDefaultState,
+  isMarkAbsent,
+  isMarkActive,
   createNodeActions,
   createMarkActions,
   union,

package/dist/prosekit-core-test.js

@@ -4,11 +4,12 @@ import {
   assert,
   createMarkActions,
   createNodeActions,
+  isProseMirrorNode,
   setupEditorExtension
-} from "./chunk-M267LRMB.js";
+} from "./chunk-MDJ2B4IL.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

@@ -36,9 +36,11 @@ export { EditorNotFoundError_alias_1 as EditorNotFoundError } from './_tsup-dts-
 export { ProseKitError_alias_1 as ProseKitError } from './_tsup-dts-rollup';
 export { defineBaseCommands } from './_tsup-dts-rollup';
 export { defineCommands } from './_tsup-dts-rollup';
+export { BaseCommandsExtension } from './_tsup-dts-rollup';
 export { defineDefaultState } from './_tsup-dts-rollup';
 export { DefaultStateOptions } from './_tsup-dts-rollup';
 export { defineDoc } from './_tsup-dts-rollup';
+export { DocExtension } from './_tsup-dts-rollup';
 export { defineDocChangeHandler } from './_tsup-dts-rollup';
 export { DocChangeHandler } from './_tsup-dts-rollup';
 export { defineDOMEventHandler } from './_tsup-dts-rollup';
@@ -76,12 +78,14 @@ export { MountHandler } from './_tsup-dts-rollup';
 export { UnmountHandler } from './_tsup-dts-rollup';
 export { UpdateHandler } from './_tsup-dts-rollup';
 export { defineHistory } from './_tsup-dts-rollup';
+export { HistoryExtension } from './_tsup-dts-rollup';
 export { HistoryOptions } from './_tsup-dts-rollup';
 export { defineKeymap } from './_tsup-dts-rollup';
 export { keymapFacet } from './_tsup-dts-rollup';
 export { Keymap } from './_tsup-dts-rollup';
 export { KeymapPayload } from './_tsup-dts-rollup';
 export { defineBaseKeymap } from './_tsup-dts-rollup';
+export { BaseKeymapExtension } from './_tsup-dts-rollup';
 export { defineMarkAttr } from './_tsup-dts-rollup';
 export { defineMarkSpec } from './_tsup-dts-rollup';
 export { MarkAttrOptions } from './_tsup-dts-rollup';
@@ -97,10 +101,12 @@ export { defineNodeViewFactory } from './_tsup-dts-rollup';
 export { NodeViewComponentOptions } from './_tsup-dts-rollup';
 export { NodeViewFactoryOptions } from './_tsup-dts-rollup';
 export { defineParagraph } from './_tsup-dts-rollup';
+export { ParagraphExtension } from './_tsup-dts-rollup';
 export { definePlugin } from './_tsup-dts-rollup';
 export { pluginFacet } from './_tsup-dts-rollup';
 export { PluginPayload } from './_tsup-dts-rollup';
 export { defineText } from './_tsup-dts-rollup';
+export { TextExtension } from './_tsup-dts-rollup';
 export { defineFacet } from './_tsup-dts-rollup';
 export { Facet } from './_tsup-dts-rollup';
 export { defineFacetPayload } from './_tsup-dts-rollup';
@@ -116,6 +122,8 @@ export { ExtractMarkActions } from './_tsup-dts-rollup';
 export { ExtractMarks } from './_tsup-dts-rollup';
 export { ExtractNodeActions } from './_tsup-dts-rollup';
 export { ExtractNodes } from './_tsup-dts-rollup';
+export { PlainExtension } from './_tsup-dts-rollup';
+export { Union } from './_tsup-dts-rollup';
 export { UnionExtension } from './_tsup-dts-rollup';
 export { CommandAction } from './_tsup-dts-rollup';
 export { CommandTyping } from './_tsup-dts-rollup';
@@ -166,6 +174,7 @@ export { isAllSelection } 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 { isTextSelection } from './_tsup-dts-rollup';
 export { withSkipCodeBlock } from './_tsup-dts-rollup';
 export { OBJECT_REPLACEMENT_CHARACTER } from './_tsup-dts-rollup';