@lexical/offset 0.44.1-nightly.20260519.0 → 0.45.0

package/package.json

@@ -8,34 +8,49 @@
     "offset"
   ],
   "license": "MIT",
-  "version": "0.44.1-nightly.20260519.0",
-  "main": "LexicalOffset.js",
-  "types": "index.d.ts",
+  "version": "0.45.0",
+  "main": "./dist/LexicalOffset.js",
+  "types": "./dist/index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/facebook/lexical.git",
     "directory": "packages/lexical-offset"
   },
-  "module": "LexicalOffset.mjs",
+  "module": "./dist/LexicalOffset.mjs",
   "sideEffects": false,
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "import": {
-        "types": "./index.d.ts",
-        "development": "./LexicalOffset.dev.mjs",
-        "production": "./LexicalOffset.prod.mjs",
-        "node": "./LexicalOffset.node.mjs",
-        "default": "./LexicalOffset.mjs"
+        "types": "./dist/index.d.ts",
+        "development": "./dist/LexicalOffset.dev.mjs",
+        "production": "./dist/LexicalOffset.prod.mjs",
+        "node": "./dist/LexicalOffset.node.mjs",
+        "default": "./dist/LexicalOffset.mjs"
       },
       "require": {
-        "types": "./index.d.ts",
-        "development": "./LexicalOffset.dev.js",
-        "production": "./LexicalOffset.prod.js",
-        "default": "./LexicalOffset.js"
+        "types": "./dist/index.d.ts",
+        "development": "./dist/LexicalOffset.dev.js",
+        "production": "./dist/LexicalOffset.prod.js",
+        "default": "./dist/LexicalOffset.js"
       }
     }
   },
   "dependencies": {
-    "lexical": "0.44.1-nightly.20260519.0"
-  }
+    "lexical": "0.45.0",
+    "@lexical/internal": "0.45.0"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/__tests__",
+    "!src/__bench__",
+    "!src/__mocks__",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/*.bench.ts",
+    "!src/**/*.bench.tsx",
+    "README.md",
+    "LICENSE"
+  ]
 }

package/src/index.ts

@@ -0,0 +1,572 @@
+/**
+ * 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 {
+  EditorState,
+  LexicalEditor,
+  NodeKey,
+  NodeMap,
+  RangeSelection,
+  RootNode,
+} from 'lexical';
+
+import invariant from '@lexical/internal/invariant';
+import {
+  $createChildrenArray as $createChildrenArray_,
+  $createRangeSelection,
+  $getNodeByKey,
+  $isElementNode,
+  $isTextNode,
+} from 'lexical';
+
+type OffsetElementNode = {
+  child: null | OffsetNode;
+  end: number;
+  key: NodeKey;
+  next: null | OffsetNode;
+  parent: null | OffsetElementNode;
+  prev: null | OffsetNode;
+  start: number;
+  type: 'element';
+};
+type OffsetTextNode = {
+  child: null;
+  end: number;
+  key: NodeKey;
+  next: null | OffsetNode;
+  parent: null | OffsetElementNode;
+  prev: null | OffsetNode;
+  start: number;
+  type: 'text';
+};
+type OffsetInlineNode = {
+  child: null;
+  end: number;
+  key: NodeKey;
+  next: null | OffsetNode;
+  parent: null | OffsetElementNode;
+  prev: null | OffsetNode;
+  start: number;
+  type: 'inline';
+};
+type OffsetNode = OffsetElementNode | OffsetTextNode | OffsetInlineNode;
+type OffsetMap = Map<NodeKey, OffsetNode>;
+
+/** @deprecated OffsetView has never worked correctly and will be removed */
+export class OffsetView {
+  _offsetMap: OffsetMap;
+  _firstNode: null | OffsetNode;
+  _blockOffsetSize: number;
+
+  constructor(
+    offsetMap: OffsetMap,
+    firstNode: null | OffsetNode,
+    blockOffsetSize = 1,
+  ) {
+    this._offsetMap = offsetMap;
+    this._firstNode = firstNode;
+    this._blockOffsetSize = blockOffsetSize;
+  }
+
+  createSelectionFromOffsets(
+    originalStart: number,
+    originalEnd: number,
+    diffOffsetView?: OffsetView,
+  ): null | RangeSelection {
+    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 = $getNodeByKey(startKey);
+    const endNode = $getNodeByKey(endKey);
+
+    if (startNode === null || endNode === null) {
+      return null;
+    }
+
+    let startOffset = 0;
+    let endOffset = 0;
+    let startType: 'element' | 'text' = 'element';
+    let endType: 'element' | 'text' = '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() &&
+        $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 = $createRangeSelection();
+
+    if (selection === null) {
+      return null;
+    }
+
+    selection.anchor.set(startKey, startOffset, startType);
+    selection.focus.set(endKey, endOffset, endType);
+
+    return selection;
+  }
+
+  getOffsetsFromSelection(selection: RangeSelection): [number, number] {
+    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);
+
+      if (node !== null) {
+        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);
+
+      if (node !== null) {
+        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: number,
+  offsetNode: null | OffsetNode,
+  prevOffsetView: OffsetView,
+  offsetView: OffsetView,
+  blockOffsetSize: number,
+): number {
+  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 alreadyVisitedParentOfCurrentNode = false;
+
+    while (currentNode !== null) {
+      if (!visited.has(currentNode.key)) {
+        alreadyVisitedParentOfCurrentNode = true;
+        break;
+      }
+
+      currentNode = currentNode.parent;
+    }
+
+    if (!alreadyVisitedParentOfCurrentNode) {
+      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: OffsetNode,
+  offset: number,
+  blockOffsetSize: number,
+): OffsetNode | null {
+  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: null | OffsetNode,
+  type: 'element' | 'text' | 'inline',
+  start: number,
+  end: number,
+  key: NodeKey,
+  parent: null | OffsetElementNode,
+): {
+  child: null | OffsetNode;
+  type: 'element' | 'text' | 'inline';
+  start: number;
+  end: number;
+  key: NodeKey;
+  parent: null | OffsetElementNode;
+  next: null;
+  prev: null;
+} {
+  return {
+    child,
+    end,
+    key,
+    next: null,
+    parent,
+    prev: null,
+    start,
+    type,
+  };
+}
+
+function $createOffsetNode(
+  state: {
+    offset: number;
+    prevIsBlock: boolean;
+  },
+  key: NodeKey,
+  parent: null | OffsetElementNode,
+  nodeMap: NodeMap,
+  offsetMap: OffsetMap,
+  blockOffsetSize: number,
+): OffsetNode {
+  const node = nodeMap.get(key);
+
+  if (node === undefined) {
+    invariant(false, 'createOffsetModel: could not find node by key');
+  }
+
+  const start = state.offset;
+
+  if ($isElementNode(node)) {
+    const childKeys = $createChildrenArray(node, nodeMap);
+    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,
+    ) as OffsetElementNode;
+
+    if (child !== null) {
+      child.parent = offsetNode;
+    }
+
+    const end = state.offset;
+    offsetNode.end = end;
+    offsetMap.set(key, offsetNode);
+    return offsetNode;
+  }
+
+  state.prevIsBlock = false;
+
+  const isText = $isTextNode(node);
+  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 as OffsetNode);
+
+  return offsetNode as OffsetNode;
+}
+
+function $createOffsetChild(
+  state: {
+    offset: number;
+    prevIsBlock: boolean;
+  },
+  children: Array<NodeKey>,
+  parent: null | OffsetElementNode,
+  nodeMap: NodeMap,
+  offsetMap: OffsetMap,
+  blockOffsetSize: number,
+): OffsetNode | null {
+  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;
+}
+
+/** @deprecated moved to `lexical` */
+export const $createChildrenArray = $createChildrenArray_;
+
+/** @deprecated OffsetView has never worked correctly and will be removed */
+export function $createOffsetView(
+  editor: LexicalEditor,
+  blockOffsetSize = 1,
+  editorState?: EditorState | null,
+): OffsetView {
+  const targetEditorState =
+    editorState || editor._pendingEditorState || editor._editorState;
+  const nodeMap = targetEditorState._nodeMap;
+
+  const root = nodeMap.get('root') as RootNode;
+
+  const offsetMap = new Map();
+  const state = {
+    offset: 0,
+    prevIsBlock: false,
+  };
+
+  const node = $createOffsetChild(
+    state,
+    $createChildrenArray(root, nodeMap),
+    null,
+    nodeMap,
+    offsetMap,
+    blockOffsetSize,
+  );
+
+  return new OffsetView(offsetMap, node, blockOffsetSize);
+}