number-flow-react-native 0.1.0

package/lib/module/core/useCanAnimate.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import { useReducedMotion } from "react-native-reanimated";
+
+/**
+ * Returns whether NumberFlow animations are currently enabled.
+ *
+ * Use this to conditionally render UI based on animation support:
+ * ```tsx
+ * const canAnimate = useCanAnimate();
+ * return canAnimate ? <NumberFlow value={42} /> : <Text>42</Text>;
+ * ```
+ *
+ * When `respectMotionPreference` is true (default), returns false
+ * if the device's "Reduce Motion" accessibility setting is on.
+ */
+export function useCanAnimate(respectMotionPreference = true) {
+  const reducedMotion = useReducedMotion();
+  if (!respectMotionPreference) return true;
+  return !reducedMotion;
+}
+//# sourceMappingURL=useCanAnimate.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useReducedMotion","useCanAnimate","respectMotionPreference","reducedMotion"],"sourceRoot":"../../../src","sources":["core/useCanAnimate.ts"],"mappings":";;AAAA,SAASA,gBAAgB,QAAQ,yBAAyB;;AAE1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,aAAaA,CAACC,uBAAuB,GAAG,IAAI,EAAW;EACrE,MAAMC,aAAa,GAAGH,gBAAgB,CAAC,CAAC;EAExC,IAAI,CAACE,uBAAuB,EAAE,OAAO,IAAI;EAEzC,OAAO,CAACC,aAAa;AACvB","ignoreList":[]}

package/lib/module/core/useContinuousSpin.js

@@ -0,0 +1,89 @@
+"use strict";
+
+import { useRef } from "react";
+import { parseDigitPosition } from "./utils.js";
+
+/**
+ * Pure algorithm: given previous and current keyed parts, determines which
+ * unchanged lower-significance digits should do a full-wheel continuous spin.
+ *
+ * Returns a new Map with incremented generation counters for those digits.
+ * The generation counter is what triggers the spin animation in useDigitAnimation.
+ */
+export function computeContinuousGenerations(prevParts, currentParts, prevGenerations) {
+  // Build lookup of previous digit values by key
+  const prevDigits = new Map();
+  for (const part of prevParts) {
+    if (part.type === "digit") {
+      prevDigits.set(part.key, part.digitValue);
+    }
+  }
+
+  // Find the highest-significance position where the digit value changed
+  let maxChangedPos = -Infinity;
+  for (const part of currentParts) {
+    if (part.type !== "digit") continue;
+    const pos = parseDigitPosition(part.key);
+    if (pos === undefined) continue;
+    const prevValue = prevDigits.get(part.key);
+    const changed = prevValue !== undefined && prevValue !== part.digitValue;
+    if (changed && pos > maxChangedPos) {
+      maxChangedPos = pos;
+    }
+  }
+
+  // No digit changed — nothing to spin
+  if (maxChangedPos === -Infinity) return prevGenerations;
+
+  /**
+   * Increment the generation counter for each unchanged digit whose
+   * significance is lower than the most-significant changed digit.
+   * Only digits that existed in the previous render qualify — entering
+   * digits have no previous value and can't be "unchanged".
+   */
+  const nextGenerations = new Map(prevGenerations);
+  for (const part of currentParts) {
+    if (part.type !== "digit") continue;
+    const pos = parseDigitPosition(part.key);
+    if (pos === undefined || pos >= maxChangedPos) continue;
+    const prevValue = prevDigits.get(part.key);
+    const unchanged = prevValue !== undefined && prevValue === part.digitValue;
+    if (unchanged) {
+      const prev = nextGenerations.get(part.key) ?? 0;
+      nextGenerations.set(part.key, prev + 1);
+    }
+  }
+  return nextGenerations;
+}
+
+/**
+ * Tracks which digits need a full-wheel continuous spin.
+ *
+ * When `continuous` is enabled, unchanged lower-significance digits spin
+ * through a complete cycle alongside higher-significance digits that changed.
+ * For example, 100 -> 200 with trend=1 makes ones and tens both do a
+ * full upward rotation even though their values didn't change.
+ *
+ * Returns a Map<key, generation> where generation increments each time
+ * a digit should perform a continuous spin. Returns undefined when
+ * continuous is disabled (zero overhead path).
+ */
+export function useContinuousSpin(keyedParts, continuous, trend) {
+  const prevPartsRef = useRef([]);
+  const generationsRef = useRef(new Map());
+  if (!continuous) {
+    prevPartsRef.current = keyedParts;
+    return undefined;
+  }
+  const prevParts = prevPartsRef.current;
+  prevPartsRef.current = keyedParts;
+
+  // First render — nothing to compare against
+  if (prevParts.length === 0) return generationsRef.current;
+
+  // Shortest-path trend defeats the purpose of continuous spin
+  if (trend === 0) return generationsRef.current;
+  generationsRef.current = computeContinuousGenerations(prevParts, keyedParts, generationsRef.current);
+  return generationsRef.current;
+}
+//# sourceMappingURL=useContinuousSpin.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useRef","parseDigitPosition","computeContinuousGenerations","prevParts","currentParts","prevGenerations","prevDigits","Map","part","type","set","key","digitValue","maxChangedPos","Infinity","pos","undefined","prevValue","get","changed","nextGenerations","unchanged","prev","useContinuousSpin","keyedParts","continuous","trend","prevPartsRef","generationsRef","current","length"],"sourceRoot":"../../../src","sources":["core/useContinuousSpin.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/core/useDebouncedWidths.js

@@ -0,0 +1,74 @@
+"use strict";
+
+import { useState } from "react";
+import { makeMutable, useAnimatedReaction, withTiming } from "react-native-reanimated";
+import { MAX_SLOTS } from "./constants.js";
+import { localeDigitValue } from "./numerals/index.js";
+const WIDTH_ANIM_MS = 200;
+
+/**
+ * Creates a pool of SharedValue<number> that hold digit widths for worklet layout.
+ *
+ * **Tabular mode during scrubbing**: While sharedValue is active (scrubbing),
+ * all digits use a fixed width (scrubDigitWidth) — this eliminates jitter entirely
+ * because all digits occupy the same width regardless of which digit (0-9) is displayed.
+ * Only digits are affected; symbols (like `.`) keep their natural width.
+ *
+ * **Proportional mode when idle**: When scrubbing ends (sharedValue becomes
+ * empty), widths animate to proportional values for natural typography.
+ *
+ * This approach gives the best of both worlds: stable layout during rapid
+ * scrubbing, and beautiful proportional spacing for static display.
+ */
+export function useDebouncedWidths(digitWidths, scrubDigitWidth, sharedValue, prefix, suffix, zeroCodePoint = 48) {
+  const [debouncedWidths] = useState(() => Array.from({
+    length: MAX_SLOTS
+  }, () => makeMutable(-1)));
+  const [prevDigits] = useState(() => Array.from({
+    length: MAX_SLOTS
+  }, () => makeMutable(-1)));
+  const [wasActive] = useState(() => makeMutable(false));
+  useAnimatedReaction(() => sharedValue?.value ?? "", (current, previous) => {
+    if (current === previous) return;
+    if (!digitWidths) return;
+    if (!current) {
+      // Scrubbing ended — animate to proportional widths
+      if (wasActive.value) {
+        wasActive.value = false;
+        for (let i = 0; i < MAX_SLOTS; i++) {
+          const prevDv = prevDigits[i].value;
+          if (prevDv >= 0) {
+            const proportionalWidth = digitWidths[prevDv];
+            debouncedWidths[i].value = withTiming(proportionalWidth, {
+              duration: WIDTH_ANIM_MS
+            });
+          } else {
+            debouncedWidths[i].value = -1;
+          }
+          prevDigits[i].value = -1;
+        }
+      }
+      return;
+    }
+    const isFirstActivation = !wasActive.value;
+    if (isFirstActivation) wasActive.value = true;
+    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) {
+        prevDigits[digitIndex].value = dv;
+        debouncedWidths[digitIndex].value = scrubDigitWidth;
+        digitIndex++;
+      }
+    }
+    for (let i = digitIndex; i < MAX_SLOTS; i++) {
+      if (debouncedWidths[i].value !== -1) debouncedWidths[i].value = -1;
+      prevDigits[i].value = -1;
+    }
+  }, [prefix, suffix, digitWidths, scrubDigitWidth, zeroCodePoint]);
+  return debouncedWidths;
+}
+//# sourceMappingURL=useDebouncedWidths.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useState","makeMutable","useAnimatedReaction","withTiming","MAX_SLOTS","localeDigitValue","WIDTH_ANIM_MS","useDebouncedWidths","digitWidths","scrubDigitWidth","sharedValue","prefix","suffix","zeroCodePoint","debouncedWidths","Array","from","length","prevDigits","wasActive","value","current","previous","i","prevDv","proportionalWidth","duration","isFirstActivation","fullText","len","digitIndex","code","charCodeAt","dv"],"sourceRoot":"../../../src","sources":["core/useDebouncedWidths.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/core/useDigitAnimation.js

@@ -0,0 +1,138 @@
+"use strict";
+
+import { useCallback, useLayoutEffect, useRef, useState } from "react";
+import { makeMutable, runOnJS, useAnimatedReaction, withTiming } from "react-native-reanimated";
+import { DIGIT_COUNT } from "./constants.js";
+import { useSlotOpacity } from "./useSlotOpacity.js";
+import { computeRollDelta } from "./utils.js";
+
+/**
+ * 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.
+ */
+
+/**
+ * Manages the digit rolling state machine: delta tracking, exit animations,
+ * prop-driven digit changes, and worklet-driven digit updates.
+ *
+ * Each renderer creates its own format-specific Y transforms and position
+ * reaction that reads animDelta + currentDigitSV from this hook.
+ */
+export function useDigitAnimation({
+  digitValue,
+  entering,
+  exiting,
+  trend,
+  spinTiming,
+  opacityTiming,
+  exitKey,
+  onExitComplete,
+  workletDigitValue,
+  digitCount,
+  continuousSpinGeneration
+}) {
+  const resolvedDigitCount = digitCount ?? DIGIT_COUNT;
+  const initialDigit = entering ? 0 : digitValue;
+  const prevDigitRef = useRef(initialDigit);
+
+  /**
+   * animDelta starts at the computed roll distance and animates toward 0.
+   * The per-digit position reaction computes c = currentDigit - animDelta
+   * and uses mod-10 arithmetic to position each digit individually.
+   */
+  const [animDelta] = useState(() => makeMutable(0));
+  const [currentDigitSV] = useState(() => makeMutable(initialDigit));
+  const handleExitingStart = useCallback(() => {
+    if (prevDigitRef.current !== 0) {
+      const delta = computeRollDelta(prevDigitRef.current, 0, trend, resolvedDigitCount);
+      prevDigitRef.current = 0;
+      currentDigitSV.value = 0;
+      animDelta.value = delta;
+      animDelta.value = withTiming(0, {
+        duration: spinTiming.duration,
+        easing: spinTiming.easing
+      });
+    }
+  }, [trend, spinTiming, animDelta, currentDigitSV, resolvedDigitCount]);
+  const slotOpacity = useSlotOpacity({
+    entering,
+    exiting,
+    opacityTiming,
+    exitKey,
+    onExitComplete,
+    onExitingStart: handleExitingStart
+  });
+  useLayoutEffect(() => {
+    const workletActive = workletDigitValue !== undefined && workletDigitValue.value >= 0;
+    if (!exiting && !workletActive && prevDigitRef.current !== digitValue) {
+      const delta = computeRollDelta(prevDigitRef.current, digitValue, trend, resolvedDigitCount);
+      prevDigitRef.current = digitValue;
+      currentDigitSV.value = digitValue;
+      animDelta.value = delta;
+      animDelta.value = withTiming(0, {
+        duration: spinTiming.duration,
+        easing: spinTiming.easing
+      });
+    }
+  }, [digitValue, exiting, workletDigitValue, trend, spinTiming, animDelta, currentDigitSV, resolvedDigitCount]);
+
+  /**
+   * Continuous spin: when the generation counter increments, this digit's
+   * value didn't change but a higher-significance digit did. Perform a
+   * full-wheel rotation so the digit appears to "carry" through.
+   *
+   * Example: 100 → 200 with trend=1 — the ones digit (0→0) spins through
+   * all 10 values upward while the hundreds digit rolls 1→2 normally.
+   */
+  const prevSpinGenRef = useRef(continuousSpinGeneration ?? 0);
+  useLayoutEffect(() => {
+    const currentGen = continuousSpinGeneration ?? 0;
+
+    // Generation unchanged — no continuous spin needed
+    if (currentGen === prevSpinGenRef.current) return;
+    prevSpinGenRef.current = currentGen;
+
+    // Don't spin digits that are entering or exiting — they animate via opacity
+    if (exiting || entering) return;
+
+    // Full wheel rotation: e.g. 10 * 1 = spin up 10, or 6 * -1 = spin down 6 (for s10)
+    const delta = resolvedDigitCount * trend;
+    if (delta === 0) return;
+
+    // Accumulate onto any in-flight animation, then ease back to 0
+    animDelta.value = animDelta.value + delta;
+    animDelta.value = withTiming(0, {
+      duration: spinTiming.duration,
+      easing: spinTiming.easing
+    });
+  }, [continuousSpinGeneration, exiting, entering, trend, spinTiming, resolvedDigitCount, animDelta]);
+  const syncFromWorklet = useCallback(digit => {
+    prevDigitRef.current = digit;
+  }, []);
+  useAnimatedReaction(() => workletDigitValue?.value ?? -1, (current, previous) => {
+    if (current < 0 || current === previous) return;
+    const prev = currentDigitSV.value;
+    if (prev === current) return;
+    const delta = computeRollDelta(prev, current, trend, resolvedDigitCount);
+    currentDigitSV.value = current;
+
+    /**
+     * Accumulate remaining animation delta (composite: 'accumulate').
+     * Safe to read animDelta.value here — we're on the UI thread.
+     */
+    animDelta.value = animDelta.value + delta;
+    animDelta.value = withTiming(0, {
+      duration: spinTiming.duration,
+      easing: spinTiming.easing
+    });
+    runOnJS(syncFromWorklet)(current);
+  }, [workletDigitValue, spinTiming, trend]);
+  return {
+    initialDigit,
+    animDelta,
+    currentDigitSV,
+    slotOpacity
+  };
+}
+//# sourceMappingURL=useDigitAnimation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useCallback","useLayoutEffect","useRef","useState","makeMutable","runOnJS","useAnimatedReaction","withTiming","DIGIT_COUNT","useSlotOpacity","computeRollDelta","useDigitAnimation","digitValue","entering","exiting","trend","spinTiming","opacityTiming","exitKey","onExitComplete","workletDigitValue","digitCount","continuousSpinGeneration","resolvedDigitCount","initialDigit","prevDigitRef","animDelta","currentDigitSV","handleExitingStart","current","delta","value","duration","easing","slotOpacity","onExitingStart","workletActive","undefined","prevSpinGenRef","currentGen","syncFromWorklet","digit","previous","prev"],"sourceRoot":"../../../src","sources":["core/useDigitAnimation.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/core/useFlowPipeline.js

@@ -0,0 +1,85 @@
+"use strict";
+
+import { useMemo, useRef } from "react";
+import { computeAdaptiveMaskHeights } from "./mask.js";
+import { useAnimationLifecycle } from "./useAnimationLifecycle.js";
+import { useContinuousSpin } from "./useContinuousSpin.js";
+import { useLayoutDiff } from "./useLayoutDiff.js";
+import { useTimingResolution } from "./useTimingResolution.js";
+import { resolveTrend } from "./utils.js";
+const ZERO_MASK = {
+  top: 0,
+  bottom: 0,
+  expansionTop: 0,
+  expansionBottom: 0
+};
+
+/**
+ * Shared data pipeline for all Flow components (NumberFlow, TimeFlow,
+ * SkiaNumberFlow, SkiaTimeFlow).
+ *
+ * Handles: timing resolution, trend tracking, continuous spin,
+ * animation lifecycle, layout diffing, accessibility label,
+ * and adaptive mask computation.
+ *
+ * Layout computation is left to callers because Skia components
+ * have additional sharedValue-driven layout paths.
+ */
+export function useFlowPipeline(input) {
+  // 1. Timing resolution
+  const {
+    resolvedSpinTiming,
+    resolvedOpacityTiming,
+    resolvedTransformTiming
+  } = useTimingResolution(input.animated, input.respectMotionPreference, input.spinTiming, input.opacityTiming, input.transformTiming);
+
+  // 2. Trend tracking
+  const prevValueRef = useRef(input.trendValue);
+  const resolvedTrend = resolveTrend(input.trend, prevValueRef.current, input.trendValue);
+  prevValueRef.current = input.trendValue;
+
+  // 3. Continuous spin
+  const spinGenerations = useContinuousSpin(input.keyedParts, input.continuous, resolvedTrend);
+
+  // 4. Animation lifecycle
+  useAnimationLifecycle(input.layout, {
+    spin: resolvedSpinTiming,
+    opacity: resolvedOpacityTiming,
+    transform: resolvedTransformTiming
+  }, input.onAnimationsStart, input.onAnimationsFinish);
+
+  // 5. Layout diff
+  const {
+    prevMap,
+    isInitialRender,
+    exitingEntries,
+    onExitComplete
+  } = useLayoutDiff(input.layout);
+
+  // 6. Accessibility label
+  const accessibilityLabel = useMemo(() => {
+    if (input.keyedParts.length === 0) return undefined;
+    return input.keyedParts.map(p => p.char).join("");
+  }, [input.keyedParts]);
+
+  // 7. Adaptive mask
+  const resolvedMask = input.mask ?? true;
+  const adaptiveMask = useMemo(() => {
+    if (!input.metrics || !resolvedMask) return ZERO_MASK;
+    return computeAdaptiveMaskHeights(input.layout, exitingEntries, input.metrics);
+  }, [input.metrics, resolvedMask, input.layout, exitingEntries]);
+  return {
+    resolvedSpinTiming,
+    resolvedOpacityTiming,
+    resolvedTransformTiming,
+    resolvedTrend,
+    spinGenerations,
+    prevMap,
+    isInitialRender,
+    exitingEntries,
+    onExitComplete,
+    accessibilityLabel,
+    adaptiveMask
+  };
+}
+//# sourceMappingURL=useFlowPipeline.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useMemo","useRef","computeAdaptiveMaskHeights","useAnimationLifecycle","useContinuousSpin","useLayoutDiff","useTimingResolution","resolveTrend","ZERO_MASK","top","bottom","expansionTop","expansionBottom","useFlowPipeline","input","resolvedSpinTiming","resolvedOpacityTiming","resolvedTransformTiming","animated","respectMotionPreference","spinTiming","opacityTiming","transformTiming","prevValueRef","trendValue","resolvedTrend","trend","current","spinGenerations","keyedParts","continuous","layout","spin","opacity","transform","onAnimationsStart","onAnimationsFinish","prevMap","isInitialRender","exitingEntries","onExitComplete","accessibilityLabel","length","undefined","map","p","char","join","resolvedMask","mask","adaptiveMask","metrics"],"sourceRoot":"../../../src","sources":["core/useFlowPipeline.ts"],"mappings":";;AAAA,SAASA,OAAO,EAAEC,MAAM,QAAQ,OAAO;AAEvC,SAASC,0BAA0B,QAA0B,WAAQ;AAErE,SAASC,qBAAqB,QAAQ,4BAAyB;AAC/D,SAASC,iBAAiB,QAAQ,wBAAqB;AACvD,SAASC,aAAa,QAAQ,oBAAiB;AAC/C,SAASC,mBAAmB,QAAQ,0BAAuB;AAC3D,SAASC,YAAY,QAAQ,YAAS;AA8CtC,MAAMC,SAAsB,GAAG;EAAEC,GAAG,EAAE,CAAC;EAAEC,MAAM,EAAE,CAAC;EAAEC,YAAY,EAAE,CAAC;EAAEC,eAAe,EAAE;AAAE,CAAC;;AAEzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,eAAeA,CAACC,KAAwB,EAAsB;EAC5E;EACA,MAAM;IAAEC,kBAAkB;IAAEC,qBAAqB;IAAEC;EAAwB,CAAC,GAC1EX,mBAAmB,CACjBQ,KAAK,CAACI,QAAQ,EACdJ,KAAK,CAACK,uBAAuB,EAC7BL,KAAK,CAACM,UAAU,EAChBN,KAAK,CAACO,aAAa,EACnBP,KAAK,CAACQ,eACR,CAAC;;EAEH;EACA,MAAMC,YAAY,GAAGtB,MAAM,CAAqBa,KAAK,CAACU,UAAU,CAAC;EACjE,MAAMC,aAAa,GAAGlB,YAAY,CAACO,KAAK,CAACY,KAAK,EAAEH,YAAY,CAACI,OAAO,EAAEb,KAAK,CAACU,UAAU,CAAC;EACvFD,YAAY,CAACI,OAAO,GAAGb,KAAK,CAACU,UAAU;;EAEvC;EACA,MAAMI,eAAe,GAAGxB,iBAAiB,CAACU,KAAK,CAACe,UAAU,EAAEf,KAAK,CAACgB,UAAU,EAAEL,aAAa,CAAC;;EAE5F;EACAtB,qBAAqB,CACnBW,KAAK,CAACiB,MAAM,EACZ;IAAEC,IAAI,EAAEjB,kBAAkB;IAAEkB,OAAO,EAAEjB,qBAAqB;IAAEkB,SAAS,EAAEjB;EAAwB,CAAC,EAChGH,KAAK,CAACqB,iBAAiB,EACvBrB,KAAK,CAACsB,kBACR,CAAC;;EAED;EACA,MAAM;IAAEC,OAAO;IAAEC,eAAe;IAAEC,cAAc;IAAEC;EAAe,CAAC,GAAGnC,aAAa,CAACS,KAAK,CAACiB,MAAM,CAAC;;EAEhG;EACA,MAAMU,kBAAkB,GAAGzC,OAAO,CAAC,MAAM;IACvC,IAAIc,KAAK,CAACe,UAAU,CAACa,MAAM,KAAK,CAAC,EAAE,OAAOC,SAAS;IAEnD,OAAO7B,KAAK,CAACe,UAAU,CAACe,GAAG,CAAEC,CAAC,IAAKA,CAAC,CAACC,IAAI,CAAC,CAACC,IAAI,CAAC,EAAE,CAAC;EACrD,CAAC,EAAE,CAACjC,KAAK,CAACe,UAAU,CAAC,CAAC;;EAEtB;EACA,MAAMmB,YAAY,GAAGlC,KAAK,CAACmC,IAAI,IAAI,IAAI;EACvC,MAAMC,YAAY,GAAGlD,OAAO,CAAC,MAAM;IACjC,IAAI,CAACc,KAAK,CAACqC,OAAO,IAAI,CAACH,YAAY,EAAE,OAAOxC,SAAS;IAErD,OAAON,0BAA0B,CAACY,KAAK,CAACiB,MAAM,EAAEQ,cAAc,EAAEzB,KAAK,CAACqC,OAAO,CAAC;EAChF,CAAC,EAAE,CAACrC,KAAK,CAACqC,OAAO,EAAEH,YAAY,EAAElC,KAAK,CAACiB,MAAM,EAAEQ,cAAc,CAAC,CAAC;EAE/D,OAAO;IACLxB,kBAAkB;IAClBC,qBAAqB;IACrBC,uBAAuB;IACvBQ,aAAa;IACbG,eAAe;IACfS,OAAO;IACPC,eAAe;IACfC,cAAc;IACdC,cAAc;IACdC,kBAAkB;IAClBS;EACF,CAAC;AACH","ignoreList":[]}

package/lib/module/core/useFormattedValue.js

@@ -0,0 +1,28 @@
+"use strict";
+
+import { useMemo } from "react";
+import { getOrCreateFormatter } from "./intlHelpers.js";
+
+/**
+ * Formats a numeric value to a display string using Intl.NumberFormat, with optional prefix/suffix.
+ * Useful for providing an accessibility label on a parent Canvas for Skia components:
+ *
+ * ```tsx
+ * const label = useFormattedValue(value, { style: "currency", currency: "USD" });
+ *
+ * <Canvas accessible accessibilityLabel={label}>
+ *   <SkiaNumberFlow value={value} font={font} format={{ style: "currency", currency: "USD" }} />
+ * </Canvas>
+ * ```
+ */
+export function useFormattedValue(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 undefined;
+    const formatter = getOrCreateFormatter(locales, format);
+    return `${prefix ?? ""}${formatter.format(value)}${suffix ?? ""}`;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [value, prefix, suffix, formatKey]);
+}
+//# sourceMappingURL=useFormattedValue.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useMemo","getOrCreateFormatter","useFormattedValue","value","format","locales","prefix","suffix","formatKey","JSON","stringify","undefined","formatter"],"sourceRoot":"../../../src","sources":["core/useFormattedValue.ts"],"mappings":";;AAAA,SAASA,OAAO,QAAQ,OAAO;AAC/B,SAASC,oBAAoB,QAAQ,kBAAe;;AAEpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAC/BC,KAAyB,EACzBC,MAAiC,EACjCC,OAA8B,EAC9BC,MAAe,EACfC,MAAe,EACK;EACpB;EACA,MAAMC,SAAS,GAAGR,OAAO,CAAC,MAAMS,IAAI,CAACC,SAAS,CAAC,CAACL,OAAO,EAAED,MAAM,CAAC,CAAC,EAAE,CAACC,OAAO,EAAED,MAAM,CAAC,CAAC;EAErF,OAAOJ,OAAO,CAAC,MAAM;IACnB,IAAIG,KAAK,KAAKQ,SAAS,EAAE,OAAOA,SAAS;IACzC,MAAMC,SAAS,GAAGX,oBAAoB,CAACI,OAAO,EAAED,MAAM,CAAC;IACvD,OAAO,GAAGE,MAAM,IAAI,EAAE,GAAGM,SAAS,CAACR,MAAM,CAACD,KAAK,CAAC,GAAGI,MAAM,IAAI,EAAE,EAAE;IACjE;EACF,CAAC,EAAE,CAACJ,KAAK,EAAEG,MAAM,EAAEC,MAAM,EAAEC,SAAS,CAAC,CAAC;AACxC","ignoreList":[]}

package/lib/module/core/useLayoutDiff.js

@@ -0,0 +1,59 @@
+"use strict";
+
+import { useCallback, useReducer, useRef } from "react";
+/**
+ * Manages enter/exit tracking for layout transitions. Diffs the current
+ * layout against the previous one and tracks exiting entries until their
+ * animations complete.
+ *
+ * The diff logic runs during render (not in useEffect) using a ref-based
+ * idempotent pattern for StrictMode safety.
+ */
+export function useLayoutDiff(layout) {
+  const prevLayoutRef = useRef([]);
+  const exitingRef = useRef(new Map());
+  const [, forceUpdate] = useReducer(n => n + 1, 0);
+  const isFirstLayoutRef = useRef(true);
+  const lastDiffIdRef = useRef("");
+  const diffResultRef = useRef({
+    prevMap: new Map(),
+    isInitialRender: true
+  });
+  const onExitComplete = useCallback(key => {
+    exitingRef.current.delete(key);
+    forceUpdate();
+  }, []);
+
+  // Stable layout identity — fast string concat instead of map+join
+  let layoutId = "";
+  for (const s of layout) {
+    layoutId += `${s.key}:${s.digitValue}|`;
+  }
+  if (layoutId !== lastDiffIdRef.current) {
+    lastDiffIdRef.current = layoutId;
+    const currentKeys = new Set(layout.map(s => s.key));
+    const prevMap = new Map(prevLayoutRef.current.map(s => [s.key, s]));
+    for (const prev of prevLayoutRef.current) {
+      if (!currentKeys.has(prev.key) && !exitingRef.current.has(prev.key)) {
+        exitingRef.current.set(prev.key, prev);
+      }
+    }
+    for (const key of currentKeys) {
+      exitingRef.current.delete(key);
+    }
+    const isInitialRender = isFirstLayoutRef.current;
+    if (layout.length > 0) isFirstLayoutRef.current = false;
+    diffResultRef.current = {
+      prevMap,
+      isInitialRender
+    };
+    prevLayoutRef.current = layout;
+  }
+  return {
+    prevMap: diffResultRef.current.prevMap,
+    isInitialRender: diffResultRef.current.isInitialRender,
+    exitingEntries: exitingRef.current,
+    onExitComplete
+  };
+}
+//# sourceMappingURL=useLayoutDiff.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useCallback","useReducer","useRef","useLayoutDiff","layout","prevLayoutRef","exitingRef","Map","forceUpdate","n","isFirstLayoutRef","lastDiffIdRef","diffResultRef","prevMap","isInitialRender","onExitComplete","key","current","delete","layoutId","s","digitValue","currentKeys","Set","map","prev","has","set","length","exitingEntries"],"sourceRoot":"../../../src","sources":["core/useLayoutDiff.ts"],"mappings":";;AAAA,SAASA,WAAW,EAAEC,UAAU,EAAEC,MAAM,QAAQ,OAAO;AAUvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,aAAaA,CAACC,MAAoB,EAAoB;EACpE,MAAMC,aAAa,GAAGH,MAAM,CAAe,EAAE,CAAC;EAC9C,MAAMI,UAAU,GAAGJ,MAAM,CAA0B,IAAIK,GAAG,CAAC,CAAC,CAAC;EAC7D,MAAM,GAAGC,WAAW,CAAC,GAAGP,UAAU,CAAEQ,CAAS,IAAKA,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;EAC3D,MAAMC,gBAAgB,GAAGR,MAAM,CAAC,IAAI,CAAC;EAErC,MAAMS,aAAa,GAAGT,MAAM,CAAC,EAAE,CAAC;EAChC,MAAMU,aAAa,GAAGV,MAAM,CAGzB;IAAEW,OAAO,EAAE,IAAIN,GAAG,CAAC,CAAC;IAAEO,eAAe,EAAE;EAAK,CAAC,CAAC;EAEjD,MAAMC,cAAc,GAAGf,WAAW,CAAEgB,GAAW,IAAK;IAClDV,UAAU,CAACW,OAAO,CAACC,MAAM,CAACF,GAAG,CAAC;IAC9BR,WAAW,CAAC,CAAC;EACf,CAAC,EAAE,EAAE,CAAC;;EAEN;EACA,IAAIW,QAAQ,GAAG,EAAE;EACjB,KAAK,MAAMC,CAAC,IAAIhB,MAAM,EAAE;IACtBe,QAAQ,IAAI,GAAGC,CAAC,CAACJ,GAAG,IAAII,CAAC,CAACC,UAAU,GAAG;EACzC;EAEA,IAAIF,QAAQ,KAAKR,aAAa,CAACM,OAAO,EAAE;IACtCN,aAAa,CAACM,OAAO,GAAGE,QAAQ;IAEhC,MAAMG,WAAW,GAAG,IAAIC,GAAG,CAACnB,MAAM,CAACoB,GAAG,CAAEJ,CAAC,IAAKA,CAAC,CAACJ,GAAG,CAAC,CAAC;IACrD,MAAMH,OAAO,GAAG,IAAIN,GAAG,CAACF,aAAa,CAACY,OAAO,CAACO,GAAG,CAAEJ,CAAC,IAAK,CAACA,CAAC,CAACJ,GAAG,EAAEI,CAAC,CAAC,CAAC,CAAC;IAErE,KAAK,MAAMK,IAAI,IAAIpB,aAAa,CAACY,OAAO,EAAE;MACxC,IAAI,CAACK,WAAW,CAACI,GAAG,CAACD,IAAI,CAACT,GAAG,CAAC,IAAI,CAACV,UAAU,CAACW,OAAO,CAACS,GAAG,CAACD,IAAI,CAACT,GAAG,CAAC,EAAE;QACnEV,UAAU,CAACW,OAAO,CAACU,GAAG,CAACF,IAAI,CAACT,GAAG,EAAES,IAAI,CAAC;MACxC;IACF;IAEA,KAAK,MAAMT,GAAG,IAAIM,WAAW,EAAE;MAC7BhB,UAAU,CAACW,OAAO,CAACC,MAAM,CAACF,GAAG,CAAC;IAChC;IAEA,MAAMF,eAAe,GAAGJ,gBAAgB,CAACO,OAAO;IAChD,IAAIb,MAAM,CAACwB,MAAM,GAAG,CAAC,EAAElB,gBAAgB,CAACO,OAAO,GAAG,KAAK;IAEvDL,aAAa,CAACK,OAAO,GAAG;MAAEJ,OAAO;MAAEC;IAAgB,CAAC;IACpDT,aAAa,CAACY,OAAO,GAAGb,MAAM;EAChC;EAEA,OAAO;IACLS,OAAO,EAAED,aAAa,CAACK,OAAO,CAACJ,OAAO;IACtCC,eAAe,EAAEF,aAAa,CAACK,OAAO,CAACH,eAAe;IACtDe,cAAc,EAAEvB,UAAU,CAACW,OAAO;IAClCF;EACF,CAAC;AACH","ignoreList":[]}