@oxyhq/bloom 0.6.21 → 0.6.23

package/lib/commonjs/scroll/index.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScrollRestorationProvider = ScrollRestorationProvider;
+exports.useScrollRestoration = useScrollRestoration;
+/**
+ * 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.
+ */
+
+/**
+ * No-op provider. Renders children unchanged — native scroll persistence is
+ * handled by the navigator, so no per-route state is kept.
+ */
+function ScrollRestorationProvider({
+  children
+}) {
+  return children;
+}
+
+/**
+ * No-op hook. Accepts the same arguments as the web implementation so call
+ * sites are identical across platforms.
+ */
+function useScrollRestoration(_target, _options) {
+  // Intentionally empty: native-stack already preserves scroll position.
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["ScrollRestorationProvider","children","useScrollRestoration","_target","_options"],"sourceRoot":"../../../src","sources":["scroll/index.ts"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAeA;AACA;AACA;AACA;AACO,SAASA,yBAAyBA,CAAC;EACxCC;AAC8B,CAAC,EAAgB;EAC/C,OAAOA,QAAQ;AACjB;;AAEA;AACA;AACA;AACA;AACO,SAASC,oBAAoBA,CAClCC,OAAgC,EAChCC,QAAsC,EAChC;EACN;AAAA","ignoreList":[]}

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

@@ -0,0 +1,226 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScrollRestorationProvider = ScrollRestorationProvider;
+exports.useScrollRestoration = useScrollRestoration;
+var _react = require("react");
+var _native = require("@react-navigation/native");
+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 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`.
+ */
+
+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.
+ */
+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).
+ */
+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;
+}
+
+/**
+ * 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.
+ */
+function useScrollRestoration(target, options) {
+  const store = useScrollOffsetStore();
+  const route = (0, _native.useRoute)();
+  const subKey = options?.key;
+  const enabled = options?.enabled ?? true;
+  const scrollKey = (0, _store.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 = (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, _native.useFocusEffect)(
+  // The effect identity is intentionally stable across renders: it reads all
+  // varying inputs from refs. React Navigation re-runs it on each focus.
+  (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);
+
+    // 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/commonjs/scroll/index.web.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","require","_native","_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":[]}

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

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createScroller = createScroller;
+/**
+ * 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`.
+ */
+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/commonjs/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;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":[]}

package/lib/commonjs/scroll/store.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScrollOffsetStore = void 0;
+exports.deriveScrollKey = deriveScrollKey;
+/**
+ * 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".
+ */
+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.
+ */
+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;
+  }
+}
+exports.ScrollOffsetStore = ScrollOffsetStore;
+//# sourceMappingURL=store.js.map

package/lib/commonjs/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","exports"],"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;AACO,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;AACO,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;AAACC,OAAA,CAAAd,iBAAA,GAAAA,iBAAA","ignoreList":[]}

package/lib/commonjs/scroll/types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=types.js.map

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

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

package/lib/module/scroll/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+/**
+ * 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.
+ */
+
+/**
+ * No-op provider. Renders children unchanged — native scroll persistence is
+ * handled by the navigator, so no per-route state is kept.
+ */
+export function ScrollRestorationProvider({
+  children
+}) {
+  return children;
+}
+
+/**
+ * No-op hook. Accepts the same arguments as the web implementation so call
+ * sites are identical across platforms.
+ */
+export function useScrollRestoration(_target, _options) {
+  // Intentionally empty: native-stack already preserves scroll position.
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["ScrollRestorationProvider","children","useScrollRestoration","_target","_options"],"sourceRoot":"../../../src","sources":["scroll/index.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAeA;AACA;AACA;AACA;AACA,OAAO,SAASA,yBAAyBA,CAAC;EACxCC;AAC8B,CAAC,EAAgB;EAC/C,OAAOA,QAAQ;AACjB;;AAEA;AACA;AACA;AACA;AACA,OAAO,SAASC,oBAAoBA,CAClCC,OAAgC,EAChCC,QAAsC,EAChC;EACN;AAAA","ignoreList":[]}