@symbiote-native/solid 3.2.0 → 3.4.0

package/build/modules/animated/index.d.ts

@@ -1,56 +1,69 @@
-import { AnimatedValue, AnimatedValueXY, AnimatedColor, timing, spring, decay, parallel, sequence, stagger, loop, delay, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent } from '@symbiote-native/engine';
 import { createAnimatedComponent } from './create-animated-component';
 export { createAnimatedComponent } from './create-animated-component';
 export type { IAnimatedComponentProps } from './create-animated-component';
 export { AnimatedProps, AnimatedStyle, AnimatedTransform, } from '@symbiote-native/engine';
 type IAnimatedComponent = ReturnType<typeof createAnimatedComponent>;
 export declare const Animated: {
-    Value: typeof AnimatedValue;
-    ValueXY: typeof AnimatedValueXY;
-    Color: typeof AnimatedColor;
+    timing: {
+        (value: import("@symbiote-native/engine").AnimatedValue, config: import("@symbiote-native/engine").ITimingConfig): import("@symbiote-native/engine").ICompositeAnimation;
+        (value: import("@symbiote-native/engine").IVectorValue, config: import("@symbiote-native/engine").IVectorTimingConfig): import("@symbiote-native/engine").ICompositeAnimation;
+    };
+    spring: {
+        (value: import("@symbiote-native/engine").AnimatedValue, config: import("@symbiote-native/engine").ISpringConfig): import("@symbiote-native/engine").ICompositeAnimation;
+        (value: import("@symbiote-native/engine").IVectorValue, config: import("@symbiote-native/engine").IVectorSpringConfig): import("@symbiote-native/engine").ICompositeAnimation;
+    };
+    decay: (_value: import("@symbiote-native/engine").AnimatedValue, _config: import("@symbiote-native/engine").IDecayConfig) => import("@symbiote-native/engine").ICompositeAnimation;
+    parallel: (animations: import("@symbiote-native/engine").ICompositeAnimation[], _config?: import("@symbiote-native/engine").IParallelConfig) => import("@symbiote-native/engine").ICompositeAnimation;
+    sequence: (animations: import("@symbiote-native/engine").ICompositeAnimation[]) => import("@symbiote-native/engine").ICompositeAnimation;
+    stagger: (_time: number, animations: import("@symbiote-native/engine").ICompositeAnimation[]) => import("@symbiote-native/engine").ICompositeAnimation;
+    loop: (_animation: import("@symbiote-native/engine").ICompositeAnimation) => import("@symbiote-native/engine").ICompositeAnimation;
+    delay: (_time: number) => import("@symbiote-native/engine").ICompositeAnimation;
+    Value: typeof import("@symbiote-native/engine").AnimatedValue;
+    ValueXY: typeof import("@symbiote-native/engine").AnimatedValueXY;
+    Color: typeof import("@symbiote-native/engine").AnimatedColor;
+    Interpolation: typeof import("@symbiote-native/engine").AnimatedInterpolation;
+    Node: typeof import("@symbiote-native/engine").AnimatedNode;
     Easing: import("@symbiote-native/engine").IEasing;
-    timing: typeof timing;
-    spring: typeof spring;
-    decay: typeof decay;
-    parallel: typeof parallel;
-    sequence: typeof sequence;
-    stagger: typeof stagger;
-    loop: typeof loop;
-    delay: typeof delay;
-    add: typeof add;
-    subtract: typeof subtract;
-    multiply: typeof multiply;
-    divide: typeof divide;
-    modulo: typeof modulo;
-    diffClamp: typeof diffClamp;
-    event: typeof event;
-    forkEvent: typeof forkEvent;
-    unforkEvent: typeof unforkEvent;
+    add: typeof import("@symbiote-native/engine").add;
+    subtract: typeof import("@symbiote-native/engine").subtract;
+    multiply: typeof import("@symbiote-native/engine").multiply;
+    divide: typeof import("@symbiote-native/engine").divide;
+    modulo: typeof import("@symbiote-native/engine").modulo;
+    diffClamp: typeof import("@symbiote-native/engine").diffClamp;
+    event: typeof import("@symbiote-native/engine").event;
+    attachNativeEvent: typeof import("@symbiote-native/engine").attachNativeEvent;
+    forkEvent: typeof import("@symbiote-native/engine").forkEvent;
+    unforkEvent: typeof import("@symbiote-native/engine").unforkEvent;
+    Event: typeof import("@symbiote-native/engine").AnimatedEvent;
     FlatList: IAnimatedComponent;
     SectionList: IAnimatedComponent;
     createAnimatedComponent: typeof createAnimatedComponent;
 } | {
-    Value: typeof AnimatedValue;
-    ValueXY: typeof AnimatedValueXY;
-    Color: typeof AnimatedColor;
+    Value: typeof import("@symbiote-native/engine").AnimatedValue;
+    ValueXY: typeof import("@symbiote-native/engine").AnimatedValueXY;
+    Color: typeof import("@symbiote-native/engine").AnimatedColor;
+    Interpolation: typeof import("@symbiote-native/engine").AnimatedInterpolation;
+    Node: typeof import("@symbiote-native/engine").AnimatedNode;
     Easing: import("@symbiote-native/engine").IEasing;
-    timing: (value: AnimatedValue, config: import("@symbiote-native/engine").ITimingConfig) => import("@symbiote-native/engine").ICompositeAnimation;
-    spring: (value: AnimatedValue, config: import("@symbiote-native/engine").ISpringConfig) => import("@symbiote-native/engine").ICompositeAnimation;
-    decay: (_value: AnimatedValue, _config: import("@symbiote-native/engine").IDecayConfig) => import("@symbiote-native/engine").ICompositeAnimation;
-    parallel: (animations: import("@symbiote-native/engine").ICompositeAnimation[], _config?: import("@symbiote-native/engine").IParallelConfig) => import("@symbiote-native/engine").ICompositeAnimation;
-    sequence: (animations: import("@symbiote-native/engine").ICompositeAnimation[]) => import("@symbiote-native/engine").ICompositeAnimation;
-    stagger: (_time: number, animations: import("@symbiote-native/engine").ICompositeAnimation[]) => import("@symbiote-native/engine").ICompositeAnimation;
-    loop: (_animation: import("@symbiote-native/engine").ICompositeAnimation) => import("@symbiote-native/engine").ICompositeAnimation;
-    delay: (_time: number) => import("@symbiote-native/engine").ICompositeAnimation;
-    add: typeof add;
-    subtract: typeof subtract;
-    multiply: typeof multiply;
-    divide: typeof divide;
-    modulo: typeof modulo;
-    diffClamp: typeof diffClamp;
-    event: typeof event;
-    forkEvent: typeof forkEvent;
-    unforkEvent: typeof unforkEvent;
+    timing: typeof import("@symbiote-native/engine").timing;
+    spring: typeof import("@symbiote-native/engine").spring;
+    decay: typeof import("@symbiote-native/engine").decay;
+    parallel: typeof import("@symbiote-native/engine").parallel;
+    sequence: typeof import("@symbiote-native/engine").sequence;
+    stagger: typeof import("@symbiote-native/engine").stagger;
+    loop: typeof import("@symbiote-native/engine").loop;
+    delay: typeof import("@symbiote-native/engine").delay;
+    add: typeof import("@symbiote-native/engine").add;
+    subtract: typeof import("@symbiote-native/engine").subtract;
+    multiply: typeof import("@symbiote-native/engine").multiply;
+    divide: typeof import("@symbiote-native/engine").divide;
+    modulo: typeof import("@symbiote-native/engine").modulo;
+    diffClamp: typeof import("@symbiote-native/engine").diffClamp;
+    event: typeof import("@symbiote-native/engine").event;
+    attachNativeEvent: typeof import("@symbiote-native/engine").attachNativeEvent;
+    forkEvent: typeof import("@symbiote-native/engine").forkEvent;
+    unforkEvent: typeof import("@symbiote-native/engine").unforkEvent;
+    Event: typeof import("@symbiote-native/engine").AnimatedEvent;
     FlatList: IAnimatedComponent;
     SectionList: IAnimatedComponent;
     createAnimatedComponent: typeof createAnimatedComponent;

package/build/modules/animated/index.js

@@ -19,7 +19,7 @@
 // useNativeDriver animation promotes the value graph itself (animations/base.ts ->
 // value.__startNativeAnimation -> graph.__makeNative), and the props leaf follows automatically
 // through graph.__addChild. This file only assembles the surface.
-import { AnimatedValue, AnimatedValueXY, AnimatedColor, AnimatedMock, Easing, Platform, timing, spring, decay, parallel, sequence, stagger, loop, delay, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent, } from '@symbiote-native/engine';
+import { AnimatedDrivers, AnimatedMock, Platform, } from '@symbiote-native/engine';
 import { FlatList } from '../../components/flat-list/index.jsx';
 import { SectionList } from '../../components/section-list/index.jsx';
 import { createAnimatedComponent } from './create-animated-component.jsx';
@@ -29,35 +29,11 @@ export { createAnimatedComponent } from './create-animated-component.jsx';
 export { AnimatedProps, AnimatedStyle, AnimatedTransform, } from '@symbiote-native/engine';
 let animatedFlatList;
 let animatedSectionList;
-// The live, JS-driven driver half. RN's AnimatedImplementation.
-const liveDrivers = {
-    Value: AnimatedValue,
-    ValueXY: AnimatedValueXY,
-    Color: AnimatedColor,
-    Easing,
-    timing,
-    spring,
-    decay,
-    parallel,
-    sequence,
-    stagger,
-    loop,
-    delay,
-    add,
-    subtract,
-    multiply,
-    divide,
-    modulo,
-    diffClamp,
-    event,
-    forkEvent,
-    unforkEvent,
-};
 // RN swaps the WHOLE driver namespace for the mock when the host reports isDisableAnimations
 // (reduced motion / test env): same surface, every animation jumping to its final value with no
 // frames. The COMPONENTS stay live in both branches — only this half is swapped, exactly as RN
 // spreads `...Animated` over the same component getters.
-const drivers = Platform.isDisableAnimations ? AnimatedMock : liveDrivers;
+const drivers = Platform.isDisableAnimations ? AnimatedMock : AnimatedDrivers;
 export const Animated = {
     get FlatList() {
         animatedFlatList ??= createAnimatedComponent(FlatList);

package/build/modules/app-registry/index.d.ts

@@ -1,7 +1,7 @@
 import type { Component } from 'solid-js';
-import { type IAppParameters } from '@symbiote-native/engine';
+import { HeadlessJsTaskError, type IAppParameters } from '@symbiote-native/engine';
 export type IComponentProvider = () => Component;
 export type IWrapperComponentProvider = (appParameters: IAppParameters) => Component;
 declare const AppRegistry: import("@symbiote-native/engine").IAppRegistry<IComponentProvider, IWrapperComponentProvider>, setHostRegistrar: (registrar: import("@symbiote-native/engine").IHostRegistrar) => void;
-export { AppRegistry, setHostRegistrar };
-export type { IAppParameters, IRunnable, IHostRegistrar, IRegistry, IHeadlessTask, ITaskProvider, ITaskCanceller, ITaskCancelProvider, } from '@symbiote-native/engine';
+export { AppRegistry, HeadlessJsTaskError, setHostRegistrar };
+export type { IAppConfig, IAppParameters, IRunnable, IHostRegistrar, IRegistry, IHeadlessTask, ITaskProvider, ITaskCanceller, ITaskCancelProvider, } from '@symbiote-native/engine';

package/build/modules/app-registry/index.js

@@ -8,7 +8,7 @@
 // design pass: a Solid component is an ordinary function value, so wrapping composes exactly the
 // way Vue's `h(wrapper, null, { default: renderRoot })` does — `createComponent(Wrapper, { get
 // children() {…} })`, which is also the literal shape compiled JSX emits for children.
-import { createAppRegistry, dlog, } from '@symbiote-native/engine';
+import { createAppRegistry, dlog, HeadlessJsTaskError, } from '@symbiote-native/engine';
 import { createComponent } from '../../renderer.js';
 import { mount } from '../../render.js';
 function runnableFor(componentProvider, getWrapperComponentProvider) {
@@ -34,4 +34,4 @@ function runnableFor(componentProvider, getWrapperComponentProvider) {
     };
 }
 const { AppRegistry, setHostRegistrar } = createAppRegistry(runnableFor);
-export { AppRegistry, setHostRegistrar };
+export { AppRegistry, HeadlessJsTaskError, setHostRegistrar };

package/build/modules/status-bar.js

@@ -1,45 +1,32 @@
-// StatusBar — the Solid lifecycle half, and nothing else. The native StatusBarManager driving
-// (applyStatusBarProps), the imperative statics (statusBarImperative) and the Android bar-height
-// constant all live in @symbiote-native/engine, shared verbatim with React / Vue / Svelte /
-// Angular; Metro selects the engine's index.ios.ts / index.android.ts per host, so the platform
-// divergence never reaches this file. Solid supplies only the declarative shape: a component that
-// renders no Fabric view and re-applies its props from a `createEffect` on mount and on every
-// prop change.
-//
-// FLAT, not a folder: the file-layout rule gives a module its own folder only for real
-// `.ios`/`.android`/`-shared` variants. React needs two files because its useEffect dep array is
-// written by hand per platform; there is no dep array here, so one file covers both hosts —
-// the same shape Svelte's and Angular's StatusBar landed on.
-//
-// Simplification vs RN, inherited from every other adapter: RN keeps a prop-merge stack so nested
-// StatusBars compose (deepest wins); this direct-applies one component's props.
-import { createEffect } from 'solid-js';
-import { applyStatusBarProps, statusBarImperative, statusBarCurrentHeight, } from '@symbiote-native/engine';
-// Renders null: StatusBar owns no host node, it drives a native module.
+// Solid half of StatusBar, the props stack and statics live in the engine. It renders no Fabric
+// view, applies its props to one stack entry from a `createEffect` and releases it on cleanup
+// FLAT, one file covers both hosts since there is no per-platform dependency array
+import { createEffect, onCleanup } from 'solid-js';
+import { createStatusBarEntry, statusBarImperative, statusBarCurrentHeight, } from '@symbiote-native/engine';
+// Renders null: StatusBar owns no host node, it drives a native module
 function StatusBarComponent(props) {
+    const entry = createStatusBarEntry();
     createEffect(() => {
-        // Every field is read HERE, not inside the engine, so the effect's dependency set is the whole
-        // prop surface rather than whichever subset this platform's impl happens to destructure —
-        // iOS's applyStatusBarProps never touches backgroundColor/translucent, and a props proxy read
-        // only there would silently stop re-applying after a host swap.
-        applyStatusBarProps({
+        // Every field is read here, so the effect depends on the whole prop surface
+        entry.apply({
             barStyle: props.barStyle,
             hidden: props.hidden,
             animated: props.animated,
+            showHideTransition: props.showHideTransition,
             networkActivityIndicatorVisible: props.networkActivityIndicatorVisible,
             backgroundColor: props.backgroundColor,
             translucent: props.translucent,
         });
     });
+    // Popping restores what the stack held below this entry
+    onCleanup(() => entry.release());
     return null;
 }
 const StatusBarWithStatics = Object.assign(StatusBarComponent, statusBarImperative);
-// Android exposes the bar height as a native constant; undefined on iOS / when absent. A getter,
-// not a value, so nothing touches native at import time.
+// A getter, not a value, so nothing touches native at import time
 Object.defineProperty(StatusBarWithStatics, 'currentHeight', {
     get: statusBarCurrentHeight,
     enumerable: true,
 });
-// currentHeight is optional, so the defineProperty-added accessor need not appear on the runtime
-// object's inferred type for this assignment to hold (no cast) — same shape as Svelte's.
+// `currentHeight` is optional, so the accessor need not appear on the inferred type (no cast)
 export const StatusBar = StatusBarWithStatics;

package/build/primitives/create-color-scheme.d.ts

@@ -1,3 +1,3 @@
 import { type Accessor } from 'solid-js';
 import { type IColorSchemeName } from '@symbiote-native/engine';
-export declare function createColorScheme(): Accessor<IColorSchemeName | null>;
+export declare function createColorScheme(): Accessor<IColorSchemeName | null | undefined>;

package/build/render.js

@@ -4,10 +4,10 @@
 import { createSurface, disposeRoot, dlog, reportUncaughtError, } from '@symbiote-native/engine';
 import { catchError, createRoot } from 'solid-js';
 import { createComponent, insert, setActiveSurface } from './renderer.js';
-// One Solid root per surface, so a surface can be torn down (unmount) or cleanly re-mounted on the
-// same rootTag: the bridgeless host stops and restarts a surface on Fast Refresh and on
-// lifecycle/focus changes, reusing the rootTag. The value is Solid's own dispose function — the
-// whole reactive root goes with it, effects and cleanups included.
+import { RootTagContext } from './root-tag-context.js';
+// One Solid root per surface, so a surface can be torn down or re-mounted on the same `rootTag`
+// The bridgeless host does that on Fast Refresh and on lifecycle or focus changes
+// The value is Solid's own `dispose`, the whole reactive root goes with it
 const roots = new Map();
 // Insertion-ordered, so the last entry is the most recently mounted surface. Kept alongside
 // `roots` only to answer one question: when a surface is torn down, is there another one still
@@ -21,16 +21,9 @@ function teardown(rootTag) {
     dispose();
     roots.delete(rootTag);
     surfaces.delete(rootTag);
-    // Cleared AFTER dispose() on purpose: disposing runs user cleanups, which can still mutate the
-    // tree, and those mutations should reach the surface they belong to rather than be dropped by
-    // renderer.ts's post-unmount guard.
-    //
-    // And cleared ONLY when the surface going away is the one the renderer is actually committing
-    // into. Clearing unconditionally killed a surface that was still mounted: with two surfaces up,
-    // unmounting the FIRST left the second alive but permanently uncommitted — every later mutation
-    // hit renderer.ts's "mutation after unmount" guard and was silently dropped. That is reachable
-    // from ordinary code the moment two surfaces exist, which is exactly the createTunnel case
-    // (../create-tunnel): the source surface stops, the target must keep painting.
+    // Cleared after `dispose()`, since user cleanups run inside it and can still mutate the tree
+    // Cleared only for the surface the renderer commits into, else a live surface goes dead
+    // With two surfaces up, unmounting the first must leave the second painting, as `createTunnel`
     if (activeRootTag !== rootTag) {
         disposeRoot(rootTag);
         return;
@@ -47,23 +40,18 @@ export function mount(rootTag, RootComponent) {
     surfaces.set(rootTag, surface);
     activeRootTag = rootTag;
     setActiveSurface(surface);
-    // `createComponent(RootComponent, {})` is exactly what compiled JSX emits for `<RootComponent />`
-    // — written by hand here because this file is plain TS, deliberately: render.ts is the one module
-    // an app's entry point imports before any JSX has been compiled, so keeping it JSX-free means it
-    // needs no Babel pass of its own.
-    //
-    // The surface IS the render container: a top-level insert routes to surface.appendChild
-    // (renderer.ts's insertNode), and the engine wraps surface.children in its synthetic flex root.
-    //
-    // `createRoot` + `insert` IS renderer.ts's `render(code, surface)`, spelled out so `catchError`
-    // can sit BETWEEN them. Solid's own `render` runs `insert(element, code())` — the insert lands
-    // outside anything `code` wrapped, so a root component returning a bare accessor would build its
-    // render effect under an owner with no error handler and throw past this seam. Written this way
-    // the insert is inside, and every computation the mount creates inherits the handler.
+    // `createComponent` is what compiled JSX emits, written by hand: render.ts must stay JSX-free
+    // `createRoot` + `insert` is `render()` spelled out, so `catchError` wraps the insert as well
+    // The Provider hands the surface tag to `useContext(RootTagContext)` for the whole tree
     let unwinding;
     const dispose = createRoot(disposeRootScope => {
         catchError(() => {
-            insert(surface, createComponent(RootComponent, {}));
+            insert(surface, createComponent(RootTagContext.Provider, {
+                value: rootTag,
+                get children() {
+                    return createComponent(RootComponent, {});
+                },
+            }));
         }, error => {
             if (unwinding?.error !== error) {
                 unwinding = { error };

package/build/root-tag-context.d.ts

@@ -0,0 +1 @@
+export declare const RootTagContext: import("solid-js").Context<number>;

package/build/root-tag-context.js

@@ -0,0 +1,4 @@
+// RN's `RootTagContext`: every `mount` provides the tag of its surface, 0 stays the default
+import { createContext } from 'solid-js';
+const NO_SURFACE = 0;
+export const RootTagContext = createContext(NO_SURFACE);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/solid",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "description": "SymbioteNative's Solid adapter — a solid-js/universal createRenderer driving real native iOS/Android views through the same engine as every other adapter.",
   "keywords": [
     "react-native",
@@ -62,19 +62,19 @@
   "dependencies": {
     "babel-preset-solid": "^1.9.12",
     "typescript": "~6.0.0",
-    "@symbiote-native/components": "3.2.0",
-    "@symbiote-native/css-parser": "0.5.4"
+    "@symbiote-native/components": "3.3.0",
+    "@symbiote-native/css-parser": "0.6.0"
   },
   "peerDependencies": {
     "solid-js": ">=1.9.0",
     "react-native": ">=0.86",
-    "@symbiote-native/engine": "^1.6.0"
+    "@symbiote-native/engine": "^1.8.0"
   },
   "devDependencies": {
     "@babel/core": "^7.25.2",
     "solid-js": "^1.9.14",
-    "@symbiote-native/engine": "1.6.0",
-    "@symbiote-native/test-utils": "0.4.7"
+    "@symbiote-native/engine": "1.8.0",
+    "@symbiote-native/test-utils": "0.5.1"
   },
   "scripts": {
     "typecheck": "tsc --build",