@symbiote-native/engine 0.1.0

package/build/animated/event.js

@@ -0,0 +1,252 @@
+// Animated.event: bridge a real native event (a scroll's contentOffset, a pan's
+// translation) into the value graph. An argMapping like
+// `[{nativeEvent: {contentOffset: {y: scrollY}}}]` names, at its leaf positions,
+// the AnimatedValues to drive; the path to each leaf is the key path inside the
+// event object. Ported from RN's AnimatedEvent.js (JS + native paths), with the
+// native-driver branches kept and AnimatedValueXY deferred.
+//
+// Two ways the mapping is consumed:
+//   - JS path: __getHandler() returns a callback the adapter wires as the view's
+//     event prop. Each fired event is walked against the mapping; every leaf
+//     AnimatedValue is set from the matching event field, then flushed so its
+//     bound props re-paint. config.listener is invoked passthrough.
+//   - Native path: __attach(viewTag, eventName) mirrors each leaf value into native
+//     and registers the key path with the stock native module, so the event drives
+//     the view with zero JS per event.
+import { dlog } from '../debug';
+import { getNativeTag, whenCommitted } from '../commit';
+import { isSymbioteNode } from '../node';
+import { AnimatedNode, flushValue } from './graph';
+import { isNativeAnimatedAvailable, nativeAnimated } from './native/native-animated';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+// A value node settable from an event field. AnimatedValue carries setValue; we
+// duck-type it (rather than importing AnimatedValue) to keep this leaf-agnostic
+// and avoid a value<->event import cycle.
+function settableValue(node) {
+    const candidate = Reflect.get(node, 'setValue');
+    return typeof candidate === 'function' ? value => candidate.call(node, value) : undefined;
+}
+// Walk the mapping to every leaf AnimatedNode, recording its key path. Shared by
+// the JS handler (to set values) and the native attach (to register paths).
+function collectMappedValues(mapping, path, out) {
+    if (mapping instanceof AnimatedNode) {
+        out.push({ path, node: mapping });
+        return;
+    }
+    for (const key of Object.keys(mapping)) {
+        const child = Reflect.get(mapping, key);
+        if (child instanceof AnimatedNode) {
+            out.push({ path: [...path, key], node: child });
+        }
+        else if (isRecord(child)) {
+            collectMappedValues(child, [...path, key], out);
+        }
+    }
+}
+// Pull the numeric field at `path` out of one event argument. Returns undefined
+// when the path is absent or the leaf is not a number, so a malformed event is a
+// no-op rather than a throw inside an event dispatch.
+function extractAtPath(event, path) {
+    let current = event;
+    for (const key of path) {
+        if (!isRecord(current))
+            return undefined;
+        current = Reflect.get(current, key);
+    }
+    return typeof current === 'number' ? current : undefined;
+}
+export class AnimatedEvent {
+    // Listeners fired (in registration order) after the values are driven. Seeded
+    // with config.listener; forkEvent appends more via __addListener (RN
+    // AnimatedEvent.js seeds `__addListener(config.listener)` in its constructor).
+    listeners = [];
+    // The leaves under argMapping[0].nativeEvent, the only place native-driven
+    // events accept animated values (RN invariant). Resolved once at construction.
+    mappedValues;
+    // RN parity: the event remembers whether useNativeDriver was requested. Honored only
+    // when a native module is present (__isNative); otherwise the JS path drives values.
+    nativeDriverRequested;
+    // Flipped once a host view native-attaches this event. The JS handler then stops
+    // setting values (native owns them on the UI thread) and only forwards listeners.
+    // no double-drive, no redundant per-tick commit.
+    attachedNatively = false;
+    constructor(argMapping, config) {
+        if (config?.listener !== undefined)
+            this.listeners.push(config.listener);
+        this.nativeDriverRequested = config?.useNativeDriver === true;
+        const mapped = [];
+        const first = argMapping[0];
+        if (isRecord(first)) {
+            const nativeEvent = Reflect.get(first, 'nativeEvent');
+            if (isRecord(nativeEvent)) {
+                collectMappedValues(nativeEvent, [], mapped);
+            }
+        }
+        this.mappedValues = mapped;
+    }
+    // Append / drop a listener (RN AnimatedEvent.js __addListener / __removeListener).
+    // forkEvent/unforkEvent use these to combine extra handlers onto one AnimatedEvent.
+    __addListener(callback) {
+        this.listeners.push(callback);
+    }
+    __removeListener(callback) {
+        const index = this.listeners.indexOf(callback);
+        if (index !== -1)
+            this.listeners.splice(index, 1);
+    }
+    // Native path: mirror each leaf value into native and register its key path with
+    // the stock module, so the event drives the view with zero JS per event.
+    // Whether this event should drive its values natively: useNativeDriver requested AND
+    // a native module present. The adapter consults it before native-attaching to a view.
+    __isNative() {
+        return this.nativeDriverRequested && isNativeAnimatedAvailable();
+    }
+    __attach(viewTag, eventName) {
+        for (const mapped of this.mappedValues) {
+            mapped.node.__makeNative();
+            dlog(`event: attach ${eventName} path=${mapped.path.join('.')} -> view=${viewTag}`);
+            nativeAnimated.addAnimatedEventToView(viewTag, eventName, {
+                nativeEventPath: mapped.path,
+                animatedValueTag: mapped.node.__getNativeTag(),
+            });
+        }
+        this.attachedNatively = true;
+    }
+    __detach(viewTag, eventName) {
+        for (const mapped of this.mappedValues) {
+            dlog(`event: detach ${eventName} -> view=${viewTag}`);
+            nativeAnimated.removeAnimatedEventFromView(viewTag, eventName, mapped.node.__getNativeTag());
+        }
+        this.attachedNatively = false;
+    }
+    // JS path: walk each leaf, set its value from the matching event field, flush so
+    // its bound props re-paint, then forward the raw args to the user's listener.
+    __getHandler() {
+        const handler = Object.assign((...args) => {
+            // Once natively attached, the UI thread owns the values, so skip the JS set/flush
+            // (it would double-drive and commit per tick); only forward listeners below.
+            if (!this.attachedNatively) {
+                // Paths are stored relative to `nativeEvent` (the native module excludes
+                // that prefix); the JS event arg still carries it, so re-add it here.
+                const nativeEvent = isRecord(args[0]) ? Reflect.get(args[0], 'nativeEvent') : undefined;
+                for (const mapped of this.mappedValues) {
+                    const extracted = extractAtPath(nativeEvent, mapped.path);
+                    if (extracted === undefined)
+                        continue;
+                    const setValue = settableValue(mapped.node);
+                    if (setValue === undefined)
+                        continue;
+                    setValue(extracted);
+                    flushValue(mapped.node);
+                }
+            }
+            for (const listener of this.listeners)
+                listener(...args);
+        }, { __getEvent: () => this });
+        return handler;
+    }
+}
+// The Animated.event factory: returns the handler an adapter wires as the event
+// prop. The handler also exposes the AnimatedEvent (__getEvent) for adapters that
+// need the native attach path.
+export function event(argMapping, config) {
+    return new AnimatedEvent(argMapping, config).__getHandler();
+}
+// Imperatively bind a real native event on a host node to the mapping's animated values, so the
+// event drives them on the UI thread with zero JS per event. RN's
+// AnimatedImplementation.attachNativeEvent (ScrollView.js:1095 uses it for sticky headers). The
+// ScrollView is NOT an animated component, so the event can't ride a prop; it is attached to the
+// node's native tag directly. Returns a detach handle. Callers MUST gate on
+// isNativeAnimatedAvailable(): with no native module __attach no-ops and the values never move,
+// so a JS Animated.event path must remain the fallback.
+export function attachNativeEvent(node, eventName, argMapping) {
+    const animatedEvent = new AnimatedEvent(argMapping);
+    let attachedTag;
+    // Bind once the node is committed: now if it already has a Fabric tag, else after the commit that
+    // assigns it. Vue/Svelte batch commits on a microtask, so the adapter can wire this — e.g. the
+    // sticky-header scroll — before the tag exists; whenCommitted defers instead of silently binding
+    // nothing. React commits synchronously and binds on the first try.
+    const cancel = whenCommitted(node, () => {
+        const viewTag = getNativeTag(node);
+        if (viewTag === undefined)
+            return;
+        dlog(`attachNativeEvent: ${eventName} -> view=${viewTag}`);
+        animatedEvent.__attach(viewTag, eventName);
+        attachedTag = viewTag;
+    });
+    return {
+        detach() {
+            cancel();
+            if (attachedTag !== undefined)
+                animatedEvent.__detach(attachedTag, eventName);
+        },
+    };
+}
+// Native-attach the AnimatedEvent already behind a handler from `event(...)`, binding it
+// to a committed host node. Unlike attachNativeEvent (which builds a fresh event from a
+// raw mapping for ScrollView's internal sticky value), this REUSES the caller's handler,
+// so createAnimatedComponent can offload `onScroll={Animated.event(…, {useNativeDriver})}`
+// to the UI thread, and the __makeNative cascade carries the bound interpolations/props
+// native with it. Returns undefined (caller keeps the JS path) when the prop is not a native
+// event handler; if it IS but the node has no tag yet, the bind defers to the commit (same race).
+export function attachNativeEventHandler(node, eventName, handler) {
+    if (!isSymbioteNode(node) || typeof handler !== 'function')
+        return undefined;
+    const accessor = Reflect.get(handler, '__getEvent');
+    if (typeof accessor !== 'function')
+        return undefined;
+    const animatedEvent = accessor.call(handler);
+    if (!(animatedEvent instanceof AnimatedEvent) || !animatedEvent.__isNative())
+        return undefined;
+    const event = animatedEvent;
+    let attachedTag;
+    const cancel = whenCommitted(node, () => {
+        const viewTag = getNativeTag(node);
+        if (viewTag === undefined)
+            return;
+        event.__attach(viewTag, eventName);
+        attachedTag = viewTag;
+    });
+    return {
+        detach: () => {
+            cancel();
+            if (attachedTag !== undefined)
+                event.__detach(attachedTag, eventName);
+        },
+    };
+}
+// Combine an existing event handler with an extra listener (RN
+// AnimatedImplementation.js forkEventImpl ~519). Three cases, by the existing event:
+//   - absent          -> the listener becomes the handler
+//   - an AnimatedEvent -> the listener is appended to it; the same event is returned
+//   - a plain function -> a new function calling both
+// The AnimatedEvent is recognised through its handler's __getEvent (the only public
+// seam), so a handler built by `event(...)` forks into the underlying AnimatedEvent.
+export function forkEvent(existing, listener) {
+    if (existing === undefined)
+        return listener;
+    const animatedEvent = getAnimatedEvent(existing);
+    if (animatedEvent !== undefined) {
+        animatedEvent.__addListener(listener);
+        return existing;
+    }
+    return (...args) => {
+        existing(...args);
+        listener(...args);
+    };
+}
+// Undo a forkEvent that targeted an AnimatedEvent (RN unforkEventImpl ~531). A
+// plain-function fork has no removable seam, so this is a no-op for that case,
+// exactly as RN, which only removes from an AnimatedEvent.
+export function unforkEvent(existing, listener) {
+    const animatedEvent = existing === undefined ? undefined : getAnimatedEvent(existing);
+    animatedEvent?.__removeListener(listener);
+}
+// Reach the AnimatedEvent behind a handler. event(...) returns an AnimatedEventHandler
+// carrying __getEvent; a bare listener does not, so this narrows the fork cases.
+function getAnimatedEvent(candidate) {
+    const accessor = Reflect.get(candidate, '__getEvent');
+    return typeof accessor === 'function' ? accessor.call(candidate) : undefined;
+}

package/build/animated/graph.d.ts

@@ -0,0 +1,38 @@
+import { type INativeNodeConfig, type IPlatformConfig } from './native/native-animated';
+export type IValueListener = (state: {
+    value: number | string;
+}) => void;
+export declare class AnimatedNode {
+    private readonly listeners;
+    private suspendCallbacks;
+    protected isNative: boolean;
+    private nativeTag;
+    private platformConfig;
+    __attach(): void;
+    __detach(): void;
+    __isNative(): boolean;
+    __makeNative(platformConfig?: IPlatformConfig): void;
+    protected __connectNativeChildren(): void;
+    __getNativeTag(): number;
+    __getNativeConfig(): INativeNodeConfig;
+    __getValue(): unknown;
+    __getAnimatedValue(): unknown;
+    __addChild(_child: AnimatedNode): void;
+    __removeChild(_child: AnimatedNode): void;
+    __getChildren(): readonly AnimatedNode[];
+    addListener(callback: IValueListener): string;
+    removeListener(id: string): void;
+    removeAllListeners(): void;
+    hasListeners(): boolean;
+    __callListeners(value: number | string): void;
+    protected withSuspendedCallbacks(fn: () => void): void;
+}
+export declare class AnimatedWithChildren extends AnimatedNode {
+    protected children: AnimatedNode[];
+    protected __connectNativeChildren(): void;
+    __addChild(child: AnimatedNode): void;
+    __removeChild(child: AnimatedNode): void;
+    __getChildren(): readonly AnimatedNode[];
+    __callListeners(value: number | string): void;
+}
+export declare function flushValue(rootNode: AnimatedNode): void;

package/build/animated/graph.js

@@ -0,0 +1,227 @@
+// The Animated dependency graph: a directed acyclic graph of value nodes that
+// sits ABOVE symbiote's shadow tree. Ported from React Native's AnimatedNode.js
+// + AnimatedWithChildren.js, with every native-driver path
+// (NativeAnimatedHelper / __isNative / __makeNative / __getNativeConfig) removed:
+// this is the JS-driven engine (ADR 0016). The native driver re-introduces those
+// hooks separately (ADR 0017).
+//
+// Two phases drive an update:
+//   A) top-down: when a Value changes, walk children to the leaf nodes (the
+//      ones with an `update()` method) and flag them.
+//   B) bottom-up: each flagged leaf re-pulls its whole subtree via __getValue()
+//      to rebuild composite props (e.g. transform from many parents).
+import { generateNativeNodeTag, nativeAnimated, } from './native/native-animated';
+let nextListenerId = 1;
+// Depth of the currently-active withSuspendedCallbacks blocks. While > 0, a
+// composite setter (AnimatedColor.setValue) is driving several channels in a row;
+// each channel's own flushValue is suppressed so the bound leaf commits ONCE (at
+// the single flushValue the composite issues after the block) instead of once per
+// channel. RN tolerates the per-channel flushes and relies on a downstream commit-
+// coalescing layer; symbiote has none here, so it coalesces at the source.
+let flushSuspendDepth = 0;
+export class AnimatedNode {
+    listeners = new Map();
+    // While > 0, this node's own __callListeners is a no-op. A composite setter
+    // (AnimatedColor.setValue) that drives several channels in a row would otherwise
+    // fire this node's listeners once per channel, each with an intermediate value
+    // that never logically existed. The setter wraps the channel writes in
+    // _withSuspendedCallbacks, then fires once with the final value. Ported from RN's
+    // AnimatedColor._suspendCallbacks.
+    suspendCallbacks = 0;
+    // Native-driver state (ADR 0017). Off until a useNativeDriver animation marks
+    // the graph native; `nativeTag` is the node's identity in the native module,
+    // allocated lazily on first reference (which also creates the native node).
+    isNative = false;
+    nativeTag;
+    // RN's AnimatedNode._platformConfig (AnimatedNode.js:34): the platform tuning bag
+    // a useNativeDriver animation hands down via __makeNative, merged into this node's
+    // native config at creation (__getNativeTag). Optional: undefined when no caller
+    // supplied one, matching today's behavior.
+    platformConfig;
+    __attach() { }
+    __detach() {
+        this.removeAllListeners();
+        if (this.isNative && this.nativeTag !== undefined) {
+            nativeAnimated.dropAnimatedNode(this.nativeTag);
+            this.nativeTag = undefined;
+        }
+    }
+    __isNative() {
+        return this.isNative;
+    }
+    // Mirror this node (and its subtree) into the native module. Two strict phases,
+    // because the native module asserts a node exists before connectAnimatedNodes
+    // references it (a connect-before-create crashes RCTNativeAnimatedNodesManager):
+    //   1. CREATE every node: __getNativeTag enqueues createAnimatedNode. A config
+    //      only READS child tags (also creating them), never connects, so creation is
+    //      side-effect-free w.r.t. edges and createAnimatedNode may precede its refs.
+    //   2. CONNECT every edge: only once both endpoints are guaranteed created.
+    __makeNative(platformConfig) {
+        if (this.isNative)
+            return;
+        this.isNative = true;
+        // RN stores the platform bag before minting the tag (AnimatedNode.js:80) so it
+        // is already present when __getNativeTag folds it into the create config.
+        if (platformConfig !== undefined)
+            this.platformConfig = platformConfig;
+        this.__getNativeTag(); // phase 1: create self (config may create referenced children)
+        this.__connectNativeChildren(); // phase 2: wire edges
+    }
+    // Phase 2 hook. A leaf has no graph children; AnimatedWithChildren wires its own.
+    __connectNativeChildren() { }
+    // The node's native tag, minting it (and creating the native node) on first use.
+    // Stable for the node's life: the native side keys animations off it. CREATION
+    // ONLY: the config reads child tags but issues no connectAnimatedNodes, so a node
+    // is safe to create before the nodes its config references exist.
+    __getNativeTag() {
+        if (this.nativeTag === undefined) {
+            this.nativeTag = generateNativeNodeTag();
+            // RN merges _platformConfig into the config after __getNativeConfig returns
+            // (AnimatedNode.js:146-148) rather than in each node's config method.
+            const config = this.platformConfig === undefined
+                ? this.__getNativeConfig()
+                : { ...this.__getNativeConfig(), platformConfig: this.platformConfig };
+            nativeAnimated.createAnimatedNode(this.nativeTag, config);
+        }
+        return this.nativeTag;
+    }
+    // Each concrete node type (value / interpolation / style / transform / props)
+    // overrides this with its native shape; a plain node cannot be offloaded.
+    __getNativeConfig() {
+        throw new Error('This animated node type cannot be used as a native animated node');
+    }
+    // The current rasterized value. Heterogeneous across the graph: scalar nodes
+    // return a number, a props leaf returns a flat payload, so the base is
+    // `unknown` and numeric subclasses narrow it.
+    __getValue() {
+        return undefined;
+    }
+    __getAnimatedValue() {
+        return this.__getValue();
+    }
+    __addChild(_child) { }
+    __removeChild(_child) { }
+    __getChildren() {
+        return [];
+    }
+    // Asynchronous observation of value updates. There is no synchronous read of a
+    // value once it is driven by an animation, so consumers subscribe instead.
+    addListener(callback) {
+        const id = String(nextListenerId++);
+        this.listeners.set(id, callback);
+        return id;
+    }
+    removeListener(id) {
+        this.listeners.delete(id);
+    }
+    removeAllListeners() {
+        this.listeners.clear();
+    }
+    hasListeners() {
+        return this.listeners.size > 0;
+    }
+    __callListeners(value) {
+        if (this.suspendCallbacks > 0)
+            return;
+        const event = { value };
+        this.listeners.forEach(listener => {
+            listener(event);
+        });
+    }
+    // Run `fn` with this node's listener fires AND every flushValue suspended,
+    // restoring the prior depth even if `fn` throws. The composite setter pairs this
+    // with one explicit flush + one listener fire after the block.
+    withSuspendedCallbacks(fn) {
+        this.suspendCallbacks++;
+        flushSuspendDepth++;
+        try {
+            fn();
+        }
+        finally {
+            this.suspendCallbacks--;
+            flushSuspendDepth--;
+        }
+    }
+}
+export class AnimatedWithChildren extends AnimatedNode {
+    children = [];
+    // Phase 2: every child's subtree is fully made native (created + its own edges
+    // wired) before we connect this node to it, so both endpoints exist at connect.
+    __connectNativeChildren() {
+        for (const child of this.children) {
+            child.__makeNative();
+        }
+        for (const child of this.children) {
+            nativeAnimated.connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+        }
+    }
+    __addChild(child) {
+        if (this.children.length === 0) {
+            this.__attach();
+        }
+        this.children.push(child);
+        // A child joining an already-native parent must itself be made native and wired.
+        if (this.isNative) {
+            child.__makeNative();
+            nativeAnimated.connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+        }
+    }
+    __removeChild(child) {
+        const index = this.children.indexOf(child);
+        if (index === -1) {
+            return;
+        }
+        if (this.isNative && child.__isNative()) {
+            nativeAnimated.disconnectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+        }
+        this.children.splice(index, 1);
+        if (this.children.length === 0) {
+            this.__detach();
+        }
+    }
+    __getChildren() {
+        return this.children;
+    }
+    __callListeners(value) {
+        super.__callListeners(value);
+        // A native-driven node's children are updated natively; don't also walk them
+        // here (their values aren't tracked in JS while native owns the animation).
+        if (this.isNative)
+            return;
+        for (const child of this.children) {
+            child.__callListeners(numericValueOf(child));
+        }
+    }
+}
+function numericValueOf(node) {
+    const value = node.__getValue();
+    return typeof value === 'number' ? value : 0;
+}
+// A leaf carries an `update()` that re-pulls its subtree and commits: the seam
+// where the value graph meets symbiote's engine. It is NOT declared on the base:
+// a class field would be initialised to undefined and shadow a subclass method
+// under useDefineForClassFields. So leaves are detected structurally instead.
+function leafUpdate(node) {
+    const candidate = Reflect.get(node, 'update');
+    return typeof candidate === 'function' ? () => candidate.call(node) : undefined;
+}
+// Top-down walk to the leaves, then re-pull each leaf (deduped by node identity,
+// so a diamond in the graph still updates a leaf once). Suppressed inside a
+// withSuspendedCallbacks block: the composite setter issues the one flush that
+// actually rebuilds the leaves after all its channel writes land.
+export function flushValue(rootNode) {
+    if (flushSuspendDepth > 0)
+        return;
+    const leaves = new Map();
+    function collect(node) {
+        const update = leafUpdate(node);
+        if (update !== undefined) {
+            leaves.set(node, update);
+        }
+        else {
+            node.__getChildren().forEach(collect);
+        }
+    }
+    collect(rootNode);
+    leaves.forEach(update => update());
+}

package/build/animated/index.d.ts

@@ -0,0 +1,20 @@
+export { AnimatedNode, AnimatedWithChildren, flushValue, type IValueListener } from './graph';
+export { AnimatedValue } from './value';
+export { AnimatedValueXY, type IValueXY } from './value-xy';
+export { AnimatedInterpolation } from './interpolation-node';
+export { AnimatedAddition, AnimatedSubtraction, AnimatedMultiplication, AnimatedDivision, AnimatedModulo, AnimatedDiffClamp, add, subtract, multiply, divide, modulo, diffClamp, } from './operators';
+export { AnimatedEvent, event, forkEvent, unforkEvent, attachNativeEvent, attachNativeEventHandler, type IEventConfig, type IEventListener, type IAnimatedEventHandler, type INativeEventAttachment, } from './event';
+export { AnimatedColor, type IRgbaValue, type IColorInput } from './color';
+export { Easing, type IEasingFunction } from './easing';
+export { createNumericInterpolation, createInterpolation, checkValidRanges, type IInterpolationConfig, type IExtrapolateType, } from './interpolation';
+export type { IAnimation, IEndCallback, IEndResult } from './animation';
+export { TimingAnimation } from './animations/timing';
+export { SpringAnimation } from './animations/spring';
+export { DecayAnimation } from './animations/decay';
+export { AnimatedTracking } from './animations/tracking';
+export { timing, spring, decay, parallel, sequence, stagger, loop, delay, type ICompositeAnimation, type ITimingConfig, type ISpringConfig, type IDecayConfig, type IParallelConfig, type ILoopAnimationConfig, } from './animations/composition';
+export { nativeAnimated, isNativeAnimatedAvailable, type INativeNodeConfig, type INativeAnimationConfig, type INativeEventMapping, type IPlatformConfig, } from './native/native-animated';
+export { AnimatedProps } from './props';
+export { AnimatedStyle, AnimatedTransform } from './style';
+export { AnimatedMock } from './mock';
+export { reduceProps, isAnimatedNode, readPassthroughStyle, resolveHostNode, } from './animated-component-shared';

package/build/animated/index.js

@@ -0,0 +1,28 @@
+// @symbiote-native/engine/animated: the framework-agnostic, JS-driven Animated engine
+// (ADR 0016). The value graph, easing, interpolation and (Phase 2) drivers are
+// pure JS with no React and no native dependency; every adapter re-exports them.
+export { AnimatedNode, AnimatedWithChildren, flushValue } from './graph';
+export { AnimatedValue } from './value';
+export { AnimatedValueXY } from './value-xy';
+export { AnimatedInterpolation } from './interpolation-node';
+export { AnimatedAddition, AnimatedSubtraction, AnimatedMultiplication, AnimatedDivision, AnimatedModulo, AnimatedDiffClamp, add, subtract, multiply, divide, modulo, diffClamp, } from './operators';
+export { AnimatedEvent, event, forkEvent, unforkEvent, attachNativeEvent, attachNativeEventHandler, } from './event';
+export { AnimatedColor } from './color';
+export { Easing } from './easing';
+export { createNumericInterpolation, createInterpolation, checkValidRanges, } from './interpolation';
+export { TimingAnimation } from './animations/timing';
+export { SpringAnimation } from './animations/spring';
+export { DecayAnimation } from './animations/decay';
+export { AnimatedTracking } from './animations/tracking';
+export { timing, spring, decay, parallel, sequence, stagger, loop, delay, } from './animations/composition';
+// The native-driver bridge (ADR 0017). Adapters need it to connect a props leaf to
+// a host view tag and to restore default values on disconnect.
+export { nativeAnimated, isNativeAnimatedAvailable, } from './native/native-animated';
+// The pure graph leaves and the mock, framework-agnostic (extend AnimatedWithChildren,
+// no React/Vue). They live here with the rest of the graph; every adapter's
+// createAnimatedComponent + Animated namespace re-exports them (ADR 0016/0017).
+export { AnimatedProps } from './props';
+export { AnimatedStyle, AnimatedTransform } from './style';
+export { AnimatedMock } from './mock';
+// Framework-agnostic createAnimatedComponent helpers. Both adapters import them.
+export { reduceProps, isAnimatedNode, readPassthroughStyle, resolveHostNode, } from './animated-component-shared';

package/build/animated/interpolation-node.d.ts

@@ -0,0 +1,16 @@
+import { AnimatedNode, AnimatedWithChildren } from './graph';
+import { type IInterpolationConfig } from './interpolation';
+import type { INativeNodeConfig, IPlatformConfig } from './native/native-animated';
+export declare class AnimatedInterpolation extends AnimatedWithChildren {
+    private readonly parent;
+    private readonly config;
+    private interpolation;
+    constructor(parent: AnimatedNode, config: IInterpolationConfig);
+    private getInterpolation;
+    __getValue(): number | string;
+    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
+    __attach(): void;
+    __detach(): void;
+    __makeNative(platformConfig?: IPlatformConfig): void;
+    __getNativeConfig(): INativeNodeConfig;
+}

package/build/animated/interpolation-node.js

@@ -0,0 +1,57 @@
+// AnimatedInterpolation: a graph node that maps its parent's numeric value
+// through an interpolation. Ported from RN's AnimatedInterpolation.js: numeric,
+// string-with-units, and color output ranges (the value graph; native config
+// removed). Platform (Native) colors stay out of scope, color.ts defers them.
+import { AnimatedNode, AnimatedWithChildren } from './graph';
+import { checkValidRanges, createInterpolation } from './interpolation';
+export class AnimatedInterpolation extends AnimatedWithChildren {
+    parent;
+    config;
+    interpolation;
+    constructor(parent, config) {
+        super();
+        this.parent = parent;
+        this.config = config;
+        // Validate eagerly so a bad range fails at construction, not first frame.
+        checkValidRanges(config.inputRange, config.outputRange);
+    }
+    getInterpolation() {
+        if (this.interpolation === undefined) {
+            this.interpolation = createInterpolation(this.config);
+        }
+        return this.interpolation;
+    }
+    __getValue() {
+        const parentValue = this.parent.__getValue();
+        if (typeof parentValue !== 'number') {
+            throw new Error('Cannot interpolate an input which is not a number');
+        }
+        return this.getInterpolation()(parentValue);
+    }
+    interpolate(config) {
+        return new AnimatedInterpolation(this, config);
+    }
+    __attach() {
+        this.parent.__addChild(this);
+        super.__attach();
+    }
+    __detach() {
+        this.parent.__removeChild(this);
+        super.__detach();
+    }
+    // Make the upstream value native first, so the parent->interpolation edge can be
+    // wired when this node is reached from a leaf rather than from the value.
+    __makeNative(platformConfig) {
+        this.parent.__makeNative(platformConfig);
+        super.__makeNative(platformConfig);
+    }
+    __getNativeConfig() {
+        return {
+            type: 'interpolation',
+            inputRange: this.config.inputRange,
+            outputRange: this.config.outputRange,
+            extrapolateLeft: this.config.extrapolateLeft ?? this.config.extrapolate ?? 'extend',
+            extrapolateRight: this.config.extrapolateRight ?? this.config.extrapolate ?? 'extend',
+        };
+    }
+}

package/build/animated/interpolation.d.ts

@@ -0,0 +1,22 @@
+import { type IEasingFunction } from './easing';
+export type IExtrapolateType = 'extend' | 'identity' | 'clamp';
+export interface IInterpolationConfig {
+    inputRange: readonly number[];
+    outputRange: readonly number[] | readonly string[];
+    easing?: IEasingFunction;
+    extrapolate?: IExtrapolateType;
+    extrapolateLeft?: IExtrapolateType;
+    extrapolateRight?: IExtrapolateType;
+}
+interface INumericInterpolationConfig {
+    inputRange: readonly number[];
+    outputRange: readonly number[];
+    easing?: IEasingFunction;
+    extrapolate?: IExtrapolateType;
+    extrapolateLeft?: IExtrapolateType;
+    extrapolateRight?: IExtrapolateType;
+}
+export declare function checkValidRanges(inputRange: readonly number[], outputRange: readonly number[] | readonly string[]): void;
+export declare function createNumericInterpolation(config: INumericInterpolationConfig): (input: number) => number;
+export declare function createInterpolation(config: IInterpolationConfig): (input: number) => number | string;
+export {};