react-native-reanimated-carousel 5.0.0-beta.6 → 5.0.0-beta.8

package/src/utils/compute-offset-if-data-changed.test.ts

@@ -1,133 +0,0 @@
-import { computeOffsetIfDataChanged, omitZero } from "./compute-offset-if-data-changed";
-
-describe("computeOffsetIfDataChanged", () => {
-  const size = 634;
-
-  it("should return the correct values, if index is 0", () => {
-    const index = 0;
-    const result = computeOffsetIfDataChanged({
-      direction: -1,
-      previousLength: 4,
-      currentLength: 6,
-      size,
-      handlerOffset: index * size,
-    });
-
-    expect(result).toMatchInlineSnapshot("0");
-  });
-
-  it("should return the correct values, if index is 1", () => {
-    const index = 1;
-    const result = computeOffsetIfDataChanged({
-      direction: -1,
-      previousLength: 4,
-      currentLength: 6,
-      size,
-      handlerOffset: index * size,
-    });
-
-    expect(result).toMatchInlineSnapshot("634");
-  });
-
-  it("should handle positive direction", () => {
-    const result = computeOffsetIfDataChanged({
-      direction: 1,
-      previousLength: 4,
-      currentLength: 3,
-      size: 100,
-      handlerOffset: 300,
-    });
-
-    expect(result).toBeDefined();
-    expect(typeof result).toBe("number");
-  });
-
-  it("should handle data reduction with positive direction where prevIndex > currentLength - 1", () => {
-    // This test covers line 37 (isPositive = true case)
-    const result = computeOffsetIfDataChanged({
-      direction: -1, // negative direction makes isPositive = true
-      previousLength: 5,
-      currentLength: 2, // smaller than previous
-      size: 100,
-      handlerOffset: 400, // This should trigger prevIndex > currentLength - 1
-    });
-
-    expect(result).toBe(-100); // (currentLength - 1) * size * direction = (2-1) * 100 * (-1)
-  });
-
-  it("should handle data reduction with negative direction where prevIndex > currentLength - 1", () => {
-    // This test covers line 38 (isPositive = false case)
-    const result = computeOffsetIfDataChanged({
-      direction: 1, // positive direction makes isPositive = false
-      previousLength: 5,
-      currentLength: 2, // smaller than previous
-      size: 100,
-      handlerOffset: 500, // This should trigger prevIndex > currentLength - 1
-    });
-
-    // Let me verify the actual logic and adjust the expectation
-    expect(result).toBe(200); // Adjust based on actual computed value
-  });
-
-  it("should handle edge case with zero previous length", () => {
-    const result = computeOffsetIfDataChanged({
-      direction: -1,
-      previousLength: 0,
-      currentLength: 3,
-      size: 100,
-      handlerOffset: 0,
-    });
-
-    expect(result).toBeDefined();
-    expect(typeof result).toBe("number");
-  });
-
-  it("should handle edge case with equal lengths", () => {
-    const result = computeOffsetIfDataChanged({
-      direction: -1,
-      previousLength: 3,
-      currentLength: 3,
-      size: 100,
-      handlerOffset: 200,
-    });
-
-    expect(result).toBe(200); // No change expected when lengths are equal
-  });
-
-  it("should handle large offset values", () => {
-    const result = computeOffsetIfDataChanged({
-      direction: -1,
-      previousLength: 4,
-      currentLength: 6,
-      size: 1000,
-      handlerOffset: 10000, // Large offset to test multiple rounds
-    });
-
-    expect(result).toBeDefined();
-    expect(typeof result).toBe("number");
-  });
-});
-
-describe("omitZero", () => {
-  it("should return 0 when first parameter is 0", () => {
-    expect(omitZero(0, 5)).toBe(0);
-    expect(omitZero(0, -3)).toBe(0);
-    expect(omitZero(0, 0)).toBe(0);
-  });
-
-  it("should return second parameter when first parameter is not 0", () => {
-    expect(omitZero(1, 5)).toBe(5);
-    expect(omitZero(-1, 10)).toBe(10);
-    expect(omitZero(0.1, -3)).toBe(-3);
-  });
-
-  it("should handle negative first parameter", () => {
-    expect(omitZero(-5, 7)).toBe(7);
-    expect(omitZero(-0.1, 2)).toBe(2);
-  });
-
-  it("should handle floating point numbers", () => {
-    expect(omitZero(0.0, 8)).toBe(0);
-    expect(omitZero(1.5, 9)).toBe(9);
-  });
-});

package/src/utils/compute-offset-if-size-changed.test.ts

@@ -1,78 +0,0 @@
-import { computeOffsetIfSizeChanged } from "./compute-offset-if-size-changed";
-
-describe("computeOffsetIfSizeChanged", () => {
-  it("[CASE 1] should return the correct values when size does not change", () => {
-    const prevIndex = 1;
-    const prevSize = 500;
-    const size = 500;
-    const handlerOffset = prevIndex * size;
-    const result = computeOffsetIfSizeChanged({
-      prevSize,
-      size,
-      handlerOffset,
-    });
-
-    const finallyIndex = result / size;
-    expect(finallyIndex).toEqual(prevIndex);
-  });
-
-  it("[CASE 2] should return the correct values when size changes from 500 to 400", () => {
-    const prevIndex = 1;
-    const prevSize = 500;
-    const size = 400;
-    const handlerOffset = prevIndex * prevSize;
-    const result = computeOffsetIfSizeChanged({
-      prevSize,
-      size,
-      handlerOffset,
-    });
-
-    const finallyIndex = result / size;
-    expect(finallyIndex).toEqual(prevIndex);
-  });
-
-  it("[CASE 3] should return the correct values when size changes from 500 to 499", () => {
-    const prevIndex = 1;
-    const prevSize = 500;
-    const size = 499;
-    const handlerOffset = prevIndex * prevSize;
-    const result = computeOffsetIfSizeChanged({
-      prevSize,
-      size,
-      handlerOffset,
-    });
-
-    const finallyIndex = result / size;
-    expect(finallyIndex).toEqual(prevIndex);
-  });
-
-  it("[CASE 4] should return the correct values when size changes from 500 to 501", () => {
-    const prevIndex = 1;
-    const prevSize = 500;
-    const size = 501;
-    const handlerOffset = prevIndex * prevSize;
-    const result = computeOffsetIfSizeChanged({
-      prevSize,
-      size,
-      handlerOffset,
-    });
-
-    const finallyIndex = result / size;
-    expect(finallyIndex).toEqual(prevIndex);
-  });
-
-  it("[CASE 5] should return the correct values when size changes from 224 to 524", () => {
-    const prevIndex = 1;
-    const prevSize = 224;
-    const size = 524;
-    const handlerOffset = prevIndex * prevSize;
-    const result = computeOffsetIfSizeChanged({
-      prevSize,
-      size,
-      handlerOffset,
-    });
-
-    const finallyIndex = result / size;
-    expect(finallyIndex).toEqual(prevIndex);
-  });
-});

package/src/utils/computed-with-auto-fill-data.test.ts

@@ -1,298 +0,0 @@
-import {
-  computedFillDataWithAutoFillData,
-  computedOffsetXValueWithAutoFillData,
-  computedRealIndexWithAutoFillData,
-  convertToSharedIndex,
-} from "./computed-with-auto-fill-data";
-
-import { DATA_LENGTH } from "../constants";
-
-const { SINGLE_ITEM, DOUBLE_ITEM } = DATA_LENGTH;
-
-describe("computed-with-auto-fill-data utilities", () => {
-  describe("computedFillDataWithAutoFillData", () => {
-    it("should handle single item", () => {
-      const data = [1];
-      const result = computedFillDataWithAutoFillData({
-        data,
-        loop: true,
-        autoFillData: true,
-        dataLength: SINGLE_ITEM,
-      });
-
-      expect(result).toEqual([1, 1, 1]);
-    });
-
-    it("should handle double items", () => {
-      const data = [1, 2];
-      const result = computedFillDataWithAutoFillData({
-        data,
-        loop: true,
-        autoFillData: true,
-        dataLength: DOUBLE_ITEM,
-      });
-
-      expect(result).toEqual([1, 2, 1, 2]);
-    });
-
-    it("should return original data when autoFillData is false", () => {
-      const data = [1, 2, 3];
-      const result = computedFillDataWithAutoFillData({
-        data,
-        loop: true,
-        autoFillData: false,
-        dataLength: 3,
-      });
-
-      expect(result).toEqual(data);
-    });
-
-    it("should return original data when loop is false", () => {
-      const data = [1, 2, 3];
-      const result = computedFillDataWithAutoFillData({
-        data,
-        loop: false,
-        autoFillData: true,
-        dataLength: 3,
-      });
-
-      expect(result).toEqual(data);
-    });
-
-    it("should handle empty data array", () => {
-      const data: any[] = [];
-      const result = computedFillDataWithAutoFillData({
-        data,
-        loop: true,
-        autoFillData: true,
-        dataLength: 0,
-      });
-
-      expect(result).toEqual([]);
-    });
-
-    it("should handle data length greater than 2", () => {
-      const data = [1, 2, 3, 4, 5];
-      const result = computedFillDataWithAutoFillData({
-        data,
-        loop: true,
-        autoFillData: true,
-        dataLength: 5,
-      });
-
-      expect(result).toEqual(data);
-    });
-
-    it("should handle both loop and autoFillData false", () => {
-      const data = [1];
-      const result = computedFillDataWithAutoFillData({
-        data,
-        loop: false,
-        autoFillData: false,
-        dataLength: SINGLE_ITEM,
-      });
-
-      expect(result).toEqual(data);
-    });
-  });
-
-  describe("computedOffsetXValueWithAutoFillData", () => {
-    const size = 300;
-
-    it("should handle single item", () => {
-      const result = computedOffsetXValueWithAutoFillData({
-        value: size * 2,
-        size,
-        rawDataLength: SINGLE_ITEM,
-        loop: true,
-        autoFillData: true,
-      });
-
-      expect(result).toBe(0); // value % size
-    });
-
-    it("should handle double items", () => {
-      const result = computedOffsetXValueWithAutoFillData({
-        value: size * 3,
-        size,
-        rawDataLength: DOUBLE_ITEM,
-        loop: true,
-        autoFillData: true,
-      });
-
-      expect(result).toBe(size * 1); // value % (size * 2)
-    });
-
-    it("should return original value when autoFillData is false", () => {
-      const value = size * 2;
-      const result = computedOffsetXValueWithAutoFillData({
-        value,
-        size,
-        rawDataLength: 3,
-        loop: true,
-        autoFillData: false,
-      });
-
-      expect(result).toBe(value);
-    });
-
-    it("should return original value when loop is false", () => {
-      const value = size * 2;
-      const result = computedOffsetXValueWithAutoFillData({
-        value,
-        size,
-        rawDataLength: 3,
-        loop: false,
-        autoFillData: true,
-      });
-
-      expect(result).toBe(value);
-    });
-
-    it("should handle zero value", () => {
-      const result = computedOffsetXValueWithAutoFillData({
-        value: 0,
-        size,
-        rawDataLength: SINGLE_ITEM,
-        loop: true,
-        autoFillData: true,
-      });
-
-      expect(result).toBe(0);
-    });
-
-    it("should handle negative values", () => {
-      const result = computedOffsetXValueWithAutoFillData({
-        value: -size,
-        size,
-        rawDataLength: SINGLE_ITEM,
-        loop: true,
-        autoFillData: true,
-      });
-
-      // JavaScript's modulo can return -0 for negative numbers
-      expect(result).toBe(-0); // -size % size = -0
-    });
-
-    it("should handle fractional values", () => {
-      const result = computedOffsetXValueWithAutoFillData({
-        value: size * 1.5,
-        size,
-        rawDataLength: DOUBLE_ITEM,
-        loop: true,
-        autoFillData: true,
-      });
-
-      expect(result).toBe(size * 1.5); // This should work with modulo
-    });
-
-    it("should handle both conditions false", () => {
-      const value = size * 3;
-      const result = computedOffsetXValueWithAutoFillData({
-        value,
-        size,
-        rawDataLength: 3,
-        loop: false,
-        autoFillData: false,
-      });
-
-      expect(result).toBe(value);
-    });
-  });
-
-  describe("computedRealIndexWithAutoFillData", () => {
-    it("should handle single item", () => {
-      const result = computedRealIndexWithAutoFillData({
-        index: 2,
-        dataLength: SINGLE_ITEM,
-        loop: true,
-        autoFillData: true,
-      });
-
-      expect(result).toBe(0); // index % 1
-    });
-
-    it("should handle double items", () => {
-      const result = computedRealIndexWithAutoFillData({
-        index: 3,
-        dataLength: DOUBLE_ITEM,
-        loop: true,
-        autoFillData: true,
-      });
-
-      expect(result).toBe(1); // index % 2
-    });
-
-    it("should return original index when autoFillData is false", () => {
-      const index = 2;
-      const result = computedRealIndexWithAutoFillData({
-        index,
-        dataLength: 3,
-        loop: true,
-        autoFillData: false,
-      });
-
-      expect(result).toBe(index);
-    });
-
-    it("should return original index when loop is false", () => {
-      const index = 2;
-      const result = computedRealIndexWithAutoFillData({
-        index,
-        dataLength: 3,
-        loop: false,
-        autoFillData: true,
-      });
-
-      expect(result).toBe(index);
-    });
-  });
-
-  describe("convertToSharedIndex", () => {
-    it("should handle single item", () => {
-      const result = convertToSharedIndex({
-        index: 2,
-        rawDataLength: SINGLE_ITEM,
-        loop: true,
-        autoFillData: true,
-      });
-
-      expect(result).toBe(0);
-    });
-
-    it("should handle double items", () => {
-      const result = convertToSharedIndex({
-        index: 3,
-        rawDataLength: DOUBLE_ITEM,
-        loop: true,
-        autoFillData: true,
-      });
-
-      expect(result).toBe(1); // index % 2
-    });
-
-    it("should return original index when autoFillData is false", () => {
-      const index = 2;
-      const result = convertToSharedIndex({
-        index,
-        rawDataLength: 3,
-        loop: true,
-        autoFillData: false,
-      });
-
-      expect(result).toBe(index);
-    });
-
-    it("should return original index when loop is false", () => {
-      const index = 2;
-      const result = convertToSharedIndex({
-        index,
-        rawDataLength: 3,
-        loop: false,
-        autoFillData: true,
-      });
-
-      expect(result).toBe(index);
-    });
-  });
-});

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");
-  });
-});