@prosekit/core 0.3.0 → 0.3.1

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

@@ -5,6 +5,7 @@ import { Command } from '@prosekit/pm/state';
 import type { ConditionalExcept } from 'type-fest';
 import type { ContentMatch } from '@prosekit/pm/model';
 import type { DirectEditorProps } from '@prosekit/pm/view';
+import type { DOMEventMap } from '@prosekit/pm/view';
 import { EditorState } from '@prosekit/pm/state';
 import type { EditorStateConfig } from '@prosekit/pm/state';
 import { EditorView } from '@prosekit/pm/view';
@@ -15,6 +16,7 @@ import type { MarkSpec } from '@prosekit/pm/model';
 import { MarkType } from '@prosekit/pm/model';
 import { MarkType as MarkType_2 } from 'prosemirror-model';
 import { Node as Node_2 } from 'prosemirror-model';
+import type { Node as Node_3 } from '@prosekit/pm/model';
 import { NodeSelection } from '@prosekit/pm/state';
 import type { NodeSpec } from '@prosekit/pm/model';
 import { NodeType } from '@prosekit/pm/model';
@@ -30,6 +32,7 @@ import type { SchemaSpec } from '@prosekit/pm/model';
 import { Selection as Selection_2 } from '@prosekit/pm/state';
 import { Selection as Selection_3 } from 'prosemirror-state';
 import type { Simplify } from 'type-fest';
+import type { Slice } from '@prosekit/pm/model';
 import { TextSelection } from '@prosekit/pm/state';
 import { Transaction } from '@prosekit/pm/state';
 import type { UnionToIntersection } from 'type-fest';
@@ -122,6 +125,14 @@ declare interface BaseNodeViewOptions {
 export { BaseNodeViewOptions }
 export { BaseNodeViewOptions as BaseNodeViewOptions_alias_1 }
 
+declare type ClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;
+export { ClickHandler }
+export { ClickHandler as ClickHandler_alias_1 }
+
+declare type ClickOnHandler = (view: EditorView, pos: number, node: Node_3, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
+export { ClickOnHandler }
+export { ClickOnHandler as ClickOnHandler_alias_1 }
+
 /**
  * A utility for constructing `className` strings conditionally.
  *
@@ -135,6 +146,8 @@ export { clsx as clsx_alias_1 }
 
 export declare function collectNodes(content: NodeContent): ProseMirrorNode[];
 
+export declare function combineEventHandlers<Handler extends (...args: any[]) => boolean | void, Args extends Parameters<Handler> = Parameters<Handler>>(): readonly [(handlers: Handler[]) => void, (...args: Args) => boolean];
+
 export declare interface CommandApplier<Args extends any[] = any[]> {
     (...args: Args): boolean;
     canApply(...args: Args): boolean;
@@ -281,6 +294,24 @@ declare function defineBaseKeymap(options?: {
 export { defineBaseKeymap }
 export { defineBaseKeymap as defineBaseKeymap_alias_1 }
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleClick}
+ */
+declare function defineClickHandler(handler: ClickHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineClickHandler }
+export { defineClickHandler as defineClickHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleClickOn}
+ */
+declare function defineClickOnHandler(handler: ClickOnHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineClickOnHandler }
+export { defineClickOnHandler as defineClickOnHandler_alias_1 }
+
 declare function defineCommands<T extends Record<string, CommandCreator> = Record<string, CommandCreator>>(commands: T): Extension<{
     COMMAND_ARGS: {
         [K in keyof T]: Parameters<T[K]>;
@@ -311,6 +342,42 @@ declare function defineDocChangeHandler(handler: DocChangeHandler): Extension<Ex
 export { defineDocChangeHandler }
 export { defineDocChangeHandler as defineDocChangeHandler_alias_1 }
 
+/**
+ * Register a new event handler for the given event type.
+ *
+ * @public
+ */
+declare function defineDOMEventHandler<Event extends keyof DOMEventMap = string>(event: Event, handler: DOMEventHandler<Event>): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDOMEventHandler }
+export { defineDOMEventHandler as defineDOMEventHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDoubleClick}
+ */
+declare function defineDoubleClickHandler(handler: DoubleClickHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDoubleClickHandler }
+export { defineDoubleClickHandler as defineDoubleClickHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDoubleClickOn}
+ */
+declare function defineDoubleClickOnHandler(handler: DoubleClickOnHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDoubleClickOnHandler }
+export { defineDoubleClickOnHandler as defineDoubleClickOnHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleDrop}
+ */
+declare function defineDropHandler(handler: DropHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDropHandler }
+export { defineDropHandler as defineDropHandler_alias_1 }
+
 /**
  * Registers a event handler that is called when the editor gains or loses focus.
  *
@@ -332,6 +399,15 @@ redo: [];
 export { defineHistory }
 export { defineHistory as defineHistory_alias_1 }
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyDown}
+ */
+declare function defineKeyDownHandler(handler: KeyDownHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineKeyDownHandler }
+export { defineKeyDownHandler as defineKeyDownHandler_alias_1 }
+
 /**
  * @public
  */
@@ -339,6 +415,15 @@ declare function defineKeymap(keymap: Keymap): Extension;
 export { defineKeymap }
 export { defineKeymap as defineKeymap_alias_1 }
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyPress}
+ */
+declare function defineKeyPressHandler(handler: KeyPressHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineKeyPressHandler }
+export { defineKeyPressHandler as defineKeyPressHandler_alias_1 }
+
 /**
  * @public
  */
@@ -415,6 +500,15 @@ export declare function defineParagraphSpec(): Extension<    {
 NODES: "paragraph";
 }>;
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handlePaste}
+ */
+declare function definePasteHandler(handler: PasteHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { definePasteHandler }
+export { definePasteHandler as definePasteHandler_alias_1 }
+
 /**
  * Adds a ProseMirror plugin to the editor.
  *
@@ -429,6 +523,15 @@ declare function definePlugin(plugin: Plugin_2 | Plugin_2[] | ((context: {
 export { definePlugin }
 export { definePlugin as definePlugin_alias_1 }
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleScrollToSelection}
+ */
+declare function defineScrollToSelectionHandler(handler: ScrollToSelectionHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineScrollToSelectionHandler }
+export { defineScrollToSelectionHandler as defineScrollToSelectionHandler_alias_1 }
+
 /**
  * @public
  */
@@ -438,6 +541,33 @@ NODES: "text";
 export { defineText }
 export { defineText as defineText_alias_1 }
 
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTextInput}
+ */
+declare function defineTextInputHandler(handler: TextInputHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineTextInputHandler }
+export { defineTextInputHandler as defineTextInputHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTripleClick}
+ */
+declare function defineTripleClickHandler(handler: TripleClickHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineTripleClickHandler }
+export { defineTripleClickHandler as defineTripleClickHandler_alias_1 }
+
+/**
+ * @public
+ *
+ * See {@link https://prosemirror.net/docs/ref/#view.EditorProps.handleTripleClickOn}
+ */
+declare function defineTripleClickOnHandler(handler: TripleClickOnHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineTripleClickOnHandler }
+export { defineTripleClickOnHandler as defineTripleClickOnHandler_alias_1 }
+
 /**
  * Registers a event handler that is called when the editor view is unmounted.
  *
@@ -468,6 +598,40 @@ declare type DocChangeHandler = (view: EditorView, prevState: EditorState) => vo
 export { DocChangeHandler }
 export { DocChangeHandler as DocChangeHandler_alias_1 }
 
+/**
+ * @internal
+ */
+export declare const domEventFacet: Facet<DOMEventPayload, PluginPayload>;
+
+/**
+ * A function to handle the events fired on the editable DOM element. Returns
+ * `true` to indicate that it handled the given event. you are responsible for
+ * calling `preventDefault` yourself (or not, if you want to allow the default
+ * behavior).
+ *
+ * @public
+ */
+declare type DOMEventHandler<Event extends keyof DOMEventMap = string> = (view: EditorView, event: DOMEventMap[Event]) => boolean | void;
+export { DOMEventHandler }
+export { DOMEventHandler as DOMEventHandler_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type DOMEventPayload = [event: string, handler: DOMEventHandler];
+
+declare type DoubleClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;
+export { DoubleClickHandler }
+export { DoubleClickHandler as DoubleClickHandler_alias_1 }
+
+declare type DoubleClickOnHandler = (view: EditorView, pos: number, node: Node_3, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
+export { DoubleClickOnHandler }
+export { DoubleClickOnHandler as DoubleClickOnHandler_alias_1 }
+
+declare type DropHandler = (view: EditorView, event: DragEvent, slice: Slice, moved: boolean) => boolean | void;
+export { DropHandler }
+export { DropHandler as DropHandler_alias_1 }
+
 /**
  * @public
  */
@@ -768,6 +932,12 @@ declare function getNodeType(schema: Schema, type: string | NodeType): NodeType;
 export { getNodeType }
 export { getNodeType as getNodeType_alias_1 }
 
+export declare type GroupedEntries<T extends Record<string, any>> = {
+    [K in keyof T]?: T[K][];
+};
+
+export declare function groupEntries<T extends Record<string, any>>(entries: ObjectEntries<T>[]): GroupedEntries<T>;
+
 /**
  * Returns a command that inserts the given node at the current selection or at
  * the given position.
@@ -897,6 +1067,10 @@ declare function jsonFromState(state: EditorState): StateJSON;
 export { jsonFromState }
 export { jsonFromState as jsonFromState_alias_1 }
 
+declare type KeyDownHandler = (view: EditorView, event: KeyboardEvent) => boolean | void;
+export { KeyDownHandler }
+export { KeyDownHandler as KeyDownHandler_alias_1 }
+
 /**
  * @public
  */
@@ -920,6 +1094,10 @@ declare type KeymapPayload = Keymap;
 export { KeymapPayload }
 export { KeymapPayload as KeymapPayload_alias_1 }
 
+declare type KeyPressHandler = (view: EditorView, event: KeyboardEvent) => boolean | void;
+export { KeyPressHandler }
+export { KeyPressHandler as KeyPressHandler_alias_1 }
+
 /**
  * @public
  */
@@ -1097,8 +1275,27 @@ declare const OBJECT_REPLACEMENT_CHARACTER = "\uFFFC";
 export { OBJECT_REPLACEMENT_CHARACTER }
 export { OBJECT_REPLACEMENT_CHARACTER as OBJECT_REPLACEMENT_CHARACTER_alias_1 }
 
+/**
+ * @internal
+ *
+ * @example
+ *
+ * ```
+ * type MyObject = { a: 1; b: 'B' }
+ * type MyEntries = ObjectEntries<MyObject>
+ * //   ^ ["a", 1] | ["b", "B"]
+ *
+ */
+export declare type ObjectEntries<T extends Record<string, any>> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T];
+
 export declare function objectEqual<T>(a: T, b: T): boolean;
 
+declare type PasteHandler = (view: EditorView, event: ClipboardEvent, slice: Slice) => boolean | void;
+export { PasteHandler }
+export { PasteHandler as PasteHandler_alias_1 }
+
 declare type Payload = unknown;
 
 export declare type Payloads = PayloadTuple[];
@@ -1176,6 +1373,10 @@ export declare const schemaFacet: Facet<SchemaPayload, SchemaPayload>;
 
 export declare type SchemaPayload = SchemaSpec;
 
+declare type ScrollToSelectionHandler = (view: EditorView) => boolean;
+export { ScrollToSelectionHandler }
+export { ScrollToSelectionHandler as ScrollToSelectionHandler_alias_1 }
+
 /**
  * Returns a command that selects the whole document.
  *
@@ -1238,6 +1439,11 @@ export { setNodeAttrs as setNodeAttrs_alias_1 }
 
 export declare function setSelectionAround(tr: Transaction, pos: number): void;
 
+/**
+ * @internal
+ */
+export declare type Setter<T> = (value: T) => void;
+
 /**
  * @internal
  */
@@ -1289,6 +1495,10 @@ export declare type StatePayload = (ctx: {
     schema: Schema;
 }) => EditorStateConfig;
 
+declare type TextInputHandler = (view: EditorView, from: number, to: number, text: string) => boolean | void;
+export { TextInputHandler }
+export { TextInputHandler as TextInputHandler_alias_1 }
+
 export declare type ToCommandApplier<T extends CommandArgs> = {
     [K in keyof T]: CommandApplier<T[K]>;
 };
@@ -1326,6 +1536,14 @@ declare function toggleNode({ type, attrs, }: {
 export { toggleNode }
 export { toggleNode as toggleNode_alias_1 }
 
+declare type TripleClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;
+export { TripleClickHandler }
+export { TripleClickHandler as TripleClickHandler_alias_1 }
+
+declare type TripleClickOnHandler = (view: EditorView, pos: number, node: Node_3, nodePos: number, event: MouseEvent, direct: boolean) => boolean | void;
+export { TripleClickOnHandler }
+export { TripleClickOnHandler as TripleClickOnHandler_alias_1 }
+
 declare type Tuple5<T> = [T, T, T, T, T];
 
 /**

package/dist/prosekit-core.d.ts

@@ -20,6 +20,32 @@ export { DefaultStateOptions } from './_tsup-dts-rollup';
 export { defineDoc } from './_tsup-dts-rollup';
 export { defineDocChangeHandler } from './_tsup-dts-rollup';
 export { DocChangeHandler } from './_tsup-dts-rollup';
+export { defineDOMEventHandler } from './_tsup-dts-rollup';
+export { DOMEventHandler } from './_tsup-dts-rollup';
+export { defineClickHandler } from './_tsup-dts-rollup';
+export { defineClickOnHandler } from './_tsup-dts-rollup';
+export { defineDoubleClickHandler } from './_tsup-dts-rollup';
+export { defineDoubleClickOnHandler } from './_tsup-dts-rollup';
+export { defineDropHandler } from './_tsup-dts-rollup';
+export { defineKeyDownHandler } from './_tsup-dts-rollup';
+export { defineKeyPressHandler } from './_tsup-dts-rollup';
+export { definePasteHandler } from './_tsup-dts-rollup';
+export { defineScrollToSelectionHandler } from './_tsup-dts-rollup';
+export { defineTextInputHandler } from './_tsup-dts-rollup';
+export { defineTripleClickHandler } from './_tsup-dts-rollup';
+export { defineTripleClickOnHandler } from './_tsup-dts-rollup';
+export { ClickHandler } from './_tsup-dts-rollup';
+export { ClickOnHandler } from './_tsup-dts-rollup';
+export { DoubleClickHandler } from './_tsup-dts-rollup';
+export { DoubleClickOnHandler } from './_tsup-dts-rollup';
+export { DropHandler } from './_tsup-dts-rollup';
+export { KeyDownHandler } from './_tsup-dts-rollup';
+export { KeyPressHandler } from './_tsup-dts-rollup';
+export { PasteHandler } from './_tsup-dts-rollup';
+export { ScrollToSelectionHandler } from './_tsup-dts-rollup';
+export { TextInputHandler } from './_tsup-dts-rollup';
+export { TripleClickHandler } from './_tsup-dts-rollup';
+export { TripleClickOnHandler } from './_tsup-dts-rollup';
 export { defineFocusChangeHandler } from './_tsup-dts-rollup';
 export { FocusChangeHandler } from './_tsup-dts-rollup';
 export { defineMountHandler } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -1442,21 +1442,201 @@ function defineDocChangeHandler(handler) {
   });
 }
 
-// src/extensions/events/focus.ts
+// src/extensions/events/dom-event.ts
 import { PluginKey as PluginKey2, ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
-function defineFocusChangeHandler(handler) {
-  const handleFocus = () => handler(true);
-  const handleBlur = () => handler(false);
-  const plugin = new ProseMirrorPlugin2({
-    key: new PluginKey2("prosekit-focus-handler"),
-    props: {
-      handleDOMEvents: {
-        focus: handleFocus,
-        blur: handleBlur
+
+// src/utils/combine-event-handlers.ts
+function combineEventHandlers() {
+  let _handlers = [];
+  function setHandlers(handlers) {
+    _handlers = handlers;
+  }
+  function combinedEventHandler(...args) {
+    for (const handler of _handlers) {
+      if (handler(...args)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  return [setHandlers, combinedEventHandler];
+}
+
+// src/utils/group-entries.ts
+function groupEntries(entries) {
+  const map = {};
+  for (const [key, value] of entries) {
+    const values = map[key];
+    if (!values) {
+      map[key] = [value];
+    } else {
+      values.push(value);
+    }
+  }
+  return map;
+}
+
+// src/extensions/events/dom-event.ts
+function defineDOMEventHandler(event, handler) {
+  return domEventFacet.extension([
+    [event, handler]
+  ]);
+}
+var domEventFacet = Facet.define({
+  converter: () => {
+    const setHandlersMap = {};
+    const combinedHandlerMap = {};
+    const update = (payloads) => {
+      let hasNewEvent = false;
+      for (const [event] of payloads) {
+        if (!setHandlersMap[event]) {
+          hasNewEvent = true;
+          const [setHandlers, combinedHandler] = combineEventHandlers();
+          setHandlersMap[event] = setHandlers;
+          combinedHandlerMap[event] = combinedHandler;
+        }
+      }
+      const map = groupEntries(payloads);
+      for (const [event, handlers] of Object.entries(map)) {
+        const setHandlers = setHandlersMap[event];
+        setHandlers(handlers != null ? handlers : []);
+      }
+      if (hasNewEvent) {
+        return new ProseMirrorPlugin2({
+          key: new PluginKey2("prosekit-dom-event-handler"),
+          props: { handleDOMEvents: combinedHandlerMap }
+        });
+      } else {
+        return null;
+      }
+    };
+    return {
+      create: (payloads) => {
+        const plugin = update(payloads);
+        return plugin ? () => plugin : () => [];
+      },
+      update: (payloads) => {
+        const plugin = update(payloads);
+        return plugin ? () => plugin : null;
+      }
+    };
+  },
+  next: pluginFacet,
+  singleton: true
+});
+
+// src/extensions/events/editor-event.ts
+import { PluginKey as PluginKey3, ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
+function defineKeyDownHandler(handler) {
+  return editorEventFacet.extension([["keyDown", handler]]);
+}
+function defineKeyPressHandler(handler) {
+  return editorEventFacet.extension([["keyPress", handler]]);
+}
+function defineTextInputHandler(handler) {
+  return editorEventFacet.extension([["textInput", handler]]);
+}
+function defineClickOnHandler(handler) {
+  return editorEventFacet.extension([["clickOn", handler]]);
+}
+function defineClickHandler(handler) {
+  return editorEventFacet.extension([["click", handler]]);
+}
+function defineDoubleClickOnHandler(handler) {
+  return editorEventFacet.extension([["doubleClickOn", handler]]);
+}
+function defineDoubleClickHandler(handler) {
+  return editorEventFacet.extension([["doubleClick", handler]]);
+}
+function defineTripleClickOnHandler(handler) {
+  return editorEventFacet.extension([["tripleClickOn", handler]]);
+}
+function defineTripleClickHandler(handler) {
+  return editorEventFacet.extension([["tripleClick", handler]]);
+}
+function definePasteHandler(handler) {
+  return editorEventFacet.extension([["paste", handler]]);
+}
+function defineDropHandler(handler) {
+  return editorEventFacet.extension([["drop", handler]]);
+}
+function defineScrollToSelectionHandler(handler) {
+  return editorEventFacet.extension([["scrollToSelection", handler]]);
+}
+var editorEventFacet = Facet.define({
+  converter: () => {
+    const [update, plugin] = setupEditorEventPlugin();
+    return {
+      create: (entries) => {
+        update(entries);
+        return () => plugin;
+      },
+      update: (entries) => {
+        update(entries);
+        return null;
       }
+    };
+  },
+  next: pluginFacet,
+  singleton: true
+});
+function setupEditorEventPlugin() {
+  const [setKeyDownHandlers, handleKeyDown] = combineEventHandlers();
+  const [setKeyPressHandlers, handleKeyPress] = combineEventHandlers();
+  const [setTextInputHandlers, handleTextInput] = combineEventHandlers();
+  const [setClickOnHandlers, handleClickOn] = combineEventHandlers();
+  const [setClickHandlers, handleClick] = combineEventHandlers();
+  const [setDoubleClickOnHandlers, handleDoubleClickOn] = combineEventHandlers();
+  const [setDoubleClickHandlers, handleDoubleClick] = combineEventHandlers();
+  const [setTripleClickOnHandlers, handleTripleClickOn] = combineEventHandlers();
+  const [setTripleClickHandlers, handleTripleClick] = combineEventHandlers();
+  const [setPasteHandlers, handlePaste] = combineEventHandlers();
+  const [setDropHandlers, handleDrop] = combineEventHandlers();
+  const [setScrollToSelectionHandlers, handleScrollToSelection] = combineEventHandlers();
+  const update = (entries) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    const map = groupEntries(entries);
+    setKeyDownHandlers((_a = map.keyDown) != null ? _a : []);
+    setKeyPressHandlers((_b = map.keyPress) != null ? _b : []);
+    setTextInputHandlers((_c = map.textInput) != null ? _c : []);
+    setClickOnHandlers((_d = map.clickOn) != null ? _d : []);
+    setClickHandlers((_e = map.click) != null ? _e : []);
+    setDoubleClickOnHandlers((_f = map.doubleClickOn) != null ? _f : []);
+    setDoubleClickHandlers((_g = map.doubleClick) != null ? _g : []);
+    setTripleClickOnHandlers((_h = map.tripleClickOn) != null ? _h : []);
+    setTripleClickHandlers((_i = map.tripleClick) != null ? _i : []);
+    setPasteHandlers((_j = map.paste) != null ? _j : []);
+    setDropHandlers((_k = map.drop) != null ? _k : []);
+    setScrollToSelectionHandlers((_l = map.scrollToSelection) != null ? _l : []);
+  };
+  const plugin = new ProseMirrorPlugin3({
+    key: new PluginKey3("prosekit-editor-handler"),
+    props: {
+      handleKeyDown,
+      handleKeyPress,
+      handleTextInput,
+      handleClickOn,
+      handleClick,
+      handleDoubleClickOn,
+      handleDoubleClick,
+      handleTripleClickOn,
+      handleTripleClick,
+      handlePaste,
+      handleDrop,
+      handleScrollToSelection
     }
   });
-  return definePlugin(plugin);
+  return [update, plugin];
+}
+
+// src/extensions/events/focus.ts
+function defineFocusChangeHandler(handler) {
+  const handleFocus = () => handler(true);
+  const handleBlur = () => handler(false);
+  return domEventFacet.extension([
+    ["focus", handleFocus],
+    ["blur", handleBlur]
+  ]);
 }
 
 // src/extensions/history.ts
@@ -1468,7 +1648,7 @@ var isMac = typeof navigator !== "undefined" ? /Mac|iP(hone|[ao]d)/.test(navigat
 // src/extensions/keymap.ts
 import { baseKeymap, chainCommands } from "@prosekit/pm/commands";
 import { keydownHandler } from "@prosekit/pm/keymap";
-import { Plugin as Plugin3, PluginKey as PluginKey3 } from "@prosekit/pm/state";
+import { Plugin as Plugin3, PluginKey as PluginKey4 } from "@prosekit/pm/state";
 function defineKeymap(keymap) {
   return keymapFacet.extension([keymap]);
 }
@@ -1519,7 +1699,7 @@ function mergeKeymaps(keymaps) {
     ])
   );
 }
-var keymapPluginKey = new PluginKey3("prosekit-keymap");
+var keymapPluginKey = new PluginKey4("prosekit-keymap");
 
 // src/extensions/history.ts
 function defineHistory() {
@@ -1632,7 +1812,7 @@ var markSpecFacet = Facet.define({
 });
 
 // src/extensions/node-view.ts
-import { ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
+import { ProseMirrorPlugin as ProseMirrorPlugin4 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function defineNodeView(options) {
   return nodeViewFacet.extension([options]);
@@ -1645,13 +1825,13 @@ var nodeViewFacet = Facet.define({
         nodeViews[input.name] = input.constructor;
       }
     }
-    return () => [new ProseMirrorPlugin3({ props: { nodeViews } })];
+    return () => [new ProseMirrorPlugin4({ props: { nodeViews } })];
   },
   next: pluginFacet
 });
 
 // src/extensions/node-view-effect.ts
-import { ProseMirrorPlugin as ProseMirrorPlugin4 } from "@prosekit/pm/state";
+import { ProseMirrorPlugin as ProseMirrorPlugin5 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function defineNodeViewFactory(options) {
   return nodeViewFactoryFacet.extension([options]);
@@ -1679,7 +1859,7 @@ var nodeViewFactoryFacet = Facet.define({
         nodeViews[name] = factory(args);
       }
     }
-    return () => [new ProseMirrorPlugin4({ props: { nodeViews } })];
+    return () => [new ProseMirrorPlugin5({ props: { nodeViews } })];
   },
   next: pluginFacet
 });
@@ -1763,12 +1943,20 @@ export {
   defaultBlockAt,
   defineBaseCommands,
   defineBaseKeymap,
+  defineClickHandler,
+  defineClickOnHandler,
   defineCommands,
+  defineDOMEventHandler,
   defineDefaultState,
   defineDoc,
   defineDocChangeHandler,
+  defineDoubleClickHandler,
+  defineDoubleClickOnHandler,
+  defineDropHandler,
   defineFocusChangeHandler,
   defineHistory,
+  defineKeyDownHandler,
+  defineKeyPressHandler,
   defineKeymap,
   defineMarkAttr,
   defineMarkSpec,
@@ -1778,8 +1966,13 @@ export {
   defineNodeView,
   defineNodeViewFactory,
   defineParagraph,
+  definePasteHandler,
   definePlugin,
+  defineScrollToSelectionHandler,
   defineText,
+  defineTextInputHandler,
+  defineTripleClickHandler,
+  defineTripleClickOnHandler,
   defineUnmountHandler,
   defineUpdateHandler,
   expandMark,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -42,7 +42,7 @@
   },
   "devDependencies": {
     "@prosekit/dev": "*",
-    "tsup": "^8.0.1",
+    "tsup": "^8.0.2",
     "typescript": "^5.3.3",
     "vitest": "^1.2.2"
   },