@prosekit/core 0.4.1 → 0.4.2

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

@@ -127,6 +127,16 @@ declare interface BaseNodeViewOptions {
 export { BaseNodeViewOptions }
 export { BaseNodeViewOptions as BaseNodeViewOptions_alias_1 }
 
+export declare function baseToggleMark(markType: MarkType, attrs?: Attrs | null, options?: {
+    removeWhenPresent: boolean;
+}): Command;
+
+export declare function cache<T>(fn: () => T): () => T;
+
+declare const canUseRegexLookbehind: () => boolean;
+export { canUseRegexLookbehind }
+export { canUseRegexLookbehind as canUseRegexLookbehind_alias_1 }
+
 declare type ClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;
 export { ClickHandler }
 export { ClickHandler as ClickHandler_alias_1 }
@@ -1087,9 +1097,21 @@ export { isMark }
 export { isMark as isMark_alias_1 }
 
 /**
+ * Returns true if the given mark is missing in some part of the range.
+ * Returns false if the entire range has the given mark.
+ *
  * @internal
  */
-export declare function isMarkActive(state: EditorState, type: string | MarkType, attrs?: Attrs | null): boolean;
+declare function isMarkAbsent(node: ProseMirrorNode, from: number, to: number, markType: MarkType, attrs?: Attrs | null): boolean;
+export { isMarkAbsent }
+export { isMarkAbsent as isMarkAbsent_alias_1 }
+
+/**
+ * @internal
+ */
+declare function isMarkActive(state: EditorState, type: string | MarkType, attrs?: Attrs | null): boolean;
+export { isMarkActive }
+export { isMarkActive as isMarkActive_alias_1 }
 
 export declare function isNodeActive(state: EditorState, type: string | NodeType, attrs?: Attrs | null): boolean;
 
@@ -1233,6 +1255,13 @@ declare interface MarkSpecOptions<MarkName extends string = string> extends Mark
 export { MarkSpecOptions }
 export { MarkSpecOptions as MarkSpecOptions_alias_1 }
 
+/**
+ * @internal
+ */
+declare function maybeRun<T, R = T extends (...args: any[]) => void ? ReturnType<T> : T>(value: T, ...args: T extends (...args: any[]) => void ? Parameters<T> : never): R;
+export { maybeRun }
+export { maybeRun as maybeRun_alias_1 }
+
 /**
  * A function that is called when the editor view is mounted.
  *

package/dist/prosekit-core.d.ts

@@ -93,12 +93,16 @@ 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 { canUseRegexLookbehind } from './_tsup-dts-rollup';
 export { clsx } from './_tsup-dts-rollup';
 export { defaultBlockAt } from './_tsup-dts-rollup';
 export { _getId } from './_tsup-dts-rollup';
 export { getMarkType } from './_tsup-dts-rollup';
 export { getNodeType } from './_tsup-dts-rollup';
 export { isInCodeBlock } from './_tsup-dts-rollup';
+export { isMarkAbsent } from './_tsup-dts-rollup';
+export { isMarkActive } from './_tsup-dts-rollup';
+export { maybeRun } from './_tsup-dts-rollup';
 export { elementFromJSON } from './_tsup-dts-rollup';
 export { elementFromNode } from './_tsup-dts-rollup';
 export { htmlFromJSON } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -252,19 +252,85 @@ function setNodeAttrs(options) {
 }
 
 // src/commands/toggle-mark.ts
-import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
 import "@prosekit/pm/model";
 import "@prosekit/pm/state";
+function markApplies(doc, ranges, type) {
+  for (const { $from, $to } of ranges) {
+    let can = $from.depth == 0 ? doc.inlineContent && doc.type.allowsMarkType(type) : false;
+    doc.nodesBetween($from.pos, $to.pos, (node) => {
+      if (can)
+        return false;
+      can = node.inlineContent && node.type.allowsMarkType(type);
+    });
+    if (can)
+      return true;
+  }
+  return false;
+}
+function baseToggleMark(markType, attrs = null, options) {
+  const removeWhenPresent = (options && options.removeWhenPresent) !== false;
+  return function(state, dispatch) {
+    const { empty, $cursor, ranges } = state.selection;
+    if (empty && !$cursor || !markApplies(state.doc, ranges, markType))
+      return false;
+    if (dispatch) {
+      if ($cursor) {
+        if (markType.isInSet(state.storedMarks || $cursor.marks()))
+          dispatch(state.tr.removeStoredMark(markType));
+        else
+          dispatch(state.tr.addStoredMark(markType.create(attrs)));
+      } else {
+        let add;
+        const tr = state.tr;
+        if (removeWhenPresent) {
+          add = !ranges.some(
+            (r) => state.doc.rangeHasMark(r.$from.pos, r.$to.pos, markType)
+          );
+        } else {
+          add = !ranges.every((r) => {
+            let missing = false;
+            tr.doc.nodesBetween(r.$from.pos, r.$to.pos, (node, pos, parent) => {
+              if (missing)
+                return false;
+              missing = !markType.isInSet(node.marks) && !!parent && parent.type.allowsMarkType(markType) && !(node.isText && /^\s*$/.test(
+                node.textBetween(
+                  Math.max(0, r.$from.pos - pos),
+                  Math.min(node.nodeSize, r.$to.pos - pos)
+                )
+              ));
+            });
+            return !missing;
+          });
+        }
+        for (const { $from, $to } of ranges) {
+          if (!add) {
+            tr.removeMark($from.pos, $to.pos, markType);
+          } else {
+            let from = $from.pos, to = $to.pos;
+            const start = $from.nodeAfter, end = $to.nodeBefore;
+            const spaceStart = start && start.isText ? /^\s*/.exec(start.text)[0].length : 0;
+            const spaceEnd = end && end.isText ? /\s*$/.exec(end.text)[0].length : 0;
+            if (from + spaceStart < to) {
+              from += spaceStart;
+              to -= spaceEnd;
+            }
+            tr.addMark(from, to, markType.create(attrs));
+          }
+        }
+        dispatch(tr.scrollIntoView());
+      }
+    }
+    return true;
+  };
+}
 function toggleMark({
   type,
   attrs
 }) {
   return (state, dispatch, view) => {
-    return baseToggleMark(getMarkType(state.schema, type), attrs)(
-      state,
-      dispatch,
-      view
-    );
+    return baseToggleMark(getMarkType(state.schema, type), attrs, {
+      removeWhenPresent: false
+    })(state, dispatch, view);
   };
 }
 
@@ -792,6 +858,18 @@ function updateExtension(prevInputs, prevConverters, extension, mode) {
 // src/editor/builder.ts
 import "@prosekit/pm/model";
 
+// src/utils/is-mark-absent.ts
+function isMarkAbsent(node, from, to, markType, attrs) {
+  const mark = attrs ? markType.create(attrs) : markType;
+  let missing = false;
+  node.nodesBetween(from, to, (node2, pos, parent) => {
+    if (missing)
+      return false;
+    missing = !mark.isInSet(node2.marks) && !!parent && parent.type.allowsMarkType(markType);
+  });
+  return missing;
+}
+
 // src/utils/is-mark-active.ts
 function isMarkActive(state, type, attrs) {
   const { from, $from, to, empty } = state.selection;
@@ -800,26 +878,25 @@ function isMarkActive(state, type, attrs) {
     const mark = attrs ? markType.create(attrs) : markType;
     return !!mark.isInSet(state.storedMarks || $from.marks());
   } else {
-    const markOrType = attrs ? markType.create(attrs) : markType;
-    return state.doc.rangeHasMark(from, to, markOrType);
+    return !isMarkAbsent(state.doc, from, to, markType, attrs);
   }
 }
 
 // src/utils/type-assertion.ts
-import { Mark, ProseMirrorNode } from "@prosekit/pm/model";
+import { Mark, ProseMirrorNode as ProseMirrorNode2 } from "@prosekit/pm/model";
 import {
   AllSelection,
   NodeSelection,
-  TextSelection as TextSelection4
+  TextSelection as TextSelection5
 } from "@prosekit/pm/state";
 function isProseMirrorNode(node) {
-  return node instanceof ProseMirrorNode;
+  return node instanceof ProseMirrorNode2;
 }
 function isMark(mark) {
   return mark instanceof Mark;
 }
 function isTextSelection(sel) {
-  return sel instanceof TextSelection4;
+  return sel instanceof TextSelection5;
 }
 function isNodeSelection(sel) {
   return sel instanceof NodeSelection;
@@ -1931,6 +2008,26 @@ function defineText() {
   });
 }
 
+// src/utils/cache.ts
+function cache(fn) {
+  let result = void 0;
+  return () => {
+    if (result === void 0) {
+      result = fn();
+    }
+    return result;
+  };
+}
+
+// src/utils/can-use-regex-lookbehind.ts
+var canUseRegexLookbehind = cache(() => {
+  try {
+    return "ab".replace(new RegExp("(?<=a)b", "g"), "c") === "ac";
+  } catch (error) {
+    return false;
+  }
+});
+
 // src/utils/clsx.ts
 import clsxLite from "clsx/lite";
 var clsx = clsxLite;
@@ -1960,6 +2057,11 @@ function isInCodeBlock(selection) {
   return isCodeBlockType(selection.$from.parent.type) || isCodeBlockType(selection.$to.parent.type);
 }
 
+// src/utils/maybe-run.ts
+function maybeRun(value, ...args) {
+  return typeof value === "function" ? value(...args) : value;
+}
+
 // src/utils/unicode.ts
 var OBJECT_REPLACEMENT_CHARACTER = "\uFFFC";
 
@@ -1981,6 +2083,7 @@ export {
   ProseKitError,
   getId as _getId,
   addMark,
+  canUseRegexLookbehind,
   clsx,
   createEditor,
   defaultBlockAt,
@@ -2029,6 +2132,8 @@ export {
   isAllSelection,
   isInCodeBlock,
   isMark,
+  isMarkAbsent,
+  isMarkActive,
   isNodeSelection,
   isProseMirrorNode,
   isTextSelection,
@@ -2036,6 +2141,7 @@ export {
   jsonFromNode,
   jsonFromState,
   keymapFacet,
+  maybeRun,
   nodeFromElement,
   nodeFromHTML,
   nodeFromJSON,

package/package.json

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