react-native-gtkx 0.3.0-alpha.1 → 0.4.0-alpha.2

package/dist/reanimated-compat/animatable-value.d.ts

@@ -0,0 +1,158 @@
+import type { CompositeAnimation, EasingFunction, FrameScheduler, MakeStep } from "../animated/index";
+import { springStep } from "../animated/index";
+import type { WithSpringConfig } from "./animation";
+/** Upstream's `AnimatableValue`, minus colour strings — those keep the
+ * existing, separate `interpolateColor` path (docs/api.md), so a leaf here
+ * is always a number. */
+export type AnimatableValue = number | AnimatableArray | AnimatableObject;
+export type AnimatableArray = readonly number[];
+export type AnimatableObject = {
+    readonly [key: string]: AnimatableValue;
+};
+/** A path from the root of an `AnimatableValue` to one of its number leaves. */
+export type LeafPath = ReadonlyArray<string | number>;
+/**
+ * True for anything `withTiming`/`withSpring` can legally target: a finite
+ * number, a plain object of these (recursively — upstream's `objectOnStart`
+ * re-decorates its clones' `onStart`, so nested objects genuinely work), or
+ * a plain array of finite numbers (upstream's arrays are flat: a clone's
+ * `onStart` is the undecorated base one, so an array element is always a
+ * number, never itself an object or array).
+ */
+export declare const isAnimatableValue: (value: unknown) => value is AnimatableValue;
+/**
+ * Validates and returns `value` unchanged — no cloning, exactly upstream's
+ * `defineAnimation` returning `starting` by reference under
+ * `IN_STYLE_UPDATER`. Throws the same shape of error the number-only gate
+ * always has, widened to name the actual offending leaf.
+ */
+export declare const assertAnimatableValue: <T>(value: T, api: string) => T;
+/** A single leaf: where it lives in the shape, and its two endpoints. */
+type LeafEndpoints = {
+    path: LeafPath;
+    from: number;
+    to: number;
+};
+/**
+ * The shape a merged frame is rebuilt from: a tree with the SAME keys/indices
+ * as the origin value, and a leaf index in place of every number — recorded
+ * once, at the start of an animation, and reused every frame
+ * (`rebuildAnimatableValue`) rather than re-walked.
+ */
+export type AnimatableShape = {
+    kind: "leaf";
+    index: number;
+} | {
+    kind: "array";
+    children: readonly AnimatableShape[];
+} | {
+    kind: "object";
+    children: Readonly<Record<string, AnimatableShape>>;
+};
+/**
+ * Walks `from` and `to` together into a flat leaf list plus the shape to
+ * rebuild frames from. Throws when the two do not line up — see the header:
+ * this is the one place this platform's behaviour is a deliberate, documented
+ * departure from upstream's silent drop.
+ */
+export declare const zipAnimatableLeaves: (api: string, from: AnimatableValue, to: AnimatableValue) => {
+    shape: AnimatableShape;
+    leaves: LeafEndpoints[];
+};
+/** The inverse of the walk above: leaf values, in `zipAnimatableLeaves` order, folded back into `shape`'s structure. */
+export declare const rebuildAnimatableValue: (shape: AnimatableShape, values: readonly number[]) => AnimatableValue;
+/**
+ * A deterministic string for an `AnimatableValue`, key order independent —
+ * `animationSignature` (animation.ts) uses this so two target objects built
+ * with the same keys in a different order (`{x, y}` vs `{y, x}`, both
+ * entirely normal across two renders) are recognised as the same animation
+ * rather than restarting it.
+ */
+export declare const animatableValueSignature: (value: AnimatableValue) => string;
+/**
+ * Structural, not reference, equality — an object rebuilt fresh every frame
+ * (`rebuildAnimatableValue`) is never `Object.is` the value it replaces even
+ * when every leaf agrees. Used where the number-only code compared with
+ * `Object.is` (`updater-animations.ts`'s snap-on-replacement rule); returns
+ * `false` on a shape it cannot line up rather than throwing — this is a
+ * comparison, not a build, and "different" is always a safe answer here.
+ */
+export declare const sameAnimatableValue: (a: AnimatableValue, b: AnimatableValue) => boolean;
+/**
+ * The largest change any single leaf underwent, for the landing cadence's
+ * epsilon check (`updater-animations.ts`): the old question — did the number
+ * move a pixel — becomes: did any leaf move a pixel. A `{x, y}` position where
+ * only `y` is moving still has to land.
+ */
+export declare const maxAnimatableLeafDelta: (a: AnimatableValue, b: AnimatableValue) => number;
+/**
+ * A `MakeStep` over a whole `AnimatableValue`: every leaf gets its own
+ * `timingStep`/`springStep` (upstream's per-leaf clone, `objectOnStart`) —
+ * SAME duration/easing/config for a timing leaf, an INDEPENDENTLY solved
+ * spring per leaf (each one's stiffness/damping only depends on ITS OWN
+ * displacement — `toPlatformSpringConfig` already computes it that way for
+ * the single-number case, called once per leaf here) — stepped in lockstep
+ * off ONE elapsed clock so the merged object publishes exactly once a frame,
+ * never once per leaf. `done` is the AND across every leaf, matching
+ * upstream's `objectOnFrame`.
+ */
+export type LeafStepFactory = (from: number, to: number) => MakeStep;
+export declare const shapeMakeSteps: (api: string, toValue: AnimatableValue, leafStepFor: LeafStepFactory) => ((startValue: AnimatableValue) => (elapsedMs: number) => {
+    position: AnimatableValue | null;
+    done: boolean;
+});
+/** `shapeMakeSteps` specialised for `withTiming`: every leaf shares the same duration/easing. */
+export declare const timingShapeMakeSteps: (toValue: AnimatableValue, duration: number, easing: EasingFunction) => (startValue: AnimatableValue) => (elapsedMs: number) => {
+    position: AnimatableValue | null;
+    done: boolean;
+};
+/**
+ * `shapeMakeSteps` specialised for `withSpring`: each leaf's physical
+ * parameters are solved independently, via `toPlatformSpringConfig` (passed
+ * in — animation.ts owns it — rather than duplicated here).
+ */
+export declare const springShapeMakeSteps: (toValue: AnimatableValue, toPlatformSpringConfig: (config: WithSpringConfig, toValue: number, from: number) => Parameters<typeof springStep>[0], config: WithSpringConfig) => (startValue: AnimatableValue) => (elapsedMs: number) => {
+    position: AnimatableValue | null;
+    done: boolean;
+};
+type ShapeListener = (event: {
+    value: AnimatableValue;
+}) => void;
+/**
+ * The object/array counterpart of `AnimatedValue` — deliberately minimal
+ * rather than a generalisation of that class: no offset, no `interpolate`,
+ * no self-tracked "current animation" (every caller here already stops the
+ * previous `CompositeAnimation` itself before starting a new one — mutable.ts
+ * and updater-animations.ts both do, same as they always have). What it DOES
+ * match is the structural shape `buildAnimation`, mutable.ts and
+ * updater-animations.ts actually read off a driver: `__getValue`,
+ * `addListener`/`removeListener`, and `setValue` for `buildRepeat`'s replay
+ * branch (the one place a driver is force-set from outside an animation).
+ */
+export declare class AnimatedShapeValue {
+    private _value;
+    private readonly _listeners;
+    private _nextListenerId;
+    constructor(value: AnimatableValue);
+    __getValue(): AnimatableValue;
+    /** @internal Called once per animation frame, after every leaf has stepped. */
+    __updateValue(value: AnimatableValue): void;
+    /** RN's own escape hatch: force the value, notifying listeners — what `withRepeat`'s non-reverse replay uses to snap back between iterations. */
+    setValue(value: AnimatableValue): void;
+    addListener(listener: ShapeListener): string;
+    removeListener(id: string): void;
+}
+/**
+ * `createValueAnimation`'s counterpart for an `AnimatedShapeValue` — same
+ * start/stop/preemption contract (a second `start()` on the same
+ * `CompositeAnimation` preempts the first, reporting `{finished: false}`),
+ * deliberately re-implemented rather than generalising `createValueAnimation`
+ * itself: that function is `src/animated`'s, i.e. RN's own Animated engine,
+ * scalar by the RN spec it mirrors (`Animated.ValueXY` is RN's own answer to
+ * a pair, and is a different, narrower thing). This is reanimated-compat's
+ * own extension point, the same way `decayStep` + the PUBLIC
+ * `createValueAnimation` was for `withDecay` — except here the driver itself
+ * is not the platform's, so the harness around it is not either.
+ */
+export declare const createShapeValueAnimation: (scheduler: FrameScheduler, value: AnimatedShapeValue, makeSteps: ReturnType<typeof shapeMakeSteps>) => CompositeAnimation;
+export {};

package/dist/reanimated-compat/animatable-value.js

@@ -0,0 +1,316 @@
+import { springStep, timingStep } from "../animated/index";
+const pathToString = (path) => path.length === 0 ? "(root)" : path.join(".");
+/**
+ * True for anything `withTiming`/`withSpring` can legally target: a finite
+ * number, a plain object of these (recursively — upstream's `objectOnStart`
+ * re-decorates its clones' `onStart`, so nested objects genuinely work), or
+ * a plain array of finite numbers (upstream's arrays are flat: a clone's
+ * `onStart` is the undecorated base one, so an array element is always a
+ * number, never itself an object or array).
+ */
+export const isAnimatableValue = (value) => {
+    if (typeof value === "number") {
+        return Number.isFinite(value);
+    }
+    if (Array.isArray(value)) {
+        return value.every((item) => typeof item === "number" && Number.isFinite(item));
+    }
+    if (typeof value === "object" && value !== null) {
+        return Object.values(value).every(isAnimatableValue);
+    }
+    return false;
+};
+/**
+ * Validates and returns `value` unchanged — no cloning, exactly upstream's
+ * `defineAnimation` returning `starting` by reference under
+ * `IN_STYLE_UPDATER`. Throws the same shape of error the number-only gate
+ * always has, widened to name the actual offending leaf.
+ */
+export const assertAnimatableValue = (value, api) => {
+    if (!isAnimatableValue(value)) {
+        throw new Error(`react-native-reanimated: ${api}() on this platform animates finite numbers, and plain objects/arrays whose leaves are finite numbers. Got ${typeof value === "string" ? `"${String(value)}"` : String(value)}. Colors and layout properties cannot be driven imperatively here yet — see docs/api.md.`);
+    }
+    return value;
+};
+const shapeMismatch = (api, path, from, to) => new Error(`react-native-reanimated: ${api}() was given a target whose shape does not match the value it is animating from, at ${pathToString(path)} ` +
+    `(from ${JSON.stringify(from)}, to ${JSON.stringify(to)}). ` +
+    "Upstream drives this from the FROM value's own keys and silently leaves a mismatched one at its previous value forever — " +
+    "this platform throws instead, naming where the shapes disagree. See docs/api.md, “Animated values”.");
+const buildShape = (api, from, to, path, leaves) => {
+    if (typeof from === "number") {
+        if (typeof to !== "number") {
+            throw shapeMismatch(api, path, from, to);
+        }
+        const index = leaves.length;
+        leaves.push({ path, from, to });
+        return { kind: "leaf", index };
+    }
+    if (Array.isArray(from)) {
+        if (!Array.isArray(to) || to.length !== from.length) {
+            throw shapeMismatch(api, path, from, to);
+        }
+        return {
+            kind: "array",
+            children: from.map((item, index) => buildShape(api, item, to[index], [...path, index], leaves)),
+        };
+    }
+    // A plain object (isAnimatableValue already refused everything else).
+    const fromObject = from;
+    if (typeof to !== "object" || to === null || Array.isArray(to)) {
+        throw shapeMismatch(api, path, from, to);
+    }
+    const toObject = to;
+    const fromKeys = Object.keys(fromObject).sort();
+    const toKeys = Object.keys(toObject).sort();
+    if (fromKeys.length !== toKeys.length ||
+        fromKeys.some((key, index) => key !== toKeys[index])) {
+        throw shapeMismatch(api, path, from, to);
+    }
+    const children = {};
+    for (const key of fromKeys) {
+        children[key] = buildShape(api, fromObject[key], toObject[key], [...path, key], leaves);
+    }
+    return { kind: "object", children };
+};
+/**
+ * Walks `from` and `to` together into a flat leaf list plus the shape to
+ * rebuild frames from. Throws when the two do not line up — see the header:
+ * this is the one place this platform's behaviour is a deliberate, documented
+ * departure from upstream's silent drop.
+ */
+export const zipAnimatableLeaves = (api, from, to) => {
+    const leaves = [];
+    const shape = buildShape(api, from, to, [], leaves);
+    return { shape, leaves };
+};
+/** The inverse of the walk above: leaf values, in `zipAnimatableLeaves` order, folded back into `shape`'s structure. */
+export const rebuildAnimatableValue = (shape, values) => {
+    switch (shape.kind) {
+        case "leaf":
+            return values[shape.index];
+        case "array":
+            return shape.children.map((child) => rebuildAnimatableValue(child, values));
+        case "object": {
+            const result = {};
+            for (const key of Object.keys(shape.children)) {
+                result[key] = rebuildAnimatableValue(shape.children[key], values);
+            }
+            return result;
+        }
+    }
+};
+/**
+ * A deterministic string for an `AnimatableValue`, key order independent —
+ * `animationSignature` (animation.ts) uses this so two target objects built
+ * with the same keys in a different order (`{x, y}` vs `{y, x}`, both
+ * entirely normal across two renders) are recognised as the same animation
+ * rather than restarting it.
+ */
+export const animatableValueSignature = (value) => {
+    if (typeof value === "number") {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => item).join(",")}]`;
+    }
+    const object = value;
+    const keys = Object.keys(object).sort();
+    return `{${keys.map((key) => `${key}:${animatableValueSignature(object[key])}`).join(",")}}`;
+};
+/**
+ * Structural, not reference, equality — an object rebuilt fresh every frame
+ * (`rebuildAnimatableValue`) is never `Object.is` the value it replaces even
+ * when every leaf agrees. Used where the number-only code compared with
+ * `Object.is` (`updater-animations.ts`'s snap-on-replacement rule); returns
+ * `false` on a shape it cannot line up rather than throwing — this is a
+ * comparison, not a build, and "different" is always a safe answer here.
+ */
+export const sameAnimatableValue = (a, b) => {
+    if (typeof a === "number" || typeof b === "number") {
+        // Object.is, not ===: -0/0 and NaN/NaN are distinct/equal respectively,
+        // matching what the number-only code compared landed values with before
+        // this function existed.
+        return Object.is(a, b);
+    }
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+            return false;
+        }
+        return a.every((item, index) => Object.is(item, b[index]));
+    }
+    const objectA = a;
+    const objectB = b;
+    const keysA = Object.keys(objectA);
+    const keysB = Object.keys(objectB);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    return keysA.every((key) => key in objectB && sameAnimatableValue(objectA[key], objectB[key]));
+};
+/**
+ * The largest change any single leaf underwent, for the landing cadence's
+ * epsilon check (`updater-animations.ts`): the old question — did the number
+ * move a pixel — becomes: did any leaf move a pixel. A `{x, y}` position where
+ * only `y` is moving still has to land.
+ */
+export const maxAnimatableLeafDelta = (a, b) => {
+    if (typeof a === "number") {
+        return typeof b === "number" ? Math.abs(a - b) : Number.POSITIVE_INFINITY;
+    }
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b) || a.length !== b.length) {
+            return Number.POSITIVE_INFINITY;
+        }
+        return Math.max(0, ...a.map((item, index) => maxAnimatableLeafDelta(item, b[index])));
+    }
+    const objectA = a;
+    const objectB = b;
+    const keys = Object.keys(objectA);
+    if (typeof b !== "object" || b === null || Array.isArray(b)) {
+        return Number.POSITIVE_INFINITY;
+    }
+    return Math.max(0, ...keys.map((key) => key in objectB
+        ? maxAnimatableLeafDelta(objectA[key], objectB[key])
+        : Number.POSITIVE_INFINITY));
+};
+export const shapeMakeSteps = (api, toValue, leafStepFor) => {
+    return (startValue) => {
+        const { shape, leaves } = zipAnimatableLeaves(api, startValue, toValue);
+        const stepFns = leaves.map(({ from, to }) => leafStepFor(from, to)(from));
+        return (elapsedMs) => {
+            let allDone = true;
+            const positions = [];
+            for (const stepFn of stepFns) {
+                const result = stepFn(elapsedMs);
+                // Every leaf here has delay 0 (withDelay wraps the WHOLE animation,
+                // never one leaf) so a step never actually returns a null position —
+                // this is defensive, not a case that fires.
+                positions.push(result.position ?? Number.NaN);
+                if (!result.done) {
+                    allDone = false;
+                }
+            }
+            return {
+                position: rebuildAnimatableValue(shape, positions),
+                done: allDone,
+            };
+        };
+    };
+};
+/** `shapeMakeSteps` specialised for `withTiming`: every leaf shares the same duration/easing. */
+export const timingShapeMakeSteps = (toValue, duration, easing) => shapeMakeSteps("withTiming", toValue, (from, to) => timingStep(to, duration, easing));
+/**
+ * `shapeMakeSteps` specialised for `withSpring`: each leaf's physical
+ * parameters are solved independently, via `toPlatformSpringConfig` (passed
+ * in — animation.ts owns it — rather than duplicated here).
+ */
+export const springShapeMakeSteps = (toValue, toPlatformSpringConfig, config) => shapeMakeSteps("withSpring", toValue, (from, to) => springStep(toPlatformSpringConfig(config, to, from)));
+/**
+ * The object/array counterpart of `AnimatedValue` — deliberately minimal
+ * rather than a generalisation of that class: no offset, no `interpolate`,
+ * no self-tracked "current animation" (every caller here already stops the
+ * previous `CompositeAnimation` itself before starting a new one — mutable.ts
+ * and updater-animations.ts both do, same as they always have). What it DOES
+ * match is the structural shape `buildAnimation`, mutable.ts and
+ * updater-animations.ts actually read off a driver: `__getValue`,
+ * `addListener`/`removeListener`, and `setValue` for `buildRepeat`'s replay
+ * branch (the one place a driver is force-set from outside an animation).
+ */
+export class AnimatedShapeValue {
+    _value;
+    _listeners = new Map();
+    _nextListenerId = 1;
+    constructor(value) {
+        this._value = value;
+    }
+    __getValue() {
+        return this._value;
+    }
+    /** @internal Called once per animation frame, after every leaf has stepped. */
+    __updateValue(value) {
+        this._value = value;
+        for (const listener of [...this._listeners.values()]) {
+            listener({ value });
+        }
+    }
+    /** RN's own escape hatch: force the value, notifying listeners — what `withRepeat`'s non-reverse replay uses to snap back between iterations. */
+    setValue(value) {
+        this.__updateValue(value);
+    }
+    addListener(listener) {
+        const id = String(this._nextListenerId++);
+        this._listeners.set(id, listener);
+        return id;
+    }
+    removeListener(id) {
+        this._listeners.delete(id);
+    }
+}
+/**
+ * `createValueAnimation`'s counterpart for an `AnimatedShapeValue` — same
+ * start/stop/preemption contract (a second `start()` on the same
+ * `CompositeAnimation` preempts the first, reporting `{finished: false}`),
+ * deliberately re-implemented rather than generalising `createValueAnimation`
+ * itself: that function is `src/animated`'s, i.e. RN's own Animated engine,
+ * scalar by the RN spec it mirrors (`Animated.ValueXY` is RN's own answer to
+ * a pair, and is a different, narrower thing). This is reanimated-compat's
+ * own extension point, the same way `decayStep` + the PUBLIC
+ * `createValueAnimation` was for `withDecay` — except here the driver itself
+ * is not the platform's, so the harness around it is not either.
+ */
+export const createShapeValueAnimation = (scheduler, value, makeSteps) => {
+    let activeStop = null;
+    const start = (callback) => {
+        // A second start() on the SAME CompositeAnimation preempts the first,
+        // reporting { finished: false } to its own callback — RN parity, and
+        // resolved fully before the new run's state exists below, so there is no
+        // reentrancy between the two.
+        activeStop?.();
+        const step = makeSteps(value.__getValue());
+        let startTime = scheduler.now?.() ?? null;
+        let ended = false;
+        let cancelFrame = null;
+        const end = (finished) => {
+            if (ended) {
+                return;
+            }
+            ended = true;
+            cancelFrame?.();
+            cancelFrame = null;
+            if (activeStop === stop) {
+                activeStop = null;
+            }
+            callback?.({ finished });
+        };
+        const stop = () => end(false);
+        const onFrame = (timeMs) => {
+            cancelFrame = null;
+            if (ended) {
+                return;
+            }
+            if (startTime === null) {
+                startTime = timeMs;
+            }
+            const { position, done } = step(timeMs - startTime);
+            if (position !== null) {
+                value.__updateValue(position);
+            }
+            if (done) {
+                end(true);
+                return;
+            }
+            cancelFrame = scheduler.schedule(onFrame);
+        };
+        activeStop = stop;
+        cancelFrame = scheduler.schedule(onFrame);
+    };
+    return {
+        start,
+        stop: () => activeStop?.(),
+        // No known caller resets a shape animation (loop()/withRepeat's own
+        // reverse and replay branches drive the value directly) — a snap back to
+        // a construction-time value would need one, and nothing needs it yet.
+        reset: () => { },
+    };
+};
+//# sourceMappingURL=animatable-value.js.map

package/dist/reanimated-compat/animatable-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"animatable-value.js","sourceRoot":"","sources":["../../src/reanimated-compat/animatable-value.ts"],"names":[],"mappings":"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","sourcesContent":["// `AnimatableValue`: upstream's real contract for what `withTiming`/\n// `withSpring` accept, read out of `react-native-reanimated` 4.5.3's\n// `src/animation/util.ts` (`decorateAnimation`) and `src/hook/useAnimatedStyle.ts`\n// (`prepareAnimation`) — not inferred, not guessed at \"probably per-key\n// seeding\" the way the task that asked for this started out.\n//\n// UPSTREAM'S RECURSIVE RULE, transcribed from `decorateAnimation`. The\n// factory-built animation (a `TimingAnimation`/`SpringAnimation`) is generic\n// over a single number; `decorateAnimation` wraps its `onStart`/`onFrame` so\n// the SAME animation can drive a colour, a matrix, an array or an object,\n// dispatched once per `onStart` call on the VALUE it is handed:\n//\n//   - a plain number: the base numeric step runs unchanged (untouched here).\n//   - an object (`typeof value === \"object\"`, not an array, not a colour):\n//     `objectOnStart` walks `for (const key in value)` — the FROM value's\n//     OWN keys, not the target's — clones the (callback-stripped) animation\n//     once per key, sets that clone's `toValue` to `toValue[key]` (which is\n//     `undefined` for a key the target does not have), and re-assigns the\n//     clone's `onStart` to the SAME decorated dispatcher, so a nested object\n//     recurses. `objectOnFrame` steps every clone and folds a FRESH object\n//     together every frame; the whole animation is `finished` only when every\n//     clone is (`finished = finished && result`, an AND across every leaf).\n//   - an array (`Array.isArray(value)`): `arrayOnStart`/`arrayOnFrame` walk\n//     the SAME way, index by index, but the clones keep the animation's own\n//     BASE (undecorated) `onStart` rather than the dispatcher — an array's\n//     elements are always plain numbers upstream, never nested objects.\n//\n// Two consequences worth stating because they are easy to get backwards:\n//\n//   1. Upstream's own object/array walk is driven by the FROM value's shape,\n//      and a target key the from-value lacks is silently never animated (its\n//      clone is never created). This is what \"an accident, not a feature\"\n//      looks like in practice — a target that grew a key nobody notices.\n//      THIS PLATFORM THROWS INSTEAD, at the point an object-targeted\n//      animation is built (`buildAnimation`/`zipAnimatableLeaves` below): the\n//      \"fail loudly, not silently\" rule this whole layer already follows for\n//      a non-finite target (`assertAnimatableValue`) extends to a reshaped\n//      one. docs/api.md's Differences row says so.\n//   2. There is exactly ONE callback per animation, at the top of the tree —\n//      `animationCopy` used for every leaf clone has `delete\n//      animationCopy.callback`, so a leaf can never report its own\n//      completion. Only the root's callback exists, and it fires once, when\n//      the root's `onFrame` returns `finished`.\n//\n// THE SEEDING RULE upstream's `prepareAnimation` adds on top (useAnimatedStyle.ts):\n// a key that is newly animating this run starts from `oldValues[key]` — the\n// PREVIOUS updater result's raw value at that key — but only when that value\n// is USABLE as a starting point:\n//\n//   let value = animation.current               // default: the target\n//   if (lastValue is a number or anything non-object) value = lastValue\n//   else if (lastValue has an own `.value`)      value = lastValue.value    // was a shared value\n//   else if (lastValue has an own `.onFrame`)     value = (previous animation's .current)\n//   // a lastValue that is a PLAIN OBJECT — no `.value`, no `.onFrame` — is\n//   // NEVER read from. `value` stays the default: the target.\n//\n// So a key that held a plain NUMBER seeds from it (already this platform's\n// rule, `updater-animations.ts`'s `startingPoint` — unchanged by this file).\n// A key that held a plain OBJECT — an ordinary `{x, y}`, not a shared value\n// or an animation node — does NOT seed from it, upstream's `typeof lastValue\n// === \"object\"` branch simply has no case that matches a plain data object.\n// It is treated exactly like a key that was ABSENT: seeded at the target,\n// never animated to it. This is the one genuinely surprising rule this file\n// exists to pin down, and it costs nothing extra to implement: this\n// platform's `startingPoint` already returns `undefined` for anything that\n// is not a finite number, which — now that objects are legal targets too —\n// already IS upstream's rule, unchanged.\nimport type {\n  CompositeAnimation,\n  EasingFunction,\n  EndCallback,\n  FrameScheduler,\n  MakeStep,\n} from \"../animated/index\"\nimport { springStep, timingStep } from \"../animated/index\"\nimport type { WithSpringConfig } from \"./animation\"\n\n/** Upstream's `AnimatableValue`, minus colour strings — those keep the\n * existing, separate `interpolateColor` path (docs/api.md), so a leaf here\n * is always a number. */\nexport type AnimatableValue = number | AnimatableArray | AnimatableObject\n\nexport type AnimatableArray = readonly number[]\n\nexport type AnimatableObject = { readonly [key: string]: AnimatableValue }\n\n/** A path from the root of an `AnimatableValue` to one of its number leaves. */\nexport type LeafPath = ReadonlyArray<string | number>\n\nconst pathToString = (path: LeafPath): string =>\n  path.length === 0 ? \"(root)\" : path.join(\".\")\n\n/**\n * True for anything `withTiming`/`withSpring` can legally target: a finite\n * number, a plain object of these (recursively — upstream's `objectOnStart`\n * re-decorates its clones' `onStart`, so nested objects genuinely work), or\n * a plain array of finite numbers (upstream's arrays are flat: a clone's\n * `onStart` is the undecorated base one, so an array element is always a\n * number, never itself an object or array).\n */\nexport const isAnimatableValue = (value: unknown): value is AnimatableValue => {\n  if (typeof value === \"number\") {\n    return Number.isFinite(value)\n  }\n  if (Array.isArray(value)) {\n    return value.every(\n      (item) => typeof item === \"number\" && Number.isFinite(item),\n    )\n  }\n  if (typeof value === \"object\" && value !== null) {\n    return Object.values(value).every(isAnimatableValue)\n  }\n  return false\n}\n\n/**\n * Validates and returns `value` unchanged — no cloning, exactly upstream's\n * `defineAnimation` returning `starting` by reference under\n * `IN_STYLE_UPDATER`. Throws the same shape of error the number-only gate\n * always has, widened to name the actual offending leaf.\n */\nexport const assertAnimatableValue = <T>(value: T, api: string): T => {\n  if (!isAnimatableValue(value)) {\n    throw new Error(\n      `react-native-reanimated: ${api}() on this platform animates finite numbers, and plain objects/arrays whose leaves are finite numbers. Got ${\n        typeof value === \"string\" ? `\"${String(value)}\"` : String(value)\n      }. Colors and layout properties cannot be driven imperatively here yet — see docs/api.md.`,\n    )\n  }\n  return value\n}\n\n/** A single leaf: where it lives in the shape, and its two endpoints. */\ntype LeafEndpoints = { path: LeafPath; from: number; to: number }\n\n/**\n * The shape a merged frame is rebuilt from: a tree with the SAME keys/indices\n * as the origin value, and a leaf index in place of every number — recorded\n * once, at the start of an animation, and reused every frame\n * (`rebuildAnimatableValue`) rather than re-walked.\n */\nexport type AnimatableShape =\n  | { kind: \"leaf\"; index: number }\n  | { kind: \"array\"; children: readonly AnimatableShape[] }\n  | { kind: \"object\"; children: Readonly<Record<string, AnimatableShape>> }\n\nconst shapeMismatch = (\n  api: string,\n  path: LeafPath,\n  from: unknown,\n  to: unknown,\n): Error =>\n  new Error(\n    `react-native-reanimated: ${api}() was given a target whose shape does not match the value it is animating from, at ${pathToString(path)} ` +\n      `(from ${JSON.stringify(from)}, to ${JSON.stringify(to)}). ` +\n      \"Upstream drives this from the FROM value's own keys and silently leaves a mismatched one at its previous value forever — \" +\n      \"this platform throws instead, naming where the shapes disagree. See docs/api.md, “Animated values”.\",\n  )\n\nconst buildShape = (\n  api: string,\n  from: AnimatableValue,\n  to: AnimatableValue,\n  path: LeafPath,\n  leaves: LeafEndpoints[],\n): AnimatableShape => {\n  if (typeof from === \"number\") {\n    if (typeof to !== \"number\") {\n      throw shapeMismatch(api, path, from, to)\n    }\n    const index = leaves.length\n    leaves.push({ path, from, to })\n    return { kind: \"leaf\", index }\n  }\n  if (Array.isArray(from)) {\n    if (!Array.isArray(to) || to.length !== from.length) {\n      throw shapeMismatch(api, path, from, to)\n    }\n    return {\n      kind: \"array\",\n      children: from.map((item, index) =>\n        buildShape(api, item, to[index]!, [...path, index], leaves),\n      ),\n    }\n  }\n  // A plain object (isAnimatableValue already refused everything else).\n  const fromObject = from as AnimatableObject\n  if (typeof to !== \"object\" || to === null || Array.isArray(to)) {\n    throw shapeMismatch(api, path, from, to)\n  }\n  const toObject = to as AnimatableObject\n  const fromKeys = Object.keys(fromObject).sort()\n  const toKeys = Object.keys(toObject).sort()\n  if (\n    fromKeys.length !== toKeys.length ||\n    fromKeys.some((key, index) => key !== toKeys[index])\n  ) {\n    throw shapeMismatch(api, path, from, to)\n  }\n  const children: Record<string, AnimatableShape> = {}\n  for (const key of fromKeys) {\n    children[key] = buildShape(\n      api,\n      fromObject[key]!,\n      toObject[key]!,\n      [...path, key],\n      leaves,\n    )\n  }\n  return { kind: \"object\", children }\n}\n\n/**\n * Walks `from` and `to` together into a flat leaf list plus the shape to\n * rebuild frames from. Throws when the two do not line up — see the header:\n * this is the one place this platform's behaviour is a deliberate, documented\n * departure from upstream's silent drop.\n */\nexport const zipAnimatableLeaves = (\n  api: string,\n  from: AnimatableValue,\n  to: AnimatableValue,\n): { shape: AnimatableShape; leaves: LeafEndpoints[] } => {\n  const leaves: LeafEndpoints[] = []\n  const shape = buildShape(api, from, to, [], leaves)\n  return { shape, leaves }\n}\n\n/** The inverse of the walk above: leaf values, in `zipAnimatableLeaves` order, folded back into `shape`'s structure. */\nexport const rebuildAnimatableValue = (\n  shape: AnimatableShape,\n  values: readonly number[],\n): AnimatableValue => {\n  switch (shape.kind) {\n    case \"leaf\":\n      return values[shape.index]!\n    case \"array\":\n      return shape.children.map(\n        (child) => rebuildAnimatableValue(child, values) as number,\n      )\n    case \"object\": {\n      const result: Record<string, AnimatableValue> = {}\n      for (const key of Object.keys(shape.children)) {\n        result[key] = rebuildAnimatableValue(shape.children[key]!, values)\n      }\n      return result\n    }\n  }\n}\n\n/**\n * A deterministic string for an `AnimatableValue`, key order independent —\n * `animationSignature` (animation.ts) uses this so two target objects built\n * with the same keys in a different order (`{x, y}` vs `{y, x}`, both\n * entirely normal across two renders) are recognised as the same animation\n * rather than restarting it.\n */\nexport const animatableValueSignature = (value: AnimatableValue): string => {\n  if (typeof value === \"number\") {\n    return String(value)\n  }\n  if (Array.isArray(value)) {\n    return `[${value.map((item) => item).join(\",\")}]`\n  }\n  const object = value as AnimatableObject\n  const keys = Object.keys(object).sort()\n  return `{${keys.map((key) => `${key}:${animatableValueSignature(object[key]!)}`).join(\",\")}}`\n}\n\n/**\n * Structural, not reference, equality — an object rebuilt fresh every frame\n * (`rebuildAnimatableValue`) is never `Object.is` the value it replaces even\n * when every leaf agrees. Used where the number-only code compared with\n * `Object.is` (`updater-animations.ts`'s snap-on-replacement rule); returns\n * `false` on a shape it cannot line up rather than throwing — this is a\n * comparison, not a build, and \"different\" is always a safe answer here.\n */\nexport const sameAnimatableValue = (\n  a: AnimatableValue,\n  b: AnimatableValue,\n): boolean => {\n  if (typeof a === \"number\" || typeof b === \"number\") {\n    // Object.is, not ===: -0/0 and NaN/NaN are distinct/equal respectively,\n    // matching what the number-only code compared landed values with before\n    // this function existed.\n    return Object.is(a, b)\n  }\n  if (Array.isArray(a) || Array.isArray(b)) {\n    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {\n      return false\n    }\n    return a.every((item, index) => Object.is(item, b[index]))\n  }\n  const objectA = a as AnimatableObject\n  const objectB = b as AnimatableObject\n  const keysA = Object.keys(objectA)\n  const keysB = Object.keys(objectB)\n  if (keysA.length !== keysB.length) {\n    return false\n  }\n  return keysA.every(\n    (key) =>\n      key in objectB && sameAnimatableValue(objectA[key]!, objectB[key]!),\n  )\n}\n\n/**\n * The largest change any single leaf underwent, for the landing cadence's\n * epsilon check (`updater-animations.ts`): the old question — did the number\n * move a pixel — becomes: did any leaf move a pixel. A `{x, y}` position where\n * only `y` is moving still has to land.\n */\nexport const maxAnimatableLeafDelta = (\n  a: AnimatableValue,\n  b: AnimatableValue,\n): number => {\n  if (typeof a === \"number\") {\n    return typeof b === \"number\" ? Math.abs(a - b) : Number.POSITIVE_INFINITY\n  }\n  if (Array.isArray(a)) {\n    if (!Array.isArray(b) || a.length !== b.length) {\n      return Number.POSITIVE_INFINITY\n    }\n    return Math.max(\n      0,\n      ...a.map((item, index) => maxAnimatableLeafDelta(item, b[index]!)),\n    )\n  }\n  const objectA = a as AnimatableObject\n  const objectB = b as AnimatableObject\n  const keys = Object.keys(objectA)\n  if (typeof b !== \"object\" || b === null || Array.isArray(b)) {\n    return Number.POSITIVE_INFINITY\n  }\n  return Math.max(\n    0,\n    ...keys.map((key) =>\n      key in objectB\n        ? maxAnimatableLeafDelta(objectA[key]!, objectB[key]!)\n        : Number.POSITIVE_INFINITY,\n    ),\n  )\n}\n\n/**\n * A `MakeStep` over a whole `AnimatableValue`: every leaf gets its own\n * `timingStep`/`springStep` (upstream's per-leaf clone, `objectOnStart`) —\n * SAME duration/easing/config for a timing leaf, an INDEPENDENTLY solved\n * spring per leaf (each one's stiffness/damping only depends on ITS OWN\n * displacement — `toPlatformSpringConfig` already computes it that way for\n * the single-number case, called once per leaf here) — stepped in lockstep\n * off ONE elapsed clock so the merged object publishes exactly once a frame,\n * never once per leaf. `done` is the AND across every leaf, matching\n * upstream's `objectOnFrame`.\n */\nexport type LeafStepFactory = (from: number, to: number) => MakeStep\n\nexport const shapeMakeSteps = (\n  api: string,\n  toValue: AnimatableValue,\n  leafStepFor: LeafStepFactory,\n): ((startValue: AnimatableValue) => (elapsedMs: number) => {\n  position: AnimatableValue | null\n  done: boolean\n}) => {\n  return (startValue) => {\n    const { shape, leaves } = zipAnimatableLeaves(api, startValue, toValue)\n    const stepFns = leaves.map(({ from, to }) => leafStepFor(from, to)(from))\n    return (elapsedMs) => {\n      let allDone = true\n      const positions: number[] = []\n      for (const stepFn of stepFns) {\n        const result = stepFn(elapsedMs)\n        // Every leaf here has delay 0 (withDelay wraps the WHOLE animation,\n        // never one leaf) so a step never actually returns a null position —\n        // this is defensive, not a case that fires.\n        positions.push(result.position ?? Number.NaN)\n        if (!result.done) {\n          allDone = false\n        }\n      }\n      return {\n        position: rebuildAnimatableValue(shape, positions),\n        done: allDone,\n      }\n    }\n  }\n}\n\n/** `shapeMakeSteps` specialised for `withTiming`: every leaf shares the same duration/easing. */\nexport const timingShapeMakeSteps = (\n  toValue: AnimatableValue,\n  duration: number,\n  easing: EasingFunction,\n) =>\n  shapeMakeSteps(\"withTiming\", toValue, (from, to) =>\n    timingStep(to, duration, easing),\n  )\n\n/**\n * `shapeMakeSteps` specialised for `withSpring`: each leaf's physical\n * parameters are solved independently, via `toPlatformSpringConfig` (passed\n * in — animation.ts owns it — rather than duplicated here).\n */\nexport const springShapeMakeSteps = (\n  toValue: AnimatableValue,\n  toPlatformSpringConfig: (\n    config: WithSpringConfig,\n    toValue: number,\n    from: number,\n  ) => Parameters<typeof springStep>[0],\n  config: WithSpringConfig,\n) =>\n  shapeMakeSteps(\"withSpring\", toValue, (from, to) =>\n    springStep(toPlatformSpringConfig(config, to, from)),\n  )\n\ntype ShapeListener = (event: { value: AnimatableValue }) => void\n\n/**\n * The object/array counterpart of `AnimatedValue` — deliberately minimal\n * rather than a generalisation of that class: no offset, no `interpolate`,\n * no self-tracked \"current animation\" (every caller here already stops the\n * previous `CompositeAnimation` itself before starting a new one — mutable.ts\n * and updater-animations.ts both do, same as they always have). What it DOES\n * match is the structural shape `buildAnimation`, mutable.ts and\n * updater-animations.ts actually read off a driver: `__getValue`,\n * `addListener`/`removeListener`, and `setValue` for `buildRepeat`'s replay\n * branch (the one place a driver is force-set from outside an animation).\n */\nexport class AnimatedShapeValue {\n  private _value: AnimatableValue\n  private readonly _listeners = new Map<string, ShapeListener>()\n  private _nextListenerId = 1\n\n  constructor(value: AnimatableValue) {\n    this._value = value\n  }\n\n  __getValue(): AnimatableValue {\n    return this._value\n  }\n\n  /** @internal Called once per animation frame, after every leaf has stepped. */\n  __updateValue(value: AnimatableValue): void {\n    this._value = value\n    for (const listener of [...this._listeners.values()]) {\n      listener({ value })\n    }\n  }\n\n  /** RN's own escape hatch: force the value, notifying listeners — what `withRepeat`'s non-reverse replay uses to snap back between iterations. */\n  setValue(value: AnimatableValue): void {\n    this.__updateValue(value)\n  }\n\n  addListener(listener: ShapeListener): string {\n    const id = String(this._nextListenerId++)\n    this._listeners.set(id, listener)\n    return id\n  }\n\n  removeListener(id: string): void {\n    this._listeners.delete(id)\n  }\n}\n\n/**\n * `createValueAnimation`'s counterpart for an `AnimatedShapeValue` — same\n * start/stop/preemption contract (a second `start()` on the same\n * `CompositeAnimation` preempts the first, reporting `{finished: false}`),\n * deliberately re-implemented rather than generalising `createValueAnimation`\n * itself: that function is `src/animated`'s, i.e. RN's own Animated engine,\n * scalar by the RN spec it mirrors (`Animated.ValueXY` is RN's own answer to\n * a pair, and is a different, narrower thing). This is reanimated-compat's\n * own extension point, the same way `decayStep` + the PUBLIC\n * `createValueAnimation` was for `withDecay` — except here the driver itself\n * is not the platform's, so the harness around it is not either.\n */\nexport const createShapeValueAnimation = (\n  scheduler: FrameScheduler,\n  value: AnimatedShapeValue,\n  makeSteps: ReturnType<typeof shapeMakeSteps>,\n): CompositeAnimation => {\n  let activeStop: (() => void) | null = null\n\n  const start = (callback?: EndCallback): void => {\n    // A second start() on the SAME CompositeAnimation preempts the first,\n    // reporting { finished: false } to its own callback — RN parity, and\n    // resolved fully before the new run's state exists below, so there is no\n    // reentrancy between the two.\n    activeStop?.()\n\n    const step = makeSteps(value.__getValue())\n    let startTime: number | null = scheduler.now?.() ?? null\n    let ended = false\n    let cancelFrame: (() => void) | null = null\n\n    const end = (finished: boolean): void => {\n      if (ended) {\n        return\n      }\n      ended = true\n      cancelFrame?.()\n      cancelFrame = null\n      if (activeStop === stop) {\n        activeStop = null\n      }\n      callback?.({ finished })\n    }\n\n    const stop = (): void => end(false)\n\n    const onFrame = (timeMs: number): void => {\n      cancelFrame = null\n      if (ended) {\n        return\n      }\n      if (startTime === null) {\n        startTime = timeMs\n      }\n      const { position, done } = step(timeMs - startTime)\n      if (position !== null) {\n        value.__updateValue(position)\n      }\n      if (done) {\n        end(true)\n        return\n      }\n      cancelFrame = scheduler.schedule(onFrame)\n    }\n\n    activeStop = stop\n    cancelFrame = scheduler.schedule(onFrame)\n  }\n\n  return {\n    start,\n    stop: () => activeStop?.(),\n    // No known caller resets a shape animation (loop()/withRepeat's own\n    // reverse and replay branches drive the value directly) — a snap back to\n    // a construction-time value would need one, and nothing needs it yet.\n    reset: () => {},\n  }\n}\n"]}

package/dist/reanimated-compat/animation.d.ts

@@ -1,8 +1,26 @@
-import { type AnimatedApi, type AnimatedValue, type CompositeAnimation, type FrameScheduler } from "../animated/index";
+import { AnimatedValue, type AnimatedApi, type CompositeAnimation, type FrameScheduler } from "../animated/index";
+import { AnimatedShapeValue, type AnimatableValue } from "./animatable-value";
 import { resolveDecayConfig, type WithDecayConfig } from "./decay";
 import { type EasingFunction } from "./easing";
+export type { AnimatableArray, AnimatableObject, AnimatableValue, } from "./animatable-value";
 /** Called when an animation settles or is cancelled, as upstream. */
-export type AnimationCallback = (finished?: boolean, current?: number) => void;
+export type AnimationCallback = (finished?: boolean, current?: AnimatableValue) => void;
+/**
+ * What every animation in this layer runs on: a single-number `AnimatedValue`
+ * for a number target, or an `AnimatedShapeValue` (animatable-value.ts) for
+ * an object/array one — the SAME driver a spec was built against throughout
+ * its whole tree (a `withSequence`'s steps, a `withRepeat`'s iterations),
+ * because the driver IS the value being animated, not a detail of one step.
+ */
+export type AnimationDriver = AnimatedValue | AnimatedShapeValue;
+/**
+ * Builds the right driver for `seed`'s type — the ONE place mutable.ts
+ * (a shared-value write) and updater-animations.ts (a key newly animating)
+ * both make this decision, so a number and a shape are dispatched the same
+ * way in both. Throws the same "not animatable" shape of error either module
+ * used to throw on its own number-only gate, widened to name what it got.
+ */
+export declare const makeAnimationDriver: (api: AnimatedApi, seed: unknown, context: string) => AnimationDriver;
 export type WithTimingConfig = {
     duration?: number;
     easing?: EasingFunction | {
@@ -31,13 +49,13 @@ export type WithSpringConfig = {
 };
 type TimingSpec = {
     kind: "timing";
-    toValue: number;
+    toValue: AnimatableValue;
     config: WithTimingConfig;
     callback?: AnimationCallback;
 };
 type SpringSpec = {
     kind: "spring";
-    toValue: number;
+    toValue: AnimatableValue;
     config: WithSpringConfig;
     callback?: AnimationCallback;
 };
@@ -77,20 +95,23 @@ export declare const isAnimationSpec: (value: unknown) => value is AnimationSpec
 export declare const initialUpdaterRun: <T>(updater: () => T) => T;
 /**
  * Lets you animate a value over a duration with an easing curve. Assign the
- * result to a shared value to start it.
+ * result to a shared value to start it. `toValue` is upstream's
+ * `AnimatableValue`: a finite number, or a plain object/array whose leaves
+ * are — a colour string is not (that keeps the separate `interpolateColor`
+ * path, docs/api.md).
  */
-export declare const withTiming: (toValue: number, config?: WithTimingConfig, callback?: AnimationCallback) => number;
-/** Lets you animate a value with spring physics. */
-export declare const withSpring: (toValue: number, config?: WithSpringConfig, callback?: AnimationCallback) => number;
+export declare const withTiming: <T extends AnimatableValue>(toValue: T, config?: WithTimingConfig, callback?: AnimationCallback) => T;
+/** Lets you animate a value with spring physics. See withTiming for `toValue`'s shape. */
+export declare const withSpring: <T extends AnimatableValue>(toValue: T, config?: WithSpringConfig, callback?: AnimationCallback) => T;
 /** Delays another animation by `delayMs`. */
-export declare const withDelay: (delayMs: number, animation: number) => number;
+export declare const withDelay: <T extends AnimatableValue>(delayMs: number, animation: T) => T;
 /** Runs animations one after another on the same shared value. */
-export declare const withSequence: (...animations: number[]) => number;
+export declare const withSequence: <T extends AnimatableValue>(...animations: T[]) => T;
 /**
  * Repeats an animation. `numberOfReps <= 0` repeats forever; `reverse` plays
  * every other repetition backwards.
  */
-export declare const withRepeat: (animation: number, numberOfReps?: number, reverse?: boolean, callback?: AnimationCallback) => number;
+export declare const withRepeat: <T extends AnimatableValue>(animation: T, numberOfReps?: number, reverse?: boolean, callback?: AnimationCallback) => T;
 /**
  * Coasts to a stop from an initial velocity — the release half of a fling.
  * Unlike every other animation here it has no target: where it lands is the
@@ -145,7 +166,7 @@ export declare const toPlatformSpringConfig: (config: WithSpringConfig, toValue:
  * The last value an animation aims at, used by `withRepeat`'s reverse and by
  * `updater-animations.ts` to seed a key that is animating for the first time.
  */
-export declare const targetOf: (spec: AnimationSpec) => number | null;
+export declare const targetOf: (spec: AnimationSpec) => AnimatableValue | null;
 /**
  * What makes two descriptors the SAME animation, for a caller that gets a
  * freshly built one on every evaluation and must decide whether to restart.
@@ -174,4 +195,4 @@ export type AnimationEngine = {
  * of the platform's own animations, so the whole tree runs off the single
  * injected frame scheduler.
  */
-export declare const buildAnimation: (engine: AnimationEngine, driver: AnimatedValue, spec: AnimationSpec) => CompositeAnimation;
+export declare const buildAnimation: (engine: AnimationEngine, driver: AnimationDriver, spec: AnimationSpec) => CompositeAnimation;