@lexical/text 0.1.15

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Dominic Gannaway
+
+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/LexicalText.dev.js

@@ -0,0 +1,223 @@
+/**
+ * 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 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.
+ *
+ * 
+ */
+function $findTextIntersectionFromCharacters(root, targetCharacters) {
+  let node = root.getFirstChild();
+  let currentCharacters = 0;
+
+  mainLoop: while (node !== null) {
+    if (lexical.$isElementNode(node)) {
+      const child = node.getFirstChild();
+
+      if (child !== null) {
+        node = child;
+        continue;
+      }
+    } else if (lexical.$isTextNode(node)) {
+      const characters = node.getTextContentSize();
+
+      if (currentCharacters + characters > targetCharacters) {
+        return {
+          node,
+          offset: targetCharacters - currentCharacters
+        };
+      }
+
+      currentCharacters += characters;
+    }
+
+    const sibling = node.getNextSibling();
+
+    if (sibling !== null) {
+      node = sibling;
+      continue;
+    }
+
+    let parent = node.getParent();
+
+    while (parent !== null) {
+      const parentSibling = parent.getNextSibling();
+
+      if (parentSibling !== null) {
+        node = parentSibling;
+        continue mainLoop;
+      }
+
+      parent = parent.getParent();
+    }
+
+    break;
+  }
+
+  return null;
+} // Return text content for child text nodes.  Each non-text node is separated by input string.
+// Caution, this function creates a string and should not be used within a tight loop.
+// Use $getNodeWithOffsetsFromJoinedTextNodesFromElementNode below to convert
+// indexes in the return string back into their corresponding node and offsets.
+
+function $joinTextNodesInElementNode(elementNode, separator, stopAt) {
+  let textContent = '';
+  const children = elementNode.getChildren();
+  const length = children.length;
+
+  for (let i = 0; i < length; ++i) {
+    const child = children[i];
+
+    if (lexical.$isTextNode(child)) {
+      const childTextContent = child.getTextContent();
+
+      if (child.is(stopAt.node)) {
+        if (stopAt.offset > childTextContent.length) {
+          {
+            throw Error(`Node ${child.__key} and selection point do not match.`);
+          }
+        }
+
+        textContent += child.getTextContent().substr(0, stopAt.offset);
+        break;
+      } else {
+        textContent += childTextContent;
+      }
+    } else {
+      textContent += separator;
+    }
+  }
+
+  return textContent;
+} // This function converts the offsetInJoinedText to
+// a node and offset result or null if not found.
+// This function is to be used in conjunction with joinTextNodesInElementNode above.
+// The joinedTextContent should be return value from joinTextNodesInElementNode.
+//
+// The offsetInJoinedText is relative to the entire string which
+// itself is relevant to the parent ElementNode.
+//
+// Example:
+// Given a Paragraph with 2 TextNodes. The first is Hello, the second is World.
+// The joinedTextContent would be "HelloWorld"
+// The offsetInJoinedText might be for the letter "e" = 1 or "r" = 7.
+// The return values would be {TextNode1, 1} or {TextNode2,2}, respectively.
+
+function $findNodeWithOffsetFromJoinedText(offsetInJoinedText, joinedTextLength, separatorLength, elementNode) {
+  const children = elementNode.getChildren();
+  const childrenLength = children.length;
+  let runningLength = 0;
+  let isPriorNodeTextNode = false;
+
+  for (let i = 0; i < childrenLength; ++i) {
+    // We must examine the offsetInJoinedText that is located
+    // at the length of the string.
+    // For example, given "hello", the length is 5, yet
+    // the caller still wants the node + offset at the
+    // right edge of the "o".
+    if (runningLength > joinedTextLength) {
+      break;
+    }
+
+    const child = children[i];
+    const isChildNodeTestNode = lexical.$isTextNode(child);
+    const childContentLength = isChildNodeTestNode ? child.getTextContent().length : separatorLength;
+    const newRunningLength = runningLength + childContentLength;
+    const isJoinedOffsetWithinNode = isPriorNodeTextNode === false && runningLength === offsetInJoinedText || runningLength === 0 && runningLength === offsetInJoinedText || runningLength < offsetInJoinedText && offsetInJoinedText <= newRunningLength;
+
+    if (isJoinedOffsetWithinNode && lexical.$isTextNode(child)) {
+      // Check isTextNode again for flow.
+      return {
+        node: child,
+        offset: offsetInJoinedText - runningLength
+      };
+    }
+
+    runningLength = newRunningLength;
+    isPriorNodeTextNode = isChildNodeTestNode;
+  }
+
+  return null;
+}
+function $isRootTextContentEmpty(isEditorComposing, trim = true) {
+  if (isEditorComposing) {
+    return false;
+  }
+
+  let text = $rootTextContentCurry();
+
+  if (trim) {
+    text = text.trim();
+  }
+
+  return text === '';
+}
+function $isRootTextContentEmptyCurry(isEditorComposing, trim) {
+  return () => $isRootTextContentEmpty(isEditorComposing, trim);
+}
+function $rootTextContentCurry() {
+  const root = lexical.$getRoot();
+  return root.getTextContent();
+}
+function $canShowPlaceholder(isComposing) {
+  if (!$isRootTextContentEmpty(isComposing, false)) {
+    return false;
+  }
+
+  const root = lexical.$getRoot();
+  const children = root.getChildren();
+  const childrenLength = children.length;
+
+  if (childrenLength > 1) {
+    return false;
+  }
+
+  for (let i = 0; i < childrenLength; i++) {
+    const topBlock = children[i];
+
+    if (lexical.$isElementNode(topBlock)) {
+      if (topBlock.__type !== 'paragraph') {
+        return false;
+      }
+
+      if (topBlock.__indent !== 0) {
+        return false;
+      }
+
+      const topBlockChildren = topBlock.getChildren();
+      const topBlockChildrenLength = topBlockChildren.length;
+
+      for (let s = 0; s < topBlockChildrenLength; s++) {
+        const child = topBlockChildren[i];
+
+        if (!lexical.$isTextNode(child)) {
+          return false;
+        }
+      }
+    }
+  }
+
+  return true;
+}
+function $canShowPlaceholderCurry(isEditorComposing) {
+  return () => $canShowPlaceholder(isEditorComposing);
+}
+
+exports.$canShowPlaceholder = $canShowPlaceholder;
+exports.$canShowPlaceholderCurry = $canShowPlaceholderCurry;
+exports.$findNodeWithOffsetFromJoinedText = $findNodeWithOffsetFromJoinedText;
+exports.$findTextIntersectionFromCharacters = $findTextIntersectionFromCharacters;
+exports.$isRootTextContentEmpty = $isRootTextContentEmpty;
+exports.$isRootTextContentEmptyCurry = $isRootTextContentEmptyCurry;
+exports.$joinTextNodesInElementNode = $joinTextNodesInElementNode;
+exports.$rootTextContentCurry = $rootTextContentCurry;

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

package/LexicalText.prod.js

@@ -0,0 +1,11 @@
+/**
+ * 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 f=require("lexical");function m(a,e=!0){if(a)return!1;a=p();e&&(a=a.trim());return""===a}function p(){return f.$getRoot().getTextContent()}function q(a){if(!m(a,!1))return!1;a=f.$getRoot().getChildren();const e=a.length;if(1<e)return!1;for(let c=0;c<e;c++){var b=a[c];if(f.$isElementNode(b)){if("paragraph"!==b.__type||0!==b.__indent)return!1;b=b.getChildren();const k=b.length;for(let d=0;d<k;d++)if(!f.$isTextNode(b[c]))return!1}}return!0}exports.$canShowPlaceholder=q;
+exports.$canShowPlaceholderCurry=function(a){return()=>q(a)};exports.$findNodeWithOffsetFromJoinedText=function(a,e,b,c){c=c.getChildren();const k=c.length;let d=0,g=!1;for(let n=0;n<k&&!(d>e);++n){const l=c[n],r=f.$isTextNode(l);var h=r?l.getTextContent().length:b;h=d+h;if((!1===g&&d===a||0===d&&d===a||d<a&&a<=h)&&f.$isTextNode(l))return{node:l,offset:a-d};d=h;g=r}return null};
+exports.$findTextIntersectionFromCharacters=function(a,e){var b=a.getFirstChild();a=0;a:for(;null!==b;){if(f.$isElementNode(b)){var c=b.getFirstChild();if(null!==c){b=c;continue}}else if(f.$isTextNode(b)){c=b.getTextContentSize();if(a+c>e)return{node:b,offset:e-a};a+=c}c=b.getNextSibling();if(null!==c)b=c;else{for(b=b.getParent();null!==b;){c=b.getNextSibling();if(null!==c){b=c;continue a}b=b.getParent()}break}}return null};exports.$isRootTextContentEmpty=m;
+exports.$isRootTextContentEmptyCurry=function(a,e){return()=>m(a,e)};
+exports.$joinTextNodesInElementNode=function(a,e,b){let c="";a=a.getChildren();const k=a.length;for(let d=0;d<k;++d){const g=a[d];if(f.$isTextNode(g)){const h=g.getTextContent();if(g.is(b.node)){if(b.offset>h.length)throw Error("Minified Lexical error #50; see codes.json for the full message or use the non-minified dev environment for full errors and additional helpful warnings.");c+=g.getTextContent().substr(0,b.offset);break}else c+=h}else c+=e}return c};exports.$rootTextContentCurry=p;

package/README.md

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

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@lexical/text",
+  "author": {
+    "name": "Dominic Gannaway",
+    "email": "dg@domgan.com"
+  },
+  "description": "This package contains utilities and helpers for handling Lexical text.",
+  "keywords": [
+    "lexical",
+    "editor",
+    "rich-text",
+    "list",
+    "text"
+  ],
+  "license": "MIT",
+  "version": "0.1.15",
+  "main": "LexicalText.js",
+  "peerDependencies": {
+    "lexical": "0.1.15"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/lexical",
+    "directory": "packages/lexical-text"
+  }
+}