react-native-header-motion 0.4.0 → 1.0.0-beta.0

package/lib/typescript/src/components/createHeaderMotionScrollable.d.ts

@@ -0,0 +1,86 @@
+import { type ReactElement, type Ref } from 'react';
+import { type AnimatedProps, type AnimatedRef } from 'react-native-reanimated';
+import type { InstanceOrElement } from 'react-native-reanimated/lib/typescript/commonTypes';
+import type { HeaderMotionOffsetProps } from '../types';
+export type HeaderMotionScrollableOwnProps<TRef extends InstanceOrElement = any> = HeaderMotionOffsetProps & {
+    /**
+     * Unique identifier for this scrollable when one header is shared across
+     * multiple scrollables.
+     */
+    scrollId?: string;
+    /**
+     * Animated ref to reuse instead of letting HeaderMotion create one.
+     */
+    animatedRef?: AnimatedRef<TRef> | AnimatedRef;
+};
+export interface CreateHeaderMotionScrollableOptions<TIsComponentAnimated extends boolean = boolean> {
+    displayName?: string;
+    /**
+     * If true, this function will NOT call Animated.createAnimatedComponent internally.
+     * Useful when you are creating a HeaderMotionScrollable from lists that already export their
+     * own (Re)animated components (e.g. LegendList).
+     *
+     * @default false
+     */
+    isComponentAnimated?: TIsComponentAnimated;
+    /**
+     * Controls how HeaderMotion injects content-container spacing.
+     *
+     * - `children`: wraps `children` in an inner `Animated.View`
+     * - `renderScrollComponent`: injects a custom scroll component that wraps the content
+     *
+     * Use `children` for ScrollView-like components. Use
+     * `renderScrollComponent` for FlatList-like components that own their
+     * internal scroll container.
+     *
+     * @default 'renderScrollComponent'
+     */
+    contentContainerMode?: ContentContainerMode;
+}
+export declare function createHeaderMotionScrollable<TScrollableComponent extends ScrollableComponent, TIsComponentAnimated extends boolean = false>(ScrollableComponent: TScrollableComponent, options?: CreateHeaderMotionScrollableOptions<TIsComponentAnimated>): HeaderMotionScrollableComponent<TScrollableComponent, TIsComponentAnimated>;
+type ContentContainerMode = 'children' | 'renderScrollComponent';
+type ScrollableComponent = ((props: any) => ReactElement | null) | (new (...args: any[]) => any);
+declare const noListItemSymbol: unique symbol;
+type NoListItem = {
+    readonly [noListItemSymbol]: true;
+};
+type ScrollableComponentProps<TScrollableComponent> = TScrollableComponent extends new (props: infer TProps, ...args: any[]) => any ? TProps : TScrollableComponent extends (props: infer TProps, ...args: any[]) => any ? TProps : never;
+type IsUnknown<TValue> = unknown extends TValue ? [keyof TValue] extends [never] ? true : false : false;
+type ReplaceUnknownDeep<TValue, TReplacement> = IsUnknown<TValue> extends true ? TReplacement : TValue extends (...args: infer TArgs) => infer TResult ? (...args: {
+    [TIndex in keyof TArgs]: ReplaceUnknownDeep<TArgs[TIndex], TReplacement>;
+}) => TResult : TValue extends readonly (infer TItem)[] ? readonly ReplaceUnknownDeep<TItem, TReplacement>[] : TValue extends object ? {
+    [TKey in keyof TValue]: ReplaceUnknownDeep<TValue[TKey], TReplacement>;
+} : TValue;
+type MaybeAnimatedProps<TProps extends object, TIsComponentAnimated> = TIsComponentAnimated extends true ? TProps : AnimatedProps<TProps>;
+type ResolveListItemProps<TProps extends object, TListItem> = [
+    TListItem
+] extends [NoListItem] ? TProps : ReplaceUnknownDeep<TProps, TListItem>;
+type ExtractDataProp<TProps> = TProps extends {
+    data?: infer TData;
+} ? TData : TProps extends {
+    data: infer TData;
+} ? TData : never;
+type ExtractListItemFromData<TData> = TData extends ReadonlyArray<infer TItem> | null | undefined ? TItem : TData extends ArrayLike<infer TItem> | null | undefined ? TItem : never;
+type HasGenericDataProp<TProps> = IsUnknown<ExtractListItemFromData<ExtractDataProp<TProps>>>;
+type ExtractRefTargetFromRef<TRef> = TRef extends Ref<infer TInstance> ? TInstance : TRef extends AnimatedRef<infer TInstance> ? TInstance : never;
+type ExtractRefTargetFromProps<TProps> = TProps extends {
+    ref?: infer TRef;
+} ? ExtractRefTargetFromRef<TRef> : TProps extends {
+    ref: infer TRef;
+} ? ExtractRefTargetFromRef<TRef> : never;
+type ResolveScrollableRefTarget<TScrollableComponent, TProps> = [
+    ExtractRefTargetFromProps<TProps>
+] extends [never] ? TScrollableComponent extends new (...args: any[]) => infer TInstance ? TInstance extends InstanceOrElement ? TInstance : any : any : ExtractRefTargetFromProps<TProps> extends InstanceOrElement ? ExtractRefTargetFromProps<TProps> : any;
+type HeaderMotionScrollableBaseProps<TScrollableComponent extends ScrollableComponent, TIsComponentAnimated extends boolean, TListItem = NoListItem> = ResolveListItemProps<MaybeAnimatedProps<ScrollableComponentProps<TScrollableComponent>, TIsComponentAnimated>, TListItem>;
+type HeaderMotionScrollablePublicProps<TScrollableComponent extends ScrollableComponent, TIsComponentAnimated extends boolean, TListItem = NoListItem> = HeaderMotionScrollableBaseProps<TScrollableComponent, TIsComponentAnimated, TListItem> & HeaderMotionScrollableOwnProps<ResolveScrollableRefTarget<TScrollableComponent, HeaderMotionScrollableBaseProps<TScrollableComponent, TIsComponentAnimated, TListItem>>>;
+type HeaderMotionGenericScrollableComponent<TScrollableComponent extends ScrollableComponent, TIsComponentAnimated extends boolean> = {
+    <TListItem = any>(props: HeaderMotionScrollablePublicProps<TScrollableComponent, TIsComponentAnimated, TListItem>): ReactElement | null;
+    displayName?: string;
+};
+type HeaderMotionStaticScrollableComponent<TScrollableComponent extends ScrollableComponent, TIsComponentAnimated extends boolean> = {
+    (props: HeaderMotionScrollablePublicProps<TScrollableComponent, TIsComponentAnimated>): ReactElement | null;
+    displayName?: string;
+};
+type HeaderMotionScrollableComponent<TScrollableComponent extends ScrollableComponent, TIsComponentAnimated extends boolean> = HasGenericDataProp<ScrollableComponentProps<TScrollableComponent>> extends true ? HeaderMotionGenericScrollableComponent<TScrollableComponent, TIsComponentAnimated> : HeaderMotionStaticScrollableComponent<TScrollableComponent, TIsComponentAnimated>;
+export {};
+//# sourceMappingURL=createHeaderMotionScrollable.d.ts.map

package/lib/typescript/src/components/createHeaderMotionScrollable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHeaderMotionScrollable.d.ts","sourceRoot":"","sources":["../../../../src/components/createHeaderMotionScrollable.tsx"],"names":[],"mappings":"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"}

package/lib/typescript/src/components/index.d.ts

@@ -1,7 +1,9 @@
+export * from './Bridge';
 export * from './FlatList';
 export * from './Header';
-export * from './HeaderBase';
+export * from './NavigationBridge';
 export * from './HeaderMotion';
 export * from './ScrollManager';
 export * from './ScrollView';
+export * from './createHeaderMotionScrollable';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/components/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,gCAAgC,CAAC"}

package/lib/typescript/src/context.d.ts

@@ -1,14 +1,4 @@
-import { type SharedValue } from 'react-native-reanimated';
-import type { MeasureAnimatedHeaderAndSet, Progress, ScrollValues } from './types';
-interface HeaderMotionContextType {
-    progress: Progress;
-    measureTotalHeight: MeasureAnimatedHeaderAndSet;
-    measureDynamic: MeasureAnimatedHeaderAndSet;
-    scrollValues: SharedValue<ScrollValues>;
-    activeScrollId: SharedValue<string> | undefined;
-    progressThreshold: number;
-    originalHeaderHeight: number;
-}
-export declare const HeaderMotionContext: import("react").Context<HeaderMotionContextType | null>;
-export {};
+import type { HeaderMotionBridgeValue } from './types';
+export declare const HeaderMotionContext: import("react").Context<HeaderMotionBridgeValue | null>;
+export declare function useHeaderMotionContextOrThrow(errorMessage: string): HeaderMotionBridgeValue;
 //# sourceMappingURL=context.d.ts.map

package/lib/typescript/src/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/context.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EACV,2BAA2B,EAC3B,QAAQ,EACR,YAAY,EACb,MAAM,SAAS,CAAC;AAEjB,UAAU,uBAAuB;IAC/B,QAAQ,EAAE,QAAQ,CAAC;IACnB,kBAAkB,EAAE,2BAA2B,CAAC;IAChD,cAAc,EAAE,2BAA2B,CAAC;IAC5C,YAAY,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC;IACxC,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;IAChD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,eAAO,MAAM,mBAAmB,yDACqB,CAAC"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAEvD,eAAO,MAAM,mBAAmB,yDACqB,CAAC;AAEtD,wBAAgB,6BAA6B,CAAC,YAAY,EAAE,MAAM,2BAOjE"}

package/lib/typescript/src/hooks/index.d.ts

@@ -1,4 +1,5 @@
 export * from './useActiveScrollId';
+export * from './useHeaderMotionBridge';
 export * from './useMotionProgress';
 export * from './useScrollManager';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/hooks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC"}

package/lib/typescript/src/hooks/useActiveScrollId.d.ts

@@ -1,16 +1,17 @@
 import type { ActiveScrollIdValues, SetActiveScrollId } from '../types';
 /**
- * Hook to manage active scroll ID for multi-scroll scenarios (e.g. tabs with different scroll views).
- * Returns both a state value and a shared value, along with a setter function.
+ * Keeps a React state value and a shared value in sync for the currently active
+ * scrollable.
  *
- * Use this when you have multiple scroll views (like in a tabbed interface) and need to
- * track which one is currently active. Pass the shared value to `HeaderMotion`'s `activeScrollId` prop.
+ * Use this when one header is shared across multiple scroll views, for example
+ * pager pages or tabs. Pass `values.sv` to `HeaderMotion` and use the setter
+ * whenever the active page changes.
  *
  * @template T - The type of the scroll ID string
  * @param initialActiveScrollId - The initial active scroll ID
  * @returns A tuple containing:
- * - `[0]`: Object with `state` (React state) and `sv` (shared value) for the active scroll ID
- * - `[1]`: Function to set the active scroll ID
+ * - an object with both the React `state` and shared-value `sv`
+ * - a setter that updates both in lockstep
  *
  * @example
  * ```tsx

package/lib/typescript/src/hooks/useActiveScrollId.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useActiveScrollId.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useActiveScrollId.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAChD,qBAAqB,EAAE,CAAC,GACvB,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAuBjD"}
+{"version":3,"file":"useActiveScrollId.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useActiveScrollId.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAChD,qBAAqB,EAAE,CAAC,GACvB,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAuBjD"}

package/lib/typescript/src/hooks/useHeaderMotionBridge.d.ts

@@ -0,0 +1,10 @@
+import type { HeaderMotionBridgeValue } from '../types';
+/**
+ * Returns the full internal HeaderMotion context value.
+ *
+ * Most app code should use `useMotionProgress()` instead. Reach for this hook
+ * only when you need to carry HeaderMotion context across a tree boundary and
+ * re-provide it somewhere else.
+ */
+export declare function useHeaderMotionBridge(): HeaderMotionBridgeValue;
+//# sourceMappingURL=useHeaderMotionBridge.d.ts.map

package/lib/typescript/src/hooks/useHeaderMotionBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHeaderMotionBridge.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useHeaderMotionBridge.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,IAAI,uBAAuB,CAI/D"}

package/lib/typescript/src/hooks/useMotionProgress.d.ts

@@ -1,36 +1,19 @@
 import type { MotionProgress } from '../types';
 /**
- * Hook to access motion progress values and measuring functions for header animations.
- * Returns the progress value (0-1), threshold, and measurement functions.
+ * Returns the two shared values most header animations actually need:
+ * `progress` and `progressThreshold`.
  *
- * Must be used within a {@link HeaderMotion} component.
+ * Use this inside your animated header components to derive transforms,
+ * opacity, scale, parallax, or any other visual response to scroll.
  *
- * @returns Motion progress values and measuring functions:
- * - `progress`: Shared value from 0 to 1
- * - `progressThreshold`: The threshold at which animation completes
- * - `measureTotalHeight`: Function to measure total header height. Should be passed to the `onLayout` prop of the base of a header, to let scrollables account for the total header height
- * - `measureDynamic`: Function to measure a dimension of choice of the animated element of the header - should be passed to the `onLayout` prop of such. If used, can be used for dynamic calculation of the {@link progressThreshold}.
- *
- * @throws Error if used outside of a {@link HeaderMotion} component
+ * `progress` usually lives in the `0..1` range, where `0` is the expanded
+ * state and `1` is the fully collapsed state. `progressThreshold` is the pixel
+ * distance that corresponds to that transition.
  *
  * @example
  * ```tsx
  * function MyHeader() {
- *   const { progress, progressThreshold, measureTotalHeight, measureDynamic } = useMotionProgress();
- *   const dynamicStyle = useAnimatedStyle(() => {
- *     const translateY = interpolate(
- *       progress.value,
- *       [0, 1],
- *       [0, -progressThreshold],
- *       Extrapolation.CLAMP,
- *     )
- *     return { transform: [{ translateY }] }
- *   })
- *   return (
- *     <AnimatedHeaderBase onLayout={measureTotalHeight}>
- *       <Animated.View onLayout={measureDynamic} style={dynamicStyle} />
- *     </AnimatedHeaderBase>
- *   )
+ *   const { progress, progressThreshold } = useMotionProgress();
  * }
  * ```
  */

package/lib/typescript/src/hooks/useMotionProgress.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMotionProgress.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useMotionProgress.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAgBlD"}
+{"version":3,"file":"useMotionProgress.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useMotionProgress.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CASlD"}

package/lib/typescript/src/hooks/useMotionProgress.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useMotionProgress.test.d.ts.map

package/lib/typescript/src/hooks/useMotionProgress.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMotionProgress.test.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useMotionProgress.test.ts"],"names":[],"mappings":""}

package/lib/typescript/src/hooks/useScrollManager.d.ts

@@ -1,28 +1,67 @@
 import { type AnimatedRef } from 'react-native-reanimated';
 import type { ScrollManagerConfig } from '../types';
-import { type ResolveRefreshControlOptions } from './refreshControl';
+import { type ResolveRefreshControlOptions } from '../utils';
+import type { InstanceOrElement } from 'react-native-reanimated/lib/typescript/commonTypes';
 import { type ConsumerScrollEventHandlers } from './useConsumerScrollHandlers';
+export interface UseScrollManagerOptions<TRef extends InstanceOrElement = any> extends Omit<ResolveRefreshControlOptions, 'progressViewOffset'>, ConsumerScrollEventHandlers {
+    /**
+     * Animated ref for the managed scrollable.
+     *
+     * Provide this when the caller also needs imperative access to the same
+     * scrollable instance. Otherwise the hook creates one internally.
+     */
+    animatedRef?: AnimatedRef<TRef>;
+    /**
+     * Overrides the refresh indicator offset.
+     *
+     * By default, HeaderMotion derives this from the measured header height so
+     * pull-to-refresh starts below the header. Override it only when you need a
+     * custom refresh placement.
+     */
+    progressViewOffset?: ResolveRefreshControlOptions['progressViewOffset'];
+    /**
+     * Ensures short content can still scroll far enough to fully collapse the
+     * header.
+     *
+     * **Experimental: this relies on extra layout measurement and may still be
+     * refined.**
+     *
+     * Enable this when your content is sometimes shorter than the viewport and
+     * you still want the header to reach the collapsed state.
+     */
+    ensureScrollableContentMinHeight?: boolean;
+}
 /**
- * Hook that manages scroll tracking and synchronization for header animations.
- * Returns props to apply to scrollable components and additional values that help with adjusting styling of the scrollables to header's dimensions.
+ * Wires a custom scrollable into HeaderMotion.
  *
- * This hook handles:
- * - Scroll position tracking
- * - Synchronization between multiple scroll views (when using multiple scroll IDs)
- * - Content container minimum height calculations for cases where one of the tracked scrollables does not take enough space to reach the progress threshold/
+ * Most code should not use this hook directly.
  *
- * Must be used within a HeaderMotion component.
+ * **Prefer `createHeaderMotionScrollable()` whenever possible.** It gives
+ * you the same integration in a reusable component wrapper with less manual
+ * wiring. Reach for `useScrollManager()` only in more complex cases where the
+ * factory API is not enough, for example when a third-party scrollable needs
+ * highly custom composition.
  *
- * @param scrollId - Optional unique identifier for the related scrollable.
- *                   Use when you have multiple scrollables (e.g., in tabs).
- * @param options - Optional configuration object.
- * @param options.animatedRef - Optional animated ref to use instead of creating one internally.
- *                              Useful when you need access to the scroll view ref from outside.
- * @returns Configuration object containing:
- * - `scrollableProps`: Props to apply to scrollable component (onScroll, scrollEventThrottle, ref)
- * - `headerMotionContext`: Header context values (originalHeaderHeight, minHeightContentContainerStyle)
+ * It returns two things:
+ * - `scrollableProps`: the event handlers / ref / refresh-control props that
+ *   should go on the scrollable itself
+ * - `headerMotionContext`: layout values you can use to offset the content
+ *   below the measured header
  *
- * @throws Error if used outside of a HeaderMotion component
+ * In multi-scroll setups, pass a unique `scrollId` for each scrollable.
+ * In single-scroll setups, you usually do not need one.
+ *
+ * If you need the same fallback behavior but prefer render-prop composition
+ * over a hook, use `HeaderMotion.ScrollManager`.
+ *
+ * @param scrollId Optional unique identifier for the managed scrollable.
+ * @param options Optional configuration for refs, refresh handling, user
+ * scroll callbacks, and short-content fallback behavior.
+ * @returns Object containing:
+ * - `scrollableProps`: props to spread onto the scrollable (`ref`, managed
+ *   `onScroll`, optional `onLayout`, and resolved `refreshControl`)
+ * - `headerMotionContext`: layout values for offsetting the content container
+ *   (`originalHeaderHeight` and optional `contentContainerMinHeight`)
  *
  * @example
  * ```tsx
@@ -31,7 +70,12 @@ import { type ConsumerScrollEventHandlers } from './useConsumerScrollHandlers';
  *
  *   return (
  *     <CustomScrollView {...scrollableProps}>
- *       <View style={{ paddingTop: headerMotionContext.originalHeaderHeight }}>
+ *       <View
+ *         style={{
+ *           paddingTop: headerMotionContext.originalHeaderHeight,
+ *           minHeight: headerMotionContext.contentContainerMinHeight,
+ *         }}
+ *       >
  *         Content
  *       </View>
  *     </CustomScrollView>
@@ -39,17 +83,5 @@ import { type ConsumerScrollEventHandlers } from './useConsumerScrollHandlers';
  * }
  * ```
  */
-export interface UseScrollManagerOptions extends Omit<ResolveRefreshControlOptions, 'progressViewOffset'>, ConsumerScrollEventHandlers {
-    /**
-     * Optional animated ref to use instead of creating one internally.
-     * Useful when you need access to the scroll view ref from outside.
-     */
-    animatedRef?: AnimatedRef<any>;
-    /**
-     * Optional refresh progress offset override.
-     * When provided, it takes precedence over the automatic offset based on header height.
-     */
-    progressViewOffset?: ResolveRefreshControlOptions['progressViewOffset'];
-}
-export declare function useScrollManager(scrollId?: string, options?: UseScrollManagerOptions): ScrollManagerConfig;
+export declare function useScrollManager<TRef extends InstanceOrElement = any>(scrollId?: string, options?: UseScrollManagerOptions<TRef>): ScrollManagerConfig<TRef>;
 //# sourceMappingURL=useScrollManager.d.ts.map

package/lib/typescript/src/hooks/useScrollManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useScrollManager.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useScrollManager.ts"],"names":[],"mappings":"AACA,OAAO,EAOL,KAAK,WAAW,EAEjB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,KAAK,EAAE,mBAAmB,EAAgB,MAAM,UAAU,CAAC;AAElE,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAGL,KAAK,2BAA2B,EACjC,MAAM,6BAA6B,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,WAAW,uBACf,SAAQ,IAAI,CAAC,4BAA4B,EAAE,oBAAoB,CAAC,EAC9D,2BAA2B;IAC7B;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;IAC/B;;;OAGG;IACH,kBAAkB,CAAC,EAAE,4BAA4B,CAAC,oBAAoB,CAAC,CAAC;CACzE;AAED,wBAAgB,gBAAgB,CAC9B,QAAQ,CAAC,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,uBAAuB,GAChC,mBAAmB,CAyKrB"}
+{"version":3,"file":"useScrollManager.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useScrollManager.ts"],"names":[],"mappings":"AAOA,OAAO,EAOL,KAAK,WAAW,EAEjB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,KAAK,EAAE,mBAAmB,EAAwB,MAAM,UAAU,CAAC;AAE1E,OAAO,EAKL,KAAK,4BAA4B,EAClC,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oDAAoD,CAAC;AAC5F,OAAO,EAGL,KAAK,2BAA2B,EACjC,MAAM,6BAA6B,CAAC;AAgQrC,MAAM,WAAW,uBAAuB,CAAC,IAAI,SAAS,iBAAiB,GAAG,GAAG,CAC3E,SAAQ,IAAI,CAAC,4BAA4B,EAAE,oBAAoB,CAAC,EAC9D,2BAA2B;IAC7B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;IAChC;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,4BAA4B,CAAC,oBAAoB,CAAC,CAAC;IACxE;;;;;;;;;OASG;IACH,gCAAgC,CAAC,EAAE,OAAO,CAAC;CAC5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,SAAS,iBAAiB,GAAG,GAAG,EACnE,QAAQ,CAAC,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,uBAAuB,CAAC,IAAI,CAAC,GACtC,mBAAmB,CAAC,IAAI,CAAC,CAuD3B"}

package/lib/typescript/src/index.d.ts

@@ -1,51 +1,81 @@
-import { AnimatedHeaderBase, HeaderBase, HeaderMotionFlatList, HeaderMotionHeader, HeaderMotionScrollManager, HeaderMotionScrollView, type HeaderMotionFlatListProps, type HeaderMotionHeaderProps, type HeaderMotionProps, type HeaderMotionScrollManagerProps, type HeaderMotionScrollViewProps } from './components';
-import type { ReactElement } from 'react';
-/**
- * Compound component type for HeaderMotion.
- * Provides the main context provider and sub-components for building collapsible headers.
- */
-type HeaderMotionComponent = {
-    /** Main context provider component */
-    <T extends string>(props: HeaderMotionProps<T>): ReactElement;
-    /** Component for providing motion progress properties to animated headers.
-     * Use to pass props to the header components in React Navigation / Expo Router, which cannot access HeaderMotion's context and `useMotionProgress` otherwise.
+import { createHeaderMotionScrollable, Bridge, HeaderMotionContextProvider, FlatList, Header, NavigationBridge, ScrollManager, ScrollView, type CreateHeaderMotionScrollableOptions, type HeaderProps, type HeaderMotionBridgeProps, type HeaderMotionFlatListProps, type HeaderMotionNavigationBridgeProps, type HeaderMotionProps, type HeaderMotionScrollManagerProps, type HeaderMotionScrollableOwnProps, type HeaderMotionScrollViewProps } from './components';
+import type { HeaderDynamicProps } from './types';
+type HeaderMotionCompound = typeof HeaderMotionContextProvider & {
+    /**
+     * Header container that measures the total header height and can optionally
+     * make the header surface pannable.
+     *
+     * Use `HeaderMotion.Header.Dynamic` inside it to mark the part of the header
+     * that should define the collapse distance.
+     */
+    Header: typeof Header;
+    /**
+     * Captures the current HeaderMotion context and exposes it through a render
+     * function so it can be forwarded across a React tree boundary.
+     *
+     * This is primarily useful for navigation-rendered headers.
+     */
+    Bridge: typeof Bridge;
+    /**
+     * Re-provides a previously captured HeaderMotion context value in another
+     * subtree.
+     *
+     * This is primarily useful for navigation libraries that render headers
+     * outside the screen subtree where `HeaderMotion` lives.
      */
-    Header: typeof HeaderMotionHeader;
-    /** Component for custom scroll implementations */
-    ScrollManager: typeof HeaderMotionScrollManager;
-    /** Animated ScrollView component with header motion integration */
-    ScrollView: typeof HeaderMotionScrollView;
-    /** Animated FlatList component with header motion integration */
-    FlatList: typeof HeaderMotionFlatList;
+    NavigationBridge: typeof NavigationBridge;
+    /**
+     * Render-prop wrapper for managing a custom scrollable.
+     *
+     * Prefer `createHeaderMotionScrollable()` for most custom integrations. Use
+     * `ScrollManager` only when the factory approach is not flexible enough.
+     */
+    ScrollManager: typeof ScrollManager;
+    /**
+     * Pre-wired `Animated.ScrollView` that participates in HeaderMotion's scroll
+     * tracking and header offsetting.
+     */
+    ScrollView: typeof ScrollView;
+    /**
+     * Pre-wired `Animated.FlatList` that participates in HeaderMotion's scroll
+     * tracking and header offsetting.
+     */
+    FlatList: typeof FlatList;
 };
 /**
  * Main HeaderMotion component.
- * A compound component that provides context for collapsible header animations.
+ * Root provider and compound entrypoint for the library.
+ *
+ * It tracks header measurements, derives the shared `progress` value, and
+ * exposes the pre-wired subcomponents used to connect headers and scrollables.
  *
  * @example
  * ```tsx
  * <HeaderMotion>
- *   <HeaderMotion.Header>
- *     {(headerProps) => (
+ *   <HeaderMotion.Bridge>
+ *     {(value) => (
  *       <Stack.Screen
  *         options={{
  *           header: () => (
- *             <MyAnimatedHeader {...headerProps} />
+ *             <HeaderMotion.NavigationBridge value={value}>
+ *               <MyAnimatedHeader />
+ *             </HeaderMotion.NavigationBridge>
  *           ),
  *         }}
  *       />
  *     )}
- *   </HeaderMotion.Header>
+ *   </HeaderMotion.Bridge>
  *   <HeaderMotion.ScrollView>
  *     <MyScrollableContent />
  *   </HeaderMotion.ScrollView>
  * </HeaderMotion>
  * ```
  */
-declare const HeaderMotion: HeaderMotionComponent;
+declare const HeaderMotion: HeaderMotionCompound;
 export default HeaderMotion;
 export * from './hooks';
 export type * from './types';
-export { AnimatedHeaderBase, HeaderBase };
-export type { HeaderMotionFlatListProps, HeaderMotionHeaderProps, HeaderMotionProps, HeaderMotionScrollManagerProps, HeaderMotionScrollViewProps, };
+export { createHeaderMotionScrollable };
+export { Bridge, Header, NavigationBridge };
+export type { CreateHeaderMotionScrollableOptions, HeaderDynamicProps, HeaderMotionFlatListProps, HeaderMotionBridgeProps, HeaderMotionNavigationBridgeProps, HeaderMotionProps, HeaderMotionScrollManagerProps, HeaderMotionScrollableOwnProps, HeaderMotionScrollViewProps, HeaderProps, };
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,UAAU,EAEV,oBAAoB,EACpB,kBAAkB,EAClB,yBAAyB,EACzB,sBAAsB,EACtB,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,KAAK,8BAA8B,EACnC,KAAK,2BAA2B,EACjC,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAE1C;;;GAGG;AACH,KAAK,qBAAqB,GAAG;IAC3B,sCAAsC;IACtC,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC;IAC9D;;OAEG;IACH,MAAM,EAAE,OAAO,kBAAkB,CAAC;IAClC,kDAAkD;IAClD,aAAa,EAAE,OAAO,yBAAyB,CAAC;IAChD,mEAAmE;IACnE,UAAU,EAAE,OAAO,sBAAsB,CAAC;IAC1C,iEAAiE;IACjE,QAAQ,EAAE,OAAO,oBAAoB,CAAC;CACvC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,QAAA,MAAM,YAAY,EAAkC,qBAAqB,CAAC;AAM1E,eAAe,YAAY,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,mBAAmB,SAAS,CAAC;AAC7B,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,CAAC;AAC1C,YAAY,EACV,yBAAyB,EACzB,uBAAuB,EACvB,iBAAiB,EACjB,8BAA8B,EAC9B,2BAA2B,GAC5B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,MAAM,EACN,2BAA2B,EAC3B,QAAQ,EACR,MAAM,EACN,gBAAgB,EAChB,aAAa,EACb,UAAU,EACV,KAAK,mCAAmC,EACxC,KAAK,WAAW,EAChB,KAAK,uBAAuB,EAC5B,KAAK,yBAAyB,EAC9B,KAAK,iCAAiC,EACtC,KAAK,iBAAiB,EACtB,KAAK,8BAA8B,EACnC,KAAK,8BAA8B,EACnC,KAAK,2BAA2B,EACjC,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,KAAK,oBAAoB,GAAG,OAAO,2BAA2B,GAAG;IAC/D;;;;;;OAMG;IACH,MAAM,EAAE,OAAO,MAAM,CAAC;IACtB;;;;;OAKG;IACH,MAAM,EAAE,OAAO,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,gBAAgB,EAAE,OAAO,gBAAgB,CAAC;IAC1C;;;;;OAKG;IACH,aAAa,EAAE,OAAO,aAAa,CAAC;IACpC;;;OAGG;IACH,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B;;;OAGG;IACH,QAAQ,EAAE,OAAO,QAAQ,CAAC;CAC3B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,QAAA,MAAM,YAAY,EAAE,oBAUnB,CAAC;AAEF,eAAe,YAAY,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,mBAAmB,SAAS,CAAC;AAC7B,OAAO,EAAE,4BAA4B,EAAE,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC;AAC5C,YAAY,EACV,mCAAmC,EACnC,kBAAkB,EAClB,yBAAyB,EACzB,uBAAuB,EACvB,iCAAiC,EACjC,iBAAiB,EACjB,8BAA8B,EAC9B,8BAA8B,EAC9B,2BAA2B,EAC3B,WAAW,GACZ,CAAC"}

package/lib/typescript/src/types.d.ts

@@ -1,8 +1,40 @@
 import type { ReactElement } from 'react';
-import type { LayoutChangeEvent, RefreshControlProps, ScrollViewProps } from 'react-native';
-import type { AnimatedRef, SharedValue } from 'react-native-reanimated';
+import type { LayoutChangeEvent, ScrollViewProps, ViewProps } from 'react-native';
+import type { AnimatedProps, AnimatedRef, SharedValue } from 'react-native-reanimated';
 import { DEFAULT_SCROLL_ID } from './utils/defaults';
+import type { InstanceOrElement } from 'react-native-reanimated/lib/typescript/commonTypes';
+import type { GestureStateChangeEvent, PanGestureHandlerEventPayload } from 'react-native-gesture-handler';
+import type { WithDecayConfig } from 'react-native-reanimated';
 export type Progress = SharedValue<number>;
+export type HeaderMotionOffsetStrategy = 'padding' | 'margin' | 'top' | 'translate' | 'none';
+export interface HeaderMotionOffsetProps {
+    /**
+     * How the scrollable content should be pushed below the measured header.
+     *
+     * `padding` is the safest default for most screens. `margin`, `top`, and
+     * `translate` can be useful when the scrollable or its children need a
+     * different layout behavior.
+     *
+     * `top` and `translate` add bottom compensation so the end of the content
+     * remains reachable.
+     *
+     * @default 'padding'
+     */
+    headerOffsetStrategy?: HeaderMotionOffsetStrategy;
+    /**
+     * Adds a minimum content height so scrollables with short content can still collapse the
+     * header completely.
+     *
+     * **Experimental: this relies on extra layout measurement and may still be
+     * refined.**
+     *
+     * Enable this when some screens do not have enough content to naturally
+     * scroll through the full collapse distance.
+     *
+     * @default false
+     */
+    ensureScrollableContentMinHeight?: boolean;
+}
 export type ProgressThreshold = number | ((measuredHeaderValue: number) => number);
 export type MeasureAnimatedHeader = (e: LayoutChangeEvent) => number;
 export type MeasureAnimatedHeaderAndSet = (e: LayoutChangeEvent) => void;
@@ -18,31 +50,47 @@ export interface ScrollValue {
 export type ScrollValues = Record<string, ScrollValue> & {
     [key in typeof DEFAULT_SCROLL_ID]?: ScrollValue;
 };
-export type WithCollapsibleHeaderProps<T extends Record<string, unknown> = Record<string, unknown>> = T & MotionProgress;
-export type WithCollapsiblePagedHeaderProps<Tab extends string = string, T extends Record<string, unknown> = Record<string, unknown>> = WithCollapsibleHeaderProps<T> & {
-    onTabChange: (newTab: Tab) => void;
-    activeTab: Tab;
-};
 export interface MotionProgress {
     progress: Progress;
-    progressThreshold: number;
+    progressThreshold: SharedValue<number>;
+}
+export type HeaderPanDecayEvent = GestureStateChangeEvent<PanGestureHandlerEventPayload>;
+export type HeaderPanDecayConfig = WithDecayConfig | ((event: HeaderPanDecayEvent) => WithDecayConfig);
+export type HeaderAsChildProps = {
+    asChild: true;
+    children: ReactElement;
+};
+export type HeaderDefaultProps = AnimatedProps<ViewProps> & {
+    asChild?: false;
+};
+export type HeaderDynamicProps = HeaderDefaultProps | HeaderAsChildProps;
+export interface HeaderMotionBridgeValue extends MotionProgress {
     measureTotalHeight: MeasureAnimatedHeaderAndSet;
     measureDynamic: MeasureAnimatedHeaderAndSet;
+    headerPanMomentumOffset: SharedValue<number | null>;
+    scrollValues: SharedValue<ScrollValues>;
+    activeScrollId: SharedValue<string> | undefined;
+    scrollToRef: React.RefObject<ScrollTo | null>;
+    originalHeaderHeight: number;
 }
 export interface ScrollManagerHeaderMotionContext {
     originalHeaderHeight: number;
-    minHeightContentContainerStyle: {} | {
-        minHeight: number;
-    };
+    contentContainerMinHeight?: number;
 }
-export interface ScrollManagerConfig {
-    scrollableProps: Required<Pick<ScrollViewProps, 'onScroll' | 'scrollEventThrottle'>> & {
-        refreshControl?: ReactElement<RefreshControlProps>;
-        ref: AnimatedRef<any>;
+export interface ScrollManagerConfig<TRef extends InstanceOrElement = any> {
+    scrollableProps: Pick<ScrollViewProps, 'onScroll' | 'onLayout'> & {
+        refreshControl?: ReactElement;
+        ref: AnimatedRef<TRef>;
     };
     headerMotionContext: ScrollManagerHeaderMotionContext;
 }
+export type ScrollTo = (y: number, options?: ScrollToOptions) => void;
 export type ScrollHandlerContext = {
     lastOffset: number | undefined;
 };
+interface ScrollToOptions {
+    isValueDelta?: boolean;
+    animated?: boolean;
+}
+export {};
 //# sourceMappingURL=types.d.ts.map