@mdxeditor/editor 0.9.0 → 0.10.0-alpha.1

package/dist/plugins/link-dialog/index.js

@@ -0,0 +1,242 @@
+import { TOGGLE_LINK_COMMAND, $isLinkNode } from "@lexical/link";
+import { $isRangeSelection, KEY_ESCAPE_COMMAND, COMMAND_PRIORITY_LOW, KEY_MODIFIER_COMMAND, COMMAND_PRIORITY_HIGH } from "lexical";
+import { IS_APPLE } from "../../utils/detectMac.js";
+import { getSelectionRectangle, getSelectedNode } from "../../utils/lexicalHelpers.js";
+import { coreSystem } from "../core/index.js";
+import { LinkDialog } from "./LinkDialog.js";
+import { system } from "../../gurx/realmFactory.js";
+import { realmPlugin } from "../../gurx/react.js";
+function getLinkNodeInSelection(selection) {
+  if (!selection) {
+    return null;
+  }
+  const node = getSelectedNode(selection);
+  const parent = node.getParent();
+  if ($isLinkNode(parent)) {
+    return parent;
+  } else if ($isLinkNode(node)) {
+    return node;
+  }
+  return null;
+}
+const linkDialogSystem = system(
+  (r, [{ activeEditor, currentSelection, createActiveEditorSubscription }]) => {
+    const dialogState = r.node(false);
+    const onWindowChange = r.node();
+    const linkDialogState = r.node({ type: "inactive" }, true);
+    const updateLinkUrl = r.node();
+    const cancelLinkEdit = r.node();
+    const applyLinkChanges = r.node();
+    const switchFromPreviewToLinkEdit = r.node();
+    const removeLink = r.node();
+    const openLinkEditDialog = r.node();
+    const linkAutocompleteSuggestions = r.node([]);
+    r.sub(
+      r.pipe(
+        openLinkEditDialog,
+        r.o.withLatestFrom(currentSelection, activeEditor),
+        r.o.filter(([, selection]) => $isRangeSelection(selection))
+      ),
+      ([, selection, editor]) => {
+        editor == null ? void 0 : editor.getEditorState().read(() => {
+          const node = getLinkNodeInSelection(selection);
+          const rectangle = getSelectionRectangle(editor);
+          if (node) {
+            r.pub(linkDialogState, {
+              type: "edit",
+              initialUrl: node.getURL(),
+              url: node.getURL(),
+              linkNodeKey: node.getKey(),
+              rectangle
+            });
+          } else {
+            r.pub(linkDialogState, {
+              type: "edit",
+              initialUrl: "",
+              url: "",
+              linkNodeKey: "",
+              rectangle
+            });
+          }
+        });
+      }
+    );
+    r.sub(r.pipe(removeLink, r.o.withLatestFrom(activeEditor)), ([, editor]) => {
+      editor == null ? void 0 : editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+    });
+    r.pub(createActiveEditorSubscription, (editor) => {
+      return editor.registerCommand(
+        KEY_ESCAPE_COMMAND,
+        () => {
+          const state = r.getValue(linkDialogState);
+          if (state.type === "preview") {
+            r.pub(linkDialogState, { type: "inactive" });
+            return true;
+          }
+          return false;
+        },
+        COMMAND_PRIORITY_LOW
+      );
+    });
+    r.pub(createActiveEditorSubscription, (editor) => {
+      return editor.registerCommand(
+        KEY_MODIFIER_COMMAND,
+        (event) => {
+          if (event.key === "k" && (IS_APPLE ? event.metaKey : event.ctrlKey)) {
+            r.pub(openLinkEditDialog, true);
+            return true;
+          }
+          return false;
+        },
+        COMMAND_PRIORITY_HIGH
+      );
+    });
+    r.link(
+      r.pipe(
+        switchFromPreviewToLinkEdit,
+        r.o.withLatestFrom(linkDialogState),
+        r.o.map(([, state]) => {
+          if (state.type === "preview") {
+            return {
+              type: "edit",
+              initialUrl: state.url,
+              url: state.url,
+              linkNodeKey: state.linkNodeKey,
+              rectangle: state.rectangle
+            };
+          } else {
+            throw new Error("Cannot switch to edit mode when not in preview mode");
+          }
+        })
+      ),
+      linkDialogState
+    );
+    r.sub(r.pipe(applyLinkChanges, r.o.withLatestFrom(linkDialogState, activeEditor)), ([, state, editor]) => {
+      if (state.type === "edit") {
+        const url = state.url.trim();
+        if (url.trim() !== "") {
+          editor == null ? void 0 : editor.dispatchCommand(TOGGLE_LINK_COMMAND, url);
+          r.pub(linkDialogState, {
+            type: "preview",
+            linkNodeKey: state.linkNodeKey,
+            rectangle: state.rectangle,
+            url
+          });
+        } else {
+          if (state.initialUrl !== "") {
+            editor == null ? void 0 : editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+          }
+          r.pub(linkDialogState, {
+            type: "inactive"
+          });
+        }
+      } else {
+        throw new Error("Cannot apply link edit when not in edit mode");
+      }
+    });
+    r.link(
+      r.pipe(
+        updateLinkUrl,
+        r.o.withLatestFrom(linkDialogState),
+        r.o.map(([url, state]) => {
+          if (state.type === "edit") {
+            return {
+              ...state,
+              url
+            };
+          } else {
+            throw new Error("Cannot update link url when not in edit mode");
+          }
+        })
+      ),
+      linkDialogState
+    );
+    r.link(
+      r.pipe(
+        cancelLinkEdit,
+        r.o.withLatestFrom(linkDialogState, activeEditor),
+        r.o.map(([, state, editor]) => {
+          if (state.type === "edit") {
+            editor == null ? void 0 : editor.focus();
+            if (state.initialUrl === "") {
+              return {
+                type: "inactive"
+              };
+            } else {
+              return {
+                type: "preview",
+                url: state.initialUrl,
+                linkNodeKey: state.linkNodeKey,
+                rectangle: state.rectangle
+              };
+            }
+          } else {
+            throw new Error("Cannot cancel edit when not in edit mode");
+          }
+        })
+      ),
+      linkDialogState
+    );
+    r.link(
+      r.pipe(
+        r.combine(currentSelection, onWindowChange),
+        r.o.withLatestFrom(activeEditor, linkDialogState),
+        r.o.map(([[selection], activeEditor2]) => {
+          if ($isRangeSelection(selection) && activeEditor2) {
+            const node = getLinkNodeInSelection(selection);
+            if (node) {
+              return {
+                type: "preview",
+                url: node.getURL(),
+                linkNodeKey: node.getKey(),
+                rectangle: getSelectionRectangle(activeEditor2)
+              };
+            } else {
+              return {
+                type: "inactive"
+              };
+            }
+          } else {
+            return {
+              type: "inactive"
+            };
+          }
+        })
+      ),
+      linkDialogState
+    );
+    return {
+      dialogState,
+      onWindowChange,
+      linkDialogState,
+      updateLinkUrl,
+      switchFromPreviewToLinkEdit,
+      cancelLinkEdit,
+      removeLink,
+      openLinkEditDialog,
+      applyLinkChanges,
+      linkAutocompleteSuggestions
+    };
+  },
+  [coreSystem]
+);
+const [
+  /** @internal */
+  linkDialogPlugin,
+  /** @internal */
+  linkDialogPluginHooks
+] = realmPlugin({
+  id: "link-dialog",
+  dependencies: ["link"],
+  systemSpec: linkDialogSystem,
+  applyParamsToSystem(r, params = {}) {
+    r.pubKey("linkAutocompleteSuggestions", params.linkAutocompleteSuggestions || []);
+  },
+  init(r) {
+    r.pubKey("addComposerChild", LinkDialog);
+  }
+});
+export {
+  linkDialogPlugin,
+  linkDialogPluginHooks
+};

package/dist/plugins/lists/LexicalListItemVisitor.d.ts

@@ -0,0 +1,4 @@
+import { ListItemNode } from '@lexical/list';
+import * as Mdast from 'mdast';
+import { LexicalExportVisitor } from '../../exportMarkdownFromLexical';
+export declare const LexicalListItemVisitor: LexicalExportVisitor<ListItemNode, Mdast.ListItem>;

package/dist/plugins/lists/LexicalListItemVisitor.js

@@ -0,0 +1,22 @@
+import { $isListItemNode, $isListNode } from "@lexical/list";
+const LexicalListItemVisitor = {
+  testLexicalNode: $isListItemNode,
+  visitLexicalNode: ({ lexicalNode, mdastParent, actions }) => {
+    const children = lexicalNode.getChildren();
+    const firstChild = children[0];
+    if (children.length === 1 && $isListNode(firstChild)) {
+      const prevListItemNode = mdastParent.children.at(-1);
+      actions.visitChildren(lexicalNode, prevListItemNode);
+    } else {
+      const listItem = actions.appendToParent(mdastParent, {
+        type: "listItem",
+        spread: false,
+        children: [{ type: "paragraph", children: [] }]
+      });
+      actions.visitChildren(lexicalNode, listItem.children[0]);
+    }
+  }
+};
+export {
+  LexicalListItemVisitor
+};

package/dist/plugins/lists/LexicalListVisitor.d.ts

@@ -0,0 +1,4 @@
+import { ListNode } from '@lexical/list';
+import * as Mdast from 'mdast';
+import { LexicalExportVisitor } from '../../exportMarkdownFromLexical';
+export declare const LexicalListVisitor: LexicalExportVisitor<ListNode, Mdast.List>;

package/dist/plugins/lists/LexicalListVisitor.js

@@ -0,0 +1,14 @@
+import { $isListNode } from "@lexical/list";
+const LexicalListVisitor = {
+  testLexicalNode: $isListNode,
+  visitLexicalNode: ({ lexicalNode, actions }) => {
+    actions.addAndStepInto("list", {
+      ordered: lexicalNode.getListType() === "number",
+      //TODO: figure out when spread can be true
+      spread: false
+    });
+  }
+};
+export {
+  LexicalListVisitor
+};

package/dist/plugins/lists/MdastListItemVisitor.d.ts

@@ -0,0 +1,3 @@
+import * as Mdast from 'mdast';
+import { MdastImportVisitor } from '../../importMarkdownToLexical';
+export declare const MdastListItemVisitor: MdastImportVisitor<Mdast.ListItem>;

package/dist/plugins/lists/MdastListItemVisitor.js

@@ -0,0 +1,10 @@
+import { $createListItemNode } from "@lexical/list";
+const MdastListItemVisitor = {
+  testNode: "listItem",
+  visitNode({ actions }) {
+    actions.addAndStepInto($createListItemNode());
+  }
+};
+export {
+  MdastListItemVisitor
+};

package/dist/plugins/lists/MdastListVisitor.d.ts

@@ -0,0 +1,3 @@
+import * as Mdast from 'mdast';
+import { MdastImportVisitor } from '../../importMarkdownToLexical';
+export declare const MdastListVisitor: MdastImportVisitor<Mdast.List>;

package/dist/plugins/lists/MdastListVisitor.js

@@ -0,0 +1,18 @@
+import { $createListNode, $isListItemNode, $createListItemNode } from "@lexical/list";
+const MdastListVisitor = {
+  testNode: "list",
+  visitNode: function({ mdastNode, lexicalParent, actions }) {
+    const lexicalNode = $createListNode(mdastNode.ordered ? "number" : "bullet");
+    if ($isListItemNode(lexicalParent)) {
+      const dedicatedParent = $createListItemNode();
+      dedicatedParent.append(lexicalNode);
+      lexicalParent.insertAfter(dedicatedParent);
+    } else {
+      lexicalParent.append(lexicalNode);
+    }
+    actions.visitChildren(mdastNode, lexicalNode);
+  }
+};
+export {
+  MdastListVisitor
+};