react-native-timer-picker 2.6.0 → 2.6.1

package/dist/commonjs/utils/getDurationAndIndexFromScrollOffset.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDurationAndIndexFromScrollOffset = void 0;
+/**
+ * Calculates the duration value and index from a scroll offset in a number picker.
+ * Handles both infinite and non-infinite scroll modes, taking into account padding and item height.
+ *
+ * @param {Object} variables - Configuration object for scroll offset calculation
+ * @param {boolean} variables.disableInfiniteScroll - Whether infinite scroll is disabled
+ * @param {number} variables.interval - The interval between consecutive numbers
+ * @param {number} variables.itemHeight - Height of each item in the picker
+ * @param {number} variables.numberOfItems - Total number of items in the picker
+ * @param {number} variables.padWithNItems - Number of empty items to pad with
+ * @param {number} variables.yContentOffset - The vertical scroll offset
+ *
+ * @returns {{ duration: number; index: number }} Object containing the calculated duration and index
+ *
+ * @example
+ * // With infinite scroll enabled
+ * getDurationAndIndexFromScrollOffset({
+ *   disableInfiniteScroll: false,
+ *   interval: 1,
+ *   itemHeight: 50,
+ *   numberOfItems: 24,
+ *   padWithNItems: 2,
+ *   yContentOffset: 100
+ * })
+ * // Returns: { duration: 2, index: 2 }
+ *
+ * @example
+ * // With infinite scroll disabled
+ * getDurationAndIndexFromScrollOffset({
+ *   disableInfiniteScroll: true,
+ *   interval: 1,
+ *   itemHeight: 50,
+ *   numberOfItems: 24,
+ *   padWithNItems: 2,
+ *   yContentOffset: 100
+ * })
+ * // Returns: { duration: 2, index: 2 }
+ */
+const getDurationAndIndexFromScrollOffset = variables => {
+  const {
+    disableInfiniteScroll,
+    interval,
+    itemHeight,
+    numberOfItems,
+    padWithNItems,
+    yContentOffset
+  } = variables;
+  const index = Math.round(yContentOffset / itemHeight);
+  const duration = (disableInfiniteScroll ? index : index + padWithNItems) % numberOfItems * interval;
+  return {
+    duration,
+    index
+  };
+};
+exports.getDurationAndIndexFromScrollOffset = getDurationAndIndexFromScrollOffset;
+//# sourceMappingURL=getDurationAndIndexFromScrollOffset.js.map

package/dist/commonjs/utils/getDurationAndIndexFromScrollOffset.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getDurationAndIndexFromScrollOffset","variables","disableInfiniteScroll","interval","itemHeight","numberOfItems","padWithNItems","yContentOffset","index","Math","round","duration","exports"],"sources":["getDurationAndIndexFromScrollOffset.ts"],"sourcesContent":["/**\n * Calculates the duration value and index from a scroll offset in a number picker.\n * Handles both infinite and non-infinite scroll modes, taking into account padding and item height.\n *\n * @param {Object} variables - Configuration object for scroll offset calculation\n * @param {boolean} variables.disableInfiniteScroll - Whether infinite scroll is disabled\n * @param {number} variables.interval - The interval between consecutive numbers\n * @param {number} variables.itemHeight - Height of each item in the picker\n * @param {number} variables.numberOfItems - Total number of items in the picker\n * @param {number} variables.padWithNItems - Number of empty items to pad with\n * @param {number} variables.yContentOffset - The vertical scroll offset\n *\n * @returns {{ duration: number; index: number }} Object containing the calculated duration and index\n *\n * @example\n * // With infinite scroll enabled\n * getDurationAndIndexFromScrollOffset({\n *   disableInfiniteScroll: false,\n *   interval: 1,\n *   itemHeight: 50,\n *   numberOfItems: 24,\n *   padWithNItems: 2,\n *   yContentOffset: 100\n * })\n * // Returns: { duration: 2, index: 2 }\n *\n * @example\n * // With infinite scroll disabled\n * getDurationAndIndexFromScrollOffset({\n *   disableInfiniteScroll: true,\n *   interval: 1,\n *   itemHeight: 50,\n *   numberOfItems: 24,\n *   padWithNItems: 2,\n *   yContentOffset: 100\n * })\n * // Returns: { duration: 2, index: 2 }\n */\nexport const getDurationAndIndexFromScrollOffset = (variables: {\n  disableInfiniteScroll: boolean;\n  interval: number;\n  itemHeight: number;\n  numberOfItems: number;\n  padWithNItems: number;\n  yContentOffset: number;\n}) => {\n  const {\n    disableInfiniteScroll,\n    interval,\n    itemHeight,\n    numberOfItems,\n    padWithNItems,\n    yContentOffset,\n  } = variables;\n\n  const index = Math.round(yContentOffset / itemHeight);\n\n  const duration =\n    ((disableInfiniteScroll ? index : index + padWithNItems) % numberOfItems) * interval;\n\n  return {\n    duration,\n    index,\n  };\n};\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,mCAAmC,GAAIC,SAOnD,IAAK;EACJ,MAAM;IACJC,qBAAqB;IACrBC,QAAQ;IACRC,UAAU;IACVC,aAAa;IACbC,aAAa;IACbC;EACF,CAAC,GAAGN,SAAS;EAEb,MAAMO,KAAK,GAAGC,IAAI,CAACC,KAAK,CAACH,cAAc,GAAGH,UAAU,CAAC;EAErD,MAAMO,QAAQ,GACX,CAACT,qBAAqB,GAAGM,KAAK,GAAGA,KAAK,GAAGF,aAAa,IAAID,aAAa,GAAIF,QAAQ;EAEtF,OAAO;IACLQ,QAAQ;IACRH;EACF,CAAC;AACH,CAAC;AAACI,OAAA,CAAAZ,mCAAA,GAAAA,mCAAA","ignoreList":[]}

package/dist/commonjs/utils/getInitialScrollIndex.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getInitialScrollIndex = void 0;
+/**
+ * Calculates the initial scroll index for a number picker based on the desired value and configuration.
+ * Handles both infinite and non-infinite scroll modes, taking into account padding and repetition.
+ *
+ * @param {Object} variables - Configuration object for scroll index calculation
+ * @param {boolean} variables.disableInfiniteScroll - Whether infinite scroll is disabled
+ * @param {number} variables.interval - The interval between consecutive numbers
+ * @param {number} variables.numberOfItems - Total number of items in the picker
+ * @param {number} variables.padWithNItems - Number of empty items to pad with
+ * @param {number} variables.repeatNumbersNTimes - How many times to repeat the number sequence
+ * @param {number} variables.value - The desired initial value
+ *
+ * @returns {number} The calculated initial scroll index
+ *
+ * @example
+ * // With infinite scroll enabled
+ * getInitialScrollIndex({
+ *   disableInfiniteScroll: false,
+ *   interval: 1,
+ *   numberOfItems: 24,
+ *   padWithNItems: 2,
+ *   repeatNumbersNTimes: 3,
+ *   value: 12
+ * })
+ * // Returns: 38
+ *
+ * @example
+ * // With infinite scroll disabled
+ * getInitialScrollIndex({
+ *   disableInfiniteScroll: true,
+ *   interval: 1,
+ *   numberOfItems: 24,
+ *   padWithNItems: 2,
+ *   repeatNumbersNTimes: 1,
+ *   value: 12
+ * })
+ * // Returns: 12
+ */
+const getInitialScrollIndex = variables => {
+  const {
+    disableInfiniteScroll,
+    interval,
+    numberOfItems,
+    padWithNItems,
+    repeatNumbersNTimes,
+    value
+  } = variables;
+  return Math.max(numberOfItems * Math.floor(repeatNumbersNTimes / 2) + (value / interval + numberOfItems) % numberOfItems - (!disableInfiniteScroll ? padWithNItems : 0), 0);
+};
+exports.getInitialScrollIndex = getInitialScrollIndex;
+//# sourceMappingURL=getInitialScrollIndex.js.map

package/dist/commonjs/utils/getInitialScrollIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getInitialScrollIndex","variables","disableInfiniteScroll","interval","numberOfItems","padWithNItems","repeatNumbersNTimes","value","Math","max","floor","exports"],"sources":["getInitialScrollIndex.ts"],"sourcesContent":["/**\n * Calculates the initial scroll index for a number picker based on the desired value and configuration.\n * Handles both infinite and non-infinite scroll modes, taking into account padding and repetition.\n *\n * @param {Object} variables - Configuration object for scroll index calculation\n * @param {boolean} variables.disableInfiniteScroll - Whether infinite scroll is disabled\n * @param {number} variables.interval - The interval between consecutive numbers\n * @param {number} variables.numberOfItems - Total number of items in the picker\n * @param {number} variables.padWithNItems - Number of empty items to pad with\n * @param {number} variables.repeatNumbersNTimes - How many times to repeat the number sequence\n * @param {number} variables.value - The desired initial value\n *\n * @returns {number} The calculated initial scroll index\n *\n * @example\n * // With infinite scroll enabled\n * getInitialScrollIndex({\n *   disableInfiniteScroll: false,\n *   interval: 1,\n *   numberOfItems: 24,\n *   padWithNItems: 2,\n *   repeatNumbersNTimes: 3,\n *   value: 12\n * })\n * // Returns: 38\n *\n * @example\n * // With infinite scroll disabled\n * getInitialScrollIndex({\n *   disableInfiniteScroll: true,\n *   interval: 1,\n *   numberOfItems: 24,\n *   padWithNItems: 2,\n *   repeatNumbersNTimes: 1,\n *   value: 12\n * })\n * // Returns: 12\n */\nexport const getInitialScrollIndex = (variables: {\n  disableInfiniteScroll: boolean;\n  interval: number;\n  numberOfItems: number;\n  padWithNItems: number;\n  repeatNumbersNTimes: number;\n  value: number;\n}) => {\n  const {\n    disableInfiniteScroll,\n    interval,\n    numberOfItems,\n    padWithNItems,\n    repeatNumbersNTimes,\n    value,\n  } = variables;\n\n  return Math.max(\n    numberOfItems * Math.floor(repeatNumbersNTimes / 2) +\n      ((value / interval + numberOfItems) % numberOfItems) -\n      (!disableInfiniteScroll ? padWithNItems : 0),\n    0\n  );\n};\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,qBAAqB,GAAIC,SAOrC,IAAK;EACJ,MAAM;IACJC,qBAAqB;IACrBC,QAAQ;IACRC,aAAa;IACbC,aAAa;IACbC,mBAAmB;IACnBC;EACF,CAAC,GAAGN,SAAS;EAEb,OAAOO,IAAI,CAACC,GAAG,CACbL,aAAa,GAAGI,IAAI,CAACE,KAAK,CAACJ,mBAAmB,GAAG,CAAC,CAAC,GAChD,CAACC,KAAK,GAAGJ,QAAQ,GAAGC,aAAa,IAAIA,aAAc,IACnD,CAACF,qBAAqB,GAAGG,aAAa,GAAG,CAAC,CAAC,EAC9C,CACF,CAAC;AACH,CAAC;AAACM,OAAA,CAAAX,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/dist/commonjs/utils/getSafeInitialValue.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSafeInitialValue = void 0;
+/**
+ * Safely extracts and validates initial duration values, ensuring all values are valid numbers.
+ * Returns a duration object with safe default values (0) for any invalid or missing inputs.
+ *
+ * @param {Object} [initialValue] - Optional initial duration values
+ * @param {number} [initialValue.days] - Initial days value
+ * @param {number} [initialValue.hours] - Initial hours value
+ * @param {number} [initialValue.minutes] - Initial minutes value
+ * @param {number} [initialValue.seconds] - Initial seconds value
+ *
+ * @returns {{ days: number; hours: number; minutes: number; seconds: number }} An object containing safe duration values
+ *
+ * @example
+ * // With valid values
+ * getSafeInitialValue({ days: 1, hours: 2, minutes: 30, seconds: 45 })
+ * // Returns: { days: 1, hours: 2, minutes: 30, seconds: 45 }
+ *
+ * @example
+ * // With invalid values
+ * getSafeInitialValue({ days: NaN, hours: 'invalid', minutes: undefined })
+ * // Returns: { days: 0, hours: 0, minutes: 0, seconds: 0 }
+ *
+ * @example
+ * // With undefined input
+ * getSafeInitialValue(undefined)
+ * // Returns: { days: 0, hours: 0, minutes: 0, seconds: 0 }
+ */
+const getSafeInitialValue = initialValue => ({
+  days: typeof (initialValue === null || initialValue === void 0 ? void 0 : initialValue.days) === "number" && !isNaN(initialValue === null || initialValue === void 0 ? void 0 : initialValue.days) ? initialValue.days : 0,
+  hours: typeof (initialValue === null || initialValue === void 0 ? void 0 : initialValue.hours) === "number" && !isNaN(initialValue === null || initialValue === void 0 ? void 0 : initialValue.hours) ? initialValue.hours : 0,
+  minutes: typeof (initialValue === null || initialValue === void 0 ? void 0 : initialValue.minutes) === "number" && !isNaN(initialValue === null || initialValue === void 0 ? void 0 : initialValue.minutes) ? initialValue.minutes : 0,
+  seconds: typeof (initialValue === null || initialValue === void 0 ? void 0 : initialValue.seconds) === "number" && !isNaN(initialValue === null || initialValue === void 0 ? void 0 : initialValue.seconds) ? initialValue.seconds : 0
+});
+exports.getSafeInitialValue = getSafeInitialValue;
+//# sourceMappingURL=getSafeInitialValue.js.map

package/dist/commonjs/utils/getSafeInitialValue.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getSafeInitialValue","initialValue","days","isNaN","hours","minutes","seconds","exports"],"sources":["getSafeInitialValue.ts"],"sourcesContent":["/**\n * Safely extracts and validates initial duration values, ensuring all values are valid numbers.\n * Returns a duration object with safe default values (0) for any invalid or missing inputs.\n *\n * @param {Object} [initialValue] - Optional initial duration values\n * @param {number} [initialValue.days] - Initial days value\n * @param {number} [initialValue.hours] - Initial hours value\n * @param {number} [initialValue.minutes] - Initial minutes value\n * @param {number} [initialValue.seconds] - Initial seconds value\n *\n * @returns {{ days: number; hours: number; minutes: number; seconds: number }} An object containing safe duration values\n *\n * @example\n * // With valid values\n * getSafeInitialValue({ days: 1, hours: 2, minutes: 30, seconds: 45 })\n * // Returns: { days: 1, hours: 2, minutes: 30, seconds: 45 }\n *\n * @example\n * // With invalid values\n * getSafeInitialValue({ days: NaN, hours: 'invalid', minutes: undefined })\n * // Returns: { days: 0, hours: 0, minutes: 0, seconds: 0 }\n *\n * @example\n * // With undefined input\n * getSafeInitialValue(undefined)\n * // Returns: { days: 0, hours: 0, minutes: 0, seconds: 0 }\n */\nexport const getSafeInitialValue = (\n  initialValue:\n    | {\n        days?: number;\n        hours?: number;\n        minutes?: number;\n        seconds?: number;\n      }\n    | undefined\n) => ({\n  days:\n    typeof initialValue?.days === \"number\" && !isNaN(initialValue?.days) ? initialValue.days : 0,\n  hours:\n    typeof initialValue?.hours === \"number\" && !isNaN(initialValue?.hours) ? initialValue.hours : 0,\n  minutes:\n    typeof initialValue?.minutes === \"number\" && !isNaN(initialValue?.minutes)\n      ? initialValue.minutes\n      : 0,\n  seconds:\n    typeof initialValue?.seconds === \"number\" && !isNaN(initialValue?.seconds)\n      ? initialValue.seconds\n      : 0,\n});\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,mBAAmB,GAC9BC,YAOa,KACT;EACJC,IAAI,EACF,QAAOD,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEC,IAAI,MAAK,QAAQ,IAAI,CAACC,KAAK,CAACF,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEC,IAAI,CAAC,GAAGD,YAAY,CAACC,IAAI,GAAG,CAAC;EAC9FE,KAAK,EACH,QAAOH,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEG,KAAK,MAAK,QAAQ,IAAI,CAACD,KAAK,CAACF,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEG,KAAK,CAAC,GAAGH,YAAY,CAACG,KAAK,GAAG,CAAC;EACjGC,OAAO,EACL,QAAOJ,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEI,OAAO,MAAK,QAAQ,IAAI,CAACF,KAAK,CAACF,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEI,OAAO,CAAC,GACtEJ,YAAY,CAACI,OAAO,GACpB,CAAC;EACPC,OAAO,EACL,QAAOL,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEK,OAAO,MAAK,QAAQ,IAAI,CAACH,KAAK,CAACF,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEK,OAAO,CAAC,GACtEL,YAAY,CAACK,OAAO,GACpB;AACR,CAAC,CAAC;AAACC,OAAA,CAAAP,mBAAA,GAAAA,mBAAA","ignoreList":[]}

package/dist/commonjs/utils/padNumber.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.padNumber = void 0;
+/**
+ * Formats a number by optionally padding it with a leading zero or space.
+ * Numbers less than 10 are padded based on the options provided.
+ *
+ * @param {number} value - The number to format
+ * @param {Object} [options] - Optional formatting options
+ * @param {boolean} [options.padWithZero] - Whether to pad with zero (true) or space (false)
+ *
+ * @returns {string} The formatted number string
+ *
+ * @example
+ * // Pad with zero
+ * padNumber(5, { padWithZero: true })
+ * // Returns: '05'
+ *
+ * @example
+ * // Pad with figure space (same width as zero)
+ * padNumber(5, { padWithZero: false })
+ * // Returns: ' 5'
+ *
+ * @example
+ * // No padding needed
+ * padNumber(15)
+ * // Returns: '15'
+ */
+const padNumber = (value, options) => {
+  if (value < 10) {
+    return (options !== null && options !== void 0 && options.padWithZero ? "0" : "\u2007") + value;
+  } else {
+    return String(value);
+  }
+};
+exports.padNumber = padNumber;
+//# sourceMappingURL=padNumber.js.map

package/dist/commonjs/utils/padNumber.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["padNumber","value","options","padWithZero","String","exports"],"sources":["padNumber.ts"],"sourcesContent":["/**\n * Formats a number by optionally padding it with a leading zero or space.\n * Numbers less than 10 are padded based on the options provided.\n *\n * @param {number} value - The number to format\n * @param {Object} [options] - Optional formatting options\n * @param {boolean} [options.padWithZero] - Whether to pad with zero (true) or space (false)\n *\n * @returns {string} The formatted number string\n *\n * @example\n * // Pad with zero\n * padNumber(5, { padWithZero: true })\n * // Returns: '05'\n *\n * @example\n * // Pad with figure space (same width as zero)\n * padNumber(5, { padWithZero: false })\n * // Returns: ' 5'\n *\n * @example\n * // No padding needed\n * padNumber(15)\n * // Returns: '15'\n */\nexport const padNumber = (value: number, options?: { padWithZero?: boolean }): string => {\n  if (value < 10) {\n    return (options?.padWithZero ? \"0\" : \"\\u2007\") + value;\n  } else {\n    return String(value);\n  }\n};\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,SAAS,GAAGA,CAACC,KAAa,EAAEC,OAAmC,KAAa;EACvF,IAAID,KAAK,GAAG,EAAE,EAAE;IACd,OAAO,CAACC,OAAO,aAAPA,OAAO,eAAPA,OAAO,CAAEC,WAAW,GAAG,GAAG,GAAG,QAAQ,IAAIF,KAAK;EACxD,CAAC,MAAM;IACL,OAAOG,MAAM,CAACH,KAAK,CAAC;EACtB;AACF,CAAC;AAACI,OAAA,CAAAL,SAAA,GAAAA,SAAA","ignoreList":[]}

package/dist/module/components/DurationScroll/DurationScroll.js

@@ -0,0 +1,418 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import React, { useRef, useCallback, forwardRef, useImperativeHandle, useState, useEffect, useMemo } from "react";
+import { View, Text, FlatList as RNFlatList } from "react-native";
+import { colorToRgba } from "../../utils/colorToRgba";
+import { generate12HourNumbers, generateNumbers } from "../../utils/generateNumbers";
+import { getAdjustedLimit } from "../../utils/getAdjustedLimit";
+import { getDurationAndIndexFromScrollOffset } from "../../utils/getDurationAndIndexFromScrollOffset";
+import { getInitialScrollIndex } from "../../utils/getInitialScrollIndex";
+import PickerItem from "../PickerItem";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const keyExtractor = (item, index) => index.toString();
+const DurationScroll = /*#__PURE__*/forwardRef((props, ref) => {
+  const {
+    aggressivelyGetLatestDuration,
+    allowFontScaling = false,
+    amLabel,
+    Audio,
+    clickSoundAsset,
+    decelerationRate = 0.88,
+    disableInfiniteScroll = false,
+    FlatList = RNFlatList,
+    Haptics,
+    initialValue = 0,
+    interval,
+    is12HourPicker,
+    isDisabled,
+    label,
+    limit,
+    LinearGradient,
+    MaskedView,
+    maximumValue,
+    onDurationChange,
+    padNumbersWithZero = false,
+    padWithNItems,
+    pickerColumnWidth,
+    pickerFeedback,
+    pickerGradientOverlayProps,
+    pickerLabelGap,
+    pmLabel,
+    repeatNumbersNTimes = 3,
+    repeatNumbersNTimesNotExplicitlySet,
+    selectedValue,
+    styles,
+    testID
+  } = props;
+  const labelPositionStyle = useMemo(() => {
+    // When the style already has an explicit `left` (from legacy percentage system or
+    // user override), don't apply pixel-based positioning.
+    if (styles.pickerLabelContainer.left != null) {
+      return undefined;
+    }
+    const gap = pickerLabelGap ?? 6;
+    const fontSize = styles.pickerItem.fontSize ?? 25;
+    const maxDigitCount = Math.max(2, String(maximumValue).length);
+    const halfNumberWidth = maxDigitCount * fontSize * 0.55 / 2;
+    return {
+      left: "50%",
+      marginLeft: halfNumberWidth + gap
+    };
+  }, [maximumValue, pickerLabelGap, styles.pickerItem.fontSize, styles.pickerLabelContainer.left]);
+  const numberOfItems = useMemo(() => {
+    // guard against negative maximum values
+    if (maximumValue < 0) {
+      return 1;
+    }
+    return Math.floor(maximumValue / interval) + 1;
+  }, [interval, maximumValue]);
+  const safeRepeatNumbersNTimes = useMemo(() => {
+    // do not repeat numbers if there is only one option
+    if (numberOfItems === 1) {
+      return 1;
+    }
+    if (!disableInfiniteScroll && repeatNumbersNTimes < 2) {
+      return 2;
+    } else if (repeatNumbersNTimes < 1 || isNaN(repeatNumbersNTimes)) {
+      return 1;
+    }
+
+    // if this variable is not explicitly set, we calculate a reasonable value based on
+    // the number of items in the picker, avoiding regular jumps up/down the list
+    // whilst avoiding rendering too many items in the picker
+    if (repeatNumbersNTimesNotExplicitlySet) {
+      return Math.max(Math.round(180 / numberOfItems), 1);
+    }
+    return Math.round(repeatNumbersNTimes);
+  }, [disableInfiniteScroll, numberOfItems, repeatNumbersNTimes, repeatNumbersNTimesNotExplicitlySet]);
+  const numbersForFlatList = useMemo(() => {
+    if (is12HourPicker) {
+      return generate12HourNumbers({
+        disableInfiniteScroll,
+        interval,
+        padNumbersWithZero,
+        padWithNItems,
+        repeatNTimes: safeRepeatNumbersNTimes
+      });
+    }
+    return generateNumbers(numberOfItems, {
+      disableInfiniteScroll,
+      interval,
+      padNumbersWithZero,
+      padWithNItems,
+      repeatNTimes: safeRepeatNumbersNTimes
+    });
+  }, [disableInfiniteScroll, is12HourPicker, interval, numberOfItems, padNumbersWithZero, padWithNItems, safeRepeatNumbersNTimes]);
+  const initialScrollIndex = useMemo(() => getInitialScrollIndex({
+    disableInfiniteScroll,
+    interval,
+    numberOfItems,
+    padWithNItems,
+    repeatNumbersNTimes: safeRepeatNumbersNTimes,
+    value: initialValue
+  }), [disableInfiniteScroll, initialValue, interval, numberOfItems, padWithNItems, safeRepeatNumbersNTimes]);
+  const adjustedLimited = useMemo(() => getAdjustedLimit(limit, numberOfItems, interval), [interval, limit, numberOfItems]);
+  const numberOfItemsToShow = 1 + padWithNItems * 2;
+
+  // keep track of the latest duration as it scrolls
+  const latestDuration = useRef(0);
+  // keep track of the last index scrolled past for haptic/audio feedback
+  const lastFeedbackIndex = useRef(0);
+  const flatListRef = useRef(null);
+  const [clickSound, setClickSound] = useState(null);
+  useEffect(() => {
+    // Audio prop deprecated in v2.2.0 (use pickerFeedback instead) - will be removed in a future version
+
+    // preload the sound when the component mounts
+    let soundInstance = null;
+    const loadSound = async () => {
+      if (!Audio) {
+        return;
+      }
+      try {
+        const {
+          sound: newSound
+        } = await Audio.Sound.createAsync(clickSoundAsset ?? {
+          // use a hosted sound as a fallback (do not use local asset due to loader issues
+          // in some environments when including mp3 in library)
+          uri: "https://drive.google.com/uc?export=download&id=10e1YkbNsRh-vGx1jmS1Nntz8xzkBp4_I"
+        }, {
+          shouldPlay: false
+        });
+        soundInstance = newSound;
+        setClickSound(newSound);
+      } catch (error) {
+        console.warn("Failed to load click sound:", error);
+      }
+    };
+    loadSound();
+    return () => {
+      var _soundInstance;
+      // unload sound when component unmounts
+      (_soundInstance = soundInstance) === null || _soundInstance === void 0 || _soundInstance.unloadAsync();
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [Audio]);
+  const playClickSound = useCallback(async () => {
+    if (!clickSound) return;
+    try {
+      await clickSound.replayAsync();
+    } catch (error) {
+      console.warn("Failed to play click sound:", error);
+    }
+  }, [clickSound]);
+  const renderItem = useCallback(({
+    item
+  }) => /*#__PURE__*/React.createElement(PickerItem, {
+    adjustedLimitedMax: adjustedLimited.max,
+    adjustedLimitedMin: adjustedLimited.min,
+    allowFontScaling: allowFontScaling,
+    amLabel: amLabel,
+    is12HourPicker: is12HourPicker,
+    item: item,
+    pickerAmPmPositionStyle: labelPositionStyle,
+    pmLabel: pmLabel,
+    selectedValue: selectedValue,
+    styles: styles
+  }), [adjustedLimited.max, adjustedLimited.min, allowFontScaling, amLabel, is12HourPicker, labelPositionStyle, pmLabel, selectedValue, styles]);
+  const onScroll = useCallback(e => {
+    // this function is only used when the picker is in a modal and/or has Haptic/Audio feedback
+    // it is used to ensure that the modal gets the latest duration on clicking
+    // the confirm button, even if the scrollview is still scrolling
+    if (!aggressivelyGetLatestDuration && !Haptics && !Audio && !pickerFeedback) {
+      return;
+    }
+    if (aggressivelyGetLatestDuration) {
+      const newValues = getDurationAndIndexFromScrollOffset({
+        disableInfiniteScroll,
+        interval,
+        itemHeight: styles.pickerItemContainer.height,
+        numberOfItems,
+        padWithNItems,
+        yContentOffset: e.nativeEvent.contentOffset.y
+      });
+      if (newValues.duration !== latestDuration.current) {
+        // check limits
+        if (newValues.duration > adjustedLimited.max) {
+          newValues.duration = adjustedLimited.max;
+        } else if (newValues.duration < adjustedLimited.min) {
+          newValues.duration = adjustedLimited.min;
+        }
+        latestDuration.current = newValues.duration;
+      }
+    }
+    if (pickerFeedback || Haptics || Audio) {
+      const feedbackIndex = Math.round((e.nativeEvent.contentOffset.y + styles.pickerItemContainer.height / 2) / styles.pickerItemContainer.height);
+      if (feedbackIndex !== lastFeedbackIndex.current) {
+        // this check stops the feedback firing when the component mounts
+        if (lastFeedbackIndex.current) {
+          // fire haptic feedback if available
+          try {
+            Haptics === null || Haptics === void 0 || Haptics.selectionAsync();
+          } catch {
+            // do nothing
+          }
+
+          // play click sound if available
+          try {
+            playClickSound();
+          } catch {
+            // do nothing
+          }
+
+          // fire custom feedback if available
+          try {
+            pickerFeedback === null || pickerFeedback === void 0 || pickerFeedback();
+          } catch {
+            // do nothing
+          }
+        }
+        lastFeedbackIndex.current = feedbackIndex;
+      }
+    }
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [adjustedLimited.max, adjustedLimited.min, aggressivelyGetLatestDuration, playClickSound, disableInfiniteScroll, interval, numberOfItems, padWithNItems, styles.pickerItemContainer.height]);
+  const onMomentumScrollEnd = useCallback(e => {
+    const newValues = getDurationAndIndexFromScrollOffset({
+      disableInfiniteScroll,
+      interval,
+      itemHeight: styles.pickerItemContainer.height,
+      numberOfItems,
+      padWithNItems,
+      yContentOffset: e.nativeEvent.contentOffset.y
+    });
+
+    // check limits
+    if (newValues.duration > adjustedLimited.max) {
+      var _flatListRef$current;
+      const targetScrollIndex = newValues.index - (newValues.duration - adjustedLimited.max);
+      (_flatListRef$current = flatListRef.current) === null || _flatListRef$current === void 0 || _flatListRef$current.scrollToIndex({
+        animated: true,
+        index:
+        // guard against scrolling beyond end of list
+        targetScrollIndex >= 0 ? targetScrollIndex : adjustedLimited.max - 1
+      }); // scroll down to max
+      newValues.duration = adjustedLimited.max;
+    } else if (newValues.duration < adjustedLimited.min) {
+      var _flatListRef$current2;
+      const targetScrollIndex = newValues.index + (adjustedLimited.min - newValues.duration);
+      (_flatListRef$current2 = flatListRef.current) === null || _flatListRef$current2 === void 0 || _flatListRef$current2.scrollToIndex({
+        animated: true,
+        index:
+        // guard against scrolling beyond end of list
+        targetScrollIndex <= numbersForFlatList.length - 1 ? targetScrollIndex : adjustedLimited.min
+      }); // scroll up to min
+      newValues.duration = adjustedLimited.min;
+    }
+    onDurationChange(newValues.duration);
+  }, [disableInfiniteScroll, interval, styles.pickerItemContainer.height, numberOfItems, padWithNItems, adjustedLimited.max, adjustedLimited.min, onDurationChange, numbersForFlatList.length]);
+  const onViewableItemsChanged = useCallback(({
+    viewableItems
+  }) => {
+    var _viewableItems$, _viewableItems$2;
+    if (numberOfItems === 1) {
+      return;
+    }
+    if ((_viewableItems$ = viewableItems[0]) !== null && _viewableItems$ !== void 0 && _viewableItems$.index && viewableItems[0].index < numberOfItems * 0.5) {
+      var _flatListRef$current3;
+      (_flatListRef$current3 = flatListRef.current) === null || _flatListRef$current3 === void 0 || _flatListRef$current3.scrollToIndex({
+        animated: false,
+        index: viewableItems[0].index + numberOfItems
+      });
+    } else if ((_viewableItems$2 = viewableItems[0]) !== null && _viewableItems$2 !== void 0 && _viewableItems$2.index && viewableItems[0].index >= numberOfItems * (safeRepeatNumbersNTimes - 0.5)) {
+      var _flatListRef$current4;
+      (_flatListRef$current4 = flatListRef.current) === null || _flatListRef$current4 === void 0 || _flatListRef$current4.scrollToIndex({
+        animated: false,
+        index: viewableItems[0].index - numberOfItems
+      });
+    }
+  }, [numberOfItems, safeRepeatNumbersNTimes]);
+  const [viewabilityConfigCallbackPairs, setViewabilityConfigCallbackPairs] = useState(!disableInfiniteScroll ? [{
+    onViewableItemsChanged: onViewableItemsChanged,
+    viewabilityConfig: {
+      viewAreaCoveragePercentThreshold: 0
+    }
+  }] : undefined);
+  const [flatListRenderKey, setFlatListRenderKey] = useState(0);
+  const initialRender = useRef(true);
+  useEffect(() => {
+    // don't run on first render
+    if (initialRender.current) {
+      initialRender.current = false;
+      return;
+    }
+
+    // if the onViewableItemsChanged callback changes, we need to update viewabilityConfigCallbackPairs
+    // which requires the FlatList to be remounted, hence the increase of the FlatList key
+    setFlatListRenderKey(prev => prev + 1);
+    setViewabilityConfigCallbackPairs(!disableInfiniteScroll ? [{
+      onViewableItemsChanged: onViewableItemsChanged,
+      viewabilityConfig: {
+        viewAreaCoveragePercentThreshold: 0
+      }
+    }] : undefined);
+  }, [disableInfiniteScroll, onViewableItemsChanged]);
+  const getItemLayout = useCallback((_, index) => ({
+    index,
+    length: styles.pickerItemContainer.height,
+    offset: styles.pickerItemContainer.height * index
+  }), [styles.pickerItemContainer.height]);
+  useImperativeHandle(ref, () => ({
+    latestDuration: latestDuration,
+    reset: options => {
+      var _flatListRef$current5;
+      (_flatListRef$current5 = flatListRef.current) === null || _flatListRef$current5 === void 0 || _flatListRef$current5.scrollToIndex({
+        animated: (options === null || options === void 0 ? void 0 : options.animated) ?? false,
+        index: initialScrollIndex
+      });
+    },
+    setValue: (value, options) => {
+      var _flatListRef$current6;
+      (_flatListRef$current6 = flatListRef.current) === null || _flatListRef$current6 === void 0 || _flatListRef$current6.scrollToIndex({
+        animated: (options === null || options === void 0 ? void 0 : options.animated) ?? false,
+        index: getInitialScrollIndex({
+          disableInfiniteScroll,
+          interval,
+          numberOfItems,
+          padWithNItems,
+          repeatNumbersNTimes: safeRepeatNumbersNTimes,
+          value: value
+        })
+      });
+    }
+  }));
+  const renderContent = useMemo(() => {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(FlatList, {
+      key: flatListRenderKey,
+      ref: flatListRef,
+      contentContainerStyle: styles.durationScrollFlatListContentContainer,
+      data: numbersForFlatList,
+      decelerationRate: decelerationRate,
+      getItemLayout: getItemLayout,
+      initialScrollIndex: initialScrollIndex,
+      keyExtractor: keyExtractor,
+      nestedScrollEnabled: true,
+      onMomentumScrollEnd: onMomentumScrollEnd,
+      onScroll: onScroll,
+      renderItem: renderItem,
+      scrollEnabled: !isDisabled,
+      scrollEventThrottle: 16,
+      showsVerticalScrollIndicator: false,
+      snapToAlignment: "start"
+      // used in place of snapToInterval due to bug on Android
+      ,
+      snapToOffsets: [...Array(numbersForFlatList.length)].map((_, i) => i * styles.pickerItemContainer.height),
+      style: styles.durationScrollFlatList,
+      testID: "duration-scroll-flatlist",
+      viewabilityConfigCallbackPairs: viewabilityConfigCallbackPairs,
+      windowSize: numberOfItemsToShow
+    }), /*#__PURE__*/React.createElement(View, {
+      pointerEvents: "none",
+      style: [styles.pickerLabelContainer, labelPositionStyle]
+    }, typeof label === "string" ? /*#__PURE__*/React.createElement(Text, {
+      allowFontScaling: allowFontScaling,
+      style: styles.pickerLabel
+    }, label) : label ?? null));
+  }, [FlatList, allowFontScaling, decelerationRate, flatListRenderKey, getItemLayout, initialScrollIndex, isDisabled, label, labelPositionStyle, numberOfItemsToShow, numbersForFlatList, onMomentumScrollEnd, onScroll, renderItem, styles.durationScrollFlatList, styles.durationScrollFlatListContentContainer, styles.pickerItemContainer.height, styles.pickerLabel, styles.pickerLabelContainer, viewabilityConfigCallbackPairs]);
+  const renderLinearGradient = useMemo(() => {
+    if (!LinearGradient) {
+      return null;
+    }
+    let colors;
+    if (MaskedView) {
+      // if using masked view, we only care about the opacity
+      colors = ["rgba(0,0,0,0)", "rgba(0,0,0,1)", "rgba(0,0,0,1)", "rgba(0,0,0,0)"];
+    } else {
+      const backgroundColor = styles.pickerContainer.backgroundColor ?? "white";
+      const transparentBackgroundColor = colorToRgba({
+        color: backgroundColor,
+        opacity: 0
+      });
+      colors = [backgroundColor, transparentBackgroundColor, transparentBackgroundColor, backgroundColor];
+    }
+
+    // calculate the gradient height to cover the top item and bottom item
+    const gradientHeight = padWithNItems > 0 ? 1 / (padWithNItems * 2 + 1) : 0.3;
+    return /*#__PURE__*/React.createElement(LinearGradient, _extends({
+      colors: colors,
+      locations: [0, gradientHeight, 1 - gradientHeight, 1],
+      pointerEvents: "none",
+      style: styles.pickerGradientOverlay
+    }, pickerGradientOverlayProps));
+  }, [LinearGradient, MaskedView, padWithNItems, pickerGradientOverlayProps, styles.pickerContainer.backgroundColor, styles.pickerGradientOverlay]);
+  return /*#__PURE__*/React.createElement(View, {
+    pointerEvents: isDisabled ? "none" : undefined,
+    style: [styles.durationScrollFlatListContainer, pickerColumnWidth != null && {
+      flex: 0,
+      width: pickerColumnWidth
+    }, {
+      height: styles.pickerItemContainer.height * numberOfItemsToShow
+    }, isDisabled && styles.disabledPickerContainer],
+    testID: testID
+  }, MaskedView ? /*#__PURE__*/React.createElement(MaskedView, {
+    maskElement: renderLinearGradient,
+    style: [styles.maskedView]
+  }, renderContent) : /*#__PURE__*/React.createElement(React.Fragment, null, renderContent, renderLinearGradient));
+});
+export default /*#__PURE__*/React.memo(DurationScroll);
+//# sourceMappingURL=DurationScroll.js.map