@estuary-solutions/rn-core-ui 0.0.3

package/dist/constants/consts.js

@@ -0,0 +1,15 @@
+export const FORMAT_TIME_DMY_ = 'DD/MM/YYYY';
+export const FORMAT_TIME_DMY = 'DD-MM-YYYY';
+export const FORMAT_TIME = 'YYYY-MM-DD HH:mm';
+export const FORMAT_TIME_DMYHMS = 'DD/MM/YYYY HH:mm:ss';
+export const FORMAT_TIME_DMYHM = 'DD/MM/YYYY HH:mm';
+export const FORMAT_TIME_VH = 'MMMM DD, YYYY HH:mm';
+export const FORMAT_TIME_DDMMM = 'DD MMM';
+export const FORMAT_TIME_YMD = 'YYYY-MM-DD';
+export const FORMAT_TIME_FILTER = 'DD/MM/YY';
+export const FORMAT_TIME_L = 'L';
+export const FORMAT_TIME_LL = 'LL';
+export const FORMAT_TIME_LLL = 'LLL';
+export const FORMAT_TIME_LLLL = 'LLLL';
+export const FORMAT_TIME_LT = 'LT';
+export const FORMAT_TIME_LTS = 'LTS';

package/dist/constants/index.d.ts

@@ -0,0 +1,3 @@
+export * from './consts';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/constants/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/constants/index.js

@@ -0,0 +1,2 @@
+export * from './consts';
+export * from './types';

package/dist/constants/types.d.ts

@@ -0,0 +1,22 @@
+export declare const MIME_TYPES: {
+    csv: string;
+    doc: string;
+    docx: string;
+    jpeg: string;
+    jpg: string;
+    mp4: string;
+    pdf: string;
+    png: string;
+    ppt: string;
+    pptx: string;
+    webm: string;
+    xls: string;
+    xlsx: string;
+};
+export declare const FILE_TYPE: {
+    empty: number;
+    pdf: number;
+    video: number;
+    other: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/constants/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/constants/types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;CActB,CAAC;AAEF,eAAO,MAAM,SAAS;;;;;CAKrB,CAAC"}

package/dist/constants/types.js

@@ -0,0 +1,21 @@
+export const MIME_TYPES = {
+    csv: 'text/csv',
+    doc: 'application/msword',
+    docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    jpeg: 'image/jpeg',
+    jpg: 'image/jpeg',
+    mp4: 'video/mp4',
+    pdf: 'application/pdf',
+    png: 'image/png',
+    ppt: 'application/vnd.ms-powerpoint',
+    pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    webm: 'video/webm',
+    xls: 'application/vnd.ms-excel',
+    xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+};
+export const FILE_TYPE = {
+    empty: -1,
+    pdf: 1,
+    video: 2,
+    other: 3,
+};

package/dist/context/DraggableFlatList/animatedValueContext.d.ts

@@ -0,0 +1,29 @@
+import React from "react";
+import { State as GestureState } from "react-native-gesture-handler";
+export default function AnimatedValueProvider({ children, }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useAnimatedValues(): {
+    activeCellOffset: import("react-native-reanimated").SharedValue<number>;
+    activeCellSize: import("react-native-reanimated").SharedValue<number>;
+    activeIndexAnim: import("react-native-reanimated").SharedValue<number>;
+    containerSize: import("react-native-reanimated").SharedValue<number>;
+    disabled: import("react-native-reanimated").SharedValue<boolean>;
+    horizontalAnim: import("react-native-reanimated").SharedValue<boolean>;
+    hoverAnim: import("react-native-reanimated").DerivedValue<number>;
+    hoverOffset: import("react-native-reanimated").DerivedValue<number>;
+    isDraggingCell: import("react-native-reanimated").DerivedValue<boolean>;
+    isTouchActiveNative: import("react-native-reanimated").SharedValue<boolean>;
+    panGestureState: import("react-native-reanimated").SharedValue<GestureState>;
+    placeholderOffset: import("react-native-reanimated").SharedValue<number>;
+    resetTouchedCell: () => void;
+    scrollOffset: import("react-native-reanimated").SharedValue<number>;
+    scrollViewSize: import("react-native-reanimated").SharedValue<number>;
+    spacerIndexAnim: import("react-native-reanimated").SharedValue<number>;
+    touchPositionDiff: import("react-native-reanimated").DerivedValue<number>;
+    touchTranslate: import("react-native-reanimated").SharedValue<number>;
+    autoScrollDistance: import("react-native-reanimated").DerivedValue<number>;
+    viewableIndexMin: import("react-native-reanimated").SharedValue<number>;
+    viewableIndexMax: import("react-native-reanimated").SharedValue<number>;
+};
+//# sourceMappingURL=animatedValueContext.d.ts.map

package/dist/context/DraggableFlatList/animatedValueContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animatedValueContext.d.ts","sourceRoot":"","sources":["../../../src/context/DraggableFlatList/animatedValueContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAM1B,OAAO,EAAE,KAAK,IAAI,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAQrE,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAAC,EAC5C,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,2CAOA;AAED,wBAAgB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;EAQhC"}

package/dist/context/DraggableFlatList/animatedValueContext.js

@@ -0,0 +1,154 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { useAnimatedReaction, useDerivedValue, useSharedValue, } from "react-native-reanimated";
+import { State as GestureState } from "react-native-gesture-handler";
+import { useProps } from "./propsContext";
+const AnimatedValueContext = React.createContext(undefined);
+export default function AnimatedValueProvider({ children, }) {
+    const value = useSetupAnimatedValues();
+    return (_jsx(AnimatedValueContext.Provider, { value: value, children: children }));
+}
+export function useAnimatedValues() {
+    const value = React.useContext(AnimatedValueContext);
+    if (!value) {
+        throw new Error("useAnimatedValues must be called from within AnimatedValueProvider!");
+    }
+    return value;
+}
+function useSetupAnimatedValues() {
+    const props = useProps();
+    const DEFAULT_VAL = useSharedValue(0);
+    const containerSize = useSharedValue(0);
+    const scrollViewSize = useSharedValue(0);
+    const panGestureState = useSharedValue(GestureState.UNDETERMINED);
+    const touchTranslate = useSharedValue(0);
+    const isTouchActiveNative = useSharedValue(false);
+    const hasMoved = useSharedValue(0);
+    const disabled = useSharedValue(false);
+    const horizontalAnim = useSharedValue(!!props.horizontal);
+    const activeIndexAnim = useSharedValue(-1); // Index of hovering cell
+    const spacerIndexAnim = useSharedValue(-1); // Index of hovered-over cell
+    const activeCellSize = useSharedValue(0); // Height or width of acctive cell
+    const activeCellOffset = useSharedValue(0); // Distance between active cell and edge of container
+    const scrollOffset = useSharedValue(0);
+    const scrollInit = useSharedValue(0);
+    const viewableIndexMin = useSharedValue(0);
+    const viewableIndexMax = useSharedValue(0);
+    // If list is nested there may be an outer scrollview
+    const outerScrollOffset = props.outerScrollOffset || DEFAULT_VAL;
+    const outerScrollInit = useSharedValue(0);
+    useAnimatedReaction(() => {
+        return activeIndexAnim.value;
+    }, (cur, prev) => {
+        if (cur !== prev && cur >= 0) {
+            scrollInit.value = scrollOffset.value;
+            outerScrollInit.value = outerScrollOffset.value;
+        }
+    }, [outerScrollOffset]);
+    const placeholderOffset = useSharedValue(0);
+    const isDraggingCell = useDerivedValue(() => {
+        return isTouchActiveNative.value && activeIndexAnim.value >= 0;
+    }, []);
+    const autoScrollDistance = useDerivedValue(() => {
+        if (!isDraggingCell.value)
+            return 0;
+        const innerScrollDiff = scrollOffset.value - scrollInit.value;
+        // If list is nested there may be an outer scroll diff
+        const outerScrollDiff = outerScrollOffset.value - outerScrollInit.value;
+        const scrollDiff = innerScrollDiff + outerScrollDiff;
+        return scrollDiff;
+    }, []);
+    const touchPositionDiff = useDerivedValue(() => {
+        const extraTranslate = isTouchActiveNative.value
+            ? autoScrollDistance.value
+            : 0;
+        return touchTranslate.value + extraTranslate;
+    }, []);
+    const touchPositionDiffConstrained = useDerivedValue(() => {
+        const containerMinusActiveCell = containerSize.value - activeCellSize.value + scrollOffset.value;
+        const offsetRelativeToScrollTop = touchPositionDiff.value + activeCellOffset.value;
+        const constrained = Math.min(containerMinusActiveCell, Math.max(scrollOffset.value, offsetRelativeToScrollTop));
+        const maxTranslateNegative = -activeCellOffset.value;
+        const maxTranslatePositive = scrollViewSize.value - (activeCellOffset.value + activeCellSize.value);
+        // Only constrain the touch position while the finger is on the screen. This allows the active cell
+        // to snap above/below the fold once let go, if the drag ends at the top/bottom of the screen.
+        const constrainedBase = isTouchActiveNative.value
+            ? constrained - activeCellOffset.value
+            : touchPositionDiff.value;
+        // Make sure item is constrained to the boundaries of the scrollview
+        return Math.min(Math.max(constrainedBase, maxTranslateNegative), maxTranslatePositive);
+    }, []);
+    const dragItemOverflow = props.dragItemOverflow;
+    const hoverAnim = useDerivedValue(() => {
+        if (activeIndexAnim.value < 0)
+            return 0;
+        return dragItemOverflow
+            ? touchPositionDiff.value
+            : touchPositionDiffConstrained.value;
+    }, []);
+    const hoverOffset = useDerivedValue(() => {
+        return hoverAnim.value + activeCellOffset.value;
+    }, [hoverAnim, activeCellOffset]);
+    useDerivedValue(() => {
+        // Reset spacer index when we stop hovering
+        const isHovering = activeIndexAnim.value >= 0;
+        if (!isHovering && spacerIndexAnim.value >= 0) {
+            spacerIndexAnim.value = -1;
+        }
+    }, []);
+    // Note: this could use a refactor as it combines touch state + cell animation
+    const resetTouchedCell = React.useCallback(() => {
+        activeCellOffset.value = 0;
+        hasMoved.value = 0;
+    }, []);
+    const value = React.useMemo(() => ({
+        activeCellOffset,
+        activeCellSize,
+        activeIndexAnim,
+        containerSize,
+        disabled,
+        horizontalAnim,
+        hoverAnim,
+        hoverOffset,
+        isDraggingCell,
+        isTouchActiveNative,
+        panGestureState,
+        placeholderOffset,
+        resetTouchedCell,
+        scrollOffset,
+        scrollViewSize,
+        spacerIndexAnim,
+        touchPositionDiff,
+        touchTranslate,
+        autoScrollDistance,
+        viewableIndexMin,
+        viewableIndexMax,
+    }), [
+        activeCellOffset,
+        activeCellSize,
+        activeIndexAnim,
+        containerSize,
+        disabled,
+        horizontalAnim,
+        hoverAnim,
+        hoverOffset,
+        isDraggingCell,
+        isTouchActiveNative,
+        panGestureState,
+        placeholderOffset,
+        resetTouchedCell,
+        scrollOffset,
+        scrollViewSize,
+        spacerIndexAnim,
+        touchPositionDiff,
+        touchTranslate,
+        autoScrollDistance,
+        viewableIndexMin,
+        viewableIndexMax,
+    ]);
+    React.useEffect(() => {
+        var _a;
+        (_a = props.onAnimValInit) === null || _a === void 0 ? void 0 : _a.call(props, value);
+    }, [value]);
+    return value;
+}

package/dist/context/DraggableFlatList/cellContext.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+type Props = {
+    isActive: boolean;
+    children: React.ReactNode;
+};
+export declare function CellProvider({ isActive, children }: Props): import("react/jsx-runtime").JSX.Element;
+declare const _default: typeof CellProvider;
+export default _default;
+export declare function useIsActive(): boolean;
+//# sourceMappingURL=cellContext.d.ts.map

package/dist/context/DraggableFlatList/cellContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cellContext.d.ts","sourceRoot":"","sources":["../../../src/context/DraggableFlatList/cellContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAY1B,KAAK,KAAK,GAAG;IACX,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CAAC;AAEF,wBAAgB,YAAY,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,KAAK,2CAQzD;;AAED,wBAAuC;AAEvC,wBAAgB,WAAW,YAM1B"}

package/dist/context/DraggableFlatList/cellContext.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { typedMemo } from "../../utils/DraggableFlatList/typedMemo";
+const CellContext = React.createContext(undefined);
+export function CellProvider({ isActive, children }) {
+    const value = React.useMemo(() => ({
+        isActive,
+    }), [isActive]);
+    return _jsx(CellContext.Provider, { value: value, children: children });
+}
+export default typedMemo(CellProvider);
+export function useIsActive() {
+    const value = React.useContext(CellContext);
+    if (!value) {
+        throw new Error("useIsActive must be called from within CellProvider!");
+    }
+    return value.isActive;
+}

package/dist/context/DraggableFlatList/draggableFlatListContext.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+type Props<T> = {
+    activeKey: string | null;
+    keyExtractor: (item: T, index: number) => string;
+    horizontal: boolean;
+    layoutAnimationDisabled: boolean;
+    children: React.ReactNode;
+};
+type DraggableFlatListContextValue<T> = Omit<Props<T>, "children">;
+export default function DraggableFlatListProvider<T>({ activeKey, keyExtractor, horizontal, layoutAnimationDisabled, children, }: Props<T>): import("react/jsx-runtime").JSX.Element;
+export declare function useDraggableFlatListContext<T>(): DraggableFlatListContextValue<T>;
+export {};
+//# sourceMappingURL=draggableFlatListContext.d.ts.map

package/dist/context/DraggableFlatList/draggableFlatListContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draggableFlatListContext.d.ts","sourceRoot":"","sources":["../../../src/context/DraggableFlatList/draggableFlatListContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,KAAK,KAAK,CAAC,CAAC,IAAI;IACd,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,YAAY,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACjD,UAAU,EAAE,OAAO,CAAC;IACpB,uBAAuB,EAAE,OAAO,CAAC;IACjC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CAAC;AAEF,KAAK,6BAA6B,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;AAMnE,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAAC,CAAC,EAAE,EACnD,SAAS,EACT,YAAY,EACZ,UAAU,EACV,uBAAuB,EACvB,QAAQ,GACT,EAAE,KAAK,CAAC,CAAC,CAAC,2CAgBV;AAED,wBAAgB,2BAA2B,CAAC,CAAC,KAO3B,6BAA6B,CAAC,CAAC,CAAC,CACjD"}

package/dist/context/DraggableFlatList/draggableFlatListContext.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+const DraggableFlatListContext = React.createContext(undefined);
+export default function DraggableFlatListProvider({ activeKey, keyExtractor, horizontal, layoutAnimationDisabled, children, }) {
+    const value = React.useMemo(() => ({
+        activeKey,
+        keyExtractor,
+        horizontal,
+        layoutAnimationDisabled,
+    }), [activeKey, keyExtractor, horizontal, layoutAnimationDisabled]);
+    return (_jsx(DraggableFlatListContext.Provider, { value: value, children: children }));
+}
+export function useDraggableFlatListContext() {
+    const value = React.useContext(DraggableFlatListContext);
+    if (!value) {
+        throw new Error("useDraggableFlatListContext must be called within DraggableFlatListProvider");
+    }
+    return value;
+}

package/dist/context/DraggableFlatList/nestableScrollContainerContext.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import { ScrollView } from "react-native-gesture-handler";
+export declare function NestableScrollContainerProvider({ children, forwardedRef, }: {
+    children: React.ReactNode;
+    forwardedRef?: React.MutableRefObject<ScrollView>;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useNestableScrollContainerContext(): {
+    outerScrollEnabled: boolean;
+    setOuterScrollEnabled: React.Dispatch<React.SetStateAction<boolean>>;
+    outerScrollOffset: import("react-native-reanimated").SharedValue<number>;
+    scrollViewSize: import("react-native-reanimated").SharedValue<number>;
+    scrollableRef: React.RefObject<ScrollView>;
+    containerSize: import("react-native-reanimated").SharedValue<number>;
+} | undefined;
+export declare function useSafeNestableScrollContainerContext(): {
+    outerScrollEnabled: boolean;
+    setOuterScrollEnabled: React.Dispatch<React.SetStateAction<boolean>>;
+    outerScrollOffset: import("react-native-reanimated").SharedValue<number>;
+    scrollViewSize: import("react-native-reanimated").SharedValue<number>;
+    scrollableRef: React.RefObject<ScrollView>;
+    containerSize: import("react-native-reanimated").SharedValue<number>;
+};
+//# sourceMappingURL=nestableScrollContainerContext.d.ts.map

package/dist/context/DraggableFlatList/nestableScrollContainerContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestableScrollContainerContext.d.ts","sourceRoot":"","sources":["../../../src/context/DraggableFlatList/nestableScrollContainerContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAqC1D,wBAAgB,+BAA+B,CAAC,EAC9C,QAAQ,EACR,YAAY,GACb,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,YAAY,CAAC,EAAE,KAAK,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;CACnD,2CAOA;AAED,wBAAgB,iCAAiC;;;;;;;cAGhD;AAED,wBAAgB,qCAAqC;;;;;;;EAQpD"}

package/dist/context/DraggableFlatList/nestableScrollContainerContext.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { useSharedValue } from "react-native-reanimated";
+const NestableScrollContainerContext = React.createContext(undefined);
+function useSetupNestableScrollContextValue({ forwardedRef, }) {
+    const [outerScrollEnabled, setOuterScrollEnabled] = React.useState(true);
+    const scrollViewSize = useSharedValue(0);
+    const scrollableRefInner = React.useRef(null);
+    const scrollableRef = forwardedRef || scrollableRefInner;
+    const outerScrollOffset = useSharedValue(0);
+    const containerSize = useSharedValue(0);
+    const contextVal = React.useMemo(() => ({
+        outerScrollEnabled,
+        setOuterScrollEnabled,
+        outerScrollOffset,
+        scrollViewSize,
+        scrollableRef,
+        containerSize,
+    }), [outerScrollEnabled]);
+    return contextVal;
+}
+export function NestableScrollContainerProvider({ children, forwardedRef, }) {
+    const contextVal = useSetupNestableScrollContextValue({ forwardedRef });
+    return (_jsx(NestableScrollContainerContext.Provider, { value: contextVal, children: children }));
+}
+export function useNestableScrollContainerContext() {
+    const value = React.useContext(NestableScrollContainerContext);
+    return value;
+}
+export function useSafeNestableScrollContainerContext() {
+    const value = useNestableScrollContainerContext();
+    if (!value) {
+        throw new Error("useSafeNestableScrollContainerContext must be called within a NestableScrollContainerContext.Provider");
+    }
+    return value;
+}

package/dist/context/DraggableFlatList/propsContext.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { DraggableFlatListProps } from "../../constants/DraggableFlatList/types";
+type Props<T> = DraggableFlatListProps<T> & {
+    children: React.ReactNode;
+};
+export default function PropsProvider<T>({ children, ...props }: Props<T>): import("react/jsx-runtime").JSX.Element;
+export declare function useProps<T>(): DraggableFlatListProps<T>;
+export {};
+//# sourceMappingURL=propsContext.d.ts.map

package/dist/context/DraggableFlatList/propsContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propsContext.d.ts","sourceRoot":"","sources":["../../../src/context/DraggableFlatList/propsContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAM3E,KAAK,KAAK,CAAC,CAAC,IAAI,sBAAsB,CAAC,CAAC,CAAC,GAAG;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,CAAC;AAE1E,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,KAAK,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC,2CAIxE;AAED,wBAAgB,QAAQ,CAAC,CAAC,+BAQzB"}

package/dist/context/DraggableFlatList/propsContext.js

@@ -0,0 +1,25 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+const PropsContext = React.createContext(undefined);
+export default function PropsProvider(_a) {
+    var { children } = _a, props = __rest(_a, ["children"]);
+    return (_jsx(PropsContext.Provider, { value: props, children: children }));
+}
+export function useProps() {
+    const value = React.useContext(PropsContext);
+    if (!value) {
+        throw new Error("useProps must be called from within PropsProvider!");
+    }
+    return value;
+}

package/dist/context/DraggableFlatList/refContext.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import { FlatList } from "react-native-gesture-handler";
+import Animated, { type SharedValue, WithSpringConfig } from "react-native-reanimated";
+import { CellData, DraggableFlatListProps } from "../../constants/DraggableFlatList/types";
+type RefContextValue<T> = {
+    propsRef: React.MutableRefObject<DraggableFlatListProps<T>>;
+    animationConfigRef: SharedValue<WithSpringConfig>;
+    cellDataRef: React.MutableRefObject<Map<string, CellData>>;
+    keyToIndexRef: React.MutableRefObject<Map<string, number>>;
+    containerRef: React.RefObject<Animated.View>;
+    flatlistRef: React.RefObject<FlatList<T>> | React.ForwardedRef<FlatList<T>>;
+    scrollViewRef: React.RefObject<Animated.ScrollView>;
+};
+export default function RefProvider<T>({ children, flatListRef, }: {
+    children: React.ReactNode;
+    flatListRef?: React.ForwardedRef<FlatList<T>> | null;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useRefs<T>(): RefContextValue<T>;
+export {};
+//# sourceMappingURL=refContext.d.ts.map

package/dist/context/DraggableFlatList/refContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refContext.d.ts","sourceRoot":"","sources":["../../../src/context/DraggableFlatList/refContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACxD,OAAO,QAAQ,EAAE,EACf,KAAK,WAAW,EAEhB,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,QAAQ,EACR,sBAAsB,EACvB,MAAM,mCAAmC,CAAC;AAI3C,KAAK,eAAe,CAAC,CAAC,IAAI;IACxB,QAAQ,EAAE,KAAK,CAAC,gBAAgB,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5D,kBAAkB,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC;IAClD,WAAW,EAAE,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC3D,aAAa,EAAE,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3D,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC7C,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5E,aAAa,EAAE,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;CACrD,CAAC;AAKF,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,CAAC,EAAE,EACrC,QAAQ,EACR,WAAW,GACZ,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,WAAW,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;CACtD,2CAGA;AAED,wBAAgB,OAAO,CAAC,CAAC,KAOP,eAAe,CAAC,CAAC,CAAC,CACnC"}

package/dist/context/DraggableFlatList/refContext.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { useSharedValue, } from "react-native-reanimated";
+import { DEFAULT_PROPS } from "../../constants/DraggableFlatList/constants";
+import { useProps } from "./propsContext";
+const RefContext = React.createContext(undefined);
+export default function RefProvider({ children, flatListRef, }) {
+    const value = useSetupRefs({ flatListRef });
+    return _jsx(RefContext.Provider, { value: value, children: children });
+}
+export function useRefs() {
+    const value = React.useContext(RefContext);
+    if (!value) {
+        throw new Error("useRefs must be called from within a RefContext.Provider!");
+    }
+    return value;
+}
+function useSetupRefs({ flatListRef: flatListRefProp, }) {
+    const props = useProps();
+    const { animationConfig = DEFAULT_PROPS.animationConfig } = props;
+    const propsRef = React.useRef(props);
+    propsRef.current = props;
+    const animConfig = React.useMemo(() => (Object.assign(Object.assign({}, DEFAULT_PROPS.animationConfig), animationConfig)), [animationConfig]);
+    const animationConfigRef = useSharedValue(animConfig);
+    React.useEffect(() => {
+        animationConfigRef.value = animConfig;
+    }, [animConfig]);
+    const cellDataRef = React.useRef(new Map());
+    const keyToIndexRef = React.useRef(new Map());
+    const containerRef = React.useRef(null);
+    const flatlistRefInternal = React.useRef(null);
+    const flatlistRef = flatListRefProp || flatlistRefInternal;
+    const scrollViewRef = React.useRef(null);
+    // useEffect(() => {
+    //   // This is a workaround for the fact that RN does not respect refs passed in
+    //   // to renderScrollViewComponent underlying ScrollView (currently not used but
+    //   // may need to add if we want to use reanimated scrollTo in the future)
+    //   //@ts-ignore
+    //   const scrollRef = flatlistRef.current?.getNativeScrollRef();
+    //   if (!scrollViewRef.current) {
+    //     //@ts-ignore
+    //     scrollViewRef(scrollRef);
+    //   }
+    // }, []);
+    const refs = React.useMemo(() => ({
+        animationConfigRef,
+        cellDataRef,
+        containerRef,
+        flatlistRef,
+        keyToIndexRef,
+        propsRef,
+        scrollViewRef,
+    }), []);
+    return refs;
+}

package/dist/hooks/DraggableFlatList/useAutoScroll.d.ts

@@ -0,0 +1,2 @@
+export declare function useAutoScroll(): null;
+//# sourceMappingURL=useAutoScroll.d.ts.map

package/dist/hooks/DraggableFlatList/useAutoScroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAutoScroll.d.ts","sourceRoot":"","sources":["../../../src/hooks/DraggableFlatList/useAutoScroll.tsx"],"names":[],"mappings":"AAYA,wBAAgB,aAAa,SA2G5B"}

package/dist/hooks/DraggableFlatList/useAutoScroll.js

@@ -0,0 +1,77 @@
+import { runOnJS, useAnimatedReaction, useDerivedValue, useSharedValue, } from "react-native-reanimated";
+import { useRefs } from "../../context/DraggableFlatList/refContext";
+import { useAnimatedValues } from "../../context/DraggableFlatList/animatedValueContext";
+import { useProps } from "../../context/DraggableFlatList/propsContext";
+import { DEFAULT_PROPS, SCROLL_POSITION_TOLERANCE } from "../../constants/DraggableFlatList/constants";
+export function useAutoScroll() {
+    const { flatlistRef } = useRefs();
+    const { autoscrollThreshold = DEFAULT_PROPS.autoscrollThreshold, autoscrollSpeed = DEFAULT_PROPS.autoscrollSpeed, } = useProps();
+    const { scrollOffset, scrollViewSize, containerSize, activeCellSize, hoverOffset, activeIndexAnim, } = useAnimatedValues();
+    const hoverScreenOffset = useDerivedValue(() => {
+        return hoverOffset.value - scrollOffset.value;
+    }, []);
+    const isScrolledUp = useDerivedValue(() => {
+        return scrollOffset.value - SCROLL_POSITION_TOLERANCE <= 0;
+    }, []);
+    const isScrolledDown = useDerivedValue(() => {
+        return (scrollOffset.value + containerSize.value + SCROLL_POSITION_TOLERANCE >=
+            scrollViewSize.value);
+    }, []);
+    const distToTopEdge = useDerivedValue(() => {
+        return Math.max(0, hoverScreenOffset.value);
+    }, []);
+    const distToBottomEdge = useDerivedValue(() => {
+        const hoverPlusActiveCell = hoverScreenOffset.value + activeCellSize.value;
+        return Math.max(0, containerSize.value - hoverPlusActiveCell);
+    }, []);
+    const isAtTopEdge = useDerivedValue(() => {
+        return distToTopEdge.value <= autoscrollThreshold;
+    });
+    const isAtBottomEdge = useDerivedValue(() => {
+        return distToBottomEdge.value <= autoscrollThreshold;
+    }, []);
+    const scrollTarget = useSharedValue(0);
+    const dragIsActive = useDerivedValue(() => {
+        return activeIndexAnim.value >= 0;
+    }, []);
+    useAnimatedReaction(() => {
+        return dragIsActive.value;
+    }, (cur, prev) => {
+        if (cur && !prev) {
+            scrollTarget.value = scrollOffset.value;
+        }
+    });
+    const shouldAutoScroll = useDerivedValue(() => {
+        const scrollTargetDiff = Math.abs(scrollTarget.value - scrollOffset.value);
+        const hasScrolledToTarget = scrollTargetDiff < SCROLL_POSITION_TOLERANCE;
+        const isAtEdge = isAtTopEdge.value || isAtBottomEdge.value;
+        const topDisabled = isAtTopEdge.value && isScrolledUp.value;
+        const bottomDisabled = isAtBottomEdge.value && isScrolledDown.value;
+        const isEdgeDisabled = topDisabled || bottomDisabled;
+        const cellIsActive = activeIndexAnim.value >= 0;
+        return hasScrolledToTarget && isAtEdge && !isEdgeDisabled && cellIsActive;
+    }, []);
+    function scrollToInternal(offset) {
+        var _a;
+        if (flatlistRef && "current" in flatlistRef) {
+            (_a = flatlistRef.current) === null || _a === void 0 ? void 0 : _a.scrollToOffset({ offset, animated: true });
+        }
+    }
+    useDerivedValue(() => {
+        if (!shouldAutoScroll.value)
+            return;
+        const distFromEdge = isAtTopEdge.value
+            ? distToTopEdge.value
+            : distToBottomEdge.value;
+        const speedPct = 1 - distFromEdge / autoscrollThreshold;
+        const offset = speedPct * autoscrollSpeed;
+        const targetOffset = isAtTopEdge.value
+            ? Math.max(0, scrollOffset.value - offset)
+            : Math.min(scrollOffset.value + offset, scrollViewSize.value - containerSize.value);
+        scrollTarget.value = targetOffset;
+        // Reanimated scrollTo is crashing on android. use 'regular' scrollTo until figured out.
+        // scrollTo(scrollViewRef, targetX, targetY, true);
+        runOnJS(scrollToInternal)(targetOffset);
+    }, []);
+    return null;
+}

package/dist/hooks/DraggableFlatList/useCellTranslate.d.ts

@@ -0,0 +1,9 @@
+import Animated from "react-native-reanimated";
+type Params = {
+    cellIndex: number;
+    cellSize: Animated.SharedValue<number>;
+    cellOffset: Animated.SharedValue<number>;
+};
+export declare function useCellTranslate({ cellIndex, cellSize, cellOffset }: Params): import("react-native-reanimated").DerivedValue<number>;
+export {};
+//# sourceMappingURL=useCellTranslate.d.ts.map

package/dist/hooks/DraggableFlatList/useCellTranslate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCellTranslate.d.ts","sourceRoot":"","sources":["../../../src/hooks/DraggableFlatList/useCellTranslate.tsx"],"names":[],"mappings":"AAAA,OAAO,QAAyC,MAAM,yBAAyB,CAAC;AAMhF,KAAK,MAAM,GAAG;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,UAAU,EAAE,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;CAC1C,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,MAAM,0DAgG3E"}