@mdxeditor/editor 2.3.2 → 2.3.3

package/dist/importMarkdownToLexical.js

@@ -16,7 +16,14 @@ class UnrecognizedMarkdownConstructError extends Error {
     this.name = "UnrecognizedMarkdownConstructError";
   }
 }
-function importMarkdownToLexical({ root, markdown, visitors, syntaxExtensions, mdastExtensions }) {
+function importMarkdownToLexical({
+  root,
+  markdown,
+  visitors,
+  syntaxExtensions,
+  mdastExtensions,
+  ...descriptors
+}) {
   var _a;
   let mdastRoot;
   try {
@@ -37,9 +44,9 @@ function importMarkdownToLexical({ root, markdown, visitors, syntaxExtensions, m
   if (((_a = mdastRoot.children.at(-1)) == null ? void 0 : _a.type) !== "paragraph") {
     mdastRoot.children.push({ type: "paragraph", children: [] });
   }
-  importMdastTreeToLexical({ root, mdastRoot, visitors });
+  importMdastTreeToLexical({ root, mdastRoot, visitors, ...descriptors });
 }
-function importMdastTreeToLexical({ root, mdastRoot, visitors }) {
+function importMdastTreeToLexical({ root, mdastRoot, visitors, ...descriptors }) {
   const formattingMap = /* @__PURE__ */ new WeakMap();
   visitors = visitors.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
   function visitChildren(mdastNode, lexicalParent) {
@@ -53,10 +60,19 @@ function importMdastTreeToLexical({ root, mdastRoot, visitors }) {
       if (typeof visitor2.testNode === "string") {
         return visitor2.testNode === mdastNode.type;
       }
-      return visitor2.testNode(mdastNode);
+      return visitor2.testNode(mdastNode, descriptors);
     });
     if (!visitor) {
-      throw new UnrecognizedMarkdownConstructError(`Unsupported markdown syntax: ${toMarkdown(mdastNode)}`);
+      try {
+        throw new UnrecognizedMarkdownConstructError(`Unsupported markdown syntax: ${toMarkdown(mdastNode)}`);
+      } catch (e) {
+        throw new UnrecognizedMarkdownConstructError(
+          `Parsing of the following markdown structure failed: ${JSON.stringify({
+            type: mdastNode.type,
+            name: "name" in mdastNode ? mdastNode.name : "N/A"
+          })}`
+        );
+      }
     }
     visitor.visitNode({
       //@ts-expect-error root type is glitching
@@ -71,11 +87,25 @@ function importMdastTreeToLexical({ root, mdastRoot, visitors }) {
             visitChildren(mdastNode, lexicalNode);
           }
         },
-        addFormatting(format, node = mdastNode) {
-          formattingMap.set(node, format | (formattingMap.get(mdastParent) ?? 0));
+        addFormatting(format, node) {
+          if (!node) {
+            if (isParent(mdastNode)) {
+              node = mdastNode;
+            }
+          }
+          if (node) {
+            formattingMap.set(node, format | (formattingMap.get(mdastParent) ?? 0));
+          }
         },
-        removeFormatting(format, node = mdastNode) {
-          formattingMap.set(node, format ^ (formattingMap.get(mdastParent) ?? 0));
+        removeFormatting(format, node) {
+          if (!node) {
+            if (isParent(mdastNode)) {
+              node = mdastNode;
+            }
+          }
+          if (node) {
+            formattingMap.set(node, format ^ (formattingMap.get(mdastParent) ?? 0));
+          }
         },
         getParentFormatting() {
           return formattingMap.get(mdastParent) ?? 0;

package/dist/index.d.ts

@@ -434,7 +434,7 @@ export declare interface CodeBlockEditorDescriptor {
      * @param language - The language of the code block.
      * @param meta - The meta of the code block.
      */
-    match: (language: string, meta: string) => boolean;
+    match: (language: string | null | undefined, meta: string | null | undefined) => boolean;
     /**
      * The React component to be used. See {@link CodeBlockEditorProps} for the props passed to the component.
      */
@@ -535,7 +535,7 @@ export declare const codeBlockPlugin: (params?: {
 /* Excluded from this release type: CodeMirrorEditor */
 
 /**
- * A plugin that adds lets users editor code blocks with CodeMirror.
+ * A plugin that adds lets users edit code blocks with CodeMirror.
  * @group CodeMirror
  */
 export declare const codeMirrorPlugin: (params?: {
@@ -736,6 +736,15 @@ export declare function curry2to1<T, K, R>(proc: (arg1: T, arg2: K) => R, arg1:
  */
 export declare const defaultCodeBlockLanguage$: NodeRef<string>;
 
+/**
+ * The registered descriptors for composite nodes (jsx, directives, code blocks).
+ */
+export declare interface Descriptors {
+    jsxComponentDescriptors: JsxComponentDescriptor[];
+    directiveDescriptors: DirectiveDescriptor[];
+    codeBlockEditorDescriptors: CodeBlockEditorDescriptor[];
+}
+
 /**
  * Use this primitive to create a toolbar button that opens a dialog with a text input, autocomplete suggestions, and a submit button.
  * @group Toolbar Primitives
@@ -847,10 +856,10 @@ export declare interface DirectiveDescriptor<T extends Directives = Directives>
 }
 
 /**
- * Contains the currently registered directive descriptors.
+ * Contains the currently registered Markdown directive descriptors.
  * @group Directive
  */
-export declare const directiveDescriptors$: NodeRef<DirectiveDescriptor<any>[]>;
+export declare const directiveDescriptors$: NodeRef<DirectiveDescriptor<Directives>[]>;
 
 /**
  * The properties passed to the {@link DirectiveDescriptor.Editor} component.
@@ -1758,8 +1767,9 @@ export declare interface MdastImportVisitor<UN extends Mdast.Nodes> {
     /**
      * The test function that determines if this visitor should be used for the given node.
      * As a convenience, you can also pass a string here, which will be compared to the node's type.
+     * @param options - the registered descriptors for composite nodes (jsx, directives, code blocks).
      */
-    testNode: ((mdastNode: Mdast.Nodes) => boolean) | string;
+    testNode: ((mdastNode: Mdast.Nodes, options: Descriptors) => boolean) | string;
     visitNode(params: {
         /**
          * The node that is currently being visited.
@@ -1789,12 +1799,12 @@ export declare interface MdastImportVisitor<UN extends Mdast.Nodes> {
              * Adds formatting as a context for the current node and its children.
              * This is necessary due to mdast treating formatting as a node, while lexical considering it an attribute of a node.
              */
-            addFormatting(format: typeof IS_BOLD | typeof IS_ITALIC | typeof IS_UNDERLINE | typeof IS_CODE, node?: Mdast.RootContent): void;
+            addFormatting(format: typeof IS_BOLD | typeof IS_ITALIC | typeof IS_UNDERLINE | typeof IS_CODE, node?: Mdast.Parent | null): void;
             /**
              * Removes formatting as a context for the current node and its children.
              * This is necessary due to mdast treating formatting as a node, while lexical considering it an attribute of a node.
              */
-            removeFormatting(format: typeof IS_BOLD | typeof IS_ITALIC | typeof IS_UNDERLINE | typeof IS_CODE, node?: Mdast.RootContent): void;
+            removeFormatting(format: typeof IS_BOLD | typeof IS_ITALIC | typeof IS_UNDERLINE | typeof IS_CODE, node?: Mdast.Parent | null): void;
             /**
              * Access the current formatting context.
              */
@@ -2019,11 +2029,11 @@ export declare const NestedLexicalEditor: <T extends Mdast.RootContent>(props: {
     /**
      * A function that returns the phrasing content of the mdast node. In most cases, this will be the `children` property of the mdast node, but you can also have multiple nested nodes with their own children.
      */
-    getContent: (mdastNode: T) => Mdast.Content[];
+    getContent: (mdastNode: T) => Mdast.RootContent[];
     /**
      * A function that should return the updated mdast node based on the original mdast node and the new content (serialized as mdast tree) produced by the editor.
      */
-    getUpdatedMdastNode: (mdastNode: T, children: Mdast.Content[]) => T;
+    getUpdatedMdastNode: (mdastNode: T, children: Mdast.RootContent[]) => T;
     /**
      * Props passed to the {@link https://github.com/facebook/lexical/blob/main/packages/lexical-react/src/LexicalContentEditable.tsx | ContentEditable} component.
      */
@@ -2558,13 +2568,13 @@ export declare function useLexicalNodeRemove(): () => void;
  * A hook that returns a function that can be used to update the mdast node. Use this in your custom editor components.
  * @group Custom Editor Primitives
  */
-export declare function useMdastNodeUpdater<T extends Mdast.Content>(): (node: Partial<T>) => void;
+export declare function useMdastNodeUpdater<T extends Mdast.RootContent>(): (node: Partial<T>) => void;
 
 /**
  * A hook to get the current {@link NestedEditorsContext} value. Use this in your custom editor components.
  * @group Custom Editor Primitives
  */
-export declare function useNestedEditorContext<T extends Mdast.Content>(): NestedEditorsContextValue<T>;
+export declare function useNestedEditorContext<T extends Mdast.RootContent>(): NestedEditorsContextValue<T>;
 
 /* Excluded from this release type: uuidv4 */
 

package/dist/index.js

@@ -3,7 +3,7 @@ export * from "@mdxeditor/gurx";
 import { MDXEditor } from "./MDXEditor.js";
 import { MarkdownParseError, UnrecognizedMarkdownConstructError, importMarkdownToLexical, importMdastTreeToLexical } from "./importMarkdownToLexical.js";
 import { exportLexicalTreeToMdast, exportMarkdownFromLexical } from "./exportMarkdownFromLexical.js";
-import { Appender, NESTED_EDITOR_UPDATED_COMMAND, activeEditor$, activeEditorSubscriptions$, activePlugins$, addActivePlugin$, addComposerChild$, addEditorWrapper$, addExportVisitor$, addImportVisitor$, addLexicalNode$, addMdastExtension$, addNestedEditorChild$, addSyntaxExtension$, addToMarkdownExtension$, addTopAreaChild$, applyBlockType$, applyFormat$, autoFocus$, composerChildren$, contentEditableClassName$, convertSelectionToNode$, corePlugin, createActiveEditorSubscription$, createRootEditorSubscription$, currentBlockType$, currentFormat$, currentSelection$, editorInFocus$, editorRootElementRef$, editorWrappers$, exportVisitors$, historyState$, iconComponentFor$, importVisitors$, inFocus$, initialMarkdown$, initialRootEditorState$, insertDecoratorNode$, insertMarkdown$, jsxComponentDescriptors$, jsxIsAvailable$, markdown$, markdownErrorSignal$, markdownProcessingError$, markdownSourceEditorValue$, mdastExtensions$, nestedEditorChildren$, onBlur$, placeholder$, readOnly$, rootEditor$, rootEditorSubscriptions$, setMarkdown$, syntaxExtensions$, toMarkdownExtensions$, toMarkdownOptions$, topAreaChildren$, usedLexicalNodes$, viewMode$ } from "./plugins/core/index.js";
+import { Appender, NESTED_EDITOR_UPDATED_COMMAND, activeEditor$, activeEditorSubscriptions$, activePlugins$, addActivePlugin$, addComposerChild$, addEditorWrapper$, addExportVisitor$, addImportVisitor$, addLexicalNode$, addMdastExtension$, addNestedEditorChild$, addSyntaxExtension$, addToMarkdownExtension$, addTopAreaChild$, applyBlockType$, applyFormat$, autoFocus$, codeBlockEditorDescriptors$, composerChildren$, contentEditableClassName$, convertSelectionToNode$, corePlugin, createActiveEditorSubscription$, createRootEditorSubscription$, currentBlockType$, currentFormat$, currentSelection$, directiveDescriptors$, editorInFocus$, editorRootElementRef$, editorWrappers$, exportVisitors$, historyState$, iconComponentFor$, importVisitors$, inFocus$, initialMarkdown$, initialRootEditorState$, insertDecoratorNode$, insertMarkdown$, jsxComponentDescriptors$, jsxIsAvailable$, markdown$, markdownErrorSignal$, markdownProcessingError$, markdownSourceEditorValue$, mdastExtensions$, nestedEditorChildren$, onBlur$, placeholder$, readOnly$, rootEditor$, rootEditorSubscriptions$, setMarkdown$, syntaxExtensions$, toMarkdownExtensions$, toMarkdownOptions$, topAreaChildren$, usedLexicalNodes$, viewMode$ } from "./plugins/core/index.js";
 import { ALL_HEADING_LEVELS, allowedHeadingLevels$, headingsPlugin } from "./plugins/headings/index.js";
 import { insertThematicBreak$, thematicBreakPlugin } from "./plugins/thematic-break/index.js";
 import { applyListType$, currentListType$, listsPlugin } from "./plugins/lists/index.js";
@@ -17,8 +17,8 @@ import { GenericJsxEditor } from "./jsx-editors/GenericJsxEditor.js";
 import { insertSandpack$, sandpackConfig$, sandpackPlugin } from "./plugins/sandpack/index.js";
 import { codeBlockLanguages$, codeMirrorPlugin, insertCodeMirror$ } from "./plugins/codemirror/index.js";
 import { CodeMirrorEditor } from "./plugins/codemirror/CodeMirrorEditor.js";
-import { appendCodeBlockEditorDescriptor$, codeBlockEditorDescriptors$, codeBlockPlugin, defaultCodeBlockLanguage$, insertCodeBlock$ } from "./plugins/codeblock/index.js";
-import { directiveDescriptors$, directivesPlugin, insertDirective$ } from "./plugins/directives/index.js";
+import { appendCodeBlockEditorDescriptor$, codeBlockPlugin, defaultCodeBlockLanguage$, insertCodeBlock$ } from "./plugins/codeblock/index.js";
+import { directivesPlugin, insertDirective$ } from "./plugins/directives/index.js";
 import { ADMONITION_TYPES, AdmonitionDirectiveDescriptor } from "./directive-editors/AdmonitionDirectiveDescriptor.js";
 import { GenericDirectiveEditor } from "./directive-editors/GenericDirectiveEditor.js";
 import { applyLinkChanges$, cancelLinkEdit$, linkAutocompleteSuggestions$, linkDialogPlugin, linkDialogState$, onWindowChange$, openLinkEditDialog$, removeLink$, switchFromPreviewToLinkEdit$, updateLink$ } from "./plugins/link-dialog/index.js";

package/dist/plugins/codeblock/CodeBlockNode.js

@@ -4,12 +4,11 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-import React__default from "react";
+import { useCellValue } from "@mdxeditor/gurx";
 import { DecoratorNode } from "lexical";
-import { codeBlockEditorDescriptors$ } from "./index.js";
+import React__default from "react";
 import { voidEmitter } from "../../utils/voidEmitter.js";
-import { NESTED_EDITOR_UPDATED_COMMAND } from "../core/index.js";
-import { useCellValue } from "@mdxeditor/gurx";
+import { codeBlockEditorDescriptors$, NESTED_EDITOR_UPDATED_COMMAND } from "../core/index.js";
 class CodeBlockNode extends DecoratorNode {
   constructor(code, language, meta, key) {
     super(key);

package/dist/plugins/codeblock/MdastCodeVisitor.js

@@ -1,6 +1,12 @@
 import { $createCodeBlockNode } from "./CodeBlockNode.js";
 const MdastCodeVisitor = {
-  testNode: "code",
+  testNode: (node, { codeBlockEditorDescriptors }) => {
+    if (node.type === "code") {
+      const descriptor = codeBlockEditorDescriptors.find((descriptor2) => descriptor2.match(node.lang, node.meta));
+      return descriptor !== void 0;
+    }
+    return false;
+  },
   visitNode({ mdastNode, actions }) {
     actions.addAndStepInto(
       $createCodeBlockNode({

package/dist/plugins/codeblock/index.js

@@ -1,11 +1,10 @@
 import { CodeBlockVisitor } from "./CodeBlockVisitor.js";
 import { MdastCodeVisitor } from "./MdastCodeVisitor.js";
-import { insertDecoratorNode$, Appender, addActivePlugin$, addImportVisitor$, addLexicalNode$, addExportVisitor$ } from "../core/index.js";
+import { insertDecoratorNode$, Appender, codeBlockEditorDescriptors$, addActivePlugin$, addImportVisitor$, addLexicalNode$, addExportVisitor$ } from "../core/index.js";
 import { $createCodeBlockNode, CodeBlockNode } from "./CodeBlockNode.js";
 import { $isCodeBlockNode, useCodeBlockEditorContext } from "./CodeBlockNode.js";
 import { Cell, Signal, withLatestFrom, map } from "@mdxeditor/gurx";
 import { realmPlugin } from "../../RealmWithPlugins.js";
-const codeBlockEditorDescriptors$ = Cell([]);
 const defaultCodeBlockLanguage$ = Cell("");
 const insertCodeBlock$ = Signal((r) => {
   r.link(
@@ -39,7 +38,6 @@ export {
   $isCodeBlockNode,
   CodeBlockNode,
   appendCodeBlockEditorDescriptor$,
-  codeBlockEditorDescriptors$,
   codeBlockPlugin,
   defaultCodeBlockLanguage$,
   insertCodeBlock$,

package/dist/plugins/codemirror/index.js

@@ -29,15 +29,21 @@ const codeMirrorPlugin = realmPlugin({
     r.pub(codeBlockLanguages$, params == null ? void 0 : params.codeBlockLanguages);
   },
   init(r, params) {
-    r.pub(appendCodeBlockEditorDescriptor$, {
-      match(language, meta) {
-        return Boolean(params == null ? void 0 : params.codeBlockLanguages.hasOwnProperty(language)) && meta === "";
-      },
-      priority: 1,
-      Editor: CodeMirrorEditor
+    r.pubIn({
+      [codeBlockLanguages$]: params == null ? void 0 : params.codeBlockLanguages,
+      [appendCodeBlockEditorDescriptor$]: buildCodeBlockDescriptor((params == null ? void 0 : params.codeBlockLanguages) || {})
     });
   }
 });
+function buildCodeBlockDescriptor(codeBlockLanguages) {
+  return {
+    match(language, meta) {
+      return Boolean(codeBlockLanguages.hasOwnProperty(language || "")) && !Boolean(meta);
+    },
+    priority: 1,
+    Editor: CodeMirrorEditor
+  };
+}
 export {
   codeBlockLanguages$,
   codeMirrorPlugin,

package/dist/plugins/core/MdastFormattingVisitor.js

@@ -14,7 +14,7 @@ const MdastFormattingVisitor = {
   },
   visitNode({ mdastNode, lexicalParent, actions, mdastParent }) {
     if (isOpeningUnderlineNode(mdastNode)) {
-      actions.addFormatting(IS_UNDERLINE, mdastParent);
+      actions.removeFormatting(IS_UNDERLINE, mdastParent);
       return;
     }
     if (isClosingUnderlineNode(mdastNode)) {

package/dist/plugins/core/NestedLexicalEditor.js

@@ -1,6 +1,6 @@
 import { $addUpdateTag, $getNodeByKey, createEditor, $getRoot, BLUR_COMMAND, COMMAND_PRIORITY_EDITOR, SELECTION_CHANGE_COMMAND, COMMAND_PRIORITY_HIGH, KEY_BACKSPACE_COMMAND, COMMAND_PRIORITY_CRITICAL } from "lexical";
 import React__default from "react";
-import { NESTED_EDITOR_UPDATED_COMMAND, rootEditor$, importVisitors$, exportVisitors$, usedLexicalNodes$, jsxComponentDescriptors$, jsxIsAvailable$, nestedEditorChildren$, editorInFocus$ } from "./index.js";
+import { NESTED_EDITOR_UPDATED_COMMAND, rootEditor$, importVisitors$, exportVisitors$, usedLexicalNodes$, jsxComponentDescriptors$, directiveDescriptors$, codeBlockEditorDescriptors$, jsxIsAvailable$, nestedEditorChildren$, editorInFocus$ } from "./index.js";
 import { ContentEditable } from "@lexical/react/LexicalContentEditable.js";
 import LexicalErrorBoundary from "@lexical/react/LexicalErrorBoundary.js";
 import { LexicalNestedComposer } from "@lexical/react/LexicalNestedComposer.js";
@@ -53,12 +53,24 @@ const NestedLexicalEditor = function(props) {
   const updateMdastNode = useMdastNodeUpdater();
   const removeNode = useLexicalNodeRemove();
   const content = getContent(mdastNode);
-  const [rootEditor, importVisitors, exportVisitors, usedLexicalNodes, jsxComponentDescriptors, jsxIsAvailable, nestedEditorChildren] = useCellValues(
+  const [
+    rootEditor,
+    importVisitors,
+    exportVisitors,
+    usedLexicalNodes,
+    jsxComponentDescriptors,
+    directiveDescriptors,
+    codeBlockEditorDescriptors,
+    jsxIsAvailable,
+    nestedEditorChildren
+  ] = useCellValues(
     rootEditor$,
     importVisitors$,
     exportVisitors$,
     usedLexicalNodes$,
     jsxComponentDescriptors$,
+    directiveDescriptors$,
+    codeBlockEditorDescriptors$,
     jsxIsAvailable$,
     nestedEditorChildren$
   );
@@ -92,7 +104,10 @@ const NestedLexicalEditor = function(props) {
           type: "root",
           children: theContent
         },
-        visitors: importVisitors
+        visitors: importVisitors,
+        directiveDescriptors,
+        codeBlockEditorDescriptors,
+        jsxComponentDescriptors
       });
     });
   }, [editor, block, importVisitors]);

package/dist/plugins/core/index.js

@@ -91,6 +91,8 @@ const toMarkdownExtensions$ = Cell([]);
 const toMarkdownOptions$ = Cell({});
 const jsxIsAvailable$ = Cell(false);
 const jsxComponentDescriptors$ = Cell([]);
+const directiveDescriptors$ = Cell([]);
+const codeBlockEditorDescriptors$ = Cell([]);
 const editorRootElementRef$ = Cell(null);
 const addLexicalNode$ = Appender(usedLexicalNodes$);
 const addImportVisitor$ = Appender(importVisitors$);
@@ -321,7 +323,10 @@ function tryImportingMarkdown(r, node, markdownValue) {
       visitors: r.getValue(importVisitors$),
       mdastExtensions: r.getValue(mdastExtensions$),
       markdown: markdownValue,
-      syntaxExtensions: r.getValue(syntaxExtensions$)
+      syntaxExtensions: r.getValue(syntaxExtensions$),
+      jsxComponentDescriptors: r.getValue(jsxComponentDescriptors$),
+      directiveDescriptors: r.getValue(directiveDescriptors$),
+      codeBlockEditorDescriptors: r.getValue(codeBlockEditorDescriptors$)
     });
     r.pub(markdownProcessingError$, null);
   } catch (e) {
@@ -526,6 +531,7 @@ export {
   applyBlockType$,
   applyFormat$,
   autoFocus$,
+  codeBlockEditorDescriptors$,
   composerChildren$,
   contentEditableClassName$,
   convertSelectionToNode$,
@@ -535,6 +541,7 @@ export {
   currentBlockType$,
   currentFormat$,
   currentSelection$,
+  directiveDescriptors$,
   editorInFocus$,
   editorRootElementRef$,
   editorWrappers$,

package/dist/plugins/directives/DirectiveNode.js

@@ -7,9 +7,9 @@ var __publicField = (obj, key, value) => {
 import React__default from "react";
 import { DecoratorNode } from "lexical";
 import { NestedEditorsContext } from "../core/NestedLexicalEditor.js";
-import { directiveDescriptors$ } from "./index.js";
 import { voidEmitter } from "../../utils/voidEmitter.js";
 import { useCellValues } from "@mdxeditor/gurx";
+import { directiveDescriptors$ } from "../core/index.js";
 let GENERATION = 0;
 class DirectiveNode extends DecoratorNode {
   /**

package/dist/plugins/directives/MdastDirectiveVisitor.js

@@ -1,13 +1,21 @@
 import { $createDirectiveNode } from "./DirectiveNode.js";
 const DIRECTIVE_TYPES = ["leafDirective", "containerDirective", "textDirective"];
+function isMdastDirectivesNode(node) {
+  return DIRECTIVE_TYPES.includes(node.type);
+}
 const MdastDirectiveVisitor = {
-  testNode: (node) => {
-    return DIRECTIVE_TYPES.includes(node.type);
+  testNode: (node, { directiveDescriptors }) => {
+    if (isMdastDirectivesNode(node)) {
+      const descriptor = directiveDescriptors.find((descriptor2) => descriptor2.testNode(node));
+      return descriptor !== void 0;
+    }
+    return false;
   },
   visitNode({ lexicalParent, mdastNode }) {
     lexicalParent.append($createDirectiveNode(mdastNode));
   }
 };
 export {
-  MdastDirectiveVisitor
+  MdastDirectiveVisitor,
+  isMdastDirectivesNode
 };

package/dist/plugins/directives/index.js

@@ -1,13 +1,12 @@
 import { realmPlugin } from "../../RealmWithPlugins.js";
-import { insertDecoratorNode$, addMdastExtension$, addSyntaxExtension$, addImportVisitor$, addLexicalNode$, addExportVisitor$, addToMarkdownExtension$ } from "../core/index.js";
-import { Cell, Signal, map } from "@mdxeditor/gurx";
+import { insertDecoratorNode$, directiveDescriptors$, addMdastExtension$, addSyntaxExtension$, addImportVisitor$, addLexicalNode$, addExportVisitor$, addToMarkdownExtension$ } from "../core/index.js";
+import { Signal, map } from "@mdxeditor/gurx";
 import { directiveFromMarkdown, directiveToMarkdown } from "mdast-util-directive";
 import { directive } from "micromark-extension-directive";
 import { $createDirectiveNode, DirectiveNode } from "./DirectiveNode.js";
 import { $isDirectiveNode } from "./DirectiveNode.js";
 import { DirectiveVisitor } from "./DirectiveVisitor.js";
 import { MdastDirectiveVisitor } from "./MdastDirectiveVisitor.js";
-const directiveDescriptors$ = Cell([]);
 const insertDirective$ = Signal((r) => {
   r.link(
     r.pipe(
@@ -40,7 +39,6 @@ export {
   $createDirectiveNode,
   $isDirectiveNode,
   DirectiveNode,
-  directiveDescriptors$,
   directivesPlugin,
   insertDirective$
 };

package/dist/plugins/jsx/MdastMdxJsxElementVisitor.js

@@ -1,7 +1,11 @@
 import { $createLexicalJsxNode } from "./LexicalJsxNode.js";
 const MdastMdxJsxElementVisitor = {
-  testNode: (node) => {
-    return (node.type === "mdxJsxTextElement" || node.type === "mdxJsxFlowElement") && node.name !== "img";
+  testNode: (node, { jsxComponentDescriptors }) => {
+    if (node.type === "mdxJsxTextElement" || node.type === "mdxJsxFlowElement") {
+      const descriptor = jsxComponentDescriptors.find((descriptor2) => descriptor2.name === node.name);
+      return descriptor !== void 0;
+    }
+    return false;
   },
   visitNode({ lexicalParent, mdastNode }) {
     lexicalParent.append($createLexicalJsxNode(mdastNode));

package/dist/plugins/sandpack/index.js

@@ -50,26 +50,32 @@ const insertSandpack$ = Signal((r) => {
   );
 });
 const sandpackPlugin = realmPlugin({
-  init(realm) {
-    realm.pub(appendCodeBlockEditorDescriptor$, {
-      match(_language, meta) {
-        return meta == null ? void 0 : meta.startsWith("live");
-      },
-      priority: 1,
-      Editor(props) {
-        const config = useCellValue(sandpackConfig$);
-        const preset = config.presets.find((preset2) => preset2.meta === props.meta);
-        if (!preset) {
-          throw new Error(`No sandpack preset found with ${props.meta}`);
-        }
-        return /* @__PURE__ */ React__default.createElement(SandpackEditor, { ...props, preset });
-      }
+  init(realm, params) {
+    realm.pubIn({
+      [sandpackConfig$]: params == null ? void 0 : params.sandpackConfig,
+      [appendCodeBlockEditorDescriptor$]: sandpackCodeBlockDescriptor()
     });
   },
   update(realm, params) {
     realm.pub(sandpackConfig$, params == null ? void 0 : params.sandpackConfig);
   }
 });
+function sandpackCodeBlockDescriptor() {
+  return {
+    match(_language, meta) {
+      return Boolean(meta == null ? void 0 : meta.startsWith("live"));
+    },
+    Editor(props) {
+      const config = useCellValue(sandpackConfig$);
+      const preset = config.presets.find((preset2) => preset2.meta === props.meta);
+      if (!preset) {
+        throw new Error(`No sandpack preset found with ${props.meta}`);
+      }
+      return /* @__PURE__ */ React__default.createElement(SandpackEditor, { ...props, preset });
+    },
+    priority: 1
+  };
+}
 export {
   insertSandpack$,
   sandpackConfig$,

package/dist/plugins/table/TableEditor.js

@@ -15,7 +15,7 @@ import classNames from "classnames";
 import styles from "../../styles/ui.module.css.js";
 import { isPartOftheEditorUI } from "../../utils/isPartOftheEditorUI.js";
 import { uuidv4 } from "../../utils/uuid4.js";
-import { iconComponentFor$, readOnly$, importVisitors$, exportVisitors$, usedLexicalNodes$, jsxComponentDescriptors$, jsxIsAvailable$, rootEditor$, NESTED_EDITOR_UPDATED_COMMAND, editorRootElementRef$ } from "../core/index.js";
+import { iconComponentFor$, readOnly$, importVisitors$, exportVisitors$, usedLexicalNodes$, jsxComponentDescriptors$, directiveDescriptors$, codeBlockEditorDescriptors$, jsxIsAvailable$, rootEditor$, NESTED_EDITOR_UPDATED_COMMAND, editorRootElementRef$ } from "../core/index.js";
 import { useCellValues } from "@mdxeditor/gurx";
 const AlignToTailwindClassMap = {
   center: styles.centeredCell,
@@ -188,11 +188,22 @@ const Cell = ({ align, ...props }) => {
   );
 };
 const CellEditor = ({ focus, setActiveCell, parentEditor, lexicalTable, contents, colIndex, rowIndex }) => {
-  const [importVisitors, exportVisitors, usedLexicalNodes, jsxComponentDescriptors, jsxIsAvailable, rootEditor] = useCellValues(
+  const [
+    importVisitors,
+    exportVisitors,
+    usedLexicalNodes,
+    jsxComponentDescriptors,
+    directiveDescriptors,
+    codeBlockEditorDescriptors,
+    jsxIsAvailable,
+    rootEditor
+  ] = useCellValues(
     importVisitors$,
     exportVisitors$,
     usedLexicalNodes$,
     jsxComponentDescriptors$,
+    directiveDescriptors$,
+    codeBlockEditorDescriptors$,
     jsxIsAvailable$,
     rootEditor$
   );
@@ -205,7 +216,10 @@ const CellEditor = ({ focus, setActiveCell, parentEditor, lexicalTable, contents
       importMdastTreeToLexical({
         root: $getRoot(),
         mdastRoot: { type: "root", children: [{ type: "paragraph", children: contents }] },
-        visitors: importVisitors
+        visitors: importVisitors,
+        jsxComponentDescriptors,
+        directiveDescriptors,
+        codeBlockEditorDescriptors
       });
     });
     return editor2;

package/package.json

@@ -11,7 +11,7 @@
     "*.css"
   ],
   "type": "module",
-  "version": "2.3.2",
+  "version": "2.3.3",
   "description": "React component for rich text markdown editing",
   "scripts": {
     "build": "vite build",