number-flow-react-native 0.1.0

package/lib/typescript/core/types.d.ts

@@ -0,0 +1,165 @@
+import type { SkFont } from "@shopify/react-native-skia";
+import type { EasingFunction, SharedValue } from "react-native-reanimated";
+export interface TimingConfig {
+    /** Duration in milliseconds */
+    duration: number;
+    /** Easing function (t: 0→1) => 0→1 */
+    easing: EasingFunction;
+}
+export interface AnimationConfig {
+    /** Timing for layout transforms (position, width changes). Defaults to NumberFlow's 900ms deceleration curve. */
+    transformTiming?: TimingConfig;
+    /** Timing for digit spin/rolling. Falls back to transformTiming if unset. */
+    spinTiming?: TimingConfig;
+    /** Timing for enter/exit opacity. Defaults to 450ms ease-out. */
+    opacityTiming?: TimingConfig;
+}
+/**
+ * Controls digit spin direction:
+ * - `1`: always spin upward
+ * - `-1`: always spin downward
+ * - `0`: each digit takes the shortest path
+ */
+export type Trend = -1 | 0 | 1;
+/**
+ * Trend prop accepted by components: either a static direction
+ * or a function that receives (prevValue, nextValue) and returns the direction.
+ */
+export type TrendProp = Trend | ((prev: number, next: number) => Trend);
+/**
+ * Animation behavior props shared by all Flow components (NumberFlow, TimeFlow,
+ * SkiaNumberFlow, SkiaTimeFlow). Controls how digit transitions behave.
+ */
+export interface AnimationBehaviorProps extends AnimationConfig {
+    /**
+     * Digit spin direction. When omitted, auto-detects from value changes:
+     * increasing values spin up, decreasing spin down.
+     * Pass `0` explicitly for shortest-path per-digit behavior.
+     */
+    trend?: TrendProp;
+    /** Set to false to disable animations and update instantly. Defaults to true. */
+    animated?: boolean;
+    /** When true (default), disables animations when the device's "Reduce Motion" setting is on. */
+    respectMotionPreference?: boolean;
+    /**
+     * When true, unchanged lower-significance digits spin through a full cycle
+     * during transitions, making the number appear to pass through intermediate values.
+     * Defaults to false.
+     */
+    continuous?: boolean;
+    /** Enable edge gradient fade masking on digit slots. Defaults to true. */
+    mask?: boolean;
+    /** Called when update animations begin */
+    onAnimationsStart?: () => void;
+    /** Called when all update animations complete */
+    onAnimationsFinish?: () => void;
+}
+/** A single character with a stable key from formatToParts RTL/LTR keying */
+export interface KeyedPart {
+    /** Stable key: "integer:0" (ones), "integer:1" (tens), "fraction:0" (tenths), "decimal:0", etc. */
+    key: string;
+    /** Whether this is a rolling digit or a static symbol */
+    type: "digit" | "symbol";
+    /** The display character */
+    char: string;
+    /** 0-9 for digits, -1 for symbols */
+    digitValue: number;
+}
+export declare function digitPart(key: string, value: number): KeyedPart;
+export declare function symbolPart(key: string, char: string): KeyedPart;
+export interface GlyphMetrics {
+    /** Advance width for each measurable character */
+    charWidths: Record<string, number>;
+    /** Maximum width among digits 0-9 (used for uniform digit slot sizing) */
+    maxDigitWidth: number;
+    /** Line height computed from font metrics: ceil(descent - ascent) */
+    lineHeight: number;
+    /** Font ascent (negative value — distance above baseline) */
+    ascent: number;
+    /** Font descent (positive value — distance below baseline) */
+    descent: number;
+    /**
+     * Per-character tight vertical bounds relative to the baseline.
+     * `top` is negative (above baseline), `bottom` is positive (below baseline).
+     * Used by the adaptive mask to avoid fading into visible glyph content.
+     */
+    charBounds: Record<string, {
+        top: number;
+        bottom: number;
+    }>;
+}
+export type TextAlign = "left" | "right" | "center";
+/**
+ * Per-position digit constraint. `max` defines the highest value the
+ * digit can display (inclusive), creating a wheel of (max + 1) values.
+ * Example: { max: 5 } creates a 0-5 wheel (6 elements).
+ */
+export interface DigitConstraint {
+    max: number;
+}
+/**
+ * Maps integer positions to their constraints.
+ * Position 0 = ones, 1 = tens, 2 = hundreds, etc.
+ * Positions not listed default to { max: 9 } (standard 0-9 wheel).
+ */
+export type DigitsProp = Record<number, DigitConstraint>;
+/** Value props — mutually exclusive: provide `value` (JS-driven) or `sharedValue` (worklet-driven), not both. */
+type SkiaNumberFlowValueProps = {
+    /** JS-thread numeric value. Mutually exclusive with sharedValue. */
+    value: number;
+    /** Intl.NumberFormatOptions for value formatting */
+    format?: Intl.NumberFormatOptions;
+    /** Locale(s) for Intl.NumberFormat */
+    locales?: Intl.LocalesArgument;
+    sharedValue?: never;
+} | {
+    value?: never;
+    format?: never;
+    locales?: never;
+    /** Worklet-driven pre-formatted string. Mutually exclusive with value. */
+    sharedValue: SharedValue<string>;
+};
+interface SkiaNumberFlowBaseProps extends AnimationBehaviorProps {
+    /** SkFont instance from useFont(). Required — renders empty until font loads. */
+    font: SkFont | null;
+    /** Text color (Skia color string). Defaults to "#000000". */
+    color?: string;
+    /** X position within the Canvas. Defaults to 0. */
+    x?: number;
+    /** Y position within the Canvas (baseline). Defaults to 0. */
+    y?: number;
+    /** Available width for alignment calculations. Defaults to 0. */
+    width?: number;
+    /** Text alignment within the available width. Defaults to "left". */
+    textAlign?: TextAlign;
+    /** Static string prepended before the number */
+    prefix?: string;
+    /** Static string appended after the number */
+    suffix?: string;
+    /** Parent opacity (SharedValue for animation coordination) */
+    opacity?: SharedValue<number>;
+    /**
+     * Per-position digit constraints. Maps integer position (0=ones, 1=tens, ...)
+     * to { max: N } where N is the highest digit value (inclusive).
+     * Example: { 1: { max: 5 } } for a wheel where tens go 0-5.
+     */
+    digits?: DigitsProp;
+    /**
+     * Controls digit width during worklet-driven scrubbing (when sharedValue is active).
+     * Value between 0 and 1 representing the percentile between min and max digit width.
+     * - 0: use narrowest digit width (tightest, may clip wide digits)
+     * - 0.5: use average digit width
+     * - 1: use widest digit width (no clipping, but wider spacing)
+     * Defaults to 0.75 (75th percentile) for a good balance.
+     * Only affects digits; symbols like "." keep their natural width.
+     */
+    scrubDigitWidthPercentile?: number;
+}
+/**
+ * Props for SkiaNumberFlow.
+ * Value changes are auto-announced for screen reader users.
+ * For VoiceOver/TalkBack focus-based reading, set `accessibilityLabel` on the parent Canvas.
+ */
+export type SkiaNumberFlowProps = SkiaNumberFlowBaseProps & SkiaNumberFlowValueProps;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/types.ts"],"names":[],"mappings":"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"}

package/lib/typescript/core/useAccessibilityAnnouncement.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Announces label changes to screen readers for Skia components.
+ *
+ * Skia renders inside <Canvas>, which is opaque to the accessibility tree.
+ * This hook auto-announces value changes when a screen reader is active
+ * so users get audio feedback. The first render is skipped to avoid
+ * announcing the initial value.
+ */
+export declare function useAccessibilityAnnouncement(label: string | undefined): void;
+//# sourceMappingURL=useAccessibilityAnnouncement.d.ts.map

package/lib/typescript/core/useAccessibilityAnnouncement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAccessibilityAnnouncement.d.ts","sourceRoot":"","sources":["../../../src/core/useAccessibilityAnnouncement.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAe5E"}

package/lib/typescript/core/useAnimatedX.d.ts

@@ -0,0 +1,9 @@
+import { type SharedValue } from "react-native-reanimated";
+import type { TimingConfig } from "./types";
+/**
+ * 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 declare function useAnimatedX(targetX: number, exiting: boolean, transformTiming: TimingConfig): SharedValue<number>;
+//# sourceMappingURL=useAnimatedX.d.ts.map

package/lib/typescript/core/useAnimatedX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnimatedX.d.ts","sourceRoot":"","sources":["../../../src/core/useAnimatedX.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,WAAW,EAAc,MAAM,yBAAyB,CAAC;AACpF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;;GAIG;AAEH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,eAAe,EAAE,YAAY,GAC5B,WAAW,CAAC,MAAM,CAAC,CAerB"}

package/lib/typescript/core/useAnimationLifecycle.d.ts

@@ -0,0 +1,14 @@
+import type { CharLayout } from "./layout";
+import type { TimingConfig } from "./types";
+/**
+ * Fires animation lifecycle callbacks (start/finish) when the layout changes.
+ *
+ * Uses refs for callbacks to avoid stale closures in the setTimeout,
+ * and tracks previous layout to detect actual changes (not initial mount).
+ */
+export declare function useAnimationLifecycle(layout: CharLayout[], timings: {
+    spin: TimingConfig;
+    opacity: TimingConfig;
+    transform: TimingConfig;
+}, onAnimationsStart?: () => void, onAnimationsFinish?: () => void): void;
+//# sourceMappingURL=useAnimationLifecycle.d.ts.map

package/lib/typescript/core/useAnimationLifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnimationLifecycle.d.ts","sourceRoot":"","sources":["../../../src/core/useAnimationLifecycle.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,UAAU,EAAE,EACpB,OAAO,EAAE;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAC;IAAC,SAAS,EAAE,YAAY,CAAA;CAAE,EAC/E,iBAAiB,CAAC,EAAE,MAAM,IAAI,EAC9B,kBAAkB,CAAC,EAAE,MAAM,IAAI,GAC9B,IAAI,CAsCN"}

package/lib/typescript/core/useCanAnimate.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 declare function useCanAnimate(respectMotionPreference?: boolean): boolean;
+//# sourceMappingURL=useCanAnimate.d.ts.map

package/lib/typescript/core/useCanAnimate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanAnimate.d.ts","sourceRoot":"","sources":["../../../src/core/useCanAnimate.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,uBAAuB,UAAO,GAAG,OAAO,CAMrE"}

package/lib/typescript/core/useContinuousSpin.d.ts

@@ -0,0 +1,23 @@
+import type { KeyedPart, Trend } from "./types";
+/**
+ * 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 declare function computeContinuousGenerations(prevParts: KeyedPart[], currentParts: KeyedPart[], prevGenerations: Map<string, number>): Map<string, number>;
+/**
+ * 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 declare function useContinuousSpin(keyedParts: KeyedPart[], continuous: boolean | undefined, trend: Trend): Map<string, number> | undefined;
+//# sourceMappingURL=useContinuousSpin.d.ts.map

package/lib/typescript/core/useContinuousSpin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContinuousSpin.d.ts","sourceRoot":"","sources":["../../../src/core/useContinuousSpin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGhD;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,SAAS,EAAE,EACtB,YAAY,EAAE,SAAS,EAAE,EACzB,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAqDrB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,SAAS,EAAE,EACvB,UAAU,EAAE,OAAO,GAAG,SAAS,EAC/B,KAAK,EAAE,KAAK,GACX,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAyBjC"}

package/lib/typescript/core/useDebouncedWidths.d.ts

@@ -0,0 +1,17 @@
+import { type SharedValue } from "react-native-reanimated";
+/**
+ * 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 declare function useDebouncedWidths(digitWidths: number[] | null, scrubDigitWidth: number, sharedValue: SharedValue<string> | undefined, prefix: string, suffix: string, zeroCodePoint?: number): SharedValue<number>[];
+//# sourceMappingURL=useDebouncedWidths.d.ts.map

package/lib/typescript/core/useDebouncedWidths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDebouncedWidths.d.ts","sourceRoot":"","sources":["../../../src/core/useDebouncedWidths.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,WAAW,EAGjB,MAAM,yBAAyB,CAAC;AAMjC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EAAE,GAAG,IAAI,EAC5B,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,EAC5C,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,aAAa,SAAK,GACjB,WAAW,CAAC,MAAM,CAAC,EAAE,CA2DvB"}

package/lib/typescript/core/useDigitAnimation.d.ts

@@ -0,0 +1,38 @@
+import { type SharedValue } from "react-native-reanimated";
+import type { TimingConfig, Trend } from "./types";
+/**
+ * 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.
+ */
+interface UseDigitAnimationParams {
+    digitValue: number;
+    entering: boolean;
+    exiting: boolean;
+    trend: Trend;
+    spinTiming: TimingConfig;
+    opacityTiming: TimingConfig;
+    exitKey?: string;
+    onExitComplete?: (key: string) => void;
+    workletDigitValue?: SharedValue<number>;
+    /** Number of values in this digit's wheel. Defaults to 10 (0-9). */
+    digitCount?: number;
+    /** Incrementing counter from useContinuousSpin; triggers a full-wheel rotation when changed. */
+    continuousSpinGeneration?: number;
+}
+interface UseDigitAnimationResult {
+    initialDigit: number;
+    animDelta: SharedValue<number>;
+    currentDigitSV: SharedValue<number>;
+    slotOpacity: SharedValue<number>;
+}
+/**
+ * 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 declare function useDigitAnimation({ digitValue, entering, exiting, trend, spinTiming, opacityTiming, exitKey, onExitComplete, workletDigitValue, digitCount, continuousSpinGeneration, }: UseDigitAnimationParams): UseDigitAnimationResult;
+export {};
+//# sourceMappingURL=useDigitAnimation.d.ts.map

package/lib/typescript/core/useDigitAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDigitAnimation.d.ts","sourceRoot":"","sources":["../../../src/core/useDigitAnimation.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,WAAW,EAGjB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAInD;;;;GAIG;AAEH,UAAU,uBAAuB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;IACb,UAAU,EAAE,YAAY,CAAC;IACzB,aAAa,EAAE,YAAY,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,iBAAiB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACxC,oEAAoE;IACpE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,UAAU,uBAAuB;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC/B,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACpC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAClC;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,UAAU,EACV,QAAQ,EACR,OAAO,EACP,KAAK,EACL,UAAU,EACV,aAAa,EACb,OAAO,EACP,cAAc,EACd,iBAAiB,EACjB,UAAU,EACV,wBAAwB,GACzB,EAAE,uBAAuB,GAAG,uBAAuB,CAkInD"}

package/lib/typescript/core/useFlowPipeline.d.ts

@@ -0,0 +1,46 @@
+import type { CharLayout } from "./layout";
+import { type MaskHeights } from "./mask";
+import type { GlyphMetrics, KeyedPart, TimingConfig, Trend, TrendProp } from "./types";
+interface FlowPipelineInput {
+    keyedParts: KeyedPart[];
+    trendValue: number | undefined;
+    layout: CharLayout[];
+    metrics: GlyphMetrics | null;
+    animated?: boolean;
+    respectMotionPreference?: boolean;
+    spinTiming?: TimingConfig;
+    opacityTiming?: TimingConfig;
+    transformTiming?: TimingConfig;
+    trend?: TrendProp;
+    continuous?: boolean;
+    mask?: boolean;
+    onAnimationsStart?: () => void;
+    onAnimationsFinish?: () => void;
+}
+interface FlowPipelineOutput {
+    resolvedSpinTiming: TimingConfig;
+    resolvedOpacityTiming: TimingConfig;
+    resolvedTransformTiming: TimingConfig;
+    resolvedTrend: Trend;
+    spinGenerations: Map<string, number> | undefined;
+    prevMap: Map<string, CharLayout>;
+    isInitialRender: boolean;
+    exitingEntries: Map<string, CharLayout>;
+    onExitComplete: (key: string) => void;
+    accessibilityLabel: string | undefined;
+    adaptiveMask: MaskHeights;
+}
+/**
+ * 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 declare function useFlowPipeline(input: FlowPipelineInput): FlowPipelineOutput;
+export {};
+//# sourceMappingURL=useFlowPipeline.d.ts.map

package/lib/typescript/core/useFlowPipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFlowPipeline.d.ts","sourceRoot":"","sources":["../../../src/core/useFlowPipeline.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAA8B,KAAK,WAAW,EAAE,MAAM,QAAQ,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAOvF,UAAU,iBAAiB;IACzB,UAAU,EAAE,SAAS,EAAE,CAAC;IAKxB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAI/B,MAAM,EAAE,UAAU,EAAE,CAAC;IAGrB,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;IAG7B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B,aAAa,CAAC,EAAE,YAAY,CAAC;IAC7B,eAAe,CAAC,EAAE,YAAY,CAAC;IAC/B,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC/B,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAC;CACjC;AAED,UAAU,kBAAkB;IAC1B,kBAAkB,EAAE,YAAY,CAAC;IACjC,qBAAqB,EAAE,YAAY,CAAC;IACpC,uBAAuB,EAAE,YAAY,CAAC;IACtC,aAAa,EAAE,KAAK,CAAC;IACrB,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IAEjD,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACjC,eAAe,EAAE,OAAO,CAAC;IACzB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACxC,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAEtC,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,YAAY,EAAE,WAAW,CAAC;CAC3B;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,iBAAiB,GAAG,kBAAkB,CA0D5E"}

package/lib/typescript/core/useFormattedValue.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 declare function useFormattedValue(value: number | undefined, format?: Intl.NumberFormatOptions, locales?: Intl.LocalesArgument, prefix?: string, suffix?: string): string | undefined;
+//# sourceMappingURL=useFormattedValue.d.ts.map

package/lib/typescript/core/useFormattedValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormattedValue.d.ts","sourceRoot":"","sources":["../../../src/core/useFormattedValue.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,MAAM,CAAC,EAAE,IAAI,CAAC,mBAAmB,EACjC,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,EAC9B,MAAM,CAAC,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,GAAG,SAAS,CAUpB"}

package/lib/typescript/core/useLayoutDiff.d.ts

@@ -0,0 +1,18 @@
+import type { CharLayout } from "./layout";
+interface LayoutDiffResult {
+    prevMap: Map<string, CharLayout>;
+    isInitialRender: boolean;
+    exitingEntries: Map<string, CharLayout>;
+    onExitComplete: (key: string) => void;
+}
+/**
+ * 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 declare function useLayoutDiff(layout: CharLayout[]): LayoutDiffResult;
+export {};
+//# sourceMappingURL=useLayoutDiff.d.ts.map

package/lib/typescript/core/useLayoutDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLayoutDiff.d.ts","sourceRoot":"","sources":["../../../src/core/useLayoutDiff.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,UAAU,gBAAgB;IACxB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACjC,eAAe,EAAE,OAAO,CAAC;IACzB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACxC,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,gBAAgB,CAoDpE"}

package/lib/typescript/core/useNumberFormatting.d.ts

@@ -0,0 +1,18 @@
+import type { KeyedPart } from "./types";
+/**
+ * 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 declare function formatToKeyedParts(value: number, formatter: Intl.NumberFormat, locales: Intl.LocalesArgument | undefined, prefix?: string, suffix?: string): KeyedPart[];
+/**
+ * Hook that formats a numeric value into stably-keyed character parts.
+ * Uses Intl.NumberFormat.formatToParts() with RTL integer keying.
+ */
+export declare function useNumberFormatting(value: number | undefined, format: Intl.NumberFormatOptions | undefined, locales: Intl.LocalesArgument | undefined, prefix: string, suffix: string): KeyedPart[];
+//# sourceMappingURL=useNumberFormatting.d.ts.map

package/lib/typescript/core/useNumberFormatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNumberFormatting.d.ts","sourceRoot":"","sources":["../../../src/core/useNumberFormatting.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,IAAI,CAAC,YAAY,EAC5B,OAAO,EAAE,IAAI,CAAC,eAAe,GAAG,SAAS,EACzC,MAAM,SAAK,EACX,MAAM,SAAK,GACV,SAAS,EAAE,CAwHb;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,MAAM,EAAE,IAAI,CAAC,mBAAmB,GAAG,SAAS,EAC5C,OAAO,EAAE,IAAI,CAAC,eAAe,GAAG,SAAS,EACzC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,SAAS,EAAE,CAUb"}

package/lib/typescript/core/useSlotOpacity.d.ts

@@ -0,0 +1,18 @@
+import { type SharedValue } from "react-native-reanimated";
+import type { TimingConfig } from "./types";
+/**
+ * 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.
+ */
+interface UseSlotOpacityParams {
+    entering: boolean;
+    exiting: boolean;
+    opacityTiming: TimingConfig;
+    exitKey?: string;
+    onExitComplete?: (key: string) => void;
+    onExitingStart?: () => void;
+}
+export declare function useSlotOpacity({ entering, exiting, opacityTiming, exitKey, onExitComplete, onExitingStart, }: UseSlotOpacityParams): SharedValue<number>;
+export {};
+//# sourceMappingURL=useSlotOpacity.d.ts.map

package/lib/typescript/core/useSlotOpacity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSlotOpacity.d.ts","sourceRoot":"","sources":["../../../src/core/useSlotOpacity.ts"],"names":[],"mappings":"AACA,OAAO,EAAwB,KAAK,WAAW,EAAc,MAAM,yBAAyB,CAAC;AAC7F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;;GAIG;AAEH,UAAU,oBAAoB;IAC5B,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,YAAY,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;CAC7B;AAED,wBAAgB,cAAc,CAAC,EAC7B,QAAQ,EACR,OAAO,EACP,aAAa,EACb,OAAO,EACP,cAAc,EACd,cAAc,GACf,EAAE,oBAAoB,GAAG,WAAW,CAAC,MAAM,CAAC,CAuC5C"}

package/lib/typescript/core/useTimeFormatting.d.ts

@@ -0,0 +1,22 @@
+import { type KeyedPart } from "./types";
+/**
+ * Converts 24h hours (0-23) to 12h display value (1-12).
+ * 0 → 12 (12 AM), 1-12 → as-is, 13-23 → subtract 12.
+ */
+export declare function to12Hour(h: number): number;
+/**
+ * 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 declare function formatTimeToKeyedParts(hours: number | undefined, minutes: number, seconds: number | undefined, is24Hour: boolean, padHours: boolean): KeyedPart[];
+/**
+ * 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 declare function useTimeFormatting(hours: number | undefined, minutes: number, seconds: number | undefined, is24Hour: boolean, padHours: boolean): KeyedPart[];
+//# sourceMappingURL=useTimeFormatting.d.ts.map

package/lib/typescript/core/useTimeFormatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTimeFormatting.d.ts","sourceRoot":"","sources":["../../../src/core/useTimeFormatting.ts"],"names":[],"mappings":"AACA,OAAO,EAAyB,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAEhE;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAI1C;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,QAAQ,EAAE,OAAO,EACjB,QAAQ,EAAE,OAAO,GAChB,SAAS,EAAE,CAiDb;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,QAAQ,EAAE,OAAO,EACjB,QAAQ,EAAE,OAAO,GAChB,SAAS,EAAE,CAKb"}

package/lib/typescript/core/useTimingResolution.d.ts

@@ -0,0 +1,13 @@
+import type { TimingConfig } from "./types";
+interface ResolvedTimings {
+    resolvedSpinTiming: TimingConfig;
+    resolvedOpacityTiming: TimingConfig;
+    resolvedTransformTiming: TimingConfig;
+}
+/**
+ * Resolves animation timing based on the `animated` prop and reduced-motion preference.
+ * When animations are disabled, all timings collapse to zero-duration.
+ */
+export declare function useTimingResolution(animated: boolean | undefined, respectMotionPreference: boolean | undefined, spinTiming?: TimingConfig, opacityTiming?: TimingConfig, transformTiming?: TimingConfig): ResolvedTimings;
+export {};
+//# sourceMappingURL=useTimingResolution.d.ts.map

package/lib/typescript/core/useTimingResolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTimingResolution.d.ts","sourceRoot":"","sources":["../../../src/core/useTimingResolution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAS5C,UAAU,eAAe;IACvB,kBAAkB,EAAE,YAAY,CAAC;IACjC,qBAAqB,EAAE,YAAY,CAAC;IACpC,uBAAuB,EAAE,YAAY,CAAC;CACvC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,OAAO,GAAG,SAAS,EAC7B,uBAAuB,EAAE,OAAO,GAAG,SAAS,EAC5C,UAAU,CAAC,EAAE,YAAY,EACzB,aAAa,CAAC,EAAE,YAAY,EAC5B,eAAe,CAAC,EAAE,YAAY,GAC7B,eAAe,CAqBjB"}

package/lib/typescript/core/useWorkletFormatting.d.ts

@@ -0,0 +1,14 @@
+import { type SharedValue } from "react-native-reanimated";
+/**
+ * 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 declare function useWorkletFormatting(sharedValue: SharedValue<string> | undefined, prefix: string, suffix: string, zeroCodePoint?: number): SharedValue<number>[] | null;
+//# sourceMappingURL=useWorkletFormatting.d.ts.map

package/lib/typescript/core/useWorkletFormatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWorkletFormatting.d.ts","sourceRoot":"","sources":["../../../src/core/useWorkletFormatting.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,WAAW,EAAuB,MAAM,yBAAyB,CAAC;AAI7F;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,EAC5C,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,aAAa,SAAK,GACjB,WAAW,CAAC,MAAM,CAAC,EAAE,GAAG,IAAI,CAqC9B"}

package/lib/typescript/core/utils.d.ts

@@ -0,0 +1,44 @@
+import type { Trend, TrendProp } from "./types";
+/**
+ * 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 declare function signedDigitOffset(n: number, c: number, digitCount?: number): number;
+/**
+ * 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 declare function computeRollDelta(prev: number, next: number, trend: number, digitCount?: number): number;
+/**
+ * Resolves a TrendProp (static value or function) into a concrete Trend.
+ * When undefined, auto-detects direction from the value change.
+ */
+export declare function resolveTrend(trendProp: TrendProp | undefined, prevValue: number | undefined, nextValue: number | undefined): Trend;
+/**
+ * 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 declare function parseDigitPosition(key: string): number | undefined;
+/**
+ * Correct wheel size for each time digit position.
+ * s10/m10 only go 0-5, h10 only goes 0-2.
+ */
+export declare const TIME_DIGIT_COUNTS: Record<string, number>;
+/**
+ * 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 declare function getDigitCount(digits: Record<number, {
+    max: number;
+}> | undefined, key: string): number;
+//# sourceMappingURL=utils.d.ts.map

package/lib/typescript/core/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEhD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,GAAE,MAAoB,GAAG,MAAM,CAOhG;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,UAAU,GAAE,MAAoB,GAC/B,MAAM,CAqBR;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,KAAK,CAeP;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CA+BlE;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAOpD,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,SAAS,EACnD,GAAG,EAAE,MAAM,GACV,MAAM,CAQR"}

package/lib/typescript/core/warnings.d.ts

@@ -0,0 +1,2 @@
+export declare function warnOnce(key: string, message: string): void;
+//# sourceMappingURL=warnings.d.ts.map

package/lib/typescript/core/warnings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warnings.d.ts","sourceRoot":"","sources":["../../../src/core/warnings.ts"],"names":[],"mappings":"AAEA,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAK3D"}

package/lib/typescript/index.d.ts

@@ -0,0 +1,8 @@
+export { detectNumberingSystem, getDigitStrings, getZeroCodePoint } from "./core/numerals";
+export type { TimeFlowProps } from "./core/timeTypes";
+export type { AnimationConfig, DigitConstraint, DigitsProp, TextAlign, TimingConfig, Trend, TrendProp, } from "./core/types";
+export { useCanAnimate } from "./core/useCanAnimate";
+export { useFormattedValue } from "./core/useFormattedValue";
+export { NumberFlow, TimeFlow } from "./native";
+export type { NumberFlowProps, NumberFlowStyle } from "./native/types";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAC3F,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,YAAY,EACV,eAAe,EACf,eAAe,EACf,UAAU,EACV,SAAS,EACT,YAAY,EACZ,KAAK,EACL,SAAS,GACV,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAChD,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}