@symbiote-native/splash-screen 3.0.3 → 3.2.0

package/README.md

@@ -2,7 +2,7 @@
 
 A wrapper package for [SymbioteNative](../../README.md) that makes
 [`react-native-bootsplash`](https://github.com/zoontek/react-native-bootsplash) usable from
-**every** adapter — React, Vue, and Angular — not just React. Unlike a native-*view* wrapper
+**every** adapter — React, Vue, Svelte, Solid, and Angular — not just React. Unlike a native-_view_ wrapper
 (see `@symbiote-native/slider`), bootsplash exposes an imperative TurboModule (`hide`/`isVisible`)
 plus a React hook (`useHideAnimation`) that composes a fade-out overlay from plain `View`/`Image`
 primitives — there is no `ViewConfig` to register, only lifecycle to port per adapter.
@@ -26,6 +26,9 @@ src/core/       hide()/isVisible() (re-exported as-is — zero React upstream),
                 react-native-bootsplash's useHideAnimation body, framework-agnostic
 src/react/      @symbiote-native/splash-screen/react   — useHideAnimation hook
 src/vue/        @symbiote-native/splash-screen/vue     — useHideAnimation composable
+src/svelte/     @symbiote-native/splash-screen/svelte  — useHideAnimation rune
+src/solid/      @symbiote-native/splash-screen/solid   — createHideAnimation primitive (Solid
+                reserves `use*` for consuming existing state)
 src/angular/    @symbiote-native/splash-screen/angular — HideAnimationService (signals)
 ```
 
@@ -109,6 +112,14 @@ import { hide } from '@symbiote-native/splash-screen/angular';
 // call once from the root component's constructor/ngOnInit.
 ```
 
+```tsx
+// Solid
+import { onMount } from 'solid-js';
+import { hide } from '@symbiote-native/splash-screen/solid';
+
+onMount(() => void hide());
+```
+
 For a fade transition gated on real readiness (layout committed + logo/brand images loaded +
 your own `ready` flag) instead of an immediate `hide()`, use `useHideAnimation` — it returns the
 same `{ container, logo, brand }` prop bags upstream's hook does, which you bind onto your own
@@ -128,7 +139,7 @@ const { container, logo } = useHideAnimation({
 ```
 
 See the docs-site package page (`docs/packages/splash-screen`) for the full config surface and
-the Vue/Angular equivalents.
+the Vue/Svelte/Solid/Angular equivalents.
 
 ## API
 
@@ -162,14 +173,20 @@ useHideAnimation(config: IHideAnimationConfig): IHideAnimationResult
 // @symbiote-native/splash-screen/vue — setup runs once, so a getter
 useHideAnimation(getConfig: () => IHideAnimationConfig): ComputedRef<IHideAnimationResult>
 
+// @symbiote-native/splash-screen/svelte — the script body runs once, so a getter
+useHideAnimation(getConfig: () => IHideAnimationConfig): { readonly current: IHideAnimationResult }
+
+// @symbiote-native/splash-screen/solid — the component body runs once, so an accessor
+createHideAnimation(config: Accessor<IHideAnimationConfig>): Accessor<IHideAnimationResult>
+
 // @symbiote-native/splash-screen/angular — inject(HideAnimationService), connect() once
 connect(getConfig: () => IHideAnimationConfig): Signal<IHideAnimationResult>
 ```
 
 ## Test it
 
-Headless hook/composable tests live next to each adapter entry
-(`src/{react,vue}/{hooks,composables}/use-hide-animation.test.{ts,tsx}`) and mock
+Headless lifecycle-wrapper tests live next to each adapter entry
+(`src/{react,vue,svelte,solid}/{hooks,composables,runes,primitives}/*hide-animation*.test.{ts,tsx}`) and mock
 `react-native-bootsplash`'s `hide`/`isVisible` plus a fake `__turboModuleProxy` for
 `getConstants()`, so they run without a real Fabric host. Native asset generation and the
 Android/iOS wiring above are verified on-device (see the parent [README](../../README.md) for the

package/build/angular/index.d.ts

@@ -1,3 +1,3 @@
 export { hide, isVisible } from '../core';
 export { HideAnimationService } from './services/hide-animation.service';
-export type { IHideAnimationConfig, IHideAnimationResult, IManifest, IHideConfig } from '../core';
+export type { IHideAnimationConfig, IHideAnimationFailure, IHideAnimationFailureStage, IHideAnimationResult, IManifest, IHideConfig, } from '../core';

package/build/angular/services/hide-animation.service/index.js

@@ -32,14 +32,12 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { computed, effect, inject, Injectable, Injector } from '@angular/core';
-import { computeHideAnimationStyles, getHideAnimationConstants, HideAnimationController, } from '../../../core/index.js';
+import { computed, effect, inject, Injectable, Injector, } from '@angular/core';
+import { computeHideAnimationStyles, HideAnimationController, } from '../../../core/index.js';
 // Angular twin of React's `useHideAnimation` hook and Vue's `useHideAnimation` composable.
-// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
-// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
-// inside an injection context) with a GETTER, so it can keep reading the caller's own signals —
-// the same reason Vue's composable also takes a getter rather than a value: there is no
-// re-render/re-setup cycle here to hang a fresh read off of.
+// Angular has no per-instance hook, so `connect()` stands in for it: call it ONCE (typically
+// from a component's field initializer, inside an injection context) with a GETTER so it can
+// keep reading the caller's own signals — same reason Vue's composable takes a getter too.
 //
 //   readonly hideAnimation = inject(HideAnimationService).connect(() => this.config());
 //   // template: [style]="hideAnimation().container.style", (layout)="..." etc.
@@ -57,16 +55,19 @@ let HideAnimationService = (() => {
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
-        // Captured in the constructor (itself always run inside an injection context by Angular's
-        // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
-        // code that is not, on its own, an active injection context — mirrors create-tunnel.ts's
-        // `TunnelOut`, which passes its own captured `Injector` to `effect()` for the same reason.
+        // Captured in the constructor (always run inside an injection context by Angular's own DI)
+        // so `connect()` can create an `effect()` even when called from field-initializer code that
+        // isn't itself an active injection context — mirrors create-tunnel.ts's `TunnelOut`.
         injector = inject(Injector);
+        // The controller reads the native constants in its constructor, so a missing RNBootSplash
+        // throws out of connect() and aborts the host component's construction — deliberately: that
+        // is a build error, and a splash quietly stuck in light mode would ship unnoticed.
         connect(getConfig) {
             const controller = new HideAnimationController(getConfig());
-            const constants = getHideAnimationConstants();
-            effect(() => controller.updateConfig(getConfig()), { injector: this.injector });
-            return computed(() => computeHideAnimationStyles(getConfig(), constants, controller));
+            effect(() => controller.updateConfig(getConfig()), {
+                injector: this.injector,
+            });
+            return computed(() => computeHideAnimationStyles(getConfig(), controller.constants, controller));
         }
     };
     return HideAnimationService = _classThis;

package/build/core/hide-animation-controller.d.ts

@@ -1,6 +1,8 @@
-import type { IHideAnimationConfig } from './types';
+import type { IHideAnimationConfig, IHideAnimationConstants } from './types';
 export declare class HideAnimationController {
+    readonly constants: IHideAnimationConstants;
     private readonly readiness;
+    private readonly reportFailure;
     constructor(config: IHideAnimationConfig);
     updateConfig(config: IHideAnimationConfig): void;
     readonly onContainerLayout: () => void;

package/build/core/hide-animation-controller.js

@@ -1,12 +1,29 @@
+import { dlog } from '@symbiote-native/engine';
 import { hide } from './hide.js';
+import { getHideAnimationConstants } from './native-module.js';
 // Faithful port of react-native-bootsplash's useHideAnimation readiness gate (its
 // src/index.ts): hide() fires exactly once, after layout + both images (if requested) +
 // the caller all report ready, then the caller's own fade-out `animate()` runs. logoReady/
 // brandReady are captured ONCE at construction (mirrors the original's useRef factory,
 // evaluated only on first render) — a config that later drops its logo/brand source does
 // NOT retroactively flip readiness back on, only updateConfig's animate/userReady do.
+//
+// DELIBERATE DIVERGENCE from upstream, one place only: upstream swallows a rejected hide() with a
+// bare `.catch(() => {})`, which strands the app under a splash it can no longer dismiss (see
+// maybeRunAnimate). We fail open and report instead. Everything else, the unguarded constants read
+// included, stays a faithful port.
 export class HideAnimationController {
+    // Read once here rather than once per adapter: the values never change over a splash's lifetime.
+    // Unguarded on purpose — a missing RNBootSplash is a build error that must stay loud, see
+    // native-module.ts for the full reasoning before wrapping this in anything.
+    constants;
     readiness;
+    // dlog is DEBUG-gated, so it is the developer's seam, not the report: config.onError is the
+    // channel the app actually hears about this on.
+    reportFailure = (failure) => {
+        dlog(`splash-screen: hide animation degraded at "${failure.stage}": ${String(failure.error)}`);
+        this.readiness.onError?.(failure);
+    };
     constructor(config) {
         this.readiness = {
             layoutReady: false,
@@ -14,11 +31,14 @@ export class HideAnimationController {
             brandReady: config.manifest.brand == null || config.brand == null,
             userReady: config.ready ?? true,
             animate: config.animate,
+            onError: config.onError,
             animateHasBeenCalled: false,
         };
+        this.constants = getHideAnimationConstants();
     }
     updateConfig(config) {
         this.readiness.animate = config.animate;
+        this.readiness.onError = config.onError;
         this.readiness.userReady = config.ready ?? true;
         this.maybeRunAnimate();
     }
@@ -42,9 +62,22 @@ export class HideAnimationController {
             state.userReady &&
             !state.animateHasBeenCalled) {
             state.animateHasBeenCalled = true;
+            // Fail open. animateHasBeenCalled is already true by the time hide() settles, so the gate
+            // is shut for good: on a rejection there is no readiness callback left that could retry,
+            // and skipping animate() means the caller's splash overlay never fades out — the app sits
+            // under it forever. Running animate() anyway costs at worst a fade over a native splash
+            // that is still up; not running it costs the whole app.
             hide({ fade: false })
-                .then(() => state.animate())
-                .catch(() => { });
+                .catch((error) => {
+                this.reportFailure({ stage: 'hide', error });
+            })
+                .then(() => {
+                state.animate();
+            })
+                .catch((error) => {
+                // The caller's own animation throwing must not become an unhandled rejection either.
+                this.reportFailure({ stage: 'animate', error });
+            });
         }
     }
 }

package/build/core/index.d.ts

@@ -2,4 +2,4 @@ export { hide, isVisible } from './hide';
 export { HideAnimationController } from './hide-animation-controller';
 export { computeHideAnimationStyles } from './compute-hide-animation-styles';
 export { getHideAnimationConstants } from './native-module';
-export type { IHideConfig, IManifest, IHideAnimationConfig, IHideAnimationContainerProps, IHideAnimationImageProps, IHideAnimationResult, IHideAnimationConstants, } from './types';
+export type { IHideConfig, IManifest, IHideAnimationConfig, IHideAnimationContainerProps, IHideAnimationFailure, IHideAnimationFailureStage, IHideAnimationImageProps, IHideAnimationResult, IHideAnimationConstants, } from './types';

package/build/core/native-module.js

@@ -7,6 +7,24 @@
 // (hide/isVisible/useHideAnimation) never exposes directly.
 import { getEnforcingNativeModule } from '@symbiote-native/engine';
 const RN_BOOT_SPLASH_MODULE_NAME = 'RNBootSplash';
+// DELIBERATELY UNGUARDED — do not wrap this in a try/catch or hand it a fallback.
+//
+// A missing RNBootSplash is a BUILD error, not a runtime condition: the module is either linked
+// into the binary or it is not, deterministically, on the very first launch. Upstream treats it
+// the same way and does not soften it either — react-native-bootsplash's whole spec file is
+// `TurboModuleRegistry.getEnforcing<Spec>("RNBootSplash")` (src/specs/NativeRNBootSplash.ts),
+// which throws at module-IMPORT time, and its useHideAnimation calls `NativeModule.getConstants()`
+// with no guard at all. `getEnforcing` exists precisely to make this loud.
+//
+// This repo has a live footgun that depends on it staying loud: `npm install` deletes the
+// `.rn-bootsplash/` folder this package's podspec vendors at pod-install time (see CLAUDE.md), so
+// a skipped `pod install` yields exactly this missing module. Degrading to light-mode defaults
+// would turn that into "the splash looks fine, just never dark" and it would ship.
+//
+// Note the failure is currently invisible under @symbiote-native/react specifically: mount()
+// (adapters/react/src/render.ts) wires the reconciler's uncaught-error callbacks to `noop`, so the
+// throw never reaches the app. That is a defect in THAT adapter, tracked separately — it is not a
+// reason to stop throwing here.
 export function getHideAnimationConstants() {
     return getEnforcingNativeModule(RN_BOOT_SPLASH_MODULE_NAME).getConstants();
 }

package/build/core/types.d.ts

@@ -16,6 +16,11 @@ export type IManifest = {
         height: number;
     };
 };
+export type IHideAnimationFailureStage = 'hide' | 'animate';
+export type IHideAnimationFailure = {
+    stage: IHideAnimationFailureStage;
+    error: unknown;
+};
 export type IHideAnimationConfig = {
     manifest: IManifest;
     ready?: boolean;
@@ -24,6 +29,7 @@ export type IHideAnimationConfig = {
     brand?: IImageSourceProp;
     darkBrand?: IImageSourceProp;
     animate: () => void;
+    onError?: (failure: IHideAnimationFailure) => void;
     statusBarTranslucent?: boolean;
     navigationBarTranslucent?: boolean;
 };

package/build/react/hooks/use-hide-animation/index.js

@@ -1,29 +1,25 @@
-// React lifecycle wiring over the framework-agnostic HideAnimationController + style
-// computation (core/) — mirrors the lifecycle-bucket naming convention of
-// adapters/react/src/hooks. Faithful port of react-native-bootsplash's own useHideAnimation:
-// the controller is constructed lazily ONCE (a useRef factory, never reconstructed across
-// re-renders), native constants are read once via useState's lazy initializer (they never
-// change), and an effect with NO dependency array re-syncs the controller's config after
-// EVERY render — intentional, since `ready` flipping true only gets picked up this way.
+// Port of react-native-bootsplash's own useHideAnimation over the framework-agnostic
+// HideAnimationController + style computation in core/. The controller is built lazily ONCE
+// via a useRef factory (never reconstructed across re-renders); the effect below has NO
+// dependency array and re-syncs the controller's config after EVERY render on purpose, since
+// `ready` flipping true is only picked up that way. The native constants ride along on that same
+// once-built controller, so there is no separate useState to hold them.
 //
-// No useMemo around the style computation: upstream lists ~15 individual primitive fields
-// (manifest.logo.width, backgroundColor, ...) as its memo's deps specifically so Object.is
-// compares by VALUE, not by the `config`/`manifest` object's reference — callers construct
-// that object fresh on every render (the normal way to call this hook), so keying a memo off
-// the whole object would recompute every render anyway while looking like it memoizes.
-// Reproducing the fine-grained list isn't worth it for a splash screen shown for a couple of
-// renders at boot; computing plainly is honest about the actual cost and simpler to read.
-import { useEffect, useRef, useState } from 'react';
-import { computeHideAnimationStyles, getHideAnimationConstants, HideAnimationController, } from '../../../core/index.js';
+// No useMemo around the style computation: upstream memoizes on ~15 individual primitive
+// fields so Object.is compares by value rather than by the config/manifest object's
+// reference (callers construct that object fresh every render, so keying off the whole
+// object would recompute anyway). Not worth reproducing for a splash screen shown a couple
+// of renders at boot — computing plainly is simpler and equally cheap.
+import { useEffect, useRef } from 'react';
+import { computeHideAnimationStyles, HideAnimationController, } from '../../../core/index.js';
 export function useHideAnimation(config) {
     const controllerRef = useRef(null);
     if (controllerRef.current == null) {
         controllerRef.current = new HideAnimationController(config);
     }
     const controller = controllerRef.current;
-    const [constants] = useState(() => getHideAnimationConstants());
     useEffect(() => {
         controller.updateConfig(config);
     });
-    return computeHideAnimationStyles(config, constants, controller);
+    return computeHideAnimationStyles(config, controller.constants, controller);
 }

package/build/react/index.d.ts

@@ -1,3 +1,3 @@
 export { hide, isVisible } from '../core';
 export { useHideAnimation } from './hooks/use-hide-animation';
-export type { IHideAnimationConfig, IHideAnimationResult, IManifest, IHideConfig } from '../core';
+export type { IHideAnimationConfig, IHideAnimationFailure, IHideAnimationFailureStage, IHideAnimationResult, IManifest, IHideConfig, } from '../core';

package/build/solid/index.d.ts

@@ -0,0 +1,3 @@
+export { hide, isVisible } from '../core';
+export { createHideAnimation } from './primitives/create-hide-animation';
+export type { IHideAnimationConfig, IHideAnimationFailure, IHideAnimationFailureStage, IHideAnimationResult, IManifest, IHideConfig, } from '../core';

package/build/solid/index.js

@@ -0,0 +1,8 @@
+// @symbiote-native/splash-screen/solid: the Solid entry over the framework-agnostic core.
+// hide/isVisible carry zero lifecycle and are re-exported verbatim; createHideAnimation wraps
+// HideAnimationController + computeHideAnimationStyles with Solid's own reactivity
+// (primitives/create-hide-animation.ts) — mirrors the lifecycle-bucket naming convention of
+// adapters/solid/src/primitives (never `hooks`/`composables`/`runes`, those are React's, Vue's
+// and Svelte's terms).
+export { hide, isVisible } from '../core/index.js';
+export { createHideAnimation } from './primitives/create-hide-animation.js';

package/build/solid/primitives/create-hide-animation.d.ts

@@ -0,0 +1,3 @@
+import { type Accessor } from 'solid-js';
+import { type IHideAnimationConfig, type IHideAnimationResult } from '../../core';
+export declare function createHideAnimation(config: Accessor<IHideAnimationConfig>): Accessor<IHideAnimationResult>;

package/build/solid/primitives/create-hide-animation.js

@@ -0,0 +1,24 @@
+// Solid lifecycle wiring over the framework-agnostic HideAnimationController + style computation
+// (core/) — the Solid twin of React's useHideAnimation hook, Vue's composable and Svelte's rune.
+//
+// `primitives/` and `create*`, never `hooks/`+`use*`: Solid's ecosystem calls a composable
+// reactive function a PRIMITIVE and reserves `use*` for consuming something that already exists.
+// Full rationale in adapters/solid/src/primitives/create-color-scheme.ts.
+//
+// Takes a config ACCESSOR, not a plain value, and returns one: a Solid component body runs ONCE
+// (like Vue's setup, unlike a React hook re-running every render), so a plain config would freeze
+// at its boot value and `ready` flipping true would never be seen. The effect below re-syncs the
+// controller on every signal the accessor reads, mirroring Vue's watchEffect.
+//
+// The controller stays a plain local, never a signal: only its methods are called. It also carries
+// the native constants, read once in its constructor — so a missing RNBootSplash throws straight
+// out of the primitive body, on purpose.
+import { createEffect, createMemo } from 'solid-js';
+import { computeHideAnimationStyles, HideAnimationController, } from '../../core/index.js';
+export function createHideAnimation(config) {
+    const controller = new HideAnimationController(config());
+    createEffect(() => {
+        controller.updateConfig(config());
+    });
+    return createMemo(() => computeHideAnimationStyles(config(), controller.constants, controller));
+}

package/build/svelte/index.d.ts

@@ -0,0 +1,3 @@
+export { hide, isVisible } from '../core';
+export { useHideAnimation } from './runes/use-hide-animation.svelte';
+export type { IHideAnimationConfig, IHideAnimationFailure, IHideAnimationFailureStage, IHideAnimationResult, IManifest, IHideConfig, } from '../core';

package/build/svelte/index.js

@@ -0,0 +1,7 @@
+// @symbiote-native/splash-screen/svelte: the Svelte entry over the framework-agnostic core.
+// hide/isVisible carry zero lifecycle and are re-exported verbatim; useHideAnimation wraps
+// HideAnimationController + computeHideAnimationStyles with Svelte's own runes
+// (runes/use-hide-animation.svelte.ts) — mirrors the lifecycle-bucket naming convention of
+// adapters/svelte/src/runes (never `hooks`/`composables`, those are React's/Vue's terms).
+export { hide, isVisible } from '../core/index.js';
+export { useHideAnimation } from './runes/use-hide-animation.svelte';

package/build/svelte/runes/use-hide-animation.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type IHideAnimationConfig, type IHideAnimationResult } from '../../core';
+export declare function useHideAnimation(getConfig: () => IHideAnimationConfig): {
+    readonly current: IHideAnimationResult;
+};

package/build/svelte/runes/use-hide-animation.svelte.js

@@ -0,0 +1,24 @@
+// Svelte lifecycle wiring over the framework-agnostic HideAnimationController + style
+// computation (core/). A Svelte component's `<script>` body runs ONCE (like Vue's setup,
+// unlike a React hook re-running every render), so this takes a config GETTER, not a plain
+// value — the boxed-getter convention from use-color-scheme.svelte.ts. The controller stays
+// a plain local, not `$state`: only its methods are called, nothing needs Svelte to react to
+// the reference itself. `$effect` re-syncs the controller's config on every reactive read
+// inside `getConfig()`, mirroring Vue's `watchEffect`. The controller also carries the native
+// constants, read once in its constructor — so a missing RNBootSplash throws straight out of the
+// component's script body, on purpose.
+import { computeHideAnimationStyles, HideAnimationController, } from '../../core/index.js';
+export function useHideAnimation(getConfig) {
+    const controller = new HideAnimationController(getConfig());
+    let result = $state(computeHideAnimationStyles(getConfig(), controller.constants, controller));
+    $effect(() => {
+        const config = getConfig();
+        controller.updateConfig(config);
+        result = computeHideAnimationStyles(config, controller.constants, controller);
+    });
+    return {
+        get current() {
+            return result;
+        },
+    };
+}

package/build/vue/composables/use-hide-animation/index.js

@@ -1,21 +1,20 @@
 // Vue lifecycle wiring over the framework-agnostic HideAnimationController + style
-// computation (core/). A Vue composable's setup body runs ONCE (unlike a React hook,
-// which re-runs every render), so this takes a config GETTER, not a plain value — Vue's
-// reactivity tracks whatever reactive refs the getter reads internally and re-runs the
-// watchEffect/computed below on their change, mirroring how a React consumer would pass a
-// fresh config object on every render.
+// computation (core/). A composable's setup body runs ONCE (unlike a React hook, which
+// re-runs every render), so this takes a config GETTER, not a plain value — Vue's
+// reactivity tracks whatever reactive refs the getter reads and re-runs the
+// watchEffect/computed below on their change, mirroring a React consumer passing a fresh
+// config object every render.
 //
-// The controller is a plain local, not a Vue ref: nothing needs Vue to react to the
-// controller reference itself (only its methods are called), so wrapping it would only
-// add an unnecessary reactive Proxy — same identity discipline as
-// `use-color-scheme.ts`'s subscription handle.
+// The controller is a plain local, not a Vue ref: only its methods are called, so wrapping
+// it would only add an unnecessary reactive Proxy — same identity discipline as
+// `use-color-scheme.ts`'s subscription handle. It also carries the native constants, read once in
+// its constructor — so a missing RNBootSplash throws straight out of setup, on purpose.
 import { computed, watchEffect } from '@vue/runtime-core';
-import { computeHideAnimationStyles, getHideAnimationConstants, HideAnimationController, } from '../../../core/index.js';
+import { computeHideAnimationStyles, HideAnimationController, } from '../../../core/index.js';
 export function useHideAnimation(getConfig) {
     const controller = new HideAnimationController(getConfig());
-    const constants = getHideAnimationConstants();
     watchEffect(() => {
         controller.updateConfig(getConfig());
     });
-    return computed(() => computeHideAnimationStyles(getConfig(), constants, controller));
+    return computed(() => computeHideAnimationStyles(getConfig(), controller.constants, controller));
 }

package/build/vue/index.d.ts

@@ -1,3 +1,3 @@
 export { hide, isVisible } from '../core';
 export { useHideAnimation } from './composables/use-hide-animation';
-export type { IHideAnimationConfig, IHideAnimationResult, IManifest, IHideConfig } from '../core';
+export type { IHideAnimationConfig, IHideAnimationFailure, IHideAnimationFailureStage, IHideAnimationResult, IManifest, IHideConfig, } from '../core';

package/build-ngc/angular/index.d.ts

@@ -1,3 +1,3 @@
 export { hide, isVisible } from '../core';
 export { HideAnimationService } from './services/hide-animation.service';
-export type { IHideAnimationConfig, IHideAnimationResult, IManifest, IHideConfig } from '../core';
+export type { IHideAnimationConfig, IHideAnimationFailure, IHideAnimationFailureStage, IHideAnimationResult, IManifest, IHideConfig, } from '../core';

package/build-ngc/angular/services/hide-animation.service/index.js

@@ -1,31 +1,32 @@
-import { computed, effect, inject, Injectable, Injector } from '@angular/core';
-import { computeHideAnimationStyles, getHideAnimationConstants, HideAnimationController, } from '../../../core';
+import { computed, effect, inject, Injectable, Injector, } from '@angular/core';
+import { computeHideAnimationStyles, HideAnimationController, } from '../../../core';
 import * as i0 from "@angular/core";
 // Angular twin of React's `useHideAnimation` hook and Vue's `useHideAnimation` composable.
-// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
-// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
-// inside an injection context) with a GETTER, so it can keep reading the caller's own signals —
-// the same reason Vue's composable also takes a getter rather than a value: there is no
-// re-render/re-setup cycle here to hang a fresh read off of.
+// Angular has no per-instance hook, so `connect()` stands in for it: call it ONCE (typically
+// from a component's field initializer, inside an injection context) with a GETTER so it can
+// keep reading the caller's own signals — same reason Vue's composable takes a getter too.
 //
 //   readonly hideAnimation = inject(HideAnimationService).connect(() => this.config());
 //   // template: [style]="hideAnimation().container.style", (layout)="..." etc.
 export class HideAnimationService {
-    // Captured in the constructor (itself always run inside an injection context by Angular's
-    // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
-    // code that is not, on its own, an active injection context — mirrors create-tunnel.ts's
-    // `TunnelOut`, which passes its own captured `Injector` to `effect()` for the same reason.
+    // Captured in the constructor (always run inside an injection context by Angular's own DI)
+    // so `connect()` can create an `effect()` even when called from field-initializer code that
+    // isn't itself an active injection context — mirrors create-tunnel.ts's `TunnelOut`.
     injector = inject(Injector);
+    // The controller reads the native constants in its constructor, so a missing RNBootSplash
+    // throws out of connect() and aborts the host component's construction — deliberately: that
+    // is a build error, and a splash quietly stuck in light mode would ship unnoticed.
     connect(getConfig) {
         const controller = new HideAnimationController(getConfig());
-        const constants = getHideAnimationConstants();
-        effect(() => controller.updateConfig(getConfig()), { injector: this.injector });
-        return computed(() => computeHideAnimationStyles(getConfig(), constants, controller));
+        effect(() => controller.updateConfig(getConfig()), {
+            injector: this.injector,
+        });
+        return computed(() => computeHideAnimationStyles(getConfig(), controller.constants, controller));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: HideAnimationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: HideAnimationService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: HideAnimationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: HideAnimationService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: HideAnimationService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: HideAnimationService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });

package/build-ngc/angular/services/hide-animation.service/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/hide-animation.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAe,MAAM,eAAe,CAAC;AAC5F,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,uBAAuB,GAGxB,MAAM,eAAe,CAAC;;AAEvB,2FAA2F;AAC3F,4FAA4F;AAC5F,+FAA+F;AAC/F,gGAAgG;AAChG,wFAAwF;AACxF,6DAA6D;AAC7D,EAAE;AACF,wFAAwF;AACxF,gFAAgF;AAEhF,MAAM,OAAO,oBAAoB;IAC/B,0FAA0F;IAC1F,gGAAgG;IAChG,yFAAyF;IACzF,2FAA2F;IAC1E,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,OAAO,CAAC,SAAqC;QAC3C,MAAM,UAAU,GAAG,IAAI,uBAAuB,CAAC,SAAS,EAAE,CAAC,CAAC;QAC5D,MAAM,SAAS,GAAG,yBAAyB,EAAE,CAAC;QAE9C,MAAM,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QAEhF,OAAO,QAAQ,CAAC,GAAG,EAAE,CAAC,0BAA0B,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;IACxF,CAAC;uGAdU,oBAAoB;2GAApB,oBAAoB,cADP,MAAM;;2FACnB,oBAAoB;kBADhC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/hide-animation.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,MAAM,EACN,MAAM,EACN,UAAU,EACV,QAAQ,GAET,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,GAGxB,MAAM,eAAe,CAAC;;AAEvB,2FAA2F;AAC3F,6FAA6F;AAC7F,6FAA6F;AAC7F,2FAA2F;AAC3F,EAAE;AACF,wFAAwF;AACxF,gFAAgF;AAEhF,MAAM,OAAO,oBAAoB;IAC/B,2FAA2F;IAC3F,4FAA4F;IAC5F,qFAAqF;IACpE,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,0FAA0F;IAC1F,4FAA4F;IAC5F,mFAAmF;IACnF,OAAO,CAAC,SAAqC;QAC3C,MAAM,UAAU,GAAG,IAAI,uBAAuB,CAAC,SAAS,EAAE,CAAC,CAAC;QAE5D,MAAM,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,SAAS,EAAE,CAAC,EAAE;YACjD,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC,CAAC;QAEH,OAAO,QAAQ,CAAC,GAAG,EAAE,CACnB,0BAA0B,CAAC,SAAS,EAAE,EAAE,UAAU,CAAC,SAAS,EAAE,UAAU,CAAC,CAC1E,CAAC;IACJ,CAAC;uGAnBU,oBAAoB;2GAApB,oBAAoB,cADP,MAAM;;2FACnB,oBAAoB;kBADhC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

package/build-ngc/core/hide-animation-controller.d.ts

@@ -1,6 +1,8 @@
-import type { IHideAnimationConfig } from './types';
+import type { IHideAnimationConfig, IHideAnimationConstants } from './types';
 export declare class HideAnimationController {
+    readonly constants: IHideAnimationConstants;
     private readonly readiness;
+    private readonly reportFailure;
     constructor(config: IHideAnimationConfig);
     updateConfig(config: IHideAnimationConfig): void;
     readonly onContainerLayout: () => void;

package/build-ngc/core/hide-animation-controller.js

@@ -1,12 +1,29 @@
+import { dlog } from '@symbiote-native/engine';
 import { hide } from './hide';
+import { getHideAnimationConstants } from './native-module';
 // Faithful port of react-native-bootsplash's useHideAnimation readiness gate (its
 // src/index.ts): hide() fires exactly once, after layout + both images (if requested) +
 // the caller all report ready, then the caller's own fade-out `animate()` runs. logoReady/
 // brandReady are captured ONCE at construction (mirrors the original's useRef factory,
 // evaluated only on first render) — a config that later drops its logo/brand source does
 // NOT retroactively flip readiness back on, only updateConfig's animate/userReady do.
+//
+// DELIBERATE DIVERGENCE from upstream, one place only: upstream swallows a rejected hide() with a
+// bare `.catch(() => {})`, which strands the app under a splash it can no longer dismiss (see
+// maybeRunAnimate). We fail open and report instead. Everything else, the unguarded constants read
+// included, stays a faithful port.
 export class HideAnimationController {
+    // Read once here rather than once per adapter: the values never change over a splash's lifetime.
+    // Unguarded on purpose — a missing RNBootSplash is a build error that must stay loud, see
+    // native-module.ts for the full reasoning before wrapping this in anything.
+    constants;
     readiness;
+    // dlog is DEBUG-gated, so it is the developer's seam, not the report: config.onError is the
+    // channel the app actually hears about this on.
+    reportFailure = (failure) => {
+        dlog(`splash-screen: hide animation degraded at "${failure.stage}": ${String(failure.error)}`);
+        this.readiness.onError?.(failure);
+    };
     constructor(config) {
         this.readiness = {
             layoutReady: false,
@@ -14,11 +31,14 @@ export class HideAnimationController {
             brandReady: config.manifest.brand == null || config.brand == null,
             userReady: config.ready ?? true,
             animate: config.animate,
+            onError: config.onError,
             animateHasBeenCalled: false,
         };
+        this.constants = getHideAnimationConstants();
     }
     updateConfig(config) {
         this.readiness.animate = config.animate;
+        this.readiness.onError = config.onError;
         this.readiness.userReady = config.ready ?? true;
         this.maybeRunAnimate();
     }
@@ -42,9 +62,22 @@ export class HideAnimationController {
             state.userReady &&
             !state.animateHasBeenCalled) {
             state.animateHasBeenCalled = true;
+            // Fail open. animateHasBeenCalled is already true by the time hide() settles, so the gate
+            // is shut for good: on a rejection there is no readiness callback left that could retry,
+            // and skipping animate() means the caller's splash overlay never fades out — the app sits
+            // under it forever. Running animate() anyway costs at worst a fade over a native splash
+            // that is still up; not running it costs the whole app.
             hide({ fade: false })
-                .then(() => state.animate())
-                .catch(() => { });
+                .catch((error) => {
+                this.reportFailure({ stage: 'hide', error });
+            })
+                .then(() => {
+                state.animate();
+            })
+                .catch((error) => {
+                // The caller's own animation throwing must not become an unhandled rejection either.
+                this.reportFailure({ stage: 'animate', error });
+            });
         }
     }
 }

package/build-ngc/core/hide-animation-controller.js.map

@@ -1 +1 @@
-{"version":3,"file":"hide-animation-controller.js","sourceRoot":"","sources":["../../src/core/hide-animation-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAY9B,kFAAkF;AAClF,wFAAwF;AACxF,2FAA2F;AAC3F,uFAAuF;AACvF,yFAAyF;AACzF,sFAAsF;AACtF,MAAM,OAAO,uBAAuB;IACjB,SAAS,CAAkB;IAE5C,YAAY,MAA4B;QACtC,IAAI,CAAC,SAAS,GAAG;YACf,WAAW,EAAE,KAAK;YAClB,SAAS,EAAE,MAAM,CAAC,IAAI,IAAI,IAAI;YAC9B,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,IAAI,IAAI,IAAI,MAAM,CAAC,KAAK,IAAI,IAAI;YACjE,SAAS,EAAE,MAAM,CAAC,KAAK,IAAI,IAAI;YAC/B,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,oBAAoB,EAAE,KAAK;SAC5B,CAAC;IACJ,CAAC;IAED,YAAY,CAAC,MAA4B;QACvC,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC;QACxC,IAAI,CAAC,SAAS,CAAC,SAAS,GAAG,MAAM,CAAC,KAAK,IAAI,IAAI,CAAC;QAChD,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC;IAEQ,iBAAiB,GAAG,GAAS,EAAE;QACtC,IAAI,CAAC,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC;QAClC,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC,CAAC;IAEO,aAAa,GAAG,GAAS,EAAE;QAClC,IAAI,CAAC,SAAS,CAAC,SAAS,GAAG,IAAI,CAAC;QAChC,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC,CAAC;IAEO,cAAc,GAAG,GAAS,EAAE;QACnC,IAAI,CAAC,SAAS,CAAC,UAAU,GAAG,IAAI,CAAC;QACjC,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC,CAAC;IAEM,eAAe;QACrB,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC;QAE7B,IACE,KAAK,CAAC,WAAW;YACjB,KAAK,CAAC,SAAS;YACf,KAAK,CAAC,UAAU;YAChB,KAAK,CAAC,SAAS;YACf,CAAC,KAAK,CAAC,oBAAoB,EAC3B,CAAC;YACD,KAAK,CAAC,oBAAoB,GAAG,IAAI,CAAC;YAClC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;iBAClB,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;iBAC3B,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;CACF"}
+{"version":3,"file":"hide-animation-controller.js","sourceRoot":"","sources":["../../src/core/hide-animation-controller.ts"],"names":[],"mappings":"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"}