react-native-scroll-to-child
Version:
Scroll a ScrollView's child into the visible viewport
389 lines (378 loc) • 62.8 kB
JavaScript
'use strict';
var React = require('react');
var reactNative = require('react-native');
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
var React__default = /*#__PURE__*/_interopDefault(React);
var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
// src/compute-scroll.tsx
var computeScrollY = /* @__PURE__ */ __name((scrollViewLayout, viewLayout, scrollY, insets, align) => {
const { height: scrollViewHeight, y: scrollViewY } = scrollViewLayout;
const { height: childHeight, y: viewY } = viewLayout;
const viewTopY = viewY - scrollViewY;
const viewBottomY = viewTopY + childHeight;
const computationData = { scrollViewHeight, scrollY, viewTopY, viewBottomY, insets };
const computeFn = alignmentsY[align];
if (!computeFn) throw new Error(`align=${align} not supported`);
return computeFn(computationData);
}, "computeScrollY");
var computeScrollYAuto = /* @__PURE__ */ __name((data) => {
const { scrollY } = data;
const scrollYTop = computeScrollYStart(data);
if (scrollY > scrollYTop) {
return scrollYTop;
}
const scrollYBottom = computeScrollYEnd(data);
if (scrollY < scrollYBottom) {
return scrollYBottom;
}
return scrollY;
}, "computeScrollYAuto");
var computeScrollYStart = /* @__PURE__ */ __name(({ scrollY, viewTopY, insets }) => {
return scrollY + viewTopY - (insets.top || 0);
}, "computeScrollYStart");
var computeScrollYEnd = /* @__PURE__ */ __name(({ scrollViewHeight, scrollY, viewBottomY, insets }) => {
return scrollY + viewBottomY - scrollViewHeight + (insets.bottom || 0);
}, "computeScrollYEnd");
var computeScrollYCenter = /* @__PURE__ */ __name((data) => {
return (computeScrollYStart(data) + computeScrollYEnd(data)) / 2;
}, "computeScrollYCenter");
var alignmentsY = {
auto: computeScrollYAuto,
start: computeScrollYStart,
end: computeScrollYEnd,
center: computeScrollYCenter
};
var computeScrollX = /* @__PURE__ */ __name((scrollViewLayout, viewLayout, scrollX, insets, align) => {
const { width: scrollViewWidth, x: scrollViewX } = scrollViewLayout;
const { width: childWidth, x: viewX } = viewLayout;
const viewLeftX = viewX - scrollViewX;
const viewRightX = viewLeftX + childWidth;
const computationData = { scrollViewWidth, scrollX, viewLeftX, viewRightX, insets };
const computeFn = alignmentsX[align];
if (!computeFn) throw new Error(`align=${align} not supported for horizontal scrolling`);
return computeFn(computationData);
}, "computeScrollX");
var computeScrollXAuto = /* @__PURE__ */ __name((data) => {
const { scrollX } = data;
const scrollXLeft = computeScrollXStart(data);
if (scrollX > scrollXLeft) {
return scrollXLeft;
}
const scrollXRight = computeScrollXEnd(data);
if (scrollX < scrollXRight) {
return scrollXRight;
}
return scrollX;
}, "computeScrollXAuto");
var computeScrollXStart = /* @__PURE__ */ __name(({ scrollX, viewLeftX, insets }) => {
return scrollX + viewLeftX - (insets.left || 0);
}, "computeScrollXStart");
var computeScrollXEnd = /* @__PURE__ */ __name(({ scrollViewWidth, scrollX, viewRightX, insets }) => {
return scrollX + viewRightX - scrollViewWidth + (insets.right || 0);
}, "computeScrollXEnd");
var computeScrollXCenter = /* @__PURE__ */ __name((data) => {
return (computeScrollXStart(data) + computeScrollXEnd(data)) / 2;
}, "computeScrollXCenter");
var alignmentsX = {
auto: computeScrollXAuto,
start: computeScrollXStart,
end: computeScrollXEnd,
center: computeScrollXCenter
};
var measureElement = /* @__PURE__ */ __name((element) => {
const node = reactNative.findNodeHandle(element);
if (!node) return Promise.reject(new Error("Unable to find node handle"));
return new Promise((resolve) => {
reactNative.UIManager.measureInWindow(node, (x, y, width, height) => resolve({ x, y, width, height }));
});
}, "measureElement");
var throttle = /* @__PURE__ */ __name((func, limit) => {
let inThrottle = false;
return function(...args) {
if (!inThrottle) {
func.apply(this, args);
inThrottle = true;
setTimeout(() => inThrottle = false, limit);
}
};
}, "throttle");
// src/config.tsx
var DefaultOptions = {
align: "auto",
animated: true,
immediate: false,
insets: {
top: 0,
bottom: 0,
left: 0,
right: 0
},
computeScrollY,
computeScrollX,
measureElement
};
var normalizeOptions = /* @__PURE__ */ __name((options = {}, fallbackOptions = DefaultOptions) => ({
...fallbackOptions,
...options,
insets: {
...fallbackOptions.insets,
...options.insets
}
}), "normalizeOptions");
var DefaultHOCConfig = {
// The method to extract the raw ScrollView node from the ref we got, if it's not directly the ScrollView itself
getScrollViewNode: /* @__PURE__ */ __name((scrollView) => {
const rnVersion = reactNative.Platform.constants.reactNativeVersion;
const isPreRN062 = rnVersion ? rnVersion.major === 0 && rnVersion.minor < 62 : false;
if (typeof scrollView.getNode === "function" && isPreRN062) {
return scrollView.getNode();
}
return scrollView;
}, "getScrollViewNode"),
// Default value for throttling, can be overridden by user with props
scrollEventThrottle: 16,
// ScrollIntoView options, can be offered by <ScrollIntoView /> comp or imperative usage
options: DefaultOptions
};
var normalizeHOCConfig = /* @__PURE__ */ __name((config = {}) => ({
...DefaultHOCConfig,
...config,
options: normalizeOptions(config.options, DefaultOptions)
}), "normalizeHOCConfig");
// src/api.tsx
var scrollIntoView = /* @__PURE__ */ __name(async (scrollView, view, scrollY, scrollX, options) => {
if (!scrollView || !view) {
throw new Error("ScrollView and target View must be provided");
}
const { align, animated, computeScrollY: computeScrollY2, computeScrollX: computeScrollX2, measureElement: measureElement2, insets } = normalizeOptions(options);
try {
const [scrollViewLayout, viewLayout] = await Promise.all([measureElement2(scrollView), measureElement2(view)]);
const targetScrollY = computeScrollY2(scrollViewLayout, viewLayout, scrollY, insets, align);
const targetScrollX = computeScrollX2(scrollViewLayout, viewLayout, scrollX, insets, align);
const scrollParams = { x: targetScrollX, y: targetScrollY, animated };
const scrollResponder = scrollView.getScrollResponder();
if (scrollResponder.scrollResponderScrollTo) {
scrollResponder.scrollResponderScrollTo(scrollParams);
} else {
scrollView.scrollTo(scrollParams);
}
} catch (error) {
const errorMessage = error instanceof Error ? error.message : "Unknown error";
throw new Error(`Failed to scroll into view: ${errorMessage}`);
}
}, "scrollIntoView");
var _ScrollIntoViewAPI = class _ScrollIntoViewAPI {
constructor(dependencies) {
this.dependencies = dependencies;
this.validateDependencies(dependencies);
}
validateDependencies(deps) {
const requiredDepKeys = [
"getScrollView",
"getScrollY",
"getScrollX",
"getDefaultOptions"
];
for (const key of requiredDepKeys) {
if (typeof deps[key] !== "function") {
throw new Error(`Dependency "${key}" must be a function.`);
}
}
}
getNormalizedOptions = /* @__PURE__ */ __name((options = {}) => normalizeOptions(options, this.dependencies.getDefaultOptions()), "getNormalizedOptions");
scrollIntoView = /* @__PURE__ */ __name((view, options) => {
const normalizedOptions = this.getNormalizedOptions(options);
return normalizedOptions.immediate ? this.scrollIntoViewImmediate(view, normalizedOptions) : this.scrollIntoViewThrottled(view, normalizedOptions);
}, "scrollIntoView");
performScroll = /* @__PURE__ */ __name((view, options) => {
return scrollIntoView(
this.dependencies.getScrollView(),
view,
this.dependencies.getScrollY(),
this.dependencies.getScrollX(),
options
);
}, "performScroll");
scrollIntoViewThrottled = throttle(this.performScroll, 16);
scrollIntoViewImmediate = this.performScroll;
};
__name(_ScrollIntoViewAPI, "ScrollIntoViewAPI");
var ScrollIntoViewAPI = _ScrollIntoViewAPI;
// src/context.tsx
var Context = React__default.default.createContext(null);
var context_default = Context;
var APIConsumer = Context.Consumer;
var ProvideAPI = /* @__PURE__ */ __name(({ dependencies, children }) => {
const api = React__default.default.useMemo(() => new ScrollIntoViewAPI(dependencies), [dependencies]);
return /* @__PURE__ */ React__default.default.createElement(Context.Provider, { value: api }, children);
}, "ProvideAPI");
// src/container.tsx
var showNotInContextWarning = throttle(() => {
console.warn(
"ScrollIntoView API is not provided in React context. Make sure you wrapped your ScrollView component with wrapScrollView(ScrollView)"
);
}, 5e3);
var ContainerBase = React.forwardRef((props, ref) => {
const {
enabled = true,
onMount = true,
onUpdate = true,
scrollIntoViewKey,
scrollIntoViewOptions,
scrollIntoViewAPI,
children,
align,
animated,
immediate,
insets,
measureElement: measureElement2,
computeScrollY: computeScrollY2,
computeScrollX: computeScrollX2,
...rest
} = props;
const containerRef = React.useRef(null);
const unmounted = React.useRef(false);
const prevProps = React.useRef({ enabled, scrollIntoViewKey });
const ensureApiProvided = React.useCallback(() => {
if (!scrollIntoViewAPI) {
showNotInContextWarning();
return false;
}
return true;
}, [scrollIntoViewAPI]);
const getPropsOptions = React.useCallback(() => {
const COMPONENT_DEFAULT_ANIMATED = true;
const COMPONENT_DEFAULT_IMMEDIATE = false;
const mergedOptions = {
animated: COMPONENT_DEFAULT_ANIMATED,
immediate: COMPONENT_DEFAULT_IMMEDIATE,
...scrollIntoViewOptions
};
const optionProps = [
"animated",
"immediate",
"align",
"insets",
"measureElement",
"computeScrollY",
"computeScrollX"
];
const propsToMerge = {
animated,
immediate,
align,
insets,
measureElement: measureElement2,
computeScrollY: computeScrollY2,
computeScrollX: computeScrollX2
};
for (const key of optionProps) {
if (propsToMerge[key] !== void 0) {
mergedOptions[key] = propsToMerge[key];
}
}
return mergedOptions;
}, [scrollIntoViewOptions, animated, immediate, align, insets, measureElement2, computeScrollY2, computeScrollX2]);
const scrollIntoView2 = React.useCallback(
(providedOptions = {}) => {
if (unmounted.current || !ensureApiProvided()) return;
const currentContainerRef = containerRef.current;
if (!currentContainerRef) return;
const options = { ...getPropsOptions(), ...providedOptions };
if (scrollIntoViewAPI) {
scrollIntoViewAPI.scrollIntoView(currentContainerRef, options);
}
},
[ensureApiProvided, getPropsOptions, scrollIntoViewAPI]
);
React.useEffect(() => {
let timerId;
if (onMount && enabled) {
timerId = setTimeout(() => {
if (!unmounted.current) {
scrollIntoView2();
}
}, 0);
}
return () => {
if (timerId) {
clearTimeout(timerId);
}
};
}, [enabled, onMount, scrollIntoView2]);
React.useEffect(() => {
const prevEnabled = prevProps.current.enabled;
const prevKey = prevProps.current.scrollIntoViewKey;
const needsUpdateScroll = onUpdate && enabled && (!prevEnabled || scrollIntoViewKey !== prevKey);
if (needsUpdateScroll) {
scrollIntoView2();
}
if (prevEnabled !== enabled || prevKey !== scrollIntoViewKey) {
prevProps.current = { enabled, scrollIntoViewKey };
}
}, [enabled, onUpdate, scrollIntoViewKey, scrollIntoView2]);
React.useEffect(() => {
return () => {
unmounted.current = true;
};
}, []);
return /* @__PURE__ */ React__default.default.createElement(reactNative.View, { ...rest, ref: ref || containerRef, collapsable: false }, children);
});
ContainerBase.displayName = "ContainerBase";
var Container = React.forwardRef((props, ref) => /* @__PURE__ */ React__default.default.createElement(APIConsumer, null, (apiFromContext) => apiFromContext && /* @__PURE__ */ React__default.default.createElement(ContainerBase, { ref, ...props, scrollIntoViewAPI: apiFromContext })));
var wrapScrollViewHOC = /* @__PURE__ */ __name((ScrollViewComp, config = {}) => {
const { getScrollViewNode, scrollEventThrottle, options } = normalizeHOCConfig(config);
const ScrollViewWrapper = React.forwardRef((props, ref) => {
var _a, _b;
const internalRef = React.useRef(null);
const scrollY = React.useRef(((_a = props.contentOffset) == null ? void 0 : _a.y) || 0);
const scrollX = React.useRef(((_b = props.contentOffset) == null ? void 0 : _b.x) || 0);
const handleScroll = React.useCallback((event) => {
scrollY.current = event.nativeEvent.contentOffset.y;
scrollX.current = event.nativeEvent.contentOffset.x;
}, []);
const dependencies = {
getScrollView: /* @__PURE__ */ __name(() => {
if (!internalRef.current) throw new Error("ScrollView ref is not set");
return getScrollViewNode(internalRef.current);
}, "getScrollView"),
getScrollY: /* @__PURE__ */ __name(() => scrollY.current, "getScrollY"),
getScrollX: /* @__PURE__ */ __name(() => scrollX.current, "getScrollX"),
getDefaultOptions: /* @__PURE__ */ __name(() => normalizeOptions(props.scrollIntoViewOptions, options), "getDefaultOptions")
};
React.useImperativeHandle(ref, () => internalRef.current, []);
const scrollViewProps = {
...props,
ref: internalRef,
scrollEventThrottle: props.scrollEventThrottle || scrollEventThrottle,
onScroll: reactNative.Animated.forkEvent(props.onScroll, handleScroll)
};
return /* @__PURE__ */ React__default.default.createElement(ScrollViewComp, { ...scrollViewProps }, /* @__PURE__ */ React__default.default.createElement(ProvideAPI, { dependencies }, props.children));
});
ScrollViewWrapper.displayName = `ScrollIntoViewWrapper(${ScrollViewComp.displayName || ScrollViewComp.name || "Component"})`;
return ScrollViewWrapper;
}, "wrapScrollViewHOC");
function useScrollIntoViewContext() {
const value = React.useContext(context_default);
if (value === null) {
throw new Error(
"ScrollIntoView context is missing. Ensure your ScrollView is wrapped with wrapScrollView() and is an ancestor in the component tree."
);
}
return value;
}
__name(useScrollIntoViewContext, "useScrollIntoViewContext");
function useScrollIntoView() {
const { scrollIntoView: scrollIntoView2 } = useScrollIntoViewContext();
return scrollIntoView2;
}
__name(useScrollIntoView, "useScrollIntoView");
// src/index.ts
var ScrollIntoView = Container;
var wrapScrollView = /* @__PURE__ */ __name((comp, config) => wrapScrollViewHOC(comp, config), "wrapScrollView");
exports.ScrollIntoView = ScrollIntoView;
exports.useScrollIntoView = useScrollIntoView;
exports.wrapScrollView = wrapScrollView;
//# sourceMappingURL=index.cjs.map
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/compute-scroll.tsx","../src/utils.tsx","../src/config.tsx","../src/api.tsx","../src/context.tsx","../src/container.tsx","../src/hoc.tsx","../src/hooks.tsx","../src/index.ts"],"names":["findNodeHandle","UIManager","Platform","computeScrollY","computeScrollX","measureElement","React","forwardRef","useRef","useCallback","scrollIntoView","useEffect","View","useImperativeHandle","Animated","useContext"],"mappings":"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","file":"index.cjs","sourcesContent":["import type { Align, Insets } from './config';\nimport type { LayoutRectangle } from 'react-native';\n\ntype ComputationData = {\n    scrollViewHeight: number;\n    scrollY: number;\n    viewTopY: number;\n    viewBottomY: number;\n    insets: Insets;\n};\n\nexport const computeScrollY = (\n    scrollViewLayout: LayoutRectangle,\n    viewLayout: LayoutRectangle,\n    scrollY: number,\n    insets: Insets,\n    align: Align\n) => {\n    const { height: scrollViewHeight, y: scrollViewY } = scrollViewLayout;\n    const { height: childHeight, y: viewY } = viewLayout;\n\n    const viewTopY = viewY - scrollViewY;\n    const viewBottomY = viewTopY + childHeight;\n\n    const computationData = { scrollViewHeight, scrollY, viewTopY, viewBottomY, insets };\n\n    const computeFn = alignmentsY[align];\n    if (!(computeFn as any)) throw new Error(`align=${align} not supported`);\n\n    return computeFn(computationData);\n};\n\nexport const computeScrollYAuto = (data: ComputationData): number => {\n    const { scrollY } = data;\n    const scrollYTop = computeScrollYStart(data);\n    if (scrollY > scrollYTop) {\n        return scrollYTop;\n    }\n    const scrollYBottom = computeScrollYEnd(data);\n    if (scrollY < scrollYBottom) {\n        return scrollYBottom;\n    }\n    return scrollY;\n};\n\nexport const computeScrollYStart = ({ scrollY, viewTopY, insets }: ComputationData): number => {\n    return scrollY + viewTopY - (insets.top || 0);\n};\n\nexport const computeScrollYEnd = ({ scrollViewHeight, scrollY, viewBottomY, insets }: ComputationData): number => {\n    return scrollY + viewBottomY - scrollViewHeight + (insets.bottom || 0);\n};\n\nexport const computeScrollYCenter = (data: ComputationData): number => {\n    return (computeScrollYStart(data) + computeScrollYEnd(data)) / 2;\n};\n\nconst alignmentsY: Record<Align, (data: ComputationData) => number> = {\n    auto: computeScrollYAuto,\n    start: computeScrollYStart,\n    end: computeScrollYEnd,\n    center: computeScrollYCenter\n};\n\ntype ComputationDataX = {\n    scrollViewWidth: number;\n    scrollX: number;\n    viewLeftX: number;\n    viewRightX: number;\n    insets: Insets;\n};\n\nexport const computeScrollX = (\n    scrollViewLayout: LayoutRectangle,\n    viewLayout: LayoutRectangle,\n    scrollX: number,\n    insets: Insets,\n    align: Align\n): number => {\n    const { width: scrollViewWidth, x: scrollViewX } = scrollViewLayout;\n    const { width: childWidth, x: viewX } = viewLayout;\n\n    const viewLeftX = viewX - scrollViewX;\n    const viewRightX = viewLeftX + childWidth;\n\n    const computationData: ComputationDataX = { scrollViewWidth, scrollX, viewLeftX, viewRightX, insets };\n\n    const computeFn = alignmentsX[align];\n    if (!(computeFn as any)) throw new Error(`align=${align} not supported for horizontal scrolling`);\n\n    return computeFn(computationData);\n};\n\nexport const computeScrollXAuto = (data: ComputationDataX): number => {\n    const { scrollX } = data;\n    const scrollXLeft = computeScrollXStart(data);\n    if (scrollX > scrollXLeft) {\n        return scrollXLeft;\n    }\n    const scrollXRight = computeScrollXEnd(data);\n    if (scrollX < scrollXRight) {\n        return scrollXRight;\n    }\n    return scrollX;\n};\n\nexport const computeScrollXStart = ({ scrollX, viewLeftX, insets }: ComputationDataX): number => {\n    return scrollX + viewLeftX - (insets.left || 0);\n};\n\nexport const computeScrollXEnd = ({ scrollViewWidth, scrollX, viewRightX, insets }: ComputationDataX): number => {\n    return scrollX + viewRightX - scrollViewWidth + (insets.right || 0);\n};\n\nexport const computeScrollXCenter = (data: ComputationDataX): number => {\n    return (computeScrollXStart(data) + computeScrollXEnd(data)) / 2;\n};\n\nconst alignmentsX: Record<Align, (data: ComputationDataX) => number> = {\n    auto: computeScrollXAuto,\n    start: computeScrollXStart,\n    end: computeScrollXEnd,\n    center: computeScrollXCenter\n};\n","import { findNodeHandle, UIManager } from 'react-native';\n\nimport type React from 'react';\nimport type { LayoutRectangle } from 'react-native';\n\ntype FindNodeHandleArg = null | number | React.Component<any, any> | React.ComponentClass<any>;\n\nexport const measureElement = (element: FindNodeHandleArg): Promise<LayoutRectangle> => {\n    const node = findNodeHandle(element);\n    if (!node) return Promise.reject(new Error('Unable to find node handle'));\n\n    return new Promise<LayoutRectangle>((resolve) => {\n        UIManager.measureInWindow(node, (x, y, width, height) => resolve({ x, y, width, height }));\n    });\n};\n\nexport const throttle = <T extends (...args: any[]) => void>(func: T, limit: number): T => {\n    let inThrottle = false;\n    return function (this: unknown, ...args: Parameters<T>) {\n        if (!inThrottle) {\n            func.apply(this, args);\n            inThrottle = true;\n            setTimeout(() => (inThrottle = false), limit);\n        }\n    } as T;\n};\n","import { Platform } from 'react-native';\n\nimport { computeScrollX, computeScrollY } from './compute-scroll';\nimport { measureElement } from './utils';\n\nimport type { ScrollView } from 'react-native';\n\nexport type Insets = {\n    top?: number;\n    bottom?: number;\n    left?: number;\n    right?: number;\n};\n\nexport type Align = 'auto' | 'start' | 'end' | 'center';\n\nexport type FullOptions = {\n    align: Align;\n    animated: boolean;\n    immediate: boolean;\n    insets: Insets;\n    computeScrollY: typeof computeScrollY;\n    computeScrollX: typeof computeScrollX;\n    measureElement: typeof measureElement;\n};\n\nexport type PartialOptions = Partial<FullOptions>;\n\nexport const DefaultOptions: FullOptions = {\n    align: 'auto',\n    animated: true,\n    immediate: false,\n    insets: {\n        top: 0,\n        bottom: 0,\n        left: 0,\n        right: 0\n    },\n    computeScrollY,\n    computeScrollX,\n    measureElement\n};\n\nexport type OptionKey = keyof FullOptions;\nexport const OptionKeys: OptionKey[] = Object.keys(DefaultOptions) as OptionKey[];\n\nexport const normalizeOptions = (options: PartialOptions = {}, fallbackOptions: FullOptions = DefaultOptions) => ({\n    ...fallbackOptions,\n    ...options,\n    insets: {\n        ...fallbackOptions.insets,\n        ...options.insets\n    }\n});\n\nexport type FullHOCConfig = {\n    getScrollViewNode: (scrollView: ScrollView) => ScrollView;\n    scrollEventThrottle: 16;\n    options: PartialOptions;\n};\nexport type PartialHOCConfig = Partial<FullHOCConfig>;\n\nexport const DefaultHOCConfig: FullHOCConfig = {\n    // The method to extract the raw ScrollView node from the ref we got, if it's not directly the ScrollView itself\n    getScrollViewNode: (scrollView: ScrollView) => {\n        // scrollView.getNode() was used for Animated.ScrollView components but is deprecated since RN 0.62.\n        // See: https://github.com/facebook/react-native/commit/66e72bb4e00aafbcb9f450ed5db261d98f99f82a\n        // We only attempt to call it if it exists and we're on an older RN version.\n        const rnVersion = Platform.constants.reactNativeVersion;\n        const isPreRN062 = (rnVersion as any) ? rnVersion.major === 0 && rnVersion.minor < 62 : false;\n\n        // Check if getNode exists on the scrollView object (common for Animated.ScrollView)\n        // and if we are on a React Native version where it was recommended.\n        if (typeof (scrollView as any).getNode === 'function' && isPreRN062) {\n            return (scrollView as any).getNode(); // Call getNode if applicable\n        }\n        return scrollView; // Otherwise, return the scrollView directly\n    },\n    // Default value for throttling, can be overridden by user with props\n    scrollEventThrottle: 16,\n    // ScrollIntoView options, can be offered by <ScrollIntoView /> comp or imperative usage\n    options: DefaultOptions\n};\n\nexport const normalizeHOCConfig = (config: PartialHOCConfig = {}) => ({\n    ...DefaultHOCConfig,\n    ...config,\n    options: normalizeOptions(config.options, DefaultOptions)\n});\n","import { normalizeOptions } from './config';\nimport { throttle } from './utils';\n\nimport type { FullOptions, PartialOptions } from './config';\nimport type { ScrollView, View } from 'react-native';\n\ntype ScrollParams = { x: number; y: number; animated: boolean };\n\nexport const scrollIntoView = async (\n    scrollView: ScrollView,\n    view: View,\n    scrollY: number,\n    scrollX: number,\n    options: PartialOptions\n): Promise<void> => {\n    if (!(scrollView as any) || !(view as any)) {\n        throw new Error('ScrollView and target View must be provided');\n    }\n\n    const { align, animated, computeScrollY, computeScrollX, measureElement, insets } = normalizeOptions(options);\n\n    try {\n        const [scrollViewLayout, viewLayout] = await Promise.all([measureElement(scrollView), measureElement(view)]);\n\n        const targetScrollY = computeScrollY(scrollViewLayout, viewLayout, scrollY, insets, align);\n        const targetScrollX = computeScrollX(scrollViewLayout, viewLayout, scrollX, insets, align);\n        const scrollParams: ScrollParams = { x: targetScrollX, y: targetScrollY, animated };\n\n        const scrollResponder = scrollView.getScrollResponder();\n        if ((scrollResponder as any).scrollResponderScrollTo) {\n            scrollResponder.scrollResponderScrollTo(scrollParams);\n        } else {\n            scrollView.scrollTo(scrollParams);\n        }\n    } catch (error) {\n        const errorMessage = error instanceof Error ? error.message : 'Unknown error';\n        throw new Error(`Failed to scroll into view: ${errorMessage}`);\n    }\n};\n\ntype GetScrollView = () => ScrollView;\ntype GetScrollY = () => number;\ntype GetScrollX = () => number;\ntype GetDefaultOptions = () => FullOptions;\n\nexport type ScrollIntoViewDependencies = {\n    readonly getScrollView: GetScrollView;\n    readonly getScrollY: GetScrollY;\n    readonly getScrollX: GetScrollX;\n    readonly getDefaultOptions: GetDefaultOptions;\n};\n\nexport class ScrollIntoViewAPI {\n    constructor(private readonly dependencies: ScrollIntoViewDependencies) {\n        this.validateDependencies(dependencies);\n    }\n\n    private validateDependencies(deps: ScrollIntoViewDependencies): void {\n        const requiredDepKeys: (keyof ScrollIntoViewDependencies)[] = [\n            'getScrollView',\n            'getScrollY',\n            'getScrollX',\n            'getDefaultOptions'\n        ];\n        for (const key of requiredDepKeys) {\n            if (typeof deps[key] !== 'function') {\n                throw new Error(`Dependency \"${key}\" must be a function.`);\n            }\n        }\n    }\n\n    private getNormalizedOptions = (options: PartialOptions = {}): FullOptions =>\n        normalizeOptions(options, this.dependencies.getDefaultOptions());\n\n    public scrollIntoView = (view: View, options?: PartialOptions): Promise<void> => {\n        const normalizedOptions = this.getNormalizedOptions(options);\n        return normalizedOptions.immediate\n            ? this.scrollIntoViewImmediate(view, normalizedOptions)\n            : this.scrollIntoViewThrottled(view, normalizedOptions);\n    };\n\n    private performScroll = (view: View, options: PartialOptions): Promise<void> => {\n        return scrollIntoView(\n            this.dependencies.getScrollView(),\n            view,\n            this.dependencies.getScrollY(),\n            this.dependencies.getScrollX(),\n            options\n        );\n    };\n\n    private scrollIntoViewThrottled = throttle(this.performScroll, 16);\n\n    private scrollIntoViewImmediate = this.performScroll;\n}\n","import React from 'react';\n\nimport { ScrollIntoViewAPI } from './api';\n\nimport type { ScrollIntoViewDependencies } from './api';\n\nconst Context = React.createContext<ScrollIntoViewAPI | null>(null);\n\nexport default Context;\n\nexport const APIConsumer = Context.Consumer;\n\ninterface ProvideAPIProps {\n    dependencies: ScrollIntoViewDependencies;\n    children: React.ReactNode;\n}\n\nexport const ProvideAPI: React.FC<ProvideAPIProps> = ({ dependencies, children }) => {\n    const