@lexical/plain-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/LexicalPlainText.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 {EditorState, LexicalEditor} from 'lexical';
+export type InitialEditorStateType = null | string | EditorState | (() => void);
+
+declare function registerPlainText(
+  editor: LexicalEditor,
+  initialEditorState?: InitialEditorStateType,
+): () => void;

package/LexicalPlainText.dev.js

@@ -0,0 +1,306 @@
+/**
+ * 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;
+
+function onCopyForPlainText(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);
+
+        if (htmlString !== null) {
+          clipboardData.setData('text/html', htmlString);
+        }
+
+        clipboardData.setData('text/plain', selection.getTextContent());
+      }
+    }
+  });
+}
+
+function onPasteForPlainText(event, editor) {
+  event.preventDefault();
+  editor.update(() => {
+    const selection = lexical.$getSelection();
+    const clipboardData = event.clipboardData;
+
+    if (clipboardData != null && lexical.$isRangeSelection(selection)) {
+      clipboard.$insertDataTransferForPlainText(clipboardData, selection);
+    }
+  });
+}
+
+function onCutForPlainText(event, editor) {
+  onCopyForPlainText(event, editor);
+  editor.update(() => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isRangeSelection(selection)) {
+      selection.removeText();
+    }
+  });
+}
+
+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 registerPlainText(editor, initialEditorState) {
+  const removeListener = utils.mergeRegister(editor.registerCommand(lexical.DELETE_CHARACTER_COMMAND, isBackward => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    selection.deleteCharacter(isBackward);
+    return true;
+  }, 0), editor.registerCommand(lexical.DELETE_WORD_COMMAND, isBackward => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    selection.deleteWord(isBackward);
+    return true;
+  }, 0), editor.registerCommand(lexical.DELETE_LINE_COMMAND, isBackward => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    selection.deleteLine(isBackward);
+    return true;
+  }, 0), editor.registerCommand(lexical.INSERT_TEXT_COMMAND, eventOrText => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    if (typeof eventOrText === 'string') {
+      selection.insertText(eventOrText);
+    } else {
+      const dataTransfer = eventOrText.dataTransfer;
+
+      if (dataTransfer != null) {
+        clipboard.$insertDataTransferForPlainText(dataTransfer, selection);
+      } else {
+        const data = eventOrText.data;
+
+        if (data) {
+          selection.insertText(data);
+        }
+      }
+    }
+
+    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.INSERT_LINE_BREAK_COMMAND, selectStart => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    selection.insertLineBreak(selectStart);
+    return true;
+  }, 0), editor.registerCommand(lexical.INSERT_PARAGRAPH_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    selection.insertLineBreak();
+    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, event => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    event.preventDefault();
+    return editor.dispatchCommand(lexical.DELETE_CHARACTER_COMMAND, true);
+  }, 0), editor.registerCommand(lexical.KEY_DELETE_COMMAND, event => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    event.preventDefault();
+    return editor.dispatchCommand(lexical.DELETE_CHARACTER_COMMAND, false);
+  }, 0), editor.registerCommand(lexical.KEY_ENTER_COMMAND, event => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    event.preventDefault();
+    return editor.dispatchCommand(lexical.INSERT_LINE_BREAK_COMMAND);
+  }, 0), editor.registerCommand(lexical.COPY_COMMAND, event => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    onCopyForPlainText(event, editor);
+    return true;
+  }, 0), editor.registerCommand(lexical.CUT_COMMAND, event => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    onCutForPlainText(event, editor);
+    return true;
+  }, 0), editor.registerCommand(lexical.PASTE_COMMAND, event => {
+    const selection = lexical.$getSelection();
+
+    if (!lexical.$isRangeSelection(selection)) {
+      return false;
+    }
+
+    onPasteForPlainText(event, editor);
+    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, 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));
+  initializeEditor(editor, initialEditorState);
+  return removeListener;
+}
+
+exports.registerPlainText = registerPlainText;

package/LexicalPlainText.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 LexicalPlainText = process.env.NODE_ENV === 'development' ? require('./LexicalPlainText.dev.js') : require('./LexicalPlainText.prod.js')
+module.exports = LexicalPlainText;

package/LexicalPlainText.js.flow

@@ -0,0 +1,15 @@
+/**
+ * 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 {EditorState, LexicalEditor} from 'lexical';
+export type InitialEditorStateType = null | string | EditorState | (() => void);
+
+declare export function registerPlainText(
+  editor: LexicalEditor,
+  initialEditorState?: InitialEditorStateType,
+): () => void;

package/LexicalPlainText.prod.js

@@ -0,0 +1,15 @@
+/**
+ * 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"};function n(d,e){d.preventDefault();e.update(()=>{const f=d.clipboardData,b=l.$getSelection();if(null!==b&&null!=f){const c=a.getHtmlContent(e);null!==c&&f.setData("text/html",c);f.setData("text/plain",b.getTextContent())}})}
+function p(d,e){d.preventDefault();e.update(()=>{const f=l.$getSelection(),b=d.clipboardData;null!=b&&l.$isRangeSelection(f)&&a.$insertDataTransferForPlainText(b,f)})}function q(d,e){n(d,e);e.update(()=>{const f=l.$getSelection();l.$isRangeSelection(f)&&f.removeText()})}
+function r(d,e){if(null!==e)if(void 0===e)d.update(()=>{var f=l.$getRoot();if(null===f.getFirstChild()){const b=l.$createParagraphNode();f.append(b);f=document.activeElement;(null!==l.$getSelection()||null!==f&&f===d.getRootElement())&&b.select()}},m);else if(null!==e)switch(typeof e){case "string":e=d.parseEditorState(e);d.setEditorState(e,m);break;case "object":d.setEditorState(e,m);break;case "function":d.update(e,m)}}
+exports.registerPlainText=function(d,e){const f=k.mergeRegister(d.registerCommand(l.DELETE_CHARACTER_COMMAND,b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;c.deleteCharacter(b);return!0},0),d.registerCommand(l.DELETE_WORD_COMMAND,b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;c.deleteWord(b);return!0},0),d.registerCommand(l.DELETE_LINE_COMMAND,b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;c.deleteLine(b);return!0},0),d.registerCommand(l.INSERT_TEXT_COMMAND,
+b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;if("string"===typeof b)c.insertText(b);else{const g=b.dataTransfer;null!=g?a.$insertDataTransferForPlainText(g,c):(b=b.data)&&c.insertText(b)}return!0},0),d.registerCommand(l.REMOVE_TEXT_COMMAND,()=>{const b=l.$getSelection();if(!l.$isRangeSelection(b))return!1;b.removeText();return!0},0),d.registerCommand(l.INSERT_LINE_BREAK_COMMAND,b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;c.insertLineBreak(b);return!0},0),
+d.registerCommand(l.INSERT_PARAGRAPH_COMMAND,()=>{const b=l.$getSelection();if(!l.$isRangeSelection(b))return!1;b.insertLineBreak();return!0},0),d.registerCommand(l.KEY_ARROW_LEFT_COMMAND,b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;const g=b.shiftKey;return h.$shouldOverrideDefaultCharacterSelection(c,!0)?(b.preventDefault(),h.$moveCharacter(c,g,!0),!0):!1},0),d.registerCommand(l.KEY_ARROW_RIGHT_COMMAND,b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;const g=
+b.shiftKey;return h.$shouldOverrideDefaultCharacterSelection(c,!1)?(b.preventDefault(),h.$moveCharacter(c,g,!1),!0):!1},0),d.registerCommand(l.KEY_BACKSPACE_COMMAND,b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;b.preventDefault();return d.dispatchCommand(l.DELETE_CHARACTER_COMMAND,!0)},0),d.registerCommand(l.KEY_DELETE_COMMAND,b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;b.preventDefault();return d.dispatchCommand(l.DELETE_CHARACTER_COMMAND,!1)},0),d.registerCommand(l.KEY_ENTER_COMMAND,
+b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;b.preventDefault();return d.dispatchCommand(l.INSERT_LINE_BREAK_COMMAND)},0),d.registerCommand(l.COPY_COMMAND,b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;n(b,d);return!0},0),d.registerCommand(l.CUT_COMMAND,b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;q(b,d);return!0},0),d.registerCommand(l.PASTE_COMMAND,b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;p(b,d);return!0},0),d.registerCommand(l.DROP_COMMAND,
+b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;b.preventDefault();return!0},0),d.registerCommand(l.DRAGSTART_COMMAND,b=>{const c=l.$getSelection();if(!l.$isRangeSelection(c))return!1;b.preventDefault();return!0},0));r(d,e);return f};

package/README.md

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

package/package.json

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