@lexical/rich-text 0.1.17

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LexicalRichText.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type {
+  DOMConversionMap,
+  EditorConfig,
+  EditorState,
+  LexicalNode,
+  NodeKey,
+  ParagraphNode,
+} from 'lexical';
+export type InitialEditorStateType = null | string | EditorState | (() => void);
+
+export declare class QuoteNode extends ElementNode {
+  static getType(): string;
+  static clone(node: QuoteNode): QuoteNode;
+  constructor(key?: NodeKey): void;
+  createDOM<EditorContext>(config: EditorConfig<EditorContext>): HTMLElement;
+  updateDOM(prevNode: QuoteNode, dom: HTMLElement): boolean;
+  insertNewAfter(): ParagraphNode;
+  collapseAtStart(): true;
+}
+export function $createQuoteNode(): QuoteNode;
+export function $isQuoteNode(node: ?LexicalNode): boolean;
+export type HeadingTagType = 'h1' | 'h2' | 'h3' | 'h4' | 'h5';
+export declare class HeadingNode extends ElementNode {
+  __tag: HeadingTagType;
+  static getType(): string;
+  static clone(node: HeadingNode): HeadingNode;
+  constructor(tag: HeadingTagType, key?: NodeKey): void;
+  getTag(): HeadingTagType;
+  createDOM<EditorContext>(config: EditorConfig<EditorContext>): HTMLElement;
+  updateDOM(prevNode: HeadingNode, dom: HTMLElement): boolean;
+  static convertDOM(): DOMConversionMap | null;
+  insertNewAfter(): ParagraphNode;
+  collapseAtStart(): true;
+}
+export function $createHeadingNode(headingTag: HeadingTagType): HeadingNode;
+export function $isHeadingNode(node: ?LexicalNode): boolean;
+export function registerRichText(
+  editor: LexicalEditor,
+  initialEditorState?: InitialEditorStateType,
+): () => void;

package/LexicalRichText.dev.js

@@ -0,0 +1,592 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var clipboard = require('@lexical/clipboard');
+var selection = require('@lexical/selection');
+var utils = require('@lexical/utils');
+var lexical = require('lexical');
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+// Convoluted logic to make this work with Flow. Order matters.
+const options = {
+  tag: 'history-merge'
+};
+const setEditorOptions = options;
+const updateOptions = options;
+class QuoteNode extends lexical.ElementNode {
+  static getType() {
+    return 'quote';
+  }
+
+  static clone(node) {
+    return new QuoteNode(node.__key);
+  }
+
+  constructor(key) {
+    super(key);
+  } // View
+
+
+  createDOM(config) {
+    const element = document.createElement('blockquote');
+    utils.addClassNamesToElement(element, config.theme.quote);
+    return element;
+  }
+
+  updateDOM(prevNode, dom) {
+    return false;
+  } // Mutation
+
+
+  insertNewAfter() {
+    const newBlock = lexical.$createParagraphNode();
+    const direction = this.getDirection();
+    newBlock.setDirection(direction);
+    this.insertAfter(newBlock);
+    return newBlock;
+  }
+
+  collapseAtStart() {
+    const paragraph = lexical.$createParagraphNode();
+    const children = this.getChildren();
+    children.forEach(child => paragraph.append(child));
+    this.replace(paragraph);
+    return true;
+  }
+
+}
+function $createQuoteNode() {
+  return new QuoteNode();
+}
+function $isQuoteNode(node) {
+  return node instanceof QuoteNode;
+}
+class HeadingNode extends lexical.ElementNode {
+  static getType() {
+    return 'heading';
+  }
+
+  static clone(node) {
+    return new HeadingNode(node.__tag, node.__key);
+  }
+
+  constructor(tag, key) {
+    super(key);
+    this.__tag = tag;
+  }
+
+  getTag() {
+    return this.__tag;
+  } // View
+
+
+  createDOM(config) {
+    const tag = this.__tag;
+    const element = document.createElement(tag);
+    const theme = config.theme;
+    const classNames = theme.heading;
+
+    if (classNames !== undefined) {
+      // $FlowFixMe: intentional cast
+      const className = classNames[tag];
+      utils.addClassNamesToElement(element, className);
+    }
+
+    return element;
+  }
+
+  updateDOM(prevNode, dom) {
+    return false;
+  }
+
+  static convertDOM() {
+    return {
+      h1: node => ({
+        conversion: convertHeadingElement,
+        priority: 0
+      }),
+      h2: node => ({
+        conversion: convertHeadingElement,
+        priority: 0
+      }),
+      h3: node => ({
+        conversion: convertHeadingElement,
+        priority: 0
+      }),
+      h4: node => ({
+        conversion: convertHeadingElement,
+        priority: 0
+      }),
+      h5: node => ({
+        conversion: convertHeadingElement,
+        priority: 0
+      })
+    };
+  } // Mutation
+
+
+  insertNewAfter() {
+    const newElement = lexical.$createParagraphNode();
+    const direction = this.getDirection();
+    newElement.setDirection(direction);
+    this.insertAfter(newElement);
+    return newElement;
+  }
+
+  collapseAtStart() {
+    const paragraph = lexical.$createParagraphNode();
+    const children = this.getChildren();
+    children.forEach(child => paragraph.append(child));
+    this.replace(paragraph);
+    return true;
+  }
+
+}
+
+function convertHeadingElement(domNode) {
+  const nodeName = domNode.nodeName.toLowerCase();
+  let node = null;
+
+  if (nodeName === 'h1' || nodeName === 'h2' || nodeName === 'h3' || nodeName === 'h4' || nodeName === 'h5') {
+    node = $createHeadingNode(nodeName);
+  }
+
+  return {
+    node
+  };
+}
+
+function $createHeadingNode(headingTag) {
+  return new HeadingNode(headingTag);
+}
+function $isHeadingNode(node) {
+  return node instanceof HeadingNode;
+}
+
+function initializeEditor(editor, initialEditorState) {
+  if (initialEditorState === null) {
+    return;
+  } else if (initialEditorState === undefined) {
+    editor.update(() => {
+      const root = lexical.$getRoot();
+      const firstChild = root.getFirstChild();
+
+      if (firstChild === null) {
+        const paragraph = lexical.$createParagraphNode();
+        root.append(paragraph);
+        const activeElement = document.activeElement;
+
+        if (lexical.$getSelection() !== null || activeElement !== null && activeElement === editor.getRootElement()) {
+          paragraph.select();
+        }
+      }
+    }, updateOptions);
+  } else if (initialEditorState !== null) {
+    switch (typeof initialEditorState) {
+      case 'string':
+        {
+          const parsedEditorState = editor.parseEditorState(initialEditorState);
+          editor.setEditorState(parsedEditorState, setEditorOptions);
+          break;
+        }
+
+      case 'object':
+        {
+          editor.setEditorState(initialEditorState, setEditorOptions);
+          break;
+        }
+
+      case 'function':
+        {
+          editor.update(initialEditorState, updateOptions);
+          break;
+        }
+    }
+  }
+}
+
+function onPasteForRichText(event, editor) {
+  event.preventDefault();
+  editor.update(() => {
+    const selection = lexical.$getSelection();
+    const clipboardData = event.clipboardData;
+
+    if (clipboardData != null && lexical.$isRangeSelection(selection)) {
+      clipboard.$insertDataTransferForRichText(clipboardData, selection, editor);
+    }
+  });
+}
+
+function onCopyForRichText(event, editor) {
+  event.preventDefault();
+  editor.update(() => {
+    const clipboardData = event.clipboardData;
+    const selection = lexical.$getSelection();
+
+    if (selection !== null) {
+      if (clipboardData != null) {
+        const htmlString = clipboard.getHtmlContent(editor);
+        const lexicalString = clipboard.$getLexicalContent(editor);
+
+        if (htmlString !== null) {
+          clipboardData.setData('text/html', htmlString);
+        }
+
+        if (lexicalString !== null) {
+          clipboardData.setData('application/x-lexical-editor', lexicalString);
+        }
+
+        clipboardData.setData('text/plain', selection.getTextContent());
+      }
+    }
+  });
+}
+
+function onCutForRichText(event, editor) {
+  onCopyForRichText(event, editor);
+  editor.update(() => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isRangeSelection(selection)) {
+      selection.removeText();
+    }
+  });
+}
+
+function registerRichText(editor, initialEditorState) {
+  const removeListener = utils.mergeRegister(editor.registerCommand(lexical.CLICK_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isNodeSelection(selection)) {
+      selection.clear();
+      return true;
+    }
+
+    return false;
+  }, 0), editor.registerCommand(lexical.DELETE_CHARACTER_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    const isBackward = payload;
+    selection.deleteCharacter(isBackward);
+    return true;
+  }, 0), editor.registerCommand(lexical.DELETE_WORD_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    const isBackward = payload;
+    selection.deleteWord(isBackward);
+    return true;
+  }, 0), editor.registerCommand(lexical.DELETE_LINE_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    const isBackward = payload;
+    selection.deleteLine(isBackward);
+    return true;
+  }, 0), editor.registerCommand(lexical.INSERT_TEXT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    const eventOrText = payload;
+
+    if (typeof eventOrText === 'string') {
+      selection.insertText(eventOrText);
+    } else {
+      const dataTransfer = eventOrText.dataTransfer;
+
+      if (dataTransfer != null) {
+        clipboard.$insertDataTransferForRichText(dataTransfer, selection, editor);
+      } else {
+        const data = eventOrText.data;
+
+        if (data) {
+          selection.insertText(data);
+        }
+
+        return true;
+      }
+    }
+
+    return true;
+  }, 0), editor.registerCommand(lexical.REMOVE_TEXT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    selection.removeText();
+    return true;
+  }, 0), editor.registerCommand(lexical.FORMAT_TEXT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    const format = payload;
+    selection.formatText(format);
+    return true;
+  }, 0), editor.registerCommand(lexical.FORMAT_ELEMENT_COMMAND, format => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    const node = selection.anchor.getNode();
+    const element = lexical.$isElementNode(node) ? node : node.getParentOrThrow();
+    element.setFormat(format);
+    return true;
+  }, 0), editor.registerCommand(lexical.INSERT_LINE_BREAK_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    const selectStart = payload;
+    selection.insertLineBreak(selectStart);
+    return true;
+  }, 0), editor.registerCommand(lexical.INSERT_PARAGRAPH_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    selection.insertParagraph();
+    return true;
+  }, 0), editor.registerCommand(lexical.INDENT_CONTENT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    } // Handle code blocks
+
+
+    const anchor = selection.anchor;
+    const parentBlock = anchor.type === 'element' ? anchor.getNode() : anchor.getNode().getParentOrThrow();
+
+    if (parentBlock.canInsertTab()) {
+      editor.dispatchCommand(lexical.INSERT_TEXT_COMMAND, '\t');
+    } else {
+      if (parentBlock.getIndent() !== 10) {
+        parentBlock.setIndent(parentBlock.getIndent() + 1);
+      }
+    }
+
+    return true;
+  }, 0), editor.registerCommand(lexical.OUTDENT_CONTENT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    } // Handle code blocks
+
+
+    const anchor = selection.anchor;
+    const anchorNode = anchor.getNode();
+    const parentBlock = anchor.type === 'element' ? anchor.getNode() : anchor.getNode().getParentOrThrow();
+
+    if (parentBlock.canInsertTab()) {
+      const textContent = anchorNode.getTextContent();
+      const character = textContent[anchor.offset - 1];
+
+      if (character === '\t') {
+        editor.dispatchCommand(lexical.DELETE_CHARACTER_COMMAND, true);
+      }
+    } else {
+      if (parentBlock.getIndent() !== 0) {
+        parentBlock.setIndent(parentBlock.getIndent() - 1);
+      }
+    }
+
+    return true;
+  }, 0), editor.registerCommand(lexical.KEY_ARROW_LEFT_COMMAND, payload => {
+    const selection$1 = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection$1)) {
+      return false;
+    }
+
+    const event = payload;
+    const isHoldingShift = event.shiftKey;
+
+    if (selection.$shouldOverrideDefaultCharacterSelection(selection$1, true)) {
+      event.preventDefault();
+      selection.$moveCharacter(selection$1, isHoldingShift, true);
+      return true;
+    }
+
+    return false;
+  }, 0), editor.registerCommand(lexical.KEY_ARROW_RIGHT_COMMAND, payload => {
+    const selection$1 = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection$1)) {
+      return false;
+    }
+
+    const event = payload;
+    const isHoldingShift = event.shiftKey;
+
+    if (selection.$shouldOverrideDefaultCharacterSelection(selection$1, false)) {
+      event.preventDefault();
+      selection.$moveCharacter(selection$1, isHoldingShift, false);
+      return true;
+    }
+
+    return false;
+  }, 0), editor.registerCommand(lexical.KEY_BACKSPACE_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    const event = payload;
+    event.preventDefault();
+    const {
+      anchor
+    } = selection;
+
+    if (selection.isCollapsed() && anchor.offset === 0) {
+      const element = anchor.type === 'element' ? anchor.getNode() : anchor.getNode().getParentOrThrow();
+
+      if (element.getIndent() > 0) {
+        return editor.dispatchCommand(lexical.OUTDENT_CONTENT_COMMAND);
+      }
+    }
+
+    return editor.dispatchCommand(lexical.DELETE_CHARACTER_COMMAND, true);
+  }, 0), editor.registerCommand(lexical.KEY_DELETE_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    const event = payload;
+    event.preventDefault();
+    return editor.dispatchCommand(lexical.DELETE_CHARACTER_COMMAND, false);
+  }, 0), editor.registerCommand(lexical.KEY_ENTER_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    const event = payload;
+    event.preventDefault();
+
+    if (event.shiftKey) {
+      return editor.dispatchCommand(lexical.INSERT_LINE_BREAK_COMMAND);
+    }
+
+    return editor.dispatchCommand(lexical.INSERT_PARAGRAPH_COMMAND);
+  }, 0), editor.registerCommand(lexical.KEY_TAB_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    const event = payload;
+    event.preventDefault();
+    return editor.dispatchCommand(event.shiftKey ? lexical.OUTDENT_CONTENT_COMMAND : lexical.INDENT_CONTENT_COMMAND);
+  }, 0), editor.registerCommand(lexical.KEY_ESCAPE_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    editor.blur();
+    return true;
+  }, 0), editor.registerCommand(lexical.DROP_COMMAND, event => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    } // TODO: Make drag and drop work at some point.
+
+
+    event.preventDefault();
+    return true;
+  }, 0), editor.registerCommand(lexical.DRAGSTART_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    } // TODO: Make drag and drop work at some point.
+
+
+    const event = payload;
+    event.preventDefault();
+    return true;
+  }, 0), editor.registerCommand(lexical.COPY_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isRangeSelection(selection) || lexical.$isGridSelection(selection)) {
+      const event = payload;
+      onCopyForRichText(event, editor);
+      return true;
+    }
+
+    return false;
+  }, 0), editor.registerCommand(lexical.CUT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isRangeSelection(selection) || lexical.$isGridSelection(selection)) {
+      const event = payload;
+      onCutForRichText(event, editor);
+      return true;
+    }
+
+    return false;
+  }, 0), editor.registerCommand(lexical.PASTE_COMMAND, event => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isRangeSelection(selection) || lexical.$isGridSelection(selection)) {
+      onPasteForRichText(event, editor);
+      return true;
+    }
+
+    return false;
+  }, 0));
+  initializeEditor(editor, initialEditorState);
+  return removeListener;
+}
+
+exports.$createHeadingNode = $createHeadingNode;
+exports.$createQuoteNode = $createQuoteNode;
+exports.$isHeadingNode = $isHeadingNode;
+exports.$isQuoteNode = $isQuoteNode;
+exports.HeadingNode = HeadingNode;
+exports.QuoteNode = QuoteNode;
+exports.registerRichText = registerRichText;

package/LexicalRichText.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict'
+const LexicalRichText = process.env.NODE_ENV === 'development' ? require('./LexicalRichText.dev.js') : require('./LexicalRichText.prod.js')
+module.exports = LexicalRichText;

package/LexicalRichText.js.flow

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ */
+import type {
+  DOMConversionMap,
+  EditorConfig,
+  EditorState,
+  LexicalNode,
+  NodeKey,
+  ParagraphNode,
+  LexicalEditor,
+} from 'lexical';
+import {ElementNode} from 'lexical';
+export type InitialEditorStateType = null | string | EditorState | (() => void);
+
+declare export class QuoteNode extends ElementNode {
+  static getType(): string;
+  static clone(node: QuoteNode): QuoteNode;
+  constructor(key?: NodeKey): void;
+  createDOM<EditorContext>(config: EditorConfig<EditorContext>): HTMLElement;
+  updateDOM(prevNode: QuoteNode, dom: HTMLElement): boolean;
+  insertNewAfter(): ParagraphNode;
+  collapseAtStart(): true;
+}
+declare export function $createQuoteNode(): QuoteNode;
+declare export function $isQuoteNode(
+  node: ?LexicalNode,
+): boolean %checks(node instanceof QuoteNode);
+export type HeadingTagType = 'h1' | 'h2' | 'h3' | 'h4' | 'h5';
+declare export class HeadingNode extends ElementNode {
+  __tag: HeadingTagType;
+  static getType(): string;
+  static clone(node: HeadingNode): HeadingNode;
+  constructor(tag: HeadingTagType, key?: NodeKey): void;
+  getTag(): HeadingTagType;
+  createDOM<EditorContext>(config: EditorConfig<EditorContext>): HTMLElement;
+  updateDOM(prevNode: HeadingNode, dom: HTMLElement): boolean;
+  static convertDOM(): DOMConversionMap | null;
+  insertNewAfter(): ParagraphNode;
+  collapseAtStart(): true;
+}
+declare export function $createHeadingNode(
+  headingTag: HeadingTagType,
+): HeadingNode;
+declare export function $isHeadingNode(
+  node: ?LexicalNode,
+): boolean %checks(node instanceof HeadingNode);
+declare export function registerRichText(
+  editor: LexicalEditor,
+  initialEditorState?: InitialEditorStateType,
+): () => void;

package/LexicalRichText.prod.js

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var a=require("@lexical/clipboard"),h=require("@lexical/selection"),k=require("@lexical/utils"),l=require("lexical");const m={tag:"history-merge"};
+class n extends l.ElementNode{static getType(){return"quote"}static clone(b){return new n(b.__key)}constructor(b){super(b)}createDOM(b){const e=document.createElement("blockquote");k.addClassNamesToElement(e,b.theme.quote);return e}updateDOM(){return!1}insertNewAfter(){const b=l.$createParagraphNode(),e=this.getDirection();b.setDirection(e);this.insertAfter(b);return b}collapseAtStart(){const b=l.$createParagraphNode();this.getChildren().forEach(e=>b.append(e));this.replace(b);return!0}}
+class p extends l.ElementNode{static getType(){return"heading"}static clone(b){return new p(b.__tag,b.__key)}constructor(b,e){super(e);this.__tag=b}getTag(){return this.__tag}createDOM(b){const e=this.__tag,f=document.createElement(e);b=b.theme.heading;void 0!==b&&k.addClassNamesToElement(f,b[e]);return f}updateDOM(){return!1}static convertDOM(){return{h1:()=>({conversion:q,priority:0}),h2:()=>({conversion:q,priority:0}),h3:()=>({conversion:q,priority:0}),h4:()=>({conversion:q,priority:0}),h5:()=>
+({conversion:q,priority:0})}}insertNewAfter(){const b=l.$createParagraphNode(),e=this.getDirection();b.setDirection(e);this.insertAfter(b);return b}collapseAtStart(){const b=l.$createParagraphNode();this.getChildren().forEach(e=>b.append(e));this.replace(b);return!0}}function q(b){b=b.nodeName.toLowerCase();let e=null;if("h1"===b||"h2"===b||"h3"===b||"h4"===b||"h5"===b)e=r(b);return{node:e}}function r(b){return new p(b)}
+function t(b,e){if(null!==e)if(void 0===e)b.update(()=>{var f=l.$getRoot();if(null===f.getFirstChild()){const c=l.$createParagraphNode();f.append(c);f=document.activeElement;(null!==l.$getSelection()||null!==f&&f===b.getRootElement())&&c.select()}},m);else if(null!==e)switch(typeof e){case "string":e=b.parseEditorState(e);b.setEditorState(e,m);break;case "object":b.setEditorState(e,m);break;case "function":b.update(e,m)}}
+function u(b,e){b.preventDefault();e.update(()=>{const f=l.$getSelection(),c=b.clipboardData;null!=c&&l.$isRangeSelection(f)&&a.$insertDataTransferForRichText(c,f,e)})}function v(b,e){b.preventDefault();e.update(()=>{const f=b.clipboardData,c=l.$getSelection();if(null!==c&&null!=f){const d=a.getHtmlContent(e),g=a.$getLexicalContent(e);null!==d&&f.setData("text/html",d);null!==g&&f.setData("application/x-lexical-editor",g);f.setData("text/plain",c.getTextContent())}})}
+function w(b,e){v(b,e);e.update(()=>{const f=l.$getSelection();l.$isRangeSelection(f)&&f.removeText()})}exports.$createHeadingNode=r;exports.$createQuoteNode=function(){return new n};exports.$isHeadingNode=function(b){return b instanceof p};exports.$isQuoteNode=function(b){return b instanceof n};exports.HeadingNode=p;exports.QuoteNode=n;
+exports.registerRichText=function(b,e){const f=k.mergeRegister(b.registerCommand(l.CLICK_COMMAND,()=>{const c=l.$getSelection();return l.$isNodeSelection(c)?(c.clear(),!0):!1},0),b.registerCommand(l.DELETE_CHARACTER_COMMAND,c=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;d.deleteCharacter(c);return!0},0),b.registerCommand(l.DELETE_WORD_COMMAND,c=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;d.deleteWord(c);return!0},0),b.registerCommand(l.DELETE_LINE_COMMAND,c=>
+{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;d.deleteLine(c);return!0},0),b.registerCommand(l.INSERT_TEXT_COMMAND,c=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;if("string"===typeof c)d.insertText(c);else{const g=c.dataTransfer;null!=g?a.$insertDataTransferForRichText(g,d,b):(c=c.data)&&d.insertText(c)}return!0},0),b.registerCommand(l.REMOVE_TEXT_COMMAND,()=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;c.removeText();return!0},0),b.registerCommand(l.FORMAT_TEXT_COMMAND,
+c=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;d.formatText(c);return!0},0),b.registerCommand(l.FORMAT_ELEMENT_COMMAND,c=>{var d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;d=d.anchor.getNode();(l.$isElementNode(d)?d:d.getParentOrThrow()).setFormat(c);return!0},0),b.registerCommand(l.INSERT_LINE_BREAK_COMMAND,c=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;d.insertLineBreak(c);return!0},0),b.registerCommand(l.INSERT_PARAGRAPH_COMMAND,()=>{const c=l.$getSelection();
+if(!l.$isRangeSelection(c))return!1;c.insertParagraph();return!0},0),b.registerCommand(l.INDENT_CONTENT_COMMAND,()=>{var c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;c=c.anchor;c="element"===c.type?c.getNode():c.getNode().getParentOrThrow();c.canInsertTab()?b.dispatchCommand(l.INSERT_TEXT_COMMAND,"\t"):10!==c.getIndent()&&c.setIndent(c.getIndent()+1);return!0},0),b.registerCommand(l.OUTDENT_CONTENT_COMMAND,()=>{var c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;c=c.anchor;const d=
+c.getNode(),g="element"===c.type?c.getNode():c.getNode().getParentOrThrow();g.canInsertTab()?"\t"===d.getTextContent()[c.offset-1]&&b.dispatchCommand(l.DELETE_CHARACTER_COMMAND,!0):0!==g.getIndent()&&g.setIndent(g.getIndent()-1);return!0},0),b.registerCommand(l.KEY_ARROW_LEFT_COMMAND,c=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;const g=c.shiftKey;return h.$shouldOverrideDefaultCharacterSelection(d,!0)?(c.preventDefault(),h.$moveCharacter(d,g,!0),!0):!1},0),b.registerCommand(l.KEY_ARROW_RIGHT_COMMAND,
+c=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;const g=c.shiftKey;return h.$shouldOverrideDefaultCharacterSelection(d,!1)?(c.preventDefault(),h.$moveCharacter(d,g,!1),!0):!1},0),b.registerCommand(l.KEY_BACKSPACE_COMMAND,c=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;c.preventDefault();({anchor:c}=d);return d.isCollapsed()&&0===c.offset&&0<("element"===c.type?c.getNode():c.getNode().getParentOrThrow()).getIndent()?b.dispatchCommand(l.OUTDENT_CONTENT_COMMAND):b.dispatchCommand(l.DELETE_CHARACTER_COMMAND,
+!0)},0),b.registerCommand(l.KEY_DELETE_COMMAND,c=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;c.preventDefault();return b.dispatchCommand(l.DELETE_CHARACTER_COMMAND,!1)},0),b.registerCommand(l.KEY_ENTER_COMMAND,c=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;c.preventDefault();return c.shiftKey?b.dispatchCommand(l.INSERT_LINE_BREAK_COMMAND):b.dispatchCommand(l.INSERT_PARAGRAPH_COMMAND)},0),b.registerCommand(l.KEY_TAB_COMMAND,c=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;
+c.preventDefault();return b.dispatchCommand(c.shiftKey?l.OUTDENT_CONTENT_COMMAND:l.INDENT_CONTENT_COMMAND)},0),b.registerCommand(l.KEY_ESCAPE_COMMAND,()=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;b.blur();return!0},0),b.registerCommand(l.DROP_COMMAND,c=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;c.preventDefault();return!0},0),b.registerCommand(l.DRAGSTART_COMMAND,c=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;c.preventDefault();return!0},
+0),b.registerCommand(l.COPY_COMMAND,c=>{const d=l.$getSelection();return l.$isRangeSelection(d)||l.$isGridSelection(d)?(v(c,b),!0):!1},0),b.registerCommand(l.CUT_COMMAND,c=>{const d=l.$getSelection();return l.$isRangeSelection(d)||l.$isGridSelection(d)?(w(c,b),!0):!1},0),b.registerCommand(l.PASTE_COMMAND,c=>{const d=l.$getSelection();return l.$isRangeSelection(d)||l.$isGridSelection(d)?(u(c,b),!0):!1},0));t(b,e);return f};

package/README.md

@@ -0,0 +1,3 @@
+# `@lexical/rich-text`
+
+This package contains rich text helpers for Lexical.

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@lexical/rich-text",
+  "description": "This package contains rich text helpers for Lexical.",
+  "keywords": [
+    "lexical",
+    "editor",
+    "rich-text"
+  ],
+  "license": "MIT",
+  "version": "0.1.17",
+  "main": "LexicalRichText.js",
+  "peerDependencies": {
+    "lexical": "0.1.17",
+    "@lexical/selection": "0.1.17",
+    "@lexical/clipboard": "0.1.17",
+    "@lexical/utils": "0.1.17"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/lexical",
+    "directory": "packages/lexical-rich-text"
+  }
+}