@kerebron/editor 0.5.2 → 0.5.4

package/src/ExtensionManager.ts

@@ -49,9 +49,7 @@ export class ExtensionManager {
 
   public converters: Record<string, Converter> = {};
 
-  private debug = true;
-
-  constructor(public readonly editorKits: EditorKit[]) {
+  constructor(public readonly editorKits: EditorKit[], private debug = false) {
     const extensions: AnyExtensionOrReq[] = editorKits
       .reduce(
         (prev: AnyExtensionOrReq[], cur) => prev.concat(cur.getExtensions()),
@@ -192,6 +190,12 @@ export class ExtensionManager {
     const createMap = (extensions: Set<AnyExtensionOrReq>) => {
       for (const extension of extensions) {
         if ('name' in extension) {
+          const existing = allExtensions.get(extension.name);
+          if (
+            existing && 'type' in existing && extension.type !== existing.type
+          ) {
+            throw new Error(`Duplicate mark/node: ${extension.name}`);
+          }
           allExtensions.set(extension.name, extension);
         }
         if ('requires' in extension) {
@@ -208,7 +212,9 @@ export class ExtensionManager {
     const initialized: Set<string> = new Set();
 
     const initializeExtension = (extension: AnyExtension) => {
-      console.info(`Initialize ${extension.type} ${extension.name}`);
+      if (this.debug) {
+        console.info(`Initialize ${extension.type} ${extension.name}`);
+      }
       this.extensions.add(extension);
     };
 

package/src/commands/CommandManager.ts

@@ -1,5 +1,5 @@
 import { EditorView } from 'prosemirror-view';
-import type { EditorState, Transaction } from 'prosemirror-state';
+import type { Transaction } from 'prosemirror-state';
 
 import type { CoreEditor } from '../CoreEditor.js';
 import { createChainableState } from './createChainableState.js';

package/src/commands/types.ts

@@ -1,4 +1,9 @@
-import type { Command as PmCommand } from 'prosemirror-state';
+import type {
+  Command as PmCommand,
+  EditorState,
+  Transaction,
+} from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
 
 interface Command extends PmCommand {
   displayName?: string;
@@ -9,6 +14,13 @@ export type { Command };
 
 export type CommandFactory = (...args: any[]) => Command;
 
+export type AsyncCommand = (
+  state: EditorState,
+  dispatch?: (tr: Transaction) => void,
+  view?: EditorView,
+) => Promise<boolean>;
+export type AsyncCommandFactory = (...args: any[]) => AsyncCommand;
+
 export interface Commands {
   [name: string]: Command;
 }

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

@@ -205,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') {
@@ -217,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;
@@ -238,11 +238,11 @@ export const runInputRulesTexts: CommandFactory = () => {
       }
     }
 
-    if (dispatch && tr.docChanged) {
+    if (dispatch) {
       dispatch(tr);
     }
 
-    return true;
+    return tr.docChanged;
   };
 
   cmd.displayName = 'runInputRulesTexts';

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

@@ -1,12 +1,5 @@
-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';
@@ -120,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/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/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 const NESTING_OPENING = 1;
+export const NESTING_SELF_CLOSING = 0;
+export const NESTING_CLOSING = -1;
+
 export interface EditorKit {
   getExtensions(): AnyExtensionOrReq[];
 }
@@ -55,6 +59,7 @@ export interface UrlRewriteContext {
   type: 'IMG' | 'A';
   dest: string; // Dest format, eg: kerebron, md, odt
   filesMap?: Record<string, Uint8Array>;
+  setMeta?: (key: string, val: string) => void;
 }
 
 export type UrlRewriter = (

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;
@@ -79,6 +90,25 @@ export class SmartOutput<K> {
     return this._pos;
   }
 
+  backspace(count: number) {
+    const metasToRestore: Array<OutputMeta<K>> = [];
+    const chunksToRestore: Array<string> = [];
+    while (count > 0 && this.chunks[0].length > 0) {
+      const lastMeta = this.metas.pop();
+      let lastChunk = this.chunks.pop();
+      if (!lastChunk || !lastMeta) {
+        break;
+      }
+      const origLen = lastChunk.length;
+      lastChunk = lastChunk.substring(0, Math.max(0, lastChunk.length - count));
+      metasToRestore.unshift(lastMeta);
+      chunksToRestore.unshift(lastChunk);
+      count -= origLen - lastChunk.length;
+    }
+    this.chunks.push(...chunksToRestore);
+    this.metas.push(...metasToRestore);
+  }
+
   endsWith(text: string) {
     return this.chunks.join('').endsWith(text);
   }