@mdxeditor/editor 0.0.1 → 0.0.4-development

package/dist/importMarkdownToLexical.d.ts

@@ -0,0 +1,101 @@
+import { LexicalNode, RootNode as LexicalRootNode } from 'lexical';
+import * as Mdast from 'mdast';
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import { ParseOptions } from 'micromark-util-types';
+import { IS_BOLD, IS_CODE, IS_ITALIC, IS_UNDERLINE } from './FormatConstants';
+/** @internal */
+export type MdastExtensions = NonNullable<Parameters<typeof fromMarkdown>[1]>['mdastExtensions'];
+/**
+ * A set of actions that can be used to modify the lexical tree while visiting the mdast tree.
+ */
+export interface MdastVisitActions {
+    /**
+     * Iterate the children of the node with the lexical node as the parent.
+     */
+    visitChildren(node: Mdast.Parent, lexicalParent: LexicalNode): void;
+    /**
+     * Add the given node to the lexical tree, and iterate the current mdast node's children with the newly created lexical node as a parent.
+     */
+    addAndStepInto(lexicalNode: LexicalNode): void;
+    /**
+     * 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.Content): void;
+    /**
+     * 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.
+     */
+    removeFormatting(format: typeof IS_BOLD | typeof IS_ITALIC | typeof IS_UNDERLINE | typeof IS_CODE, node?: Mdast.Content): void;
+    /**
+     * Access the current formatting context.
+     */
+    getParentFormatting(): number;
+}
+/**
+ * Parameters passed to the {@link MdastImportVisitor.visitNode} function.
+ * @param mdastNode - The node that is currently being visited.
+ * @param lexicalParent - The parent lexical node to which the results of the processing should be added.
+ * @param actions - A set of convenience utilities that can be used to add nodes to the lexical tree.
+ * @typeParam T - The type of the mdast node that is being visited.
+ */
+export interface MdastVisitParams<T extends Mdast.Content> {
+    mdastNode: T;
+    mdastParent: Mdast.Parent | null;
+    lexicalParent: LexicalNode;
+    actions: MdastVisitActions;
+}
+/**
+ * Implement this interface to convert certian mdast nodes into lexical nodes.
+ * @typeParam UN - The type of the mdast node that is being visited.
+ */
+export interface MdastImportVisitor<UN extends Mdast.Content> {
+    /**
+     * 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.
+     */
+    testNode: ((mdastNode: Mdast.Content | Mdast.Root) => boolean) | string;
+    /**
+     * The function that is called when the node is visited. See {@link MdastVisitParams} for details.
+     */
+    visitNode(params: MdastVisitParams<UN>): void;
+    /**
+     * Default 0, optional, sets the priority of the visitor. The higher the number, the earlier it will be called.
+     */
+    priority?: number;
+}
+/**
+ * The options of the tree import utility. Not meant to be used directly.
+ * @internal
+ */
+export interface MdastTreeImportOptions {
+    root: LexicalRootNode;
+    visitors: MdastImportVisitor<Mdast.Content>[];
+    mdastRoot: Mdast.Root;
+}
+/** @internal */
+export interface MarkdownParseOptions extends Omit<MdastTreeImportOptions, 'mdastRoot'> {
+    markdown: string;
+    syntaxExtensions: NonNullable<ParseOptions['extensions']>;
+    mdastExtensions: MdastExtensions;
+}
+/**
+ * An extension for the `fromMarkdown` utility tree construction.
+ * @internal
+ */
+export type MdastExtension = NonNullable<MdastExtensions>[number];
+/**
+ * An extension for the `fromMarkdown` utility markdown parse.
+ * @internal
+ */
+export type SyntaxExtension = MarkdownParseOptions['syntaxExtensions'][number];
+export declare class MarkdownParseError extends Error {
+    constructor(message: string, cause: unknown);
+}
+export declare class UnrecognizedMarkdownConstructError extends Error {
+    constructor(message: string);
+}
+/** @internal */
+export declare function importMarkdownToLexical({ root, markdown, visitors, syntaxExtensions, mdastExtensions }: MarkdownParseOptions): void;
+/** @internal */
+export declare function importMdastTreeToLexical({ root, mdastRoot, visitors }: MdastTreeImportOptions): void;

package/dist/importMarkdownToLexical.js

@@ -0,0 +1,93 @@
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { toMarkdown } from "mdast-util-to-markdown";
+function isParent(node) {
+  return node.children instanceof Array;
+}
+class MarkdownParseError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = "MarkdownParseError";
+    this.cause = cause;
+  }
+}
+class UnrecognizedMarkdownConstructError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnrecognizedMarkdownConstructError";
+  }
+}
+function importMarkdownToLexical({ root, markdown, visitors, syntaxExtensions, mdastExtensions }) {
+  var _a;
+  let mdastRoot;
+  try {
+    mdastRoot = fromMarkdown(markdown, {
+      extensions: syntaxExtensions,
+      mdastExtensions
+    });
+  } catch (e) {
+    if (e instanceof Error) {
+      throw new MarkdownParseError(`Error parsing markdown: ${e.message}`, e);
+    } else {
+      throw new MarkdownParseError(`Error parsing markdown: ${e}`, e);
+    }
+  }
+  if (mdastRoot.children.length === 0) {
+    mdastRoot.children.push({ type: "paragraph", children: [] });
+  }
+  if (((_a = mdastRoot.children.at(-1)) == null ? void 0 : _a.type) !== "paragraph") {
+    mdastRoot.children.push({ type: "paragraph", children: [] });
+  }
+  importMdastTreeToLexical({ root, mdastRoot, visitors });
+}
+function importMdastTreeToLexical({ root, mdastRoot, visitors }) {
+  const formattingMap = /* @__PURE__ */ new WeakMap();
+  visitors = visitors.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  function visitChildren(mdastNode, lexicalParent) {
+    if (!isParent(mdastNode)) {
+      throw new Error("Attempting to visit children of a non-parent");
+    }
+    mdastNode.children.forEach((child) => visit(child, lexicalParent, mdastNode));
+  }
+  function visit(mdastNode, lexicalParent, mdastParent) {
+    const visitor = visitors.find((visitor2) => {
+      if (typeof visitor2.testNode === "string") {
+        return visitor2.testNode === mdastNode.type;
+      }
+      return visitor2.testNode(mdastNode);
+    });
+    if (!visitor) {
+      throw new UnrecognizedMarkdownConstructError(`Unsupported markdown syntax: ${toMarkdown(mdastNode)}`);
+    }
+    visitor.visitNode({
+      //@ts-expect-error root type is glitching
+      mdastNode,
+      lexicalParent,
+      mdastParent,
+      actions: {
+        visitChildren,
+        addAndStepInto(lexicalNode) {
+          lexicalParent.append(lexicalNode);
+          if (isParent(mdastNode)) {
+            visitChildren(mdastNode, lexicalNode);
+          }
+        },
+        addFormatting(format, node = mdastNode) {
+          formattingMap.set(node, format | (formattingMap.get(mdastParent) ?? 0));
+        },
+        removeFormatting(format, node = mdastNode) {
+          formattingMap.set(node, format ^ (formattingMap.get(mdastParent) ?? 0));
+        },
+        getParentFormatting() {
+          return formattingMap.get(mdastParent) ?? 0;
+        }
+      }
+    });
+  }
+  visit(mdastRoot, root, null);
+}
+export {
+  MarkdownParseError,
+  UnrecognizedMarkdownConstructError,
+  importMarkdownToLexical,
+  importMdastTreeToLexical
+};