@symbiote-native/engine 0.1.4 → 0.1.5

package/build/animated/operators.js

@@ -10,7 +10,6 @@
 // each input's native tag (creating the input node) but issues no connect.
 import { AnimatedNode, AnimatedWithChildren } from './graph.js';
 import { AnimatedValue } from './value.js';
-import { AnimatedInterpolation } from './interpolation-node.js';
 import { dlog } from '../debug.js';
 // Wrap a bare number in an AnimatedValue so every input is a graph node.
 function toNode(input) {
@@ -23,7 +22,10 @@ function numericValue(node) {
     }
     return value;
 }
-export class AnimatedAddition extends AnimatedWithChildren {
+// Shared shape of add/subtract/multiply/divide: two operand nodes, wired into the
+// graph identically (attach/detach both as children, makeNative both natively).
+// Each subclass supplies only its arithmetic (`compute`) and its native config type.
+class AnimatedBinaryOp extends AnimatedWithChildren {
     a;
     b;
     constructor(a, b) {
@@ -32,10 +34,7 @@ export class AnimatedAddition extends AnimatedWithChildren {
         this.b = toNode(b);
     }
     __getValue() {
-        return numericValue(this.a) + numericValue(this.b);
-    }
-    interpolate(config) {
-        return new AnimatedInterpolation(this, config);
+        return this.compute(numericValue(this.a), numericValue(this.b));
     }
     __attach() {
         this.a.__addChild(this);
@@ -52,91 +51,40 @@ export class AnimatedAddition extends AnimatedWithChildren {
         this.b.__makeNative(platformConfig);
         super.__makeNative(platformConfig);
     }
+}
+export class AnimatedAddition extends AnimatedBinaryOp {
+    compute(a, b) {
+        return a + b;
+    }
     __getNativeConfig() {
         return { type: 'addition', input: [this.a.__getNativeTag(), this.b.__getNativeTag()] };
     }
 }
-export class AnimatedSubtraction extends AnimatedWithChildren {
-    a;
-    b;
-    constructor(a, b) {
-        super();
-        this.a = toNode(a);
-        this.b = toNode(b);
-    }
-    __getValue() {
-        return numericValue(this.a) - numericValue(this.b);
-    }
-    interpolate(config) {
-        return new AnimatedInterpolation(this, config);
-    }
-    __attach() {
-        this.a.__addChild(this);
-        this.b.__addChild(this);
-        super.__attach();
-    }
-    __detach() {
-        this.a.__removeChild(this);
-        this.b.__removeChild(this);
-        super.__detach();
-    }
-    __makeNative(platformConfig) {
-        this.a.__makeNative(platformConfig);
-        this.b.__makeNative(platformConfig);
-        super.__makeNative(platformConfig);
+export class AnimatedSubtraction extends AnimatedBinaryOp {
+    compute(a, b) {
+        return a - b;
     }
     __getNativeConfig() {
         return { type: 'subtraction', input: [this.a.__getNativeTag(), this.b.__getNativeTag()] };
     }
 }
-export class AnimatedMultiplication extends AnimatedWithChildren {
-    a;
-    b;
-    constructor(a, b) {
-        super();
-        this.a = toNode(a);
-        this.b = toNode(b);
-    }
-    __getValue() {
-        return numericValue(this.a) * numericValue(this.b);
-    }
-    interpolate(config) {
-        return new AnimatedInterpolation(this, config);
-    }
-    __attach() {
-        this.a.__addChild(this);
-        this.b.__addChild(this);
-        super.__attach();
-    }
-    __detach() {
-        this.a.__removeChild(this);
-        this.b.__removeChild(this);
-        super.__detach();
-    }
-    __makeNative(platformConfig) {
-        this.a.__makeNative(platformConfig);
-        this.b.__makeNative(platformConfig);
-        super.__makeNative(platformConfig);
+export class AnimatedMultiplication extends AnimatedBinaryOp {
+    compute(a, b) {
+        return a * b;
     }
     __getNativeConfig() {
         return { type: 'multiplication', input: [this.a.__getNativeTag(), this.b.__getNativeTag()] };
     }
 }
-export class AnimatedDivision extends AnimatedWithChildren {
-    a;
-    b;
+export class AnimatedDivision extends AnimatedBinaryOp {
     warnedAboutDivideByZero = false;
     constructor(a, b) {
-        super();
+        super(a, b);
         if (b === 0 || (b instanceof AnimatedNode && b.__getValue() === 0)) {
             dlog('AnimatedDivision: detected potential division by zero');
         }
-        this.a = toNode(a);
-        this.b = toNode(b);
     }
-    __getValue() {
-        const a = numericValue(this.a);
-        const b = numericValue(this.b);
+    compute(a, b) {
         if (b === 0) {
             // A divide-by-zero yields Infinity/NaN, which crashes Fabric, so clamp to 0.
             if (!this.warnedAboutDivideByZero) {
@@ -148,24 +96,6 @@ export class AnimatedDivision extends AnimatedWithChildren {
         this.warnedAboutDivideByZero = false;
         return a / b;
     }
-    interpolate(config) {
-        return new AnimatedInterpolation(this, config);
-    }
-    __attach() {
-        this.a.__addChild(this);
-        this.b.__addChild(this);
-        super.__attach();
-    }
-    __detach() {
-        this.a.__removeChild(this);
-        this.b.__removeChild(this);
-        super.__detach();
-    }
-    __makeNative(platformConfig) {
-        this.a.__makeNative(platformConfig);
-        this.b.__makeNative(platformConfig);
-        super.__makeNative(platformConfig);
-    }
     __getNativeConfig() {
         return { type: 'division', input: [this.a.__getNativeTag(), this.b.__getNativeTag()] };
     }
@@ -184,9 +114,6 @@ export class AnimatedModulo extends AnimatedWithChildren {
         const a = numericValue(this.a);
         return ((a % this.modulus) + this.modulus) % this.modulus;
     }
-    interpolate(config) {
-        return new AnimatedInterpolation(this, config);
-    }
     __attach() {
         this.a.__addChild(this);
         super.__attach();
@@ -227,9 +154,6 @@ export class AnimatedDiffClamp extends AnimatedWithChildren {
         this.value = Math.min(Math.max(this.value + diff, this.min), this.max);
         return this.value;
     }
-    interpolate(config) {
-        return new AnimatedInterpolation(this, config);
-    }
     __attach() {
         this.a.__addChild(this);
         super.__attach();

package/build/animated/value.d.ts

@@ -1,9 +1,7 @@
 import type { IAnimation, IEndCallback } from './animation';
 import { AnimatedWithChildren, type IValueListener } from './graph';
 import type { AnimatedTracking } from './animations/tracking';
-import { AnimatedInterpolation } from './interpolation-node';
-import type { IInterpolationConfig } from './interpolation';
-import { type INativeNodeConfig, type IPlatformConfig } from './native/native-animated';
+import { type INativeAnimationConfig, type INativeNodeConfig, type IPlatformConfig } from './native/native-animated';
 export declare class AnimatedValue extends AnimatedWithChildren {
     private value;
     private readonly startingValue;
@@ -25,12 +23,12 @@ export declare class AnimatedValue extends AnimatedWithChildren {
     flattenOffset(): void;
     extractOffset(): void;
     __onNativeUpdate(value: number, offset?: number): void;
+    __startNativeAnimation(config: INativeAnimationConfig, nativeId: number, onEnd: (finished: boolean) => void, platformConfig?: IPlatformConfig): void;
     __getNativeConfig(): INativeNodeConfig;
     stopAnimation(callback?: (value: number) => void): void;
     track(tracking: AnimatedTracking): void;
     private stopTracking;
     resetAnimation(callback?: (value: number) => void): void;
-    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
     animate(animation: IAnimation, callback?: IEndCallback): void;
     private updateValue;
 }

package/build/animated/value.js

@@ -4,7 +4,6 @@
 // AnimatedValue.js with the native-driver branches removed; tracking
 // (animating toward another animated node) is deferred.
 import { AnimatedWithChildren, flushValue } from './graph.js';
-import { AnimatedInterpolation } from './interpolation-node.js';
 import { nativeAnimated, } from './native/native-animated.js';
 export class AnimatedValue extends AnimatedWithChildren {
     value;
@@ -120,6 +119,23 @@ export class AnimatedValue extends AnimatedWithChildren {
             this.offset = offset;
         }
     }
+    // Own the native-driver "start" handshake end-to-end: make this value native, mint
+    // its tag, hand the curve to the native module, and on completion sync the JS value
+    // (no re-flush to bound leaves' native side; native already moved the view). A
+    // driver (BaseAnimation.startNativeIfNeeded) supplies only what IT owns: the curve
+    // config, its own animation id, its platform bag, and its own end callback, never
+    // touching __makeNative / __getNativeTag / __onNativeUpdate / flushValue directly.
+    // Information Expert: this value is the one object that actually holds those internals.
+    __startNativeAnimation(config, nativeId, onEnd, platformConfig) {
+        this.__makeNative(platformConfig);
+        nativeAnimated.startAnimatingNode(nativeId, this.__getNativeTag(), config, result => {
+            onEnd(result.finished);
+            if (result.value !== undefined) {
+                this.__onNativeUpdate(result.value, result.offset);
+                flushValue(this);
+            }
+        });
+    }
     __getNativeConfig() {
         return { type: 'value', value: this.value, offset: this.offset };
     }
@@ -153,10 +169,6 @@ export class AnimatedValue extends AnimatedWithChildren {
         this.stopAnimation(callback);
         this.value = this.startingValue;
     }
-    // Map the value before it reaches a prop, e.g. 0..1 -> 0..10.
-    interpolate(config) {
-        return new AnimatedInterpolation(this, config);
-    }
     // Drive this value with an animation. Typically called by Animated.timing /
     // spring / decay rather than directly.
     animate(animation, callback) {

package/build/app-state/index.js

@@ -5,8 +5,8 @@
 // NativeEventEmitter bound to the AppState native module and maps them onto the
 // public 'change'/'memoryWarning'/'focus'/'blur' listeners, mirroring RN's
 // Libraries/AppState/AppState.js.
-import { getNativeModule } from '../native-modules.js';
-import { installDeviceEventHub, NativeEventEmitter, } from '../native-events.js';
+import { createDeviceEventModule } from '../native-modules.js';
+import {} from '../native-events.js';
 import { dlog } from '../debug.js';
 // The native module name RN registers AppState under, confirmed from its spec
 // (specs_DEPRECATED/modules/INativeAppState.js, `TurboModuleRegistry.getEnforcing('AppState')`).
@@ -30,36 +30,31 @@ function isStateChangePayload(value) {
 // Lazily resolved so importing this module has no native side effect: a headless
 // run without a fake __turboModuleProxy still loads it; resolution happens on first
 // use. `null` when the module isn't linked.
-let appStateModule;
-let emitter;
 let currentState = null;
-function getModule() {
-    if (appStateModule === undefined) {
-        appStateModule = getNativeModule(APP_STATE_MODULE);
-        dlog(`AppState: module ${appStateModule ? 'resolved' : 'NOT resolved (null)'}`);
-    }
-    return appStateModule;
-}
-function getEmitter() {
-    if (emitter === undefined) {
-        // WHY lazy: install on first use so the hub exists before native emits, without
-        // a hard bootstrap-order dependency. Idempotent.
-        installDeviceEventHub();
-        const module = getModule();
+// The self-subscription policy that diverges from a plain lazy-resolve+emitter:
+// AppState hydrates `currentState` from the module's initial constants, then keeps it
+// fresh forever via a permanent 'appStateDidChange' listener, so a read after a native
+// change returns the new value even with nobody else listening (RN parity).
+const deviceEventModule = createDeviceEventModule({
+    moduleName: APP_STATE_MODULE,
+    moduleLogPrefix: 'AppState: module',
+    onEmitterCreated: (emitter, module) => {
         if (module !== null) {
             currentState = module.getConstants().initialAppState;
         }
-        emitter = new NativeEventEmitter(module ?? undefined);
-        // Keep `currentState` fresh even when nobody listens, so a read after a state
-        // change returns the new value; RN registers the same always-on observer.
         emitter.addListener(NATIVE_EVENT.stateDidChange, payload => {
             if (!isStateChangePayload(payload))
                 return;
             dlog(`AppState: ${NATIVE_EVENT.stateDidChange} -> ${payload.app_state}`);
             currentState = payload.app_state;
         });
-    }
-    return emitter;
+    },
+});
+function getModule() {
+    return deviceEventModule.getModule();
+}
+function getEmitter() {
+    return deviceEventModule.getEmitter();
 }
 class AppStateImpl {
     // Feature-detect: true when the native AppState module resolved, false when it

package/build/appearance/index.js

@@ -4,8 +4,8 @@
 // native module (which RN keys its appearance events off of) and re-broadcasts to
 // JS listeners as a plain `{ colorScheme }` payload. Mirrors RN's
 // Libraries/Utilities/Appearance.js, slimmed to the parts we need.
-import { getNativeModule } from '../native-modules.js';
-import { installDeviceEventHub, NativeEventEmitter, } from '../native-events.js';
+import { createDeviceEventModule } from '../native-modules.js';
+import {} from '../native-events.js';
 import { dlog } from '../debug.js';
 // The native module name RN registers the appearance module under, confirmed from
 // its spec (specs_DEPRECATED/modules/INativeAppearance.js, `TurboModuleRegistry.get('Appearance')`).
@@ -16,37 +16,29 @@ const APPEARANCE_CHANGED_EVENT = 'appearanceChanged';
 function isAppearancePreferences(value) {
     return typeof value === 'object' && value !== null && 'colorScheme' in value;
 }
-// Lazily resolved so importing this module has no native side effect: a headless
-// run without a fake __turboModuleProxy still loads it; resolution happens on the
-// first use. `null` when the module isn't linked.
-let appearanceModule;
-let emitter;
 // Cached scheme, kept fresh by the change listener; mirrors RN's `state.appearance`.
 let cachedScheme;
-function getModule() {
-    if (appearanceModule === undefined) {
-        appearanceModule = getNativeModule(APPEARANCE_MODULE);
-        dlog(`Appearance: module ${appearanceModule ? 'resolved' : 'NOT resolved (null)'}`);
-    }
-    return appearanceModule;
-}
-function getEmitter() {
-    if (emitter === undefined) {
-        // WHY lazy: install on first subscribe so the hub exists before native emits,
-        // without a hard bootstrap-order dependency. Idempotent.
-        installDeviceEventHub();
-        const module = getModule();
-        emitter = new NativeEventEmitter(module ?? undefined);
-        // Keep the cached scheme fresh even when nobody is listening, so a later
-        // getColorScheme() after a system change reads the new value. RN does the same.
+// The self-subscription policy that diverges from a plain lazy-resolve+emitter:
+// Appearance keeps `cachedScheme` fresh forever via a permanent change listener, so a
+// later getColorScheme() after a system change reads the new value even with nobody
+// else listening. RN does the same.
+const deviceEventModule = createDeviceEventModule({
+    moduleName: APPEARANCE_MODULE,
+    moduleLogPrefix: 'Appearance: module',
+    onEmitterCreated: emitter => {
         emitter.addListener(APPEARANCE_CHANGED_EVENT, payload => {
             if (!isAppearancePreferences(payload))
                 return;
             dlog(`Appearance: ${APPEARANCE_CHANGED_EVENT} -> ${String(payload.colorScheme)}`);
             cachedScheme = payload.colorScheme;
         });
-    }
-    return emitter;
+    },
+});
+function getModule() {
+    return deviceEventModule.getModule();
+}
+function getEmitter() {
+    return deviceEventModule.getEmitter();
 }
 export const Appearance = {
     // The current color scheme, or null when no module is linked / the device is in

package/build/back-handler/index.js

@@ -6,8 +6,8 @@
 // Android-only by intent: iOS has no hardware back button, so the whole module
 // degrades to a no-op when the native module is absent, matching RN's
 // BackHandler.ios.js stub. Mirrors RN's Libraries/Utilities/BackHandler.android.js.
-import { getNativeModule } from '../native-modules.js';
-import { installDeviceEventHub, NativeEventEmitter, } from '../native-events.js';
+import { createDeviceEventModule } from '../native-modules.js';
+import {} from '../native-events.js';
 import { dlog } from '../debug.js';
 // The native module name RN registers this under. NOTE: this is the name the
 // INativeDeviceEventManager spec resolves via
@@ -31,25 +31,22 @@ function isHandled(result) {
 // Lazily resolved so importing this module has no native side effect: a headless
 // run without a fake __turboModuleProxy still loads it; resolution happens on the
 // first use. `null` when the module isn't linked (e.g. iOS).
-let deviceEventManager;
-let emitter;
+//
+// The self-subscription policy that diverges from a plain lazy-resolve+emitter:
+// BackHandler wires the native back-press event to the reverse-order chain exactly
+// once, permanently.
+const deviceEventModule = createDeviceEventModule({
+    moduleName: DEVICE_EVENT_MANAGER_MODULE,
+    moduleLogPrefix: 'BackHandler: module',
+    onEmitterCreated: emitter => {
+        emitter.addListener(DEVICE_BACK_EVENT, dispatchBackPress);
+    },
+});
 function getModule() {
-    if (deviceEventManager === undefined) {
-        deviceEventManager = getNativeModule(DEVICE_EVENT_MANAGER_MODULE);
-        dlog(`BackHandler: module ${deviceEventManager ? 'resolved' : 'NOT resolved (null)'}`);
-    }
-    return deviceEventManager;
+    return deviceEventModule.getModule();
 }
 function getEmitter() {
-    if (emitter === undefined) {
-        // WHY lazy: install on first subscribe so the hub exists before native emits,
-        // without a hard bootstrap-order dependency. Idempotent.
-        installDeviceEventHub();
-        emitter = new NativeEventEmitter(getModule() ?? undefined);
-        // Wire the native back-press event to the reverse-order chain exactly once.
-        emitter.addListener(DEVICE_BACK_EVENT, dispatchBackPress);
-    }
-    return emitter;
+    return deviceEventModule.getEmitter();
 }
 // Run handlers last-registered-first; the first to return true consumes the press
 // and the rest are skipped. If none consume it, fall through to the native default.

package/build/commit.d.ts

@@ -1,8 +1,6 @@
 import { type IFabricNode, type IRootTag, type IMeasureOnSuccess, type IMeasureInWindowOnSuccess, type IMeasureLayoutOnSuccess } from './fabric';
 import { type ISymbioteNode } from './node';
-import { type IColorValue } from './platform-color';
-export declare function setColorProcessor(process: (value: IColorValue) => unknown): void;
-export declare function processColor(color: IColorValue): unknown;
+export { processColor, setColorProcessor } from './platform-color';
 export declare function disposeRoot(rootTag: IRootTag): void;
 export declare function commitChildren(rootTag: IRootTag, children: readonly ISymbioteNode[]): void;
 export declare function setNativeProps(node: ISymbioteNode, partial: Record<string, unknown>): void;