@kerebron/editor 0.4.31 → 0.5.0

package/src/plugins/input-rules/InputRulesPlugin.ts

@@ -25,6 +25,7 @@ type PluginState = {
 export class InputRule {
   /// @internal
   handler: (
+    tr: Transaction,
     state: EditorState,
     match: RegExpMatchArray,
     start: number,
@@ -52,10 +53,11 @@ export class InputRule {
   /// rule's effect, or null to indicate the input was not handled.
   constructor(
     /// @internal
-    readonly match: RegExp,
+    readonly regex: RegExp,
     handler:
       | string
       | ((
+        tr: Transaction,
         state: EditorState,
         match: RegExpMatchArray,
         start: number,
@@ -72,7 +74,7 @@ export class InputRule {
       inCode?: boolean | 'only';
     } = {},
   ) {
-    this.match = match;
+    this.regex = regex;
     this.handler = typeof handler == 'string'
       ? stringHandler(handler)
       : handler;
@@ -83,11 +85,16 @@ export class InputRule {
 
 function stringHandler(string: string) {
   return function (
+    tr: Transaction,
     state: EditorState,
     match: RegExpMatchArray,
     start: number,
     end: number,
   ) {
+    if (!tr) {
+      tr = state.tr;
+    }
+
     let insert = string;
     if (match[1]) {
       const offset = match[0].lastIndexOf(match[1]);
@@ -99,7 +106,7 @@ function stringHandler(string: string) {
         start = end;
       }
     }
-    return state.tr.insertText(insert, start, end);
+    return tr.insertText(insert, start, end);
   };
 }
 
@@ -124,7 +131,7 @@ export class InputRulesPlugin extends Plugin<PluginState> {
 
       props: {
         handleTextInput(view, from, to, text) {
-          const cmd = runInputRules(from, to, text, rules);
+          const cmd = runInputRulesRange(from, to, text);
           const dispatch = (tr: Transaction) => {
             view.dispatch(tr);
           };
@@ -136,28 +143,115 @@ export class InputRulesPlugin extends Plugin<PluginState> {
             setTimeout(() => {
               const { $cursor } = view.state.selection as TextSelection;
               if ($cursor) {
-                const cmd = runInputRules($cursor.pos, $cursor.pos, '', rules);
+                const cmd = runInputRulesRange($cursor.pos, $cursor.pos, '');
                 const dispatch = (tr: Transaction) => {
                   view.dispatch(tr);
                 };
                 return cmd(view.state, dispatch, view);
-                // run(view, $cursor.pos, $cursor.pos, '', rules, this);
+                // run(view, $cursor.pos, $cursor.pos, '', this);
               }
             });
           },
         },
       },
 
+      rules,
       isInputRules: true,
     });
   }
 }
 
-export const runInputRules: CommandFactory = (
+export const runInputRulesTexts: CommandFactory = () => {
+  const cmd: Command = (
+    state: EditorState,
+    dispatch?: (tr: Transaction) => void,
+    view?: EditorView,
+  ) => {
+    const plugins = state.plugins;
+    const plugin: InputRulesPlugin | undefined = plugins.find((plugin) =>
+      (plugin.spec as any).isInputRules
+    );
+    if (!plugin) {
+      return false;
+    }
+
+    const rules: readonly InputRule[] = plugin.spec.rules;
+
+    if (view?.composing) return false;
+
+    let doc = state.doc;
+    let tr = state.tr;
+
+    for (let i = 0; i < rules.length; i++) {
+      const rule = rules[i];
+
+      const textNodePositions: { pos: number; node: ProseMirrorNode }[] = [];
+      doc.descendants((node, pos) => {
+        if (node.isText) {
+          textNodePositions.push({ pos, node });
+        }
+      });
+
+      if (textNodePositions.length === 0) {
+        return false; // Nothing to do
+      }
+
+      // Process from the end of the document to the start to avoid position invalidation
+      for (let i = textNodePositions.length - 1; i >= 0; i--) {
+        const { pos, node } = textNodePositions[i];
+        if (!node.isText || !node.text) continue;
+
+        let text = node.text;
+
+        // throw new Error('aaaaaaaaaaa');
+
+        if (node.type.spec.code) {
+          if (!rule.inCode) continue;
+        } else if (rule.inCode === 'only') {
+          continue;
+        }
+        const match = rule.regex.exec(text);
+        if (!match) {
+          continue;
+        }
+
+        const from = pos;
+        const to = pos + node.nodeSize;
+
+        let subTr = rule.handler(
+          tr,
+          state,
+          match,
+          from - (match[0].length - text.length),
+          to,
+        );
+        if (!subTr) continue;
+
+        tr = subTr;
+        doc = tr.doc;
+
+        if (rule.undoable) {
+          tr.setMeta(plugin, { transform: tr, from, to, text });
+        }
+      }
+    }
+
+    if (dispatch && tr.docChanged) {
+      dispatch(tr);
+    }
+
+    return true;
+  };
+
+  cmd.displayName = 'runInputRulesTexts';
+
+  return cmd;
+};
+
+export const runInputRulesRange: CommandFactory = (
   from: number,
   to: number,
   text: string,
-  rules: readonly InputRule[],
 ) => {
   const cmd: Command = (
     state: EditorState,
@@ -172,6 +266,8 @@ export const runInputRules: CommandFactory = (
       return false;
     }
 
+    const rules: readonly InputRule[] = plugin.spec.rules;
+
     if (view?.composing) return false;
     const $from = state.doc.resolve(from);
     const textBefore = $from.parent.textBetween(
@@ -180,6 +276,7 @@ export const runInputRules: CommandFactory = (
       null,
       '\ufffc',
     ) + text;
+    let tr = state.tr;
     for (let i = 0; i < rules.length; i++) {
       const rule = rules[i];
       if ($from.parent.type.spec.code) {
@@ -187,19 +284,33 @@ export const runInputRules: CommandFactory = (
       } else if (rule.inCode === 'only') {
         continue;
       }
-      const match = rule.match.exec(textBefore);
-      const tr = match &&
-        rule.handler(state, match, from - (match[0].length - text.length), to);
-      if (!tr) continue;
+      const match = rule.regex.exec(textBefore);
+      if (!match) {
+        continue;
+      }
+
+      const subTr = rule.handler(
+        tr,
+        state,
+        match,
+        from - (match[0].length - text.length),
+        to,
+      );
+      if (!subTr) continue;
+
+      tr = subTr;
       if (rule.undoable) {
         tr.setMeta(plugin, { transform: tr, from, to, text });
       }
-      view?.dispatch(tr);
-      return true;
     }
+
+    if (dispatch) {
+      dispatch(tr);
+    }
+
     return false;
   };
-  cmd.displayName = 'runInputRules';
+  cmd.displayName = 'runInputRulesRange';
 
   return cmd;
 };

package/src/plugins/input-rules/rulebuilders.ts

@@ -1,5 +1,12 @@
-import { canJoin, findWrapping } from 'prosemirror-transform';
-import { Attrs, Fragment, Node, NodeType, Slice } from 'prosemirror-model';
+import { canJoin, findWrapping, replaceStep } from 'prosemirror-transform';
+import {
+  Attrs,
+  Fragment,
+  Node,
+  NodeType,
+  ResolvedPos,
+  Slice,
+} from 'prosemirror-model';
 
 import { InputRule } from './InputRulesPlugin.js';
 
@@ -24,9 +31,12 @@ export function wrappingInputRule(
   getAttrs: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null) = null,
   joinPredicate?: (match: RegExpMatchArray, node: Node) => boolean,
 ) {
-  return new InputRule(regexp, (state, match, start, end) => {
+  return new InputRule(regexp, (tr, state, match, start, end) => {
+    if (!tr) {
+      tr = state.tr;
+    }
     const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
-    const tr = state.tr.delete(start, end);
+    tr = tr.delete(start, end);
     const $start = tr.doc.resolve(start);
     const range = $start.blockRange();
     const wrapping = range && findWrapping(range, nodeType, attrs);
@@ -54,7 +64,10 @@ export function textblockTypeInputRule(
   nodeType: NodeType,
   getAttrs: Attrs | null | ((match: RegExpMatchArray) => Attrs | null) = null,
 ) {
-  return new InputRule(regexp, (state, match, start, end) => {
+  return new InputRule(regexp, (tr, state, match, start, end) => {
+    if (!tr) {
+      tr = state.tr;
+    }
     const $start = state.doc.resolve(start);
     const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
     if (
@@ -64,7 +77,7 @@ export function textblockTypeInputRule(
         nodeType,
       )
     ) return null;
-    return state.tr
+    return tr
       .delete(start, end)
       .setBlockType(start, start, nodeType, attrs);
   });
@@ -75,14 +88,18 @@ export function replaceInlineNode(
   nodeType: NodeType,
   getAttrs: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null) = null,
 ) {
-  return new InputRule(regexp, (state, match, start, end) => {
+  return new InputRule(regexp, (tr, state, match, start, end) => {
+    if (!tr) {
+      tr = state.tr;
+    }
+
     const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+
     const node = nodeType.createAndFill(attrs);
-    const slice = new Slice(Fragment.from(node), 0, 0);
 
-    const tr = state.tr;
     const from = tr.mapping.map(start);
     const to = tr.mapping.map(end);
-    return tr.replace(from, to, slice);
+
+    return tr.replaceWith(from, to, Fragment.from(node));
   });
 }

package/src/types.ts

@@ -3,6 +3,10 @@ import type { Extension } from './Extension.js';
 import type { Mark } from './Mark.js';
 import type { Node } from './Node.js';
 
+export interface EditorKit {
+  getExtensions(): AnyExtensionOrReq[];
+}
+
 export type AnyExtension = Extension | Node | Mark;
 export type AnyExtensionOrReq = AnyExtension | {
   requires: Array<AnyExtensionOrReq | string>;
@@ -10,18 +14,6 @@ export type AnyExtensionOrReq = AnyExtension | {
 
 export type Content = JSONContent | JSONContent[] | null;
 
-export interface EditorConfig {
-  element: HTMLElement;
-  content: Content;
-  parseOptions: ParseOptions;
-  extensions: AnyExtensionOrReq[];
-  cdnUrl?: string;
-  uri?: string;
-  languageID?: string;
-  topNode?: string;
-  readOnly?: boolean;
-}
-
 export type JSONContent = {
   type?: string;
   attrs?: Record<string, any>;

package/src/utilities/createNodeFromContent.ts

@@ -19,9 +19,9 @@ export function createNodeFromObject(
     }
 
     return node;
-  } catch (error) {
+  } catch (error: any) {
     if (options?.errorOnInvalidContent) {
-      throw new Error('Invalid JSON content', {
+      throw new Error('Invalid JSON content: ' + error.message, {
         cause: error as Error,
       });
     }