@prosekit/extensions 0.0.0-next-20240427133255 → 0.0.0-next-20240427200701

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

@@ -24,13 +24,13 @@ import { Parser } from 'prosemirror-highlight';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
 import { PluginKey } from '@prosekit/pm/state';
 import { ProseMirrorNode } from '@prosekit/pm/model';
-import type { ResolvedPos } from '@prosekit/pm/model';
-import type { Selection as Selection_2 } from '@prosekit/pm/state';
 import type { SpecialLanguage } from 'shiki';
 import { ToggleCollapsedOptions } from 'prosemirror-flat-list';
 import { Transaction } from '@prosekit/pm/state';
 import { UnwrapListOptions } from 'prosemirror-flat-list';
 
+export declare function applyMarkRules(rules: MarkRule[], transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Transaction | null;
+
 declare class AutocompleteRule {
     readonly regex: RegExp;
     readonly onMatch: MatchHandler;
@@ -471,11 +471,8 @@ export declare function defineListSpec(): Extension<{
 }>;
 
 /**
- * A mark rule is something that can automatically apply marks to text if it matches a certain pattern, and remove them if it doesn't match anymore.
- *
- * For every transaction that changes the document, the mark rule will be applied to the changed text.
- *
- *
+ * A mark rule is something that can automatically apply marks to text if it
+ * matches a certain pattern, and remove them if it doesn't match anymore.
  */
 export declare function defineMarkRule(options: MarkRuleOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
@@ -770,20 +767,12 @@ export declare type EnterRuleOptions = {
  */
 export declare const exitTable: Command;
 
-/**
- * @internal
- */
-export declare function findChangedTextRanges(selection: Selection_2): Array<[from: number, to: number]>;
-
-/** @internal */
-export declare function getAffectedRange(transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): readonly [number, number];
+export declare function getCheckRanges(transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Array<[number, number]>;
 
 export { getHighlighter }
 
 export declare function getPluginState(state: EditorState): PredictionPluginState | undefined;
 
-export declare function getSpanTextRanges($from: ResolvedPos, $to: ResolvedPos): [number, number][];
-
 export declare function getTrMeta(tr: Transaction): PredictionPluginState;
 
 export declare interface HeadingAttrs {
@@ -834,9 +823,24 @@ export declare interface LinkAttrs {
 
 export { ListDOMSerializer }
 
-export declare interface MarkRuleOptions {
+/**
+ * @internal
+ */
+export declare class MarkRule {
+    readonly regex: RegExp;
+    readonly type: string | MarkType;
+    readonly getAttrs: (match: RegExpMatchArray) => Attrs | null;
+    constructor({ regex, type, attrs }: MarkRuleOptions);
+}
+
+/**
+ * The options for {@link defineMarkRule}.
+ *
+ * @public
+ */
+declare interface MarkRuleOptions {
     /**
-     * The regular expression to match against. It should have a `g` flag to match
+     * The regular expression to match against. It must has a `g` flag to match
      * all instances of the mark.
      */
     regex: RegExp;
@@ -847,9 +851,13 @@ export declare interface MarkRuleOptions {
     /**
      * Attributes to set on the mark. If a function is provided, it will be called
      * with the matched result from the regular expression.
+     *
+     * @default null
      */
     attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
 }
+export { MarkRuleOptions }
+export { MarkRuleOptions as MarkRuleOptions_alias_1 }
 
 declare type MatchHandler = (options: {
     state: EditorState;

package/dist/prosekit-extensions-mark-rule.d.ts

@@ -1,3 +1,2 @@
 export { defineMarkRule } from './_tsup-dts-rollup';
-export { getAffectedRange } from './_tsup-dts-rollup';
 export { MarkRuleOptions } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-mark-rule.js

@@ -1,15 +1,14 @@
 // src/mark-rule/index.ts
-import {
-  Facet,
-  OBJECT_REPLACEMENT_CHARACTER,
-  getMarkType,
-  pluginFacet
-} from "@prosekit/core";
-import "@prosekit/pm/model";
+import { Facet, pluginFacet } from "@prosekit/core";
 import { ProseMirrorPlugin } from "@prosekit/pm/state";
 
-// src/mark-rule/changed-range.ts
-import { isTextSelection } from "@prosekit/core";
+// src/mark-rule/apply.ts
+import { OBJECT_REPLACEMENT_CHARACTER, getMarkType } from "@prosekit/core";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+
+// src/mark-rule/range.ts
+import "@prosekit/pm/state";
 function getSpanTextRanges($from, $to) {
   const nodeRange = $from.blockRange($to);
   if (!nodeRange) {
@@ -38,12 +37,23 @@ function getSpanTextRanges($from, $to) {
   }
   return ranges;
 }
-
-// src/mark-rule/index.ts
-function defineMarkRule(options) {
-  return markRuleFacet.extension([options]);
+function getInlineTextRange($from, $to) {
+  return [$from.start(), $to.end()];
+}
+function getTextRanges(doc, from, to) {
+  const $from = doc.resolve(from);
+  const $to = doc.resolve(to);
+  if ($from.sameParent($to) && $from.parent.isTextblock) {
+    return [getInlineTextRange($from, $to)];
+  } else {
+    const nodeRange = $from.blockRange($to);
+    if (!nodeRange) {
+      return [];
+    }
+    return getSpanTextRanges($from, $to);
+  }
 }
-function getAffectedRange(transactions, oldState, newState) {
+function getMapRange(transactions, oldState, newState) {
   let lo = oldState.selection.from;
   let hi = oldState.selection.to;
   for (const tr of transactions) {
@@ -60,19 +70,12 @@ function getAffectedRange(transactions, oldState, newState) {
   hi = Math.min(lo, hi, newState.selection.to);
   return [lo, hi];
 }
-function getCheckRanges(doc, from, to) {
-  const $from = doc.resolve(from);
-  const $to = doc.resolve(to);
-  if ($from.sameParent($to)) {
-    return [[$from.start(), $to.end()]];
-  } else {
-    const nodeRange = $from.blockRange($to);
-    if (!nodeRange) {
-      return [];
-    }
-    return getSpanTextRanges($from, $to);
-  }
+function getCheckRanges(transactions, oldState, newState) {
+  const [from, to] = getMapRange(transactions, oldState, newState);
+  return getTextRanges(newState.doc, from, to);
 }
+
+// src/mark-rule/apply.ts
 function getExpectedMarkings(rules, doc, from, to) {
   const text = doc.textBetween(from, to, OBJECT_REPLACEMENT_CHARACTER);
   const result = [];
@@ -80,14 +83,13 @@ function getExpectedMarkings(rules, doc, from, to) {
     rule.regex.lastIndex = 0;
     const matches = text.matchAll(rule.regex);
     const markType = getMarkType(doc.type.schema, rule.type);
-    const getAttrs = rule.attrs;
     for (const match of matches) {
       const index = match.index;
       if (index == null)
         continue;
-      const attrs = getAttrs ? typeof getAttrs === "function" ? getAttrs(match) : getAttrs : null;
+      const attrs = rule.getAttrs(match);
       const mark = markType.create(attrs);
-      result.push([from + index, from + index + match[0].length, mark]);
+      result.push([mark, from + index, from + index + match[0].length]);
     }
   }
   return result;
@@ -96,25 +98,21 @@ function getReceivedMarkings(rules, doc, from, to) {
   const result = [];
   const schema = doc.type.schema;
   const markTypes = rules.map((rule) => getMarkType(schema, rule.type));
-  let seen = false;
-  doc.nodesBetween(from, to, (node) => {
-    if (!node.isTextblock || seen) {
+  doc.nodesBetween(from, to, (node, pos) => {
+    if (!node.isInline) {
       return;
     }
-    seen = true;
-    node.content.forEach((child, offset) => {
-      for (const markType of markTypes) {
-        const mark = child.marks.find((mark2) => mark2.type === markType);
-        if (mark) {
-          result.push([from + offset, from + offset + child.nodeSize, mark]);
-        }
+    for (const markType of markTypes) {
+      const mark = node.marks.find((mark2) => mark2.type === markType);
+      if (mark) {
+        result.push([mark, pos, pos + node.nodeSize]);
       }
-    });
+    }
   });
   return result;
 }
 function markingEquals(a, b) {
-  return a[0] === b[0] && a[1] === b[1] && a[2].eq(b[2]);
+  return a[1] === b[1] && a[2] === b[2] && a[0].eq(b[0]);
 }
 function markingDiffs(a, b) {
   return a.filter((x) => !b.some((y) => markingEquals(x, y)));
@@ -123,13 +121,12 @@ function applyMarkRules(rules, transactions, oldState, newState) {
   if (transactions.length === 0 || transactions.every((tr2) => !tr2.docChanged)) {
     return null;
   }
-  const [from, to] = getAffectedRange(transactions, oldState, newState);
-  const ranges = getCheckRanges(newState.doc, from, to);
+  const ranges = getCheckRanges(transactions, oldState, newState);
   const toRemove = [];
   const toCreate = [];
-  for (const [from2, to2] of ranges) {
-    const expected = getExpectedMarkings(rules, newState.doc, from2, to2);
-    const received = getReceivedMarkings(rules, newState.doc, from2, to2);
+  for (const [from, to] of ranges) {
+    const expected = getExpectedMarkings(rules, newState.doc, from, to);
+    const received = getReceivedMarkings(rules, newState.doc, from, to);
     toRemove.push(...markingDiffs(received, expected));
     toCreate.push(...markingDiffs(expected, received));
   }
@@ -137,14 +134,29 @@ function applyMarkRules(rules, transactions, oldState, newState) {
     return null;
   }
   const tr = newState.tr;
-  for (const [from2, to2, mark] of toRemove) {
-    tr.removeMark(from2, to2, mark);
+  for (const [mark, from, to] of toRemove) {
+    tr.removeMark(from, to, mark);
   }
-  for (const [from2, to2, mark] of toCreate) {
-    tr.addMark(from2, to2, mark);
+  for (const [mark, from, to] of toCreate) {
+    tr.addMark(from, to, mark);
   }
   return tr;
 }
+
+// src/mark-rule/rule.ts
+import "@prosekit/pm/model";
+var MarkRule = class {
+  constructor({ regex, type, attrs = null }) {
+    this.regex = regex;
+    this.type = type;
+    this.getAttrs = typeof attrs === "function" ? attrs : () => attrs;
+  }
+};
+
+// src/mark-rule/index.ts
+function defineMarkRule(options) {
+  return markRuleFacet.extension([new MarkRule(options)]);
+}
 var markRuleFacet = Facet.define({
   converter: () => {
     let rules = [];
@@ -168,6 +180,5 @@ var markRuleFacet = Facet.define({
   next: pluginFacet
 });
 export {
-  defineMarkRule,
-  getAffectedRange
+  defineMarkRule
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/extensions",
   "type": "module",
-  "version": "0.0.0-next-20240427133255",
+  "version": "0.0.0-next-20240427200701",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -152,8 +152,8 @@
     "dist"
   ],
   "dependencies": {
-    "@prosekit/core": "0.0.0-next-20240427133255",
-    "@prosekit/pm": "0.0.0-next-20240427133255",
+    "@prosekit/core": "0.0.0-next-20240427200701",
+    "@prosekit/pm": "0.0.0-next-20240427200701",
     "prosemirror-dropcursor": "^1.8.1",
     "prosemirror-flat-list": "^0.5.0",
     "prosemirror-highlight": "^0.5.0",