@momo-kits/carousel 0.165.2-beta.3 → 0.167.1-beta.1

package/core/utils/carousel-math.ts

@@ -1,156 +0,0 @@
-export function positiveModulo(value: number, divisor: number): number {
-  "worklet";
-
-  if (!Number.isFinite(value) || !Number.isFinite(divisor) || divisor <= 0) return 0;
-
-  const remainder = value % divisor;
-  return remainder < 0 ? remainder + divisor : remainder;
-}
-
-export function getLogicalProgress(offset: number, itemSize: number): number {
-  "worklet";
-
-  if (!Number.isFinite(offset) || !Number.isFinite(itemSize) || itemSize <= 0) return 0;
-  return -offset / itemSize;
-}
-
-export function getOffsetForLogicalPage(page: number, itemSize: number): number {
-  "worklet";
-
-  if (!Number.isFinite(page) || !Number.isFinite(itemSize) || itemSize <= 0) return 0;
-  if (page === 0) return 0;
-  return -page * itemSize;
-}
-
-export function getNearestLogicalPage(offset: number, itemSize: number): number {
-  "worklet";
-
-  return Math.round(getLogicalProgress(offset, itemSize));
-}
-
-export function getSettledRawIndex(progress: number, count: number): number {
-  "worklet";
-
-  if (!Number.isFinite(count) || count <= 0) return 0;
-  return positiveModulo(Math.round(progress), Math.floor(count));
-}
-
-export function getNearestLoopPosition(rawIndex: number, progress: number, count: number): number {
-  "worklet";
-
-  if (
-    !Number.isFinite(rawIndex) ||
-    !Number.isFinite(progress) ||
-    !Number.isFinite(count) ||
-    count <= 0
-  ) {
-    return 0;
-  }
-
-  const safeCount = Math.floor(count);
-  const normalizedIndex = positiveModulo(Math.round(rawIndex), safeCount);
-  const lowerCycle = Math.floor((progress - normalizedIndex) / safeCount);
-  const lower = normalizedIndex + lowerCycle * safeCount;
-  const upper = lower + safeCount;
-  const lowerDistance = Math.abs(progress - lower);
-  const upperDistance = Math.abs(upper - progress);
-
-  if (upperDistance < lowerDistance) return upper;
-  if (lowerDistance < upperDistance) return lower;
-
-  // An exact tie resolves in the logical forward direction.
-  return upper >= progress ? upper : lower;
-}
-
-export function getRelativeProgress(params: {
-  rawIndex: number;
-  progress: number;
-  count: number;
-  loop: boolean;
-}): number {
-  "worklet";
-
-  const { rawIndex, progress, count, loop } = params;
-  if (!Number.isFinite(progress)) return 0;
-
-  const itemPosition = loop ? getNearestLoopPosition(rawIndex, progress, count) : rawIndex;
-  return itemPosition - progress;
-}
-
-export function getBoundedLoopOffset(offset: number, itemSize: number, count: number): number {
-  "worklet";
-
-  if (
-    !Number.isFinite(offset) ||
-    !Number.isFinite(itemSize) ||
-    !Number.isFinite(count) ||
-    itemSize <= 0 ||
-    count <= 0
-  ) {
-    return 0;
-  }
-
-  const cycleSize = itemSize * Math.floor(count);
-  return offset % cycleSize;
-}
-
-export function getShortestLoopTargetPage(params: {
-  currentPage: number;
-  targetIndex: number;
-  count: number;
-}): number {
-  "worklet";
-
-  const { currentPage, targetIndex, count } = params;
-  if (
-    !Number.isFinite(currentPage) ||
-    !Number.isInteger(targetIndex) ||
-    !Number.isInteger(count) ||
-    count <= 0
-  ) {
-    return 0;
-  }
-
-  const currentRawIndex = positiveModulo(currentPage, count);
-  const forwardDistance = positiveModulo(targetIndex - currentRawIndex, count);
-  const backwardDistance = forwardDistance - count;
-  const distance =
-    Math.abs(forwardDistance) <= Math.abs(backwardDistance) ? forwardDistance : backwardDistance;
-
-  return currentPage + distance;
-}
-
-export function reconcileOffsetAfterDataChange(params: {
-  offset: number;
-  itemSize: number;
-  previousCount: number;
-  nextCount: number;
-  defaultIndex: number;
-  loop: boolean;
-  retainedIndex?: number | undefined;
-}): number {
-  "worklet";
-
-  const { offset, itemSize, previousCount, nextCount, defaultIndex, loop, retainedIndex } = params;
-  if (!Number.isInteger(nextCount) || nextCount <= 0 || itemSize <= 0) return 0;
-
-  if (!Number.isInteger(previousCount) || previousCount <= 0) {
-    const initialIndex = Math.max(0, Math.min(nextCount - 1, defaultIndex));
-    return getOffsetForLogicalPage(initialIndex, itemSize);
-  }
-
-  const currentPage = getNearestLogicalPage(offset, itemSize);
-  const previousRawIndex = positiveModulo(currentPage, previousCount);
-  const nextRawIndex =
-    typeof retainedIndex === "number" &&
-    Number.isInteger(retainedIndex) &&
-    retainedIndex >= 0 &&
-    retainedIndex < nextCount
-      ? retainedIndex
-      : Math.min(previousRawIndex, nextCount - 1);
-  const nextPage = loop
-    ? getNearestLoopPosition(nextRawIndex, currentPage, nextCount)
-    : nextRawIndex;
-
-  return getOffsetForLogicalPage(nextPage, itemSize);
-}

package/core/utils/compute-gesture-translation.ts

@@ -1,29 +0,0 @@
-export function computeGestureTranslation(options: {
-  loop: boolean;
-  overscrollEnabled: boolean;
-  currentTranslation: number;
-  panOffset: number;
-  panTranslation: number;
-  max: number;
-}): number {
-  "worklet";
-  const { loop, overscrollEnabled, currentTranslation, panOffset, panTranslation, max } = options;
-  const raw = panOffset + panTranslation;
-
-  if (loop) return raw;
-
-  if (!overscrollEnabled) {
-    // In non-loop mode with overscroll disabled, translation must stay in [-max, 0].
-    return Math.min(0, Math.max(-max, raw));
-  }
-
-  // Keep resistance behavior only when overscroll is enabled.
-  if (currentTranslation > 0 || currentTranslation < -max) {
-    const boundary = currentTranslation > 0 ? 0 : -max;
-    const fixed = boundary - panOffset;
-    const dynamic = panTranslation - fixed;
-    return boundary + dynamic * 0.5;
-  }
-
-  return raw;
-}

package/core/utils/compute-offset-if-size-changed.ts

@@ -1,14 +0,0 @@
-export function computeOffsetIfSizeChanged(params: {
-  handlerOffset: number;
-  prevSize: number;
-  size: number;
-}) {
-  "worklet";
-  const { handlerOffset, prevSize, size } = params;
-
-  if (!prevSize) {
-    return handlerOffset;
-  }
-
-  return (handlerOffset / prevSize) * size;
-}

package/core/utils/computed-with-auto-fill-data.ts

@@ -1,92 +0,0 @@
-import { DATA_LENGTH } from "../constants";
-
-const { SINGLE_ITEM, DOUBLE_ITEM } = DATA_LENGTH;
-
-function isAutoFillData(params: { autoFillData: boolean; loop: boolean }) {
-  "worklet";
-  return !!params.loop && !!params.autoFillData;
-}
-
-type BaseParams<T extends object> = {
-  autoFillData: boolean;
-  loop: boolean;
-} & T;
-
-export function convertToSharedIndex(params: BaseParams<{ index: number; rawDataLength: number }>) {
-  "worklet";
-  const { loop, rawDataLength, index, autoFillData } = params;
-
-  if (isAutoFillData({ loop, autoFillData })) {
-    switch (rawDataLength) {
-      case SINGLE_ITEM:
-        return 0;
-      case DOUBLE_ITEM:
-        return index % 2;
-    }
-  }
-
-  return index;
-}
-
-export function computedOffsetXValueWithAutoFillData(
-  params: BaseParams<{
-    rawDataLength: number;
-    value: number;
-    size: number;
-  }>
-) {
-  "worklet";
-
-  const { rawDataLength, value, size, loop, autoFillData } = params;
-
-  if (isAutoFillData({ loop, autoFillData })) {
-    switch (rawDataLength) {
-      case SINGLE_ITEM:
-        return value % size;
-      case DOUBLE_ITEM:
-        return value % (size * 2);
-    }
-  }
-
-  return value;
-}
-
-export function computedRealIndexWithAutoFillData(
-  params: BaseParams<{
-    index: number;
-    dataLength: number;
-  }>
-) {
-  const { index, dataLength, loop, autoFillData } = params;
-
-  if (isAutoFillData({ loop, autoFillData })) {
-    switch (dataLength) {
-      case SINGLE_ITEM:
-        return index % 1;
-      case DOUBLE_ITEM:
-        return index % 2;
-    }
-  }
-
-  return index;
-}
-
-export function computedFillDataWithAutoFillData<T>(
-  params: BaseParams<{
-    data: T[];
-    dataLength: number;
-  }>
-): T[] {
-  const { data, loop, autoFillData, dataLength } = params;
-
-  if (isAutoFillData({ loop, autoFillData })) {
-    switch (dataLength) {
-      case SINGLE_ITEM:
-        return [data[0]!, data[0]!, data[0]!];
-      case DOUBLE_ITEM:
-        return [data[0]!, data[1]!, data[0]!, data[1]!];
-    }
-  }
-
-  return data;
-}

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

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

package/core/utils/log.ts

@@ -1,12 +0,0 @@
-/**
- * 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/core/utils/sanitize-animation-style.ts

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