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

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-data-changed.ts

@@ -1,44 +0,0 @@
-export function omitZero(a: number, b: number) {
-  "worklet";
-  if (a === 0) return 0;
-
-  return b;
-}
-
-export function computeOffsetIfDataChanged(params: {
-  direction: number;
-  handlerOffset: number;
-  size: number;
-  previousLength: number;
-  currentLength: number;
-}) {
-  "worklet";
-  const { direction, handlerOffset: _handlerOffset, size, previousLength, currentLength } = params;
-
-  let handlerOffset = _handlerOffset;
-  let positionIndex: number;
-  let round: number;
-
-  const isPositive = direction < 0;
-
-  if (isPositive) {
-    positionIndex = Math.abs(handlerOffset) / size;
-    round = Number.parseInt(String(omitZero(previousLength, positionIndex / previousLength)));
-  } else {
-    positionIndex = (Math.abs(handlerOffset) - size) / size;
-    round = Number.parseInt(String(omitZero(previousLength, positionIndex / previousLength))) + 1;
-  }
-
-  const prevOffset = omitZero(previousLength, positionIndex % previousLength);
-  const prevIndex = isPositive ? prevOffset : previousLength - prevOffset - 1;
-  const changedLength = round * (currentLength - previousLength);
-  const changedOffset = changedLength * size;
-  if (prevIndex > currentLength - 1 && currentLength < previousLength) {
-    if (isPositive) handlerOffset = (currentLength - 1) * size * direction;
-    else handlerOffset = (currentLength - 1) * size * -1;
-  } else {
-    handlerOffset += changedOffset * direction;
-  }
-
-  return handlerOffset;
-}

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