@mdxeditor/editor 0.0.1 → 0.0.4-development

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

@@ -0,0 +1,254 @@
+import { TOGGLE_LINK_COMMAND, $isLinkNode } from "@lexical/link";
+import { $isRangeSelection, KEY_ESCAPE_COMMAND, COMMAND_PRIORITY_LOW, KEY_MODIFIER_COMMAND, $getSelection, COMMAND_PRIORITY_HIGH, $createTextNode, $insertNodes } 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);
+  if (node === null) {
+    return null;
+  }
+  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 updateLink = 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.focus(() => {
+          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(),
+                initialTitle: node.getTitle() || "",
+                url: node.getURL(),
+                title: node.getTitle() || "",
+                linkNodeKey: node.getKey(),
+                rectangle
+              });
+            } else {
+              r.pub(linkDialogState, {
+                type: "edit",
+                initialUrl: "",
+                initialTitle: "",
+                title: "",
+                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)) {
+            const selection = $getSelection();
+            if ($isRangeSelection(selection)) {
+              r.pub(openLinkEditDialog, true);
+              event.stopPropagation();
+              event.preventDefault();
+              return true;
+            } else {
+              return false;
+            }
+          }
+          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(updateLink, r.o.withLatestFrom(activeEditor, linkDialogState, currentSelection)),
+      ([payload, editor, state, selection]) => {
+        const url = payload.url.trim();
+        const title = payload.title.trim();
+        if (url.trim() !== "") {
+          if (selection == null ? void 0 : selection.isCollapsed()) {
+            const linkContent = title || url;
+            editor == null ? void 0 : editor.update(
+              () => {
+                if (!getLinkNodeInSelection(selection)) {
+                  const node = $createTextNode(linkContent);
+                  $insertNodes([node]);
+                  node.select();
+                }
+              },
+              { discrete: true }
+            );
+          }
+          editor == null ? void 0 : editor.dispatchCommand(TOGGLE_LINK_COMMAND, { url, title });
+          r.pub(linkDialogState, {
+            type: "preview",
+            linkNodeKey: state.linkNodeKey,
+            rectangle: state.rectangle,
+            url
+          });
+        } else {
+          if (state.type === "edit" && state.initialUrl !== "") {
+            editor == null ? void 0 : editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+          }
+          r.pub(linkDialogState, {
+            type: "inactive"
+          });
+        }
+      }
+    );
+    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,
+      updateLink,
+      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, params) {
+    r.pubKey("addComposerChild", (params == null ? void 0 : params.LinkDialog) || 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,23 @@
+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",
+        checked: lexicalNode.getChecked(),
+        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,13 @@
+import { $isListNode } from "@lexical/list";
+const LexicalListVisitor = {
+  testLexicalNode: $isListNode,
+  visitLexicalNode: ({ lexicalNode, actions }) => {
+    actions.addAndStepInto("list", {
+      ordered: lexicalNode.getListType() === "number",
+      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({ mdastNode, actions }) {
+    actions.addAndStepInto($createListItemNode(mdastNode.checked ?? void 0));
+  }
+};
+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,20 @@
+import { $createListNode, $isListItemNode, $createListItemNode } from "@lexical/list";
+const MdastListVisitor = {
+  testNode: "list",
+  visitNode: function({ mdastNode, lexicalParent, actions }) {
+    var _a;
+    const listType = ((_a = mdastNode.children) == null ? void 0 : _a.some((e) => typeof e.checked === "boolean")) ? "check" : mdastNode.ordered ? "number" : "bullet";
+    const lexicalNode = $createListNode(listType);
+    if ($isListItemNode(lexicalParent)) {
+      const dedicatedParent = $createListItemNode();
+      dedicatedParent.append(lexicalNode);
+      lexicalParent.insertAfter(dedicatedParent);
+    } else {
+      lexicalParent.append(lexicalNode);
+    }
+    actions.visitChildren(mdastNode, lexicalNode);
+  }
+};
+export {
+  MdastListVisitor
+};