@prosekit/core 0.0.13 → 0.0.14

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

@@ -1,4 +1,5 @@
 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';
@@ -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';
@@ -30,11 +33,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 +44,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,19 +122,14 @@ declare function defineBaseCommands(): Extension<{
             to?: number | undefined;
         }];
         insertNode: [{
-            node: ProseMirrorNode;
+            node: Node_2;
             pos?: number | undefined;
         }];
         wrap: [{
-            nodeType: NodeType;
-            attrs?: Attrs | null | undefined;
-        }];
-        setBlockType: [{
-            nodeType: NodeType;
-            attrs?: Attrs | null | undefined;
-            from?: number | undefined;
-            to?: number | undefined;
+            nodeType: NodeType_2;
+            attrs?: Attrs_2 | null | undefined;
         }];
+        setBlockType: [nodeType: NodeType_2, attrs?: Attrs_2 | null | undefined];
         selectAll: [];
     };
 }>;
@@ -432,11 +426,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 +581,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 +596,13 @@ declare interface SelectionJson {
 export { SelectionJson }
 export { SelectionJson as SelectionJson_alias_1 }
 
+export declare function setBlockType({ nodeType, attrs, from, to, }: {
+    nodeType: NodeType;
+    attrs?: Attrs | null;
+    from?: number;
+    to?: number;
+}): Command;
+
 /**
  * @internal
  */
@@ -635,28 +657,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 +699,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,9 +1,7 @@
 export { addMark } from './_tsup-dts-rollup';
-export { AddMarkOptions } from './_tsup-dts-rollup';
 export { toggleMark } from './_tsup-dts-rollup';
-export { ToggleMarkOptions } from './_tsup-dts-rollup';
+export { insertNode } 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';

package/dist/prosekit-core.js

@@ -40,19 +40,21 @@ function addMark(options) {
 import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
 import "@prosekit/pm/model";
 import "@prosekit/pm/state";
-function toggleMark(options) {
+function toggleMark({
+  type,
+  attrs
+}) {
   return (state, dispatch, view) => {
-    return baseToggleMark(
-      getMarkType(state.schema, options.type),
-      options.attrs
-    )(state, dispatch, view);
+    return baseToggleMark(getMarkType(state.schema, type), 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 +69,34 @@ 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/toggle-node.ts
+import { setBlockType } 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 +141,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);
     } else {
-      const nodeType = getNodeType(state.schema, options.type);
-      return setBlockType(nodeType, options.attrs)(state, dispatch, view);
+      const nodeType = getNodeType(state.schema, type);
+      return setBlockType(nodeType, attrs)(state, dispatch, view);
     }
   };
 }
@@ -776,77 +809,83 @@ function withPriority(extension, priority) {
 }
 
 // src/extensions/command.ts
-import "@prosekit/pm/model";
+import { setBlockType as setBlockType2 } from "@prosekit/pm/commands";
+
+// 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: setBlockType2,
+    selectAll
   });
 }
 
@@ -1160,6 +1199,7 @@ export {
   defineText,
   getMarkType,
   getNodeType,
+  insertNode,
   pluginFacet,
   toggleMark,
   toggleNode,

package/package.json

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

package/src/index.ts

@@ -1,6 +1,7 @@
-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 { toggleMark } from './commands/toggle-mark'
+export { insertNode } from './commands/insert-node'
+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'