feat: refactor core

Author: HideInMatrix

packages/core/src/commands/attributes.ts

@@ -6,8 +6,12 @@ import {
   type Transaction,
 } from "@mxm-editor/pm";
 import type { Editor } from "../Editor";
-import type { RawCommands } from "../types";
+import type {
+  Range,
+  RawCommands,
+} from "../types";
 import { getMarkRange } from "../helpers";
+import { clamp } from "../utilities";
 
 function normalizeAttributeNames(attributes: string | string[]) {
   return Array.isArray(attributes) ? attributes : [attributes];
@@ -307,7 +311,42 @@ function resetNodeAttributes(
   return true;
 }
 
-type AttributeCommands = Pick<RawCommands, "updateAttributes" | "resetAttributes">;
+function resolveRange(
+  transaction: Transaction,
+  position?: number | Range,
+) {
+  if (typeof position === "number") {
+    const nextPosition = clamp(position, 0, transaction.doc.content.size);
+
+    return {
+      from: nextPosition,
+      to: nextPosition,
+    };
+  }
+
+  if (position) {
+    const from = clamp(position.from, 0, transaction.doc.content.size);
+    const to = clamp(position.to, from, transaction.doc.content.size);
+
+    return {
+      from,
+      to,
+    };
+  }
+
+  return {
+    from: transaction.selection.from,
+    to: transaction.selection.to,
+  };
+}
+
+type AttributeCommands = Pick<
+  RawCommands,
+  | "updateAttributes"
+  | "resetAttributes"
+  | "setTextDirection"
+  | "unsetTextDirection"
+>;
 
 export function createAttributeCommands(editor: Editor): AttributeCommands {
   return {
@@ -356,5 +395,58 @@ export function createAttributeCommands(editor: Editor): AttributeCommands {
 
         return false;
       },
+    setTextDirection:
+      (
+        direction: "ltr" | "rtl" | "auto",
+        position?: number | Range,
+      ) =>
+      ({ tr, dispatch }) => {
+        const range = resolveRange(tr, position);
+
+        if (!dispatch) {
+          return true;
+        }
+
+        tr.doc.nodesBetween(range.from, range.to, (node, pos) => {
+          if (node.isText || !node.type.spec.attrs?.dir) {
+            return true;
+          }
+
+          tr.setNodeMarkup(pos, undefined, {
+            ...node.attrs,
+            dir: direction,
+          });
+
+          return true;
+        });
+
+        return true;
+      },
+    unsetTextDirection:
+      (position?: number | Range) =>
+      ({ tr, dispatch }) => {
+        const range = resolveRange(tr, position);
+
+        if (!dispatch) {
+          return true;
+        }
+
+        tr.doc.nodesBetween(range.from, range.to, (node, pos) => {
+          if (node.isText || !node.type.spec.attrs?.dir) {
+            return true;
+          }
+
+          const nextAttributes = {
+            ...node.attrs,
+          };
+
+          delete nextAttributes.dir;
+          tr.setNodeMarkup(pos, undefined, nextAttributes);
+
+          return true;
+        });
+
+        return true;
+      },
   };
 }

packages/core/src/commands/content.ts

@@ -9,6 +9,7 @@ import {
 import { selectionToInsertionEnd } from "../helpers";
 import type {
   Content,
+  Range,
   InsertContentAtPosition,
   InsertContentOptions,
   RawCommands,
@@ -84,7 +85,7 @@ function isOnlyBlockContent(fragment: Fragment) {
 
 type ContentCommands = Pick<
   RawCommands,
-  "setContent" | "clearContent" | "insertContent" | "insertContentAt"
+  "setContent" | "clearContent" | "insertContent" | "insertContentAt" | "cut"
 >;
 
 export function createContentCommands(editor: Editor): ContentCommands {
@@ -174,6 +175,31 @@ export function createContentCommands(editor: Editor): ContentCommands {
           selectionToInsertionEnd(tr, startLength, -1);
         }
 
+        return true;
+      },
+    cut:
+      (range: Range, targetPos: number) =>
+      ({ tr }) => {
+        const from = clamp(range.from, 0, tr.doc.content.size);
+        const to = clamp(range.to, from, tr.doc.content.size);
+        const contentSlice = tr.doc.slice(from, to);
+
+        tr.deleteRange(from, to);
+
+        const newPosition = clamp(
+          tr.mapping.map(targetPos),
+          0,
+          tr.doc.content.size,
+        );
+
+        tr.insert(newPosition, contentSlice.content);
+        tr.setSelection(
+          Selection.near(
+            tr.doc.resolve(clamp(Math.max(newPosition - 1, 0), 0, tr.doc.content.size)),
+            1,
+          ),
+        );
+
         return true;
       },
   };

packages/core/src/commands/focus.ts

@@ -97,9 +97,23 @@ export function createFocusCommands(editor: Editor): FocusCommands {
       },
     blur:
       () =>
-      ({ dispatch }) => {
-        if (dispatch) {
-          editor.view?.dom.blur();
+      ({ view }) => {
+        const run = () => {
+          if (!view || editor.isDestroyed) {
+            return;
+          }
+
+          (view.dom as HTMLElement).blur();
+
+          if (typeof window !== "undefined") {
+            window.getSelection()?.removeAllRanges();
+          }
+        };
+
+        if (typeof requestAnimationFrame === "function") {
+          requestAnimationFrame(run);
+        } else {
+          run();
         }
 
         return true;

packages/core/src/commands/node.ts

@@ -91,6 +91,7 @@ function joinListForwards(
 
 type NodeCommands = Pick<
   RawCommands,
+  | "deleteCurrentNode"
   | "deleteNode"
   | "clearNodes"
   | "wrapInList"
@@ -108,6 +109,36 @@ type NodeCommands = Pick<
 
 export function createNodeCommands(editor: Editor): NodeCommands {
   return {
+    deleteCurrentNode:
+      () =>
+      ({ tr, dispatch }) => {
+        const currentNode = tr.selection.$anchor.node();
+
+        if (currentNode.content.size > 0) {
+          return false;
+        }
+
+        const $position = tr.selection.$anchor;
+
+        for (let depth = $position.depth; depth > 0; depth -= 1) {
+          const node = $position.node(depth);
+
+          if (node.type !== currentNode.type) {
+            continue;
+          }
+
+          if (dispatch) {
+            const from = $position.before(depth);
+            const to = $position.after(depth);
+
+            tr.delete(from, to).scrollIntoView();
+          }
+
+          return true;
+        }
+
+        return false;
+      },
     deleteNode:
       (nameOrType: string | NodeType) =>
       ({ tr, dispatch }) => {

packages/core/src/helpers/findChildrenInRange.ts

@@ -0,0 +1,22 @@
+import type { Node as ProseMirrorNode } from "@mxm-editor/pm";
+
+export function findChildrenInRange(
+  node: ProseMirrorNode,
+  range: { from: number; to: number },
+  predicate: (node: ProseMirrorNode) => boolean,
+) {
+  const nodes: Array<{ node: ProseMirrorNode; pos: number }> = [];
+
+  node.nodesBetween(range.from, range.to, (child, pos) => {
+    if (predicate(child)) {
+      nodes.push({
+        node: child,
+        pos,
+      });
+    }
+
+    return true;
+  });
+
+  return nodes;
+}

packages/core/src/helpers/getAttributes.ts

@@ -0,0 +1,34 @@
+import type {
+  EditorState,
+  MarkType,
+  NodeType,
+} from "@mxm-editor/pm";
+import { getMarkAttributes } from "./getMarkAttributes";
+import { getNodeAttributes } from "./getNodeAttributes";
+
+export function getAttributes(
+  state: EditorState,
+  typeOrName: string | NodeType | MarkType,
+) {
+  if (typeof typeOrName === "string") {
+    if (state.schema.nodes[typeOrName]) {
+      return getNodeAttributes(state, typeOrName);
+    }
+
+    if (state.schema.marks[typeOrName]) {
+      return getMarkAttributes(state, typeOrName);
+    }
+
+    return {};
+  }
+
+  if (state.schema.nodes[typeOrName.name] === typeOrName) {
+    return getNodeAttributes(state, typeOrName);
+  }
+
+  if (state.schema.marks[typeOrName.name] === typeOrName) {
+    return getMarkAttributes(state, typeOrName);
+  }
+
+  return {};
+}

packages/core/src/helpers/getMarkAttributes.ts

@@ -0,0 +1,38 @@
+import type {
+  EditorState,
+  Mark as ProseMirrorMark,
+  MarkType,
+} from "@mxm-editor/pm";
+import { getMarkType } from "./getMarkType";
+
+export function getMarkAttributes(
+  state: EditorState,
+  typeOrName: string | MarkType,
+) {
+  const type = getMarkType(typeOrName, state.schema);
+  const { from, to, empty } = state.selection;
+  const marks: ProseMirrorMark[] = [];
+
+  if (empty) {
+    if (state.storedMarks) {
+      marks.push(...state.storedMarks);
+    }
+
+    marks.push(...state.selection.$head.marks());
+  } else {
+    state.doc.nodesBetween(from, to, (node) => {
+      marks.push(...node.marks);
+      return true;
+    });
+  }
+
+  const mark = marks.find((item) => item.type === type);
+
+  if (!mark) {
+    return {};
+  }
+
+  return {
+    ...mark.attrs,
+  };
+}

packages/core/src/helpers/getNodeAtPosition.ts

@@ -0,0 +1,31 @@
+import type {
+  EditorState,
+  Node as ProseMirrorNode,
+  NodeType,
+} from "@mxm-editor/pm";
+import { getNodeType } from "./getNodeType";
+
+export function getNodeAtPosition(
+  state: EditorState,
+  typeOrName: string | NodeType,
+  position: number,
+  maxDepth = 20,
+): [ProseMirrorNode | null, number] {
+  const type = getNodeType(typeOrName, state.schema);
+  const $position = state.doc.resolve(position);
+  let currentDepth = Math.min(maxDepth, $position.depth);
+  let node: ProseMirrorNode | null = null;
+
+  while (currentDepth > 0 && node === null) {
+    const currentNode = $position.node(currentDepth);
+
+    if (currentNode.type === type) {
+      node = currentNode;
+      break;
+    }
+
+    currentDepth -= 1;
+  }
+
+  return [node, currentDepth];
+}

packages/core/src/helpers/getNodeAttributes.ts

@@ -0,0 +1,30 @@
+import type {
+  EditorState,
+  Node as ProseMirrorNode,
+  NodeType,
+} from "@mxm-editor/pm";
+import { getNodeType } from "./getNodeType";
+
+export function getNodeAttributes(
+  state: EditorState,
+  typeOrName: string | NodeType,
+) {
+  const type = getNodeType(typeOrName, state.schema);
+  const { from, to } = state.selection;
+  const nodes: ProseMirrorNode[] = [];
+
+  state.doc.nodesBetween(from, to, (node) => {
+    nodes.push(node);
+    return true;
+  });
+
+  const node = nodes.reverse().find((item) => item.type === type);
+
+  if (!node) {
+    return {};
+  }
+
+  return {
+    ...node.attrs,
+  };
+}