react-native-timer-picker 2.1.0 → 2.2.0

package/dist/commonjs/utils/getDurationAndIndexFromScrollOffset.js

@@ -4,6 +4,44 @@ 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,

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

@@ -1 +1 @@
-{"version":3,"names":["getDurationAndIndexFromScrollOffset","variables","disableInfiniteScroll","interval","itemHeight","numberOfItems","padWithNItems","yContentOffset","index","Math","round","duration","exports"],"sources":["getDurationAndIndexFromScrollOffset.ts"],"sourcesContent":["export 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) %\n            numberOfItems) *\n        interval;\n\n    return {\n        duration,\n        index,\n    };\n};\n"],"mappings":";;;;;;AAAO,MAAMA,mCAAmC,GAAIC,SAOnD,IAAK;EACF,MAAM;IACFC,qBAAqB;IACrBC,QAAQ;IACRC,UAAU;IACVC,aAAa;IACbC,aAAa;IACbC;EACJ,CAAC,GAAGN,SAAS;EAEb,MAAMO,KAAK,GAAGC,IAAI,CAACC,KAAK,CAACH,cAAc,GAAGH,UAAU,CAAC;EAErD,MAAMO,QAAQ,GACT,CAACT,qBAAqB,GAAGM,KAAK,GAAGA,KAAK,GAAGF,aAAa,IACnDD,aAAa,GACjBF,QAAQ;EAEZ,OAAO;IACHQ,QAAQ;IACRH;EACJ,CAAC;AACL,CAAC;AAACI,OAAA,CAAAZ,mCAAA,GAAAA,mCAAA","ignoreList":[]}
+{"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) %\n            numberOfItems) *\n        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;EACF,MAAM;IACFC,qBAAqB;IACrBC,QAAQ;IACRC,UAAU;IACVC,aAAa;IACbC,aAAa;IACbC;EACJ,CAAC,GAAGN,SAAS;EAEb,MAAMO,KAAK,GAAGC,IAAI,CAACC,KAAK,CAACH,cAAc,GAAGH,UAAU,CAAC;EAErD,MAAMO,QAAQ,GACT,CAACT,qBAAqB,GAAGM,KAAK,GAAGA,KAAK,GAAGF,aAAa,IACnDD,aAAa,GACjBF,QAAQ;EAEZ,OAAO;IACHQ,QAAQ;IACRH;EACJ,CAAC;AACL,CAAC;AAACI,OAAA,CAAAZ,mCAAA,GAAAA,mCAAA","ignoreList":[]}

package/dist/commonjs/utils/getInitialScrollIndex.js

@@ -4,6 +4,44 @@ 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,

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

@@ -1 +1 @@
-{"version":3,"names":["getInitialScrollIndex","variables","disableInfiniteScroll","interval","numberOfItems","padWithNItems","repeatNumbersNTimes","value","Math","max","floor","exports"],"sources":["getInitialScrollIndex.ts"],"sourcesContent":["export 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":";;;;;;AAAO,MAAMA,qBAAqB,GAAIC,SAOrC,IAAK;EACF,MAAM;IACFC,qBAAqB;IACrBC,QAAQ;IACRC,aAAa;IACbC,aAAa;IACbC,mBAAmB;IACnBC;EACJ,CAAC,GAAGN,SAAS;EAEb,OAAOO,IAAI,CAACC,GAAG,CACXL,aAAa,GAAGI,IAAI,CAACE,KAAK,CAACJ,mBAAmB,GAAG,CAAC,CAAC,GAC9C,CAACC,KAAK,GAAGJ,QAAQ,GAAGC,aAAa,IAAIA,aAAc,IACnD,CAACF,qBAAqB,GAAGG,aAAa,GAAG,CAAC,CAAC,EAChD,CACJ,CAAC;AACL,CAAC;AAACM,OAAA,CAAAX,qBAAA,GAAAA,qBAAA","ignoreList":[]}
+{"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;EACF,MAAM;IACFC,qBAAqB;IACrBC,QAAQ;IACRC,aAAa;IACbC,aAAa;IACbC,mBAAmB;IACnBC;EACJ,CAAC,GAAGN,SAAS;EAEb,OAAOO,IAAI,CAACC,GAAG,CACXL,aAAa,GAAGI,IAAI,CAACE,KAAK,CAACJ,mBAAmB,GAAG,CAAC,CAAC,GAC9C,CAACC,KAAK,GAAGJ,QAAQ,GAAGC,aAAa,IAAIA,aAAc,IACnD,CAACF,qBAAqB,GAAGG,aAAa,GAAG,CAAC,CAAC,EAChD,CACJ,CAAC;AACL,CAAC;AAACM,OAAA,CAAAX,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/dist/commonjs/utils/getSafeInitialValue.js

@@ -4,7 +4,35 @@ 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

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

@@ -1 +1 @@
-{"version":3,"names":["getSafeInitialValue","initialValue","hours","isNaN","minutes","seconds","exports"],"sources":["getSafeInitialValue.ts"],"sourcesContent":["export const getSafeInitialValue = (\n    initialValue:\n        | {\n              hours?: number;\n              minutes?: number;\n              seconds?: number;\n          }\n        | undefined\n) => ({\n    hours:\n        typeof initialValue?.hours === \"number\" && !isNaN(initialValue?.hours)\n            ? initialValue.hours\n            : 0,\n    minutes:\n        typeof initialValue?.minutes === \"number\" &&\n        !isNaN(initialValue?.minutes)\n            ? initialValue.minutes\n            : 0,\n    seconds:\n        typeof initialValue?.seconds === \"number\" &&\n        !isNaN(initialValue?.seconds)\n            ? initialValue.seconds\n            : 0,\n});\n"],"mappings":";;;;;;AAAO,MAAMA,mBAAmB,GAC5BC,YAMe,KACb;EACFC,KAAK,EACD,QAAOD,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEC,KAAK,MAAK,QAAQ,IAAI,CAACC,KAAK,CAACF,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEC,KAAK,CAAC,GAChED,YAAY,CAACC,KAAK,GAClB,CAAC;EACXE,OAAO,EACH,QAAOH,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEG,OAAO,MAAK,QAAQ,IACzC,CAACD,KAAK,CAACF,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEG,OAAO,CAAC,GACvBH,YAAY,CAACG,OAAO,GACpB,CAAC;EACXC,OAAO,EACH,QAAOJ,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEI,OAAO,MAAK,QAAQ,IACzC,CAACF,KAAK,CAACF,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEI,OAAO,CAAC,GACvBJ,YAAY,CAACI,OAAO,GACpB;AACd,CAAC,CAAC;AAACC,OAAA,CAAAN,mBAAA,GAAAA,mBAAA","ignoreList":[]}
+{"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)\n            ? initialValue.days\n            : 0,\n    hours:\n        typeof initialValue?.hours === \"number\" && !isNaN(initialValue?.hours)\n            ? initialValue.hours\n            : 0,\n    minutes:\n        typeof initialValue?.minutes === \"number\" &&\n        !isNaN(initialValue?.minutes)\n            ? initialValue.minutes\n            : 0,\n    seconds:\n        typeof initialValue?.seconds === \"number\" &&\n        !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,GAC5BC,YAOe,KACb;EACFC,IAAI,EACA,QAAOD,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEC,IAAI,MAAK,QAAQ,IAAI,CAACC,KAAK,CAACF,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEC,IAAI,CAAC,GAC9DD,YAAY,CAACC,IAAI,GACjB,CAAC;EACXE,KAAK,EACD,QAAOH,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEG,KAAK,MAAK,QAAQ,IAAI,CAACD,KAAK,CAACF,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEG,KAAK,CAAC,GAChEH,YAAY,CAACG,KAAK,GAClB,CAAC;EACXC,OAAO,EACH,QAAOJ,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEI,OAAO,MAAK,QAAQ,IACzC,CAACF,KAAK,CAACF,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEI,OAAO,CAAC,GACvBJ,YAAY,CAACI,OAAO,GACpB,CAAC;EACXC,OAAO,EACH,QAAOL,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEK,OAAO,MAAK,QAAQ,IACzC,CAACH,KAAK,CAACF,YAAY,aAAZA,YAAY,uBAAZA,YAAY,CAAEK,OAAO,CAAC,GACvBL,YAAY,CAACK,OAAO,GACpB;AACd,CAAC,CAAC;AAACC,OAAA,CAAAP,mBAAA,GAAAA,mBAAA","ignoreList":[]}

package/dist/commonjs/utils/padNumber.js

@@ -4,6 +4,31 @@ 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 space
+ * 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" : " ") + value;

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

@@ -1 +1 @@
-{"version":3,"names":["padNumber","value","options","padWithZero","String","exports"],"sources":["padNumber.ts"],"sourcesContent":["export const padNumber = (\n    value: number,\n    options?: { padWithZero?: boolean }\n): string => {\n    if (value < 10) {\n        return (options?.padWithZero ? \"0\" : \" \") + value;\n    } else {\n        return String(value);\n    }\n};\n"],"mappings":";;;;;;AAAO,MAAMA,SAAS,GAAGA,CACrBC,KAAa,EACbC,OAAmC,KAC1B;EACT,IAAID,KAAK,GAAG,EAAE,EAAE;IACZ,OAAO,CAACC,OAAO,aAAPA,OAAO,eAAPA,OAAO,CAAEC,WAAW,GAAG,GAAG,GAAG,GAAG,IAAIF,KAAK;EACrD,CAAC,MAAM;IACH,OAAOG,MAAM,CAACH,KAAK,CAAC;EACxB;AACJ,CAAC;AAACI,OAAA,CAAAL,SAAA,GAAAA,SAAA","ignoreList":[]}
+{"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 space\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 = (\n    value: number,\n    options?: { padWithZero?: boolean }\n): string => {\n    if (value < 10) {\n        return (options?.padWithZero ? \"0\" : \" \") + 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,CACrBC,KAAa,EACbC,OAAmC,KAC1B;EACT,IAAID,KAAK,GAAG,EAAE,EAAE;IACZ,OAAO,CAACC,OAAO,aAAPA,OAAO,eAAPA,OAAO,CAAEC,WAAW,GAAG,GAAG,GAAG,GAAG,IAAIF,KAAK;EACrD,CAAC,MAAM;IACH,OAAOG,MAAM,CAACH,KAAK,CAAC;EACxB;AACJ,CAAC;AAACI,OAAA,CAAAL,SAAA,GAAAA,SAAA","ignoreList":[]}

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

@@ -0,0 +1,410 @@
+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";
+// 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,
+    pickerFeedback,
+    pickerGradientOverlayProps,
+    pmLabel,
+    repeatNumbersNTimes = 3,
+    repeatNumbersNTimesNotExplicitlySet,
+    styles,
+    testID
+  } = props;
+  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({
+        padNumbersWithZero,
+        repeatNTimes: safeRepeatNumbersNTimes,
+        disableInfiniteScroll,
+        padWithNItems,
+        interval
+      });
+    }
+    return generateNumbers(numberOfItems, {
+      padNumbersWithZero,
+      repeatNTimes: safeRepeatNumbersNTimes,
+      disableInfiniteScroll,
+      padWithNItems,
+      interval
+    });
+  }, [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
+  }) => {
+    let stringItem = item;
+    let intItem;
+    let isAm;
+    if (!is12HourPicker) {
+      intItem = parseInt(item);
+    } else {
+      isAm = item.includes("AM");
+      stringItem = item.replace(/\s[AP]M/g, "");
+      intItem = parseInt(stringItem);
+    }
+    return /*#__PURE__*/React.createElement(View, {
+      key: item,
+      style: styles.pickerItemContainer,
+      testID: "picker-item"
+    }, /*#__PURE__*/React.createElement(Text, {
+      allowFontScaling: allowFontScaling,
+      style: [styles.pickerItem, intItem > adjustedLimited.max || intItem < adjustedLimited.min ? styles.disabledPickerItem : {}]
+    }, stringItem), is12HourPicker ? /*#__PURE__*/React.createElement(View, {
+      pointerEvents: "none",
+      style: styles.pickerAmPmContainer
+    }, /*#__PURE__*/React.createElement(Text, {
+      allowFontScaling: allowFontScaling,
+      style: [styles.pickerAmPmLabel]
+    }, isAm ? amLabel : pmLabel)) : null);
+  }, [adjustedLimited.max, adjustedLimited.min, allowFontScaling, amLabel, is12HourPicker, pmLabel, styles.disabledPickerItem, styles.pickerAmPmContainer, styles.pickerAmPmLabel, styles.pickerItem, styles.pickerItemContainer]);
+  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 ? [{
+    viewabilityConfig: {
+      viewAreaCoveragePercentThreshold: 0
+    },
+    onViewableItemsChanged: onViewableItemsChanged
+  }] : 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 ? [{
+      viewabilityConfig: {
+        viewAreaCoveragePercentThreshold: 0
+      },
+      onViewableItemsChanged: onViewableItemsChanged
+    }] : undefined);
+  }, [disableInfiniteScroll, onViewableItemsChanged]);
+  const getItemLayout = useCallback((_, index) => ({
+    length: styles.pickerItemContainer.height,
+    offset: styles.pickerItemContainer.height * index,
+    index
+  }), [styles.pickerItemContainer.height]);
+  useImperativeHandle(ref, () => ({
+    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
+        })
+      });
+    },
+    latestDuration: latestDuration
+  }));
+  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
+    }, typeof label === "string" ? /*#__PURE__*/React.createElement(Text, {
+      allowFontScaling: allowFontScaling,
+      style: styles.pickerLabel
+    }, label) : label ?? null));
+  }, [FlatList, allowFontScaling, flatListRenderKey, getItemLayout, initialScrollIndex, isDisabled, label, numberOfItemsToShow, numbersForFlatList, onMomentumScrollEnd, onScroll, renderItem, styles.durationScrollFlatList, styles.durationScrollFlatListContentContainer, styles.pickerItemContainer.height, styles.pickerLabel, styles.pickerLabelContainer, viewabilityConfigCallbackPairs, decelerationRate]);
+  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, {
+      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