@mdxeditor/editor 4.0.4 → 4.1.0

package/dist/plugins/core/lexicalExtensions.js

@@ -0,0 +1,143 @@
+import { InitialStateExtension, NestedEditorExtension, buildEditorFromExtensions, getPeerDependencyFromEditor } from "@lexical/extension";
+import { SharedHistoryExtension, HistoryExtension } from "@lexical/history";
+import { ReactExtension } from "@lexical/react/ReactExtension";
+import { ReactProviderExtension } from "@lexical/react/ReactProviderExtension";
+import { configExtension, HISTORIC_TAG, defineExtension, CAN_UNDO_COMMAND, CAN_REDO_COMMAND, FOCUS_COMMAND, COMMAND_PRIORITY_LOW, RootNode, TextNode, LineBreakNode, TabNode, ParagraphNode } from "lexical";
+const editorsWithSharedHistory = /* @__PURE__ */ new WeakSet();
+const editorHistoryStates = /* @__PURE__ */ new WeakMap();
+const extensionBuiltinNodes = /* @__PURE__ */ new Set([RootNode, TextNode, LineBreakNode, TabNode, ParagraphNode]);
+const meaningfulHistoryEntries = /* @__PURE__ */ new WeakMap();
+function externalHistoryExtension(historyState) {
+  return configExtension(HistoryExtension, {
+    createInitialHistoryState: () => historyState,
+    disabled: false
+  });
+}
+function createExtensionEditor({
+  name,
+  namespace,
+  nodes,
+  theme,
+  editable = true,
+  parentEditor,
+  historyMode,
+  historyState,
+  initialEditorState,
+  onError = (error) => {
+    throw error;
+  }
+}) {
+  const dependencies = [
+    ReactProviderExtension,
+    configExtension(ReactExtension, { contentEditable: null }),
+    configExtension(InitialStateExtension, {
+      setOptions: { tag: HISTORIC_TAG },
+      updateOptions: { tag: HISTORIC_TAG }
+    })
+  ];
+  if (parentEditor) {
+    dependencies.push(
+      configExtension(NestedEditorExtension, {
+        $getParentEditor: () => parentEditor,
+        inheritEditableFromParent: true
+      })
+    );
+  }
+  if (historyMode === "nested-shared") {
+    dependencies.push(SharedHistoryExtension);
+  } else if (historyMode === "root-shared" || historyMode === "nested-external") {
+    if (!historyState) {
+      throw new Error(`${historyMode} requires a historyState`);
+    }
+    dependencies.push(externalHistoryExtension(historyState));
+  } else if (historyMode === "table-local") {
+    dependencies.push(configExtension(HistoryExtension, { disabled: false }));
+  }
+  const editorExtension = defineExtension({
+    name,
+    namespace,
+    // InitialStateExtension already declares Lexical's built-ins. Filtering
+    // them here also prevents Vite's optimized extension bundle from seeing
+    // the same built-in constructor through two module facades.
+    nodes: nodes == null ? void 0 : nodes.filter((node) => !extensionBuiltinNodes.has(node)),
+    theme,
+    editable,
+    $initialEditorState: initialEditorState,
+    onError,
+    dependencies
+  });
+  const editor = buildEditorFromExtensions(editorExtension);
+  const historyDependency = getPeerDependencyFromEditor(editor, HistoryExtension.name);
+  const editorHistoryState = historyDependency == null ? void 0 : historyDependency.output.historyState.value;
+  if (editorHistoryState) {
+    editorHistoryStates.set(editor, editorHistoryState);
+  }
+  if (editorHistoryState) {
+    if (!meaningfulHistoryEntries.has(editorHistoryState)) {
+      meaningfulHistoryEntries.set(editorHistoryState, editorHistoryState.current);
+    }
+  }
+  const unregisterHistoryFocusGuard = editorHistoryState ? editor.registerUpdateListener(({ dirtyElements, dirtyLeaves, tags }) => {
+    const current = editorHistoryState.current;
+    if (tags.has(HISTORIC_TAG)) {
+      meaningfulHistoryEntries.set(editorHistoryState, current);
+      return;
+    }
+    if (dirtyElements.size > 0 || dirtyLeaves.size > 0) {
+      meaningfulHistoryEntries.set(editorHistoryState, current);
+      return;
+    }
+    const meaningfulEntry = meaningfulHistoryEntries.get(editorHistoryState);
+    if ((current == null ? void 0 : current.editor) === editor && meaningfulEntry && meaningfulEntry.editor !== editor) {
+      editorHistoryState.undoStack.push({ ...meaningfulEntry });
+      editorHistoryState.redoStack = [];
+      editor.dispatchCommand(CAN_UNDO_COMMAND, true);
+      editor.dispatchCommand(CAN_REDO_COMMAND, false);
+      meaningfulHistoryEntries.set(editorHistoryState, current);
+    } else {
+      meaningfulHistoryEntries.set(editorHistoryState, current);
+    }
+  }) : () => void 0;
+  const availabilityTimers = /* @__PURE__ */ new Set();
+  const unregisterHistoryAvailability = editorHistoryState ? editor.registerCommand(
+    FOCUS_COMMAND,
+    () => {
+      const timer = setTimeout(() => {
+        availabilityTimers.delete(timer);
+        editor.dispatchCommand(CAN_UNDO_COMMAND, editorHistoryState.undoStack.length > 0);
+        editor.dispatchCommand(CAN_REDO_COMMAND, editorHistoryState.redoStack.length > 0);
+      });
+      availabilityTimers.add(timer);
+      return false;
+    },
+    COMMAND_PRIORITY_LOW
+  ) : () => void 0;
+  const dispose = editor.dispose.bind(editor);
+  let disposed = false;
+  editor.dispose = () => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    availabilityTimers.forEach(clearTimeout);
+    availabilityTimers.clear();
+    unregisterHistoryAvailability();
+    unregisterHistoryFocusGuard();
+    dispose();
+  };
+  if (historyMode === "root-shared") {
+    editorsWithSharedHistory.add(editor);
+  }
+  return editor;
+}
+function editorHasSharedHistory(editor) {
+  return editorsWithSharedHistory.has(editor);
+}
+function editorUsesHistoryState(editor, historyState) {
+  return editorHistoryStates.get(editor) === historyState;
+}
+export {
+  createExtensionEditor,
+  editorHasSharedHistory,
+  editorUsesHistoryState
+};

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

@@ -171,7 +171,8 @@ const LinkDialog = () => {
       "a",
       {
         className: styles.linkDialogPreviewAnchor,
-        href: linkDialogState.url,
+        "data-testid": "link-dialog-preview",
+        href: linkDialogState.href ?? "about:blank",
         ...urlIsExternal ? { target: "_blank", rel: "noreferrer" } : {},
         onClick: (e) => {
           if (onClickLinkCallback !== null) {

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

@@ -23,6 +23,17 @@ function getLinkNodeInSelection(selection) {
   }
   return null;
 }
+function getPreviewHref(editor, linkNodeKey, url) {
+  if (!editor)
+    return "about:blank";
+  return editor.getEditorState().read(() => {
+    const keyedNode = linkNodeKey === "" ? null : $getNodeByKey(linkNodeKey);
+    const selection = $getSelection();
+    const selectedNode = $isRangeSelection(selection) ? getLinkNodeInSelection(selection) : null;
+    const linkNode = $isLinkNode(keyedNode) ? keyedNode : selectedNode;
+    return (linkNode == null ? void 0 : linkNode.sanitizeUrl(url)) ?? "about:blank";
+  });
+}
 const onWindowChange$ = Signal();
 const linkDialogState$ = Cell({ type: "inactive" }, (r) => {
   r.pub(createActiveEditorSubscription$, (editor) => {
@@ -129,7 +140,8 @@ const linkDialogState$ = Cell({ type: "inactive" }, (r) => {
         linkNodeKey: state.linkNodeKey,
         rectangle: state.rectangle,
         title,
-        url
+        url,
+        href: getPreviewHref(editor, state.linkNodeKey ?? "", url)
       });
     } else {
       if (state.type === "edit" && state.initialUrl !== "") {
@@ -155,6 +167,7 @@ const linkDialogState$ = Cell({ type: "inactive" }, (r) => {
             return {
               type: "preview",
               url: state.initialUrl,
+              href: getPreviewHref(editor, state.linkNodeKey, state.initialUrl),
               linkNodeKey: state.linkNodeKey,
               rectangle: state.rectangle
             };
@@ -183,6 +196,7 @@ const linkDialogState$ = Cell({ type: "inactive" }, (r) => {
             return {
               type: "preview",
               url: node.getURL(),
+              href: node.sanitizeUrl(node.getURL()),
               linkNodeKey: node.getKey(),
               title: node.getTitle(),
               rectangle: rect