react-native-ui-lib 8.1.1 → 8.1.5

package/src/components/textField/validators.d.ts

@@ -0,0 +1,9 @@
+declare const validators: {
+    required: (value?: string) => boolean;
+    email: (value?: string) => boolean;
+    optionalEmail: (value?: string) => boolean;
+    url: (value?: string) => boolean;
+    number: (value?: string) => boolean;
+    price: (value?: string) => boolean;
+};
+export default validators;

package/src/components/textFieldOld/index.d.ts

@@ -0,0 +1,71 @@
+import React from 'react';
+import BaseInput from '../baseInput';
+/**
+ * @description: A wrapper for TextInput component with extra functionality like floating placeholder and validations (This is an uncontrolled component)
+ * @modifiers: Typography
+ * @extends: TextInput
+ * @extendsLink: https://reactnative.dev/docs/textinput
+ * @gif: https://media.giphy.com/media/xULW8su8Cs5Z9Fq4PS/giphy.gif, https://media.giphy.com/media/3ohc1dhDcLS9FvWLJu/giphy.gif, https://media.giphy.com/media/oNUSOxnHdMP5ZnKYsh/giphy.gif
+ * @example: https://github.com/wix/react-native-ui-lib/blob/master/demo/src/screens/componentScreens/TextFieldScreen/BasicTextFieldScreen.js
+ */
+export default class TextField extends BaseInput {
+    static displayName: string;
+    static propTypes: any;
+    static defaultProps: {
+        enableErrors: boolean;
+        validateOnBlur: boolean;
+    };
+    constructor(props: any);
+    UNSAFE_componentWillReceiveProps(nextProps: any): void;
+    componentDidUpdate(_prevProps: any, prevState: any): void;
+    onPlaceholderLayout: (event: any) => void;
+    /** Actions */
+    generatePropsWarnings(props: any): void;
+    generateStyles(): void;
+    getAccessibilityInfo(): {
+        accessibilityLabel: any;
+        accessibilityState: {
+            disabled: boolean;
+        } | undefined;
+    };
+    toggleExpandableModal: (value: any) => void;
+    updateFloatingPlaceholderState: (withoutAnimation: any) => void;
+    getPlaceholderText: (this: any, placeholder: any, helperText: any) => any;
+    getStateColor(colorProp?: {}): any;
+    getCharCount(): any;
+    setCharCountColor(key: any): void;
+    getCharCountColor(): any;
+    getTopPaddings(): 25 | undefined;
+    getTopErrorsPosition(): {
+        top: number;
+    } | undefined;
+    isDisabled(): boolean;
+    isCounterLimit(): boolean;
+    hasText(value: any): boolean;
+    shouldShowHelperText(): any;
+    shouldFloatOnFocus(): any;
+    shouldFloatPlaceholder(text: any): any;
+    shouldFakePlaceholder(): boolean;
+    shouldShowError(): any;
+    getErrorMessage(): any;
+    shouldShowTopError(): any;
+    shouldDisplayRightButton(): any;
+    shouldRenderTitle(): any;
+    onPressRightButton: () => void;
+    /** Renders */
+    renderPlaceholder(): React.JSX.Element | undefined;
+    renderPrefix(): React.JSX.Element | undefined;
+    renderTitle(): React.JSX.Element | undefined;
+    renderCharCounter(): React.JSX.Element | undefined;
+    renderError(visible: any): React.JSX.Element | undefined;
+    renderExpandableModal(): any;
+    renderExpandableInput(): any;
+    renderTextInput(): React.JSX.Element;
+    renderRightButton(): React.JSX.Element | undefined;
+    renderRightIcon(): React.JSX.Element | undefined;
+    render(): React.JSX.Element;
+    /** Events */
+    onDoneEditingExpandableInput: () => void;
+    onKeyPress: (event: any) => void;
+    onChangeText: (text: any) => void;
+}

package/src/components/timeline/Line.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { ViewStyle } from 'react-native';
+import { LineProps } from './types';
+type LinePropsInternal = LineProps & {
+    top?: boolean;
+    style?: ViewStyle;
+    testID?: string;
+};
+declare const Line: React.MemoExoticComponent<(props: LinePropsInternal) => React.JSX.Element>;
+export default Line;

package/src/components/timeline/Point.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { LayoutChangeEvent } from 'react-native';
+import { PointProps } from './types';
+type PointPropsInternal = PointProps & {
+    onLayout?: (event: LayoutChangeEvent) => void;
+    testID?: string;
+};
+declare const Point: (props: PointPropsInternal) => React.JSX.Element;
+export default Point;

package/src/components/timeline/index.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { TimelineProps, PointProps, LineProps, StateTypes, PointTypes, LineTypes } from './types';
+export { TimelineProps, PointProps as TimelinePointProps, LineProps as TimelineLineProps, StateTypes as TimelineStateTypes, PointTypes as TimelinePointTypes, LineTypes as TimelineLineTypes };
+declare const Timeline: {
+    (props: TimelineProps): React.JSX.Element;
+    displayName: string;
+    states: typeof StateTypes;
+    lineTypes: typeof LineTypes;
+    pointTypes: typeof PointTypes;
+};
+export default Timeline;

package/src/components/timeline/line.driver.d.ts

@@ -0,0 +1,10 @@
+import { ComponentProps } from '../../testkit/new/Component.driver';
+export declare const LineDriver: (props: ComponentProps) => {
+    getLine: () => {
+        exists: () => boolean;
+        getStyle: () => any;
+        isVisible: () => boolean;
+        isEntryPointExists: () => boolean;
+        getEntryPointStyle: () => any;
+    };
+};

package/src/components/timeline/point.driver.d.ts

@@ -0,0 +1,8 @@
+import { ComponentProps } from '../../testkit/new/Component.driver';
+export declare const PointDriver: (props: ComponentProps) => {
+    getPoint: () => {
+        exists: () => boolean;
+        getStyle: () => any;
+        getContentStyle: () => any;
+    };
+};

package/src/components/timeline/timeline.driver.d.ts

@@ -0,0 +1,25 @@
+import { ComponentProps } from '../../testkit/new/Component.driver';
+export declare const TimelineDriver: (props: ComponentProps) => {
+    getPoint: () => {
+        exists: () => boolean;
+        getStyle: () => any;
+        getContentStyle: () => any;
+    };
+    getTopLine: () => {
+        exists: () => boolean;
+        getStyle: () => any;
+        isVisible: () => boolean;
+        isEntryPointExists: () => boolean;
+        getEntryPointStyle: () => any;
+    };
+    getBottomLine: () => {
+        exists: () => boolean;
+        getStyle: () => any;
+        isVisible: () => boolean;
+        isEntryPointExists: () => boolean;
+        getEntryPointStyle: () => any;
+    };
+    getElement: () => import("react-test-renderer").ReactTestInstance;
+    queryElement: () => import("react-test-renderer").ReactTestInstance | undefined;
+    exists: () => boolean;
+};

package/src/components/timeline/types.d.ts

@@ -0,0 +1,50 @@
+import React, { PropsWithChildren } from 'react';
+import { ImageRequireSource } from 'react-native';
+import { IconProps } from '../icon';
+export declare enum StateTypes {
+    CURRENT = "current",
+    NEXT = "next",
+    ERROR = "error",
+    SUCCESS = "success"
+}
+export declare enum LineTypes {
+    SOLID = "solid",
+    DASHED = "dashed"
+}
+export declare enum PointTypes {
+    BULLET = "bullet",
+    CIRCLE = "circle",
+    OUTLINE = "outline"
+}
+export type LineProps = {
+    state?: StateTypes;
+    type?: LineTypes | `${LineTypes}`;
+    color?: string;
+    /** to mark as entry point */
+    entry?: boolean;
+    width?: number;
+};
+export type PointProps = {
+    state?: StateTypes | `${StateTypes}`;
+    type?: PointTypes | `${PointTypes}`;
+    color?: string;
+    icon?: ImageRequireSource;
+    iconProps?: IconProps;
+    removeIconBackground?: boolean;
+    label?: number;
+    labelColor?: string;
+    /** to align point to this view's center */
+    anchorRef?: React.MutableRefObject<undefined>;
+};
+export type Layout = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type TimelineProps = PropsWithChildren<{
+    topLine?: LineProps;
+    bottomLine?: LineProps;
+    point?: PointProps;
+    testID?: string;
+}>;

package/src/components/touchableOpacity/index.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+import { GestureResponderEvent, TouchableOpacityProps as RNTouchableOpacityProps } from 'react-native';
+import { ContainerModifiers, BackgroundColorModifier } from '../../commons/new';
+import { RecorderProps } from '../../typings/recorderTypes';
+import { ViewProps } from '../view';
+export interface TouchableOpacityProps extends Omit<RNTouchableOpacityProps, 'style' | 'onPress' | 'onPressIn' | 'onPressOut' | 'onLongPress'>, ContainerModifiers, BackgroundColorModifier, RecorderProps {
+    /**
+     * background color for TouchableOpacity
+     */
+    backgroundColor?: string;
+    /**
+     * throttle time in MS for onPress callback
+     */
+    throttleTime?: number;
+    /**
+     * throttle options {leading, trailing}
+     */
+    throttleOptions?: {
+        leading: boolean;
+        trailing: boolean;
+    };
+    /**
+     * Apply background color on TouchableOpacity when active (press is on)
+     */
+    activeBackgroundColor?: string;
+    /**
+     * Will apply scale press feedback. This will enforce the useNative prop
+     */
+    activeScale?: number;
+    /**
+     * Should use a more native touchable opacity component
+     */
+    useNative?: boolean;
+    /**
+     * Custom value of any type to pass on to TouchableOpacity and receive back in onPress callback
+     */
+    customValue?: any;
+    style?: ViewProps['style'];
+    onPress?: (props?: (TouchableOpacityProps & {
+        event: GestureResponderEvent;
+    }) | any) => void;
+    onPressIn?: (props?: TouchableOpacityProps | GestureResponderEvent | any) => void | RNTouchableOpacityProps['onPressIn'];
+    onPressOut?: (props?: TouchableOpacityProps | GestureResponderEvent | any) => void | RNTouchableOpacityProps['onPressOut'];
+    onLongPress?: (props?: (TouchableOpacityProps & {
+        event: GestureResponderEvent;
+    }) | any) => void | RNTouchableOpacityProps['onLongPress'];
+    nativeID?: string;
+}
+declare const _default: React.ForwardRefExoticComponent<TouchableOpacityProps & React.RefAttributes<any>>;
+export default _default;

package/src/components/view/View.driver.new.d.ts

@@ -0,0 +1,7 @@
+import { ComponentProps } from '../../testkit/new/Component.driver';
+export declare const ViewDriver: (props: ComponentProps) => {
+    getStyle: (flatten?: boolean) => any;
+    getElement: () => import("react-test-renderer").ReactTestInstance;
+    queryElement: () => import("react-test-renderer").ReactTestInstance | undefined;
+    exists: () => boolean;
+};

package/src/components/view/index.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import { View as RNView, Animated, ViewProps as RNViewProps, type StyleProp, type ViewStyle, type DimensionValue } from 'react-native';
+import type { AnimateProps as RNReanimatedProps } from 'react-native-reanimated';
+import { ContainerModifiers } from '../../commons/new';
+import type { RecorderProps } from '../../typings/recorderTypes';
+/**
+ * Extra props when using reanimated (only non experimental props)
+ */
+type ReanimatedProps = Partial<Pick<RNReanimatedProps<object>, 'entering' | 'exiting' | 'layout'>>;
+export interface ViewProps extends Omit<RNViewProps, 'style'>, ReanimatedProps, ContainerModifiers, RecorderProps {
+    /**
+     * If true, will render as SafeAreaView
+     */
+    useSafeArea?: boolean;
+    /**
+     * Use Animate.View as a container
+     */
+    animated?: boolean;
+    /**
+     * Use Animate.View (from react-native-reanimated) as a container
+     */
+    reanimated?: boolean;
+    /**
+     * Turn off accessibility for this view and its nested children
+     */
+    inaccessible?: boolean;
+    /**
+     * TODO: probably isn't needed
+     */
+    width?: DimensionValue;
+    /**
+     * TODO: probably isn't needed
+     */
+    height?: DimensionValue;
+    /**
+     * Experimental: Pass time in ms to delay render
+     */
+    renderDelay?: number;
+    /**
+     * Set background color
+     */
+    backgroundColor?: string;
+    style?: StyleProp<ViewStyle | Animated.AnimatedProps<ViewStyle>>;
+}
+declare const _default: React.ForwardRefExoticComponent<ViewProps & React.RefAttributes<RNView>>;
+export default _default;

package/src/components/wizard/WizardStates.d.ts

@@ -0,0 +1,2 @@
+import { WizardStepsConfig } from './types';
+export declare const StatesConfig: WizardStepsConfig;

package/src/components/wizard/WizardStep.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { WizardStepProps } from './types';
+declare const _default: React.ForwardRefExoticComponent<WizardStepProps & React.RefAttributes<any>>;
+export default _default;

package/src/components/wizard/index.d.ts

@@ -0,0 +1,31 @@
+import React, { Component } from 'react';
+import WizardStep from './WizardStep';
+import { WizardProps, WizardStepProps, WizardStepStates, WizardStepConfig, WizardStepsConfig } from './types';
+export { WizardProps, WizardStepProps, WizardStepStates, WizardStepConfig, WizardStepsConfig };
+interface State {
+    maxWidth: number;
+}
+/**
+ * @description: Wizard Component: a wizard presents a series of steps in  prescribed order
+ * that the user needs to complete in order to accomplish a goal (e.g. purchase a product).
+ *
+ * @example: https://github.com/wix/react-native-ui-lib/blob/master/demo/src/screens/componentScreens/WizardScreen.tsx
+ * @notes: Use Wizard with nested Wizard.Step(s) to achieve the desired result.
+ * @gif: https://github.com/wix/react-native-ui-lib/blob/master/demo/showcase/Wizard/Wizard.gif?raw=true
+ * @image: https://github.com/wix/react-native-ui-lib/blob/master/demo/showcase/Wizard/WizardPresets.png?raw=true
+ */
+declare class Wizard extends Component<WizardProps, State> {
+    static displayName: string;
+    static Step: typeof WizardStep;
+    static States: typeof WizardStepStates;
+    private dimensionsChangeListener;
+    constructor(props: WizardProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    onOrientationChange: () => void;
+    getMaxWidth(): number;
+    renderChildren(): React.DetailedReactHTMLElement<any, HTMLElement>[] | null | undefined;
+    render(): React.JSX.Element;
+}
+declare const _default: React.ForwardRefExoticComponent<WizardProps & React.RefAttributes<any>> & typeof Wizard;
+export default _default;

package/src/components/wizard/types.d.ts

@@ -0,0 +1,90 @@
+/// <reference types="react" />
+import { ImageProps } from '../image';
+import { StyleProp, TextStyle, ViewStyle } from 'react-native';
+export declare enum WizardStepStates {
+    ENABLED = "enabled",
+    DISABLED = "disabled",
+    ERROR = "error",
+    SKIPPED = "skipped",
+    COMPLETED = "completed"
+}
+export interface WizardStepProps {
+    /**
+     * The state of the step (Wizard.States.X)
+     */
+    state: WizardStepStates | `${WizardStepStates}`;
+    /**
+     * The label of the item
+     */
+    label?: string;
+    /**
+     * Additional styles for the label
+     */
+    labelStyle?: StyleProp<TextStyle>;
+    /**
+     * Additional styles for the connector
+     */
+    connectorStyle?: StyleProp<ViewStyle>;
+    /**
+     * Color of the step index (or of the icon, when provided)
+     */
+    color?: string;
+    /**
+     * Color of the circle
+     */
+    circleColor?: string;
+    /**
+     * The step's circle size (diameter)
+     */
+    circleSize?: number;
+    /**
+     * Circle's background color
+     */
+    circleBackgroundColor?: string;
+    /**
+     * Icon to replace the (default) index
+     */
+    icon?: ImageProps['source'];
+    /**
+     * Additional styles for the index's label (when icon is not provided)
+     */
+    indexLabelStyle?: StyleProp<TextStyle>;
+    /**
+     * Whether the step should be enabled
+     */
+    enabled?: boolean;
+    /**
+     * Extra text to be read in accessibility mode
+     */
+    accessibilityInfo?: string;
+}
+export type WizardStepConfig = Omit<WizardStepProps, 'state'>;
+export interface WizardStepsConfig {
+    enabled?: WizardStepConfig;
+    disabled?: WizardStepConfig;
+    error?: WizardStepConfig;
+    skipped?: WizardStepConfig;
+    completed?: WizardStepConfig;
+    active?: WizardStepConfig;
+}
+export interface WizardProps {
+    /**
+     * The active step's index
+     */
+    activeIndex: number;
+    /**
+     * The configuration of the active step (see Wizard.Step.propTypes)
+     */
+    activeConfig?: WizardStepProps;
+    /**
+     * Callback that is called when the active step is changed (i.e. a step was clicked on).
+     * The new activeIndex will be the input of the callback.
+     */
+    onActiveIndexChanged?: (index: number) => void;
+    /**
+     * Add or override style of the container
+     */
+    containerStyle?: StyleProp<ViewStyle>;
+    testID?: string;
+    children?: React.ReactNode;
+}

package/src/helpers/AvatarHelper.d.ts

@@ -0,0 +1,9 @@
+export declare function getInitialsTypography(size: number): import("react-native/types").TextStyle | undefined;
+export declare function hashStringToNumber(str?: string): number;
+export declare function getAvatarColors(): string[];
+export declare function getColorById(id: string, avatarColors?: string[]): string;
+export declare function getInitials(name?: string, limit?: number): string;
+export declare function getBackgroundColor(name?: string, avatarColors?: string[], hashFunction?: (name?: string) => number, defaultColor?: string): string | undefined;
+export declare function isGravatarUrl(url: string): boolean;
+export declare function isBlankGravatarUrl(url: string): boolean;
+export declare function patchGravatarUrl(gravatarUrl: string): string;

package/src/helpers/FormattingPresenter.d.ts

@@ -0,0 +1,6 @@
+interface Options {
+    shouldAddPlus?: boolean;
+    maxPlusLimit?: number;
+}
+export declare function formatLastItemLabel(label: string | number | undefined, options: Options): string | undefined;
+export {};

package/src/helpers/Profiler.d.ts

@@ -0,0 +1,22 @@
+import React, { ProfilerProps as RProfilerProps, PropsWithChildren } from 'react';
+export type ProfilerProps = Pick<RProfilerProps, 'id'>;
+export default class Profiler extends React.Component<PropsWithChildren<ProfilerProps>> {
+    onRender: (...profileData: any[]) => void;
+    render(): React.JSX.Element;
+}
+export declare const getProfileData: ([id, phase, actualDuration, baseDuration, startTime, commitTime, interactions]: [any, any, any, any, any, any, any]) => {
+    id: any;
+    interactions: any;
+    phase: any;
+    actualDuration: number;
+    baseDuration: number;
+    commitTime: number;
+    cumulativeDuration: string;
+    startTime: number;
+};
+export declare const logProfileData: ({ id, actualDuration, cumulativeDuration, phase }: {
+    id: any;
+    actualDuration: any;
+    cumulativeDuration: any;
+    phase: any;
+}) => void;

package/src/helpers/index.d.ts

@@ -0,0 +1,3 @@
+import * as AvatarHelper from './AvatarHelper';
+import Profiler from './Profiler';
+export { AvatarHelper, Profiler };

package/src/hooks/index.d.ts

@@ -0,0 +1,14 @@
+export { default as useCombinedRefs } from './useCombinedRefs';
+export { default as useToggleValue } from './useToggleValue';
+export { default as useDidUpdate } from './useDidUpdate';
+export { default as useMeasure } from './useMeasure';
+export { default as useModifiers } from './useModifiers';
+export { default as useOrientation } from './useOrientation';
+export { default as useScrollEnabler } from './useScrollEnabler';
+export { default as useScrollReached } from './useScrollReached';
+export { default as useScrollToItem } from './useScrollToItem';
+export { default as useScrollTo } from './useScrollTo';
+export { default as useThemeProps } from './useThemeProps';
+export { default as useDebounce } from './useDebounce';
+export { default as useKeyboardHeight } from './useKeyboardHeight';
+export * from './useScrollTo';

package/src/hooks/useCombinedRefs/index.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const useCombinedRefs: <T>(...refs: React.Ref<any>[]) => T;
+export default useCombinedRefs;

package/src/hooks/useDebounce/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This hook is used to debounce a function call
+ */
+declare function useDebounce<A>(func: (args: A) => void, timeout?: number): (args: A) => void;
+export default useDebounce;

package/src/hooks/useDidUpdate/index.d.ts

@@ -0,0 +1,6 @@
+import { DependencyList } from 'react';
+/**
+ * This hook avoid calling useEffect on the initial value of his dependency array
+ */
+declare const useDidUpdate: (callback: () => void, dep: DependencyList) => void;
+export default useDidUpdate;

package/src/hooks/useHiddenLocation/index.d.ts

@@ -0,0 +1,13 @@
+import { RefCallback } from 'react';
+import { View, LayoutChangeEvent } from 'react-native';
+import { PanningDirectionsEnum } from '../../components/panView';
+type HiddenLocationRecord = Record<PanningDirectionsEnum, number>;
+export interface HiddenLocation extends HiddenLocationRecord {
+    wasMeasured: boolean;
+}
+export default function useHiddenLocation<T extends View>(): {
+    setRef: RefCallback<T>;
+    onLayout: (event: LayoutChangeEvent) => void;
+    hiddenLocation: HiddenLocation;
+};
+export {};

package/src/hooks/useHiddenLocation/index.web.d.ts

@@ -0,0 +1,13 @@
+import { RefCallback } from 'react';
+import { View, LayoutChangeEvent } from 'react-native';
+import { PanningDirectionsEnum } from '../../components/panView';
+type HiddenLocationRecord = Record<PanningDirectionsEnum, number>;
+export interface HiddenLocation extends HiddenLocationRecord {
+    wasMeasured: boolean;
+}
+export default function useHiddenLocation<T extends View>(): {
+    setRef: RefCallback<T>;
+    onLayout: (event: LayoutChangeEvent) => void;
+    hiddenLocation: HiddenLocation;
+};
+export {};

package/src/hooks/useKeyboardHeight/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hook that tracks keyboard height and provides real-time updates
+ */
+declare const useKeyboardHeight: () => number;
+export default useKeyboardHeight;

package/src/hooks/useMeasure/index.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { View as RNView } from 'react-native';
+interface Measurements {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    pageX: number;
+    pageY: number;
+}
+declare const _default: () => {
+    ref: import("react").MutableRefObject<RNView | undefined>;
+    measurements: Measurements | undefined;
+};
+export default _default;

package/src/hooks/useModifiers/index.d.ts

@@ -0,0 +1,3 @@
+import * as Modifiers from '../../commons/modifiers';
+declare const useModifiers: (props: any, options: Modifiers.ModifiersOptions) => Modifiers.ExtractedStyle;
+export default useModifiers;

package/src/hooks/useOrientation/index.d.ts

@@ -0,0 +1,7 @@
+interface UseOrientationProps {
+    onOrientationChange?: Function;
+}
+declare const useOrientation: ({ onOrientationChange }?: UseOrientationProps) => {
+    orientation: import("../../commons/Constants").orientations;
+};
+export default useOrientation;

package/src/hooks/useScrollEnabler/index.d.ts

@@ -0,0 +1,23 @@
+import { LayoutChangeEvent } from 'react-native';
+export type ScrollEnablerProps = {
+    /**
+     * Whether the scroll is horizontal (default is false).
+     */
+    horizontal?: boolean;
+};
+export type ScrollEnablerResultProps = {
+    /**
+     * onContentSizeChange callback (should be set to your onContentSizeChange).
+     */
+    onContentSizeChange: (contentWidth: number, contentHeight: number) => void;
+    /**
+     * onLayout callback (should be set to your onLayout).
+     */
+    onLayout: (event: LayoutChangeEvent) => void;
+    /**
+     * Whether the scroll should be enabled (should be set to your scrollEnabled).
+     */
+    scrollEnabled: boolean;
+};
+declare const useScrollEnabler: (props?: ScrollEnablerProps) => ScrollEnablerResultProps;
+export default useScrollEnabler;

package/src/hooks/useScrollReached/index.d.ts

@@ -0,0 +1,28 @@
+import { NativeSyntheticEvent, NativeScrollEvent } from 'react-native';
+export type ScrollEnablerProps = {
+    /**
+     * Whether the scroll is horizontal (default is false).
+     */
+    horizontal?: boolean;
+    /**
+     * Allows to be notified prior to actually reaching the start \ end of the scroll (by the threshold).
+     * Should be a positive value.
+     */
+    threshold?: number;
+};
+export type ScrollEnablerResultProps = {
+    /**
+     * onScroll callback (should be set to your onScroll).
+     */
+    onScroll: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    /**
+     * Is the scroll at the start (or equal\smaller than the threshold if one was given)
+     */
+    isScrollAtStart?: boolean;
+    /**
+     * Is the scroll at the end (or equal\greater than the threshold if one was given)
+     */
+    isScrollAtEnd?: boolean;
+};
+declare const useScrollReached: (props?: ScrollEnablerProps) => ScrollEnablerResultProps;
+export default useScrollReached;