@oxyhq/bloom 0.79.0 → 0.80.0

package/lib/commonjs/scroll/index.web.js

@@ -3,32 +3,36 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ScrollRestorationProvider = ScrollRestorationProvider;
+Object.defineProperty(exports, "ScrollRestorationProvider", {
+  enumerable: true,
+  get: function () {
+    return _context.ScrollRestorationProvider;
+  }
+});
 exports.useScrollRestoration = useScrollRestoration;
 var _react = require("react");
-var _expoRouter = require("expo-router");
+var _context = require("./context.js");
 var _scrollableWeb = require("./scrollable.web.js");
 var _store = require("./store.js");
-var _jsxRuntime = require("react/jsx-runtime");
 /**
  * Web variant of the scroll-restoration primitive.
  *
- * Mirrors the proven Bluesky pattern (`history.scrollRestoration = 'manual'`
- * plus an in-memory `Map<routeKey, offset>`) with two deliberate differences
- * forced by Oxy's layouts and the behaviour of the (expo-router-wrapped)
- * React Navigation web stack:
+ * Mirrors the proven Bluesky pattern (manual `history.scrollRestoration` plus
+ * an in-memory `Map<key, offset>`) with three deliberate differences forced by
+ * Oxy's layouts and by the behaviour of the (expo-router-wrapped) React
+ * Navigation web stack:
  *
  *  1. Bluesky restores the WINDOW scroller, whereas Oxy apps keep multi-column
  *     layouts whose feed scrolls an INNER container. So we restore the offset
  *     of a caller-registered scrollable (a ref to an element / RN scroll
- *     component, or the `'window'` sentinel), keyed by the active route.
+ *     component, or the `'window'` sentinel).
  *
- *  2. The web stack HIDES the background screen on push. While
- *     hidden, the previous screen's scroll container collapses
- *     (`scrollHeight === clientHeight`) and the navigator forces its
- *     `scrollTop` to 0. The screen is NOT unmounted, so a virtualized list
- *     (e.g. FlashList) keeps its rows but re-lays them out over SEVERAL frames
- *     once the screen is re-shown. Two problems follow, both handled here:
+ *  2. The web stack HIDES the background screen on push. While hidden, the
+ *     previous screen's scroll container collapses (`scrollHeight ===
+ *     clientHeight`) and the navigator forces its `scrollTop` to 0. The screen
+ *     is NOT unmounted, so a virtualized list (e.g. FlashList) keeps its rows
+ *     but re-lays them out over SEVERAL frames once the screen is re-shown. Two
+ *     problems follow, both handled here:
  *
  *       (a) A blur-time read of `scrollTop` returns the navigator's forced 0,
  *           not the user's real offset — saving it would clobber the good
@@ -42,28 +46,22 @@ var _jsxRuntime = require("react/jsx-runtime");
  *           sticks (the content has grown tall enough) or a small frame cap is
  *           reached.
  *
- * Native bundlers use `./index.ts` (a no-op); web bundlers select this file via
- * the `"browser"` export condition in `package.json`.
+ *  3. A document-scrolled app (one window scroller shared by every route) has
+ *     no per-screen container to reset, so an unrecognised key MUST be written
+ *     to 0 explicitly. Doing nothing leaves the previous screen's offset in
+ *     place and the new screen opens mid-page.
  *
- * The navigation hooks are imported from `expo-router` (which re-exports
- * `useFocusEffect` and `useRoute` from its bundled React Navigation core) rather
- * than from `@react-navigation/native` directly. Every Oxy app uses expo-router
- * as its router, so it is always a DIRECT, top-level dependency that resolves
- * cleanly under Bun's isolated linker — whereas `@react-navigation/native` is
- * only a nested/transitive dependency of expo-router and would fail to resolve
- * when bundling those apps.
+ * Native bundlers use `./index.ts`; web bundlers select this file via the
+ * `"browser"` export condition in `package.json`.
  */
 
-const ScrollOffsetContext = /*#__PURE__*/(0, _react.createContext)(null);
-ScrollOffsetContext.displayName = 'BloomScrollOffsetContext';
-
 /**
- * Maximum number of animation frames the focus restore will re-apply the saved
- * offset before giving up. A virtualized list re-lays out its rows over a
- * handful of frames after its screen is re-shown; ~30 frames (≈0.5s at 60fps)
- * is comfortably longer than any observed relayout while staying short enough
- * that the loop never lingers as a perceptible cost. The loop normally exits
- * far earlier — as soon as the write sticks.
+ * Maximum number of animation frames the restore will re-apply the saved offset
+ * before giving up. A virtualized list re-lays out its rows over a handful of
+ * frames after its screen is re-shown; ~30 frames (≈0.5s at 60fps) is
+ * comfortably longer than any observed relayout while staying short enough that
+ * the loop never lingers as a perceptible cost. The loop normally exits far
+ * earlier — as soon as the write sticks.
  */
 const RESTORE_FRAME_CAP = 30;
 
@@ -77,141 +75,243 @@ const RESTORE_FRAME_CAP = 30;
 const RESTORE_STICK_TOLERANCE_PX = 2;
 
 /**
- * Switch the browser to manual scroll restoration exactly once per document.
- *
- * The browser's default `'auto'` restoration fights our manual restore on
- * Back/Forward navigations. Doing this at module scope (guarded for SSR) means
- * it is set before any provider mounts, matching Bluesky's module-level call.
+ * The web binding is a constant: this platform observes offsets by subscribing
+ * to the resolved DOM node's own `scroll` event, so it needs nothing from the
+ * caller. It is still returned — and still safe to spread onto a list — so a
+ * call site is written once and runs on both platforms.
  */
-if (typeof history !== 'undefined' && 'scrollRestoration' in history) {
-  history.scrollRestoration = 'manual';
-}
+const WEB_BINDING = {
+  onScroll: () => undefined
+};
 
 /**
- * Holds the per-route offset map for the subtree. One provider near the app
- * root is enough; the store lives for the document's lifetime so offsets
- * survive navigating away and back (including browser Back/Forward).
+ * Events that mean the USER has taken over the scroller, and the restore must
+ * stop trying to put them back.
+ *
+ * The browser's own restoration is specified the same way: HTML §7.4.6.5 has
+ * the UA re-attempt the saved position and "may continue to attempt to do so
+ * periodically, until document's has been scrolled by the user becomes true".
+ * Without this the loop fights anyone who starts scrolling inside the frame
+ * budget, yanking them back once per frame for up to {@link RESTORE_FRAME_CAP}
+ * frames.
+ *
+ * Two designs were rejected, and the reasons are the point:
+ *
+ *  - **"Any `scroll` event aborts"** — the obvious version, and it aborts on the
+ *    FIRST frame every time: `setOffset` is itself a scroll, so the loop would
+ *    cancel on the event its own write produced and no restore would ever
+ *    complete.
+ *  - **"Abort on an offset we did not write"** — tempting because it needs no
+ *    listeners, but a virtualized list inserting rows ABOVE the viewport makes
+ *    the browser's scroll anchoring move `scrollTop` on its own. That is
+ *    precisely the situation the loop exists for, so the unexplained-delta test
+ *    would abort exactly when it must not.
+ *
+ * What is being detected is user INPUT, so this detects user input. `pointerdown`
+ * covers a scrollbar drag and a touch-less press; `keydown` covers arrow/page
+ * keys, and reaches us whenever focus is inside the scroller it would scroll.
  */
-function ScrollRestorationProvider({
-  children
-}) {
-  const store = (0, _react.useMemo)(() => new _store.ScrollOffsetStore(), []);
-  return /*#__PURE__*/(0, _jsxRuntime.jsx)(ScrollOffsetContext.Provider, {
-    value: store,
-    children: children
-  });
-}
-function useScrollOffsetStore() {
-  const store = (0, _react.useContext)(ScrollOffsetContext);
-  if (store === null) {
-    throw new Error('useScrollRestoration must be used within a <ScrollRestorationProvider>.');
-  }
-  return store;
-}
+const USER_TAKEOVER_EVENTS = ['wheel', 'touchstart', 'pointerdown', 'keydown'];
 
 /**
  * Preserve and restore the scroll offset of `target` across navigation, keyed
- * by the active route (plus an optional `options.key` for routes that host
- * multiple scrollables).
+ * by the content its screen is showing plus an optional `options.key`.
  *
  * Behaviour (web):
  * - On every scroll while the screen is focused, the current offset is recorded
- *   in memory and persisted. This live stream of saves is the source of truth.
- * - On focus, the saved offset is re-applied across a bounded run of animation
- *   frames, stopping as soon as the write sticks (the list has re-rendered its
- *   rows and grown tall enough) or {@link RESTORE_FRAME_CAP} is reached. A
- *   saved offset of 0 is a no-op (nothing to restore).
- * - On blur, the LAST OBSERVED offset is persisted as a final safety net — not
- *   a fresh `scrollTop` read, which the navigator may already have forced to 0
- *   while collapsing the hidden screen.
+ *   under the key that was live when the listener was attached. This stream of
+ *   saves is the source of truth.
+ * - On focus — and again whenever the key changes while the screen STAYS
+ *   focused, which is how an in-screen tab or folder swap is seen at all — the
+ *   offset saved for the new key is re-applied across a bounded run of
+ *   animation frames, stopping as soon as the write sticks or
+ *   {@link RESTORE_FRAME_CAP} is reached. Content never seen this session is
+ *   written to 0 once instead; a write to 0 always sticks, so it needs no loop.
+ * - On blur (and on a key change), the LAST OBSERVED offset is persisted under
+ *   the OUTGOING key as a final safety net — not a fresh `scrollTop` read,
+ *   which the navigator may already have forced to 0 while collapsing the
+ *   hidden screen.
  */
 function useScrollRestoration(target, options) {
-  const store = useScrollOffsetStore();
-  const route = (0, _expoRouter.useRoute)();
-  const subKey = options?.key;
+  const {
+    store,
+    adapter
+  } = (0, _context.useScrollRestorationContext)();
+  const contentId = adapter.useScreenContentId();
   const enabled = options?.enabled ?? true;
-  const scrollKey = (0, _store.deriveScrollKey)(route.key, subKey);
+  const scrollKey = (0, _store.deriveScrollKey)(contentId, options?.key);
 
-  // Keep the latest target/enabled/key in refs so the focus effect can read
-  // them without being re-subscribed on every render.
-  const targetRef = (0, _react.useRef)(target);
-  targetRef.current = target;
-  const enabledRef = (0, _react.useRef)(enabled);
-  enabledRef.current = enabled;
-  const scrollKeyRef = (0, _react.useRef)(scrollKey);
-  scrollKeyRef.current = scrollKey;
-  (0, _expoRouter.useFocusEffect)(
-  // The effect identity is intentionally stable across renders: it reads all
-  // varying inputs from refs. expo-router's `useFocusEffect` re-runs it on
-  // each focus.
+  // The key this hook instance has already sent to the top. Writing 0 is a
+  // one-time ARRIVAL action: a later re-run for the SAME key (`enabled` turning
+  // on once the rows exist, a screen regaining focus) must not repeat it,
+  // because by then the user may have scrolled somewhere the hook never got to
+  // record. Restoring twice is harmless; resetting twice is data loss.
+  const resetKeyRef = (0, _react.useRef)(null);
+  adapter.useScreenFocusEffect(
+  // Every varying input is a dependency rather than a ref read, so the
+  // session below CLOSES OVER the key it belongs to. That is what makes a
+  // key change mid-focus correct in both directions: the outgoing session's
+  // cleanup persists to the old key, and the incoming one restores the new.
   (0, _react.useCallback)(() => {
-    const key = scrollKeyRef.current;
-    if (!enabledRef.current || key === null) return undefined;
-    const scroller = (0, _scrollableWeb.createScroller)(targetRef.current);
-    const element = targetRef.current === 'window' ? typeof window !== 'undefined' ? window : null : resolveScrollEventTarget(targetRef.current);
+    if (!enabled || scrollKey === null) return undefined;
+    const scroller = (0, _scrollableWeb.createScroller)(target);
+    const element = target === 'window' ? typeof window === 'undefined' ? null : window : resolveScrollEventTarget(target);
 
-    // The last offset the live scroll listener observed for this focus
-    // session. This — not a blur-time `getOffset()` — is what we persist on
-    // blur, because by blur time the navigator may have collapsed the
-    // hidden screen and forced its `scrollTop` to 0 (bug A). `null` means
-    // the user never scrolled this session, so there is nothing newer to
-    // persist than what the scroll listener already saved live.
+    // The last offset the live scroll listener observed for this session.
+    // This — not a cleanup-time `getOffset()` — is what we persist at the
+    // end, because by then the navigator may have collapsed the hidden
+    // screen and forced its `scrollTop` to 0 (problem A). `null` means the
+    // user never scrolled this session, so there is nothing newer to persist
+    // than what the scroll listener already saved live.
     let lastObservedOffset = null;
+
+    // The offset WE last wrote, which a real browser dispatches back as a
+    // `scroll` event (jsdom does not, so the tests for this emit it
+    // explicitly). Both writers arm it: the reset, and every frame of the
+    // restore loop. Persisting either records an offset the user never
+    // chose — the reset's 0 under a key another LIVE screen may share (the
+    // two-live-entries trade content keying makes, see `deriveScrollKey`),
+    // and the loop's intermediate value as a PARTIAL that outlives an
+    // interrupted restore.
+    //
+    // A `restoring` FLAG covering the loop's duration is the obvious
+    // alternative and is wrong. It could only be cleared by a takeover
+    // event, so a session whose scroll came from a source that fires none —
+    // `scrollIntoView` from another component, a focus-driven scroll — would
+    // suppress saves indefinitely and never record the user's position at
+    // all: an unbounded corruption traded for a bounded one. Arming a VALUE
+    // is bounded to one event per write and covers every way the loop can
+    // end (stuck, capped, aborted), because each frame re-arms.
+    let echoOffset = null;
+
+    // The largest offset reachable when we last PERSISTED one. A browser
+    // clamp is recognised against this rather than against the previous
+    // OBSERVATION, and that distinction is the whole mechanism: Chrome
+    // dispatches TWO `scroll` events for one clamp, so an
+    // observation-relative test sees the shrink on the first and nothing on
+    // the second, which then saves the clamped value anyway. Measured.
+    let maxOffsetAtLastSave = scroller.getMaxOffset();
     const save = () => {
-      const currentKey = scrollKeyRef.current;
-      if (!enabledRef.current || currentKey === null) return;
       const offset = scroller.getOffset();
+      const maxOffset = scroller.getMaxOffset();
       // Ignore a spurious 0 produced by the navigator collapsing a hidden
       // background screen: while collapsed the container cannot scroll, so
-      // its `scrollTop` is forced to 0. Persisting it would clobber the
-      // good offset recorded by earlier live saves (bug A). A genuine
+      // its `scrollTop` is forced to 0. Persisting it would clobber the good
+      // offset recorded by earlier live saves (problem A). A genuine
       // scroll-to-top keeps the container scrollable and is saved normally.
-      if (offset === 0 && !scroller.canScroll()) return;
+      if (offset === 0 && maxOffset <= 0) return;
+      // A partial clamp: the reachable range SHRANK and the offset is sitting
+      // exactly at the new bottom. That is what the browser does to a tab
+      // whose document has been taken over by a shorter sibling — the two
+      // together are a signature a genuine scroll does not have, because
+      // reaching the bottom on your own does not shrink the page in the same
+      // breath. Suppressing keeps the pre-clamp offset, which on return
+      // simply clamps to the same place if the content really did shrink.
+      if (maxOffset < maxOffsetAtLastSave && Math.abs(offset - maxOffset) <= RESTORE_STICK_TOLERANCE_PX) {
+        return;
+      }
+      if (offset === echoOffset) {
+        // Our own write coming back. Consume the arming so a real scroll to
+        // the same offset later is saved normally.
+        echoOffset = null;
+        return;
+      }
+      echoOffset = null;
       lastObservedOffset = offset;
-      store.save(currentKey, offset);
+      maxOffsetAtLastSave = maxOffset;
+      store.save(scrollKey, offset);
     };
 
-    // Restore across a bounded run of frames. A freshly re-shown
-    // virtualized list re-lays out its rows over several frames, so a
-    // single write while it is still collapsed would be clamped to 0 and
-    // never re-applied (bug B). We re-apply each frame until the write
-    // sticks or the frame cap is hit.
-    const targetOffset = store.read(key);
+    // Restore and reset are ONE write. A miss reads 0, and 0 is exactly what
+    // an unseen screen must be written to — left alone it would show the
+    // previous screen's offset, since a document-scrolled app shares one
+    // scroller across every route.
+    const targetOffset = store.read(scrollKey);
+
+    // They remain two DECISIONS, though, and `read` cannot tell them apart:
+    // a key never seen and a key deliberately saved at the top both read 0.
+    // Only the first is a RESET, and a reset is a one-time ARRIVAL action
+    // gated on `resetKeyRef` — repeating it on a later re-run for the same
+    // key would send a user who has since scrolled back to the top, and the
+    // hook was inert while they did it so there is nothing to restore them
+    // to afterwards. A 0 the user deliberately saved is theirs, and always
+    // re-applies. `has` is the only thing that answers this.
+    const isReset = !store.has(scrollKey);
+    const alreadyReset = isReset && resetKeyRef.current === scrollKey;
+    if (isReset) resetKeyRef.current = scrollKey;
     let rafId = null;
-    if (targetOffset > 0 && typeof requestAnimationFrame !== 'undefined') {
+    const stopRestore = () => {
+      if (rafId === null) return;
+      cancelAnimationFrame(rafId);
+      rafId = null;
+    };
+    if (alreadyReset) {
+      // Nothing to write: this content has already been sent to the top once
+      // and the user is wherever they have moved to since.
+    } else if (targetOffset === 0) {
+      // A write to 0 is never clamped away, so it needs no re-apply loop.
+      echoOffset = 0;
+      scroller.setOffset(0);
+    } else if (typeof requestAnimationFrame !== 'undefined') {
+      // Re-apply across a bounded run of frames. A freshly re-shown
+      // virtualized list re-lays out its rows over several frames, so a
+      // single write while it is still collapsed would be clamped to 0 and
+      // never re-applied (problem B).
+      //
+      // Every write the loop makes is suppressed from the save path (see
+      // `echoOffset` below), so an interrupted restore leaves the ORIGINAL
+      // target stored rather than a partial. Nothing is lost on the success
+      // path: `targetOffset` came out of the store, so persisting it again
+      // would write back the same number.
       let framesLeft = RESTORE_FRAME_CAP;
       const applyOffset = () => {
         rafId = null;
         scroller.setOffset(targetOffset);
         framesLeft -= 1;
+        // `getOffset` re-reads the value the browser actually took, which is
+        // clamped to the content height it has reached so far. Arm it as the
+        // echo to swallow: this write is about to come back as a `scroll`
+        // event, and persisting a PARTIAL offset we wrote ourselves is how a
+        // restore that is aborted or capped corrupts the stored position.
+        const landed = scroller.getOffset();
+        echoOffset = landed;
         // Stop once the write took effect (content grew tall enough) or we
-        // exhaust the frame budget. `getOffset` re-reads the clamped value.
-        const reached = Math.abs(scroller.getOffset() - targetOffset) <= RESTORE_STICK_TOLERANCE_PX;
+        // exhaust the frame budget.
+        const reached = Math.abs(landed - targetOffset) <= RESTORE_STICK_TOLERANCE_PX;
         if (!reached && framesLeft > 0) {
           rafId = requestAnimationFrame(applyOffset);
         }
       };
       rafId = requestAnimationFrame(applyOffset);
+      // Only while a loop is actually in flight — the reset path has nothing
+      // to abort, and the listeners would be idle on every screen.
+      for (const type of USER_TAKEOVER_EVENTS) {
+        element?.addEventListener(type, stopRestore, {
+          passive: true
+        });
+      }
     }
     element?.addEventListener('scroll', save, {
       passive: true
     });
     return () => {
-      if (rafId !== null) cancelAnimationFrame(rafId);
+      stopRestore();
       element?.removeEventListener('scroll', save);
-      // Final capture on blur: persist the last offset the scroll listener
-      // OBSERVED, never a fresh read (which the navigator may have forced
-      // to 0 while collapsing the hidden screen). When the user never
-      // scrolled this session there is nothing newer to persist than the
-      // live saves already recorded.
+      // Removing a listener that was never added is a no-op, so this needs no
+      // flag tracking whether the loop branch ran.
+      for (const type of USER_TAKEOVER_EVENTS) {
+        element?.removeEventListener(type, stopRestore);
+      }
+      // Final capture: persist the last offset the scroll listener OBSERVED,
+      // never a fresh read (which the navigator may have forced to 0 while
+      // collapsing the hidden screen). When the user never scrolled this
+      // session there is nothing newer than the live saves already recorded.
       if (lastObservedOffset !== null) {
-        const currentKey = scrollKeyRef.current;
-        if (enabledRef.current && currentKey !== null) {
-          store.save(currentKey, lastObservedOffset);
-        }
+        store.save(scrollKey, lastObservedOffset);
       }
     };
-  }, [store]));
+  }, [store, scrollKey, enabled, target]));
+  return WEB_BINDING;
 }
 
 /**

package/lib/commonjs/scroll/index.web.js.map

@@ -1 +1 @@
-{"version":3,"names":["_react","require","_expoRouter","_scrollableWeb","_store","_jsxRuntime","ScrollOffsetContext","createContext","displayName","RESTORE_FRAME_CAP","RESTORE_STICK_TOLERANCE_PX","history","scrollRestoration","ScrollRestorationProvider","children","store","useMemo","ScrollOffsetStore","jsx","Provider","value","useScrollOffsetStore","useContext","Error","useScrollRestoration","target","options","route","useRoute","subKey","key","enabled","scrollKey","deriveScrollKey","targetRef","useRef","current","enabledRef","scrollKeyRef","useFocusEffect","useCallback","undefined","scroller","createScroller","element","window","resolveScrollEventTarget","lastObservedOffset","save","currentKey","offset","getOffset","canScroll","targetOffset","read","rafId","requestAnimationFrame","framesLeft","applyOffset","setOffset","reached","Math","abs","addEventListener","passive","cancelAnimationFrame","removeEventListener","EventTarget","handle","getScrollableNode","node"],"sourceRoot":"../../../src","sources":["scroll/index.web.tsx"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_react","require","_context","_scrollableWeb","_store","RESTORE_FRAME_CAP","RESTORE_STICK_TOLERANCE_PX","WEB_BINDING","onScroll","undefined","USER_TAKEOVER_EVENTS","useScrollRestoration","target","options","store","adapter","useScrollRestorationContext","contentId","useScreenContentId","enabled","scrollKey","deriveScrollKey","key","resetKeyRef","useRef","useScreenFocusEffect","useCallback","scroller","createScroller","element","window","resolveScrollEventTarget","lastObservedOffset","echoOffset","maxOffsetAtLastSave","getMaxOffset","save","offset","getOffset","maxOffset","Math","abs","targetOffset","read","isReset","has","alreadyReset","current","rafId","stopRestore","cancelAnimationFrame","setOffset","requestAnimationFrame","framesLeft","applyOffset","landed","reached","type","addEventListener","passive","removeEventListener","EventTarget","handle","getScrollableNode","node"],"sourceRoot":"../../../src","sources":["scroll/index.web.tsx"],"mappings":";;;;;;;;;;;;AAwCA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,QAAA,GAAAD,OAAA;AACA,IAAAE,cAAA,GAAAF,OAAA;AACA,IAAAG,MAAA,GAAAH,OAAA;AA5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAwBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMI,iBAAiB,GAAG,EAAE;;AAE5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,0BAA0B,GAAG,CAAC;;AAEpC;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,WAAqC,GAAG;EAAEC,QAAQ,EAAEA,CAAA,KAAMC;AAAU,CAAC;;AAE3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,oBAAoB,GAAG,CAAC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,CAAC;;AAE9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,oBAAoBA,CAClCC,MAA+B,EAC/BC,OAAqC,EACX;EAC1B,MAAM;IAAEC,KAAK;IAAEC;EAAQ,CAAC,GAAG,IAAAC,oCAA2B,EAAC,CAAC;EACxD,MAAMC,SAAS,GAAGF,OAAO,CAACG,kBAAkB,CAAC,CAAC;EAC9C,MAAMC,OAAO,GAAGN,OAAO,EAAEM,OAAO,IAAI,IAAI;EACxC,MAAMC,SAAS,GAAG,IAAAC,sBAAe,EAACJ,SAAS,EAAEJ,OAAO,EAAES,GAAG,CAAC;;EAE1D;EACA;EACA;EACA;EACA;EACA,MAAMC,WAAW,GAAG,IAAAC,aAAM,EA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","ignoreList":[]}

package/lib/commonjs/scroll/scrollable.native.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createScroller = createScroller;
+/**
+ * The write half of a scrollable, on native. There is no read half: native
+ * offers no way to sample a list's offset from outside it, so offsets arrive
+ * through the `onScroll` binding the hook returns instead.
+ */
+
+function hasScrollToOffset(value) {
+  return typeof value === 'object' && value !== null && typeof value.scrollToOffset === 'function';
+}
+function hasScrollTo(value) {
+  return typeof value === 'object' && value !== null && typeof value.scrollTo === 'function';
+}
+
+/**
+ * Build a {@link NativeScroller} for a target.
+ *
+ * `scrollToOffset` (`FlatList`, `FlashList`) is preferred over `scrollTo`
+ * (`ScrollView`) because a list exposes both shapes on some versions and only
+ * the former accounts for the list's own header. The `'window'` sentinel has no
+ * native meaning — there is no document scroller — so it resolves to a no-op
+ * rather than an error: a call site shared with web legitimately passes it.
+ *
+ * The handle is re-resolved on every write; it is never cached, because a ref
+ * can be swapped or detached between the schedule and the write.
+ */
+function createScroller(target) {
+  if (target === 'window') {
+    return {
+      setOffset: () => undefined
+    };
+  }
+  return {
+    setOffset: offset => {
+      const current = target.current;
+      if (current == null) return;
+      if (hasScrollToOffset(current)) {
+        current.scrollToOffset({
+          offset,
+          animated: false
+        });
+        return;
+      }
+      if (hasScrollTo(current)) {
+        current.scrollTo({
+          y: offset,
+          animated: false
+        });
+      }
+    }
+  };
+}
+//# sourceMappingURL=scrollable.native.js.map

package/lib/commonjs/scroll/scrollable.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["hasScrollToOffset","value","scrollToOffset","hasScrollTo","scrollTo","createScroller","target","setOffset","undefined","offset","current","animated","y"],"sourceRoot":"../../../src","sources":["scroll/scrollable.native.ts"],"mappings":";;;;;;AAEA;AACA;AACA;AACA;AACA;;AAKA,SAASA,iBAAiBA,CACxBC,KAAc,EAC+C;EAC7D,OACE,OAAOA,KAAK,KAAK,QAAQ,IACzBA,KAAK,KAAK,IAAI,IACd,OAAQA,KAAK,CAAsBC,cAAc,KAAK,UAAU;AAEpE;AAEA,SAASC,WAAWA,CAClBF,KAAc,EACyC;EACvD,OACE,OAAOA,KAAK,KAAK,QAAQ,IACzBA,KAAK,KAAK,IAAI,IACd,OAAQA,KAAK,CAAsBG,QAAQ,KAAK,UAAU;AAE9D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,cAAcA,CAC5BC,MAA+B,EACf;EAChB,IAAIA,MAAM,KAAK,QAAQ,EAAE;IACvB,OAAO;MAAEC,SAAS,EAAEA,CAAA,KAAMC;IAAU,CAAC;EACvC;EAEA,OAAO;IACLD,SAAS,EAAGE,MAAM,IAAK;MACrB,MAAMC,OAAO,GAAGJ,MAAM,CAACI,OAAO;MAC9B,IAAIA,OAAO,IAAI,IAAI,EAAE;MACrB,IAAIV,iBAAiB,CAACU,OAAO,CAAC,EAAE;QAC9BA,OAAO,CAACR,cAAc,CAAC;UAAEO,MAAM;UAAEE,QAAQ,EAAE;QAAM,CAAC,CAAC;QACnD;MACF;MACA,IAAIR,WAAW,CAACO,OAAO,CAAC,EAAE;QACxBA,OAAO,CAACN,QAAQ,CAAC;UAAEQ,CAAC,EAAEH,MAAM;UAAEE,QAAQ,EAAE;QAAM,CAAC,CAAC;MAClD;IACF;EACF,CAAC;AACH","ignoreList":[]}

package/lib/commonjs/scroll/scrollable.web.js

@@ -48,7 +48,12 @@ function createScroller(target) {
       setOffset: offset => {
         if (typeof window !== 'undefined') window.scrollTo(0, offset);
       },
-      canScroll: () => true
+      getMaxOffset: () => {
+        if (typeof window === 'undefined' || typeof document === 'undefined') {
+          return 0;
+        }
+        return Math.max(0, document.documentElement.scrollHeight - window.innerHeight);
+      }
     };
   }
   return {
@@ -60,9 +65,10 @@ function createScroller(target) {
       const element = resolveElement(target);
       if (element) element.scrollTop = offset;
     },
-    canScroll: () => {
+    getMaxOffset: () => {
       const element = resolveElement(target);
-      return element ? element.scrollHeight > element.clientHeight : false;
+      if (!element) return 0;
+      return Math.max(0, element.scrollHeight - element.clientHeight);
     }
   };
 }

package/lib/commonjs/scroll/scrollable.web.js.map

@@ -1 +1 @@
-{"version":3,"names":["isElement","value","HTMLElement","hasGetScrollableNode","getScrollableNode","resolveElement","target","current","node","createScroller","getOffset","window","scrollY","setOffset","offset","scrollTo","canScroll","element","scrollTop","scrollHeight","clientHeight"],"sourceRoot":"../../../src","sources":["scroll/scrollable.web.ts"],"mappings":";;;;;;AAEA;AACA;AACA;AACA;AACA;;AAkBA,SAASA,SAASA,CAACC,KAAc,EAAwB;EACvD,OAAO,OAAOC,WAAW,KAAK,WAAW,IAAID,KAAK,YAAYC,WAAW;AAC3E;AAEA,SAASC,oBAAoBA,CAC3BF,KAAc,EACkD;EAChE,OACE,OAAOA,KAAK,KAAK,QAAQ,IACzBA,KAAK,KAAK,IAAI,IACd,OAAQA,KAAK,CAAsBG,iBAAiB,KAAK,UAAU;AAEvE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,cAAcA,CAACC,MAA+B,EAAsB;EAC3E,IAAIA,MAAM,KAAK,QAAQ,EAAE,OAAO,IAAI;EAEpC,MAAMC,OAAO,GAAID,MAAM,CAA0BC,OAAO;EACxD,IAAIA,OAAO,IAAI,IAAI,EAAE,OAAO,IAAI;EAEhC,IAAIP,SAAS,CAACO,OAAO,CAAC,EAAE,OAAOA,OAAO;EAEtC,IAAIJ,oBAAoB,CAACI,OAAO,CAAC,EAAE;IACjC,MAAMC,IAAI,GAAGD,OAAO,CAACH,iBAAiB,CAAC,CAAC;IACxC,IAAIJ,SAAS,CAACQ,IAAI,CAAC,EAAE,OAAOA,IAAI;EAClC;EAEA,OAAO,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACO,SAASC,cAAcA,CAACH,MAA+B,EAAoB;EAChF,IAAIA,MAAM,KAAK,QAAQ,EAAE;IACvB,OAAO;MACLI,SAAS,EAAEA,CAAA,KAAO,OAAOC,MAAM,KAAK,WAAW,GAAG,CAAC,GAAGA,MAAM,CAACC,OAAQ;MACrEC,SAAS,EAAGC,MAAM,IAAK;QACrB,IAAI,OAAOH,MAAM,KAAK,WAAW,EAAEA,MAAM,CAACI,QAAQ,CAAC,CAAC,EAAED,MAAM,CAAC;MAC/D,CAAC;MACDE,SAAS,EAAEA,CAAA,KAAM;IACnB,CAAC;EACH;EAEA,OAAO;IACLN,SAAS,EAAEA,CAAA,KAAM;MACf,MAAMO,OAAO,GAAGZ,cAAc,CAACC,MAAM,CAAC;MACtC,OAAOW,OAAO,GAAGA,OAAO,CAACC,SAAS,GAAG,CAAC;IACxC,CAAC;IACDL,SAAS,EAAGC,MAAM,IAAK;MACrB,MAAMG,OAAO,GAAGZ,cAAc,CAACC,MAAM,CAAC;MACtC,IAAIW,OAAO,EAAEA,OAAO,CAACC,SAAS,GAAGJ,MAAM;IACzC,CAAC;IACDE,SAAS,EAAEA,CAAA,KAAM;MACf,MAAMC,OAAO,GAAGZ,cAAc,CAACC,MAAM,CAAC;MACtC,OAAOW,OAAO,GAAGA,OAAO,CAACE,YAAY,GAAGF,OAAO,CAACG,YAAY,GAAG,KAAK;IACtE;EACF,CAAC;AACH","ignoreList":[]}
+{"version":3,"names":["isElement","value","HTMLElement","hasGetScrollableNode","getScrollableNode","resolveElement","target","current","node","createScroller","getOffset","window","scrollY","setOffset","offset","scrollTo","getMaxOffset","document","Math","max","documentElement","scrollHeight","innerHeight","element","scrollTop","clientHeight"],"sourceRoot":"../../../src","sources":["scroll/scrollable.web.ts"],"mappings":";;;;;;AAEA;AACA;AACA;AACA;AACA;;AA+BA,SAASA,SAASA,CAACC,KAAc,EAAwB;EACvD,OAAO,OAAOC,WAAW,KAAK,WAAW,IAAID,KAAK,YAAYC,WAAW;AAC3E;AAEA,SAASC,oBAAoBA,CAC3BF,KAAc,EACkD;EAChE,OACE,OAAOA,KAAK,KAAK,QAAQ,IACzBA,KAAK,KAAK,IAAI,IACd,OAAQA,KAAK,CAAsBG,iBAAiB,KAAK,UAAU;AAEvE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,cAAcA,CAACC,MAA+B,EAAsB;EAC3E,IAAIA,MAAM,KAAK,QAAQ,EAAE,OAAO,IAAI;EAEpC,MAAMC,OAAO,GAAID,MAAM,CAA0BC,OAAO;EACxD,IAAIA,OAAO,IAAI,IAAI,EAAE,OAAO,IAAI;EAEhC,IAAIP,SAAS,CAACO,OAAO,CAAC,EAAE,OAAOA,OAAO;EAEtC,IAAIJ,oBAAoB,CAACI,OAAO,CAAC,EAAE;IACjC,MAAMC,IAAI,GAAGD,OAAO,CAACH,iBAAiB,CAAC,CAAC;IACxC,IAAIJ,SAAS,CAACQ,IAAI,CAAC,EAAE,OAAOA,IAAI;EAClC;EAEA,OAAO,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACO,SAASC,cAAcA,CAACH,MAA+B,EAAoB;EAChF,IAAIA,MAAM,KAAK,QAAQ,EAAE;IACvB,OAAO;MACLI,SAAS,EAAEA,CAAA,KAAO,OAAOC,MAAM,KAAK,WAAW,GAAG,CAAC,GAAGA,MAAM,CAACC,OAAQ;MACrEC,SAAS,EAAGC,MAAM,IAAK;QACrB,IAAI,OAAOH,MAAM,KAAK,WAAW,EAAEA,MAAM,CAACI,QAAQ,CAAC,CAAC,EAAED,MAAM,CAAC;MAC/D,CAAC;MACDE,YAAY,EAAEA,CAAA,KAAM;QAClB,IAAI,OAAOL,MAAM,KAAK,WAAW,IAAI,OAAOM,QAAQ,KAAK,WAAW,EAAE;UACpE,OAAO,CAAC;QACV;QACA,OAAOC,IAAI,CAACC,GAAG,CACb,CAAC,EACDF,QAAQ,CAACG,eAAe,CAACC,YAAY,GAAGV,MAAM,CAACW,WACjD,CAAC;MACH;IACF,CAAC;EACH;EAEA,OAAO;IACLZ,SAAS,EAAEA,CAAA,KAAM;MACf,MAAMa,OAAO,GAAGlB,cAAc,CAACC,MAAM,CAAC;MACtC,OAAOiB,OAAO,GAAGA,OAAO,CAACC,SAAS,GAAG,CAAC;IACxC,CAAC;IACDX,SAAS,EAAGC,MAAM,IAAK;MACrB,MAAMS,OAAO,GAAGlB,cAAc,CAACC,MAAM,CAAC;MACtC,IAAIiB,OAAO,EAAEA,OAAO,CAACC,SAAS,GAAGV,MAAM;IACzC,CAAC;IACDE,YAAY,EAAEA,CAAA,KAAM;MAClB,MAAMO,OAAO,GAAGlB,cAAc,CAACC,MAAM,CAAC;MACtC,IAAI,CAACiB,OAAO,EAAE,OAAO,CAAC;MACtB,OAAOL,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEI,OAAO,CAACF,YAAY,GAAGE,OAAO,CAACE,YAAY,CAAC;IACjE;EACF,CAAC;AACH","ignoreList":[]}