@prosekit/core 0.2.1 → 0.2.3

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

@@ -120,6 +120,17 @@ declare interface BaseNodeViewOptions {
 export { BaseNodeViewOptions }
 export { BaseNodeViewOptions as BaseNodeViewOptions_alias_1 }
 
+/**
+ * A utility for constructing `className` strings conditionally.
+ *
+ * It is a re-export of [clsx/lite](https://www.npmjs.com/package/clsx) with stricter types.
+ *
+ * @public
+ */
+declare const clsx: (...args: Array<string | boolean | null | undefined>) => string;
+export { clsx }
+export { clsx as clsx_alias_1 }
+
 export declare function collectNodes(content: NodeContent): ProseMirrorNode[];
 
 export declare interface CommandApplier<Args extends any[] = any[]> {
@@ -277,6 +288,15 @@ NODES: "doc";
 export { defineDoc }
 export { defineDoc as defineDoc_alias_1 }
 
+/**
+ * Registers a event handler that is called when the editor document is changed.
+ *
+ * @public
+ */
+declare function defineDocChangeHandler(handler: DocChangeHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineDocChangeHandler }
+export { defineDocChangeHandler as defineDocChangeHandler_alias_1 }
+
 /**
  * Add undo/redo history to the editor.
  */
@@ -312,6 +332,13 @@ declare function defineKeymap(keymap: Keymap): Extension;
 export { defineKeymap }
 export { defineKeymap as defineKeymap_alias_1 }
 
+/**
+ * @public
+ */
+declare function defineMarkAttr(options: MarkAttrOptions): Extension;
+export { defineMarkAttr }
+export { defineMarkAttr as defineMarkAttr_alias_1 }
+
 /**
  * @public
  */
@@ -322,6 +349,26 @@ export { defineMarkSpec }
 export { defineMarkSpec as defineMarkSpec_alias_1 }
 
 /**
+ * Registers a event handler that is called when the editor view is mounted.
+ *
+ * @public
+ */
+declare function defineMountHandler(handler: MountHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineMountHandler }
+export { defineMountHandler as defineMountHandler_alias_1 }
+
+/**
+ * Defines an attribute for a node type.
+ *
+ * @public
+ */
+declare function defineNodeAttr(options: NodeAttrOptions): Extension;
+export { defineNodeAttr }
+export { defineNodeAttr as defineNodeAttr_alias_1 }
+
+/**
+ * Defines a node type.
+ *
  * @public
  */
 declare function defineNodeSpec<NodeName extends string>(options: NodeSpecOptions<NodeName>): Extension<{
@@ -385,12 +432,35 @@ export { defineText }
 export { defineText as defineText_alias_1 }
 
 /**
- * @internal
+ * Registers a event handler that is called when the editor view is unmounted.
+ *
+ * @public
+ */
+declare function defineUnmountHandler(handler: UnmountHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineUnmountHandler }
+export { defineUnmountHandler as defineUnmountHandler_alias_1 }
+
+/**
+ * Registers a event handler that is called when the editor state is updated.
+ *
+ * @public
  */
 declare function defineUpdateHandler(handler: UpdateHandler): Extension<ExtensionTyping<string, string, CommandArgs>>;
 export { defineUpdateHandler }
 export { defineUpdateHandler as defineUpdateHandler_alias_1 }
 
+/**
+ * A function that is called when the editor document is changed.
+ *
+ * @param view - The editor view.
+ * @param prevState - The previous editor state.
+ *
+ * @public
+ */
+declare type DocChangeHandler = (view: EditorView, prevState: EditorState) => void;
+export { DocChangeHandler }
+export { DocChangeHandler as DocChangeHandler_alias_1 }
+
 /**
  * @public
  */
@@ -660,6 +730,8 @@ declare function isAllSelection(sel: Selection_2): sel is AllSelection;
 export { isAllSelection }
 export { isAllSelection as isAllSelection_alias_1 }
 
+export declare function isElement(value: unknown): value is Element;
+
 export declare const isMac: boolean;
 
 /**
@@ -755,6 +827,36 @@ declare type KeymapPayload = Keymap;
 export { KeymapPayload }
 export { KeymapPayload as KeymapPayload_alias_1 }
 
+/**
+ * @public
+ */
+declare interface MarkAttrOptions {
+    /**
+     * The name of the mark type.
+     */
+    type: string;
+    /**
+     * The name of the attribute.
+     */
+    attr: string;
+    /**
+     * The default value for this attribute, to use when no explicit value is
+     * provided. Attributes that have no default must be provided whenever a mark
+     * of a type that has them is created.
+     */
+    default?: any;
+    /**
+     * Returns the attribute key and value to be set on the DOM node.
+     */
+    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    /**
+     * Parses the attribute value from the DOM.
+     */
+    parseDOM?: (node: HTMLElement) => any;
+}
+export { MarkAttrOptions }
+export { MarkAttrOptions as MarkAttrOptions_alias_1 }
+
 export declare interface MarkBuilder {
     (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode[];
     (...children: NodeChild[]): ProseMirrorNode[];
@@ -770,6 +872,47 @@ declare interface MarkSpecOptions<MarkName extends string = string> extends Mark
 export { MarkSpecOptions }
 export { MarkSpecOptions as MarkSpecOptions_alias_1 }
 
+/**
+ * A function that is called when the editor view is mounted.
+ *
+ * @param view - The editor view.
+ *
+ * @public
+ */
+declare type MountHandler = (view: EditorView) => void;
+export { MountHandler }
+export { MountHandler as MountHandler_alias_1 }
+
+/**
+ * @public
+ */
+declare interface NodeAttrOptions {
+    /**
+     * The name of the node type.
+     */
+    type: string;
+    /**
+     * The name of the attribute.
+     */
+    attr: string;
+    /**
+     * The default value for this attribute, to use when no explicit value is
+     * provided. Attributes that have no default must be provided whenever a node
+     * of a type that has them is created.
+     */
+    default?: any;
+    /**
+     * Returns the attribute key and value to be set on the DOM node.
+     */
+    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    /**
+     * Parses the attribute value from the DOM.
+     */
+    parseDOM?: (node: HTMLElement) => any;
+}
+export { NodeAttrOptions }
+export { NodeAttrOptions as NodeAttrOptions_alias_1 }
+
 export declare interface NodeBuilder {
     (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode;
     (...children: NodeChild[]): ProseMirrorNode;
@@ -879,6 +1022,8 @@ export { PluginPayload }
 export { PluginPayload as PluginPayload_alias_1 }
 
 /**
+ * ProseKit extension priority.
+ *
  * @public
  */
 declare const enum Priority {
@@ -1053,6 +1198,15 @@ export declare function uniqPush<T>(prev: readonly T[], next: readonly T[]): T[]
 
 export declare function uniqRemove<T>(prev: T[], next: T[]): T[];
 
+/**
+ * A function that is called when the editor view is unmounted.
+ *
+ * @public
+ */
+declare type UnmountHandler = () => void;
+export { UnmountHandler }
+export { UnmountHandler as UnmountHandler_alias_1 }
+
 export declare function updateExtension(prevInputs: Payloads, prevConverters: Converters, extension: Extension, mode: 'add' | 'remove'): {
     schemaInput: SchemaPayload | null;
     stateInput: StatePayload | null;
@@ -1060,10 +1214,17 @@ export declare function updateExtension(prevInputs: Payloads, prevConverters: Co
     commandInput: CommandCreators | null;
 };
 
-export declare type UpdateHandler = (options: {
-    view: EditorView;
-    prevState?: EditorState;
-}) => void;
+/**
+ * A function that is called when the editor state is updated.
+ *
+ * @param view - The editor view.
+ * @param prevState - The previous editor state.
+ *
+ * @public
+ */
+declare type UpdateHandler = (view: EditorView, prevState: EditorState) => void;
+export { UpdateHandler }
+export { UpdateHandler as UpdateHandler_alias_1 }
 
 export declare const viewFacet: Facet<ViewPayload, ViewPayload>;
 

package/dist/prosekit-core.d.ts

@@ -15,6 +15,14 @@ export { defineCommands } from './_tsup-dts-rollup';
 export { defineDefaultState } from './_tsup-dts-rollup';
 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 { defineMountHandler } from './_tsup-dts-rollup';
+export { defineUnmountHandler } from './_tsup-dts-rollup';
+export { defineUpdateHandler } from './_tsup-dts-rollup';
+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 { defineInputRule } from './_tsup-dts-rollup';
 export { defineBaseKeymap } from './_tsup-dts-rollup';
@@ -22,9 +30,13 @@ 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 { defineMarkAttr } from './_tsup-dts-rollup';
 export { defineMarkSpec } from './_tsup-dts-rollup';
+export { MarkAttrOptions } from './_tsup-dts-rollup';
 export { MarkSpecOptions } from './_tsup-dts-rollup';
+export { defineNodeAttr } from './_tsup-dts-rollup';
 export { defineNodeSpec } from './_tsup-dts-rollup';
+export { NodeAttrOptions } from './_tsup-dts-rollup';
 export { NodeSpecOptions } from './_tsup-dts-rollup';
 export { defineNodeView } from './_tsup-dts-rollup';
 export { NodeViewOptions } from './_tsup-dts-rollup';
@@ -35,7 +47,6 @@ 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 { defineUpdateHandler } from './_tsup-dts-rollup';
 export { Facet } from './_tsup-dts-rollup';
 export { FacetOptions } from './_tsup-dts-rollup';
 export { BaseNodeViewOptions } from './_tsup-dts-rollup';
@@ -52,6 +63,7 @@ export { SelectionJSON } from './_tsup-dts-rollup';
 export { StateJSON } from './_tsup-dts-rollup';
 export { Priority } from './_tsup-dts-rollup';
 export { SimplifyUnion } from './_tsup-dts-rollup';
+export { clsx } from './_tsup-dts-rollup';
 export { _getId } from './_tsup-dts-rollup';
 export { getMarkType } from './_tsup-dts-rollup';
 export { getNodeType } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -1099,26 +1099,110 @@ function defineBaseCommands() {
   });
 }
 
+// src/utils/is-element.ts
+var hasElement = typeof Element !== "undefined";
+function isElement(value) {
+  return hasElement && value instanceof Element;
+}
+
+// src/utils/is-not-null.ts
+function isNotNull(value) {
+  return value != null;
+}
+
 // src/extensions/node-spec.ts
 function defineNodeSpec(options) {
-  return nodeSpecFacet.extension([options]);
+  const payload = [options, void 0];
+  return nodeSpecFacet.extension([payload]);
+}
+function defineNodeAttr(options) {
+  const payload = [void 0, options];
+  return nodeSpecFacet.extension([payload]);
 }
 var nodeSpecFacet = Facet.define({
-  convert: (options) => {
+  convert: (payloads) => {
     const nodes = {};
     let topNodeName = void 0;
-    for (const { name, topNode, ...spec } of options) {
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
+    for (const { name, topNode, ...spec } of specPayloads) {
       if (nodes[name]) {
         throw new ProseKitError(`Node type ${name} has already been defined`);
       }
-      if (topNodeName && !topNode) {
+      if (topNode) {
         topNodeName = name;
       }
       nodes[name] = spec;
     }
+    for (const {
+      type,
+      attr,
+      default: defaultValue,
+      toDOM,
+      parseDOM
+    } of attrPayloads) {
+      const spec = nodes[type];
+      if (!spec) {
+        throw new ProseKitError(
+          `Node type ${type} must be defined before defining attributes`
+        );
+      }
+      if (!spec.attrs) {
+        spec.attrs = {};
+      }
+      spec.attrs[attr] = { default: defaultValue };
+      if (toDOM && spec.toDOM) {
+        const existingToDom = spec.toDOM;
+        spec.toDOM = (node) => {
+          const dom = existingToDom(node);
+          if (!dom) {
+            return dom;
+          }
+          const attrDOM = toDOM(node.attrs[attr]);
+          if (!attrDOM) {
+            return dom;
+          }
+          const [key, value] = attrDOM;
+          if (!key) {
+            return dom;
+          }
+          if (Array.isArray(dom)) {
+            if (typeof dom[1] === "object") {
+              return [dom[0], { ...dom[1], [key]: value }, ...dom.slice(2)];
+            } else {
+              return [dom[0], { [key]: value }, ...dom.slice(1)];
+            }
+          } else if (isElement(dom)) {
+            dom.setAttribute(key, value);
+          } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
+            dom.dom.setAttribute(key, value);
+          }
+          return dom;
+        };
+      }
+      if (parseDOM && spec.parseDOM) {
+        for (const rule of spec.parseDOM) {
+          const existingGetAttrs = rule.getAttrs;
+          const existingAttrs = rule.attrs;
+          rule.getAttrs = (dom) => {
+            var _a;
+            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
+            if (attrs === false || !dom || !isElement(dom)) {
+              return attrs != null ? attrs : null;
+            }
+            const value = parseDOM(dom);
+            return {
+              ...attrs,
+              [attr]: value
+            };
+          };
+        }
+      }
+    }
     return { nodes, topNode: topNodeName };
   },
-  next: schemaFacet
+  next: schemaFacet,
+  singleton: true
 });
 
 // src/extensions/doc.ts
@@ -1130,16 +1214,8 @@ function defineDoc() {
   });
 }
 
-// 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 Plugin3, PluginKey } from "@prosekit/pm/state";
+// src/extensions/events/plugin-view.ts
+import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
 
 // src/extensions/plugin.ts
 import "@prosekit/pm/model";
@@ -1177,7 +1253,89 @@ var pluginFacet = Facet.define({
   next: stateFacet
 });
 
+// src/extensions/events/plugin-view.ts
+function defineMountHandler(handler) {
+  return pluginViewFacet.extension([["mount", handler]]);
+}
+function defineUpdateHandler(handler) {
+  return pluginViewFacet.extension([["update", handler]]);
+}
+function defineUnmountHandler(handler) {
+  return pluginViewFacet.extension([["unmount", handler]]);
+}
+var pluginViewFacet = Facet.define({
+  converter: () => {
+    let mountHandlers = [];
+    let updateHandlers = [];
+    let unmountHandlers = [];
+    const plugin = new ProseMirrorPlugin({
+      key: pluginKey,
+      view: (view) => {
+        mountHandlers.forEach((fn) => fn(view));
+        return {
+          update: (view2, prevState) => {
+            updateHandlers.forEach((fn) => fn(view2, prevState));
+          },
+          destroy: () => {
+            unmountHandlers.forEach((fn) => fn());
+          }
+        };
+      }
+    });
+    const pluginFunc = () => [plugin];
+    const register = (input) => {
+      mountHandlers = [];
+      updateHandlers = [];
+      unmountHandlers = [];
+      for (const args of input) {
+        switch (args[0]) {
+          case "mount":
+            mountHandlers.push(args[1]);
+            break;
+          case "update":
+            updateHandlers.push(args[1]);
+            break;
+          case "unmount":
+            unmountHandlers.push(args[1]);
+            break;
+        }
+      }
+    };
+    return {
+      create: (input) => {
+        register(input);
+        return pluginFunc;
+      },
+      update: (input) => {
+        register(input);
+        return null;
+      }
+    };
+  },
+  next: pluginFacet,
+  singleton: true
+});
+var pluginKey = new PluginKey("prosekit-plugin-view-handler");
+
+// src/extensions/events/doc-change.ts
+function defineDocChangeHandler(handler) {
+  return defineUpdateHandler((view, prevState) => {
+    if (!view.state.doc.eq(prevState.doc)) {
+      handler(view, prevState);
+    }
+  });
+}
+
+// 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 Plugin3, PluginKey as PluginKey2 } from "@prosekit/pm/state";
 function defineKeymap(keymap) {
   return keymapFacet.extension([keymap]);
 }
@@ -1228,7 +1386,7 @@ function mergeKeymaps(keymaps) {
     ])
   );
 }
-var keymapPluginKey = new PluginKey("prosekit-keymap");
+var keymapPluginKey = new PluginKey2("prosekit-keymap");
 
 // src/extensions/history.ts
 function defineHistory() {
@@ -1277,24 +1435,97 @@ var inputRuleFacet = Facet.define({
 
 // src/extensions/mark-spec.ts
 function defineMarkSpec(options) {
-  return markSpecFacet.extension([options]);
+  const payload = [options, void 0];
+  return markSpecFacet.extension([payload]);
+}
+function defineMarkAttr(options) {
+  const payload = [void 0, options];
+  return markSpecFacet.extension([payload]);
 }
 var markSpecFacet = Facet.define({
-  convert: (options) => {
+  convert: (payloads) => {
     const marks = {};
-    for (const { name, ...spec } of options) {
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
+    for (const { name, ...spec } of specPayloads) {
       if (marks[name]) {
         throw new ProseKitError(`Mark type ${name} has already been defined`);
       }
       marks[name] = spec;
     }
+    for (const {
+      type,
+      attr,
+      default: defaultValue,
+      toDOM,
+      parseDOM
+    } of attrPayloads) {
+      const spec = marks[type];
+      if (!spec) {
+        throw new ProseKitError(
+          `Mark type ${type} must be defined before defining attributes`
+        );
+      }
+      if (!spec.attrs) {
+        spec.attrs = {};
+      }
+      spec.attrs[attr] = { default: defaultValue };
+      if (toDOM && spec.toDOM) {
+        const existingToDom = spec.toDOM;
+        spec.toDOM = (mark, inline) => {
+          const dom = existingToDom(mark, inline);
+          if (!dom) {
+            return dom;
+          }
+          const attrDOM = toDOM(mark.attrs[attr]);
+          if (!attrDOM) {
+            return dom;
+          }
+          const [key, value] = attrDOM;
+          if (!key) {
+            return dom;
+          }
+          if (Array.isArray(dom)) {
+            if (typeof dom[1] === "object") {
+              return [dom[0], { ...dom[1], [key]: value }, ...dom.slice(2)];
+            } else {
+              return [dom[0], { [key]: value }, ...dom.slice(1)];
+            }
+          } else if (isElement(dom)) {
+            dom.setAttribute(key, value);
+          } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
+            dom.dom.setAttribute(key, value);
+          }
+          return dom;
+        };
+      }
+      if (parseDOM && spec.parseDOM) {
+        for (const rule of spec.parseDOM) {
+          const existingGetAttrs = rule.getAttrs;
+          const existingAttrs = rule.attrs;
+          rule.getAttrs = (dom) => {
+            var _a;
+            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
+            if (attrs === false || !dom || !isElement(dom)) {
+              return attrs != null ? attrs : null;
+            }
+            const value = parseDOM(dom);
+            return {
+              ...attrs,
+              [attr]: value
+            };
+          };
+        }
+      }
+    }
     return { marks, nodes: {} };
   },
-  next: schemaFacet
+  next: schemaFacet,
+  singleton: true
 });
 
 // src/extensions/node-view.ts
-import { ProseMirrorPlugin } from "@prosekit/pm/state";
+import { ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function defineNodeView(options) {
   return nodeViewFacet.extension([options]);
@@ -1307,13 +1538,13 @@ var nodeViewFacet = Facet.define({
         nodeViews[input.name] = input.constructor;
       }
     }
-    return () => [new ProseMirrorPlugin({ props: { nodeViews } })];
+    return () => [new ProseMirrorPlugin2({ props: { nodeViews } })];
   },
   next: pluginFacet
 });
 
 // src/extensions/node-view-effect.ts
-import { ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
+import { ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function defineNodeViewFactory(options) {
   return nodeViewFactoryFacet.extension([options]);
@@ -1341,7 +1572,7 @@ var nodeViewFactoryFacet = Facet.define({
         nodeViews[name] = factory(args);
       }
     }
-    return () => [new ProseMirrorPlugin2({ props: { nodeViews } })];
+    return () => [new ProseMirrorPlugin3({ props: { nodeViews } })];
   },
   next: pluginFacet
 });
@@ -1370,48 +1601,9 @@ function defineText() {
   });
 }
 
-// src/extensions/update-handler.ts
-import { PluginKey as PluginKey2, ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
-
-// src/utils/is-not-null.ts
-function isNotNull(value) {
-  return value != null;
-}
-
-// src/extensions/update-handler.ts
-function defineUpdateHandler(handler) {
-  return updateHandlerFacet.extension([handler]);
-}
-var updateHandlerFacet = Facet.define({
-  converter: () => {
-    let updateHandlers = [];
-    const plugin = new ProseMirrorPlugin3({
-      key: pluginKey,
-      view: (view) => {
-        updateHandlers.forEach((fn) => fn({ view }));
-        return {
-          update: (view2, prevState) => {
-            updateHandlers.forEach((fn) => fn({ view: view2, prevState }));
-          }
-        };
-      }
-    });
-    const pluginFunc = () => [plugin];
-    return {
-      create: (handlers) => {
-        updateHandlers = handlers.filter(isNotNull);
-        return pluginFunc;
-      },
-      update: (handlers) => {
-        updateHandlers = handlers.filter(isNotNull);
-        return null;
-      }
-    };
-  },
-  next: pluginFacet,
-  singleton: true
-});
-var pluginKey = new PluginKey2("prosekit-event-handler");
+// src/utils/clsx.ts
+import clsxLite from "clsx/lite";
+var clsx = clsxLite;
 
 // src/utils/get-id.ts
 var id = 0;
@@ -1426,22 +1618,28 @@ export {
   ProseKitError,
   getId as _getId,
   addMark,
+  clsx,
   createEditor,
   defineBaseCommands,
   defineBaseKeymap,
   defineCommands,
   defineDefaultState,
   defineDoc,
+  defineDocChangeHandler,
   defineHistory,
   defineInputRule,
   defineKeymap,
+  defineMarkAttr,
   defineMarkSpec,
+  defineMountHandler,
+  defineNodeAttr,
   defineNodeSpec,
   defineNodeView,
   defineNodeViewFactory,
   defineParagraph,
   definePlugin,
   defineText,
+  defineUnmountHandler,
   defineUpdateHandler,
   getMarkType,
   getNodeType,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -36,6 +36,7 @@
   ],
   "dependencies": {
     "@prosekit/pm": "^0.1.1",
+    "clsx": "^2.1.0",
     "orderedmap": "^2.1.1",
     "type-fest": "^4.9.0"
   },
@@ -43,7 +44,7 @@
     "@prosekit/dev": "*",
     "tsup": "^8.0.1",
     "typescript": "^5.3.3",
-    "vitest": "^1.1.1"
+    "vitest": "^1.1.3"
   },
   "scripts": {
     "build:tsup": "tsup",

package/src/index.ts

@@ -14,6 +14,18 @@ export {
   type DefaultStateOptions,
 } from './extensions/default-state'
 export { defineDoc } from './extensions/doc'
+export {
+  defineDocChangeHandler,
+  type DocChangeHandler,
+} from './extensions/events/doc-change'
+export {
+  defineMountHandler,
+  defineUnmountHandler,
+  defineUpdateHandler,
+  type MountHandler,
+  type UnmountHandler,
+  type UpdateHandler,
+} from './extensions/events/plugin-view'
 export { defineHistory } from './extensions/history'
 export { defineInputRule } from './extensions/input-rules'
 export {
@@ -23,8 +35,18 @@ export {
   type Keymap,
   type KeymapPayload,
 } from './extensions/keymap'
-export { defineMarkSpec, type MarkSpecOptions } from './extensions/mark-spec'
-export { defineNodeSpec, type NodeSpecOptions } from './extensions/node-spec'
+export {
+  defineMarkAttr,
+  defineMarkSpec,
+  type MarkAttrOptions,
+  type MarkSpecOptions,
+} from './extensions/mark-spec'
+export {
+  defineNodeAttr,
+  defineNodeSpec,
+  type NodeAttrOptions,
+  type NodeSpecOptions,
+} from './extensions/node-spec'
 export { defineNodeView, type NodeViewOptions } from './extensions/node-view'
 export {
   defineNodeViewFactory,
@@ -37,7 +59,6 @@ export {
   type PluginPayload,
 } from './extensions/plugin'
 export { defineText } from './extensions/text'
-export { defineUpdateHandler } from './extensions/update-handler'
 export { Facet, type FacetOptions } from './facets/facet'
 export type { BaseNodeViewOptions } from './types/base-node-view-options'
 export { type CommandArgs } from './types/command'
@@ -53,6 +74,7 @@ export { type ExtensionTyping } from './types/extension-typing'
 export type { NodeJSON, SelectionJSON, StateJSON } from './types/model'
 export { Priority } from './types/priority'
 export { type SimplifyUnion } from './types/simplify-union'
+export { clsx } from './utils/clsx'
 export { getId as _getId } from './utils/get-id'
 export { getMarkType } from './utils/get-mark-type'
 export { getNodeType } from './utils/get-node-type'