@payloadcms/richtext-lexical 0.1.0-beta.0

package/dist/field/lexical/plugins/handles/AddBlockHandlePlugin/index.js

@@ -0,0 +1,264 @@
+/**
+ * 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";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AddBlockHandlePlugin", {
+    enumerable: true,
+    get: function() {
+        return AddBlockHandlePlugin;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _lexical = require("lexical");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactdom = require("react-dom");
+const _guard = require("../../../utils/guard");
+const _point = require("../../../utils/point");
+const _rect = require("../../../utils/rect");
+const _LexicalTypeaheadMenuPlugin = require("../../SlashMenu/LexicalTypeaheadMenuPlugin");
+const _getCollapsedMargins = require("../utils/getCollapsedMargins");
+const _getTopLevelNodeKeys = require("../utils/getTopLevelNodeKeys");
+const _isOnHandleElement = require("../utils/isOnHandleElement");
+const _setHandlePosition = require("../utils/setHandlePosition");
+require("./index.scss");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const SPACE = -24;
+const ADD_BLOCK_MENU_CLASSNAME = 'add-block-menu';
+const Downward = 1;
+const Upward = -1;
+const Indeterminate = 0;
+let prevIndex = Infinity;
+function getCurrentIndex(keysLength) {
+    if (keysLength === 0) {
+        return Infinity;
+    }
+    if (prevIndex >= 0 && prevIndex < keysLength) {
+        return prevIndex;
+    }
+    return Math.floor(keysLength / 2);
+}
+function getBlockElement(anchorElem, editor, event, useEdgeAsDefault = false, horizontalOffset = 0) {
+    const anchorElementRect = anchorElem.getBoundingClientRect();
+    const topLevelNodeKeys = (0, _getTopLevelNodeKeys.getTopLevelNodeKeys)(editor);
+    let blockElem = null;
+    let blockNode = null;
+    let shouldRemove = false;
+    // Return null if matching block element is the first or last node
+    editor.getEditorState().read(()=>{
+        if (useEdgeAsDefault) {
+            const [firstNode, lastNode] = [
+                editor.getElementByKey(topLevelNodeKeys[0]),
+                editor.getElementByKey(topLevelNodeKeys[topLevelNodeKeys.length - 1])
+            ];
+            const [firstNodeRect, lastNodeRect] = [
+                firstNode?.getBoundingClientRect(),
+                lastNode?.getBoundingClientRect()
+            ];
+            if (firstNodeRect && lastNodeRect) {
+                if (event.y < firstNodeRect.top) {
+                    blockElem = firstNode;
+                } else if (event.y > lastNodeRect.bottom) {
+                    blockElem = lastNode;
+                }
+                if (blockElem) {
+                    return {
+                        blockElem: null,
+                        shouldRemove
+                    };
+                }
+            }
+        }
+        // Find matching block element
+        let index = getCurrentIndex(topLevelNodeKeys.length);
+        let direction = Indeterminate;
+        while(index >= 0 && index < topLevelNodeKeys.length){
+            const key = topLevelNodeKeys[index];
+            const elem = editor.getElementByKey(key);
+            if (elem === null) {
+                break;
+            }
+            const point = new _point.Point(event.x + horizontalOffset, event.y);
+            const domRect = _rect.Rect.fromDOM(elem);
+            const { marginBottom, marginTop } = (0, _getCollapsedMargins.getCollapsedMargins)(elem);
+            const rect = domRect.generateNewRect({
+                bottom: domRect.bottom + marginBottom,
+                left: anchorElementRect.left,
+                right: anchorElementRect.right,
+                top: domRect.top - marginTop
+            });
+            const { reason: { isOnBottomSide, isOnTopSide }, result } = rect.contains(point);
+            if (result) {
+                blockElem = elem;
+                blockNode = (0, _lexical.$getNodeByKey)(key);
+                prevIndex = index;
+                // Check if blockNode is an empty text node
+                if (!blockNode || blockNode.getType() !== 'paragraph' || blockNode.getTextContent() !== '') {
+                    blockElem = null;
+                    shouldRemove = true;
+                }
+                break;
+            }
+            if (direction === Indeterminate) {
+                if (isOnTopSide) {
+                    direction = Upward;
+                } else if (isOnBottomSide) {
+                    direction = Downward;
+                } else {
+                    // stop search block element
+                    direction = Infinity;
+                }
+            }
+            index += direction;
+        }
+    });
+    return {
+        blockElem: blockElem,
+        shouldRemove
+    };
+}
+function useAddBlockHandle(editor, anchorElem, isEditable) {
+    const scrollerElem = anchorElem.parentElement;
+    const menuRef = (0, _react.useRef)(null);
+    const [emptyBlockElem, setEmptyBlockElem] = (0, _react.useState)(null);
+    (0, _react.useEffect)(()=>{
+        function onDocumentMouseMove(event) {
+            const target = event.target;
+            if (!(0, _guard.isHTMLElement)(target)) {
+                return;
+            }
+            let distanceFromScrollerElem = 0;
+            // Calculate distance between scrollerElem and target if target is not in scrollerElem
+            if (scrollerElem && !scrollerElem.contains(target)) {
+                const { bottom, left, right, top } = scrollerElem.getBoundingClientRect();
+                const { pageX, pageY } = event;
+                const horizontalBuffer = 50;
+                const verticalBuffer = 25;
+                const adjustedTop = top + window.scrollY;
+                const adjustedBottom = bottom + window.scrollY;
+                if (pageY < adjustedTop - verticalBuffer || pageY > adjustedBottom + verticalBuffer || pageX < left - horizontalBuffer || pageX > right + horizontalBuffer) {
+                    setEmptyBlockElem(null);
+                    return;
+                }
+                // This is used to allow the _emptyBlockElem to be found when the mouse is in the
+                // buffer zone around the scrollerElem.
+                if (pageX < left || pageX > right) {
+                    distanceFromScrollerElem = pageX < left ? pageX - left : pageX - right;
+                }
+            }
+            if ((0, _isOnHandleElement.isOnHandleElement)(target, ADD_BLOCK_MENU_CLASSNAME)) {
+                return;
+            }
+            const { blockElem: _emptyBlockElem, shouldRemove } = getBlockElement(anchorElem, editor, event, false, -distanceFromScrollerElem);
+            if (!_emptyBlockElem && !shouldRemove) {
+                return;
+            }
+            setEmptyBlockElem(_emptyBlockElem);
+        }
+        // Since the draggableBlockElem is outside the actual editor, we need to listen to the document
+        // to be able to detect when the mouse is outside the editor and respect a buffer around the
+        // the scrollerElem to avoid the draggableBlockElem disappearing too early.
+        document?.addEventListener('mousemove', onDocumentMouseMove);
+        return ()=>{
+            document?.removeEventListener('mousemove', onDocumentMouseMove);
+        };
+    }, [
+        scrollerElem,
+        anchorElem,
+        editor
+    ]);
+    (0, _react.useEffect)(()=>{
+        if (menuRef.current) {
+            (0, _setHandlePosition.setHandlePosition)(emptyBlockElem, menuRef.current, anchorElem, SPACE);
+        }
+    }, [
+        anchorElem,
+        emptyBlockElem
+    ]);
+    const handleAddClick = (0, _react.useCallback)((event)=>{
+        if (!emptyBlockElem) {
+            return;
+        }
+        editor.update(()=>{
+            const node = (0, _lexical.$getNearestNodeFromDOMNode)(emptyBlockElem);
+            if (!node || node.getType() !== 'paragraph') {
+                return;
+            }
+            editor.focus();
+            node.select();
+        /*const ns = $createNodeSelection();
+        ns.add(node.getKey())
+        $setSelection(ns)*/ });
+        // Make sure this is called AFTER the editorfocus() event has been processed by the browser
+        // Otherwise, this won't work
+        setTimeout(()=>{
+            editor.dispatchCommand(_LexicalTypeaheadMenuPlugin.ENABLE_SLASH_MENU_COMMAND, {
+                rect: emptyBlockElem.getBoundingClientRect()
+            });
+        }, 0);
+        event.stopPropagation();
+        event.preventDefault();
+    }, [
+        editor,
+        emptyBlockElem
+    ]);
+    return /*#__PURE__*/ (0, _reactdom.createPortal)(/*#__PURE__*/ _react.createElement(_react.Fragment, null, /*#__PURE__*/ _react.createElement("button", {
+        className: "icon add-block-menu",
+        onClick: (event)=>{
+            handleAddClick(event);
+        },
+        ref: menuRef,
+        type: "button"
+    }, /*#__PURE__*/ _react.createElement("div", {
+        className: isEditable ? 'icon' : ''
+    }))), anchorElem);
+}
+function AddBlockHandlePlugin({ anchorElem = document.body }) {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    return useAddBlockHandle(editor, anchorElem, editor._editable);
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/lexical/plugins/handles/AddBlockHandlePlugin/index.tsx"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport type { ParagraphNode } from 'lexical'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport {\n  $getNearestNodeFromDOMNode,\n  $getNodeByKey,\n  type LexicalEditor,\n  type LexicalNode,\n} from 'lexical'\nimport * as React from 'react'\nimport { useCallback, useEffect, useRef, useState } from 'react'\nimport { createPortal } from 'react-dom'\n\nimport { isHTMLElement } from '../../../utils/guard'\nimport { Point } from '../../../utils/point'\nimport { Rect } from '../../../utils/rect'\nimport { ENABLE_SLASH_MENU_COMMAND } from '../../SlashMenu/LexicalTypeaheadMenuPlugin'\nimport { getCollapsedMargins } from '../utils/getCollapsedMargins'\nimport { getTopLevelNodeKeys } from '../utils/getTopLevelNodeKeys'\nimport { isOnHandleElement } from '../utils/isOnHandleElement'\nimport { setHandlePosition } from '../utils/setHandlePosition'\nimport './index.scss'\n\nconst SPACE = -24\nconst ADD_BLOCK_MENU_CLASSNAME = 'add-block-menu'\n\nconst Downward = 1\nconst Upward = -1\nconst Indeterminate = 0\n\nlet prevIndex = Infinity\n\nfunction getCurrentIndex(keysLength: number): number {\n  if (keysLength === 0) {\n    return Infinity\n  }\n  if (prevIndex >= 0 && prevIndex < keysLength) {\n    return prevIndex\n  }\n\n  return Math.floor(keysLength / 2)\n}\n\nfunction getBlockElement(\n  anchorElem: HTMLElement,\n  editor: LexicalEditor,\n  event: MouseEvent,\n  useEdgeAsDefault = false,\n  horizontalOffset = 0,\n): {\n  blockElem: HTMLElement | null\n  shouldRemove: boolean\n} {\n  const anchorElementRect = anchorElem.getBoundingClientRect()\n  const topLevelNodeKeys = getTopLevelNodeKeys(editor)\n\n  let blockElem: HTMLElement | null = null\n  let blockNode: LexicalNode | null = null\n  let shouldRemove = false\n\n  // Return null if matching block element is the first or last node\n  editor.getEditorState().read(() => {\n    if (useEdgeAsDefault) {\n      const [firstNode, lastNode] = [\n        editor.getElementByKey(topLevelNodeKeys[0]),\n        editor.getElementByKey(topLevelNodeKeys[topLevelNodeKeys.length - 1]),\n      ]\n\n      const [firstNodeRect, lastNodeRect] = [\n        firstNode?.getBoundingClientRect(),\n        lastNode?.getBoundingClientRect(),\n      ]\n\n      if (firstNodeRect && lastNodeRect) {\n        if (event.y < firstNodeRect.top) {\n          blockElem = firstNode\n        } else if (event.y > lastNodeRect.bottom) {\n          blockElem = lastNode\n        }\n\n        if (blockElem) {\n          return {\n            blockElem: null,\n            shouldRemove,\n          }\n        }\n      }\n    }\n\n    // Find matching block element\n    let index = getCurrentIndex(topLevelNodeKeys.length)\n    let direction = Indeterminate\n\n    while (index >= 0 && index < topLevelNodeKeys.length) {\n      const key = topLevelNodeKeys[index]\n      const elem = editor.getElementByKey(key)\n      if (elem === null) {\n        break\n      }\n      const point = new Point(event.x + horizontalOffset, event.y)\n      const domRect = Rect.fromDOM(elem)\n      const { marginBottom, marginTop } = getCollapsedMargins(elem)\n\n      const rect = domRect.generateNewRect({\n        bottom: domRect.bottom + marginBottom,\n        left: anchorElementRect.left,\n        right: anchorElementRect.right,\n        top: domRect.top - marginTop,\n      })\n\n      const {\n        reason: { isOnBottomSide, isOnTopSide },\n        result,\n      } = rect.contains(point)\n\n      if (result) {\n        blockElem = elem\n        blockNode = $getNodeByKey(key)\n        prevIndex = index\n\n        // Check if blockNode is an empty text node\n        if (\n          !blockNode ||\n          blockNode.getType() !== 'paragraph' ||\n          blockNode.getTextContent() !== ''\n        ) {\n          blockElem = null\n          shouldRemove = true\n        }\n        break\n      }\n\n      if (direction === Indeterminate) {\n        if (isOnTopSide) {\n          direction = Upward\n        } else if (isOnBottomSide) {\n          direction = Downward\n        } else {\n          // stop search block element\n          direction = Infinity\n        }\n      }\n\n      index += direction\n    }\n  })\n\n  return {\n    blockElem: blockElem,\n    shouldRemove,\n  }\n}\n\nfunction useAddBlockHandle(\n  editor: LexicalEditor,\n  anchorElem: HTMLElement,\n  isEditable: boolean,\n): JSX.Element {\n  const scrollerElem = anchorElem.parentElement\n\n  const menuRef = useRef<HTMLButtonElement>(null)\n  const [emptyBlockElem, setEmptyBlockElem] = useState<HTMLElement | null>(null)\n\n  useEffect(() => {\n    function onDocumentMouseMove(event: MouseEvent) {\n      const target = event.target\n      if (!isHTMLElement(target)) {\n        return\n      }\n\n      let distanceFromScrollerElem = 0\n      // Calculate distance between scrollerElem and target if target is not in scrollerElem\n      if (scrollerElem && !scrollerElem.contains(target)) {\n        const { bottom, left, right, top } = scrollerElem.getBoundingClientRect()\n        const { pageX, pageY } = event\n        const horizontalBuffer = 50\n        const verticalBuffer = 25\n        const adjustedTop = top + window.scrollY\n        const adjustedBottom = bottom + window.scrollY\n\n        if (\n          pageY < adjustedTop - verticalBuffer ||\n          pageY > adjustedBottom + verticalBuffer ||\n          pageX < left - horizontalBuffer ||\n          pageX > right + horizontalBuffer\n        ) {\n          setEmptyBlockElem(null)\n          return\n        }\n\n        // This is used to allow the _emptyBlockElem to be found when the mouse is in the\n        // buffer zone around the scrollerElem.\n        if (pageX < left || pageX > right) {\n          distanceFromScrollerElem = pageX < left ? pageX - left : pageX - right\n        }\n      }\n\n      if (isOnHandleElement(target, ADD_BLOCK_MENU_CLASSNAME)) {\n        return\n      }\n      const { blockElem: _emptyBlockElem, shouldRemove } = getBlockElement(\n        anchorElem,\n        editor,\n        event,\n        false,\n        -distanceFromScrollerElem,\n      )\n      if (!_emptyBlockElem && !shouldRemove) {\n        return\n      }\n      setEmptyBlockElem(_emptyBlockElem)\n    }\n\n    // Since the draggableBlockElem is outside the actual editor, we need to listen to the document\n    // to be able to detect when the mouse is outside the editor and respect a buffer around the\n    // the scrollerElem to avoid the draggableBlockElem disappearing too early.\n    document?.addEventListener('mousemove', onDocumentMouseMove)\n\n    return () => {\n      document?.removeEventListener('mousemove', onDocumentMouseMove)\n    }\n  }, [scrollerElem, anchorElem, editor])\n\n  useEffect(() => {\n    if (menuRef.current) {\n      setHandlePosition(emptyBlockElem, menuRef.current, anchorElem, SPACE)\n    }\n  }, [anchorElem, emptyBlockElem])\n\n  const handleAddClick = useCallback(\n    (event) => {\n      if (!emptyBlockElem) {\n        return\n      }\n\n      editor.update(() => {\n        const node: ParagraphNode = $getNearestNodeFromDOMNode(emptyBlockElem) as ParagraphNode\n        if (!node || node.getType() !== 'paragraph') {\n          return\n        }\n        editor.focus()\n\n        node.select()\n        /*const ns = $createNodeSelection();\n        ns.add(node.getKey())\n        $setSelection(ns)*/\n      })\n\n      // Make sure this is called AFTER the editorfocus() event has been processed by the browser\n      // Otherwise, this won't work\n      setTimeout(() => {\n        editor.dispatchCommand(ENABLE_SLASH_MENU_COMMAND, {\n          rect: emptyBlockElem.getBoundingClientRect(),\n        })\n      }, 0)\n\n      event.stopPropagation()\n      event.preventDefault()\n    },\n    [editor, emptyBlockElem],\n  )\n\n  return createPortal(\n    <React.Fragment>\n      <button\n        className=\"icon add-block-menu\"\n        onClick={(event) => {\n          handleAddClick(event)\n        }}\n        ref={menuRef}\n        type=\"button\"\n      >\n        <div className={isEditable ? 'icon' : ''} />\n      </button>\n    </React.Fragment>,\n    anchorElem,\n  )\n}\n\nexport function AddBlockHandlePlugin({\n  anchorElem = document.body,\n}: {\n  anchorElem?: HTMLElement\n}): JSX.Element {\n  const [editor] = useLexicalComposerContext()\n  return useAddBlockHandle(editor, anchorElem, editor._editable)\n}\n"],"names":["AddBlockHandlePlugin","SPACE","ADD_BLOCK_MENU_CLASSNAME","Downward","Upward","Indeterminate","prevIndex","Infinity","getCurrentIndex","keysLength","Math","floor","getBlockElement","anchorElem","editor","event","useEdgeAsDefault","horizontalOffset","anchorElementRect","getBoundingClientRect","topLevelNodeKeys","getTopLevelNodeKeys","blockElem","blockNode","shouldRemove","getEditorState","read","firstNode","lastNode","getElementByKey","length","firstNodeRect","lastNodeRect","y","top","bottom","index","direction","key","elem","point","Point","x","domRect","Rect","fromDOM","marginBottom","marginTop","getCollapsedMargins","rect","generateNewRect","left","right","reason","isOnBottomSide","isOnTopSide","result","contains","$getNodeByKey","getType","getTextContent","useAddBlockHandle","isEditable","scrollerElem","parentElement","menuRef","useRef","emptyBlockElem","setEmptyBlockElem","useState","useEffect","onDocumentMouseMove","target","isHTMLElement","distanceFromScrollerElem","pageX","pageY","horizontalBuffer","verticalBuffer","adjustedTop","window","scrollY","adjustedBottom","isOnHandleElement","_emptyBlockElem","document","addEventListener","removeEventListener","current","setHandlePosition","handleAddClick","useCallback","update","node","$getNearestNodeFromDOMNode","focus","select","setTimeout","dispatchCommand","ENABLE_SLASH_MENU_COMMAND","stopPropagation","preventDefault","createPortal","React","Fragment","button","className","onClick","ref","type","div","body","useLexicalComposerContext","_editable"],"mappings":"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"}

package/dist/field/lexical/plugins/handles/DraggableBlockPlugin/debounce.d.ts

@@ -0,0 +1,2 @@
+export declare function debounce(func: Function, wait: number): (...args: any[]) => void;
+//# sourceMappingURL=debounce.d.ts.map

package/dist/field/lexical/plugins/handles/DraggableBlockPlugin/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/handles/DraggableBlockPlugin/debounce.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,aAEzB,GAAG,EAAE,UAUhC"}

package/dist/field/lexical/plugins/handles/DraggableBlockPlugin/debounce.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "debounce", {
+    enumerable: true,
+    get: function() {
+        return debounce;
+    }
+});
+function debounce(func, wait) {
+    let timeout = null;
+    return function(...args) {
+        const later = ()=>{
+            clearTimeout(timeout);
+            timeout = null;
+            func(...args);
+        };
+        clearTimeout(timeout);
+        timeout = window.setTimeout(later, wait);
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9sZXhpY2FsL3BsdWdpbnMvaGFuZGxlcy9EcmFnZ2FibGVCbG9ja1BsdWdpbi9kZWJvdW5jZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gZGVib3VuY2UoZnVuYzogRnVuY3Rpb24sIHdhaXQ6IG51bWJlcikge1xuICBsZXQgdGltZW91dDogbnVsbCB8IG51bWJlciA9IG51bGxcbiAgcmV0dXJuIGZ1bmN0aW9uICguLi5hcmdzOiBhbnlbXSkge1xuICAgIGNvbnN0IGxhdGVyID0gKCkgPT4ge1xuICAgICAgY2xlYXJUaW1lb3V0KHRpbWVvdXQpXG4gICAgICB0aW1lb3V0ID0gbnVsbFxuICAgICAgZnVuYyguLi5hcmdzKVxuICAgIH1cblxuICAgIGNsZWFyVGltZW91dCh0aW1lb3V0KVxuICAgIHRpbWVvdXQgPSB3aW5kb3cuc2V0VGltZW91dChsYXRlciwgd2FpdClcbiAgfVxufVxuIl0sIm5hbWVzIjpbImRlYm91bmNlIiwiZnVuYyIsIndhaXQiLCJ0aW1lb3V0IiwiYXJncyIsImxhdGVyIiwiY2xlYXJUaW1lb3V0Iiwid2luZG93Iiwic2V0VGltZW91dCJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFBZ0JBOzs7ZUFBQUE7OztBQUFULFNBQVNBLFNBQVNDLElBQWMsRUFBRUMsSUFBWTtJQUNuRCxJQUFJQyxVQUF5QjtJQUM3QixPQUFPLFNBQVUsR0FBR0MsSUFBVztRQUM3QixNQUFNQyxRQUFRO1lBQ1pDLGFBQWFIO1lBQ2JBLFVBQVU7WUFDVkYsUUFBUUc7UUFDVjtRQUVBRSxhQUFhSDtRQUNiQSxVQUFVSSxPQUFPQyxVQUFVLENBQUNILE9BQU9IO0lBQ3JDO0FBQ0YifQ==

package/dist/field/lexical/plugins/handles/DraggableBlockPlugin/getBoundingRectWithoutTransform.d.ts

@@ -0,0 +1,2 @@
+export declare function getBoundingClientRectWithoutTransform(elem: HTMLElement): DOMRect;
+//# sourceMappingURL=getBoundingRectWithoutTransform.d.ts.map

package/dist/field/lexical/plugins/handles/DraggableBlockPlugin/getBoundingRectWithoutTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBoundingRectWithoutTransform.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/handles/DraggableBlockPlugin/getBoundingRectWithoutTransform.ts"],"names":[],"mappings":"AAAA,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAchF"}

package/dist/field/lexical/plugins/handles/DraggableBlockPlugin/getBoundingRectWithoutTransform.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getBoundingClientRectWithoutTransform", {
+    enumerable: true,
+    get: function() {
+        return getBoundingClientRectWithoutTransform;
+    }
+});
+function getBoundingClientRectWithoutTransform(elem) {
+    const rect = elem.getBoundingClientRect();
+    // Extract the translation value from the transform style
+    const transformValue = getComputedStyle(elem).getPropertyValue('transform');
+    if (!transformValue || transformValue === 'none') {
+        return rect;
+    }
+    const lastNumberOfTransformValue = transformValue.split(',').pop();
+    rect.y = rect.y - Number(lastNumberOfTransformValue.replace(')', ''));
+    // Return the original bounding rect if no translation is applied
+    return rect;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9sZXhpY2FsL3BsdWdpbnMvaGFuZGxlcy9EcmFnZ2FibGVCbG9ja1BsdWdpbi9nZXRCb3VuZGluZ1JlY3RXaXRob3V0VHJhbnNmb3JtLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBnZXRCb3VuZGluZ0NsaWVudFJlY3RXaXRob3V0VHJhbnNmb3JtKGVsZW06IEhUTUxFbGVtZW50KTogRE9NUmVjdCB7XG4gIGNvbnN0IHJlY3QgPSBlbGVtLmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpXG5cbiAgLy8gRXh0cmFjdCB0aGUgdHJhbnNsYXRpb24gdmFsdWUgZnJvbSB0aGUgdHJhbnNmb3JtIHN0eWxlXG4gIGNvbnN0IHRyYW5zZm9ybVZhbHVlID0gZ2V0Q29tcHV0ZWRTdHlsZShlbGVtKS5nZXRQcm9wZXJ0eVZhbHVlKCd0cmFuc2Zvcm0nKVxuICBpZiAoIXRyYW5zZm9ybVZhbHVlIHx8IHRyYW5zZm9ybVZhbHVlID09PSAnbm9uZScpIHtcbiAgICByZXR1cm4gcmVjdFxuICB9XG5cbiAgY29uc3QgbGFzdE51bWJlck9mVHJhbnNmb3JtVmFsdWUgPSB0cmFuc2Zvcm1WYWx1ZS5zcGxpdCgnLCcpLnBvcCgpXG4gIHJlY3QueSA9IHJlY3QueSAtIE51bWJlcihsYXN0TnVtYmVyT2ZUcmFuc2Zvcm1WYWx1ZS5yZXBsYWNlKCcpJywgJycpKVxuXG4gIC8vIFJldHVybiB0aGUgb3JpZ2luYWwgYm91bmRpbmcgcmVjdCBpZiBubyB0cmFuc2xhdGlvbiBpcyBhcHBsaWVkXG4gIHJldHVybiByZWN0XG59XG4iXSwibmFtZXMiOlsiZ2V0Qm91bmRpbmdDbGllbnRSZWN0V2l0aG91dFRyYW5zZm9ybSIsImVsZW0iLCJyZWN0IiwiZ2V0Qm91bmRpbmdDbGllbnRSZWN0IiwidHJhbnNmb3JtVmFsdWUiLCJnZXRDb21wdXRlZFN0eWxlIiwiZ2V0UHJvcGVydHlWYWx1ZSIsImxhc3ROdW1iZXJPZlRyYW5zZm9ybVZhbHVlIiwic3BsaXQiLCJwb3AiLCJ5IiwiTnVtYmVyIiwicmVwbGFjZSJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFBZ0JBOzs7ZUFBQUE7OztBQUFULFNBQVNBLHNDQUFzQ0MsSUFBaUI7SUFDckUsTUFBTUMsT0FBT0QsS0FBS0UscUJBQXFCO0lBRXZDLHlEQUF5RDtJQUN6RCxNQUFNQyxpQkFBaUJDLGlCQUFpQkosTUFBTUssZ0JBQWdCLENBQUM7SUFDL0QsSUFBSSxDQUFDRixrQkFBa0JBLG1CQUFtQixRQUFRO1FBQ2hELE9BQU9GO0lBQ1Q7SUFFQSxNQUFNSyw2QkFBNkJILGVBQWVJLEtBQUssQ0FBQyxLQUFLQyxHQUFHO0lBQ2hFUCxLQUFLUSxDQUFDLEdBQUdSLEtBQUtRLENBQUMsR0FBR0MsT0FBT0osMkJBQTJCSyxPQUFPLENBQUMsS0FBSztJQUVqRSxpRUFBaUU7SUFDakUsT0FBT1Y7QUFDVCJ9

package/dist/field/lexical/plugins/handles/DraggableBlockPlugin/getNodeCloseToPoint.d.ts

@@ -0,0 +1,27 @@
+import type { LexicalEditor, LexicalNode } from 'lexical';
+import { Point } from '../../../utils/point';
+type Props = {
+    anchorElem: HTMLElement;
+    cache_treshold?: number;
+    editor: LexicalEditor;
+    /** fuzzy makes the search not exact. If no exact match found, find the closes node instead of returning null */
+    fuzzy?: boolean;
+    horizontalOffset?: number;
+    point: Point;
+    /**
+     * The index to start searching from. It can be a considerable performance optimization to start searching from the index of the
+     * previously found node, as the node is likely to be close to the next node.
+     */
+    startIndex?: number;
+    useEdgeAsDefault?: boolean;
+    verbose?: boolean;
+};
+type Output = {
+    blockElem: HTMLElement | null;
+    blockNode: LexicalNode | null;
+    foundAtIndex: number;
+    isFoundNodeEmptyParagraph: boolean;
+};
+export declare function getNodeCloseToPoint(props: Props): Output;
+export {};
+//# sourceMappingURL=getNodeCloseToPoint.d.ts.map

package/dist/field/lexical/plugins/handles/DraggableBlockPlugin/getNodeCloseToPoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getNodeCloseToPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/handles/DraggableBlockPlugin/getNodeCloseToPoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAIzD,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAA;AAW5C,KAAK,KAAK,GAAG;IACX,UAAU,EAAE,WAAW,CAAA;IACvB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,MAAM,EAAE,aAAa,CAAA;IACrB,gHAAgH;IAChH,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,KAAK,EAAE,KAAK,CAAA;IACZ;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,KAAK,MAAM,GAAG;IACZ,SAAS,EAAE,WAAW,GAAG,IAAI,CAAA;IAC7B,SAAS,EAAE,WAAW,GAAG,IAAI,CAAA;IAC7B,YAAY,EAAE,MAAM,CAAA;IACpB,yBAAyB,EAAE,OAAO,CAAA;CACnC,CAAA;AAaD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAkLxD"}

package/dist/field/lexical/plugins/handles/DraggableBlockPlugin/getNodeCloseToPoint.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getNodeCloseToPoint", {
+    enumerable: true,
+    get: function() {
+        return getNodeCloseToPoint;
+    }
+});
+const _lexical = require("lexical");
+const _point = require("../../../utils/point");
+const _rect = require("../../../utils/rect");
+const _getCollapsedMargins = require("../utils/getCollapsedMargins");
+const _getTopLevelNodeKeys = require("../utils/getTopLevelNodeKeys");
+const _getBoundingRectWithoutTransform = require("./getBoundingRectWithoutTransform");
+// Directions
+const Downward = 1;
+const Upward = -1;
+const Indeterminate = 0;
+const cache = {
+    props: null,
+    result: null
+};
+function isPointClose(previous, current, threshold = 20) {
+    const dx = previous.x - current.x;
+    const dy = previous.y - current.y;
+    return dx * dx + dy * dy <= threshold * threshold;
+}
+function getNodeCloseToPoint(props) {
+    const { anchorElem, cache_treshold = 20, editor, fuzzy = false, horizontalOffset = 0, point: { x, y }, startIndex = 0, useEdgeAsDefault = false, verbose = false } = props;
+    // Use cache
+    if (cache_treshold > 0 && cache.props && cache.result && cache.props.fuzzy === props.fuzzy && cache.props.horizontalOffset === props.horizontalOffset && cache.props.useEdgeAsDefault === props.useEdgeAsDefault && isPointClose(cache.props.point, props.point, cache_treshold)) {
+        if (verbose) {
+        //console.log('Returning cached result')
+        }
+        return cache.result;
+    }
+    const anchorElementRect = anchorElem.getBoundingClientRect();
+    const topLevelNodeKeys = (0, _getTopLevelNodeKeys.getTopLevelNodeKeys)(editor);
+    const closestBlockElem = {
+        blockElem: null,
+        blockNode: null,
+        distance: Infinity,
+        foundAtIndex: -1,
+        isFoundNodeEmptyParagraph: false
+    };
+    // Return null if matching block element is the first or last node
+    editor.getEditorState().read(()=>{
+        if (useEdgeAsDefault) {
+            const [firstNode, lastNode] = [
+                editor.getElementByKey(topLevelNodeKeys[0]),
+                editor.getElementByKey(topLevelNodeKeys[topLevelNodeKeys.length - 1])
+            ];
+            const [firstNodeRect, lastNodeRect] = [
+                (0, _getBoundingRectWithoutTransform.getBoundingClientRectWithoutTransform)(firstNode),
+                (0, _getBoundingRectWithoutTransform.getBoundingClientRectWithoutTransform)(lastNode)
+            ];
+            if (firstNodeRect && lastNodeRect) {
+                if (y < firstNodeRect.top) {
+                    closestBlockElem.blockElem = firstNode;
+                    closestBlockElem.distance = firstNodeRect.top - y;
+                    closestBlockElem.blockNode = (0, _lexical.$getNodeByKey)(topLevelNodeKeys[0]);
+                    closestBlockElem.foundAtIndex = 0;
+                } else if (y > lastNodeRect.bottom) {
+                    closestBlockElem.distance = y - lastNodeRect.bottom;
+                    closestBlockElem.blockNode = (0, _lexical.$getNodeByKey)(topLevelNodeKeys[topLevelNodeKeys.length - 1]);
+                    closestBlockElem.blockElem = lastNode;
+                    closestBlockElem.foundAtIndex = topLevelNodeKeys.length - 1;
+                }
+                if (closestBlockElem?.blockElem) {
+                    if (verbose) {
+                    //console.log('useEdgeAsDefault', useEdgeAsDefault)
+                    }
+                    return {
+                        blockElem: null,
+                        isFoundNodeEmptyParagraph: false
+                    };
+                }
+            }
+        }
+        // Find matching block element
+        let index = startIndex;
+        let direction = Indeterminate;
+        if (verbose) {
+        //console.log('start index', startIndex)
+        }
+        while(index >= 0 && index < topLevelNodeKeys.length){
+            const key = topLevelNodeKeys[index];
+            const elem = editor.getElementByKey(key);
+            if (elem === null) {
+                break;
+            }
+            const point = new _point.Point(x + horizontalOffset, y);
+            //const domRect = Rect.fromDOM(elem)
+            // Do not consider transform of blocks when calculating distance
+            const domRect = _rect.Rect.fromDOMRect((0, _getBoundingRectWithoutTransform.getBoundingClientRectWithoutTransform)(elem));
+            const { marginBottom, marginTop } = (0, _getCollapsedMargins.getCollapsedMargins)(elem);
+            const rect = domRect.generateNewRect({
+                bottom: domRect.bottom + marginBottom,
+                left: anchorElementRect.left,
+                right: anchorElementRect.right,
+                top: domRect.top - marginTop
+            });
+            const { distance, isOnBottomSide, isOnTopSide } = rect.distanceFromPoint(point);
+            if (verbose) {
+            //console.log('distance', distance)
+            }
+            if (distance === 0) {
+                closestBlockElem.blockElem = elem;
+                closestBlockElem.blockNode = (0, _lexical.$getNodeByKey)(key);
+                closestBlockElem.foundAtIndex = index;
+                closestBlockElem.distance = distance;
+                // Check if blockNode is an empty text node
+                if (closestBlockElem.blockNode && closestBlockElem.blockNode.getType() === 'paragraph' && closestBlockElem.blockNode.getTextContent() === '') {
+                    if (!fuzzy) {
+                        closestBlockElem.blockElem = null;
+                        closestBlockElem.blockNode = null;
+                    }
+                    closestBlockElem.isFoundNodeEmptyParagraph = true;
+                }
+                break;
+            } else if (fuzzy) {
+                if (distance < closestBlockElem.distance) {
+                    closestBlockElem.blockElem = elem;
+                    closestBlockElem.blockNode = (0, _lexical.$getNodeByKey)(key);
+                    closestBlockElem.distance = distance;
+                    closestBlockElem.foundAtIndex = index;
+                }
+            }
+            if (direction === Indeterminate) {
+                if (isOnTopSide) {
+                    direction = Upward;
+                } else if (isOnBottomSide) {
+                    direction = Downward;
+                } else {
+                    // stop search block element
+                    direction = Infinity;
+                }
+            }
+            index += direction;
+        }
+    });
+    // Store in cache before returning
+    cache.props = props;
+    cache.result = {
+        blockElem: closestBlockElem.blockElem,
+        blockNode: closestBlockElem.blockNode,
+        foundAtIndex: closestBlockElem.foundAtIndex,
+        isFoundNodeEmptyParagraph: closestBlockElem.isFoundNodeEmptyParagraph
+    };
+    return {
+        blockElem: closestBlockElem.blockElem,
+        blockNode: closestBlockElem.blockNode,
+        foundAtIndex: closestBlockElem.foundAtIndex,
+        isFoundNodeEmptyParagraph: closestBlockElem.isFoundNodeEmptyParagraph
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/field/lexical/plugins/handles/DraggableBlockPlugin/getNodeCloseToPoint.ts"],"sourcesContent":["import type { LexicalEditor, LexicalNode } from 'lexical'\n\nimport { $getNodeByKey } from 'lexical'\n\nimport { Point } from '../../../utils/point'\nimport { Rect } from '../../../utils/rect'\nimport { getCollapsedMargins } from '../utils/getCollapsedMargins'\nimport { getTopLevelNodeKeys } from '../utils/getTopLevelNodeKeys'\nimport { getBoundingClientRectWithoutTransform } from './getBoundingRectWithoutTransform'\n\n// Directions\nconst Downward = 1\nconst Upward = -1\nconst Indeterminate = 0\n\ntype Props = {\n  anchorElem: HTMLElement\n  cache_treshold?: number\n  editor: LexicalEditor\n  /** fuzzy makes the search not exact. If no exact match found, find the closes node instead of returning null */\n  fuzzy?: boolean\n  horizontalOffset?: number\n  point: Point\n  /**\n   * The index to start searching from. It can be a considerable performance optimization to start searching from the index of the\n   * previously found node, as the node is likely to be close to the next node.\n   */\n  startIndex?: number\n  useEdgeAsDefault?: boolean\n  verbose?: boolean\n}\n\ntype Output = {\n  blockElem: HTMLElement | null\n  blockNode: LexicalNode | null\n  foundAtIndex: number\n  isFoundNodeEmptyParagraph: boolean\n}\n\nconst cache = {\n  props: null as Props | null,\n  result: null as Output | null,\n}\n\nfunction isPointClose(previous: Point, current: Point, threshold: number = 20): boolean {\n  const dx = previous.x - current.x\n  const dy = previous.y - current.y\n  return dx * dx + dy * dy <= threshold * threshold\n}\n\nexport function getNodeCloseToPoint(props: Props): Output {\n  const {\n    anchorElem,\n    cache_treshold = 20,\n    editor,\n    fuzzy = false,\n    horizontalOffset = 0,\n    point: { x, y },\n    startIndex = 0,\n    useEdgeAsDefault = false,\n    verbose = false,\n  } = props\n\n  // Use cache\n  if (\n    cache_treshold > 0 &&\n    cache.props &&\n    cache.result &&\n    cache.props.fuzzy === props.fuzzy &&\n    cache.props.horizontalOffset === props.horizontalOffset &&\n    cache.props.useEdgeAsDefault === props.useEdgeAsDefault &&\n    isPointClose(cache.props.point, props.point, cache_treshold)\n  ) {\n    if (verbose) {\n      //console.log('Returning cached result')\n    }\n    return cache.result\n  }\n\n  const anchorElementRect = anchorElem.getBoundingClientRect()\n  const topLevelNodeKeys = getTopLevelNodeKeys(editor)\n\n  const closestBlockElem: {\n    blockElem: HTMLElement | null\n    blockNode: LexicalNode | null\n    distance: number\n    foundAtIndex: number\n    isFoundNodeEmptyParagraph: boolean\n  } = {\n    blockElem: null,\n    blockNode: null,\n    distance: Infinity,\n    foundAtIndex: -1,\n    isFoundNodeEmptyParagraph: false,\n  }\n\n  // Return null if matching block element is the first or last node\n  editor.getEditorState().read(() => {\n    if (useEdgeAsDefault) {\n      const [firstNode, lastNode] = [\n        editor.getElementByKey(topLevelNodeKeys[0]),\n        editor.getElementByKey(topLevelNodeKeys[topLevelNodeKeys.length - 1]),\n      ]\n\n      const [firstNodeRect, lastNodeRect] = [\n        getBoundingClientRectWithoutTransform(firstNode),\n        getBoundingClientRectWithoutTransform(lastNode),\n      ]\n\n      if (firstNodeRect && lastNodeRect) {\n        if (y < firstNodeRect.top) {\n          closestBlockElem.blockElem = firstNode\n          closestBlockElem.distance = firstNodeRect.top - y\n          closestBlockElem.blockNode = $getNodeByKey(topLevelNodeKeys[0])\n          closestBlockElem.foundAtIndex = 0\n        } else if (y > lastNodeRect.bottom) {\n          closestBlockElem.distance = y - lastNodeRect.bottom\n          closestBlockElem.blockNode = $getNodeByKey(topLevelNodeKeys[topLevelNodeKeys.length - 1])\n          closestBlockElem.blockElem = lastNode\n          closestBlockElem.foundAtIndex = topLevelNodeKeys.length - 1\n        }\n\n        if (closestBlockElem?.blockElem) {\n          if (verbose) {\n            //console.log('useEdgeAsDefault', useEdgeAsDefault)\n          }\n\n          return {\n            blockElem: null,\n            isFoundNodeEmptyParagraph: false,\n          } as Output\n        }\n      }\n    }\n\n    // Find matching block element\n    let index = startIndex\n    let direction = Indeterminate\n\n    if (verbose) {\n      //console.log('start index', startIndex)\n    }\n\n    while (index >= 0 && index < topLevelNodeKeys.length) {\n      const key = topLevelNodeKeys[index]\n      const elem = editor.getElementByKey(key)\n      if (elem === null) {\n        break\n      }\n      const point = new Point(x + horizontalOffset, y)\n      //const domRect = Rect.fromDOM(elem)\n      // Do not consider transform of blocks when calculating distance\n      const domRect = Rect.fromDOMRect(getBoundingClientRectWithoutTransform(elem))\n\n      const { marginBottom, marginTop } = getCollapsedMargins(elem)\n\n      const rect = domRect.generateNewRect({\n        bottom: domRect.bottom + marginBottom,\n        left: anchorElementRect.left,\n        right: anchorElementRect.right,\n        top: domRect.top - marginTop,\n      })\n\n      const { distance, isOnBottomSide, isOnTopSide } = rect.distanceFromPoint(point)\n\n      if (verbose) {\n        //console.log('distance', distance)\n      }\n\n      if (distance === 0) {\n        closestBlockElem.blockElem = elem\n        closestBlockElem.blockNode = $getNodeByKey(key)\n        closestBlockElem.foundAtIndex = index\n        closestBlockElem.distance = distance\n\n        // Check if blockNode is an empty text node\n        if (\n          closestBlockElem.blockNode &&\n          closestBlockElem.blockNode.getType() === 'paragraph' &&\n          closestBlockElem.blockNode.getTextContent() === ''\n        ) {\n          if (!fuzzy) {\n            closestBlockElem.blockElem = null\n            closestBlockElem.blockNode = null\n          }\n\n          closestBlockElem.isFoundNodeEmptyParagraph = true\n        }\n        break\n      } else if (fuzzy) {\n        if (distance < closestBlockElem.distance) {\n          closestBlockElem.blockElem = elem\n          closestBlockElem.blockNode = $getNodeByKey(key)\n          closestBlockElem.distance = distance\n          closestBlockElem.foundAtIndex = index\n        }\n      }\n\n      if (direction === Indeterminate) {\n        if (isOnTopSide) {\n          direction = Upward\n        } else if (isOnBottomSide) {\n          direction = Downward\n        } else {\n          // stop search block element\n          direction = Infinity\n        }\n      }\n\n      index += direction\n    }\n  })\n\n  // Store in cache before returning\n  cache.props = props\n  cache.result = {\n    blockElem: closestBlockElem.blockElem,\n    blockNode: closestBlockElem.blockNode,\n    foundAtIndex: closestBlockElem.foundAtIndex,\n    isFoundNodeEmptyParagraph: closestBlockElem.isFoundNodeEmptyParagraph,\n  }\n\n  return {\n    blockElem: closestBlockElem.blockElem,\n    blockNode: closestBlockElem.blockNode,\n    foundAtIndex: closestBlockElem.foundAtIndex,\n    isFoundNodeEmptyParagraph: closestBlockElem.isFoundNodeEmptyParagraph,\n  }\n}\n"],"names":["getNodeCloseToPoint","Downward","Upward","Indeterminate","cache","props","result","isPointClose","previous","current","threshold","dx","x","dy","y","anchorElem","cache_treshold","editor","fuzzy","horizontalOffset","point","startIndex","useEdgeAsDefault","verbose","anchorElementRect","getBoundingClientRect","topLevelNodeKeys","getTopLevelNodeKeys","closestBlockElem","blockElem","blockNode","distance","Infinity","foundAtIndex","isFoundNodeEmptyParagraph","getEditorState","read","firstNode","lastNode","getElementByKey","length","firstNodeRect","lastNodeRect","getBoundingClientRectWithoutTransform","top","$getNodeByKey","bottom","index","direction","key","elem","Point","domRect","Rect","fromDOMRect","marginBottom","marginTop","getCollapsedMargins","rect","generateNewRect","left","right","isOnBottomSide","isOnTopSide","distanceFromPoint","getType","getTextContent"],"mappings":"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"}

package/dist/field/lexical/plugins/handles/DraggableBlockPlugin/highlightElemOriginalPosition.d.ts

@@ -0,0 +1,3 @@
+import type React from 'react';
+export declare function highlightElemOriginalPosition(debugHighlightRef: React.RefObject<HTMLDivElement>, htmlElem: HTMLElement, anchorElem: HTMLElement): void;
+//# sourceMappingURL=highlightElemOriginalPosition.d.ts.map

package/dist/field/lexical/plugins/handles/DraggableBlockPlugin/highlightElemOriginalPosition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"highlightElemOriginalPosition.d.ts","sourceRoot":"","sources":["../../../../../../src/field/lexical/plugins/handles/DraggableBlockPlugin/highlightElemOriginalPosition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,wBAAgB,6BAA6B,CAC3C,iBAAiB,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,EAClD,QAAQ,EAAE,WAAW,EACrB,UAAU,EAAE,WAAW,QA4BxB"}