@prosekit/core 0.0.10 → 0.0.12

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

@@ -30,12 +30,90 @@ declare type Action = (options: {
     view?: EditorView;
 }) => boolean;
 
+declare function addMark(options: AddMarkOptions): Command;
+export { addMark }
+export { addMark as addMark_alias_1 }
+
+declare interface AddMarkOptions {
+    type: string | MarkType;
+    attrs?: Attrs | null;
+    /**
+     * The start position of the mark. By default it will be the start position of current selection.
+     */
+    from?: number;
+    /**
+     * The end position of the mark. By default it will be the end position of current selection.
+     */
+    to?: number;
+}
+export { AddMarkOptions }
+export { AddMarkOptions as AddMarkOptions_alias_1 }
+
+export declare type AnySlot = Slot<any, any>;
+
+export declare function applyAction(operator: Action): Command;
+
+/**
+ * Utility function assert that two types are equal in tests.
+ */
+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[];
+}
+export { CommandArgs }
+export { CommandArgs as CommandArgs_alias_1 }
+
+export declare type CommandCreator<Args extends any[] = any[]> = (...arg: Args) => Command;
+
+export declare interface CommandCreators {
+    [name: string]: CommandCreator;
+}
+
+export declare const commandSlot: Facet<CommandSlotInput, CommandSlotInput>;
+
+export declare type CommandSlotInput = Record<string, CommandCreator<any>>;
+
+/** @public */
+declare function createEditor<E extends Extension>({ extension, defaultDoc, defaultSelection, }: EditorOptions<E>): Editor<E>;
+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;
+
+declare interface DefaultStateOptions {
+    /**
+     * A JSON representation of a ProseMirror document.
+     */
+    doc?: NodeJson;
+    /**
+     * A JSON representation of a ProseMirror selection.
+     */
+    selection?: SelectionJson;
+}
+export { DefaultStateOptions }
+export { DefaultStateOptions as DefaultStateOptions_alias_1 }
+
 /**
  * Add some base commands
  *
  * @public
  */
-declare function addBaseCommands(): Extension<{
+declare function defineBaseCommands(): Extension<{
     COMMAND_ARGS: {
         insertText: [{
             text: string;
@@ -59,103 +137,96 @@ declare function addBaseCommands(): Extension<{
         selectAll: [];
     };
 }>;
-export { addBaseCommands }
-export { addBaseCommands as addBaseCommands_alias_1 }
+export { defineBaseCommands }
+export { defineBaseCommands as defineBaseCommands_alias_1 }
 
 /** @public */
-declare function addBaseKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
-export { addBaseKeymap }
-export { addBaseKeymap as addBaseKeymap_alias_1 }
+declare function defineBaseKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineBaseKeymap }
+export { defineBaseKeymap as defineBaseKeymap_alias_1 }
 
-declare function addCommands<T extends Record<string, CommandCreator> = Record<string, CommandCreator>>(commands: T): Extension<{
+declare function defineCommands<T extends Record<string, CommandCreator> = Record<string, CommandCreator>>(commands: T): Extension<{
     COMMAND_ARGS: {
         [K in keyof T]: Parameters<T[K]>;
     };
 }>;
-export { addCommands }
-export { addCommands as addCommands_alias_1 }
+export { defineCommands }
+export { defineCommands as defineCommands_alias_1 }
 
-declare function addDefaultState(options: DefaultStateOptions): Extension;
-export { addDefaultState }
-export { addDefaultState as addDefaultState_alias_1 }
+declare function defineDefaultState(options: DefaultStateOptions): Extension;
+export { defineDefaultState }
+export { defineDefaultState as defineDefaultState_alias_1 }
 
 /** @public */
-declare function addDoc(): Extension<    {
+declare function defineDoc(): Extension<    {
 NODES: "doc";
 }>;
-export { addDoc }
-export { addDoc as addDoc_alias_1 }
+export { defineDoc }
+export { defineDoc as defineDoc_alias_1 }
 
 /**
  * @internal
  */
-declare function addEventHandler(options: {
+declare function defineEventHandler(options: {
     update?: VoidFunction;
 }): FacetExtension<VoidFunction, PluginFacetInput>;
-export { addEventHandler }
-export { addEventHandler as addEventHandler_alias_1 }
+export { defineEventHandler }
+export { defineEventHandler as defineEventHandler_alias_1 }
+
+/**
+ * Add undo/redo history to the editor.
+ */
+declare function defineHistory(): Extension<    {
+COMMAND_ARGS: {
+undo: [];
+redo: [];
+};
+}>;
+export { defineHistory }
+export { defineHistory as defineHistory_alias_1 }
 
 /**
  * @public
  */
-declare function addInputRule(rules: (context: {
+declare function defineInputRule(rules: (context: {
     schema: Schema;
 }) => InputRule[]): Extension;
-export { addInputRule }
-export { addInputRule as addInputRule_alias_1 }
+export { defineInputRule }
+export { defineInputRule as defineInputRule_alias_1 }
 
 /** @public */
-declare function addKeymap(keymap: Keymap): Extension;
-export { addKeymap }
-export { addKeymap as addKeymap_alias_1 }
-
-declare function addMark(options: AddMarkOptions): Command;
-export { addMark }
-export { addMark as addMark_alias_1 }
-
-declare interface AddMarkOptions {
-    type: string | MarkType;
-    attrs?: Attrs | null;
-    /**
-     * The start position of the mark. By default it will be the start position of current selection.
-     */
-    from?: number;
-    /**
-     * The end position of the mark. By default it will be the end position of current selection.
-     */
-    to?: number;
-}
-export { AddMarkOptions }
-export { AddMarkOptions as AddMarkOptions_alias_1 }
+declare function defineKeymap(keymap: Keymap): Extension;
+export { defineKeymap }
+export { defineKeymap as defineKeymap_alias_1 }
 
 /**
  * @public
  */
-declare function addMarkSpec<Mark extends string>(options: MarkSpecOptions<Mark>): Extension<{
+declare function defineMarkSpec<Mark extends string>(options: MarkSpecOptions<Mark>): Extension<{
     MARKS: Mark;
 }>;
-export { addMarkSpec }
-export { addMarkSpec as addMarkSpec_alias_1 }
+export { defineMarkSpec }
+export { defineMarkSpec as defineMarkSpec_alias_1 }
 
 /**
  * @public
  */
-declare function addNodeSpec<NodeName extends string>(options: NodeSpecOptions<NodeName>): Extension<{
+declare function defineNodeSpec<NodeName extends string>(options: NodeSpecOptions<NodeName>): Extension<{
     NODES: NodeName;
 }>;
-export { addNodeSpec }
-export { addNodeSpec as addNodeSpec_alias_1 }
+export { defineNodeSpec }
+export { defineNodeSpec as defineNodeSpec_alias_1 }
 
-declare function addNodeView(options: NodeViewOptions): Extension;
-export { addNodeView }
-export { addNodeView as addNodeView_alias_1 }
+declare function defineNodeView(options: NodeViewOptions): Extension;
+export { defineNodeView }
+export { defineNodeView as defineNodeView_alias_1 }
 
 /** @public */
-declare function addParagraph(): Extension<    {
+declare function defineParagraph(): Extension<    {
 NODES: "paragraph";
 }>;
-export { addParagraph }
-export { addParagraph as addParagraph_alias_1 }
+export { defineParagraph }
+export { defineParagraph as defineParagraph_alias_1 }
 
 /**
  * Adds a ProseMirror plugin to the editor.
@@ -165,78 +236,18 @@ export { addParagraph as addParagraph_alias_1 }
  *
  * @public
  */
-declare function addPlugin(plugin: Plugin_2 | Plugin_2[] | ((context: {
+declare function definePlugin(plugin: Plugin_2 | Plugin_2[] | ((context: {
     schema: Schema;
 }) => Plugin_2[])): Extension;
-export { addPlugin }
-export { addPlugin as addPlugin_alias_1 }
+export { definePlugin }
+export { definePlugin as definePlugin_alias_1 }
 
 /** @public */
-declare function addText(): Extension<    {
+declare function defineText(): Extension<    {
 NODES: "text";
 }>;
-export { addText }
-export { addText as addText_alias_1 }
-
-export declare type AnySlot = Slot<any, any>;
-
-export declare function applyAction(operator: Action): Command;
-
-/**
- * Utility function assert that two types are equal in tests.
- */
-export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
-
-export declare function collectNodes(content: NodeContent): ProseMirrorNode[];
-
-/** @internal */
-declare interface CommandArgs {
-    [name: string]: any[];
-}
-export { CommandArgs }
-export { CommandArgs as CommandArgs_alias_1 }
-
-export declare type CommandCreator<Args extends any[] = any[]> = (...arg: Args) => Command;
-
-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>>;
-
-/** @public */
-declare function createEditor<E extends Extension>({ extension, defaultDoc, defaultSelection, }: EditorOptions<E>): Editor<E>;
-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;
-
-declare interface DefaultStateOptions {
-    /**
-     * A JSON representation of a ProseMirror document.
-     */
-    doc?: NodeJson;
-    /**
-     * A JSON representation of a ProseMirror selection.
-     */
-    selection?: SelectionJson;
-}
-export { DefaultStateOptions }
-export { DefaultStateOptions as DefaultStateOptions_alias_1 }
-
-declare function defineExtension<E extends Extension | Extension[]>(extension: E): SimplifyExtension<E>;
-export { defineExtension }
-export { defineExtension as defineExtension_alias_1 }
+export { defineText }
+export { defineText as defineText_alias_1 }
 
 /** @public */
 declare class Editor<E extends Extension = any> {
@@ -248,7 +259,7 @@ 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;
@@ -286,7 +297,7 @@ declare interface EditorOptions<E extends Extension> {
 export { EditorOptions }
 export { EditorOptions as EditorOptions_alias_1 }
 
-declare type EmptyValue = never | undefined | null | EmptyObject;
+declare type EmptyValue = undefined | null | EmptyObject;
 
 export declare type ExceptEmptyValue<T> = ConditionalExcept<T, EmptyValue>;
 
@@ -312,6 +323,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
  */
@@ -326,13 +344,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
  */
@@ -421,6 +432,8 @@ 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;
@@ -611,6 +624,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]>;
 };
@@ -619,10 +636,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 }
@@ -645,6 +658,10 @@ declare interface ToggleNodeOptions {
 export { ToggleNodeOptions }
 export { ToggleNodeOptions as ToggleNodeOptions_alias_1 }
 
+declare function union<E extends Extension | Extension[]>(extension: E): SimplifyExtension<E>;
+export { union }
+export { union as union_alias_1 }
+
 export declare function uniqPush<T>(prev: readonly T[], next: readonly T[]): T[];
 
 export declare function uniqRemove<T>(prev: T[], next: T[]): T[];

package/dist/prosekit-core.d.ts

@@ -10,34 +10,35 @@ export { EditorOptions } from './_tsup-dts-rollup';
 export { Facet } from './_tsup-dts-rollup';
 export { FacetExtension } from './_tsup-dts-rollup';
 export { FacetOptions } from './_tsup-dts-rollup';
-export { defineExtension } from './_tsup-dts-rollup';
+export { union } from './_tsup-dts-rollup';
 export { withPriority } from './_tsup-dts-rollup';
 export { ProseKitError_alias_1 as ProseKitError } from './_tsup-dts-rollup';
-export { addBaseCommands } from './_tsup-dts-rollup';
-export { addCommands } from './_tsup-dts-rollup';
-export { addDefaultState } from './_tsup-dts-rollup';
+export { defineBaseCommands } from './_tsup-dts-rollup';
+export { defineCommands } from './_tsup-dts-rollup';
+export { defineDefaultState } from './_tsup-dts-rollup';
 export { DefaultStateOptions } from './_tsup-dts-rollup';
-export { addDoc } from './_tsup-dts-rollup';
-export { addEventHandler } from './_tsup-dts-rollup';
-export { addInputRule } from './_tsup-dts-rollup';
-export { addBaseKeymap } from './_tsup-dts-rollup';
-export { addKeymap } from './_tsup-dts-rollup';
+export { defineDoc } from './_tsup-dts-rollup';
+export { defineEventHandler } from './_tsup-dts-rollup';
+export { defineHistory } from './_tsup-dts-rollup';
+export { defineInputRule } from './_tsup-dts-rollup';
+export { defineBaseKeymap } from './_tsup-dts-rollup';
+export { defineKeymap } from './_tsup-dts-rollup';
 export { Keymap } from './_tsup-dts-rollup';
-export { addMarkSpec } from './_tsup-dts-rollup';
+export { defineMarkSpec } from './_tsup-dts-rollup';
 export { MarkSpecOptions } from './_tsup-dts-rollup';
-export { addNodeSpec } from './_tsup-dts-rollup';
+export { defineNodeSpec } from './_tsup-dts-rollup';
 export { NodeSpecOptions } from './_tsup-dts-rollup';
-export { addNodeView } from './_tsup-dts-rollup';
+export { defineNodeView } from './_tsup-dts-rollup';
 export { NodeViewOptions } from './_tsup-dts-rollup';
-export { addParagraph } from './_tsup-dts-rollup';
-export { addPlugin } from './_tsup-dts-rollup';
+export { defineParagraph } from './_tsup-dts-rollup';
+export { definePlugin } from './_tsup-dts-rollup';
 export { pluginFacet } from './_tsup-dts-rollup';
 export { PluginFacetInput } from './_tsup-dts-rollup';
-export { addText } from './_tsup-dts-rollup';
+export { defineText } 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

@@ -306,7 +306,7 @@ var commandSlot = Facet.defineSlot({
 });
 
 // src/extensions/default-state.ts
-function addDefaultState(options) {
+function defineDefaultState(options) {
   return stateSlot.extension([
     ({ schema }) => {
       const config = {};
@@ -597,7 +597,7 @@ function updateExtension(prevInputs, prevSlots, extension, mode) {
 }
 
 // src/editor/type-utils.ts
-function defineExtension(extension) {
+function union(extension) {
   if (extension && Array.isArray(extension)) {
     return { extension };
   }
@@ -611,9 +611,9 @@ function createEditor({
   defaultSelection
 }) {
   if (defaultDoc) {
-    extension = defineExtension([
+    extension = union([
       extension,
-      addDefaultState({
+      defineDefaultState({
         doc: defaultDoc,
         selection: defaultSelection
       })
@@ -624,7 +624,7 @@ function createEditor({
 var EditorInstance = class {
   constructor(extension) {
     this.view = null;
-    this.commandDispatchers = {};
+    this.commandAppliers = {};
     this.inputs = [];
     this.slots = [];
     this.mount = this.mount.bind(this);
@@ -638,7 +638,7 @@ var EditorInstance = class {
     const state = EditorState.create(stateConfig);
     if (commandInput) {
       for (const [name, commandCreator] of Object.entries(commandInput)) {
-        this.addCommand(name, commandCreator);
+        this.defineCommand(name, commandCreator);
       }
     }
     this.directEditorProps = { state, ...viewInput };
@@ -682,7 +682,7 @@ var EditorInstance = class {
     if (commandInput) {
       const names = Object.keys(commandInput);
       for (const name of names) {
-        this.addCommand(name, commandInput[name]);
+        this.defineCommand(name, commandInput[name]);
       }
     }
   }
@@ -707,7 +707,7 @@ var EditorInstance = class {
       throw new ProseKitError("Editor is not mounted");
     return this.view;
   }
-  addPlugins(plugins) {
+  definePlugins(plugins) {
     const view = this.assertView;
     const state = view.state;
     const newPlugins = [...plugins, ...state.plugins];
@@ -723,16 +723,27 @@ var EditorInstance = class {
     const newState = state.reconfigure({ plugins: newPlugins });
     view.setProps({ state: newState });
   }
-  addCommand(name, commandCreator) {
-    const dispatcher = (...args) => {
-      const view = this.assertView;
+  defineCommand(name, commandCreator) {
+    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 {
@@ -760,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) {
@@ -817,11 +828,11 @@ function withPriority(extension, priority) {
 import "@prosekit/pm/model";
 import { AllSelection } from "@prosekit/pm/state";
 import { findWrapping, insertPoint } from "@prosekit/pm/transform";
-function addCommands(commands) {
+function defineCommands(commands) {
   return commandSlot.extension([commands]);
 }
-function addBaseCommands() {
-  return addCommands({
+function defineBaseCommands() {
+  return defineCommands({
     insertText: ({
       text,
       from,
@@ -889,7 +900,7 @@ function addBaseCommands() {
 }
 
 // src/extensions/node-spec.ts
-function addNodeSpec(options) {
+function defineNodeSpec(options) {
   return nodeSpecFacet.extension([options]);
 }
 var nodeSpecFacet = Facet.define({
@@ -911,8 +922,8 @@ var nodeSpecFacet = Facet.define({
 });
 
 // src/extensions/doc.ts
-function addDoc() {
-  return addNodeSpec({
+function defineDoc() {
+  return defineNodeSpec({
     name: "doc",
     content: "block+"
   });
@@ -928,7 +939,7 @@ function voidFunction() {
 // src/extensions/plugin.ts
 import "@prosekit/pm/model";
 import { Plugin as Plugin2 } from "@prosekit/pm/state";
-function addPlugin(plugin) {
+function definePlugin(plugin) {
   if (plugin instanceof Plugin2) {
     return pluginFacet.extension([() => [plugin]]);
   }
@@ -951,7 +962,7 @@ var pluginFacet = Facet.define({
 });
 
 // src/extensions/event-handler.ts
-function addEventHandler(options) {
+function defineEventHandler(options) {
   var _a;
   const updateHandler = (_a = options == null ? void 0 : options.update) != null ? _a : voidFunction;
   return eventFacet.extension([updateHandler]);
@@ -962,6 +973,7 @@ var eventFacet = Facet.define({
     const plugin = new ProseMirrorPlugin({
       key: pluginKey,
       view: () => {
+        updateHandlers.forEach((fn) => fn());
         return {
           update: (_view, _prevState) => {
             updateHandlers.forEach((fn) => fn());
@@ -986,32 +998,21 @@ var eventFacet = Facet.define({
 });
 var pluginKey = new PluginKey("prosekit-event-handler");
 
-// 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/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 as PluginKey2 } from "@prosekit/pm/state";
-function addKeymap(keymap) {
+import { Plugin as Plugin3, PluginKey as PluginKey2 } from "@prosekit/pm/state";
+function defineKeymap(keymap) {
   return keymapFacet.extension([keymap]);
 }
-function addBaseKeymap() {
-  return addKeymap(baseKeymap);
+function defineBaseKeymap() {
+  return defineKeymap(baseKeymap);
 }
 var keymapFacet = Facet.define({
   slot: () => {
@@ -1021,7 +1022,7 @@ var keymapFacet = Facet.define({
         return handler(view, event);
       return false;
     };
-    const plugin = new Plugin4({
+    const plugin = new Plugin3({
       key: keymapPluginKey,
       props: { handleKeyDown: handlerWrapper }
     });
@@ -1057,8 +1058,44 @@ function mergeKeymaps(keymaps) {
 }
 var keymapPluginKey = new PluginKey2("prosekit-keymap");
 
+// src/extensions/history.ts
+function defineHistory() {
+  const keymap = {
+    "Mod-z": undo,
+    "Shift-Mod-z": redo
+  };
+  if (!isMac) {
+    keymap["Mod-y"] = redo;
+  }
+  return union([
+    definePlugin(history()),
+    defineKeymap(keymap),
+    defineCommands({
+      undo: () => undo,
+      redo: () => redo
+    })
+  ]);
+}
+
+// src/extensions/input-rules.ts
+import { inputRules } from "@prosekit/pm/inputrules";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+function defineInputRule(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) {
+function defineMarkSpec(options) {
   return markSpecFacet.extension([options]);
 }
 var markSpecFacet = Facet.define({
@@ -1078,7 +1115,7 @@ var markSpecFacet = Facet.define({
 // src/extensions/node-view.ts
 import { Plugin as Plugin5 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
-function addNodeView(options) {
+function defineNodeView(options) {
   return nodeViewFacet.extension([options]);
 }
 var nodeViewFacet = Facet.define({
@@ -1095,8 +1132,8 @@ var nodeViewFacet = Facet.define({
 });
 
 // src/extensions/paragraph.ts
-function addParagraph() {
-  return addNodeSpec({
+function defineParagraph() {
+  return defineNodeSpec({
     name: "paragraph",
     content: "inline*",
     group: "block",
@@ -1108,8 +1145,8 @@ function addParagraph() {
 }
 
 // src/extensions/text.ts
-function addText() {
-  return addNodeSpec({
+function defineText() {
+  return defineNodeSpec({
     name: "text",
     group: "inline"
   });
@@ -1120,27 +1157,28 @@ export {
   FacetExtension,
   Priority,
   ProseKitError,
-  addBaseCommands,
-  addBaseKeymap,
-  addCommands,
-  addDefaultState,
-  addDoc,
-  addEventHandler,
-  addInputRule,
-  addKeymap,
   addMark,
-  addMarkSpec,
-  addNodeSpec,
-  addNodeView,
-  addParagraph,
-  addPlugin,
-  addText,
   createEditor,
-  defineExtension,
+  defineBaseCommands,
+  defineBaseKeymap,
+  defineCommands,
+  defineDefaultState,
+  defineDoc,
+  defineEventHandler,
+  defineHistory,
+  defineInputRule,
+  defineKeymap,
+  defineMarkSpec,
+  defineNodeSpec,
+  defineNodeView,
+  defineParagraph,
+  definePlugin,
+  defineText,
   getMarkType,
   getNodeType,
   pluginFacet,
   toggleMark,
   toggleNode,
+  union,
   withPriority
 };

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.32.1/node_modules/prosemirror-view/style/prosemirror.css */
 .ProseMirror {
   position: relative;
 }
@@ -25,6 +25,9 @@
 .ProseMirror-hideselection {
   caret-color: transparent;
 }
+.ProseMirror [draggable][contenteditable=false] {
+  user-select: text;
+}
 .ProseMirror-selectednode {
   outline: 2px solid #8cf;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -38,15 +38,15 @@
     "dist"
   ],
   "dependencies": {
-    "@prosekit/pm": "^0.0.5",
+    "@prosekit/pm": "^0.0.6",
     "orderedmap": "^2.1.1",
-    "type-fest": "^4.3.1"
+    "type-fest": "^4.4.0"
   },
   "devDependencies": {
     "@prosekit/dev": "*",
     "tsup": "^7.2.0",
     "typescript": "^5.2.2",
-    "vitest": "^0.34.3"
+    "vitest": "^0.34.6"
   },
   "scripts": {
     "build:tsup": "tsup",

package/src/index.ts

@@ -3,34 +3,39 @@ export { toggleMark, type ToggleMarkOptions } from './commands/toggle-mark'
 export { toggleNode, type ToggleNodeOptions } from './commands/toggle-node'
 export { Editor, createEditor, type EditorOptions } from './editor/editor'
 export { Facet, FacetExtension, type FacetOptions } from './editor/facet'
-export { defineExtension } from './editor/type-utils'
+export { union } from './editor/type-utils'
 export { withPriority } from './editor/with-priority'
 export { ProseKitError } from './error'
-export { addBaseCommands, addCommands } from './extensions/command'
+export { defineBaseCommands, defineCommands } from './extensions/command'
 export {
-  addDefaultState,
+  defineDefaultState,
   type DefaultStateOptions,
 } from './extensions/default-state'
-export { addDoc } from './extensions/doc'
-export { addEventHandler } from './extensions/event-handler'
-export { addInputRule } from './extensions/input-rules'
-export { addBaseKeymap, addKeymap, type Keymap } from './extensions/keymap'
-export { addMarkSpec, type MarkSpecOptions } from './extensions/mark-spec'
-export { addNodeSpec, type NodeSpecOptions } from './extensions/node-spec'
-export { addNodeView, type NodeViewOptions } from './extensions/node-view'
-export { addParagraph } from './extensions/paragraph'
+export { defineDoc } from './extensions/doc'
+export { defineEventHandler } from './extensions/event-handler'
+export { defineHistory } from './extensions/history'
+export { defineInputRule } from './extensions/input-rules'
 export {
-  addPlugin,
+  defineBaseKeymap,
+  defineKeymap,
+  type Keymap,
+} from './extensions/keymap'
+export { defineMarkSpec, type MarkSpecOptions } from './extensions/mark-spec'
+export { defineNodeSpec, type NodeSpecOptions } from './extensions/node-spec'
+export { defineNodeView, type NodeViewOptions } from './extensions/node-view'
+export { defineParagraph } from './extensions/paragraph'
+export {
+  definePlugin,
   pluginFacet,
   type PluginFacetInput,
 } from './extensions/plugin'
-export { addText } from './extensions/text'
+export { defineText } from './extensions/text'
 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,