@mdxeditor/editor 0.0.1 → 0.0.4-development

package/dist/plugins/core/index.js

@@ -0,0 +1,490 @@
+import { createEmptyHistoryState } from "@lexical/react/LexicalHistoryPlugin.js";
+import { $isHeadingNode } from "@lexical/rich-text";
+import { $setBlocksType } from "@lexical/selection";
+import { $findMatchingParent, $wrapNodeInElement, $insertNodeToNearestRoot } from "@lexical/utils";
+import { createCommand, SELECTION_CHANGE_COMMAND, $getRoot, COMMAND_PRIORITY_CRITICAL, $setSelection, BLUR_COMMAND, FOCUS_COMMAND, KEY_DOWN_COMMAND, $isDecoratorNode, FORMAT_TEXT_COMMAND, $isRootOrShadowRoot, $getSelection, $isRangeSelection, $insertNodes, $createParagraphNode, ParagraphNode, TextNode } from "lexical";
+import { exportMarkdownFromLexical } from "../../exportMarkdownFromLexical.js";
+import { importMarkdownToLexical, MarkdownParseError, UnrecognizedMarkdownConstructError } from "../../importMarkdownToLexical.js";
+import { LexicalLinebreakVisitor } from "./LexicalLinebreakVisitor.js";
+import { LexicalParagraphVisitor } from "./LexicalParagraphVisitor.js";
+import { LexicalRootVisitor } from "./LexicalRootVisitor.js";
+import { LexicalTextVisitor } from "./LexicalTextVisitor.js";
+import { MdastFormattingVisitor } from "./MdastFormattingVisitor.js";
+import { MdastInlineCodeVisitor } from "./MdastInlineCodeVisitor.js";
+import { MdastParagraphVisitor } from "./MdastParagraphVisitor.js";
+import { MdastRootVisitor } from "./MdastRootVisitor.js";
+import { MdastTextVisitor } from "./MdastTextVisitor.js";
+import { SharedHistoryPlugin } from "./SharedHistoryPlugin.js";
+import { noop } from "../../utils/fp.js";
+import { controlOrMeta } from "../../utils/detectMac.js";
+import { MdastBreakVisitor } from "./MdastBreakVisitor.js";
+import { mdxJsxFromMarkdown, mdxJsxToMarkdown } from "mdast-util-mdx-jsx";
+import { mdxJsx } from "micromark-extension-mdx-jsx";
+import { MdastHTMLVisitor } from "./MdastHTMLVisitor.js";
+import { GenericHTMLNode } from "./GenericHTMLNode.js";
+import { $createGenericHTMLNode, $isGenericHTMLNode } from "./GenericHTMLNode.js";
+import { LexicalGenericHTMLVisitor } from "./LexicalGenericHTMLNodeVisitor.js";
+import { system } from "../../gurx/realmFactory.js";
+import { realmPlugin } from "../../gurx/react.js";
+const NESTED_EDITOR_UPDATED_COMMAND = createCommand("NESTED_EDITOR_UPDATED_COMMAND");
+const coreSystem = system((r) => {
+  function createAppendNodeFor(node) {
+    const appendNode = r.node();
+    r.link(
+      r.pipe(
+        appendNode,
+        r.o.withLatestFrom(node),
+        r.o.map(([newValue, values]) => {
+          if (values.includes(newValue)) {
+            return values;
+          }
+          return [...values, newValue];
+        })
+      ),
+      node
+    );
+    return appendNode;
+  }
+  const rootEditor = r.node(null);
+  const activeEditor = r.node(null, true);
+  const contentEditableClassName = r.node("");
+  const readOnly = r.node(false);
+  const placeholder = r.node("");
+  const autoFocus = r.node(false);
+  const inFocus = r.node(false, true);
+  const currentFormat = r.node(0, true);
+  const markdownProcessingError = r.node(null);
+  const markdownErrorSignal = r.node();
+  r.link(
+    r.pipe(
+      markdownProcessingError,
+      r.o.filter((e) => e !== null)
+    ),
+    markdownErrorSignal
+  );
+  const applyFormat = r.node();
+  const currentSelection = r.node(null);
+  const activeEditorSubscriptions = r.node([]);
+  const rootEditorSubscriptions = r.node([]);
+  const editorInFocus = r.node(null);
+  const onBlur = r.node();
+  const iconComponentFor = r.node((name) => {
+    throw new Error(`No icon component for ${name}`);
+  });
+  const rebind = () => r.o.scan((teardowns, [subs, activeEditorValue]) => {
+    teardowns.forEach((teardown) => {
+      if (!teardown) {
+        throw new Error("You have a subscription that does not return a teardown");
+      }
+      teardown();
+    });
+    return activeEditorValue ? subs.map((s) => s(activeEditorValue)) : [];
+  }, []);
+  r.pipe(r.combine(activeEditorSubscriptions, activeEditor), rebind());
+  r.pipe(r.combine(rootEditorSubscriptions, rootEditor), rebind());
+  const createRootEditorSubscription = createAppendNodeFor(rootEditorSubscriptions);
+  const createActiveEditorSubscription = createAppendNodeFor(activeEditorSubscriptions);
+  function handleSelectionChange() {
+    const selection = $getSelection();
+    if ($isRangeSelection(selection)) {
+      r.pubKeys({
+        currentSelection: selection,
+        currentFormat: selection.format
+      });
+    }
+  }
+  r.pub(createRootEditorSubscription, (theRootEditor) => {
+    return theRootEditor.registerCommand(
+      SELECTION_CHANGE_COMMAND,
+      (_, theActiveEditor) => {
+        r.pubIn({
+          [activeEditor.key]: theActiveEditor,
+          [inFocus.key]: true
+        });
+        if (theActiveEditor._parentEditor === null) {
+          theActiveEditor.getEditorState().read(() => {
+            r.pub(editorInFocus, {
+              rootNode: $getRoot(),
+              editorType: "lexical"
+            });
+          });
+        }
+        handleSelectionChange();
+        return false;
+      },
+      COMMAND_PRIORITY_CRITICAL
+    );
+  });
+  r.pub(createRootEditorSubscription, (theRootEditor) => {
+    return theRootEditor.registerUpdateListener(({ dirtyElements, dirtyLeaves, editorState }) => {
+      const err = r.getValue(markdownProcessingError);
+      if (err !== null) {
+        return;
+      }
+      if (dirtyElements.size === 0 && dirtyLeaves.size === 0) {
+        return;
+      }
+      let theNewMarkdownValue;
+      editorState.read(() => {
+        theNewMarkdownValue = exportMarkdownFromLexical({
+          root: $getRoot(),
+          visitors: r.getValue(exportVisitors),
+          jsxComponentDescriptors: r.getValue(jsxComponentDescriptors),
+          toMarkdownExtensions: r.getValue(toMarkdownExtensions),
+          toMarkdownOptions: r.getValue(toMarkdownOptions),
+          jsxIsAvailable: r.getValue(jsxIsAvailable)
+        });
+      });
+      r.pub(markdown, theNewMarkdownValue.trim());
+    });
+  });
+  const initialMarkdown = r.node("");
+  const markdown = r.node("", true);
+  const markdownSignal = r.node();
+  r.link(markdown, markdownSignal);
+  r.link(initialMarkdown, markdown);
+  const importVisitors = r.node([]);
+  const syntaxExtensions = r.node([]);
+  const mdastExtensions = r.node([]);
+  const usedLexicalNodes = r.node([]);
+  const exportVisitors = r.node([]);
+  const toMarkdownExtensions = r.node([]);
+  const toMarkdownOptions = r.node({}, true);
+  const jsxIsAvailable = r.node(false);
+  const jsxComponentDescriptors = r.node([]);
+  const editorRootElementRef = r.node(null);
+  const addLexicalNode = createAppendNodeFor(usedLexicalNodes);
+  const addImportVisitor = createAppendNodeFor(importVisitors);
+  const addSyntaxExtension = createAppendNodeFor(syntaxExtensions);
+  const addMdastExtension = createAppendNodeFor(mdastExtensions);
+  const addExportVisitor = createAppendNodeFor(exportVisitors);
+  const addToMarkdownExtension = createAppendNodeFor(toMarkdownExtensions);
+  const setMarkdown = r.node();
+  function tryImportingMarkdown(markdownValue) {
+    try {
+      importMarkdownToLexical({
+        root: $getRoot(),
+        visitors: r.getValue(importVisitors),
+        mdastExtensions: r.getValue(mdastExtensions),
+        markdown: markdownValue,
+        syntaxExtensions: r.getValue(syntaxExtensions)
+      });
+      r.pub(markdownProcessingError, null);
+    } catch (e) {
+      if (e instanceof MarkdownParseError || e instanceof UnrecognizedMarkdownConstructError) {
+        r.pubIn({
+          [markdown.key]: markdownValue,
+          [markdownProcessingError.key]: {
+            error: e.message,
+            source: markdown
+          }
+        });
+      } else {
+        throw e;
+      }
+    }
+  }
+  r.sub(
+    r.pipe(
+      setMarkdown,
+      r.o.withLatestFrom(markdown, rootEditor, inFocus),
+      r.o.filter(([newMarkdown, oldMarkdown]) => {
+        return newMarkdown.trim() !== oldMarkdown.trim();
+      })
+    ),
+    ([theNewMarkdownValue, , editor, inFocus2]) => {
+      editor == null ? void 0 : editor.update(() => {
+        $getRoot().clear();
+        tryImportingMarkdown(theNewMarkdownValue);
+        if (!inFocus2) {
+          $setSelection(null);
+        } else {
+          editor.focus();
+        }
+      });
+    }
+  );
+  const initialRootEditorState = r.node((theRootEditor) => {
+    r.pub(rootEditor, theRootEditor);
+    r.pub(activeEditor, theRootEditor);
+    tryImportingMarkdown(r.getValue(initialMarkdown));
+    const autoFocusValue = r.getValue(autoFocus);
+    if (autoFocusValue) {
+      if (autoFocusValue === true) {
+        setTimeout(() => theRootEditor.focus(noop, { defaultSelection: "rootStart" }));
+        return;
+      }
+      setTimeout(
+        () => theRootEditor.focus(noop, {
+          defaultSelection: autoFocusValue.defaultSelection ?? "rootStart"
+        })
+      );
+    }
+  });
+  r.pub(createActiveEditorSubscription, (editor) => {
+    return editor.registerUpdateListener(({ editorState }) => {
+      editorState.read(() => {
+        handleSelectionChange();
+      });
+    });
+  });
+  r.pub(createActiveEditorSubscription, (theEditor) => {
+    return theEditor.registerCommand(
+      BLUR_COMMAND,
+      (payload) => {
+        var _a;
+        const theRootEditor = r.getValue(rootEditor);
+        if (theRootEditor) {
+          const movingOutside = !((_a = theRootEditor.getRootElement()) == null ? void 0 : _a.contains(payload.relatedTarget));
+          if (movingOutside) {
+            r.pubIn({
+              [inFocus.key]: false,
+              [onBlur.key]: payload
+            });
+          }
+        }
+        return false;
+      },
+      COMMAND_PRIORITY_CRITICAL
+    );
+  });
+  r.pub(createRootEditorSubscription, (theEditor) => {
+    return theEditor.registerCommand(
+      FOCUS_COMMAND,
+      () => {
+        r.pub(inFocus, true);
+        return false;
+      },
+      COMMAND_PRIORITY_CRITICAL
+    );
+  });
+  r.pub(createRootEditorSubscription, (theRootEditor) => {
+    return theRootEditor.registerCommand(
+      KEY_DOWN_COMMAND,
+      (event) => {
+        const { keyCode, ctrlKey, metaKey } = event;
+        if (keyCode === 65 && controlOrMeta(metaKey, ctrlKey)) {
+          let shouldOverride = false;
+          theRootEditor.getEditorState().read(() => {
+            shouldOverride = $isDecoratorNode($getRoot().getFirstChild()) || $isDecoratorNode($getRoot().getLastChild());
+          });
+          if (shouldOverride) {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            theRootEditor.update(() => {
+              var _a;
+              const rootElement = theRootEditor.getRootElement();
+              (_a = window.getSelection()) == null ? void 0 : _a.selectAllChildren(rootElement);
+              rootElement.focus({
+                preventScroll: true
+              });
+            });
+            return true;
+          }
+        }
+        return false;
+      },
+      COMMAND_PRIORITY_CRITICAL
+    );
+  });
+  const composerChildren = r.node([]);
+  const addComposerChild = createAppendNodeFor(composerChildren);
+  const topAreaChildren = r.node([]);
+  const addTopAreaChild = createAppendNodeFor(topAreaChildren);
+  const editorWrappers = r.node([]);
+  const addEditorWrapper = createAppendNodeFor(editorWrappers);
+  const nestedEditorChildren = r.node([]);
+  const addNestedEditorChild = createAppendNodeFor(nestedEditorChildren);
+  const historyState = r.node(createEmptyHistoryState());
+  r.sub(r.pipe(applyFormat, r.o.withLatestFrom(activeEditor)), ([format, theEditor]) => {
+    theEditor == null ? void 0 : theEditor.dispatchCommand(FORMAT_TEXT_COMMAND, format);
+  });
+  const currentBlockType = r.node("");
+  const applyBlockType = r.node();
+  r.sub(r.pipe(currentSelection, r.o.withLatestFrom(activeEditor)), ([selection, theEditor]) => {
+    if (!selection || !theEditor) {
+      return;
+    }
+    const anchorNode = selection.anchor.getNode();
+    let element = anchorNode.getKey() === "root" ? anchorNode : $findMatchingParent(anchorNode, (e) => {
+      const parent = e.getParent();
+      return parent !== null && $isRootOrShadowRoot(parent);
+    });
+    if (element === null) {
+      element = anchorNode.getTopLevelElementOrThrow();
+    }
+    const elementKey = element.getKey();
+    const elementDOM = theEditor.getElementByKey(elementKey);
+    if (elementDOM !== null) {
+      const blockType = $isHeadingNode(element) ? element.getTag() : element.getType();
+      r.pub(currentBlockType, blockType);
+    }
+  });
+  const convertSelectionToNode = r.node();
+  r.sub(r.pipe(convertSelectionToNode, r.o.withLatestFrom(activeEditor)), ([factory, editor]) => {
+    editor == null ? void 0 : editor.update(() => {
+      const selection = $getSelection();
+      if ($isRangeSelection(selection)) {
+        $setBlocksType(selection, factory);
+        setTimeout(() => {
+          editor.focus();
+        });
+      }
+    });
+  });
+  const insertDecoratorNode = r.node();
+  r.sub(r.pipe(insertDecoratorNode, r.o.withLatestFrom(activeEditor)), ([nodeFactory, theEditor]) => {
+    theEditor == null ? void 0 : theEditor.focus(
+      () => {
+        theEditor.getEditorState().read(() => {
+          const selection = $getSelection();
+          if ($isRangeSelection(selection)) {
+            const focusNode = selection.focus.getNode();
+            if (focusNode !== null) {
+              theEditor.update(() => {
+                const node = nodeFactory();
+                if (node.isInline()) {
+                  $insertNodes([node]);
+                  if ($isRootOrShadowRoot(node.getParentOrThrow())) {
+                    $wrapNodeInElement(node, $createParagraphNode).selectEnd();
+                  }
+                } else {
+                  $insertNodeToNearestRoot(node);
+                }
+                if ("select" in node && typeof node.select === "function") {
+                  setTimeout(() => node.select());
+                }
+              });
+              setTimeout(() => {
+                theEditor.dispatchCommand(NESTED_EDITOR_UPDATED_COMMAND, void 0);
+              });
+            }
+          }
+        });
+      },
+      { defaultSelection: "rootEnd" }
+    );
+  });
+  r.sub(r.pipe(readOnly, r.o.withLatestFrom(rootEditor)), ([readOnly2, theRootEditor]) => {
+    theRootEditor == null ? void 0 : theRootEditor.setEditable(!readOnly2);
+  });
+  return {
+    // state
+    activeEditor,
+    inFocus,
+    historyState,
+    currentSelection,
+    // jsx
+    jsxIsAvailable,
+    jsxComponentDescriptors,
+    // lexical editor
+    initialRootEditorState,
+    rootEditor,
+    createRootEditorSubscription,
+    createActiveEditorSubscription,
+    // import
+    importVisitors,
+    syntaxExtensions,
+    mdastExtensions,
+    usedLexicalNodes,
+    addImportVisitor,
+    addLexicalNode,
+    addSyntaxExtension,
+    addMdastExtension,
+    // export
+    toMarkdownExtensions,
+    toMarkdownOptions,
+    addToMarkdownExtension,
+    addExportVisitor,
+    exportVisitors,
+    // markdown strings
+    initialMarkdown,
+    setMarkdown,
+    markdown,
+    markdownSignal,
+    // DOM
+    editorRootElementRef,
+    contentEditableClassName,
+    placeholder,
+    autoFocus,
+    readOnly,
+    // child controls
+    composerChildren,
+    addComposerChild,
+    topAreaChildren,
+    addTopAreaChild,
+    nestedEditorChildren,
+    addNestedEditorChild,
+    editorWrappers,
+    addEditorWrapper,
+    // editor content state and commands
+    currentFormat,
+    editorInFocus,
+    applyFormat,
+    currentBlockType,
+    applyBlockType,
+    convertSelectionToNode,
+    insertDecoratorNode,
+    // Events
+    onBlur,
+    iconComponentFor,
+    // error handling
+    markdownProcessingError,
+    markdownErrorSignal
+  };
+}, []);
+const [
+  /** @internal */
+  corePlugin,
+  /** @internal */
+  corePluginHooks
+] = realmPlugin({
+  id: "core",
+  systemSpec: coreSystem,
+  applyParamsToSystem(realm, params) {
+    realm.pubKeys({
+      contentEditableClassName: params.contentEditableClassName,
+      toMarkdownOptions: params.toMarkdownOptions,
+      autoFocus: params.autoFocus,
+      placeholder: params.placeholder,
+      readOnly: params.readOnly
+    });
+    realm.singletonSubKey("markdownSignal", params.onChange);
+    realm.singletonSubKey("onBlur", params.onBlur);
+    realm.singletonSubKey("markdownErrorSignal", params.onError);
+  },
+  init(realm, params) {
+    realm.pubKey("initialMarkdown", params.initialMarkdown.trim());
+    realm.pubKey("iconComponentFor", params.iconComponentFor);
+    realm.pubKey("addImportVisitor", MdastRootVisitor);
+    realm.pubKey("addImportVisitor", MdastParagraphVisitor);
+    realm.pubKey("addImportVisitor", MdastTextVisitor);
+    realm.pubKey("addImportVisitor", MdastFormattingVisitor);
+    realm.pubKey("addImportVisitor", MdastInlineCodeVisitor);
+    realm.pubKey("addImportVisitor", MdastBreakVisitor);
+    realm.pubKey("addLexicalNode", ParagraphNode);
+    realm.pubKey("addLexicalNode", TextNode);
+    realm.pubKey("addLexicalNode", GenericHTMLNode);
+    realm.pubKey("addExportVisitor", LexicalRootVisitor);
+    realm.pubKey("addExportVisitor", LexicalParagraphVisitor);
+    realm.pubKey("addExportVisitor", LexicalTextVisitor);
+    realm.pubKey("addExportVisitor", LexicalLinebreakVisitor);
+    realm.pubKey("addExportVisitor", LexicalGenericHTMLVisitor);
+    realm.pubKey("addComposerChild", SharedHistoryPlugin);
+    if (!params.suppressHtmlProcessing) {
+      realm.pubKey("addMdastExtension", mdxJsxFromMarkdown());
+      realm.pubKey("addSyntaxExtension", mdxJsx());
+      realm.pubKey("addToMarkdownExtension", mdxJsxToMarkdown());
+      realm.pubKey("addImportVisitor", MdastHTMLVisitor);
+    }
+  }
+});
+export {
+  $createGenericHTMLNode,
+  $isGenericHTMLNode,
+  GenericHTMLNode,
+  NESTED_EDITOR_UPDATED_COMMAND,
+  corePlugin,
+  corePluginHooks,
+  coreSystem
+};

package/dist/plugins/core/ui/DownshiftAutoComplete.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { Control, UseFormSetValue, UseFormRegister } from 'react-hook-form';
+interface DownshiftAutoCompleteProps {
+    suggestions: string[];
+    control: Control<any, any>;
+    setValue: UseFormSetValue<any>;
+    register: UseFormRegister<any>;
+    placeholder: string;
+    inputName: string;
+    autofocus?: boolean;
+    initialInputValue: string;
+}
+export declare const DownshiftAutoComplete: React.FC<DownshiftAutoCompleteProps>;
+export declare const DownshiftAutoCompleteWithSuggestions: React.FC<DownshiftAutoCompleteProps>;
+export {};

package/dist/plugins/core/ui/DownshiftAutoComplete.js

@@ -0,0 +1,83 @@
+import { useCombobox } from "downshift";
+import React__default from "react";
+import { Controller } from "react-hook-form";
+import styles from "../../../styles/ui.module.css.js";
+import { corePluginHooks } from "../index.js";
+const MAX_SUGGESTIONS = 20;
+const DownshiftAutoComplete = (props) => {
+  if (props.suggestions.length > 0) {
+    return /* @__PURE__ */ React__default.createElement(DownshiftAutoCompleteWithSuggestions, { ...props });
+  } else {
+    return /* @__PURE__ */ React__default.createElement("input", { className: styles.textInput, size: 40, autoFocus: true, ...props.register(props.inputName) });
+  }
+};
+const DownshiftAutoCompleteWithSuggestions = ({
+  autofocus,
+  suggestions,
+  control,
+  inputName,
+  placeholder,
+  initialInputValue,
+  setValue
+}) => {
+  const [items, setItems] = React__default.useState(suggestions.slice(0, MAX_SUGGESTIONS));
+  const [iconComponentFor] = corePluginHooks.useEmitterValues("iconComponentFor");
+  const enableAutoComplete = suggestions.length > 0;
+  const { isOpen, getToggleButtonProps, getMenuProps, getInputProps, highlightedIndex, getItemProps, selectedItem } = useCombobox({
+    initialInputValue,
+    onInputValueChange({ inputValue = "" }) {
+      setValue(inputName, inputValue);
+      inputValue = (inputValue == null ? void 0 : inputValue.toLowerCase()) || "";
+      const matchingItems = [];
+      for (const suggestion of suggestions) {
+        if (suggestion.toLowerCase().includes(inputValue)) {
+          matchingItems.push(suggestion);
+          if (matchingItems.length >= MAX_SUGGESTIONS) {
+            break;
+          }
+        }
+      }
+      setItems(matchingItems);
+    },
+    items,
+    itemToString(item) {
+      return item ?? "";
+    }
+  });
+  const dropdownIsVisible = isOpen && items.length > 0;
+  return /* @__PURE__ */ React__default.createElement("div", { className: styles.downshiftAutocompleteContainer }, /* @__PURE__ */ React__default.createElement("div", { "data-visible-dropdown": dropdownIsVisible, className: styles.downshiftInputWrapper }, /* @__PURE__ */ React__default.createElement(
+    Controller,
+    {
+      name: inputName,
+      control,
+      render: ({ field }) => {
+        const downshiftSrcProps = getInputProps();
+        return /* @__PURE__ */ React__default.createElement(
+          "input",
+          {
+            ...downshiftSrcProps,
+            name: field.name,
+            placeholder,
+            className: styles.downshiftInput,
+            size: 30,
+            "data-editor-dialog": true,
+            autoFocus: autofocus
+          }
+        );
+      }
+    }
+  ), enableAutoComplete && /* @__PURE__ */ React__default.createElement("button", { "aria-label": "toggle menu", type: "button", ...getToggleButtonProps() }, iconComponentFor("arrow_drop_down"))), /* @__PURE__ */ React__default.createElement("div", { className: styles.downshiftAutocompleteContainer }, /* @__PURE__ */ React__default.createElement("ul", { ...getMenuProps(), "data-visible": dropdownIsVisible }, items.map((item, index) => /* @__PURE__ */ React__default.createElement(
+    "li",
+    {
+      "data-selected": selectedItem === item,
+      "data-highlighted": highlightedIndex === index,
+      key: `${item}${index}`,
+      ...getItemProps({ item, index })
+    },
+    item
+  )))));
+};
+export {
+  DownshiftAutoComplete,
+  DownshiftAutoCompleteWithSuggestions
+};

package/dist/plugins/core/ui/PopoverUtils.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import * as RadixPopover from '@radix-ui/react-popover';
+export declare const PopoverPortal: (props: RadixPopover.PopoverPortalProps) => React.JSX.Element;
+export declare const PopoverContent: React.ForwardRefExoticComponent<Omit<RadixPopover.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<any>>;

package/dist/plugins/core/ui/PopoverUtils.js

@@ -0,0 +1,17 @@
+import React__default from "react";
+import * as RadixPopover from "@radix-ui/react-popover";
+import { corePluginHooks } from "../index.js";
+import styles from "../../../styles/ui.module.css.js";
+const PopoverPortal = (props) => {
+  const [editorRootElementRef] = corePluginHooks.useEmitterValues("editorRootElementRef");
+  return /* @__PURE__ */ React__default.createElement(RadixPopover.Portal, { ...props, container: editorRootElementRef == null ? void 0 : editorRootElementRef.current });
+};
+const PopoverContent = React__default.forwardRef(
+  (props, ref) => {
+    return /* @__PURE__ */ React__default.createElement(RadixPopover.Content, { ...props, className: styles.popoverContent, sideOffset: 5, side: "top", ref }, /* @__PURE__ */ React__default.createElement("span", { className: styles.popoverArrow }, /* @__PURE__ */ React__default.createElement(RadixPopover.Arrow, null)), props.children);
+  }
+);
+export {
+  PopoverContent,
+  PopoverPortal
+};

package/dist/plugins/diff-source/DiffSourceWrapper.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const DiffSourceWrapper: React.FC<{
+    children: React.ReactNode;
+}>;

package/dist/plugins/diff-source/DiffSourceWrapper.js

@@ -0,0 +1,14 @@
+import React__default from "react";
+import { diffSourcePluginHooks } from "./index.js";
+import { DiffViewer } from "./DiffViewer.js";
+import { SourceEditor } from "./SourceEditor.js";
+import { corePluginHooks } from "../core/index.js";
+import styles from "../../styles/ui.module.css.js";
+const DiffSourceWrapper = ({ children }) => {
+  const [error] = corePluginHooks.useEmitterValues("markdownProcessingError");
+  const [viewMode] = diffSourcePluginHooks.useEmitterValues("viewMode");
+  return /* @__PURE__ */ React__default.createElement("div", null, error ? /* @__PURE__ */ React__default.createElement("div", { className: styles.markdownParseError }, /* @__PURE__ */ React__default.createElement("p", null, error.error, "."), /* @__PURE__ */ React__default.createElement("p", null, "You can fix the errors in source mode and switch to rich text mode when you are ready.")) : null, /* @__PURE__ */ React__default.createElement("div", { style: { display: viewMode === "rich-text" && error == null ? "block" : "none" } }, children), viewMode === "diff" ? /* @__PURE__ */ React__default.createElement(DiffViewer, null) : null, viewMode === "source" ? /* @__PURE__ */ React__default.createElement(SourceEditor, null) : null);
+};
+export {
+  DiffSourceWrapper
+};

package/dist/plugins/diff-source/DiffViewer.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const DiffViewer: React.FC;