@kerebron/editor 0.5.1 → 0.5.3

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

@@ -1,7 +1,8 @@
-import { Fragment, Node as ProseMirrorNode } from 'prosemirror-model';
+import { Node as ProseMirrorNode } from 'prosemirror-model';
 import {
   EditorState,
   Plugin,
+  PluginKey,
   TextSelection,
   Transaction,
 } from 'prosemirror-state';
@@ -116,6 +117,7 @@ function stringHandler(string: string) {
 export class InputRulesPlugin extends Plugin<PluginState> {
   constructor(rules: readonly InputRule[]) {
     super({
+      key: new PluginKey('input-rules'),
       state: {
         init() {
           return null;
@@ -203,8 +205,6 @@ export const runInputRulesTexts: CommandFactory = () => {
 
         let text = node.text;
 
-        // throw new Error('aaaaaaaaaaa');
-
         if (node.type.spec.code) {
           if (!rule.inCode) continue;
         } else if (rule.inCode === 'only') {
@@ -215,14 +215,16 @@ export const runInputRulesTexts: CommandFactory = () => {
           continue;
         }
 
-        const from = pos;
-        const to = pos + node.nodeSize;
+        const index = match.index;
+
+        const from = pos + index;
+        const to = pos + index + match[0].length;
 
         let subTr = rule.handler(
           tr,
           state,
           match,
-          from - (match[0].length - text.length),
+          from,
           to,
         );
         if (!subTr) continue;
@@ -236,11 +238,11 @@ export const runInputRulesTexts: CommandFactory = () => {
       }
     }
 
-    if (dispatch && tr.docChanged) {
+    if (dispatch) {
       dispatch(tr);
     }
 
-    return true;
+    return tr.docChanged;
   };
 
   cmd.displayName = 'runInputRulesTexts';
@@ -269,6 +271,7 @@ export const runInputRulesRange: CommandFactory = (
     const rules: readonly InputRule[] = plugin.spec.rules;
 
     if (view?.composing) return false;
+
     const $from = state.doc.resolve(from);
     const textBefore = $from.parent.textBetween(
       Math.max(0, $from.parentOffset - MAX_MATCH),
@@ -277,6 +280,7 @@ export const runInputRulesRange: CommandFactory = (
       '\ufffc',
     ) + text;
     let tr = state.tr;
+
     for (let i = 0; i < rules.length; i++) {
       const rule = rules[i];
       if ($from.parent.type.spec.code) {
@@ -293,8 +297,8 @@ export const runInputRulesRange: CommandFactory = (
         tr,
         state,
         match,
-        from - (match[0].length - text.length),
-        to,
+        tr.mapping.map(from - (match[0].length - text.length)),
+        tr.mapping.map(to),
       );
       if (!subTr) continue;
 
@@ -302,10 +306,12 @@ export const runInputRulesRange: CommandFactory = (
       if (rule.undoable) {
         tr.setMeta(plugin, { transform: tr, from, to, text });
       }
+      break;
     }
 
-    if (dispatch) {
-      dispatch(tr);
+    if (tr.docChanged) {
+      dispatch?.(tr);
+      return true;
     }
 
     return false;

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

@@ -1,14 +1,9 @@
-import { canJoin, findWrapping, replaceStep } from 'prosemirror-transform';
-import {
-  Attrs,
-  Fragment,
-  Node,
-  NodeType,
-  ResolvedPos,
-  Slice,
-} from 'prosemirror-model';
+import { Attrs, Fragment, Node, NodeType } from 'prosemirror-model';
+import { canJoin, findWrapping } from 'prosemirror-transform';
 
 import { InputRule } from './InputRulesPlugin.js';
+import { Command } from '../../commands/types.js';
+import { Transaction } from 'prosemirror-state';
 
 /// Build an input rule for automatically wrapping a textblock when a
 /// given string is typed. The `regexp` argument is
@@ -83,6 +78,29 @@ export function textblockTypeInputRule(
   });
 }
 
+export function commandInputRule(
+  regexp: RegExp,
+  command: Command,
+  getAttrs: Attrs | null | ((match: RegExpMatchArray) => Attrs | null) = null,
+) {
+  return new InputRule(regexp, (tr, state, match, start, end) => {
+    if (!tr) {
+      tr = state.tr;
+    }
+    const $start = state.doc.resolve(start);
+
+    const dispatch = (newTr: Transaction) => {
+      tr = newTr;
+      state = state.apply(tr);
+    };
+
+    dispatch(tr.delete(start, end));
+    command(state, dispatch);
+
+    return tr;
+  });
+}
+
 export function replaceInlineNode(
   regexp: RegExp,
   nodeType: NodeType,
@@ -95,6 +113,11 @@ export function replaceInlineNode(
 
     const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
 
+    const $pos = state.doc.resolve(start);
+    if ($pos.parent.type === state.schema.nodes.code_block) {
+      return tr;
+    }
+
     const node = nodeType.createAndFill(attrs);
 
     const from = tr.mapping.map(start);

package/src/plugins/keymap/keymap.ts

@@ -1,4 +1,4 @@
-import { Plugin } from 'prosemirror-state';
+import { Plugin, PluginKey } from 'prosemirror-state';
 import { EditorView } from 'prosemirror-view';
 
 import type { Command } from '../../commands/types.js';
@@ -76,7 +76,10 @@ function modifiers(name: string, event: KeyboardEvent, shift = true) {
 /// the array get to dispatch first).
 export class KeymapPlugin extends Plugin {
   constructor(bindings: { [key: string]: Command }) {
-    super({ props: { handleKeyDown: keydownHandler(bindings) } });
+    super({
+      key: new PluginKey('keymap'),
+      props: { handleKeyDown: keydownHandler(bindings) },
+    });
   }
 }
 

package/src/plugins/keymap/w3c-keyname.ts

@@ -98,7 +98,9 @@ for (let i = 65; i <= 90; i++) {
 
 // For each code that doesn't have a shift-equivalent, copy the base name
 for (const code in base) {
-  if (!shift.hasOwnProperty(code)) shift[code] = base[code];
+  if (!Object.prototype.hasOwnProperty.call(shift, code)) {
+    shift[code] = base[code];
+  }
 }
 
 export function keyName(event: KeyboardEvent) {

package/src/utilities/SmartOutput.ts

@@ -29,6 +29,17 @@ export class SmartOutput<K> {
   private chunks: Array<string> = [];
   private metas: Array<OutputMeta<K>> = [];
 
+  rtrim() {
+    if (this.chunks.length === 0) {
+      return;
+    }
+    const lastText = this.chunks[this.chunks.length - 1];
+    this.chunks[this.chunks.length - 1] = lastText.replace(/[ \t]+$/, '');
+    const delta = lastText.length - this.chunks[this.chunks.length - 1].length;
+    this._colPos -= delta;
+    this._pos -= delta;
+  }
+
   log(text: string, item?: K) {
     if (text.length === 0) {
       return;