@lexical/offset 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/LexicalOffset.dev.js

@@ -0,0 +1,374 @@
+/**
+ * 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.
+ *
+ * 
+ */
+class OffsetView {
+  constructor(offsetMap, firstNode, blockOffsetSize = 1) {
+    this._offsetMap = offsetMap;
+    this._firstNode = firstNode;
+    this._blockOffsetSize = blockOffsetSize;
+  }
+
+  createSelectionFromOffsets(originalStart, originalEnd, diffOffsetView) {
+    const firstNode = this._firstNode;
+
+    if (firstNode === null) {
+      return null;
+    }
+
+    let start = originalStart;
+    let end = originalEnd;
+    let startOffsetNode = $searchForNodeWithOffset(firstNode, start, this._blockOffsetSize);
+    let endOffsetNode = $searchForNodeWithOffset(firstNode, end, this._blockOffsetSize);
+
+    if (diffOffsetView !== undefined) {
+      start = $getAdjustedOffsetFromDiff(start, startOffsetNode, diffOffsetView, this, this._blockOffsetSize);
+      startOffsetNode = $searchForNodeWithOffset(firstNode, start, this._blockOffsetSize);
+      end = $getAdjustedOffsetFromDiff(end, endOffsetNode, diffOffsetView, this, this._blockOffsetSize);
+      endOffsetNode = $searchForNodeWithOffset(firstNode, end, this._blockOffsetSize);
+    }
+
+    if (startOffsetNode === null || endOffsetNode === null) {
+      return null;
+    }
+
+    let startKey = startOffsetNode.key;
+    let endKey = endOffsetNode.key;
+    const startNode = lexical.$getNodeByKey(startKey);
+    const endNode = lexical.$getNodeByKey(endKey);
+
+    if (startNode === null || endNode === null) {
+      return null;
+    }
+
+    let startOffset = 0;
+    let endOffset = 0;
+    let startType = 'element';
+    let endType = 'element';
+
+    if (startOffsetNode.type === 'text') {
+      startOffset = start - startOffsetNode.start;
+      startType = 'text'; // If we are at the edge of a text node and we
+      // don't have a collapsed selection, then let's
+      // try and correct the offset node.
+
+      const sibling = startNode.getNextSibling();
+
+      if (start !== end && startOffset === startNode.getTextContentSize() && lexical.$isTextNode(sibling)) {
+        startOffset = 0;
+        startKey = sibling.__key;
+      }
+    } else if (startOffsetNode.type === 'inline') {
+      startKey = startNode.getParentOrThrow().getKey();
+      startOffset = end > startOffsetNode.start ? startOffsetNode.end : startOffsetNode.start;
+    }
+
+    if (endOffsetNode.type === 'text') {
+      endOffset = end - endOffsetNode.start;
+      endType = 'text';
+    } else if (endOffsetNode.type === 'inline') {
+      endKey = endNode.getParentOrThrow().getKey();
+      endOffset = end > endOffsetNode.start ? endOffsetNode.end : endOffsetNode.start;
+    }
+
+    const selection = lexical.$createRangeSelection();
+
+    if (selection === null) {
+      return null;
+    }
+
+    selection.anchor.set(startKey, startOffset, startType);
+    selection.focus.set(endKey, endOffset, endType);
+    return selection;
+  }
+
+  getOffsetsFromSelection(selection) {
+    const anchor = selection.anchor;
+    const focus = selection.focus;
+    const offsetMap = this._offsetMap;
+    const anchorOffset = anchor.offset;
+    const focusOffset = focus.offset;
+    let start = -1;
+    let end = -1;
+
+    if (anchor.type === 'text') {
+      const offsetNode = offsetMap.get(anchor.key);
+
+      if (offsetNode !== undefined) {
+        start = offsetNode.start + anchorOffset;
+      }
+    } else {
+      const node = anchor.getNode().getDescendantByIndex(anchorOffset);
+      const offsetNode = offsetMap.get(node.getKey());
+
+      if (offsetNode !== undefined) {
+        const isAtEnd = node.getIndexWithinParent() !== anchorOffset;
+        start = isAtEnd ? offsetNode.end : offsetNode.start;
+      }
+    }
+
+    if (focus.type === 'text') {
+      const offsetNode = offsetMap.get(focus.key);
+
+      if (offsetNode !== undefined) {
+        end = offsetNode.start + focus.offset;
+      }
+    } else {
+      const node = focus.getNode().getDescendantByIndex(focusOffset);
+      const offsetNode = offsetMap.get(node.getKey());
+
+      if (offsetNode !== undefined) {
+        const isAtEnd = node.getIndexWithinParent() !== focusOffset;
+        end = isAtEnd ? offsetNode.end : offsetNode.start;
+      }
+    }
+
+    return [start, end];
+  }
+
+}
+
+function $getAdjustedOffsetFromDiff(offset, offsetNode, prevOffsetView, offsetView, blockOffsetSize) {
+  const prevOffsetMap = prevOffsetView._offsetMap;
+  const offsetMap = offsetView._offsetMap;
+  const visited = new Set();
+  let adjustedOffset = offset;
+  let currentNode = offsetNode;
+
+  while (currentNode !== null) {
+    const key = currentNode.key;
+    const prevNode = prevOffsetMap.get(key);
+    const diff = currentNode.end - currentNode.start;
+    visited.add(key);
+
+    if (prevNode === undefined) {
+      adjustedOffset += diff;
+    } else {
+      const prevDiff = prevNode.end - prevNode.start;
+
+      if (prevDiff !== diff) {
+        adjustedOffset += diff - prevDiff;
+      }
+    }
+
+    const sibling = currentNode.prev;
+
+    if (sibling !== null) {
+      currentNode = sibling;
+      continue;
+    }
+
+    let parent = currentNode.parent;
+
+    while (parent !== null) {
+      let parentSibling = parent.prev;
+
+      if (parentSibling !== null) {
+        const parentSiblingKey = parentSibling.key;
+        const prevParentSibling = prevOffsetMap.get(parentSiblingKey);
+        const parentDiff = parentSibling.end - parentSibling.start;
+        visited.add(parentSiblingKey);
+
+        if (prevParentSibling === undefined) {
+          adjustedOffset += parentDiff;
+        } else {
+          const prevParentDiff = prevParentSibling.end - prevParentSibling.start;
+
+          if (prevParentDiff !== parentDiff) {
+            adjustedOffset += parentDiff - prevParentDiff;
+          }
+        }
+
+        parentSibling = parentSibling.prev;
+      }
+
+      parent = parent.parent;
+    }
+
+    break;
+  } // Now traverse through the old offsets nodes and find any nodes we missed
+  // above, because they were not in the latest offset node view (they have been
+  // deleted).
+
+
+  const prevFirstNode = prevOffsetView._firstNode;
+
+  if (prevFirstNode !== null) {
+    currentNode = $searchForNodeWithOffset(prevFirstNode, offset, blockOffsetSize);
+    let alreadyVisistedParentOfCurrentNode = false;
+
+    while (currentNode !== null) {
+      if (!visited.has(currentNode.key)) {
+        alreadyVisistedParentOfCurrentNode = true;
+        break;
+      }
+
+      currentNode = currentNode.parent;
+    }
+
+    if (!alreadyVisistedParentOfCurrentNode) {
+      while (currentNode !== null) {
+        const key = currentNode.key;
+
+        if (!visited.has(key)) {
+          const node = offsetMap.get(key);
+          const prevDiff = currentNode.end - currentNode.start;
+
+          if (node === undefined) {
+            adjustedOffset -= prevDiff;
+          } else {
+            const diff = node.end - node.start;
+
+            if (prevDiff !== diff) {
+              adjustedOffset += diff - prevDiff;
+            }
+          }
+        }
+
+        currentNode = currentNode.prev;
+      }
+    }
+  }
+
+  return adjustedOffset;
+}
+
+function $searchForNodeWithOffset(firstNode, offset, blockOffsetSize) {
+  let currentNode = firstNode;
+
+  while (currentNode !== null) {
+    const end = currentNode.end + (currentNode.type !== 'element' || blockOffsetSize === 0 ? 1 : 0);
+
+    if (offset < end) {
+      const child = currentNode.child;
+
+      if (child !== null) {
+        currentNode = child;
+        continue;
+      }
+
+      return currentNode;
+    }
+
+    const sibling = currentNode.next;
+
+    if (sibling === null) {
+      break;
+    }
+
+    currentNode = sibling;
+  }
+
+  return null;
+}
+
+function $createInternalOffsetNode(child, type, start, end, key, parent) {
+  // $FlowFixMe: not sure why Flow doesn't like this?
+  return {
+    child,
+    end,
+    key,
+    next: null,
+    parent,
+    prev: null,
+    start,
+    type
+  };
+}
+
+function $createOffsetNode(state, key, parent, nodeMap, offsetMap, blockOffsetSize) {
+  const node = nodeMap.get(key);
+
+  if (node === undefined) {
+    {
+      throw Error(`createOffsetModel: could not find node by key`);
+    }
+  }
+
+  const start = state.offset;
+
+  if (lexical.$isElementNode(node)) {
+    const childKeys = node.__children;
+    const blockIsEmpty = childKeys.length === 0;
+    const child = blockIsEmpty ? null : $createOffsetChild(state, childKeys, null, nodeMap, offsetMap, blockOffsetSize); // If the prev node was not a block or the block is empty, we should
+    // account for the user being able to selection the block (due to the \n).
+
+    if (!state.prevIsBlock || blockIsEmpty) {
+      state.prevIsBlock = true;
+      state.offset += blockOffsetSize;
+    }
+
+    const offsetNode = $createInternalOffsetNode(child, 'element', start, start, key, parent);
+
+    if (child !== null) {
+      child.parent = offsetNode;
+    }
+
+    const end = state.offset;
+    offsetNode.end = end;
+    offsetMap.set(key, offsetNode);
+    return offsetNode;
+  }
+
+  state.prevIsBlock = false;
+  const isText = lexical.$isTextNode(node); // $FlowFixMe: isText means __text is available
+
+  const length = isText ? node.__text.length : 1;
+  const end = state.offset += length;
+  const offsetNode = $createInternalOffsetNode(null, isText ? 'text' : 'inline', start, end, key, parent);
+  offsetMap.set(key, offsetNode);
+  return offsetNode;
+}
+
+function $createOffsetChild(state, children, parent, nodeMap, offsetMap, blockOffsetSize) {
+  let firstNode = null;
+  let currentNode = null;
+  const childrenLength = children.length;
+
+  for (let i = 0; i < childrenLength; i++) {
+    const childKey = children[i];
+    const offsetNode = $createOffsetNode(state, childKey, parent, nodeMap, offsetMap, blockOffsetSize);
+
+    if (currentNode === null) {
+      firstNode = offsetNode;
+    } else {
+      offsetNode.prev = currentNode;
+      currentNode.next = offsetNode;
+    }
+
+    currentNode = offsetNode;
+  }
+
+  return firstNode;
+}
+
+function $createOffsetView(editor, blockOffsetSize = 1, editorState) {
+  const targetEditorState = editorState || editor._pendingEditorState || editor._editorState;
+  const nodeMap = targetEditorState._nodeMap; // $FlowFixMe: root is always in the Map
+
+  const root = nodeMap.get('root');
+  const offsetMap = new Map();
+  const state = {
+    offset: 0,
+    prevIsBlock: false
+  };
+  const node = $createOffsetChild(state, root.__children, null, nodeMap, offsetMap, blockOffsetSize);
+  return new OffsetView(offsetMap, node, blockOffsetSize);
+}
+
+exports.$createOffsetView = $createOffsetView;
+exports.OffsetView = OffsetView;

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

package/LexicalOffset.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 q=require("lexical");
+class t{constructor(b,a,c=1){this._offsetMap=b;this._firstNode=a;this._blockOffsetSize=c}createSelectionFromOffsets(b,a,c){var e=this._firstNode;if(null===e)return null;var f=y(e,b,this._blockOffsetSize);let h=y(e,a,this._blockOffsetSize);void 0!==c&&(b=z(b,f,c,this,this._blockOffsetSize),f=y(e,b,this._blockOffsetSize),a=z(a,h,c,this,this._blockOffsetSize),h=y(e,a,this._blockOffsetSize));if(null===f||null===h)return null;c=f.key;e=h.key;const m=q.$getNodeByKey(c),k=q.$getNodeByKey(e);if(null===m||
+null===k)return null;let l=0,d=0,g="element",n="element";"text"===f.type?(l=b-f.start,g="text",f=m.getNextSibling(),b!==a&&l===m.getTextContentSize()&&q.$isTextNode(f)&&(l=0,c=f.__key)):"inline"===f.type&&(c=m.getParentOrThrow().getKey(),l=a>f.start?f.end:f.start);"text"===h.type?(d=a-h.start,n="text"):"inline"===h.type&&(e=k.getParentOrThrow().getKey(),d=a>h.start?h.end:h.start);b=q.$createRangeSelection();if(null===b)return null;b.anchor.set(c,l,g);b.focus.set(e,d,n);return b}getOffsetsFromSelection(b){var a=
+b.anchor,c=b.focus,e=this._offsetMap;const f=a.offset;var h=c.offset;let m=b=-1;if("text"===a.type)a=e.get(a.key),void 0!==a&&(b=a.start+f);else{a=a.getNode().getDescendantByIndex(f);const k=e.get(a.getKey());void 0!==k&&(b=a.getIndexWithinParent()!==f?k.end:k.start)}"text"===c.type?(h=e.get(c.key),void 0!==h&&(m=h.start+c.offset)):(c=c.getNode().getDescendantByIndex(h),e=e.get(c.getKey()),void 0!==e&&(m=c.getIndexWithinParent()!==h?e.end:e.start));return[b,m]}}
+function z(b,a,c,e,f){const h=c._offsetMap;e=e._offsetMap;const m=new Set;let k=b;for(;null!==a;){var l=a.key,d=h.get(l),g=a.end-a.start;m.add(l);void 0===d?k+=g:(l=d.end-d.start,l!==g&&(k+=g-l));g=a.prev;if(null!==g)a=g;else{for(a=a.parent;null!==a;)d=a.prev,null!==d&&(g=d.key,l=h.get(g),d=d.end-d.start,m.add(g),void 0===l?k+=d:(g=l.end-l.start,g!==d&&(k+=d-g))),a=a.parent;break}}c=c._firstNode;if(null!==c){a=y(c,b,f);for(b=!1;null!==a;){if(!m.has(a.key)){b=!0;break}a=a.parent}if(!b)for(;null!==
+a;)b=a.key,m.has(b)||(f=e.get(b),b=a.end-a.start,void 0===f?k-=b:(f=f.end-f.start,b!==f&&(k+=f-b))),a=a.prev}return k}function y(b,a,c){for(;null!==b;){if(a<b.end+("element"!==b.type||0===c?1:0)){const e=b.child;if(null!==e){b=e;continue}return b}b=b.next;if(null===b)break}return null}
+function A(b,a,c,e,f,h){let m=null,k=null;const l=a.length;for(let v=0;v<l;v++){{var d=b;var g=a[v];var n=c,r=e,w=f,u=h,p=r.get(g);if(void 0===p)throw Error("Minified Lexical error #3; see codes.json for the full message or use the non-minified dev environment for full errors and additional helpful warnings.");const x=d.offset;if(q.$isElementNode(p)){const B=p.__children;r=(p=0===B.length)?null:A(d,B,null,r,w,u);if(!d.prevIsBlock||p)d.prevIsBlock=!0,d.offset+=u;n={child:r,end:x,key:g,next:null,parent:n,
+prev:null,start:x,type:"element"};null!==r&&(r.parent=n);n.end=d.offset;w.set(g,n);g=n}else d.prevIsBlock=!1,u=q.$isTextNode(p),d={child:null,end:d.offset+=u?p.__text.length:1,key:g,next:null,parent:n,prev:null,start:x,type:u?"text":"inline"},w.set(g,d),g=d}null===k?m=g:(g.prev=k,k.next=g);k=g}return m}
+exports.$createOffsetView=function(b,a=1,c){c=(c||b._pendingEditorState||b._editorState)._nodeMap;const e=c.get("root");b=new Map;c=A({offset:0,prevIsBlock:!1},e.__children,null,c,b,a);return new t(b,c,a)};exports.OffsetView=t;

package/README.md

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

package/package.json

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