react-native-reanimated-carousel 5.0.0-beta.7 → 5.0.0

package/src/utils/deal-with-animation.test.ts

@@ -1,181 +0,0 @@
-import { withSpring, withTiming } from "react-native-reanimated";
-
-import { dealWithAnimation } from "./deal-with-animation";
-
-// Mock Reanimated
-jest.mock("react-native-reanimated", () => ({
-  withSpring: jest.fn((value, _config, callback) => {
-    callback?.(true);
-    return value;
-  }),
-  withTiming: jest.fn((value, _config, callback) => {
-    callback?.(true);
-    return value;
-  }),
-}));
-
-describe("dealWithAnimation", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it("should handle spring animation", () => {
-    const callback = jest.fn();
-    const springConfig = {
-      damping: 20,
-      stiffness: 90,
-    };
-
-    const animation = dealWithAnimation({
-      type: "spring",
-      config: springConfig,
-    });
-
-    const result = animation(100, callback);
-
-    expect(withSpring).toHaveBeenCalledWith(100, springConfig, expect.any(Function));
-    expect(callback).toHaveBeenCalledWith(true);
-    expect(result).toBe(100);
-  });
-
-  it("should handle timing animation", () => {
-    const callback = jest.fn();
-    const timingConfig = {
-      duration: 300,
-    };
-
-    const animation = dealWithAnimation({
-      type: "timing",
-      config: timingConfig,
-    });
-
-    const result = animation(100, callback);
-
-    expect(withTiming).toHaveBeenCalledWith(100, timingConfig, expect.any(Function));
-    expect(callback).toHaveBeenCalledWith(true);
-    expect(result).toBe(100);
-  });
-
-  it("should pass animation config correctly", () => {
-    const springConfig = {
-      damping: 10,
-      mass: 1,
-      stiffness: 100,
-    };
-
-    const animation = dealWithAnimation({
-      type: "spring",
-      config: springConfig,
-    });
-
-    animation(100, jest.fn());
-
-    expect(withSpring).toHaveBeenCalledWith(
-      100,
-      expect.objectContaining(springConfig),
-      expect.any(Function)
-    );
-  });
-
-  it("should handle animation completion", () => {
-    const callback = jest.fn();
-    const animation = dealWithAnimation({
-      type: "timing",
-      config: { duration: 300 },
-    });
-
-    animation(100, callback);
-
-    expect(callback).toHaveBeenCalledWith(true);
-  });
-
-  it("should handle spring animation with different values", () => {
-    const callback = jest.fn();
-    const animation = dealWithAnimation({
-      type: "spring",
-      config: { damping: 15 },
-    });
-
-    animation(0, callback);
-    animation(-100, callback);
-    animation(500, callback);
-
-    expect(withSpring).toHaveBeenCalledWith(0, { damping: 15 }, expect.any(Function));
-    expect(withSpring).toHaveBeenCalledWith(-100, { damping: 15 }, expect.any(Function));
-    expect(withSpring).toHaveBeenCalledWith(500, { damping: 15 }, expect.any(Function));
-    expect(callback).toHaveBeenCalledTimes(3);
-  });
-
-  it("should handle timing animation with different values", () => {
-    const callback = jest.fn();
-    const animation = dealWithAnimation({
-      type: "timing",
-      config: { duration: 500 },
-    });
-
-    animation(0, callback);
-    animation(-50, callback);
-    animation(1000, callback);
-
-    expect(withTiming).toHaveBeenCalledWith(0, { duration: 500 }, expect.any(Function));
-    expect(withTiming).toHaveBeenCalledWith(-50, { duration: 500 }, expect.any(Function));
-    expect(withTiming).toHaveBeenCalledWith(1000, { duration: 500 }, expect.any(Function));
-    expect(callback).toHaveBeenCalledTimes(3);
-  });
-
-  it("should handle empty spring config", () => {
-    const callback = jest.fn();
-    const animation = dealWithAnimation({
-      type: "spring",
-      config: {},
-    });
-
-    animation(100, callback);
-
-    expect(withSpring).toHaveBeenCalledWith(100, {}, expect.any(Function));
-    expect(callback).toHaveBeenCalledWith(true);
-  });
-
-  it("should handle empty timing config", () => {
-    const callback = jest.fn();
-    const animation = dealWithAnimation({
-      type: "timing",
-      config: {},
-    });
-
-    animation(100, callback);
-
-    expect(withTiming).toHaveBeenCalledWith(100, {}, expect.any(Function));
-    expect(callback).toHaveBeenCalledWith(true);
-  });
-
-  it("should handle fractional values", () => {
-    const callback = jest.fn();
-    const animation = dealWithAnimation({
-      type: "spring",
-      config: { damping: 10 },
-    });
-
-    animation(50.5, callback);
-    animation(-25.75, callback);
-
-    expect(withSpring).toHaveBeenCalledWith(50.5, { damping: 10 }, expect.any(Function));
-    expect(withSpring).toHaveBeenCalledWith(-25.75, { damping: 10 }, expect.any(Function));
-  });
-
-  it("should create different animation functions for different configs", () => {
-    const animation1 = dealWithAnimation({
-      type: "spring",
-      config: { damping: 10 },
-    });
-
-    const animation2 = dealWithAnimation({
-      type: "timing",
-      config: { duration: 200 },
-    });
-
-    expect(animation1).not.toBe(animation2);
-    expect(typeof animation1).toBe("function");
-    expect(typeof animation2).toBe("function");
-  });
-});

package/src/utils/handleroffset-direction.test.ts

@@ -1,124 +0,0 @@
-import { useSharedValue } from "react-native-reanimated";
-
-import { renderHook } from "@testing-library/react-hooks";
-
-import { handlerOffsetDirection } from "./handleroffset-direction";
-
-describe("handlerOffsetDirection", () => {
-  it("should return -1 when default value equals to zero", () => {
-    const result = renderHook(() => {
-      const handlerOffsetAnimVal = useSharedValue(0);
-      return handlerOffsetDirection(handlerOffsetAnimVal);
-    });
-
-    expect(result.result.current).toBe(-1);
-  });
-
-  it("should return 1 when default value is greater than zero", () => {
-    const result = renderHook(() => {
-      const handlerOffsetAnimVal = useSharedValue(1);
-      return handlerOffsetDirection(handlerOffsetAnimVal);
-    });
-
-    expect(result.result.current).toBe(1);
-  });
-
-  it("should return -1 when default value is less than zero", () => {
-    const result = renderHook(() => {
-      const handlerOffsetAnimVal = useSharedValue(-1);
-      return handlerOffsetDirection(handlerOffsetAnimVal);
-    });
-
-    expect(result.result.current).toBe(-1);
-  });
-
-  it("should return 1 when default value equals to zero and fixedDirection is negative", () => {
-    const result = renderHook(() => {
-      const handlerOffsetAnimVal = useSharedValue(-1);
-      return handlerOffsetDirection(handlerOffsetAnimVal, "positive");
-    });
-
-    expect(result.result.current).toBe(1);
-  });
-
-  it("should return -1 when default value is greater than zero and fixedDirection is negative", () => {
-    const result = renderHook(() => {
-      const handlerOffsetAnimVal = useSharedValue(1);
-      return handlerOffsetDirection(handlerOffsetAnimVal, "negative");
-    });
-
-    expect(result.result.current).toBe(-1);
-  });
-
-  it("should handle fractional positive values", () => {
-    const result = renderHook(() => {
-      const handlerOffsetAnimVal = useSharedValue(0.5);
-      return handlerOffsetDirection(handlerOffsetAnimVal);
-    });
-
-    expect(result.result.current).toBe(1);
-  });
-
-  it("should handle fractional negative values", () => {
-    const result = renderHook(() => {
-      const handlerOffsetAnimVal = useSharedValue(-0.5);
-      return handlerOffsetDirection(handlerOffsetAnimVal);
-    });
-
-    expect(result.result.current).toBe(-1);
-  });
-
-  it("should handle large positive values", () => {
-    const result = renderHook(() => {
-      const handlerOffsetAnimVal = useSharedValue(1000);
-      return handlerOffsetDirection(handlerOffsetAnimVal);
-    });
-
-    expect(result.result.current).toBe(1);
-  });
-
-  it("should handle large negative values", () => {
-    const result = renderHook(() => {
-      const handlerOffsetAnimVal = useSharedValue(-1000);
-      return handlerOffsetDirection(handlerOffsetAnimVal);
-    });
-
-    expect(result.result.current).toBe(-1);
-  });
-
-  it("should override with positive fixed direction", () => {
-    const result = renderHook(() => {
-      const handlerOffsetAnimVal = useSharedValue(-100);
-      return handlerOffsetDirection(handlerOffsetAnimVal, "positive");
-    });
-
-    expect(result.result.current).toBe(1);
-  });
-
-  it("should override with negative fixed direction", () => {
-    const result = renderHook(() => {
-      const handlerOffsetAnimVal = useSharedValue(100);
-      return handlerOffsetDirection(handlerOffsetAnimVal, "negative");
-    });
-
-    expect(result.result.current).toBe(-1);
-  });
-
-  it("should handle very small positive values", () => {
-    const result = renderHook(() => {
-      const handlerOffsetAnimVal = useSharedValue(0.001);
-      return handlerOffsetDirection(handlerOffsetAnimVal);
-    });
-
-    expect(result.result.current).toBe(1);
-  });
-
-  it("should handle very small negative values", () => {
-    const result = renderHook(() => {
-      const handlerOffsetAnimVal = useSharedValue(-0.001);
-      return handlerOffsetDirection(handlerOffsetAnimVal);
-    });
-
-    expect(result.result.current).toBe(-1);
-  });
-});

package/src/utils/handleroffset-direction.ts

@@ -1,18 +0,0 @@
-import type { SharedValue } from "react-native-reanimated";
-
-import type { TCarouselProps } from "../types";
-
-export function handlerOffsetDirection(
-  handlerOffset: SharedValue<number>,
-  fixedDirection?: TCarouselProps["fixedDirection"]
-): -1 | 1 {
-  "worklet";
-
-  if (fixedDirection === "negative") return -1;
-
-  if (fixedDirection === "positive") return 1;
-
-  if (handlerOffset.value === 0) return -1;
-
-  return Math.sign(handlerOffset.value) as -1 | 1;
-}

package/src/utils/index.test.ts

@@ -1,90 +0,0 @@
-import { computeOffsetIfDataChanged } from "./compute-offset-if-data-changed";
-
-describe("should work as expected", () => {
-  const size = 375;
-  const positive = -1;
-  const negative = 1;
-
-  const params = (params: {
-    direction: "positive" | "negative";
-    currentIndex: number;
-    previousLength: number;
-    currentLength: number;
-  }) => {
-    const { currentIndex, direction: _direction, previousLength, currentLength } = params;
-    const direction = _direction === "negative" ? negative : positive;
-    return {
-      direction,
-      handlerOffset: size * currentIndex * direction,
-      size,
-      previousLength,
-      currentLength,
-    };
-  };
-
-  it("The direction is negative, And changing length of data set from 4 to 3, the new index will to be 2.", async () => {
-    const currentIndex = 1;
-    const handlerOffset = computeOffsetIfDataChanged(
-      params({
-        currentIndex,
-        direction: "negative",
-        previousLength: 4,
-        currentLength: 3,
-      })
-    );
-
-    expect(handlerOffset / size).toBe(2 * positive);
-  });
-
-  it("The direction is negative, Changing length of data set from 4 to 3, the index remains original.", async () => {
-    const handlerOffset = computeOffsetIfDataChanged(
-      params({
-        currentIndex: 2,
-        direction: "negative",
-        previousLength: 4,
-        currentLength: 3,
-      })
-    );
-
-    expect(handlerOffset / size).toBe(1 * negative);
-  });
-
-  it("The direction is positive, Changing length of data set from 4 to 5, the index remains original.", async () => {
-    const handlerOffset = computeOffsetIfDataChanged(
-      params({
-        currentIndex: 3,
-        direction: "positive",
-        previousLength: 4,
-        currentLength: 5,
-      })
-    );
-
-    expect(handlerOffset / size).toBe(3 * positive);
-  });
-
-  it("The direction is negative, Changing length of data set from 4 to 5, the index remains original.", async () => {
-    const handlerOffset = computeOffsetIfDataChanged(
-      params({
-        currentIndex: 3,
-        direction: "negative",
-        previousLength: 4,
-        currentLength: 5,
-      })
-    );
-
-    expect(handlerOffset / size).toBe(4 * negative);
-  });
-
-  it("Changing length of data set from 0 to 3, the index remains original.", async () => {
-    const handlerOffset = computeOffsetIfDataChanged(
-      params({
-        currentIndex: 0,
-        direction: "positive",
-        previousLength: 0,
-        currentLength: 3,
-      })
-    );
-
-    expect(handlerOffset / size).toBe(0 * positive);
-  });
-});

package/src/utils/log.test.ts

@@ -1,134 +0,0 @@
-import { log, round } from "./log";
-
-describe("log utilities", () => {
-  describe("log", () => {
-    const mockConsoleLog = jest.fn();
-    const originalConsoleLog = console.log;
-
-    beforeEach(() => {
-      console.log = mockConsoleLog;
-    });
-
-    afterEach(() => {
-      mockConsoleLog.mockClear();
-      console.log = originalConsoleLog;
-    });
-
-    it("should call console.log with provided arguments", () => {
-      const args = ["test", 123, { key: "value" }];
-      log(...args);
-
-      expect(mockConsoleLog).toHaveBeenCalledWith(...args);
-    });
-
-    it("should handle single argument", () => {
-      log("test");
-      expect(mockConsoleLog).toHaveBeenCalledWith("test");
-    });
-
-    it("should handle multiple arguments", () => {
-      log("test", 123, true);
-      expect(mockConsoleLog).toHaveBeenCalledWith("test", 123, true);
-    });
-
-    it("should handle no arguments", () => {
-      log();
-      expect(mockConsoleLog).toHaveBeenCalledWith();
-    });
-
-    it("should handle null and undefined", () => {
-      log(null, undefined);
-      expect(mockConsoleLog).toHaveBeenCalledWith(null, undefined);
-    });
-
-    it("should handle complex objects", () => {
-      const complexObj = {
-        nested: { array: [1, 2, 3] },
-        func: () => "test",
-        date: new Date("2023-01-01"),
-      };
-      log(complexObj);
-      expect(mockConsoleLog).toHaveBeenCalledWith(complexObj);
-    });
-
-    it("should handle arrays", () => {
-      const arr = [1, "two", { three: 3 }];
-      log(arr);
-      expect(mockConsoleLog).toHaveBeenCalledWith(arr);
-    });
-
-    it("should handle mixed types", () => {
-      log("string", 42, true, null, undefined, { key: "value" }, [1, 2, 3]);
-      expect(mockConsoleLog).toHaveBeenCalledWith(
-        "string",
-        42,
-        true,
-        null,
-        undefined,
-        { key: "value" },
-        [1, 2, 3]
-      );
-    });
-  });
-
-  describe("round", () => {
-    it("should round positive numbers correctly", () => {
-      expect(round(1.4)).toBe(1);
-      expect(round(1.5)).toBe(2);
-      expect(round(1.6)).toBe(2);
-    });
-
-    it("should round negative numbers correctly", () => {
-      expect(round(-1.4)).toBe(-1);
-      expect(round(-1.5)).toBe(-1);
-      expect(round(-1.6)).toBe(-2);
-    });
-
-    it("should handle zero values", () => {
-      expect(round(0)).toBe(0);
-      expect(round(-0)).toBe(-0);
-      expect(1 / round(-0)).toBe(Number.NEGATIVE_INFINITY);
-    });
-
-    it("should handle integers", () => {
-      expect(round(5)).toBe(5);
-      expect(round(-5)).toBe(-5);
-    });
-
-    it("should handle decimal places", () => {
-      expect(round(Math.PI)).toBe(3);
-      expect(round(-Math.PI)).toBe(-3);
-    });
-
-    it("should handle edge cases", () => {
-      expect(round(0.5)).toBe(1);
-      expect(round(-0.5)).toBe(-0);
-      expect(round(1.999999)).toBe(2);
-      expect(round(-1.999999)).toBe(-2);
-    });
-
-    it("should handle very large numbers", () => {
-      expect(round(1e10 + 0.4)).toBe(1e10);
-      expect(round(1e10 + 0.6)).toBe(1e10 + 1);
-    });
-
-    it("should handle very small numbers", () => {
-      expect(round(0.00001)).toBe(0);
-      expect(round(-0.00001)).toBe(-0);
-    });
-
-    it("should handle Infinity", () => {
-      expect(round(Number.POSITIVE_INFINITY)).toBe(Number.POSITIVE_INFINITY);
-      expect(round(Number.NEGATIVE_INFINITY)).toBe(Number.NEGATIVE_INFINITY);
-    });
-
-    it("should handle NaN", () => {
-      expect(round(Number.NaN)).toBe(Number.NaN);
-    });
-
-    it("should handle floating point precision issues", () => {
-      expect(round(0.1 + 0.2)).toBe(0); // 0.1 + 0.2 = 0.30000000000000004
-      expect(round(1.1 + 1.2)).toBe(2); // Should round to 2
-    });
-  });
-});

package/src/utils/sanitize-animation-style.test.ts

@@ -1,40 +0,0 @@
-import { sanitizeAnimationStyle } from "./sanitize-animation-style";
-
-describe("sanitizeAnimationStyle", () => {
-  it("rounds zIndex to an integer", () => {
-    const style = sanitizeAnimationStyle({
-      transform: [{ translateX: 12 }],
-      zIndex: 3.7,
-    });
-
-    expect(style.zIndex).toBe(4);
-  });
-
-  it("drops invalid zIndex values", () => {
-    const style = sanitizeAnimationStyle({
-      // invalid value from userland worklet should not flow to native styles
-      zIndex: Number.NaN,
-    });
-
-    expect(style).not.toHaveProperty("zIndex");
-  });
-
-  it("returns empty object for null/undefined input", () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect(sanitizeAnimationStyle(null as any)).toEqual({});
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect(sanitizeAnimationStyle(undefined as any)).toEqual({});
-  });
-
-  it("strips non-number zIndex (e.g. string)", () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const style = sanitizeAnimationStyle({ opacity: 1, zIndex: "auto" as any });
-    expect(style).not.toHaveProperty("zIndex");
-    expect(style).toHaveProperty("opacity", 1);
-  });
-
-  it("preserves style without zIndex unchanged", () => {
-    const style = sanitizeAnimationStyle({ opacity: 0.5 });
-    expect(style).toEqual({ opacity: 0.5 });
-  });
-});