@mdxeditor/editor 0.9.0 → 0.10.0-alpha.1

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

@@ -0,0 +1,55 @@
+import { coreSystem } from "../core/index.js";
+import { DiffSourceWrapper } from "./DiffSourceWrapper.js";
+import { system } from "../../gurx/realmFactory.js";
+import { realmPlugin } from "../../gurx/react.js";
+const diffSourceSystem = system(
+  (r, [{ markdown, setMarkdown }]) => {
+    const diffMarkdown = r.node("");
+    const markdownSourceEditorValue = r.node("");
+    r.link(markdown, markdownSourceEditorValue);
+    const viewMode = r.node("rich-text");
+    r.sub(
+      r.pipe(
+        viewMode,
+        r.o.scan(
+          (prev, next) => {
+            return {
+              current: prev.next,
+              next
+            };
+          },
+          { current: "rich-text", next: "rich-text" }
+        ),
+        r.o.withLatestFrom(markdownSourceEditorValue)
+      ),
+      ([{ current }, markdownSourceFromEditor]) => {
+        if (current === "source") {
+          r.pub(setMarkdown, markdownSourceFromEditor);
+        }
+      }
+    );
+    return { viewMode, diffMarkdown, markdownSourceEditorValue };
+  },
+  [coreSystem]
+);
+const [
+  /** @internal */
+  diffSourcePlugin,
+  /** @internal */
+  diffSourcePluginHooks
+] = realmPlugin({
+  id: "diff-source",
+  systemSpec: diffSourceSystem,
+  applyParamsToSystem(r, params) {
+    r.pubKey("viewMode", (params == null ? void 0 : params.viewMode) || "rich-text");
+  },
+  init(r, params) {
+    r.pubKey("diffMarkdown", (params == null ? void 0 : params.diffMarkdown) || "");
+    r.pubKey("addEditorWrapper", DiffSourceWrapper);
+  }
+});
+export {
+  diffSourcePlugin,
+  diffSourcePluginHooks,
+  diffSourceSystem
+};

package/dist/plugins/directives/DirectiveNode.d.ts

@@ -0,0 +1,51 @@
+import React from 'react';
+import type { EditorConfig, LexicalEditor, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
+import { DecoratorNode } from 'lexical';
+import { Directive } from 'mdast-util-directive';
+import { VoidEmitter } from '../../utils/voidEmitter';
+/**
+ * A serialized representation of an {@link DirectiveNode}.
+ */
+export type SerializedDirectiveNode = Spread<{
+    mdastNode: Directive;
+    type: 'directive';
+    version: 1;
+}, SerializedLexicalNode>;
+/**
+ * A lexical node that represents an image. Use {@link "$createDirectiveNode"} to construct one.
+ */
+export declare class DirectiveNode extends DecoratorNode<React.JSX.Element> {
+    __mdastNode: Directive;
+    __focusEmitter: {
+        publish: () => void;
+        subscribe: (cb: () => void) => void;
+    };
+    static getType(): string;
+    static clone(node: DirectiveNode): DirectiveNode;
+    static importJSON(serializedNode: SerializedDirectiveNode): DirectiveNode;
+    constructor(mdastNode: Directive, key?: NodeKey);
+    getMdastNode(): Directive;
+    exportJSON(): SerializedDirectiveNode;
+    createDOM(): HTMLElement;
+    updateDOM(): false;
+    setMdastNode(mdastNode: Directive): void;
+    select: () => void;
+    decorate(parentEditor: LexicalEditor, config: EditorConfig): JSX.Element;
+    isInline(): boolean;
+    isKeyboardSelectable(): boolean;
+}
+export declare function DirectiveEditorContainer(props: {
+    parentEditor: LexicalEditor;
+    lexicalNode: DirectiveNode;
+    mdastNode: Directive;
+    config: EditorConfig;
+    focusEmitter: VoidEmitter;
+}): React.JSX.Element;
+/**
+ * Creates an {@link DirectiveNode}.
+ */
+export declare function $createDirectiveNode(mdastNode: Directive, key?: NodeKey): DirectiveNode;
+/**
+ * Retruns true if the node is an {@link DirectiveNode}.
+ */
+export declare function $isDirectiveNode(node: LexicalNode | null | undefined): node is DirectiveNode;

package/dist/plugins/directives/DirectiveNode.js

@@ -0,0 +1,92 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import React__default from "react";
+import { DecoratorNode } from "lexical";
+import { NestedEditorsContext } from "../core/NestedLexicalEditor.js";
+import { directivesPluginHooks } from "./index.js";
+import { voidEmitter } from "../../utils/voidEmitter.js";
+let GENERATION = 0;
+class DirectiveNode extends DecoratorNode {
+  constructor(mdastNode, key) {
+    super(key);
+    __publicField(this, "__mdastNode");
+    __publicField(this, "__focusEmitter", voidEmitter());
+    __publicField(this, "select", () => {
+      this.__focusEmitter.publish();
+    });
+    this.__mdastNode = mdastNode;
+    this.generation = GENERATION++;
+  }
+  static getType() {
+    return "directive";
+  }
+  static clone(node) {
+    return new DirectiveNode(structuredClone(node.__mdastNode), node.__key);
+  }
+  static importJSON(serializedNode) {
+    return $createDirectiveNode(serializedNode.mdastNode);
+  }
+  getMdastNode() {
+    return this.__mdastNode;
+  }
+  exportJSON() {
+    return {
+      mdastNode: structuredClone(this.__mdastNode),
+      type: "directive",
+      version: 1
+    };
+  }
+  createDOM() {
+    return document.createElement(this.__mdastNode.type === "textDirective" ? "span" : "div");
+  }
+  updateDOM() {
+    return false;
+  }
+  setMdastNode(mdastNode) {
+    this.getWritable().__mdastNode = mdastNode;
+  }
+  decorate(parentEditor, config) {
+    return /* @__PURE__ */ React__default.createElement(
+      DirectiveEditorContainer,
+      {
+        lexicalNode: this,
+        mdastNode: this.getMdastNode(),
+        parentEditor,
+        config,
+        focusEmitter: this.__focusEmitter
+      }
+    );
+  }
+  isInline() {
+    return this.__mdastNode.type === "textDirective";
+  }
+  isKeyboardSelectable() {
+    return true;
+  }
+}
+function DirectiveEditorContainer(props) {
+  const { mdastNode } = props;
+  const [directiveDescriptors] = directivesPluginHooks.useEmitterValues("directiveDescriptors");
+  const descriptor = directiveDescriptors.find((descriptor2) => descriptor2.testNode(mdastNode));
+  if (!descriptor) {
+    throw new Error(`No descriptor found for directive ${mdastNode.name}`);
+  }
+  const Editor = descriptor.Editor;
+  return /* @__PURE__ */ React__default.createElement(NestedEditorsContext.Provider, { value: props }, /* @__PURE__ */ React__default.createElement(Editor, { descriptor, mdastNode, lexicalNode: props.lexicalNode, parentEditor: props.parentEditor }));
+}
+function $createDirectiveNode(mdastNode, key) {
+  return new DirectiveNode(mdastNode, key);
+}
+function $isDirectiveNode(node) {
+  return node instanceof DirectiveNode;
+}
+export {
+  $createDirectiveNode,
+  $isDirectiveNode,
+  DirectiveEditorContainer,
+  DirectiveNode
+};

package/dist/plugins/directives/DirectiveVisitor.d.ts

@@ -0,0 +1,4 @@
+import { LeafDirective } from 'mdast-util-directive';
+import { LexicalExportVisitor } from '../../exportMarkdownFromLexical';
+import { DirectiveNode } from './DirectiveNode';
+export declare const DirectiveVisitor: LexicalExportVisitor<DirectiveNode, LeafDirective>;

package/dist/plugins/directives/DirectiveVisitor.js

@@ -0,0 +1,10 @@
+import { $isDirectiveNode } from "./DirectiveNode.js";
+const DirectiveVisitor = {
+  testLexicalNode: $isDirectiveNode,
+  visitLexicalNode({ actions, mdastParent, lexicalNode }) {
+    actions.appendToParent(mdastParent, lexicalNode.getMdastNode());
+  }
+};
+export {
+  DirectiveVisitor
+};

package/dist/plugins/directives/MdastDirectiveVisitor.d.ts

@@ -0,0 +1,3 @@
+import { Directive } from 'mdast-util-directive';
+import { MdastImportVisitor } from '../../importMarkdownToLexical';
+export declare const MdastDirectiveVisitor: MdastImportVisitor<Directive>;

package/dist/plugins/directives/MdastDirectiveVisitor.js

@@ -0,0 +1,13 @@
+import { $createDirectiveNode } from "./DirectiveNode.js";
+const DIRECTIVE_TYPES = ["leafDirective", "containerDirective", "textDirective"];
+const MdastDirectiveVisitor = {
+  testNode: (node) => {
+    return DIRECTIVE_TYPES.includes(node.type);
+  },
+  visitNode({ lexicalParent, mdastNode }) {
+    lexicalParent.append($createDirectiveNode(mdastNode));
+  }
+};
+export {
+  MdastDirectiveVisitor
+};