react-native-header-motion 1.0.0-alpha.0 → 1.0.0

package/src/index.ts

@@ -1,76 +1,122 @@
 import {
-  AnimatedHeaderBase,
-  HeaderBase,
+  createHeaderMotionScrollable,
+  Bridge,
   HeaderMotionContextProvider,
-  HeaderMotionFlatList,
-  HeaderMotionHeader,
-  HeaderMotionScrollManager,
-  HeaderMotionScrollView,
+  FlatList,
+  Header,
+  NavigationBridge,
+  ScrollManager,
+  ScrollView,
+  type CreateHeaderMotionScrollableOptions,
+  type HeaderProps,
+  type HeaderMotionBridgeProps,
   type HeaderMotionFlatListProps,
-  type HeaderMotionHeaderProps,
+  type HeaderMotionNavigationBridgeProps,
   type HeaderMotionProps,
   type HeaderMotionScrollManagerProps,
+  type HeaderMotionScrollableOwnProps,
   type HeaderMotionScrollViewProps,
 } from './components';
-import type { ReactElement } from 'react';
+import type { HeaderDynamicProps } from './types';
 
-/**
- * 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.
+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.
+   */
+  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.
    */
-  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;
+  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>
  * ```
  */
-const HeaderMotion = HeaderMotionContextProvider as HeaderMotionComponent;
-HeaderMotion.Header = HeaderMotionHeader;
-HeaderMotion.ScrollManager = HeaderMotionScrollManager;
-HeaderMotion.ScrollView = HeaderMotionScrollView;
-HeaderMotion.FlatList = HeaderMotionFlatList;
+const HeaderMotion: HeaderMotionCompound = Object.assign(
+  HeaderMotionContextProvider,
+  {
+    Header,
+    Bridge,
+    NavigationBridge,
+    ScrollManager,
+    ScrollView,
+    FlatList,
+  }
+);
 
 export default HeaderMotion;
 export * from './hooks';
 export type * from './types';
-export { AnimatedHeaderBase, HeaderBase };
+export { createHeaderMotionScrollable };
+export { Bridge, Header, NavigationBridge };
 export type {
+  CreateHeaderMotionScrollableOptions,
+  HeaderDynamicProps,
   HeaderMotionFlatListProps,
-  HeaderMotionHeaderProps,
+  HeaderMotionBridgeProps,
+  HeaderMotionNavigationBridgeProps,
   HeaderMotionProps,
   HeaderMotionScrollManagerProps,
+  HeaderMotionScrollableOwnProps,
   HeaderMotionScrollViewProps,
+  HeaderProps,
 };

package/src/types.ts

@@ -1,10 +1,58 @@
 import type { ReactElement } from 'react';
-import type { LayoutChangeEvent, 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
@@ -26,46 +74,46 @@ 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: 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;
-  animatedHeaderBaseProps: AnimatedHeaderBaseMotionProps;
+  headerPanMomentumOffset: SharedValue<number | null>;
+  scrollValues: SharedValue<ScrollValues>;
   activeScrollId: SharedValue<string> | undefined;
-}
-
-export interface AnimatedHeaderBaseMotionProps {
-  enableHeaderPan: boolean;
   scrollToRef: React.RefObject<ScrollTo | null>;
-  headerPanMomentumOffset: SharedValue<number | null>;
+  originalHeaderHeight: number;
 }
 
 export interface ScrollManagerHeaderMotionContext {
-  originalHeaderHeight: SharedValue<number>;
-  minHeightContentContainerStyle:
-    | {}
-    | {
-        minHeight: number;
-      };
+  originalHeaderHeight: number;
+  contentContainerMinHeight?: number;
 }
 
 export interface ScrollManagerConfig<TRef extends InstanceOrElement = any> {
-  scrollableProps: Required<
-    Pick<ScrollViewProps, 'onScroll' | 'scrollEventThrottle'>
-  > & {
+  scrollableProps: Pick<ScrollViewProps, 'onScroll' | 'onLayout'> & {
     refreshControl?: ReactElement;
     ref: AnimatedRef<TRef>;
   };
@@ -74,6 +122,10 @@ export interface ScrollManagerConfig<TRef extends InstanceOrElement = any> {
 
 export type ScrollTo = (y: number, options?: ScrollToOptions) => void;
 
+export type ScrollHandlerContext = {
+  lastOffset: number | undefined;
+};
+
 interface ScrollToOptions {
   isValueDelta?: boolean;
   animated?: boolean;

package/src/utils/defaults.ts

@@ -1,15 +1,21 @@
-import type { MeasureAnimatedHeader, ProgressThreshold } from '../types';
+import type {
+  HeaderMotionOffsetStrategy,
+  MeasureAnimatedHeader,
+  ProgressThreshold,
+} from '../types';
 
 const DEFAULT_PROGRESS_THRESHOLD: ProgressThreshold = (measuredHeaderValue) =>
   measuredHeaderValue;
 const DEFAULT_MEASURE_DYNAMIC: MeasureAnimatedHeader = (e) =>
   e.nativeEvent.layout.height;
+const DEFAULT_HEADER_OFFSET_STRATEGY: HeaderMotionOffsetStrategy = 'padding';
 
 // Symbol doesn't work?
 // const DEFAULT_SCROLL_ID = Symbol("HEADER_MOTION_DEFAULT_SCROLL_ID");
 const DEFAULT_SCROLL_ID = '__HEADER_MOTION_DEFAULT_SCROLL_ID__';
 
 export {
+  DEFAULT_HEADER_OFFSET_STRATEGY,
   DEFAULT_MEASURE_DYNAMIC,
   DEFAULT_PROGRESS_THRESHOLD,
   DEFAULT_SCROLL_ID,

package/src/utils/header.tsx

@@ -0,0 +1,52 @@
+import {
+  Fragment,
+  cloneElement,
+  isValidElement,
+  type ReactElement,
+} from 'react';
+import type { ViewProps } from 'react-native';
+
+export type SlottableElementProps = {
+  onLayout?: ViewProps['onLayout'];
+};
+
+export type SlottableElement = ReactElement<SlottableElementProps>;
+
+export function composeOnLayoutHandlers(
+  userHandler: ViewProps['onLayout'],
+  internalHandler: ViewProps['onLayout']
+) {
+  return (e: Parameters<NonNullable<ViewProps['onLayout']>>[0]) => {
+    internalHandler?.(e);
+    userHandler?.(e);
+  };
+}
+
+export function resolveSlottableChild(
+  componentName: string,
+  child: ReactElement
+) {
+  if (!isValidElement(child) || child.type === Fragment) {
+    throw new Error(
+      `${componentName} with \`asChild\` expects a single valid React element child that accepts \`onLayout\`.`
+    );
+  }
+
+  return child as SlottableElement;
+}
+
+export function cloneWithOnLayout(
+  child: SlottableElement,
+  onLayout: ViewProps['onLayout'],
+  componentName: string
+) {
+  if (!isValidElement(child)) {
+    throw new Error(
+      `${componentName} with \`asChild\` expects a valid React element child.`
+    );
+  }
+
+  return cloneElement(child, {
+    onLayout: composeOnLayoutHandlers(child.props.onLayout, onLayout),
+  });
+}

package/src/utils/headerOffsetStyle.ts

@@ -0,0 +1,40 @@
+import type { SharedValue } from 'react-native-reanimated';
+import type { HeaderMotionOffsetStrategy } from '../types';
+import { DEFAULT_HEADER_OFFSET_STRATEGY } from './defaults';
+
+type HeaderOffsetValue = number | SharedValue<number>;
+
+type HeaderOffsetStyle =
+  | undefined
+  | { paddingTop: HeaderOffsetValue }
+  | { marginTop: HeaderOffsetValue }
+  | { top: HeaderOffsetValue; paddingBottom: HeaderOffsetValue }
+  | {
+      transform: [{ translateY: HeaderOffsetValue }];
+      paddingBottom: HeaderOffsetValue;
+    };
+
+export function resolveHeaderOffsetStyle(
+  originalHeaderHeight: HeaderOffsetValue,
+  headerOffsetStrategy: HeaderMotionOffsetStrategy = DEFAULT_HEADER_OFFSET_STRATEGY
+): HeaderOffsetStyle {
+  switch (headerOffsetStrategy) {
+    case 'none':
+      return undefined;
+    case 'margin':
+      return { marginTop: originalHeaderHeight };
+    case 'top':
+      return {
+        top: originalHeaderHeight,
+        paddingBottom: originalHeaderHeight,
+      };
+    case 'translate':
+      return {
+        transform: [{ translateY: originalHeaderHeight }],
+        paddingBottom: originalHeaderHeight,
+      };
+    case 'padding':
+    default:
+      return { paddingTop: originalHeaderHeight };
+  }
+}

package/src/utils/index.ts

@@ -1,3 +1,5 @@
 export * from './defaults';
+export * from './header';
+export * from './headerOffsetStyle';
 export * from './values';
 export * from './refreshControl';

package/lib/module/components/HeaderBase.js

@@ -1,107 +0,0 @@
-"use strict";
-
-import { useMemo } from 'react';
-import { Platform, StyleSheet, View } from 'react-native';
-import { Gesture, GestureDetector, GestureHandlerRootView } from 'react-native-gesture-handler';
-import Animated, { useAnimatedReaction, withDecay } from 'react-native-reanimated';
-import { jsx as _jsx } from "react/jsx-runtime";
-const PLATFORM_PANNING_ENABLED = Platform.select({
-  default: true,
-  android: false
-});
-/**
- * Base header component with absolute positioning.
- * Provides a foundation for building headers that need to be positioned absolutely.
- *
- * @example
- * ```tsx
- * <HeaderBase
- *   onLayout={measureTotalHeight}
- * >
- *   ...
- * </HeaderBase>
- * ```
- */
-export function HeaderBase({
-  style,
-  ...rest
-}) {
-  return /*#__PURE__*/_jsx(View, {
-    style: [style, styles.container],
-    ...rest
-  });
-}
-
-/**
- * Animated version of HeaderBase using Reanimated's Animated.View.
- * Use this when you need to animate the header based on scroll progress.
- *
- * @example
- * ```tsx
- * <AnimatedHeaderBase
- *   onLayout={measureTotalHeight}
- *   style={[{ paddingTop: insets.top }, animatedStyle]}
- * >
- *   ...
- * </AnimatedHeaderBase>
- * ```
- */
-
-// TODO: Thinking about DX, perhaps creating another context in AnimatedHeaderBase or somewhere else could make sense
-// Note: Depending on feedback, there might be a need to intercept ongoing scroll when starting to pan (perhaps even on the tap itself but to be checked what feels better when using)
-// Note: Depending on feedback, there might be a need to block momentum by forcing scrollTo
-export function AnimatedHeaderBase({
-  style,
-  animatedHeaderBaseProps,
-  withGestureHandlerRootView = false,
-  ...rest
-}) {
-  if (!animatedHeaderBaseProps) {
-    throw new Error('AnimatedHeaderBase requires `animatedHeaderBaseProps`. Pass the value from HeaderMotion.Header or useMotionProgress.');
-  }
-  const {
-    enableHeaderPan,
-    scrollToRef,
-    headerPanMomentumOffset: momentumScrollOffset
-  } = animatedHeaderBaseProps;
-  useAnimatedReaction(() => momentumScrollOffset.get(), (offset, prevOffset) => {
-    if (offset !== null) {
-      const dy = offset - (prevOffset ?? 0);
-      scrollToRef.current?.(dy);
-    }
-  });
-  const isPanEnabled = PLATFORM_PANNING_ENABLED && enableHeaderPan;
-  const pan = useMemo(() => Gesture.Pan().enabled(isPanEnabled).onChange(e => {
-    const dy = e.changeY;
-    scrollToRef.current?.(dy);
-  }).onEnd(e => {
-    momentumScrollOffset.set(withDecay({
-      velocity: e.velocityY
-    }, () => momentumScrollOffset.set(null)));
-  }).shouldCancelWhenOutside(false),
-  // Note: In first testing Android works without gesture handler whatsoever. If this functionality is needed, we can further control it with a prop in the future
-  [isPanEnabled, scrollToRef, momentumScrollOffset]);
-  const content = /*#__PURE__*/_jsx(GestureDetector, {
-    gesture: pan,
-    children: /*#__PURE__*/_jsx(Animated.View, {
-      style: [style, styles.container],
-      ...rest
-    })
-  });
-  if (!withGestureHandlerRootView) {
-    return content;
-  }
-  return /*#__PURE__*/_jsx(GestureHandlerRootView, {
-    children: content
-  });
-}
-const styles = StyleSheet.create({
-  container: {
-    position: 'absolute',
-    left: 0,
-    right: 0
-  }
-});
-
-// TODO: Lib refactor: context repetition, make people use less boilerplate by just wrapping the header with <HeaderBaseOrSomethingElse ctx={headerProps} /> that does everything under the hood (measuring total for example). That will then allow for people to use context inside
-//# sourceMappingURL=HeaderBase.js.map

package/lib/module/components/HeaderBase.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["useMemo","Platform","StyleSheet","View","Gesture","GestureDetector","GestureHandlerRootView","Animated","useAnimatedReaction","withDecay","jsx","_jsx","PLATFORM_PANNING_ENABLED","select","default","android","HeaderBase","style","rest","styles","container","AnimatedHeaderBase","animatedHeaderBaseProps","withGestureHandlerRootView","Error","enableHeaderPan","scrollToRef","headerPanMomentumOffset","momentumScrollOffset","get","offset","prevOffset","dy","current","isPanEnabled","pan","Pan","enabled","onChange","e","changeY","onEnd","set","velocity","velocityY","shouldCancelWhenOutside","content","gesture","children","create","position","left","right"],"sourceRoot":"../../../src","sources":["components/HeaderBase.tsx"],"mappings":"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","ignoreList":[]}

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

@@ -1,41 +0,0 @@
-import { type ViewProps } from 'react-native';
-import { type AnimatedProps } from 'react-native-reanimated';
-import type { MotionProgress } from '../types';
-export type HeaderBaseProps = ViewProps;
-export type AnimatedHeaderBaseProps = AnimatedProps<ViewProps> & Pick<MotionProgress, 'animatedHeaderBaseProps'> & {
-    /**
-     * Wraps the header with GestureHandlerRootView.
-     * Keep this disabled when your app already has a root-level GestureHandlerRootView.
-     */
-    withGestureHandlerRootView?: boolean;
-};
-/**
- * Base header component with absolute positioning.
- * Provides a foundation for building headers that need to be positioned absolutely.
- *
- * @example
- * ```tsx
- * <HeaderBase
- *   onLayout={measureTotalHeight}
- * >
- *   ...
- * </HeaderBase>
- * ```
- */
-export declare function HeaderBase({ style, ...rest }: HeaderBaseProps): import("react/jsx-runtime").JSX.Element;
-/**
- * Animated version of HeaderBase using Reanimated's Animated.View.
- * Use this when you need to animate the header based on scroll progress.
- *
- * @example
- * ```tsx
- * <AnimatedHeaderBase
- *   onLayout={measureTotalHeight}
- *   style={[{ paddingTop: insets.top }, animatedStyle]}
- * >
- *   ...
- * </AnimatedHeaderBase>
- * ```
- */
-export declare function AnimatedHeaderBase({ style, animatedHeaderBaseProps, withGestureHandlerRootView, ...rest }: AnimatedHeaderBaseProps): import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=HeaderBase.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"HeaderBase.d.ts","sourceRoot":"","sources":["../../../../src/components/HeaderBase.tsx"],"names":[],"mappings":"AACA,OAAO,EAA8B,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAM1E,OAAiB,EAGf,KAAK,aAAa,EACnB,MAAM,yBAAyB,CAAC;AAOjC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,MAAM,MAAM,eAAe,GAAG,SAAS,CAAC;AACxC,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,SAAS,CAAC,GAC5D,IAAI,CAAC,cAAc,EAAE,yBAAyB,CAAC,GAAG;IAChD;;;OAGG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACtC,CAAC;AAEJ;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,EAAE,eAAe,2CAE7D;AAED;;;;;;;;;;;;;GAaG;AAKH,wBAAgB,kBAAkB,CAAC,EACjC,KAAK,EACL,uBAAuB,EACvB,0BAAkC,EAClC,GAAG,IAAI,EACR,EAAE,uBAAuB,2CA2DzB"}