@prosekit/core 0.0.9 → 0.0.11

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

@@ -8,6 +8,7 @@ import { EditorView } from '@prosekit/pm/view';
 import type { EmptyObject } from 'type-fest';
 import { InputRule } from '@prosekit/pm/inputrules';
 import type { IsEqual } from 'type-fest';
+import { Mark } from '@prosekit/pm/model';
 import type { MarkSpec } from '@prosekit/pm/model';
 import { MarkType } from '@prosekit/pm/model';
 import type { NodeSpec } from '@prosekit/pm/model';
@@ -15,6 +16,7 @@ import { NodeType } from '@prosekit/pm/model';
 import { NodeViewConstructor } from '@prosekit/pm/view';
 import { Options } from 'tsup';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
+import { ProseMirrorFragment } from '@prosekit/pm/model';
 import { ProseMirrorNode } from '@prosekit/pm/model';
 import { Schema } from '@prosekit/pm/model';
 import type { SchemaSpec } from '@prosekit/pm/model';
@@ -84,6 +86,27 @@ NODES: "doc";
 export { addDoc }
 export { addDoc as addDoc_alias_1 }
 
+/**
+ * @internal
+ */
+declare function addEventHandler(options: {
+    update?: VoidFunction;
+}): FacetExtension<VoidFunction, PluginFacetInput>;
+export { addEventHandler }
+export { addEventHandler as addEventHandler_alias_1 }
+
+/**
+ * Add undo/redo history to the editor.
+ */
+declare function addHistory(): Extension<    {
+COMMAND_ARGS: {
+undo: [];
+redo: [];
+};
+}>;
+export { addHistory }
+export { addHistory as addHistory_alias_1 }
+
 /**
  * @public
  */
@@ -176,6 +199,13 @@ export declare function applyAction(operator: Action): Command;
  */
 export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
 
+export declare function collectNodes(content: NodeContent): ProseMirrorNode[];
+
+export declare interface CommandApplier<Args extends any[] = any[]> {
+    (...args: Args): boolean;
+    canApply(...args: Args): boolean;
+}
+
 /** @internal */
 declare interface CommandArgs {
     [name: string]: any[];
@@ -189,8 +219,6 @@ export declare interface CommandCreators {
     [name: string]: CommandCreator;
 }
 
-export declare type CommandDispatcher<Args extends any[] = any[]> = (...arg: Args) => boolean;
-
 export declare const commandSlot: Facet<CommandSlotInput, CommandSlotInput>;
 
 export declare type CommandSlotInput = Record<string, CommandCreator<any>>;
@@ -200,6 +228,10 @@ declare function createEditor<E extends Extension>({ extension, defaultDoc, defa
 export { createEditor }
 export { createEditor as createEditor_alias_1 }
 
+export declare function createMarkBuilder(getState: () => EditorState | null | undefined, type: MarkType): MarkBuilder;
+
+export declare function createNodeBuilder(getState: () => EditorState | null | undefined, type: NodeType): NodeBuilder;
+
 export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
 
 export declare const default_alias_1: UserProjectConfigExport;
@@ -231,12 +263,20 @@ declare class Editor<E extends Extension = any> {
     get mounted(): boolean;
     get view(): EditorView;
     get schema(): Schema<ExtractNodes<E>, ExtractMarks<E>>;
-    get commands(): ExtractCommandDispatchers<E>;
+    get commands(): ExtractCommandAppliers<E>;
     mount(place: HTMLElement | null | undefined | void): void;
     unmount(): void;
     use(extension: Extension): VoidFunction;
+    /**
+     * @deprecated
+     */
     isNodeActive(nodeType: string | NodeType, attrs?: Attrs): boolean;
+    /**
+     * @deprecated
+     */
     isMarkActive(markType: string | MarkType, attrs?: Attrs): boolean;
+    get nodes(): Record<ExtractNodes<E>, NodeBuilder>;
+    get marks(): Record<ExtractMarks<E>, MarkBuilder>;
 }
 export { Editor }
 export { Editor as Editor_alias_1 }
@@ -287,6 +327,13 @@ declare interface ExtensionTyping<Node extends string = string, Mark extends str
 export { ExtensionTyping }
 export { ExtensionTyping as ExtensionTyping_alias_1 }
 
+/**
+ * @public
+ */
+declare type ExtractCommandAppliers<E extends Extension> = ToCommandApplier<ExtractCommandArgs<E>>;
+export { ExtractCommandAppliers }
+export { ExtractCommandAppliers as ExtractCommandAppliers_alias_1 }
+
 /**
  * @internal
  */
@@ -301,13 +348,6 @@ declare type ExtractCommandCreators<E extends Extension> = ToCommandCreators<Ext
 export { ExtractCommandCreators }
 export { ExtractCommandCreators as ExtractCommandCreators_alias_1 }
 
-/**
- * @public
- */
-declare type ExtractCommandDispatchers<E extends Extension> = ToCommandDispatcher<ExtractCommandArgs<E>>;
-export { ExtractCommandDispatchers }
-export { ExtractCommandDispatchers as ExtractCommandDispatchers_alias_1 }
-
 /**
  * @intneral
  */
@@ -396,10 +436,16 @@ export declare function insertNode({ node, pos, }: {
     pos?: number;
 }): Action;
 
+export declare const isMac: boolean;
+
+export declare function isMark(mark: unknown): mark is Mark;
+
 export declare function isMarkActive(state: EditorState, type: string | MarkType, attrs?: Attrs | null): boolean;
 
 export declare function isNodeActive(state: EditorState, type: string | NodeType, attrs?: Attrs | null): boolean;
 
+export declare function isProseMirrorNode(node: unknown): node is ProseMirrorNode;
+
 /** @public */
 declare interface Keymap {
     [key: string]: Command;
@@ -407,6 +453,12 @@ declare interface Keymap {
 export { Keymap }
 export { Keymap as Keymap_alias_1 }
 
+export declare interface MarkBuilder {
+    (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode[];
+    (...children: NodeChild[]): ProseMirrorNode[];
+    isActive(attrs?: Attrs): boolean;
+}
+
 /**
  * @public
  */
@@ -416,6 +468,16 @@ declare interface MarkSpecOptions<MarkName extends string = string> extends Mark
 export { MarkSpecOptions }
 export { MarkSpecOptions as MarkSpecOptions_alias_1 }
 
+export declare interface NodeBuilder {
+    (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode;
+    (...children: NodeChild[]): ProseMirrorNode;
+    isActive(attrs?: Attrs): boolean;
+}
+
+export declare type NodeChild = ProseMirrorNode | string | NodeChild[];
+
+export declare type NodeContent = ProseMirrorNode | ProseMirrorFragment | NodeContent[];
+
 /**
  * A JSON representation of the prosemirror node.
  *
@@ -566,6 +628,10 @@ export { StateJson as StateJson_alias_1 }
 
 export declare const stateSlot: Facet<StateConfigCallback, StateConfigCallback>;
 
+export declare type ToCommandApplier<T extends CommandArgs> = {
+    [K in keyof T]: CommandApplier<T[K]>;
+};
+
 export declare type ToCommandArgs<T extends CommandCreators> = {
     [K in keyof T]: Parameters<T[K]>;
 };
@@ -574,10 +640,6 @@ export declare type ToCommandCreators<T extends CommandArgs> = {
     [K in keyof T]: CommandCreator<T[K]>;
 };
 
-export declare type ToCommandDispatcher<T extends CommandArgs> = {
-    [K in keyof T]: CommandDispatcher<T[K]>;
-};
-
 declare function toggleMark(options: ToggleMarkOptions): Command;
 export { toggleMark }
 export { toggleMark as toggleMark_alias_1 }

package/dist/prosekit-core.d.ts

@@ -18,6 +18,8 @@ export { addCommands } from './_tsup-dts-rollup';
 export { addDefaultState } from './_tsup-dts-rollup';
 export { DefaultStateOptions } from './_tsup-dts-rollup';
 export { addDoc } from './_tsup-dts-rollup';
+export { addEventHandler } from './_tsup-dts-rollup';
+export { addHistory } from './_tsup-dts-rollup';
 export { addInputRule } from './_tsup-dts-rollup';
 export { addBaseKeymap } from './_tsup-dts-rollup';
 export { addKeymap } from './_tsup-dts-rollup';
@@ -35,8 +37,8 @@ export { PluginFacetInput } from './_tsup-dts-rollup';
 export { addText } from './_tsup-dts-rollup';
 export { CommandArgs } from './_tsup-dts-rollup';
 export { Extension } from './_tsup-dts-rollup';
+export { ExtractCommandAppliers } from './_tsup-dts-rollup';
 export { ExtractCommandCreators } from './_tsup-dts-rollup';
-export { ExtractCommandDispatchers } from './_tsup-dts-rollup';
 export { ExtractMarks } from './_tsup-dts-rollup';
 export { ExtractNodes } from './_tsup-dts-rollup';
 export { SimplifyExtension } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -127,27 +127,15 @@ function toggleNode(options) {
 }
 
 // src/editor/editor.ts
-import { Schema as Schema3 } from "@prosekit/pm/model";
+import { Schema as Schema4 } from "@prosekit/pm/model";
 import { EditorState } from "@prosekit/pm/state";
 import { EditorView } from "@prosekit/pm/view";
 
-// src/utils/is-mark-active.ts
-function isMarkActive(state, type, attrs) {
-  const markType = getMarkType(state.schema, type);
-  const mark = attrs ? markType.create(attrs) : markType;
-  const { from, to } = state.selection;
-  return state.doc.rangeHasMark(from, to, mark);
-}
+// src/extensions/default-state.ts
+import { Selection } from "@prosekit/pm/state";
 
-// src/types/priority.ts
-var Priority = /* @__PURE__ */ ((Priority2) => {
-  Priority2[Priority2["lowest"] = 4] = "lowest";
-  Priority2[Priority2["low"] = 3] = "low";
-  Priority2[Priority2["default"] = 2] = "default";
-  Priority2[Priority2["high"] = 1] = "high";
-  Priority2[Priority2["highest"] = 0] = "highest";
-  return Priority2;
-})(Priority || {});
+// src/editor/slots.ts
+import OrderedMap from "orderedmap";
 
 // src/utils/uniq-array.ts
 function uniqPush(prev, next) {
@@ -257,13 +245,12 @@ function sortFacets(unsorted) {
     }
   }
   if (facetCount !== sortedFacets.length) {
-    throw new Error(`Facet has circular dependency`);
+    throw new ProseKitError(`Facet has circular dependency`);
   }
   return sortedFacets;
 }
 
 // src/editor/slots.ts
-import OrderedMap from "orderedmap";
 var schemaSlot = Facet.defineSlot({
   combine: (specs) => {
     var _a;
@@ -296,7 +283,9 @@ var stateSlot = Facet.defineSlot({
         config.plugins = uniqPush((_e = config.plugins) != null ? _e : [], (_f = c.plugins) != null ? _f : []);
       }
       if (!config.doc && !config.schema) {
-        throw new Error("Can't create state without a schema nor a document");
+        throw new ProseKitError(
+          "Can't create state without a schema nor a document"
+        );
       }
       if (config.doc) {
         config.schema = void 0;
@@ -316,6 +305,128 @@ var commandSlot = Facet.defineSlot({
   }
 });
 
+// src/extensions/default-state.ts
+function addDefaultState(options) {
+  return stateSlot.extension([
+    ({ schema }) => {
+      const config = {};
+      if (options.doc) {
+        config.doc = schema.nodeFromJSON(options.doc);
+        if (options.selection) {
+          config.selection = Selection.fromJSON(config.doc, options.selection);
+        }
+      }
+      return config;
+    }
+  ]);
+}
+
+// src/utils/type-assertion.ts
+import { Mark, ProseMirrorNode } from "@prosekit/pm/model";
+function isProseMirrorNode(node) {
+  return node instanceof ProseMirrorNode;
+}
+function isMark(mark) {
+  return mark instanceof Mark;
+}
+
+// src/utils/is-mark-active.ts
+function isMarkActive(state, type, attrs) {
+  var _a;
+  const markType = getMarkType(state.schema, type);
+  const mark = attrs ? markType.create(attrs) : markType;
+  const { from, to, $from, $to } = state.selection;
+  return state.doc.rangeHasMark(from, to, mark) || hasMark(
+    [...$from.marks(), ...$to.marks(), ...(_a = state.storedMarks) != null ? _a : []],
+    mark
+  );
+}
+function hasMark(marks, mark) {
+  if (marks.length === 0) {
+    return false;
+  }
+  if (isMark(mark)) {
+    return marks.some((m) => m.eq(mark));
+  } else {
+    return marks.some((m) => m.type === mark);
+  }
+}
+
+// src/editor/builder.ts
+import "@prosekit/pm/model";
+function createNodeBuilder(getState, type) {
+  const builder = (...args) => buildNode(type, args);
+  builder.isActive = (attrs) => {
+    const state = getState();
+    return state ? isNodeActive(state, type, attrs) : false;
+  };
+  return builder;
+}
+function createMarkBuilder(getState, type) {
+  const builder = (...args) => buildMark(type, args);
+  builder.isActive = (attrs) => {
+    const state = getState();
+    return state ? isMarkActive(state, type, attrs) : false;
+  };
+  return builder;
+}
+function buildMark(type, args) {
+  const [attrs, children] = normalizeArgs(args);
+  return flattenChildren(type.schema, children, type.create(attrs));
+}
+function buildNode(type, args) {
+  const [attrs, children] = normalizeArgs(args);
+  const node = type.createAndFill(attrs, flattenChildren(type.schema, children));
+  if (!node) {
+    throw new ProseKitError(`Couldn't create node ${type.name}`);
+  }
+  return node;
+}
+function flattenChildren(schema, children, mark) {
+  const nodes = [];
+  for (const child of children) {
+    if (typeof child === "string") {
+      if (child) {
+        nodes.push(schema.text(child, mark ? [mark] : null));
+      }
+    } else if (Array.isArray(child)) {
+      nodes.push(...flattenChildren(schema, child, mark));
+    } else if (isProseMirrorNode(child)) {
+      nodes.push(mark ? child.mark(mark.addToSet(child.marks)) : child);
+    } else {
+      throw new ProseKitError(`Invalid node child: ${typeof child}`);
+    }
+  }
+  return nodes;
+}
+function normalizeArgs(args) {
+  const [attrs, ...children] = args;
+  if (isNodeChild(args)) {
+    children.unshift(args);
+    return [null, children];
+  } else if (typeof attrs === "object") {
+    return [attrs, children];
+  } else {
+    return [null, children];
+  }
+}
+function isNodeChild(value) {
+  if (!value) {
+    return false;
+  }
+  return typeof value === "string" || Array.isArray(value) || isProseMirrorNode(value);
+}
+
+// src/types/priority.ts
+var Priority = /* @__PURE__ */ ((Priority2) => {
+  Priority2[Priority2["lowest"] = 4] = "lowest";
+  Priority2[Priority2["low"] = 3] = "low";
+  Priority2[Priority2["default"] = 2] = "default";
+  Priority2[Priority2["high"] = 1] = "high";
+  Priority2[Priority2["highest"] = 0] = "highest";
+  return Priority2;
+})(Priority || {});
+
 // src/editor/flatten.ts
 function flattenInputTuple(inputTuple) {
   return [
@@ -385,7 +496,7 @@ function extractFacets(root) {
         priorities.push(p);
       }
     } else {
-      throw new Error("Invalid extension");
+      throw new ProseKitError("Invalid extension");
     }
   }
   return [facets, inputs];
@@ -477,7 +588,7 @@ function updateExtension(prevInputs, prevSlots, extension, mode) {
             commandInput = output;
             break;
           default:
-            throw new Error("Invalid facet");
+            throw new ProseKitError("Invalid facet");
         }
       }
     }
@@ -485,6 +596,14 @@ function updateExtension(prevInputs, prevSlots, extension, mode) {
   return { schemaInput, stateInput, viewInput, commandInput };
 }
 
+// src/editor/type-utils.ts
+function defineExtension(extension) {
+  if (extension && Array.isArray(extension)) {
+    return { extension };
+  }
+  return extension;
+}
+
 // src/editor/editor.ts
 function createEditor({
   extension,
@@ -505,16 +624,16 @@ function createEditor({
 var EditorInstance = class {
   constructor(extension) {
     this.view = null;
-    this.commandDispatchers = {};
+    this.commandAppliers = {};
     this.inputs = [];
     this.slots = [];
     this.mount = this.mount.bind(this);
     this.unmount = this.unmount.bind(this);
     const { schemaInput, stateInput, viewInput, commandInput } = updateExtension(this.inputs, this.slots, extension, "add");
     if (!schemaInput) {
-      throw new Error("Schema must be defined");
+      throw new ProseKitError("Schema must be defined");
     }
-    const schema = new Schema3(schemaInput);
+    const schema = new Schema4(schemaInput);
     const stateConfig = stateInput ? stateInput({ schema }) : { schema };
     const state = EditorState.create(stateConfig);
     if (commandInput) {
@@ -524,6 +643,22 @@ var EditorInstance = class {
     }
     this.directEditorProps = { state, ...viewInput };
     this.schema = this.directEditorProps.state.schema;
+    const getState = () => {
+      var _a;
+      return (_a = this.view) == null ? void 0 : _a.state;
+    };
+    this.nodeBuilders = Object.fromEntries(
+      Object.values(this.schema.nodes).map((type) => [
+        type.name,
+        createNodeBuilder(getState, type)
+      ])
+    );
+    this.markBuilders = Object.fromEntries(
+      Object.values(this.schema.marks).map((type) => [
+        type.name,
+        createMarkBuilder(getState, type)
+      ])
+    );
   }
   updateExtension(extension, mode) {
     var _a;
@@ -553,23 +688,23 @@ var EditorInstance = class {
   }
   mount(place) {
     if (this.view) {
-      throw new Error("Editor is already mounted");
+      throw new ProseKitError("Editor is already mounted");
     }
     if (!place) {
-      throw new Error("Can't mount editor without a place");
+      throw new ProseKitError("Can't mount editor without a place");
     }
     this.view = new EditorView({ mount: place }, this.directEditorProps);
   }
   unmount() {
     if (!this.view) {
-      throw new Error("Editor is not mounted yet");
+      throw new ProseKitError("Editor is not mounted yet");
     }
     this.view.destroy();
     this.view = null;
   }
   get assertView() {
     if (!this.view)
-      throw new Error("Editor is not mounted");
+      throw new ProseKitError("Editor is not mounted");
     return this.view;
   }
   addPlugins(plugins) {
@@ -589,15 +724,26 @@ var EditorInstance = class {
     view.setProps({ state: newState });
   }
   addCommand(name, commandCreator) {
-    const dispatcher = (...args) => {
-      const view = this.assertView;
+    const applier = (...args) => {
+      const view = this.view;
+      if (!view) {
+        return false;
+      }
       const command = commandCreator(...args);
       return command(view.state, view.dispatch.bind(view), view);
     };
-    this.commandDispatchers[name] = dispatcher;
+    applier.canApply = (...args) => {
+      const view = this.view;
+      if (!view) {
+        return false;
+      }
+      const command = commandCreator(...args);
+      return command(view.state, void 0, view);
+    };
+    this.commandAppliers[name] = applier;
   }
   removeCommand(name) {
-    delete this.commandDispatchers[name];
+    delete this.commandAppliers[name];
   }
 };
 var Editor = class _Editor {
@@ -625,7 +771,7 @@ var Editor = class _Editor {
     return this.instance.schema;
   }
   get commands() {
-    return this.instance.commandDispatchers;
+    return this.instance.commandAppliers;
   }
   mount(place) {
     if (!place) {
@@ -653,21 +799,25 @@ var Editor = class _Editor {
     this.instance.updateExtension(extension, "add");
     return () => this.instance.updateExtension(extension, "remove");
   }
+  /**
+   * @deprecated
+   */
   isNodeActive(nodeType, attrs) {
     return isNodeActive(this.view.state, nodeType, attrs);
   }
+  /**
+   * @deprecated
+   */
   isMarkActive(markType, attrs) {
     return isMarkActive(this.view.state, markType, attrs);
   }
-};
-
-// src/editor/type-utils.ts
-function defineExtension(extension) {
-  if (extension && Array.isArray(extension)) {
-    return { extension };
+  get nodes() {
+    return this.instance.nodeBuilders;
   }
-  return extension;
-}
+  get marks() {
+    return this.instance.markBuilders;
+  }
+};
 
 // src/editor/with-priority.ts
 function withPriority(extension, priority) {
@@ -749,23 +899,6 @@ function addBaseCommands() {
   });
 }
 
-// src/extensions/default-state.ts
-import { Selection } from "@prosekit/pm/state";
-function addDefaultState(options) {
-  return stateSlot.extension([
-    ({ schema }) => {
-      const config = {};
-      if (options.doc) {
-        config.doc = schema.nodeFromJSON(options.doc);
-        if (options.selection) {
-          config.selection = Selection.fromJSON(config.doc, options.selection);
-        }
-      }
-      return config;
-    }
-  ]);
-}
-
 // src/extensions/node-spec.ts
 function addNodeSpec(options) {
   return nodeSpecFacet.extension([options]);
@@ -776,7 +909,7 @@ var nodeSpecFacet = Facet.define({
     let topNodeName = void 0;
     for (const { name, topNode, ...spec } of options) {
       if (nodes[name]) {
-        throw new Error(`Node type ${name} has already been defined`);
+        throw new ProseKitError(`Node type ${name} has already been defined`);
       }
       if (topNodeName && !topNode) {
         topNodeName = name;
@@ -796,10 +929,12 @@ function addDoc() {
   });
 }
 
-// src/extensions/input-rules.ts
-import { inputRules } from "@prosekit/pm/inputrules";
-import "@prosekit/pm/model";
-import "@prosekit/pm/state";
+// src/extensions/event-handler.ts
+import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
+
+// src/types/void-function.ts
+function voidFunction() {
+}
 
 // src/extensions/plugin.ts
 import "@prosekit/pm/model";
@@ -826,24 +961,52 @@ var pluginFacet = Facet.define({
   next: stateSlot
 });
 
-// src/extensions/input-rules.ts
-function addInputRule(rules) {
-  return inputRuleFacet.extension([rules]);
+// src/extensions/event-handler.ts
+function addEventHandler(options) {
+  var _a;
+  const updateHandler = (_a = options == null ? void 0 : options.update) != null ? _a : voidFunction;
+  return eventFacet.extension([updateHandler]);
 }
-var inputRuleFacet = Facet.define({
-  combine: (inputs) => {
-    return (context) => {
-      const rules = inputs.flatMap((callback) => callback(context));
-      return [inputRules({ rules })];
+var eventFacet = Facet.define({
+  slot: () => {
+    let updateHandlers = [];
+    const plugin = new ProseMirrorPlugin({
+      key: pluginKey,
+      view: () => {
+        return {
+          update: (_view, _prevState) => {
+            updateHandlers.forEach((fn) => fn());
+          }
+        };
+      }
+    });
+    const pluginFunc = () => [plugin];
+    return {
+      create: (handlers) => {
+        updateHandlers = handlers;
+        return pluginFunc;
+      },
+      update: (handlers) => {
+        updateHandlers = handlers;
+        return null;
+      }
     };
   },
-  next: pluginFacet
+  next: pluginFacet,
+  single: true
 });
+var pluginKey = new PluginKey("prosekit-event-handler");
+
+// src/extensions/history.ts
+import { history, redo, undo } from "@prosekit/pm/history";
+
+// src/utils/env.ts
+var isMac = typeof navigator !== "undefined" ? /Mac|iP(hone|[ao]d)/.test(navigator.platform) : false;
 
 // src/extensions/keymap.ts
 import { baseKeymap, chainCommands } from "@prosekit/pm/commands";
 import { keydownHandler } from "@prosekit/pm/keymap";
-import { Plugin as Plugin4, PluginKey } from "@prosekit/pm/state";
+import { Plugin as Plugin3, PluginKey as PluginKey2 } from "@prosekit/pm/state";
 function addKeymap(keymap) {
   return keymapFacet.extension([keymap]);
 }
@@ -858,7 +1021,7 @@ var keymapFacet = Facet.define({
         return handler(view, event);
       return false;
     };
-    const plugin = new Plugin4({
+    const plugin = new Plugin3({
       key: keymapPluginKey,
       props: { handleKeyDown: handlerWrapper }
     });
@@ -892,7 +1055,43 @@ function mergeKeymaps(keymaps) {
     ])
   );
 }
-var keymapPluginKey = new PluginKey("prosekit-keymap");
+var keymapPluginKey = new PluginKey2("prosekit-keymap");
+
+// src/extensions/history.ts
+function addHistory() {
+  const keymap = {
+    "Mod-z": undo,
+    "Shift-Mod-z": redo
+  };
+  if (!isMac) {
+    keymap["Mod-y"] = redo;
+  }
+  return defineExtension([
+    addPlugin(history()),
+    addKeymap(keymap),
+    addCommands({
+      undo: () => undo,
+      redo: () => redo
+    })
+  ]);
+}
+
+// src/extensions/input-rules.ts
+import { inputRules } from "@prosekit/pm/inputrules";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+function addInputRule(rules) {
+  return inputRuleFacet.extension([rules]);
+}
+var inputRuleFacet = Facet.define({
+  combine: (inputs) => {
+    return (context) => {
+      const rules = inputs.flatMap((callback) => callback(context));
+      return [inputRules({ rules })];
+    };
+  },
+  next: pluginFacet
+});
 
 // src/extensions/mark-spec.ts
 function addMarkSpec(options) {
@@ -903,7 +1102,7 @@ var markSpecFacet = Facet.define({
     const marks = {};
     for (const { name, ...spec } of options) {
       if (marks[name]) {
-        throw new Error(`Mark type ${name} has already been defined`);
+        throw new ProseKitError(`Mark type ${name} has already been defined`);
       }
       marks[name] = spec;
     }
@@ -962,6 +1161,8 @@ export {
   addCommands,
   addDefaultState,
   addDoc,
+  addEventHandler,
+  addHistory,
   addInputRule,
   addKeymap,
   addMark,

package/dist/style.css

@@ -1,4 +1,4 @@
-/* ../../node_modules/.pnpm/prosemirror-view@1.31.7/node_modules/prosemirror-view/style/prosemirror.css */
+/* ../../node_modules/.pnpm/prosemirror-view@1.31.8/node_modules/prosemirror-view/style/prosemirror.css */
 .ProseMirror {
   position: relative;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -38,7 +38,7 @@
     "dist"
   ],
   "dependencies": {
-    "@prosekit/pm": "^0.0.4",
+    "@prosekit/pm": "^0.0.6",
     "orderedmap": "^2.1.1",
     "type-fest": "^4.3.1"
   },
@@ -46,7 +46,7 @@
     "@prosekit/dev": "*",
     "tsup": "^7.2.0",
     "typescript": "^5.2.2",
-    "vitest": "^0.34.3"
+    "vitest": "^0.34.5"
   },
   "scripts": {
     "build:tsup": "tsup",

package/src/index.ts

@@ -12,6 +12,8 @@ export {
   type DefaultStateOptions,
 } from './extensions/default-state'
 export { addDoc } from './extensions/doc'
+export { addEventHandler } from './extensions/event-handler'
+export { addHistory } from './extensions/history'
 export { addInputRule } from './extensions/input-rules'
 export { addBaseKeymap, addKeymap, type Keymap } from './extensions/keymap'
 export { addMarkSpec, type MarkSpecOptions } from './extensions/mark-spec'
@@ -28,8 +30,8 @@ export { type CommandArgs as CommandArgs } from './types/command'
 export * from './types/editor'
 export {
   type Extension,
+  type ExtractCommandAppliers,
   type ExtractCommandCreators,
-  type ExtractCommandDispatchers,
   type ExtractMarks,
   type ExtractNodes,
   type SimplifyExtension,