@leonsilicon/react-native-reanimated-carousel 0.0.0

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

@@ -0,0 +1,17 @@
+import { withSpring, withTiming } from "react-native-reanimated";
+
+import type { WithAnimation } from "../types";
+
+export function dealWithAnimation(
+  withAnimation: WithAnimation
+): (value: number, cb: (isFinished: boolean) => void) => number {
+  "worklet";
+  switch (withAnimation.type) {
+    case "spring":
+      return (value, cb) =>
+        withSpring(value, withAnimation.config, (isFinished) => cb(isFinished as boolean));
+    case "timing":
+      return (value, cb) =>
+        withTiming(value, withAnimation.config, (isFinished) => cb(isFinished as boolean));
+  }
+}

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

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

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

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

@@ -0,0 +1,134 @@
+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/log.ts

@@ -0,0 +1,12 @@
+/**
+ * In worklet
+ * e.g. scheduleOnRN(lop, ...);
+ */
+export function log(...msg: any) {
+  console.log(...msg);
+}
+
+export function round(number: number) {
+  "worklet";
+  return Math.round(number);
+}

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

@@ -0,0 +1,40 @@
+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 });
+  });
+});

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

@@ -0,0 +1,20 @@
+import type { ViewStyle } from "react-native";
+
+type MutableViewStyle = ViewStyle & { zIndex?: unknown };
+
+export function sanitizeAnimationStyle(style: ViewStyle): ViewStyle {
+  "worklet";
+
+  if (!style || typeof style !== "object") return {};
+
+  const nextStyle: MutableViewStyle = { ...style };
+  const { zIndex, ...restStyle } = nextStyle;
+
+  if (typeof zIndex === "number") {
+    // Native layers are sensitive to invalid/non-integer zIndex values.
+    if (Number.isFinite(zIndex)) return { ...restStyle, zIndex: Math.round(zIndex) };
+    return restStyle;
+  }
+
+  return typeof zIndex === "undefined" ? nextStyle : restStyle;
+}

package/src/utils/size-resolver.test.ts

@@ -0,0 +1,193 @@
+import { makeMutable } from "react-native-reanimated";
+
+import {
+  binarySearchPrefix,
+  binarySearchPrefixCached,
+  buildPrefixSum,
+  createUniformSizeResolver,
+  createVariableSizeResolver,
+} from "./size-resolver";
+
+describe("buildPrefixSum", () => {
+  it("returns a flat prefix for empty input", () => {
+    const result = buildPrefixSum(0, () => 100);
+    expect(result.sizes).toEqual([]);
+    expect(result.prefix).toEqual([0]);
+    expect(result.total).toBe(0);
+  });
+
+  it("computes cumulative offsets correctly", () => {
+    const widths = [80, 150, 220, 100, 300];
+    const result = buildPrefixSum(widths.length, (i) => widths[i]);
+    expect(result.sizes).toEqual([80, 150, 220, 100, 300]);
+    expect(result.prefix).toEqual([0, 80, 230, 450, 550, 850]);
+    expect(result.total).toBe(850);
+  });
+
+  it("treats non-finite or non-positive sizes as 0", () => {
+    const result = buildPrefixSum(4, (i) => [100, -50, Number.NaN, 200][i]);
+    expect(result.sizes).toEqual([100, 0, 0, 200]);
+    expect(result.prefix).toEqual([0, 100, 100, 100, 300]);
+    expect(result.total).toBe(300);
+  });
+});
+
+describe("binarySearchPrefix", () => {
+  const prefix = [0, 80, 230, 450, 550, 850];
+
+  it("returns 0 for target at the very start", () => {
+    expect(binarySearchPrefix(prefix, 0)).toBe(0);
+  });
+
+  it("returns last item when target is past the end", () => {
+    expect(binarySearchPrefix(prefix, 9999)).toBe(4);
+  });
+
+  it("finds the bucket for an interior offset", () => {
+    expect(binarySearchPrefix(prefix, 79)).toBe(0);
+    expect(binarySearchPrefix(prefix, 80)).toBe(1);
+    expect(binarySearchPrefix(prefix, 229)).toBe(1);
+    expect(binarySearchPrefix(prefix, 230)).toBe(2);
+    expect(binarySearchPrefix(prefix, 449)).toBe(2);
+    expect(binarySearchPrefix(prefix, 450)).toBe(3);
+    expect(binarySearchPrefix(prefix, 549)).toBe(3);
+    expect(binarySearchPrefix(prefix, 550)).toBe(4);
+  });
+
+  it("handles negative targets by clamping to 0", () => {
+    expect(binarySearchPrefix(prefix, -100)).toBe(0);
+  });
+
+  it("returns 0 when prefix is degenerate", () => {
+    expect(binarySearchPrefix([0], 100)).toBe(0);
+    expect(binarySearchPrefix([], 100)).toBe(0);
+  });
+});
+
+describe("binarySearchPrefixCached", () => {
+  const prefix = [0, 80, 230, 450, 550, 850];
+
+  it("uses the hint when it is correct", () => {
+    // target 100 → index 1; hint 1 is exactly correct
+    expect(binarySearchPrefixCached(prefix, 100, 1)).toBe(1);
+  });
+
+  it("scans ±1 around a stale hint", () => {
+    // target 100 → index 1; hint 0 means hint+1 is correct
+    expect(binarySearchPrefixCached(prefix, 100, 0)).toBe(1);
+    // target 100 → index 1; hint 2 means hint-1 is correct
+    expect(binarySearchPrefixCached(prefix, 100, 2)).toBe(1);
+  });
+
+  it("falls back to binary search when hint is far off", () => {
+    expect(binarySearchPrefixCached(prefix, 100, 4)).toBe(1);
+    expect(binarySearchPrefixCached(prefix, 700, 0)).toBe(4);
+  });
+
+  it("clamps out-of-bounds hints", () => {
+    expect(binarySearchPrefixCached(prefix, 100, -50)).toBe(1);
+    expect(binarySearchPrefixCached(prefix, 100, 9999)).toBe(1);
+  });
+});
+
+describe("createUniformSizeResolver", () => {
+  it("computes offsets as size * index", () => {
+    const size = makeMutable(100);
+    const count = makeMutable(5);
+    const total = makeMutable(500);
+    const resolver = createUniformSizeResolver({ size, count, total });
+
+    expect(resolver.variable).toBe(false);
+    expect(resolver.itemSize(0)).toBe(100);
+    expect(resolver.itemSize(3)).toBe(100);
+    expect(resolver.offsetAt(0)).toBe(0);
+    expect(resolver.offsetAt(3)).toBe(300);
+    expect(resolver.indexAt(0)).toBe(0);
+    expect(resolver.indexAt(250)).toBe(3);
+    expect(resolver.midpointOf(2)).toBe(250);
+    expect(resolver.total.value).toBe(500);
+  });
+
+  it("returns 0 from indexAt when size is 0", () => {
+    const size = makeMutable(0);
+    const count = makeMutable(5);
+    const total = makeMutable(0);
+    const resolver = createUniformSizeResolver({ size, count, total });
+    expect(resolver.indexAt(500)).toBe(0);
+  });
+});
+
+describe("createVariableSizeResolver", () => {
+  const widths = [80, 150, 220, 100, 300];
+  const built = buildPrefixSum(widths.length, (i) => widths[i]);
+
+  const makeResolver = (hint?: number) => {
+    const sizes = makeMutable(built.sizes);
+    const prefix = makeMutable(built.prefix);
+    const total = makeMutable(built.total);
+    const count = makeMutable(widths.length);
+    const hintSv = hint === undefined ? undefined : makeMutable(hint);
+    return {
+      resolver: createVariableSizeResolver({ sizes, prefix, total, count, hint: hintSv }),
+      hintSv,
+    };
+  };
+
+  it("reports per-item sizes", () => {
+    const { resolver } = makeResolver();
+    expect(resolver.variable).toBe(true);
+    expect(resolver.itemSize(0)).toBe(80);
+    expect(resolver.itemSize(2)).toBe(220);
+    expect(resolver.itemSize(4)).toBe(300);
+  });
+
+  it("clamps itemSize out-of-bounds index to first/last", () => {
+    const { resolver } = makeResolver();
+    expect(resolver.itemSize(-1)).toBe(80);
+    expect(resolver.itemSize(99)).toBe(300);
+  });
+
+  it("returns cumulative offsets", () => {
+    const { resolver } = makeResolver();
+    expect(resolver.offsetAt(0)).toBe(0);
+    expect(resolver.offsetAt(1)).toBe(80);
+    expect(resolver.offsetAt(2)).toBe(230);
+    expect(resolver.offsetAt(3)).toBe(450);
+    expect(resolver.offsetAt(4)).toBe(550);
+    expect(resolver.offsetAt(5)).toBe(850);
+  });
+
+  it("inverts via indexAt", () => {
+    const { resolver } = makeResolver();
+    expect(resolver.indexAt(0)).toBe(0);
+    expect(resolver.indexAt(79)).toBe(0);
+    expect(resolver.indexAt(80)).toBe(1);
+    expect(resolver.indexAt(229)).toBe(1);
+    expect(resolver.indexAt(230)).toBe(2);
+    expect(resolver.indexAt(845)).toBe(4);
+    expect(resolver.indexAt(99999)).toBe(4);
+  });
+
+  it("updates the hint when one is supplied", () => {
+    const { resolver, hintSv } = makeResolver(0);
+    resolver.indexAt(700); // should land at index 4
+    expect(hintSv!.value).toBe(4);
+  });
+
+  it("computes midpoints correctly", () => {
+    const { resolver } = makeResolver();
+    expect(resolver.midpointOf(0)).toBe(40); // 0 + 80/2
+    expect(resolver.midpointOf(2)).toBe(340); // 230 + 220/2
+  });
+
+  it("handles empty arrays without crashing", () => {
+    const sizes = makeMutable<number[]>([]);
+    const prefix = makeMutable<number[]>([0]);
+    const total = makeMutable(0);
+    const count = makeMutable(0);
+    const resolver = createVariableSizeResolver({ sizes, prefix, total, count });
+    expect(resolver.itemSize(0)).toBe(0);
+    expect(resolver.offsetAt(0)).toBe(0);
+    expect(resolver.indexAt(100)).toBe(0);
+  });
+});