@estuary-solutions/rn-core-ui 0.0.5 → 0.1.0

package/dist/constants/types.js

@@ -1,21 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,154 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,18 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,19 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,36 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,25 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,55 +0,0 @@
-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.map

@@ -1 +0,0 @@
-{"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

@@ -1,77 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}

package/dist/hooks/DraggableFlatList/useCellTranslate.js

@@ -1,72 +0,0 @@
-import { useDerivedValue, withSpring } from "react-native-reanimated";
-import { useRefs } from "../../context/DraggableFlatList/refContext";
-import { useDraggableFlatListContext } from "../../context/DraggableFlatList/draggableFlatListContext";
-import { useAnimatedValues } from "../../context/DraggableFlatList/animatedValueContext";
-export function useCellTranslate({ cellIndex, cellSize, cellOffset }) {
-    const { activeIndexAnim, activeCellSize, hoverOffset, spacerIndexAnim, placeholderOffset, hoverAnim, viewableIndexMin, viewableIndexMax, } = useAnimatedValues();
-    const { activeKey } = useDraggableFlatListContext();
-    const { animationConfigRef } = useRefs();
-    const translate = useDerivedValue(() => {
-        const isActiveCell = cellIndex === activeIndexAnim.value;
-        const isOutsideViewableRange = !isActiveCell &&
-            (cellIndex < viewableIndexMin.value ||
-                cellIndex > viewableIndexMax.value);
-        if (!activeKey || activeIndexAnim.value < 0 || isOutsideViewableRange) {
-            return 0;
-        }
-        // Determining spacer index is hard to visualize. See diagram: https://i.imgur.com/jRPf5t3.jpg
-        const isBeforeActive = cellIndex < activeIndexAnim.value;
-        const isAfterActive = cellIndex > activeIndexAnim.value;
-        const hoverPlusActiveSize = hoverOffset.value + activeCellSize.value;
-        const offsetPlusHalfSize = cellOffset.value + cellSize.value / 2;
-        const offsetPlusSize = cellOffset.value + cellSize.value;
-        let result = -1;
-        if (isAfterActive) {
-            if (hoverPlusActiveSize >= cellOffset.value &&
-                hoverPlusActiveSize < offsetPlusHalfSize) {
-                // bottom edge of active cell overlaps top half of current cell
-                result = cellIndex - 1;
-            }
-            else if (hoverPlusActiveSize >= offsetPlusHalfSize &&
-                hoverPlusActiveSize < offsetPlusSize) {
-                // bottom edge of active cell overlaps bottom half of current cell
-                result = cellIndex;
-            }
-        }
-        else if (isBeforeActive) {
-            if (hoverOffset.value < offsetPlusSize &&
-                hoverOffset.value >= offsetPlusHalfSize) {
-                // top edge of active cell overlaps bottom half of current cell
-                result = cellIndex + 1;
-            }
-            else if (hoverOffset.value >= cellOffset.value &&
-                hoverOffset.value < offsetPlusHalfSize) {
-                // top edge of active cell overlaps top half of current cell
-                result = cellIndex;
-            }
-        }
-        if (result !== -1 && result !== spacerIndexAnim.value) {
-            spacerIndexAnim.value = result;
-        }
-        if (spacerIndexAnim.value === cellIndex) {
-            const newPlaceholderOffset = isAfterActive
-                ? cellSize.value + (cellOffset.value - activeCellSize.value)
-                : cellOffset.value;
-            placeholderOffset.value = newPlaceholderOffset;
-        }
-        // Active cell follows touch
-        if (isActiveCell) {
-            return hoverAnim.value;
-        }
-        // Translate cell down if it is before active index and active cell has passed it.
-        // Translate cell up if it is after the active index and active cell has passed it.
-        const shouldTranslate = isAfterActive
-            ? cellIndex <= spacerIndexAnim.value
-            : cellIndex >= spacerIndexAnim.value;
-        const translationAmt = shouldTranslate
-            ? activeCellSize.value * (isAfterActive ? -1 : 1)
-            : 0;
-        return withSpring(translationAmt, animationConfigRef.value);
-    }, [activeKey, cellIndex]);
-    return translate;
-}