Changes in src/assets/js/mod/read.js [9173265:e48ec78] in Klonkt

File:

• src/assets/js/mod/read.js (modified) (1 diff)

src/assets/js/mod/read.js

@@ -448 +448 @@
     if (punten[vooruit].value - nu <= vangZone()) echtGaNaar(vooruit);
   };
+
+  // OP TOUCH DOET DE MODULE-EIGEN TRIGGER HET NIET, en dat is meetbaar in de
+  // vendor-bron, geen vermoeden. Drie feiten op een rij:
+  //
+  //   1. lenis geeft 'virtual-scroll' door met de RUWE vingerdelta, VOOR hij
+  //      de uitloop uitrekent (teken * |snelheid|^touchInertiaExponent).
+  //   2. lenis-snap negeert elke touchmove en beoordeelt dus EEN keer per
+  //      gebaar, op touchend, met `scroll + rawDelta` -- de plek waar je
+  //      vinger LOSLIET.
+  //   3. de uitloop draagt daarna nog honderden pixels verder.
+  //
+  // De snapbeslissing valt dus op een positie die de scroll meteen verlaat.
+  // Op desktop klopt dezelfde som wel: wieldelta's zijn klein en de
+  // smoothWheel-uitloop is kort, dus voorspelling en landing liggen bijeen.
+  // Vandaar: op touch de module-trigger eraf en zelf beoordelen tegen
+  // lenis.targetScroll -- die wordt synchroon bij touchend gezet en IS het
+  // exacte landingspunt van de uitloop.
+  if (OP_TOUCH.matches) {
+    // Hoe lang het richten naar de lijn duurt, in seconden. De ene knop voor
+    // "snapperiger": 0.18 is direct, 0.3 is landen, 0.5 is zweven.
+    const SNAP_DUUR = 0.22;
+    lenis.off('virtual-scroll', snap.onSnapDebounced);
+    let raakTimer = null;
+    let vertrek = 0;   // scrollpositie bij loslaten: punten daarachter zijn
+                       // de bovenkant van het HUIDIGE bericht, nooit grijpen
+    lenis.on('virtual-scroll', (e) => {
+      const soort = e.event && e.event.type;
+      if (soort === 'touchstart' || soort === 'touchmove') { clearTimeout(raakTimer); return; }
+      if (soort !== 'touchend') return;
+      vertrek = lenis.scroll;
+      clearTimeout(raakTimer);
+      // TIMEOUT 0, geen 150ms. Dit event komt binnen VOOR lenis zelf de
+      // touchend verwerkt (de emit staat in de bron boven de verwerking), dus
+      // targetScroll is hier nog het oude doel. Een tik later is de uitloop
+      // gestart en staat targetScroll op de echte landing -- en dan sturen we
+      // hem meteen bij, in plaats van de uitloop 150ms te laten lopen en er
+      // dan een aparte snap-animatie overheen te zetten.
+      raakTimer = setTimeout(() => {
+        if (!laatsteRichtingOmlaag || snap.isStopped) return;
+        const doel = lenis.targetScroll;   // de echte landing, niet de raakdelta
+        const punten = snap.computeSnaps();
+        // De EERSTE grens voorbij het loslaatpunt, niet de dichtstbijzijnde bij
+        // de landing. Robins regel (24-8): wordt het target voorbijgescrolld,
+        // dan landen we alsnog OP het target. De zone werkt dus alleen aan de
+        // korte kant -- kom je er niet eens bij in de buurt, dan lees je gewoon
+        // binnen een lang bericht en blijft alles vrij. Eroverheen, hoe ver
+        // ook, betekent grijpen. Een harde veeg komt daarmee altijd precies
+        // een bericht verder, nooit twee: dat is het bladeren.
+        let eerste = -1;
+        punten.forEach((punt, i) => {
+          if (punt.value > vertrek + 2 && (eerste < 0 || punt.value < punten[eerste].value)) eerste = i;
+        });
+        if (eerste < 0) return;            // niets meer voor je: vrij uitscrollen
+        // HET RICHTEN IS DE SNAP (Robins regel, 24-8): de lopende uitloop
+        // krijgt het nieuwe doel, er komt geen tweede animatie overheen.
+        //
+        // MET EEN VASTE DUUR, niet met de lerp van de uitloop. Die lerp-vorm
+        // (0.09) is boterzacht maar heeft een exponentiele staart van ruim een
+        // halve seconde -- Robin wilde het korter en beslister (24-8). Een
+        // duur eindigt ECHT, op een instelbaar moment, zoals iOS-paging: vlot
+        // weg, stevig landen. Zelfde easing-familie als de desktop-snap.
+        // SNAP_DUUR is de enige knop: korter is snapperiger, langer is zachter.
+        if (doel >= punten[eerste].value - vangZone()) {
+          lenis.scrollTo(punten[eerste].value, {
+            duration: SNAP_DUUR,
+            easing: (t) => 1 - Math.pow(1 - t, 4),
+            force: true,
+            userData: { initiator: 'snap' },
+          });
+        }
+      }, 0);
+    });
+  }
+
   // Native snappen uit: twee mechanismen op dezelfde scroller vechten.
   document.documentElement.style.scrollSnapType = 'none';