slate-angular 16.1.0-next.14 → 16.1.0-next.15

package/fesm2022/slate-angular.mjs

@@ -610,13 +610,17 @@ const AngularEditor = {
     /**
      * Find a Slate node from a native DOM `element`.
      */
-    toSlateNode(editor, domNode) {
+    toSlateNode(editor, domNode, options) {
+        const { suppressThrow } = options || { suppressThrow: false };
         let domEl = isDOMElement(domNode) ? domNode : domNode.parentElement;
         if (domEl && !domEl.hasAttribute('data-slate-node')) {
             domEl = domEl.closest(`[data-slate-node]`);
         }
         const node = domEl ? ELEMENT_TO_NODE.get(domEl) : null;
         if (!node) {
+            if (suppressThrow) {
+                return null;
+            }
             throw new Error(`Cannot resolve a Slate node from DOM node: ${domEl}`);
         }
         return node;
@@ -632,7 +636,7 @@ const AngularEditor = {
         if (x == null || y == null) {
             throw new Error(`Cannot resolve a Slate range from a DOM event: ${event}`);
         }
-        const node = AngularEditor.toSlateNode(editor, event.target);
+        const node = AngularEditor.toSlateNode(editor, event.target, { suppressThrow: false });
         const path = AngularEditor.findPath(editor, node);
         // If the drop target is inside a void node, move it into either the
         // next or previous node, depending on which side the `x` and `y`
@@ -668,18 +672,25 @@ const AngularEditor = {
             throw new Error(`Cannot resolve a Slate range from a DOM event: ${event}`);
         }
         // Resolve a Slate range from the DOM range.
-        const range = AngularEditor.toSlateRange(editor, domRange);
+        const range = AngularEditor.toSlateRange(editor, domRange, { suppressThrow: false });
         return range;
     },
-    isLeafInEditor(editor, leafNode) {
+    isLeafInEditor(editor, leafNode, options) {
+        const { suppressThrow } = options;
         const textNode = leafNode.closest('[data-slate-node="text"]');
-        const node = AngularEditor.toSlateNode(editor, textNode);
-        return AngularEditor.isNodeInEditor(editor, node);
+        const node = AngularEditor.toSlateNode(editor, textNode, { suppressThrow });
+        if (node && AngularEditor.isNodeInEditor(editor, node)) {
+            return true;
+        }
+        else {
+            return false;
+        }
     },
     /**
      * Find a Slate point from a DOM selection's `domNode` and `domOffset`.
      */
-    toSlatePoint(editor, domPoint) {
+    toSlatePoint(editor, domPoint, options) {
+        const { exactMatch, suppressThrow } = options;
         const [domNode] = domPoint;
         const [nearestNode, nearestOffset] = normalizeDOMPoint(domPoint);
         let parentNode = nearestNode.parentNode;
@@ -726,7 +737,7 @@ const AngularEditor = {
             let domNode = null;
             // Calculate how far into the text node the `nearestNode` is, so that we
             // can determine what the offset relative to the text node is.
-            if (leafNode && AngularEditor.isLeafInEditor(editor, leafNode)) {
+            if (leafNode && AngularEditor.isLeafInEditor(editor, leafNode, { suppressThrow: true })) {
                 textNode = leafNode.closest('[data-slate-node="text"]');
                 const window = AngularEditor.getWindow(editor);
                 const range = window.document.createRange();
@@ -768,19 +779,26 @@ const AngularEditor = {
             }
         }
         if (!textNode) {
+            if (suppressThrow) {
+                return null;
+            }
             throw new Error(`Cannot resolve a Slate point from DOM point: ${domPoint}`);
         }
         // COMPAT: If someone is clicking from one Slate editor into another,
         // the select event fires twice, once for the old editor's `element`
         // first, and then afterwards for the correct `element`. (2017/03/03)
-        const slateNode = AngularEditor.toSlateNode(editor, textNode);
+        const slateNode = AngularEditor.toSlateNode(editor, textNode, { suppressThrow });
+        if (!slateNode && suppressThrow) {
+            return null;
+        }
         const path = AngularEditor.findPath(editor, slateNode);
         return { path, offset };
     },
     /**
      * Find a Slate range from a DOM range or selection.
      */
-    toSlateRange(editor, domRange) {
+    toSlateRange(editor, domRange, options) {
+        const { exactMatch, suppressThrow } = options || {};
         const el = isDOMSelection(domRange) ? domRange.anchorNode : domRange.startContainer;
         let anchorNode;
         let anchorOffset;
@@ -824,8 +842,14 @@ const AngularEditor = {
             focusNode = anchorNode;
             focusOffset = anchorNode.textContent?.length || 0;
         }
-        const anchor = AngularEditor.toSlatePoint(editor, [anchorNode, anchorOffset]);
-        const focus = isCollapsed ? anchor : AngularEditor.toSlatePoint(editor, [focusNode, focusOffset]);
+        const anchor = AngularEditor.toSlatePoint(editor, [anchorNode, anchorOffset], { suppressThrow, exactMatch });
+        if (!anchor) {
+            return null;
+        }
+        const focus = isCollapsed ? anchor : AngularEditor.toSlatePoint(editor, [focusNode, focusOffset], { suppressThrow, exactMatch });
+        if (!focus) {
+            return null;
+        }
         let range = { anchor: anchor, focus: focus };
         // if the selection is a hanging range that ends in a void
         // and the DOM focus is an Element
@@ -856,7 +880,7 @@ const AngularEditor = {
     },
     toSlateCardEntry(editor, node) {
         const element = node.parentElement.closest('.slate-block-card')?.querySelector('[card-target="card-center"]').firstElementChild;
-        const slateNode = AngularEditor.toSlateNode(editor, element);
+        const slateNode = AngularEditor.toSlateNode(editor, element, { suppressThrow: false });
         const path = AngularEditor.findPath(editor, slateNode);
         return [slateNode, path];
     },
@@ -2461,6 +2485,7 @@ class BaseElementComponent extends BaseComponent {
         if (NODE_TO_ELEMENT.get(this.element) === this.nativeElement) {
             NODE_TO_ELEMENT.delete(this.element);
         }
+        ELEMENT_TO_NODE.delete(this.nativeElement);
         if (ELEMENT_TO_COMPONENT.get(this.element) === this) {
             ELEMENT_TO_COMPONENT.delete(this.element);
         }
@@ -2534,6 +2559,7 @@ class BaseTextComponent extends BaseComponent {
         if (NODE_TO_ELEMENT.get(this.text) === this.nativeElement) {
             NODE_TO_ELEMENT.delete(this.text);
         }
+        ELEMENT_TO_NODE.delete(this.nativeElement);
     }
     onContextChange() {
         this.updateWeakMap();
@@ -3117,12 +3143,11 @@ class SlateEditable {
                 hasDomSelectionInEditor = true;
             }
             // If the DOM selection is in the editor and the editor selection is already correct, we're done.
-            if (hasDomSelection &&
-                hasDomSelectionInEditor &&
-                selection &&
-                hasStringTarget(domSelection) &&
-                Range.equals(AngularEditor.toSlateRange(this.editor, domSelection), selection)) {
-                return;
+            if (hasDomSelection && hasDomSelectionInEditor && selection && hasStringTarget(domSelection)) {
+                const rangeFromDOMSelection = AngularEditor.toSlateRange(this.editor, domSelection, { suppressThrow: true });
+                if (rangeFromDOMSelection && Range.equals(rangeFromDOMSelection, selection)) {
+                    return;
+                }
             }
             // prevent updating native selection when active element is void element
             if (isTargetInsideVoid(this.editor, activeElement)) {
@@ -3133,7 +3158,7 @@ class SlateEditable {
             // but Slate's value is not being updated through any operation
             // and thus it doesn't transform selection on its own
             if (selection && !AngularEditor.hasRange(this.editor, selection)) {
-                this.editor.selection = AngularEditor.toSlateRange(this.editor, domSelection);
+                this.editor.selection = AngularEditor.toSlateRange(this.editor, domSelection, { suppressThrow: false });
                 return;
             }
             // Otherwise the DOM selection is out of sync, so update it.