@prosekit/core 0.0.8 → 0.0.10

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,15 @@ 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 }
+
 /**
  * @public
  */
@@ -176,6 +187,8 @@ 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[];
+
 /** @internal */
 declare interface CommandArgs {
     [name: string]: any[];
@@ -200,6 +213,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;
@@ -235,8 +252,16 @@ declare class Editor<E extends Extension = any> {
     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 }
@@ -396,10 +421,14 @@ export declare function insertNode({ node, pos, }: {
     pos?: number;
 }): Action;
 
+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 +436,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 +451,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.
  *

package/dist/prosekit-core.d.ts

@@ -18,6 +18,7 @@ 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 { addInputRule } from './_tsup-dts-rollup';
 export { addBaseKeymap } from './_tsup-dts-rollup';
 export { addKeymap } 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,
@@ -512,9 +631,9 @@ var EditorInstance = class {
     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) {
@@ -653,21 +788,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 +888,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 +898,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 +918,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,7 +950,46 @@ var pluginFacet = Facet.define({
   next: stateSlot
 });
 
+// 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 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,
+  single: true
+});
+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]);
 }
@@ -843,7 +1006,7 @@ var inputRuleFacet = Facet.define({
 // 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 Plugin4, PluginKey as PluginKey2 } from "@prosekit/pm/state";
 function addKeymap(keymap) {
   return keymapFacet.extension([keymap]);
 }
@@ -892,7 +1055,7 @@ function mergeKeymaps(keymaps) {
     ])
   );
 }
-var keymapPluginKey = new PluginKey("prosekit-keymap");
+var keymapPluginKey = new PluginKey2("prosekit-keymap");
 
 // src/extensions/mark-spec.ts
 function addMarkSpec(options) {
@@ -903,7 +1066,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 +1125,7 @@ export {
   addCommands,
   addDefaultState,
   addDoc,
+  addEventHandler,
   addInputRule,
   addKeymap,
   addMark,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -38,7 +38,7 @@
     "dist"
   ],
   "dependencies": {
-    "@prosekit/pm": "^0.0.3",
+    "@prosekit/pm": "^0.0.5",
     "orderedmap": "^2.1.1",
     "type-fest": "^4.3.1"
   },

package/src/index.ts

@@ -12,6 +12,7 @@ export {
   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'