https://github.com/neomjs/neo/issues/8151

Author: tobiu

src/component/DateSelector.mjs

@@ -861,10 +861,10 @@ class DateSelector extends Component {
         me.getCenterContentEl().cn = [];
         me.createDayViewContent(true);
 
-        // using force => we do want to keep the same ids
-        syncIds && me.syncVdomIds(me.vnode, me.vdom, true);
+        // we need to sync the new ids into the vdom
+        syncIds && me.syncVdomState(me.vnode, me.vdom, true);
 
-        !silent && me.update()
+        me.update()
     }
 
     /**

src/date/DayViewComponent.mjs

@@ -241,8 +241,8 @@ class DayViewComponent extends Base {
         me.vdom.cn = [];
         me.createContent(true);
 
-        // using force => we do want to keep the same ids
-        syncIds && me.syncVdomIds(me.vnode, me.vdom, true);
+        // we need to sync the new ids into the vdom
+        syncIds && me.syncVdomState(me.vnode, me.vdom, true);
 
         me.update()
     }

src/functional/component/Base.mjs

@@ -270,7 +270,7 @@ class FunctionalBase extends Abstract {
         // Re-hydrate the new vdom with stable IDs from the previous vnode tree.
         // This is crucial for functional components where the vdom is recreated on every render,
         // ensuring the diffing algorithm can track nodes correctly.
-        me.syncVdomIds();
+        me.syncVdomState();
 
         if (me.beforeUpdate() !== false) {
             me.updateVdom()
@@ -480,55 +480,6 @@ class FunctionalBase extends Abstract {
 
         return vdomTree
     }
-
-    /**
-     * Overrides the default VdomLifecycle.syncVdomIds to also hydrate scroll positions.
-     * This is critical for functional components to maintain scroll state across re-renders.
-     * @param {Neo.vdom.VNode} [vnode=this.vnode]
-     * @param {Object} [vdom=this.vdom]
-     * @param {Boolean} [force=false]
-     */
-    syncVdomIds(vnode=this.vnode, vdom=this.vdom, force=false) {
-        // We cannot use super.syncVdomIds(), since we need to sync the scroll position
-        // in the same run as the ids to ensure performance.
-        if (vnode && vdom) {
-            vdom = VDomUtil.getVdom(vdom);
-
-            let childNodes = vdom.cn,
-                cn, i, len;
-
-            if (force) {
-                if (vnode.id && vdom.id !== vnode.id) {
-                    vdom.id = vnode.id
-                }
-            } else {
-                if (vnode.id && (!vdom.id || vdom.id.startsWith('neo-vnode-'))) {
-                    vdom.id = vnode.id
-                }
-            }
-
-            if (vnode.scrollTop) {
-                vdom.scrollTop = vnode.scrollTop
-            }
-
-            if (vnode.scrollLeft) {
-                vdom.scrollLeft = vnode.scrollLeft
-            }
-
-            if (childNodes) {
-                cn  = childNodes.map(item => VDomUtil.getVdom(item));
-                cn  = cn.filter(item => item && item.removeDom !== true);
-                i   = 0;
-                len = cn?.length || 0;
-
-                for (; i < len; i++) {
-                    if (vnode.childNodes) {
-                        this.syncVdomIds(vnode.childNodes[i], cn[i], force)
-                    }
-                }
-            }
-        }
-    }
 }
 
 export default Neo.setupClass(FunctionalBase);

src/grid/Body.mjs

@@ -992,7 +992,15 @@ class GridBody extends Component {
     }
 
     /**
-     *
+     * @param {Object} data
+     */
+    onScrollCapture(data) {
+        super.onScrollCapture(data);
+        this.parent.scrollManager.onBodyScroll(data)
+    }
+
+    /**
+     * @param {Object} data
      */
     onStoreFilter() {
         this.onStoreLoad({items: this.store.items})

src/grid/Container.mjs

@@ -557,6 +557,14 @@ class GridContainer extends BaseContainer {
         }
     }
 
+    /**
+     * @param {Object} data
+     */
+    onScrollCapture(data) {
+        super.onScrollCapture(data);
+        this.scrollManager.onContainerScroll(data)
+    }
+
     /**
      * @param {Object} opts
      * @param {String} opts.direction

src/grid/ScrollManager.mjs

@@ -74,16 +74,10 @@ class ScrollManager extends Base {
         let me = this;
 
         me.gridBody.addDomListeners({
-            scroll     : me.onBodyScroll,
             touchcancel: me.onTouchCancel,
             touchend   : me.onTouchEnd,
             scope      : me
         });
-
-        me.gridContainer.addDomListeners({
-            scroll: me.onContainerScroll,
-            scope : me
-        })
     }
 
     /**

src/mixin/VdomLifecycle.mjs

@@ -527,13 +527,13 @@ class VdomLifecycle extends Base {
     }
 
     /**
-     * Placeholder method for util.VDom.syncVdomIds to allow overriding (disabling) it
+     * Placeholder method for util.VDom.syncVdomState to allow overriding (disabling) it
      * @param {Neo.vdom.VNode} [vnode=this.vnode]
      * @param {Object} [vdom=this.vdom]
      * @param {Boolean} force=false
      */
-    syncVdomIds(vnode=this.vnode, vdom=this.vdom, force=false) {
-        VDomUtil.syncVdomIds(vnode, vdom, force)
+    syncVdomState(vnode=this.vnode, vdom=this.vdom, force=false) {
+        VDomUtil.syncVdomState(vnode, vdom, force)
     }
 
     /**
@@ -554,7 +554,7 @@ class VdomLifecycle extends Base {
             start = performance.now()
         }
 
-        me.syncVdomIds();
+        me.syncVdomState();
 
         if (vnode && me.id !== vnode.id) {
             ComponentManager.registerWrapperNode(vnode.id, me)

src/util/VDom.mjs

@@ -408,13 +408,24 @@ class VDom extends Base {
     }
 
     /**
-     * Neo.vdom.Helper will create ids for each vnode which does not already have one,
-     * so we need to sync them into the vdom.
+     * Synchronizes state between the live VDOM (blueprint) and the incoming VNode (worker response).
+     *
+     * 1. **ID Synchronization (VNode -> VDOM):**
+     *    `Neo.vdom.Helper` automatically assigns dynamic IDs to any VNode that lacks one, as the
+     *    delta update engine requires unique IDs to target DOM nodes. These generated IDs are
+     *    synced back into the VDOM to ensure stability and persistent referencing for future updates.
+     *
+     * 2. **Scroll State Synchronization (Bidirectional):**
+     *    - **Preservation (VDOM -> VNode):** Ensures that the latest scroll position captured on the
+     *      Main Thread (stored in VDOM) overrides potentially stale state returning from the Worker.
+     *    - **Rehydration (VNode -> VDOM):** Ensures that new VDOM trees (e.g., from Functional Components)
+     *      inherit the persistent scroll state from the existing VNode.
+     *
      * @param {Neo.vdom.VNode} vnode
      * @param {Object} vdom
      * @param {Boolean} force=false The force param will enforce overwriting different ids
      */
-    static syncVdomIds(vnode, vdom, force=false) {
+    static syncVdomState(vnode, vdom, force=false) {
         if (vnode && vdom) {
             vdom = VDom.getVdom(vdom);
 
@@ -435,6 +446,24 @@ class VDom extends Base {
                 }
             }
 
+            // 1. Rehydration (vnode -> vdom)
+            // Used by Functional Components (vdom is new)
+            if (Neo.isNumber(vnode.scrollTop) && !Neo.isNumber(vdom.scrollTop)) {
+                vdom.scrollTop = vnode.scrollTop
+            }
+            if (Neo.isNumber(vnode.scrollLeft) && !Neo.isNumber(vdom.scrollLeft)) {
+                vdom.scrollLeft = vnode.scrollLeft
+            }
+
+            // 2. Preservation (vdom -> vnode)
+            // Used by Classic Components (vdom is source of truth via capture)
+            if (Neo.isNumber(vdom.scrollTop)) {
+                vnode.scrollTop = vdom.scrollTop
+            }
+            if (Neo.isNumber(vdom.scrollLeft)) {
+                vnode.scrollLeft = vdom.scrollLeft
+            }
+
             if (childNodes) {
                 cn  = childNodes.map(item => VDom.getVdom(item));
                 // The vnode.childNodes array is already filtered by the worker.
@@ -448,7 +477,7 @@ class VDom extends Base {
 
                 for (; i < len; i++) {
                     if (vnode.childNodes) {
-                        VDom.syncVdomIds(vnode.childNodes[i], cn[i], force)
+                        VDom.syncVdomState(vnode.childNodes[i], cn[i], force)
                     }
                 }
             }