number-flow-react-native 0.1.0

package/lib/module/core/useNumberFormatting.js

@@ -0,0 +1,158 @@
+"use strict";
+
+import { useMemo } from "react";
+import { getOrCreateFormatter, safeFormatToParts } from "./intlHelpers.js";
+import { detectOutputZeroCodePoint, localeDigitValue } from "./numerals/index.js";
+/**
+ * Transforms `Intl.NumberFormat.formatToParts()` output into a flat array of
+ * stably-keyed single-character parts. Integer digits are keyed right-to-left
+ * (ones = `integer:0`, tens = `integer:1`, etc.) so that the ones place always
+ * maps to the same React key regardless of digit count. Fraction digits are
+ * keyed left-to-right from the decimal point (`fraction:0` = tenths, etc.).
+ *
+ * This keying ensures correct animation behavior when digits are added/removed
+ * (e.g., 9→10: ones place spins 9→0, tens place enters as new digit).
+ */
+export function formatToKeyedParts(value, formatter, locales, prefix = "", suffix = "") {
+  const rawParts = safeFormatToParts(formatter, value, locales);
+
+  /**
+   * Detect the actual zero codepoint from the formatted output rather than
+   * trusting resolvedOptions().numberingSystem. Hermes may report "arab" but
+   * output Latin digits, or vice versa. Output-based detection is always correct.
+   */
+  const rawString = rawParts.map(p => p.value).join("");
+  const zeroCP = detectOutputZeroCodePoint(rawString);
+
+  // Step 1: Flatten all parts into single characters with their source type
+
+  const flatChars = [];
+  for (const char of prefix) {
+    flatChars.push({
+      sourceType: "prefix",
+      char
+    });
+  }
+  for (const part of rawParts) {
+    // Merge signs into unified types.
+    // The fallback parser emits extended types (exponentMinusSign, etc.)
+    // that aren't in Intl.NumberFormatPart["type"], so we widen to string.
+    const partType = part.type;
+    const type = partType === "minusSign" || partType === "plusSign" ? "sign" : partType === "exponentMinusSign" || partType === "exponentPlusSign" ? "exponentSign" : partType;
+
+    // Replace exponentSeparator "E" with ×10 display
+    if (type === "exponentSeparator") {
+      flatChars.push({
+        sourceType: "exponentSeparator",
+        char: "\u00D7"
+      });
+      flatChars.push({
+        sourceType: "exponentSeparator",
+        char: "1"
+      });
+      flatChars.push({
+        sourceType: "exponentSeparator",
+        char: "0"
+      });
+      continue;
+    }
+
+    // Flatten digit sequences into individual characters
+    if (type === "integer" || type === "fraction" || type === "exponentInteger") {
+      for (const char of part.value) {
+        flatChars.push({
+          sourceType: type,
+          char
+        });
+      }
+    } else {
+      flatChars.push({
+        sourceType: type,
+        char: part.value
+      });
+    }
+  }
+  for (const char of suffix) {
+    flatChars.push({
+      sourceType: "suffix",
+      char
+    });
+  }
+
+  // Step 2: Key characters — integers+groups RTL, everything else LTR
+  const result = new Array(flatChars.length);
+  const counts = {};
+  const nextKey = type => `${type}:${counts[type] = (counts[type] ?? -1) + 1}`;
+
+  // Find all integer + group indices (they form one contiguous block to key RTL)
+  const integerGroupIndices = [];
+  for (let i = 0; i < flatChars.length; i++) {
+    if (flatChars[i].sourceType === "integer" || flatChars[i].sourceType === "group") {
+      integerGroupIndices.push(i);
+    }
+  }
+
+  /**
+   * Key integer digits and group separators RTL — rightmost integer digit
+   * gets "integer:0" (ones place), next gets "integer:1" (tens), etc.
+   */
+  for (let i = integerGroupIndices.length - 1; i >= 0; i--) {
+    const idx = integerGroupIndices[i];
+    const fc = flatChars[idx];
+    const isDigit = fc.sourceType === "integer";
+    result[idx] = {
+      key: nextKey(fc.sourceType),
+      type: isDigit ? "digit" : "symbol",
+      char: fc.char,
+      digitValue: isDigit ? localeDigitValue(fc.char.charCodeAt(0), zeroCP) : -1
+    };
+  }
+
+  // Find all exponent integer indices (key RTL, same logic as mantissa integers)
+  const exponentIntegerIndices = [];
+  for (let i = 0; i < flatChars.length; i++) {
+    if (flatChars[i].sourceType === "exponentInteger") {
+      exponentIntegerIndices.push(i);
+    }
+  }
+  for (let i = exponentIntegerIndices.length - 1; i >= 0; i--) {
+    const idx = exponentIntegerIndices[i];
+    const fc = flatChars[idx];
+    result[idx] = {
+      key: nextKey("exponentInteger"),
+      type: "digit",
+      char: fc.char,
+      digitValue: localeDigitValue(fc.char.charCodeAt(0), zeroCP)
+    };
+  }
+
+  // Key everything else LTR (fraction, decimal, prefix, suffix, exponentSeparator, exponentSign, etc.)
+  for (let i = 0; i < flatChars.length; i++) {
+    if (result[i]) continue; // already keyed (integer, group, or exponentInteger)
+    const fc = flatChars[i];
+    const isDigit = fc.sourceType === "fraction";
+    result[i] = {
+      key: nextKey(fc.sourceType),
+      type: isDigit ? "digit" : "symbol",
+      char: fc.char,
+      digitValue: isDigit ? localeDigitValue(fc.char.charCodeAt(0), zeroCP) : -1
+    };
+  }
+  return result;
+}
+
+/**
+ * Hook that formats a numeric value into stably-keyed character parts.
+ * Uses Intl.NumberFormat.formatToParts() with RTL integer keying.
+ */
+export function useNumberFormatting(value, format, locales, prefix, suffix) {
+  // Serialize format/locales to a stable string — avoids re-runs when callers pass inline objects
+  const formatKey = useMemo(() => JSON.stringify([locales, format]), [locales, format]);
+  return useMemo(() => {
+    if (value === undefined) return [];
+    const formatter = getOrCreateFormatter(locales, format);
+    return formatToKeyedParts(value, formatter, locales, prefix, suffix);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [value, prefix, suffix, formatKey]);
+}
+//# sourceMappingURL=useNumberFormatting.js.map

package/lib/module/core/useNumberFormatting.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useMemo","getOrCreateFormatter","safeFormatToParts","detectOutputZeroCodePoint","localeDigitValue","formatToKeyedParts","value","formatter","locales","prefix","suffix","rawParts","rawString","map","p","join","zeroCP","flatChars","char","push","sourceType","part","partType","type","result","Array","length","counts","nextKey","integerGroupIndices","i","idx","fc","isDigit","key","digitValue","charCodeAt","exponentIntegerIndices","useNumberFormatting","format","formatKey","JSON","stringify","undefined"],"sourceRoot":"../../../src","sources":["core/useNumberFormatting.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/core/useSlotOpacity.js

@@ -0,0 +1,53 @@
+"use strict";
+
+import { useLayoutEffect, useRef, useState } from "react";
+import { makeMutable, runOnJS, withTiming } from "react-native-reanimated";
+
+/**
+ * We use makeMutable (via useState) instead of useSharedValue because
+ * useSharedValue's cleanup calls cancelAnimation, which kills in-flight
+ * animations when the component re-renders in StrictMode.
+ */
+
+export function useSlotOpacity({
+  entering,
+  exiting,
+  opacityTiming,
+  exitKey,
+  onExitComplete,
+  onExitingStart
+}) {
+  const [slotOpacity] = useState(() => makeMutable(entering ? 0 : 1));
+  const prevStateRef = useRef(null);
+  const currentState = entering ? "entering" : exiting ? "exiting" : "active";
+  useLayoutEffect(() => {
+    if (currentState === prevStateRef.current) return;
+    const wasInitial = prevStateRef.current === null;
+    prevStateRef.current = currentState;
+    if (currentState === "entering") {
+      slotOpacity.value = withTiming(1, {
+        duration: opacityTiming.duration,
+        easing: opacityTiming.easing
+      });
+    } else if (currentState === "exiting") {
+      slotOpacity.value = withTiming(0, {
+        duration: opacityTiming.duration,
+        easing: opacityTiming.easing
+      }, finished => {
+        "worklet";
+
+        if (finished && onExitComplete && exitKey) {
+          runOnJS(onExitComplete)(exitKey);
+        }
+      });
+      onExitingStart?.();
+    } else if (!wasInitial) {
+      slotOpacity.value = withTiming(1, {
+        duration: opacityTiming.duration,
+        easing: opacityTiming.easing
+      });
+    }
+  }, [currentState, opacityTiming, exitKey, onExitComplete, onExitingStart, slotOpacity]);
+  return slotOpacity;
+}
+//# sourceMappingURL=useSlotOpacity.js.map

package/lib/module/core/useSlotOpacity.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useLayoutEffect","useRef","useState","makeMutable","runOnJS","withTiming","useSlotOpacity","entering","exiting","opacityTiming","exitKey","onExitComplete","onExitingStart","slotOpacity","prevStateRef","currentState","current","wasInitial","value","duration","easing","finished"],"sourceRoot":"../../../src","sources":["core/useSlotOpacity.ts"],"mappings":";;AAAA,SAASA,eAAe,EAAEC,MAAM,EAAEC,QAAQ,QAAQ,OAAO;AACzD,SAASC,WAAW,EAAEC,OAAO,EAAoBC,UAAU,QAAQ,yBAAyB;;AAG5F;AACA;AACA;AACA;AACA;;AAWA,OAAO,SAASC,cAAcA,CAAC;EAC7BC,QAAQ;EACRC,OAAO;EACPC,aAAa;EACbC,OAAO;EACPC,cAAc;EACdC;AACoB,CAAC,EAAuB;EAC5C,MAAM,CAACC,WAAW,CAAC,GAAGX,QAAQ,CAAC,MAAMC,WAAW,CAACI,QAAQ,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;EACnE,MAAMO,YAAY,GAAGb,MAAM,CAA2C,IAAI,CAAC;EAC3E,MAAMc,YAAY,GAAGR,QAAQ,GAAG,UAAU,GAAGC,OAAO,GAAG,SAAS,GAAG,QAAQ;EAE3ER,eAAe,CAAC,MAAM;IACpB,IAAIe,YAAY,KAAKD,YAAY,CAACE,OAAO,EAAE;IAC3C,MAAMC,UAAU,GAAGH,YAAY,CAACE,OAAO,KAAK,IAAI;IAChDF,YAAY,CAACE,OAAO,GAAGD,YAAY;IAEnC,IAAIA,YAAY,KAAK,UAAU,EAAE;MAC/BF,WAAW,CAACK,KAAK,GAAGb,UAAU,CAAC,CAAC,EAAE;QAChCc,QAAQ,EAAEV,aAAa,CAACU,QAAQ;QAChCC,MAAM,EAAEX,aAAa,CAACW;MACxB,CAAC,CAAC;IACJ,CAAC,MAAM,IAAIL,YAAY,KAAK,SAAS,EAAE;MACrCF,WAAW,CAACK,KAAK,GAAGb,UAAU,CAC5B,CAAC,EACD;QACEc,QAAQ,EAAEV,aAAa,CAACU,QAAQ;QAChCC,MAAM,EAAEX,aAAa,CAACW;MACxB,CAAC,EACAC,QAAQ,IAAK;QACZ,SAAS;;QACT,IAAIA,QAAQ,IAAIV,cAAc,IAAID,OAAO,EAAE;UACzCN,OAAO,CAACO,cAAc,CAAC,CAACD,OAAO,CAAC;QAClC;MACF,CACF,CAAC;MACDE,cAAc,GAAG,CAAC;IACpB,CAAC,MAAM,IAAI,CAACK,UAAU,EAAE;MACtBJ,WAAW,CAACK,KAAK,GAAGb,UAAU,CAAC,CAAC,EAAE;QAChCc,QAAQ,EAAEV,aAAa,CAACU,QAAQ;QAChCC,MAAM,EAAEX,aAAa,CAACW;MACxB,CAAC,CAAC;IACJ;EACF,CAAC,EAAE,CAACL,YAAY,EAAEN,aAAa,EAAEC,OAAO,EAAEC,cAAc,EAAEC,cAAc,EAAEC,WAAW,CAAC,CAAC;EAEvF,OAAOA,WAAW;AACpB","ignoreList":[]}

package/lib/module/core/useTimeFormatting.js

@@ -0,0 +1,74 @@
+"use strict";
+
+import { useMemo } from "react";
+import { digitPart, symbolPart } from "./types.js";
+
+/**
+ * Converts 24h hours (0-23) to 12h display value (1-12).
+ * 0 → 12 (12 AM), 1-12 → as-is, 13-23 → subtract 12.
+ */
+export function to12Hour(h) {
+  if (h === 0) return 12;
+  if (h > 12) return h - 12;
+  return h;
+}
+
+/**
+ * Builds a time display into stably-keyed character parts.
+ *
+ * Each digit position gets a fixed semantic key (h10, h1, m10, m1, s10, s1)
+ * regardless of the actual value. This ensures correct enter/exit animation
+ * behavior — e.g. when hours go from 9→10, the h10 key *enters* (fades in)
+ * rather than shifting all existing positions.
+ */
+export function formatTimeToKeyedParts(hours, minutes, seconds, is24Hour, padHours) {
+  const parts = [];
+  const hasHours = hours !== undefined;
+  const hasSeconds = seconds !== undefined;
+  if (hasHours) {
+    const displayHours = is24Hour ? hours : to12Hour(hours);
+    const h10 = Math.floor(displayHours / 10);
+    const h1 = displayHours % 10;
+
+    // Hours tens digit — only shown if >= 10 or padding is on
+    if (h10 > 0 || padHours) {
+      parts.push(digitPart("h10", h10));
+    }
+    parts.push(digitPart("h1", h1));
+    parts.push(symbolPart("sep", ":"));
+  }
+  const m10 = Math.floor(minutes / 10);
+  const m1 = minutes % 10;
+  parts.push(digitPart("m10", m10));
+  parts.push(digitPart("m1", m1));
+  if (hasSeconds) {
+    parts.push(symbolPart("sep2", ":"));
+    const s10 = Math.floor(seconds / 10);
+    const s1 = seconds % 10;
+    parts.push(digitPart("s10", s10));
+    parts.push(digitPart("s1", s1));
+  }
+
+  /**
+   * Each character gets a value-dependent key so AM→PM triggers exit/enter crossfade.
+   * Characters are emitted individually for correct glyph width measurement.
+   */
+  if (hasHours && !is24Hour) {
+    const label = hours < 12 ? "AM" : "PM";
+    parts.push(symbolPart("ampm-sp", " "));
+    for (let i = 0; i < label.length; i++) {
+      parts.push(symbolPart(`ampm:${label}:${i}`, label[i]));
+    }
+  }
+  return parts;
+}
+
+/**
+ * Hook that formats time values into stably-keyed character parts.
+ * Uses fixed positional keys (h10, h1, sep, m10, m1, etc.) instead of
+ * NumberFlow's RTL integer keying.
+ */
+export function useTimeFormatting(hours, minutes, seconds, is24Hour, padHours) {
+  return useMemo(() => formatTimeToKeyedParts(hours, minutes, seconds, is24Hour, padHours), [hours, minutes, seconds, is24Hour, padHours]);
+}
+//# sourceMappingURL=useTimeFormatting.js.map

package/lib/module/core/useTimeFormatting.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useMemo","digitPart","symbolPart","to12Hour","h","formatTimeToKeyedParts","hours","minutes","seconds","is24Hour","padHours","parts","hasHours","undefined","hasSeconds","displayHours","h10","Math","floor","h1","push","m10","m1","s10","s1","label","i","length","useTimeFormatting"],"sourceRoot":"../../../src","sources":["core/useTimeFormatting.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/core/useTimingResolution.js

@@ -0,0 +1,21 @@
+"use strict";
+
+import { DEFAULT_OPACITY_TIMING, DEFAULT_SPIN_TIMING, DEFAULT_TRANSFORM_TIMING, ZERO_TIMING } from "./timing.js";
+import { useCanAnimate } from "./useCanAnimate.js";
+/**
+ * Resolves animation timing based on the `animated` prop and reduced-motion preference.
+ * When animations are disabled, all timings collapse to zero-duration.
+ */
+export function useTimingResolution(animated, respectMotionPreference, spinTiming, opacityTiming, transformTiming) {
+  const canAnimate = useCanAnimate(respectMotionPreference);
+  const shouldAnimate = (animated ?? true) && canAnimate;
+  const resolvedSpinTiming = shouldAnimate ? spinTiming ?? DEFAULT_SPIN_TIMING : ZERO_TIMING;
+  const resolvedOpacityTiming = shouldAnimate ? opacityTiming ?? DEFAULT_OPACITY_TIMING : ZERO_TIMING;
+  const resolvedTransformTiming = shouldAnimate ? transformTiming ?? DEFAULT_TRANSFORM_TIMING : ZERO_TIMING;
+  return {
+    resolvedSpinTiming,
+    resolvedOpacityTiming,
+    resolvedTransformTiming
+  };
+}
+//# sourceMappingURL=useTimingResolution.js.map

package/lib/module/core/useTimingResolution.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DEFAULT_OPACITY_TIMING","DEFAULT_SPIN_TIMING","DEFAULT_TRANSFORM_TIMING","ZERO_TIMING","useCanAnimate","useTimingResolution","animated","respectMotionPreference","spinTiming","opacityTiming","transformTiming","canAnimate","shouldAnimate","resolvedSpinTiming","resolvedOpacityTiming","resolvedTransformTiming"],"sourceRoot":"../../../src","sources":["core/useTimingResolution.ts"],"mappings":";;AACA,SACEA,sBAAsB,EACtBC,mBAAmB,EACnBC,wBAAwB,EACxBC,WAAW,QACN,aAAU;AACjB,SAASC,aAAa,QAAQ,oBAAiB;AAQ/C;AACA;AACA;AACA;AACA,OAAO,SAASC,mBAAmBA,CACjCC,QAA6B,EAC7BC,uBAA4C,EAC5CC,UAAyB,EACzBC,aAA4B,EAC5BC,eAA8B,EACb;EACjB,MAAMC,UAAU,GAAGP,aAAa,CAACG,uBAAuB,CAAC;EACzD,MAAMK,aAAa,GAAG,CAACN,QAAQ,IAAI,IAAI,KAAKK,UAAU;EAEtD,MAAME,kBAAkB,GAAGD,aAAa,GACnCJ,UAAU,IAAIP,mBAAmB,GAClCE,WAAW;EAEf,MAAMW,qBAAqB,GAAGF,aAAa,GACtCH,aAAa,IAAIT,sBAAsB,GACxCG,WAAW;EAEf,MAAMY,uBAAuB,GAAGH,aAAa,GACxCF,eAAe,IAAIR,wBAAwB,GAC5CC,WAAW;EAEf,OAAO;IACLU,kBAAkB;IAClBC,qBAAqB;IACrBC;EACF,CAAC;AACH","ignoreList":[]}

package/lib/module/core/useWorkletFormatting.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import { useState } from "react";
+import { makeMutable, useAnimatedReaction } from "react-native-reanimated";
+import { MAX_SLOTS } from "./constants.js";
+import { localeDigitValue } from "./numerals/index.js";
+
+/**
+ * Watches a SharedValue<string> and extracts per-digit numeric values on the
+ * UI thread. Returns an array of SharedValues indexed by digit position
+ * (0 = first digit, 1 = second digit, etc.), skipping non-digit characters.
+ *
+ * This enables zero-latency digit updates during chart scrubbing — the worklet
+ * writes directly to SharedValues without crossing the JS bridge.
+ *
+ * When sharedValue is empty (e.g., scrubbing ended), all slots are set to
+ * -1, signaling DigitSlots to fall back to prop-driven animated updates.
+ */
+export function useWorkletFormatting(sharedValue, prefix, suffix, zeroCodePoint = 48) {
+  const [digitValues] = useState(() => Array.from({
+    length: MAX_SLOTS
+  }, () => makeMutable(-1)));
+  useAnimatedReaction(() => sharedValue?.value ?? "", (current, previous) => {
+    if (current === previous) return;
+    if (!current) {
+      for (let i = 0; i < MAX_SLOTS; i++) {
+        digitValues[i].value = -1;
+      }
+      return;
+    }
+    const fullText = prefix + current + suffix;
+    const len = fullText.length;
+    let digitIndex = 0;
+    for (let i = 0; i < len && digitIndex < MAX_SLOTS; i++) {
+      const code = fullText.charCodeAt(i);
+      const dv = localeDigitValue(code, zeroCodePoint);
+      if (dv >= 0) {
+        digitValues[digitIndex].value = dv;
+        digitIndex++;
+      }
+    }
+    for (let i = digitIndex; i < MAX_SLOTS; i++) {
+      digitValues[i].value = -1;
+    }
+  }, [prefix, suffix, zeroCodePoint]);
+  if (!sharedValue) return null;
+  return digitValues;
+}
+//# sourceMappingURL=useWorkletFormatting.js.map

package/lib/module/core/useWorkletFormatting.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useState","makeMutable","useAnimatedReaction","MAX_SLOTS","localeDigitValue","useWorkletFormatting","sharedValue","prefix","suffix","zeroCodePoint","digitValues","Array","from","length","value","current","previous","i","fullText","len","digitIndex","code","charCodeAt","dv"],"sourceRoot":"../../../src","sources":["core/useWorkletFormatting.ts"],"mappings":";;AAAA,SAASA,QAAQ,QAAQ,OAAO;AAChC,SAASC,WAAW,EAAoBC,mBAAmB,QAAQ,yBAAyB;AAC5F,SAASC,SAAS,QAAQ,gBAAa;AACvC,SAASC,gBAAgB,QAAQ,qBAAY;;AAE7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,oBAAoBA,CAClCC,WAA4C,EAC5CC,MAAc,EACdC,MAAc,EACdC,aAAa,GAAG,EAAE,EACY;EAC9B,MAAM,CAACC,WAAW,CAAC,GAAGV,QAAQ,CAAC,MAAMW,KAAK,CAACC,IAAI,CAAC;IAAEC,MAAM,EAAEV;EAAU,CAAC,EAAE,MAAMF,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;EAE9FC,mBAAmB,CACjB,MAAMI,WAAW,EAAEQ,KAAK,IAAI,EAAE,EAC9B,CAACC,OAAO,EAAEC,QAAQ,KAAK;IACrB,IAAID,OAAO,KAAKC,QAAQ,EAAE;IAE1B,IAAI,CAACD,OAAO,EAAE;MACZ,KAAK,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGd,SAAS,EAAEc,CAAC,EAAE,EAAE;QAClCP,WAAW,CAACO,CAAC,CAAC,CAACH,KAAK,GAAG,CAAC,CAAC;MAC3B;MACA;IACF;IAEA,MAAMI,QAAQ,GAAGX,MAAM,GAAGQ,OAAO,GAAGP,MAAM;IAC1C,MAAMW,GAAG,GAAGD,QAAQ,CAACL,MAAM;IAC3B,IAAIO,UAAU,GAAG,CAAC;IAElB,KAAK,IAAIH,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGE,GAAG,IAAIC,UAAU,GAAGjB,SAAS,EAAEc,CAAC,EAAE,EAAE;MACtD,MAAMI,IAAI,GAAGH,QAAQ,CAACI,UAAU,CAACL,CAAC,CAAC;MACnC,MAAMM,EAAE,GAAGnB,gBAAgB,CAACiB,IAAI,EAAEZ,aAAa,CAAC;MAChD,IAAIc,EAAE,IAAI,CAAC,EAAE;QACXb,WAAW,CAACU,UAAU,CAAC,CAACN,KAAK,GAAGS,EAAE;QAClCH,UAAU,EAAE;MACd;IACF;IAEA,KAAK,IAAIH,CAAC,GAAGG,UAAU,EAAEH,CAAC,GAAGd,SAAS,EAAEc,CAAC,EAAE,EAAE;MAC3CP,WAAW,CAACO,CAAC,CAAC,CAACH,KAAK,GAAG,CAAC,CAAC;IAC3B;EACF,CAAC,EACD,CAACP,MAAM,EAAEC,MAAM,EAAEC,aAAa,CAChC,CAAC;EAED,IAAI,CAACH,WAAW,EAAE,OAAO,IAAI;EAC7B,OAAOI,WAAW;AACpB","ignoreList":[]}

package/lib/module/core/utils.js

@@ -0,0 +1,132 @@
+"use strict";
+
+import { DIGIT_COUNT } from "./constants.js";
+/**
+ * Computes the signed modular offset for digit n relative to virtual
+ * scroll position c. Returns a value in [-half, half), where 0 means
+ * the digit is centered in the viewport.
+ *
+ * This is the Reanimated equivalent of NumberFlow's CSS:
+ *   offset-raw: mod(length + n - mod(c, length), length)
+ *   offset: offset-raw - length * round(down, offset-raw / (length/2), 1)
+ */
+export function signedDigitOffset(n, c, digitCount = DIGIT_COUNT) {
+  "worklet";
+
+  const raw = ((n - c) % digitCount + digitCount) % digitCount;
+  const half = digitCount / 2;
+  return raw >= half ? raw - digitCount : raw;
+}
+
+/**
+ * Computes the roll delta for a digit transition, respecting the trend direction.
+ *
+ * For trend > 0 (always up):   8→2 = +4 (through 9,0,1,2), not -6
+ * For trend < 0 (always down): 2→8 = -6 (through 1,0,9,8), not +4
+ * For trend = 0 (auto):        takes the shortest path
+ */
+export function computeRollDelta(prev, next, trend, digitCount = DIGIT_COUNT) {
+  "worklet";
+
+  if (prev === next) return 0;
+
+  // Always roll up (positive delta)
+  if (trend > 0) {
+    return next >= prev ? next - prev : digitCount - prev + next;
+  }
+
+  // Always roll down (negative delta)
+  if (trend < 0) {
+    return next <= prev ? next - prev : -(digitCount - next + prev);
+  }
+
+  // Auto: shortest path
+  const half = digitCount / 2;
+  const diff = next - prev;
+  if (Math.abs(diff) <= half) return diff;
+  return diff > 0 ? diff - digitCount : diff + digitCount;
+}
+
+/**
+ * Resolves a TrendProp (static value or function) into a concrete Trend.
+ * When undefined, auto-detects direction from the value change.
+ */
+export function resolveTrend(trendProp, prevValue, nextValue) {
+  const hasChange = prevValue !== undefined && nextValue !== undefined && prevValue !== nextValue;
+
+  // Static trend value — pass through
+  if (typeof trendProp === "number") {
+    return trendProp;
+  }
+
+  // Function trend — call with prev/next when there's an actual change
+  if (typeof trendProp === "function") {
+    return hasChange ? trendProp(prevValue, nextValue) : 0;
+  }
+
+  // Auto-detect from direction of change
+  return hasChange ? Math.sign(nextValue - prevValue) : 0;
+}
+
+/**
+ * Extracts the significance position from a digit's keyed part key.
+ * "integer:2" → 2 (hundreds), "fraction:0" → -1 (tenths).
+ * Returns undefined for non-digit keys (symbols, decimals, etc.).
+ */
+export function parseDigitPosition(key) {
+  "worklet";
+
+  // Exponent digits are a separate domain — they don't cascade in continuous spin
+  if (key.startsWith("exponentInteger:")) return undefined;
+  if (key.startsWith("integer:")) {
+    return parseInt(key.slice(8), 10);
+  }
+  if (key.startsWith("fraction:")) {
+    return -(parseInt(key.slice(9), 10) + 1);
+  }
+
+  // Time digit keys — significance ordered: s1 < s10 < m1 < m10 < h1 < h10
+  switch (key) {
+    case "s1":
+      return 0;
+    case "s10":
+      return 1;
+    case "m1":
+      return 2;
+    case "m10":
+      return 3;
+    case "h1":
+      return 4;
+    case "h10":
+      return 5;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Correct wheel size for each time digit position.
+ * s10/m10 only go 0-5, h10 only goes 0-2.
+ */
+export const TIME_DIGIT_COUNTS = {
+  s1: 10,
+  s10: 6,
+  m1: 10,
+  m10: 6,
+  h1: 10,
+  h10: 3
+};
+
+/**
+ * Resolves the wheel size for a digit at a given key.
+ * Uses the `digits` prop for NumberFlow, or TIME_DIGIT_COUNTS for TimeFlow.
+ * Returns DIGIT_COUNT (10) when no constraint applies.
+ */
+export function getDigitCount(digits, key) {
+  if (!digits) return DIGIT_COUNT;
+  const pos = parseDigitPosition(key);
+  if (pos === undefined || pos < 0) return DIGIT_COUNT;
+  const constraint = digits[pos];
+  return constraint ? constraint.max + 1 : DIGIT_COUNT;
+}
+//# sourceMappingURL=utils.js.map

package/lib/module/core/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DIGIT_COUNT","signedDigitOffset","n","c","digitCount","raw","half","computeRollDelta","prev","next","trend","diff","Math","abs","resolveTrend","trendProp","prevValue","nextValue","hasChange","undefined","sign","parseDigitPosition","key","startsWith","parseInt","slice","TIME_DIGIT_COUNTS","s1","s10","m1","m10","h1","h10","getDigitCount","digits","pos","constraint","max"],"sourceRoot":"../../../src","sources":["core/utils.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/core/warnings.js

@@ -0,0 +1,10 @@
+"use strict";
+
+const warned = new Set();
+export function warnOnce(key, message) {
+  if (__DEV__ && !warned.has(key)) {
+    warned.add(key);
+    console.warn(`[NumberFlow] ${message}`);
+  }
+}
+//# sourceMappingURL=warnings.js.map

package/lib/module/core/warnings.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["warned","Set","warnOnce","key","message","__DEV__","has","add","console","warn"],"sourceRoot":"../../../src","sources":["core/warnings.ts"],"mappings":";;AAAA,MAAMA,MAAM,GAAG,IAAIC,GAAG,CAAS,CAAC;AAEhC,OAAO,SAASC,QAAQA,CAACC,GAAW,EAAEC,OAAe,EAAQ;EAC3D,IAAIC,OAAO,IAAI,CAACL,MAAM,CAACM,GAAG,CAACH,GAAG,CAAC,EAAE;IAC/BH,MAAM,CAACO,GAAG,CAACJ,GAAG,CAAC;IACfK,OAAO,CAACC,IAAI,CAAC,gBAAgBL,OAAO,EAAE,CAAC;EACzC;AACF","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+export { detectNumberingSystem, getDigitStrings, getZeroCodePoint } from "./core/numerals/index.js";
+export { useCanAnimate } from "./core/useCanAnimate.js";
+export { useFormattedValue } from "./core/useFormattedValue.js";
+export { NumberFlow, TimeFlow } from "./native/index.js";
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["detectNumberingSystem","getDigitStrings","getZeroCodePoint","useCanAnimate","useFormattedValue","NumberFlow","TimeFlow"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,qBAAqB,EAAEC,eAAe,EAAEC,gBAAgB,QAAQ,0BAAiB;AAW1F,SAASC,aAAa,QAAQ,yBAAsB;AACpD,SAASC,iBAAiB,QAAQ,6BAA0B;AAC5D,SAASC,UAAU,EAAEC,QAAQ,QAAQ,mBAAU","ignoreList":[]}