@oxyhq/bloom 0.6.21 → 0.6.23

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

@@ -0,0 +1,220 @@
+"use strict";
+
+/**
+ * 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 React Navigation's 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.
+ *
+ *  2. React Navigation's 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
+ *           value. We therefore persist the last offset OBSERVED by the live
+ *           scroll listener, never a fresh read taken at blur time.
+ *
+ *       (b) A single-frame restore writes `scrollTop` while the list is still
+ *           collapsed; the write is clamped to 0 and never re-applied once the
+ *           content grows. We therefore re-apply the target offset across a
+ *           bounded run of animation frames, stopping as soon as the write
+ *           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`.
+ */
+import { createContext, useCallback, useContext, useMemo, useRef } from 'react';
+import { useFocusEffect, useRoute } from '@react-navigation/native';
+import { createScroller } from "./scrollable.web.js";
+import { ScrollOffsetStore, deriveScrollKey } from "./store.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+const ScrollOffsetContext = /*#__PURE__*/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.
+ */
+const RESTORE_FRAME_CAP = 30;
+
+/**
+ * Tolerance (in CSS pixels) for considering a restore "stuck". After writing
+ * `element.scrollTop = target`, the browser may clamp it to the current
+ * `scrollHeight - clientHeight`; if the resulting offset is within this many
+ * pixels of the target we treat the restore as complete. Sub-pixel rounding and
+ * fractional device-pixel ratios make an exact equality check unreliable.
+ */
+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.
+ */
+if (typeof history !== 'undefined' && 'scrollRestoration' in history) {
+  history.scrollRestoration = 'manual';
+}
+
+/**
+ * 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).
+ */
+export function ScrollRestorationProvider({
+  children
+}) {
+  const store = useMemo(() => new ScrollOffsetStore(), []);
+  return /*#__PURE__*/_jsx(ScrollOffsetContext.Provider, {
+    value: store,
+    children: children
+  });
+}
+function useScrollOffsetStore() {
+  const store = useContext(ScrollOffsetContext);
+  if (store === null) {
+    throw new Error('useScrollRestoration must be used within a <ScrollRestorationProvider>.');
+  }
+  return store;
+}
+
+/**
+ * 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).
+ *
+ * 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.
+ */
+export function useScrollRestoration(target, options) {
+  const store = useScrollOffsetStore();
+  const route = useRoute();
+  const subKey = options?.key;
+  const enabled = options?.enabled ?? true;
+  const scrollKey = deriveScrollKey(route.key, subKey);
+
+  // Keep the latest target/enabled/key in refs so the focus effect can read
+  // them without being re-subscribed on every render.
+  const targetRef = useRef(target);
+  targetRef.current = target;
+  const enabledRef = useRef(enabled);
+  enabledRef.current = enabled;
+  const scrollKeyRef = useRef(scrollKey);
+  scrollKeyRef.current = scrollKey;
+  useFocusEffect(
+  // The effect identity is intentionally stable across renders: it reads all
+  // varying inputs from refs. React Navigation re-runs it on each focus.
+  useCallback(() => {
+    const key = scrollKeyRef.current;
+    if (!enabledRef.current || key === null) return undefined;
+    const scroller = createScroller(targetRef.current);
+    const element = targetRef.current === 'window' ? typeof window !== 'undefined' ? window : null : resolveScrollEventTarget(targetRef.current);
+
+    // 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.
+    let lastObservedOffset = null;
+    const save = () => {
+      const currentKey = scrollKeyRef.current;
+      if (!enabledRef.current || currentKey === null) return;
+      const offset = scroller.getOffset();
+      // 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
+      // scroll-to-top keeps the container scrollable and is saved normally.
+      if (offset === 0 && !scroller.canScroll()) return;
+      lastObservedOffset = offset;
+      store.save(currentKey, 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);
+    let rafId = null;
+    if (targetOffset > 0 && typeof requestAnimationFrame !== 'undefined') {
+      let framesLeft = RESTORE_FRAME_CAP;
+      const applyOffset = () => {
+        rafId = null;
+        scroller.setOffset(targetOffset);
+        framesLeft -= 1;
+        // 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;
+        if (!reached && framesLeft > 0) {
+          rafId = requestAnimationFrame(applyOffset);
+        }
+      };
+      rafId = requestAnimationFrame(applyOffset);
+    }
+    element?.addEventListener('scroll', save, {
+      passive: true
+    });
+    return () => {
+      if (rafId !== null) cancelAnimationFrame(rafId);
+      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.
+      if (lastObservedOffset !== null) {
+        const currentKey = scrollKeyRef.current;
+        if (enabledRef.current && currentKey !== null) {
+          store.save(currentKey, lastObservedOffset);
+        }
+      }
+    };
+  }, [store]));
+}
+
+/**
+ * Resolve the EventTarget to listen for `scroll` on. RNW scroll components
+ * expose `getScrollableNode()`; raw refs may hold the DOM node directly.
+ */
+function resolveScrollEventTarget(target) {
+  const current = target.current;
+  if (current == null) return null;
+  if (typeof EventTarget !== 'undefined' && current instanceof EventTarget) {
+    return current;
+  }
+  const handle = current;
+  if (typeof handle.getScrollableNode === 'function') {
+    const node = handle.getScrollableNode();
+    if (typeof EventTarget !== 'undefined' && node instanceof EventTarget) {
+      return node;
+    }
+  }
+  return null;
+}
+//# sourceMappingURL=index.web.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createContext","useCallback","useContext","useMemo","useRef","useFocusEffect","useRoute","createScroller","ScrollOffsetStore","deriveScrollKey","jsx","_jsx","ScrollOffsetContext","displayName","RESTORE_FRAME_CAP","RESTORE_STICK_TOLERANCE_PX","history","scrollRestoration","ScrollRestorationProvider","children","store","Provider","value","useScrollOffsetStore","Error","useScrollRestoration","target","options","route","subKey","key","enabled","scrollKey","targetRef","current","enabledRef","scrollKeyRef","undefined","scroller","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":[]}

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

@@ -0,0 +1,65 @@
+"use strict";
+
+/**
+ * A normalized read/write interface over whatever the caller registered, so
+ * the hook does not branch on target shape. All methods are safe no-ops when
+ * the underlying element is not yet (or no longer) attached.
+ */
+
+function isElement(value) {
+  return typeof HTMLElement !== 'undefined' && value instanceof HTMLElement;
+}
+function hasGetScrollableNode(value) {
+  return typeof value === 'object' && value !== null && typeof value.getScrollableNode === 'function';
+}
+
+/**
+ * Resolve the live DOM element a target currently points at, or `null`.
+ *
+ * RNW scroll components expose `getScrollableNode()`; plain refs may hold the
+ * DOM node directly. We never cache the node because RNW can swap it across
+ * renders — we re-resolve on every read/write.
+ */
+function resolveElement(target) {
+  if (target === 'window') return null;
+  const current = target.current;
+  if (current == null) return null;
+  if (isElement(current)) return current;
+  if (hasGetScrollableNode(current)) {
+    const node = current.getScrollableNode();
+    if (isElement(node)) return node;
+  }
+  return null;
+}
+
+/**
+ * Build a {@link ResolvedScroller} for a target. The window sentinel reads and
+ * writes the document scroller; everything else operates on the resolved
+ * element's `scrollTop`.
+ */
+export function createScroller(target) {
+  if (target === 'window') {
+    return {
+      getOffset: () => typeof window === 'undefined' ? 0 : window.scrollY,
+      setOffset: offset => {
+        if (typeof window !== 'undefined') window.scrollTo(0, offset);
+      },
+      canScroll: () => true
+    };
+  }
+  return {
+    getOffset: () => {
+      const element = resolveElement(target);
+      return element ? element.scrollTop : 0;
+    },
+    setOffset: offset => {
+      const element = resolveElement(target);
+      if (element) element.scrollTop = offset;
+    },
+    canScroll: () => {
+      const element = resolveElement(target);
+      return element ? element.scrollHeight > element.clientHeight : false;
+    }
+  };
+}
+//# sourceMappingURL=scrollable.web.js.map

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

@@ -0,0 +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;AACA,OAAO,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":[]}

package/lib/module/scroll/store.js

@@ -0,0 +1,84 @@
+"use strict";
+
+/**
+ * Pure, platform-agnostic core of the scroll-restoration primitive.
+ *
+ * This file deliberately contains NO React and NO DOM/native imports so the
+ * logic can be unit-tested in isolation and shared verbatim by the web and
+ * native barrels. The web barrel drives it with real scroll offsets; the
+ * native barrel never instantiates it (native-stack already restores scroll).
+ */
+
+/**
+ * Separator between the navigation route key and an optional caller-supplied
+ * sub-key. A route may host more than one independently-scrolling list (e.g.
+ * a tabbed profile screen), so each list contributes its own sub-key.
+ *
+ * `\0` (NUL) can never appear in a React Navigation route key or in a
+ * developer-authored sub-key, so it is collision-free as a delimiter. It is
+ * written as an escape sequence (not a literal byte) so the source stays
+ * text-diffable.
+ */
+const COMPOSITE_KEY_SEPARATOR = '\0';
+
+/**
+ * Derive the storage key for a scrollable from its owning route key and an
+ * optional caller sub-key.
+ *
+ * - `routeKey` is React Navigation's stable per-route `route.key`.
+ * - `subKey` distinguishes multiple scrollables that share a single route.
+ *
+ * Returns `null` when there is no route key to anchor against (the scrollable
+ * is not inside a navigator), which the caller treats as "do not persist".
+ */
+export function deriveScrollKey(routeKey, subKey) {
+  if (!routeKey) return null;
+  if (subKey === undefined || subKey === '') return routeKey;
+  return `${routeKey}${COMPOSITE_KEY_SEPARATOR}${subKey}`;
+}
+
+/**
+ * In-memory map of `scrollKey -> last-known scroll offset`.
+ *
+ * Mirrors the semantics of Bluesky's `Map<screenKey, scrollY>`: offsets live
+ * only for the lifetime of the document/session. We never persist them — a
+ * full reload should start at the top — and we never auto-evict, because a
+ * route can be revisited via browser Forward/Back long after it blurred.
+ */
+export class ScrollOffsetStore {
+  offsets = new Map();
+
+  /** Persist the offset for a key. A negative offset is clamped to 0. */
+  save(key, offset) {
+    this.offsets.set(key, offset > 0 ? offset : 0);
+  }
+
+  /**
+   * Read the saved offset for a key. Returns `0` when nothing was saved, so
+   * callers can restore unconditionally (an unseen list restores to the top).
+   */
+  read(key) {
+    return this.offsets.get(key) ?? 0;
+  }
+
+  /** Whether an offset was ever saved for this key. */
+  has(key) {
+    return this.offsets.has(key);
+  }
+
+  /** Drop a saved offset (e.g. when a route is permanently removed). */
+  forget(key) {
+    this.offsets.delete(key);
+  }
+
+  /** Clear every saved offset. Primarily for tests and full resets. */
+  clear() {
+    this.offsets.clear();
+  }
+
+  /** Number of distinct keys currently tracked. */
+  get size() {
+    return this.offsets.size;
+  }
+}
+//# sourceMappingURL=store.js.map

package/lib/module/scroll/store.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["COMPOSITE_KEY_SEPARATOR","deriveScrollKey","routeKey","subKey","undefined","ScrollOffsetStore","offsets","Map","save","key","offset","set","read","get","has","forget","delete","clear","size"],"sourceRoot":"../../../src","sources":["scroll/store.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMA,uBAAuB,GAAG,IAAI;;AAEpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,eAAeA,CAC7BC,QAA4B,EAC5BC,MAAe,EACA;EACf,IAAI,CAACD,QAAQ,EAAE,OAAO,IAAI;EAC1B,IAAIC,MAAM,KAAKC,SAAS,IAAID,MAAM,KAAK,EAAE,EAAE,OAAOD,QAAQ;EAC1D,OAAO,GAAGA,QAAQ,GAAGF,uBAAuB,GAAGG,MAAM,EAAE;AACzD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAME,iBAAiB,CAAC;EACZC,OAAO,GAAG,IAAIC,GAAG,CAAiB,CAAC;;EAEpD;EACAC,IAAIA,CAACC,GAAW,EAAEC,MAAc,EAAQ;IACtC,IAAI,CAACJ,OAAO,CAACK,GAAG,CAACF,GAAG,EAAEC,MAAM,GAAG,CAAC,GAAGA,MAAM,GAAG,CAAC,CAAC;EAChD;;EAEA;AACF;AACA;AACA;EACEE,IAAIA,CAACH,GAAW,EAAU;IACxB,OAAO,IAAI,CAACH,OAAO,CAACO,GAAG,CAACJ,GAAG,CAAC,IAAI,CAAC;EACnC;;EAEA;EACAK,GAAGA,CAACL,GAAW,EAAW;IACxB,OAAO,IAAI,CAACH,OAAO,CAACQ,GAAG,CAACL,GAAG,CAAC;EAC9B;;EAEA;EACAM,MAAMA,CAACN,GAAW,EAAQ;IACxB,IAAI,CAACH,OAAO,CAACU,MAAM,CAACP,GAAG,CAAC;EAC1B;;EAEA;EACAQ,KAAKA,CAAA,EAAS;IACZ,IAAI,CAACX,OAAO,CAACW,KAAK,CAAC,CAAC;EACtB;;EAEA;EACA,IAAIC,IAAIA,CAAA,EAAW;IACjB,OAAO,IAAI,CAACZ,OAAO,CAACY,IAAI;EAC1B;AACF","ignoreList":[]}

package/lib/module/scroll/types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=types.js.map

package/lib/module/scroll/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["scroll/types.ts"],"mappings":"","ignoreList":[]}

package/lib/typescript/commonjs/scroll/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Native variant of the scroll-restoration primitive — a deliberate no-op.
+ *
+ * React Navigation's native-stack keeps every screen mounted while it is in the
+ * stack, so a list's scroll position survives a push/pop for free. There is
+ * nothing to save or restore. We still ship the full API surface (provider +
+ * hook) so consumers write one set of call sites that compile and run on every
+ * platform; on native the provider just renders its children and the hook does
+ * nothing.
+ *
+ * Web bundlers select `./index.web` via the `"browser"` export condition in
+ * `package.json`; native bundlers fall through to this file.
+ */
+import type { ReactElement } from 'react';
+import type { ScrollRestorationProviderProps, ScrollRestorationTarget, UseScrollRestorationOptions } from './types';
+export type { ScrollableHandle, ScrollRestorationProviderProps, ScrollRestorationTarget, UseScrollRestorationOptions, } from './types';
+/**
+ * No-op provider. Renders children unchanged — native scroll persistence is
+ * handled by the navigator, so no per-route state is kept.
+ */
+export declare function ScrollRestorationProvider({ children, }: ScrollRestorationProviderProps): ReactElement;
+/**
+ * No-op hook. Accepts the same arguments as the web implementation so call
+ * sites are identical across platforms.
+ */
+export declare function useScrollRestoration(_target: ScrollRestorationTarget, _options?: UseScrollRestorationOptions): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/scroll/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/scroll/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAC1C,OAAO,KAAK,EACV,8BAA8B,EAC9B,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,SAAS,CAAC;AAEjB,YAAY,EACV,gBAAgB,EAChB,8BAA8B,EAC9B,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,QAAQ,GACT,EAAE,8BAA8B,GAAG,YAAY,CAE/C;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,uBAAuB,EAChC,QAAQ,CAAC,EAAE,2BAA2B,GACrC,IAAI,CAEN"}

package/lib/typescript/commonjs/scroll/index.web.d.ts

@@ -0,0 +1,26 @@
+import type { ScrollRestorationProviderProps, ScrollRestorationTarget, UseScrollRestorationOptions } from './types';
+export type { ScrollableHandle, ScrollRestorationProviderProps, ScrollRestorationTarget, UseScrollRestorationOptions, } from './types';
+/**
+ * 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).
+ */
+export declare function ScrollRestorationProvider({ children, }: ScrollRestorationProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * 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).
+ *
+ * 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.
+ */
+export declare function useScrollRestoration(target: ScrollRestorationTarget, options?: UseScrollRestorationOptions): void;
+//# sourceMappingURL=index.web.d.ts.map

package/lib/typescript/commonjs/scroll/index.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.web.d.ts","sourceRoot":"","sources":["../../../../src/scroll/index.web.tsx"],"names":[],"mappings":"AAuCA,OAAO,KAAK,EACV,8BAA8B,EAC9B,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,SAAS,CAAC;AAEjB,YAAY,EACV,gBAAgB,EAChB,8BAA8B,EAC9B,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,SAAS,CAAC;AAmCjB;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,QAAQ,GACT,EAAE,8BAA8B,2CAOhC;AAYD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,uBAAuB,EAC/B,OAAO,CAAC,EAAE,2BAA2B,GACpC,IAAI,CAoGN"}

package/lib/typescript/commonjs/scroll/scrollable.web.d.ts

@@ -0,0 +1,29 @@
+import type { ScrollRestorationTarget } from './types';
+/**
+ * A normalized read/write interface over whatever the caller registered, so
+ * the hook does not branch on target shape. All methods are safe no-ops when
+ * the underlying element is not yet (or no longer) attached.
+ */
+export interface ResolvedScroller {
+    getOffset: () => number;
+    setOffset: (offset: number) => void;
+    /**
+     * Whether the scroll container can currently hold a non-zero offset, i.e.
+     * its content is taller than its viewport (`scrollHeight > clientHeight`).
+     *
+     * React Navigation's web stack collapses a hidden background screen so its
+     * content height drops to the viewport height; while collapsed the container
+     * cannot be scrolled and its `scrollTop` is forced to 0. The hook uses this
+     * to ignore a spurious 0 read coming from a collapsed container rather than
+     * persisting it over a previously-saved good offset. The `'window'` scroller
+     * is never collapsed by the navigator, so it always reports `true`.
+     */
+    canScroll: () => boolean;
+}
+/**
+ * Build a {@link ResolvedScroller} for a target. The window sentinel reads and
+ * writes the document scroller; everything else operates on the resolved
+ * element's `scrollTop`.
+ */
+export declare function createScroller(target: ScrollRestorationTarget): ResolvedScroller;
+//# sourceMappingURL=scrollable.web.d.ts.map

package/lib/typescript/commonjs/scroll/scrollable.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrollable.web.d.ts","sourceRoot":"","sources":["../../../../src/scroll/scrollable.web.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAEzE;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,MAAM,CAAC;IACxB,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC;;;;;;;;;;OAUG;IACH,SAAS,EAAE,MAAM,OAAO,CAAC;CAC1B;AAuCD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,uBAAuB,GAAG,gBAAgB,CAyBhF"}

package/lib/typescript/commonjs/scroll/store.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Pure, platform-agnostic core of the scroll-restoration primitive.
+ *
+ * This file deliberately contains NO React and NO DOM/native imports so the
+ * logic can be unit-tested in isolation and shared verbatim by the web and
+ * native barrels. The web barrel drives it with real scroll offsets; the
+ * native barrel never instantiates it (native-stack already restores scroll).
+ */
+/**
+ * Derive the storage key for a scrollable from its owning route key and an
+ * optional caller sub-key.
+ *
+ * - `routeKey` is React Navigation's stable per-route `route.key`.
+ * - `subKey` distinguishes multiple scrollables that share a single route.
+ *
+ * Returns `null` when there is no route key to anchor against (the scrollable
+ * is not inside a navigator), which the caller treats as "do not persist".
+ */
+export declare function deriveScrollKey(routeKey: string | undefined, subKey?: string): string | null;
+/**
+ * In-memory map of `scrollKey -> last-known scroll offset`.
+ *
+ * Mirrors the semantics of Bluesky's `Map<screenKey, scrollY>`: offsets live
+ * only for the lifetime of the document/session. We never persist them — a
+ * full reload should start at the top — and we never auto-evict, because a
+ * route can be revisited via browser Forward/Back long after it blurred.
+ */
+export declare class ScrollOffsetStore {
+    private readonly offsets;
+    /** Persist the offset for a key. A negative offset is clamped to 0. */
+    save(key: string, offset: number): void;
+    /**
+     * Read the saved offset for a key. Returns `0` when nothing was saved, so
+     * callers can restore unconditionally (an unseen list restores to the top).
+     */
+    read(key: string): number;
+    /** Whether an offset was ever saved for this key. */
+    has(key: string): boolean;
+    /** Drop a saved offset (e.g. when a route is permanently removed). */
+    forget(key: string): void;
+    /** Clear every saved offset. Primarily for tests and full resets. */
+    clear(): void;
+    /** Number of distinct keys currently tracked. */
+    get size(): number;
+}
+//# sourceMappingURL=store.d.ts.map

package/lib/typescript/commonjs/scroll/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../src/scroll/store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAcH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAIf;AAED;;;;;;;GAOG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IAErD,uEAAuE;IACvE,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAIvC;;;OAGG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAIzB,qDAAqD;IACrD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,sEAAsE;IACtE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIzB,qEAAqE;IACrE,KAAK,IAAI,IAAI;IAIb,iDAAiD;IACjD,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/lib/typescript/commonjs/scroll/types.d.ts

@@ -0,0 +1,46 @@
+import type { ReactNode, RefObject } from 'react';
+/**
+ * Anything `useScrollRestoration` knows how to read/write a vertical scroll
+ * offset from. The hook accepts a ref to one of these:
+ *
+ * - a React Native `ScrollView` / `FlatList` ref (which on web is backed by a
+ *   DOM node and exposes `getScrollableNode()`),
+ * - a raw DOM element ref (when a component renders its own scroll container),
+ * - the literal `'window'` sentinel, for the rare layout where the list IS the
+ *   window scroller (matches Bluesky's default).
+ *
+ * Native never reads any of these — the native hook is a no-op — so the type is
+ * intentionally permissive rather than coupled to a specific RN class.
+ */
+export interface ScrollableHandle {
+    /** Imperative scroll API exposed by RN scrollables. */
+    scrollTo?: (options: {
+        x?: number;
+        y?: number;
+        animated?: boolean;
+    }) => void;
+    /** Web/RNW path: returns the underlying DOM node. */
+    getScrollableNode?: () => unknown;
+}
+/**
+ * The accepted ref shapes. `'window'` is a sentinel for the document scroller.
+ */
+export type ScrollRestorationTarget = RefObject<ScrollableHandle | null> | RefObject<unknown> | 'window';
+export interface UseScrollRestorationOptions {
+    /**
+     * Sub-key to disambiguate multiple scrollables that live on the same route
+     * (e.g. the tabs of a profile screen). Combined with the active route key to
+     * form the storage key. Omit when a route has a single scrollable.
+     */
+    key?: string;
+    /**
+     * When `false`, the hook is inert (saves and restores are skipped). Useful to
+     * gate restoration behind a feature flag without changing call sites.
+     * Defaults to `true`.
+     */
+    enabled?: boolean;
+}
+export interface ScrollRestorationProviderProps {
+    children: ReactNode;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/commonjs/scroll/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/scroll/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAElD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,gBAAgB;IAC/B,uDAAuD;IACvD,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC7E,qDAAqD;IACrD,iBAAiB,CAAC,EAAE,MAAM,OAAO,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAC/B,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,GAClC,SAAS,CAAC,OAAO,CAAC,GAClB,QAAQ,CAAC;AAEb,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,SAAS,CAAC;CACrB"}

package/lib/typescript/module/scroll/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Native variant of the scroll-restoration primitive — a deliberate no-op.
+ *
+ * React Navigation's native-stack keeps every screen mounted while it is in the
+ * stack, so a list's scroll position survives a push/pop for free. There is
+ * nothing to save or restore. We still ship the full API surface (provider +
+ * hook) so consumers write one set of call sites that compile and run on every
+ * platform; on native the provider just renders its children and the hook does
+ * nothing.
+ *
+ * Web bundlers select `./index.web` via the `"browser"` export condition in
+ * `package.json`; native bundlers fall through to this file.
+ */
+import type { ReactElement } from 'react';
+import type { ScrollRestorationProviderProps, ScrollRestorationTarget, UseScrollRestorationOptions } from './types';
+export type { ScrollableHandle, ScrollRestorationProviderProps, ScrollRestorationTarget, UseScrollRestorationOptions, } from './types';
+/**
+ * No-op provider. Renders children unchanged — native scroll persistence is
+ * handled by the navigator, so no per-route state is kept.
+ */
+export declare function ScrollRestorationProvider({ children, }: ScrollRestorationProviderProps): ReactElement;
+/**
+ * No-op hook. Accepts the same arguments as the web implementation so call
+ * sites are identical across platforms.
+ */
+export declare function useScrollRestoration(_target: ScrollRestorationTarget, _options?: UseScrollRestorationOptions): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/scroll/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/scroll/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAC1C,OAAO,KAAK,EACV,8BAA8B,EAC9B,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,SAAS,CAAC;AAEjB,YAAY,EACV,gBAAgB,EAChB,8BAA8B,EAC9B,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,QAAQ,GACT,EAAE,8BAA8B,GAAG,YAAY,CAE/C;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,uBAAuB,EAChC,QAAQ,CAAC,EAAE,2BAA2B,GACrC,IAAI,CAEN"}