slate-angular 20.2.0-next.1 → 20.2.0-next.3

package/fesm2022/slate-angular.mjs

@@ -1739,6 +1739,7 @@ class BaseElementFlavour extends BaseFlavour {
         this.getOutletElement = () => {
             return this.nativeElement.querySelector('.children-outlet');
         };
+        this.stableHeight = null;
     }
     get element() {
         return this._context && this._context.element;
@@ -1824,11 +1825,21 @@ class BaseElementFlavour extends BaseFlavour {
             readonly: this._context.readonly
         };
     }
+    isStableHeight() {
+        return false;
+    }
     getRealHeight() {
+        if (this.isStableHeight() && this.stableHeight !== null) {
+            return this.stableHeight;
+        }
         const blockCard = getBlockCardByNativeElement(this.nativeElement);
         const target = blockCard || this.nativeElement;
         const computedStyle = getComputedStyle(target);
-        return Promise.resolve(target.offsetHeight + parseFloat(computedStyle.marginTop) + parseFloat(computedStyle.marginBottom));
+        const height = target.offsetHeight + parseFloat(computedStyle.marginTop) + parseFloat(computedStyle.marginBottom);
+        if (this.isStableHeight()) {
+            this.stableHeight = height;
+        }
+        return height;
     }
 }
 
@@ -2556,20 +2567,32 @@ function executeAfterViewInit(editor) {
 const JUST_NOW_UPDATED_VIRTUAL_VIEW = new WeakMap();
 // not correctly clipboardData on beforeinput
 const forceOnDOMPaste = IS_SAFARI;
+const isDebug = localStorage.getItem(SLATE_DEBUG_KEY) === 'true';
 class SlateEditable {
     set virtualScroll(config) {
         this.virtualConfig = config;
         this.refreshVirtualViewAnimId && cancelAnimationFrame(this.refreshVirtualViewAnimId);
         this.refreshVirtualViewAnimId = requestAnimationFrame(() => {
-            const virtualView = this.refreshVirtualView();
-            const diff = this.diffVirtualView(virtualView);
-            if (diff) {
-                this.applyVirtualView(virtualView);
-                if (this.listRender.initialized) {
-                    this.listRender.update(virtualView.renderedChildren, this.editor, this.context);
+            let virtualView = this.refreshVirtualView();
+            let diff = this.diffVirtualView(virtualView);
+            if (!diff.isDiff) {
+                return;
+            }
+            if (diff.isMissingTop) {
+                const result = this.remeasureHeightByIndics([...diff.diffTopRenderedIndexes]);
+                if (result) {
+                    virtualView = this.refreshVirtualView();
+                    diff = this.diffVirtualView(virtualView, 'second');
+                    if (!diff.isDiff) {
+                        return;
+                    }
                 }
-                this.scheduleMeasureVisibleHeights();
             }
+            this.applyVirtualView(virtualView);
+            if (this.listRender.initialized) {
+                this.listRender.update(virtualView.renderedChildren, this.editor, this.context);
+            }
+            this.scheduleMeasureVisibleHeights();
         });
     }
     get hasBeforeInputSupport() {
@@ -2936,6 +2959,7 @@ class SlateEditable {
             this.elementRef.nativeElement.appendChild(this.virtualTopHeightElement);
             this.elementRef.nativeElement.appendChild(this.virtualCenterOutlet);
             this.elementRef.nativeElement.appendChild(this.virtualBottomHeightElement);
+            // businessHeight
         }
     }
     changeVirtualHeight(topHeight, bottomHeight) {
@@ -3008,67 +3032,75 @@ class SlateEditable {
         this.changeVirtualHeight(virtualView.top, virtualView.bottom);
         this.virtualVisibleIndexes = virtualView.visibleIndexes;
     }
-    diffVirtualView(virtualView) {
+    diffVirtualView(virtualView, stage = 'first') {
         if (!this.renderedChildren.length) {
-            return true;
+            return {
+                isDiff: true,
+                diffTopRenderedIndexes: [],
+                diffBottomRenderedIndexes: []
+            };
         }
         const oldVisibleIndexes = [...this.virtualVisibleIndexes];
         const newVisibleIndexes = [...virtualView.visibleIndexes];
-        if (newVisibleIndexes[0] !== oldVisibleIndexes[0] ||
-            newVisibleIndexes[newVisibleIndexes.length - 1] !== oldVisibleIndexes[oldVisibleIndexes.length - 1]) {
-            if (localStorage.getItem(SLATE_DEBUG_KEY) === 'true') {
-                const diffTopRenderedIndexes = [];
-                const diffBottomRenderedIndexes = [];
-                let direction = '';
-                if (newVisibleIndexes[0] > oldVisibleIndexes[0]) {
-                    // 向下
-                    direction = 'down';
-                    for (let index = 0; index < oldVisibleIndexes.length; index++) {
-                        const element = oldVisibleIndexes[index];
-                        if (!newVisibleIndexes.includes(element)) {
-                            diffTopRenderedIndexes.push(element);
-                        }
-                        else {
-                            break;
-                        }
+        const firstNewIndex = newVisibleIndexes[0];
+        const lastNewIndex = newVisibleIndexes[newVisibleIndexes.length - 1];
+        const firstOldIndex = oldVisibleIndexes[0];
+        const lastOldIndex = oldVisibleIndexes[oldVisibleIndexes.length - 1];
+        if (firstNewIndex !== firstOldIndex || lastNewIndex !== lastOldIndex) {
+            const diffTopRenderedIndexes = [];
+            const diffBottomRenderedIndexes = [];
+            const isMissingTop = firstNewIndex !== firstOldIndex && firstNewIndex > firstOldIndex;
+            const isAddedTop = firstNewIndex !== firstOldIndex && firstNewIndex < firstOldIndex;
+            const isMissingBottom = lastNewIndex !== lastOldIndex && lastOldIndex > lastNewIndex;
+            const isAddedBottom = lastNewIndex !== lastOldIndex && lastOldIndex < lastNewIndex;
+            if (isMissingTop || isAddedBottom) {
+                // 向下
+                for (let index = 0; index < oldVisibleIndexes.length; index++) {
+                    const element = oldVisibleIndexes[index];
+                    if (!newVisibleIndexes.includes(element)) {
+                        diffTopRenderedIndexes.push(element);
                     }
-                    for (let index = newVisibleIndexes.length - 1; index >= 0; index--) {
-                        const element = newVisibleIndexes[index];
-                        if (!oldVisibleIndexes.includes(element)) {
-                            diffBottomRenderedIndexes.push(element);
-                        }
-                        else {
-                            break;
-                        }
+                    else {
+                        break;
                     }
                 }
-                else {
-                    // 向上
-                    direction = 'up';
-                    for (let index = 0; index < newVisibleIndexes.length; index++) {
-                        const element = newVisibleIndexes[index];
-                        if (!oldVisibleIndexes.includes(element)) {
-                            diffTopRenderedIndexes.push(element);
-                        }
-                        else {
-                            break;
-                        }
+                for (let index = newVisibleIndexes.length - 1; index >= 0; index--) {
+                    const element = newVisibleIndexes[index];
+                    if (!oldVisibleIndexes.includes(element)) {
+                        diffBottomRenderedIndexes.push(element);
                     }
-                    for (let index = oldVisibleIndexes.length - 1; index >= 0; index--) {
-                        const element = oldVisibleIndexes[index];
-                        if (!newVisibleIndexes.includes(element)) {
-                            diffBottomRenderedIndexes.push(element);
-                        }
-                        else {
-                            break;
-                        }
+                    else {
+                        break;
+                    }
+                }
+            }
+            else if (isAddedTop || isMissingBottom) {
+                // 向上
+                for (let index = 0; index < newVisibleIndexes.length; index++) {
+                    const element = newVisibleIndexes[index];
+                    if (!oldVisibleIndexes.includes(element)) {
+                        diffTopRenderedIndexes.push(element);
+                    }
+                    else {
+                        break;
+                    }
+                }
+                for (let index = oldVisibleIndexes.length - 1; index >= 0; index--) {
+                    const element = oldVisibleIndexes[index];
+                    if (!newVisibleIndexes.includes(element)) {
+                        diffBottomRenderedIndexes.push(element);
+                    }
+                    else {
+                        break;
                     }
                 }
+            }
+            if (isDebug) {
+                console.log(`====== diffVirtualView stage: ${stage} ======`);
                 console.log('oldVisibleIndexes:', oldVisibleIndexes);
                 console.log('newVisibleIndexes:', newVisibleIndexes);
-                const directionStr = direction === 'down' ? '+' : '-';
-                console.log('diffTopRenderedIndexes:', directionStr, diffTopRenderedIndexes, diffTopRenderedIndexes.map(index => virtualView.heights[index]));
-                console.log('diffBottomRenderedIndexes:', directionStr, diffBottomRenderedIndexes, diffBottomRenderedIndexes.map(index => virtualView.heights[index]));
+                console.log('diffTopRenderedIndexes:', isMissingTop ? '-' : isAddedTop ? '+' : '-', diffTopRenderedIndexes, diffTopRenderedIndexes.map(index => this.getBlockHeight(index, 0)));
+                console.log('diffBottomRenderedIndexes:', isAddedBottom ? '+' : isMissingBottom ? '-' : '+', diffBottomRenderedIndexes, diffBottomRenderedIndexes.map(index => this.getBlockHeight(index, 0)));
                 const needTop = virtualView.heights.slice(0, newVisibleIndexes[0]).reduce((acc, height) => acc + height, 0);
                 const needBottom = virtualView.heights
                     .slice(newVisibleIndexes[newVisibleIndexes.length - 1] + 1)
@@ -3077,17 +3109,29 @@ class SlateEditable {
                 console.log('newBottomHeight:', needBottom, 'prevBottomHeight:', parseFloat(this.virtualBottomHeightElement.style.height));
                 console.warn('=========== Dividing line ===========');
             }
-            return true;
+            return {
+                isDiff: true,
+                isMissingTop,
+                isAddedTop,
+                isMissingBottom,
+                isAddedBottom,
+                diffTopRenderedIndexes,
+                diffBottomRenderedIndexes
+            };
         }
-        return false;
+        return {
+            isDiff: false,
+            diffTopRenderedIndexes: [],
+            diffBottomRenderedIndexes: []
+        };
     }
-    getBlockHeight(index) {
+    getBlockHeight(index, defaultHeight = VIRTUAL_SCROLL_DEFAULT_BLOCK_HEIGHT) {
         const node = this.editor.children[index];
         if (!node) {
-            return VIRTUAL_SCROLL_DEFAULT_BLOCK_HEIGHT;
+            return defaultHeight;
         }
         const key = AngularEditor.findKey(this.editor, node);
-        return this.measuredHeights.get(key.id) ?? VIRTUAL_SCROLL_DEFAULT_BLOCK_HEIGHT;
+        return this.measuredHeights.get(key.id) ?? defaultHeight;
     }
     buildAccumulatedHeight(heights) {
         const accumulatedHeights = new Array(heights.length + 1).fill(0);
@@ -3115,14 +3159,9 @@ class SlateEditable {
         if (!this.shouldUseVirtual()) {
             return;
         }
-        if (this.measurePending) {
-            return;
-        }
-        this.measurePending = true;
         this.measureVisibleHeightsAnimId && cancelAnimationFrame(this.measureVisibleHeightsAnimId);
         this.measureVisibleHeightsAnimId = requestAnimationFrame(() => {
             this.measureVisibleHeights();
-            this.measurePending = false;
         });
     }
     measureVisibleHeights() {
@@ -3141,11 +3180,55 @@ class SlateEditable {
             if (!view) {
                 return;
             }
-            view.getRealHeight()?.then(height => {
-                this.measuredHeights.set(key.id, height);
-            });
+            const ret = view.getRealHeight();
+            if (ret instanceof Promise) {
+                ret.then(height => {
+                    this.measuredHeights.set(key.id, height);
+                });
+            }
+            else {
+                this.measuredHeights.set(key.id, ret);
+            }
         });
     }
+    remeasureHeightByIndics(indics) {
+        const children = (this.editor.children || []);
+        let isHeightChanged = false;
+        indics.forEach(index => {
+            const node = children[index];
+            if (!node) {
+                return;
+            }
+            const key = AngularEditor.findKey(this.editor, node);
+            const view = ELEMENT_TO_COMPONENT.get(node);
+            if (!view) {
+                return;
+            }
+            const prevHeight = this.measuredHeights.get(key.id);
+            const ret = view.getRealHeight();
+            if (ret instanceof Promise) {
+                ret.then(height => {
+                    if (height !== prevHeight) {
+                        this.measuredHeights.set(key.id, height);
+                        isHeightChanged = true;
+                        if (isDebug) {
+                            console.log(`remeasureHeightByIndics, index: ${index} prevHeight: ${prevHeight} newHeight: ${height}`);
+                        }
+                    }
+                });
+            }
+            else {
+                if (ret !== prevHeight) {
+                    this.measuredHeights.set(key.id, ret);
+                    isHeightChanged = true;
+                    if (isDebug) {
+                        console.log(`remeasureHeightByIndics, index: ${index} prevHeight: ${prevHeight} newHeight: ${ret}`);
+                    }
+                }
+            }
+        });
+        return isHeightChanged;
+    }
     //#region event proxy
     addEventListener(eventName, listener, target = this.elementRef.nativeElement) {
         this.manualListeners.push(this.renderer2.listen(target, eventName, (event) => {
@@ -4096,6 +4179,7 @@ class BaseElementComponent extends BaseComponent {
             }
             return null;
         };
+        this.stableHeight = null;
     }
     get element() {
         return this._context && this._context.element;
@@ -4177,11 +4261,21 @@ class BaseElementComponent extends BaseComponent {
             readonly: this._context.readonly
         };
     }
+    isStableHeight() {
+        return false;
+    }
     getRealHeight() {
+        if (this.isStableHeight() && this.stableHeight !== null) {
+            return this.stableHeight;
+        }
         const blockCard = getBlockCardByNativeElement(this.nativeElement);
         const target = blockCard || this.nativeElement;
         const computedStyle = getComputedStyle(target);
-        return Promise.resolve(target.offsetHeight + parseFloat(computedStyle.marginTop) + parseFloat(computedStyle.marginBottom));
+        const height = target.offsetHeight + parseFloat(computedStyle.marginTop) + parseFloat(computedStyle.marginBottom);
+        if (this.isStableHeight()) {
+            this.stableHeight = height;
+        }
+        return height;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.12", ngImport: i0, type: BaseElementComponent, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.12", type: BaseElementComponent, isStandalone: true, viewQueries: [{ propertyName: "childrenOutletInstance", first: true, predicate: SlateChildrenOutlet, descendants: true, static: true }], usesInheritance: true, ngImport: i0 }); }