@prosekit/core 0.0.13 → 0.0.15

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

@@ -1,8 +1,9 @@
 import { Attrs } from '@prosekit/pm/model';
+import { Attrs as Attrs_2 } from 'prosemirror-model';
 import { Command } from '@prosekit/pm/state';
 import type { ConditionalExcept } from 'type-fest';
 import type { DirectEditorProps } from '@prosekit/pm/view';
-import type { EditorState } from '@prosekit/pm/state';
+import { EditorState } from '@prosekit/pm/state';
 import type { EditorStateConfig } from '@prosekit/pm/state';
 import { EditorView } from '@prosekit/pm/view';
 import type { EmptyObject } from 'type-fest';
@@ -11,8 +12,10 @@ 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 { Node as Node_2 } from 'prosemirror-model';
 import type { NodeSpec } from '@prosekit/pm/model';
 import { NodeType } from '@prosekit/pm/model';
+import { NodeType as NodeType_2 } from 'prosemirror-model';
 import { NodeViewConstructor } from '@prosekit/pm/view';
 import { Options } from 'tsup';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
@@ -20,6 +23,7 @@ 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';
+import { Selection as Selection_2 } from 'prosemirror-state';
 import type { Simplify } from 'type-fest';
 import { Transaction } from '@prosekit/pm/state';
 import type { UnionToIntersection } from 'type-fest';
@@ -30,11 +34,7 @@ declare type Action = (options: {
     view?: EditorView;
 }) => boolean;
 
-declare function addMark(options: AddMarkOptions): Command;
-export { addMark }
-export { addMark as addMark_alias_1 }
-
-declare interface AddMarkOptions {
+declare function addMark(options: {
     type: string | MarkType;
     attrs?: Attrs | null;
     /**
@@ -45,9 +45,9 @@ declare interface AddMarkOptions {
      * 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 }
+}): Command;
+export { addMark }
+export { addMark as addMark_alias_1 }
 
 export declare function applyAction(operator: Action): Command;
 
@@ -123,16 +123,16 @@ declare function defineBaseCommands(): Extension<{
             to?: number | undefined;
         }];
         insertNode: [{
-            node: ProseMirrorNode;
+            node: Node_2;
             pos?: number | undefined;
         }];
         wrap: [{
-            nodeType: NodeType;
-            attrs?: Attrs | null | undefined;
+            nodeType: NodeType_2;
+            attrs?: Attrs_2 | null | undefined;
         }];
-        setBlockType: [{
-            nodeType: NodeType;
-            attrs?: Attrs | null | undefined;
+        setBlockType: [options: {
+            type: string | NodeType_2;
+            attrs?: Attrs_2 | null | undefined;
             from?: number | undefined;
             to?: number | undefined;
         }];
@@ -386,8 +386,10 @@ declare class Facet<Input, Output> {
     readonly converter: () => FacetConverter<Input, Output>;
     /** @internal */
     readonly next: Facet<Output, any> | null;
+    /** @internal */
+    readonly singleton: boolean;
     private constructor();
-    static define<Input, Output>({ converter: converter, convert: convert, next, }: FacetOptions<Input, Output>): Facet<Input, Output>;
+    static define<Input, Output>({ converter: converter, convert: convert, next, singleton, }: FacetOptions<Input, Output>): Facet<Input, Output>;
     /** @internal */
     static defineRootFacet<Input>(options: Omit<FacetOptions<Input, Input>, 'next'>): Facet<Input, Input>;
     extension(payloads: Input[]): FacetExtension<Input, Output>;
@@ -416,10 +418,13 @@ declare interface FacetOptions<Input, Output> {
     convert?: (payloads: Input[]) => Output;
     converter?: () => FacetConverter<Input, Output>;
     next: Facet<Output, any>;
+    singleton?: boolean;
 }
 export { FacetOptions }
 export { FacetOptions as FacetOptions_alias_1 }
 
+export declare function getCustomSelection(state: EditorState, from?: number | null, to?: number | null): Selection_2;
+
 export declare function getFacetCount(): number;
 
 /** @internal */
@@ -432,11 +437,30 @@ declare function getNodeType(schema: Schema, type: string | NodeType): NodeType;
 export { getNodeType }
 export { getNodeType as getNodeType_alias_1 }
 
-export declare function insertNode({ node, pos, }: {
+declare function insertNode(options: {
+    node: ProseMirrorNode;
+    pos?: number;
+}): Command;
+
+declare function insertNode(options: {
+    attrs?: Attrs;
+    type: string;
+    pos?: number;
+}): Command;
+export { insertNode }
+export { insertNode as insertNode_alias_1 }
+
+export declare function insertNode_alias_2({ node, pos, }: {
     node: ProseMirrorNode;
     pos?: number;
 }): Action;
 
+export declare function insertText({ text, from, to, }: {
+    text: string;
+    from?: number;
+    to?: number;
+}): Command;
+
 export declare const isMac: boolean;
 
 export declare function isMark(mark: unknown): mark is Mark;
@@ -568,6 +592,8 @@ export declare const schemaFacet: Facet<SchemaPayload, SchemaPayload>;
 
 export declare type SchemaPayload = SchemaSpec;
 
+export declare function selectAll(): Command;
+
 /**
  * A JSON representation of the prosemirror selection.
  *
@@ -581,6 +607,19 @@ declare interface SelectionJson {
 export { SelectionJson }
 export { SelectionJson as SelectionJson_alias_1 }
 
+/**
+ * Returns a command that tries to set the selected textblocks to the given node
+ * type with the given attributes.
+ */
+declare function setBlockType(options: {
+    type: NodeType | string;
+    attrs?: Attrs | null;
+    from?: number;
+    to?: number;
+}): Command;
+export { setBlockType }
+export { setBlockType as setBlockType_alias_1 }
+
 /**
  * @internal
  */
@@ -635,28 +674,20 @@ export declare type ToCommandCreators<T extends CommandArgs> = {
     [K in keyof T]: CommandCreator<T[K]>;
 };
 
-declare function toggleMark(options: ToggleMarkOptions): Command;
+declare function toggleMark({ type, attrs, }: {
+    type: string | MarkType;
+    attrs?: Attrs | null;
+}): Command;
 export { toggleMark }
 export { toggleMark as toggleMark_alias_1 }
 
-declare interface ToggleMarkOptions {
-    type: string | MarkType;
+declare function toggleNode({ type, attrs, }: {
+    type: string | NodeType;
     attrs?: Attrs | null;
-}
-export { ToggleMarkOptions }
-export { ToggleMarkOptions as ToggleMarkOptions_alias_1 }
-
-declare function toggleNode(options: ToggleNodeOptions): Command;
+}): Command;
 export { toggleNode }
 export { toggleNode as toggleNode_alias_1 }
 
-declare interface ToggleNodeOptions {
-    type: string | NodeType;
-    attrs?: Attrs | null;
-}
-export { ToggleNodeOptions }
-export { ToggleNodeOptions as ToggleNodeOptions_alias_1 }
-
 declare type Tuple5<T> = [T, T, T, T, T];
 
 declare function union<E extends Extension | Extension[]>(extension: E): SimplifyExtension<E>;
@@ -685,4 +716,9 @@ declare function withPriority<T extends Extension>(extension: T, priority: Prior
 export { withPriority }
 export { withPriority as withPriority_alias_1 }
 
+export declare function wrap({ nodeType, attrs, }: {
+    nodeType: NodeType;
+    attrs?: Attrs | null;
+}): Command;
+
 export { }

package/dist/prosekit-core.d.ts

@@ -1,15 +1,11 @@
 export { addMark } from './_tsup-dts-rollup';
-export { AddMarkOptions } from './_tsup-dts-rollup';
+export { insertNode } from './_tsup-dts-rollup';
+export { setBlockType } from './_tsup-dts-rollup';
 export { toggleMark } from './_tsup-dts-rollup';
-export { ToggleMarkOptions } from './_tsup-dts-rollup';
 export { toggleNode } from './_tsup-dts-rollup';
-export { ToggleNodeOptions } from './_tsup-dts-rollup';
 export { Editor } from './_tsup-dts-rollup';
 export { createEditor } from './_tsup-dts-rollup';
 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 { union } from './_tsup-dts-rollup';
 export { withPriority } from './_tsup-dts-rollup';
 export { ProseKitError_alias_1 as ProseKitError } from './_tsup-dts-rollup';
@@ -37,6 +33,9 @@ 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 { Facet } from './_tsup-dts-rollup';
+export { FacetExtension } from './_tsup-dts-rollup';
+export { FacetOptions } from './_tsup-dts-rollup';
 export { CommandArgs } from './_tsup-dts-rollup';
 export { Extension } from './_tsup-dts-rollup';
 export { ExtractCommandAppliers } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -36,23 +36,8 @@ function addMark(options) {
   };
 }
 
-// src/commands/toggle-mark.ts
-import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
-import "@prosekit/pm/model";
-import "@prosekit/pm/state";
-function toggleMark(options) {
-  return (state, dispatch, view) => {
-    return baseToggleMark(
-      getMarkType(state.schema, options.type),
-      options.attrs
-    )(state, dispatch, view);
-  };
-}
-
-// src/commands/toggle-node.ts
-import { setBlockType } from "@prosekit/pm/commands";
-import "@prosekit/pm/model";
-import "@prosekit/pm/state";
+// src/commands/insert-node.ts
+import { insertPoint } from "@prosekit/pm/transform";
 
 // src/utils/get-node-type.ts
 import "@prosekit/pm/model";
@@ -67,6 +52,108 @@ function getNodeType(schema, type) {
   return type;
 }
 
+// src/commands/insert-node.ts
+function insertNode(options) {
+  return (state, dispatch) => {
+    var _a;
+    const node = options.node ? options.node : options.type ? getNodeType(state.schema, options.type).createChecked(options.attrs) : null;
+    if (!node) {
+      throw new ProseKitError("You must provide either a node or a type");
+    }
+    const insertPos = insertPoint(
+      state.doc,
+      (_a = options.pos) != null ? _a : state.selection.to,
+      node.type
+    );
+    if (insertPos == null)
+      return false;
+    if (dispatch) {
+      const tr = state.tr.insert(insertPos, node);
+      dispatch(tr);
+    }
+    return true;
+  };
+}
+
+// src/commands/set-block-type.ts
+import "@prosekit/pm/state";
+
+// src/utils/get-custom-selection.ts
+import { TextSelection } from "@prosekit/pm/state";
+function getCustomSelection(state, from, to) {
+  const pos = from != null ? from : to;
+  if (pos != null) {
+    const $from = state.doc.resolve(from != null ? from : pos);
+    const $to = state.doc.resolve(to != null ? to : pos);
+    return TextSelection.between($from, $to);
+  }
+  return state.selection;
+}
+
+// src/commands/set-block-type.ts
+function setBlockType(options) {
+  return (state, dispatch) => {
+    const nodeType = getNodeType(state.schema, options.type);
+    const selection = getCustomSelection(state, options.from, options.to);
+    const attrs = options.attrs;
+    let applicable = false;
+    for (let i = 0; i < selection.ranges.length && !applicable; i++) {
+      const {
+        $from: { pos: from },
+        $to: { pos: to }
+      } = selection.ranges[i];
+      state.doc.nodesBetween(from, to, (node, pos) => {
+        if (applicable)
+          return false;
+        if (!node.isTextblock || node.hasMarkup(nodeType, attrs))
+          return;
+        if (node.type == nodeType) {
+          applicable = true;
+        } else {
+          const $pos = state.doc.resolve(pos), index = $pos.index();
+          applicable = $pos.parent.canReplaceWith(index, index + 1, nodeType);
+        }
+      });
+    }
+    if (!applicable)
+      return false;
+    if (dispatch) {
+      const tr = state.tr;
+      for (const range of selection.ranges) {
+        const {
+          $from: { pos: from },
+          $to: { pos: to }
+        } = range;
+        tr.setBlockType(from, to, nodeType, attrs);
+      }
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+}
+
+// src/commands/toggle-mark.ts
+import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+function toggleMark({
+  type,
+  attrs
+}) {
+  return (state, dispatch, view) => {
+    return baseToggleMark(getMarkType(state.schema, type), attrs)(
+      state,
+      dispatch,
+      view
+    );
+  };
+}
+
+// src/commands/toggle-node.ts
+import { setBlockType as setBlockType2 } from "@prosekit/pm/commands";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+
 // src/utils/object-euqal.ts
 function objectEqual(a, b) {
   if (a === b) {
@@ -111,17 +198,20 @@ function isNodeActive(state, type, attrs) {
 }
 
 // src/commands/toggle-node.ts
-function toggleNode(options) {
+function toggleNode({
+  type,
+  attrs
+}) {
   return (state, dispatch, view) => {
-    if (isNodeActive(state, options.type, options.attrs)) {
+    if (isNodeActive(state, type, attrs)) {
       const defaultType = state.schema.topNodeType.contentMatch.defaultType;
       if (!defaultType) {
         return false;
       }
-      return setBlockType(defaultType)(state, dispatch, view);
+      return setBlockType2(defaultType)(state, dispatch, view);
     } else {
-      const nodeType = getNodeType(state.schema, options.type);
-      return setBlockType(nodeType, options.attrs)(state, dispatch, view);
+      const nodeType = getNodeType(state.schema, type);
+      return setBlockType2(nodeType, attrs)(state, dispatch, view);
     }
   };
 }
@@ -161,16 +251,18 @@ function getFacetCount() {
   return facetCount;
 }
 var Facet = class _Facet {
-  constructor(converter, next) {
+  constructor(converter, next, singleton) {
     /** @internal */
     this.index = facetCount++;
     this.converter = converter;
     this.next = next;
+    this.singleton = singleton;
   }
   static define({
     converter,
     convert,
-    next
+    next,
+    singleton
   }) {
     const converterFunction = converter ? converter : convert ? () => ({
       create: convert,
@@ -179,7 +271,7 @@ var Facet = class _Facet {
     if (!converterFunction) {
       throw new ProseKitError("Facet must have either 'convert' or 'converter'");
     }
-    return new _Facet(converterFunction, next);
+    return new _Facet(converterFunction, next, singleton != null ? singleton : false);
   }
   /** @internal */
   static defineRootFacet(options) {
@@ -476,7 +568,7 @@ function updateExtension(prevInputs, prevConverters, extension, mode) {
     }
     const inputTuple = modifyInputTuple(prevInputs[index], inputs[index]);
     prevInputs[index] = inputTuple;
-    if (facet.next) {
+    if (facet.next && !facet.singleton) {
       let hasOutput = false;
       const outputTuple = [[], [], [], [], []];
       for (let pri = 0; pri < 5; pri++) {
@@ -511,35 +603,43 @@ function updateExtension(prevInputs, prevConverters, extension, mode) {
       continue;
     } else {
       const inputArray = flattenInputTuple(inputTuple);
-      const converterTuple = prevConverters[index] || (prevConverters[index] = [
+      prevConverters[index] || (prevConverters[index] = [
         void 0,
         void 0,
         void 0,
         void 0,
         void 0
       ]);
-      const prevConverter = converterTuple[2 /* default */];
+      const prevConverter = prevConverters[index][2 /* default */];
       const converter = prevConverter || facet.converter();
       prevConverters[index][2 /* default */] = converter;
       const output = prevConverter ? converter.update(inputArray) : converter.create(inputArray);
       if (!output) {
         continue;
       }
-      switch (facet) {
-        case schemaFacet:
-          schemaInput = output;
-          break;
-        case stateFacet:
-          stateInput = output;
-          break;
-        case viewFacet:
-          viewInput = output;
-          break;
-        case commandFacet:
-          commandInput = output;
-          break;
-        default:
-          throw new ProseKitError("Invalid root facet");
+      if (facet.next) {
+        const outputTuple = [[], [], [output], [], []];
+        inputs[facet.next.index] = modifyInputTuple(
+          inputs[facet.next.index],
+          outputTuple
+        );
+      } else {
+        switch (facet) {
+          case schemaFacet:
+            schemaInput = output;
+            break;
+          case stateFacet:
+            stateInput = output;
+            break;
+          case viewFacet:
+            viewInput = output;
+            break;
+          case commandFacet:
+            commandInput = output;
+            break;
+          default:
+            throw new ProseKitError("Invalid root facet");
+        }
       }
     }
   }
@@ -775,78 +875,81 @@ function withPriority(extension, priority) {
   return { extension, priority };
 }
 
-// src/extensions/command.ts
-import "@prosekit/pm/model";
+// src/commands/insert-text.ts
+function insertText({
+  text,
+  from,
+  to
+}) {
+  return (state, dispatch) => {
+    if (text) {
+      dispatch == null ? void 0 : dispatch(state.tr.insertText(text, from, to));
+    }
+    return true;
+  };
+}
+
+// src/commands/select-all.ts
 import { AllSelection } from "@prosekit/pm/state";
-import { findWrapping, insertPoint } from "@prosekit/pm/transform";
+function selectAll() {
+  return (state, dispatch) => {
+    dispatch == null ? void 0 : dispatch(state.tr.setSelection(new AllSelection(state.doc)));
+    return true;
+  };
+}
+
+// src/commands/wrap.ts
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+import { findWrapping } from "@prosekit/pm/transform";
+function wrap({
+  nodeType,
+  attrs
+}) {
+  return (state, dispatch) => {
+    const { $from, $to } = state.selection;
+    const range = $from.blockRange($to);
+    if (!range)
+      return false;
+    const wrapping = findWrapping(range, nodeType, attrs);
+    if (!wrapping)
+      return false;
+    dispatch == null ? void 0 : dispatch(state.tr.wrap(range, wrapping));
+    return true;
+  };
+}
+
+// src/extensions/actions.ts
+import "@prosekit/pm/model";
+import { Selection as Selection2 } from "@prosekit/pm/state";
+import { insertPoint as insertPoint2 } from "@prosekit/pm/transform";
+function insertNode2({
+  node,
+  pos
+}) {
+  return ({ tr }) => {
+    const insertPos = insertPoint2(tr.doc, pos != null ? pos : tr.selection.to, node.type);
+    if (insertPos == null) {
+      return false;
+    }
+    tr.insert(insertPos, node);
+    const $pos = tr.doc.resolve(insertPos);
+    tr.setSelection(Selection2.near($pos));
+    return true;
+  };
+}
+
+// src/extensions/command.ts
 function defineCommands(commands) {
   return commandFacet.extension([commands]);
 }
 function defineBaseCommands() {
   return defineCommands({
-    insertText: ({
-      text,
-      from,
-      to
-    }) => {
-      return (state, dispatch) => {
-        if (text) {
-          dispatch == null ? void 0 : dispatch(state.tr.insertText(text, from, to));
-        }
-        return true;
-      };
-    },
-    insertNode: ({ node, pos }) => {
-      return (state, dispatch) => {
-        const insertPos = insertPoint(
-          state.doc,
-          pos != null ? pos : state.selection.to,
-          node.type
-        );
-        if (insertPos == null)
-          return false;
-        if (dispatch) {
-          const tr = state.tr.insert(insertPos, node);
-          dispatch(tr);
-        }
-        return true;
-      };
-    },
-    wrap: ({
-      nodeType,
-      attrs
-    }) => {
-      return (state, dispatch) => {
-        const { $from, $to } = state.selection;
-        const range = $from.blockRange($to);
-        if (!range)
-          return false;
-        const wrapping = findWrapping(range, nodeType, attrs);
-        if (!wrapping)
-          return false;
-        dispatch == null ? void 0 : dispatch(state.tr.wrap(range, wrapping));
-        return true;
-      };
-    },
-    setBlockType: ({
-      nodeType,
-      attrs,
-      from,
-      to
-    }) => {
-      return (state, dispatch) => {
-        from = from != null ? from : state.selection.from;
-        to = from != null ? from : state.selection.from;
-        dispatch == null ? void 0 : dispatch(state.tr.setBlockType(from, to, nodeType, attrs));
-        return true;
-      };
-    },
-    selectAll: () => {
-      return (state, dispatch) => {
-        dispatch == null ? void 0 : dispatch(state.tr.setSelection(new AllSelection(state.doc)));
-        return true;
-      };
-    }
+    insertText,
+    insertNode: insertNode2,
+    wrap,
+    setBlockType,
+    selectAll
   });
 }
 
@@ -944,7 +1047,8 @@ var eventFacet = Facet.define({
       }
     };
   },
-  next: pluginFacet
+  next: pluginFacet,
+  singleton: true
 });
 var pluginKey = new PluginKey("prosekit-event-handler");
 
@@ -988,7 +1092,8 @@ var keymapFacet = Facet.define({
       }
     };
   },
-  next: pluginFacet
+  next: pluginFacet,
+  singleton: true
 });
 function mergeKeymaps(keymaps) {
   const bindings = {};
@@ -1160,7 +1265,9 @@ export {
   defineText,
   getMarkType,
   getNodeType,
+  insertNode,
   pluginFacet,
+  setBlockType,
   toggleMark,
   toggleNode,
   union,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "private": false,
   "author": {
     "name": "ocavue",

package/src/index.ts

@@ -1,8 +1,9 @@
-export { addMark, type AddMarkOptions } from './commands/add-mark'
-export { toggleMark, type ToggleMarkOptions } from './commands/toggle-mark'
-export { toggleNode, type ToggleNodeOptions } from './commands/toggle-node'
+export { addMark } from './commands/add-mark'
+export { insertNode } from './commands/insert-node'
+export { setBlockType } from './commands/set-block-type'
+export { toggleMark } from './commands/toggle-mark'
+export { toggleNode } from './commands/toggle-node'
 export { Editor, createEditor, type EditorOptions } from './editor/editor'
-export { Facet, FacetExtension, type FacetOptions } from './facets/facet'
 export { union } from './editor/type-utils'
 export { withPriority } from './editor/with-priority'
 export { ProseKitError } from './error'
@@ -34,6 +35,7 @@ export {
   type PluginPayload,
 } from './extensions/plugin'
 export { defineText } from './extensions/text'
+export { Facet, FacetExtension, type FacetOptions } from './facets/facet'
 export { type CommandArgs as CommandArgs } from './types/command'
 export {
   type Extension,