@symbiote-native/splash-screen 0.1.1

package/react-native.config.cjs

@@ -0,0 +1,39 @@
+const fs = require('fs');
+const path = require('path');
+
+const PACKAGE_NAME = '@symbiote-native/splash-screen';
+const NATIVE_SPLASH_SCREEN_PACKAGE = 'react-native-bootsplash';
+
+function findCliDependencyRoot() {
+  let current = process.cwd();
+
+  while (true) {
+    const candidate = path.join(current, 'node_modules', ...PACKAGE_NAME.split('/'));
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return __dirname;
+    }
+
+    current = parent;
+  }
+}
+
+const cliDependencyRoot = findCliDependencyRoot();
+const nativeSplashScreenRoot = path.dirname(
+  require.resolve(`${NATIVE_SPLASH_SCREEN_PACKAGE}/package.json`),
+);
+
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: path.relative(cliDependencyRoot, path.join(nativeSplashScreenRoot, 'android')),
+      },
+      ios: {},
+    },
+  },
+};

package/src/angular/index.ts

@@ -0,0 +1,6 @@
+// hide()/isVisible() carry zero framework dependency — re-exported verbatim from core, same as
+// every other adapter. HideAnimationService is the Angular-only lifecycle half; the state
+// machine, style computation, and native-constants read all live in core, shared with React/Vue.
+export { hide, isVisible } from '../core';
+export { HideAnimationService } from './services/hide-animation.service';
+export type { IHideAnimationConfig, IHideAnimationResult, IManifest, IHideConfig } from '../core';

package/src/angular/services/hide-animation.service.test.ts

@@ -0,0 +1,205 @@
+// Co-located Angular-driven test (ADR 0025) for HideAnimationService. Mounts a real host
+// component through @symbiote-native/angular so `connect()` runs the same way an app would call
+// it — inside the component's own injection context — and drives the returned signal through a
+// full mount/unmount lifecycle rather than poking the service in isolation.
+
+import '@angular/compiler';
+import { Component, inject, signal, type Signal } from '@angular/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/angular';
+import { flattenStyle } from '@symbiote-native/engine';
+import { installFabric } from '@symbiote-native/test-utils';
+import type { IImageSourceProp } from '@symbiote-native/components';
+import { hide as mockedHide } from 'react-native-bootsplash';
+import type { IHideAnimationResult } from '../../core';
+import { HideAnimationService } from './hide-animation.service';
+
+vi.mock('react-native-bootsplash', () => ({
+  hide: vi.fn(() => Promise.resolve()),
+  isVisible: vi.fn(() => true),
+}));
+
+function isPresent<T>(value: unknown): value is T {
+  return value !== null && value !== undefined;
+}
+
+const FAKE_NATIVE_MODULE = {
+  getConstants: () => ({ darkModeEnabled: false }),
+  hide: vi.fn(() => Promise.resolve()),
+  isVisible: () => true,
+};
+
+const registeredNativeModules: Record<string, unknown> = { RNBootSplash: FAKE_NATIVE_MODULE };
+
+const ROOT_TAG = 940;
+const fabric = installFabric();
+const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+const settle = async (): Promise<void> => {
+  await tick();
+  await tick();
+};
+
+const MANIFEST = {
+  background: '#ffffff',
+  logo: { width: 100, height: 100 },
+  brand: { bottom: 40, width: 80, height: 20 },
+};
+
+const LOGO_SOURCE: IImageSourceProp = { uri: 'logo.png' };
+const BRAND_SOURCE: IImageSourceProp = { uri: 'brand.png' };
+
+let capturedResult: Signal<IHideAnimationResult> | undefined;
+let capturedAnimate: ReturnType<typeof vi.fn> | undefined;
+let capturedReady: ReturnType<typeof signal<boolean>> | undefined;
+
+@Component({
+  selector: 'symbiote-hide-animation-host',
+  standalone: true,
+  template: '',
+})
+class HideAnimationHost {
+  readonly ready = signal(true);
+  readonly animate = vi.fn();
+
+  readonly hideAnimation = inject(HideAnimationService).connect(() => ({
+    manifest: MANIFEST,
+    ready: this.ready(),
+    logo: LOGO_SOURCE,
+    brand: BRAND_SOURCE,
+    animate: this.animate,
+  }));
+
+  constructor() {
+    capturedResult = this.hideAnimation;
+    capturedAnimate = this.animate;
+    capturedReady = this.ready;
+  }
+}
+
+@Component({
+  selector: 'symbiote-hide-animation-no-logo-host',
+  standalone: true,
+  template: '',
+})
+class HideAnimationNoLogoHost {
+  readonly animate = vi.fn();
+
+  readonly hideAnimation = inject(HideAnimationService).connect(() => ({
+    manifest: MANIFEST,
+    logo: undefined,
+    brand: undefined,
+    animate: this.animate,
+  }));
+
+  constructor() {
+    capturedResult = this.hideAnimation;
+    capturedAnimate = this.animate;
+  }
+}
+
+beforeEach(() => {
+  globalThis.__turboModuleProxy = <T>(name: string): T | null => {
+    const module = registeredNativeModules[name];
+    return isPresent<T>(module) ? module : null;
+  };
+  capturedResult = undefined;
+  capturedAnimate = undefined;
+  capturedReady = undefined;
+});
+
+afterEach(() => {
+  unmount(ROOT_TAG);
+  fabric.reset();
+  globalThis.__turboModuleProxy = undefined;
+  vi.clearAllMocks();
+});
+
+describe('HideAnimationService.connect', () => {
+  it('reports the container/logo/brand shapes for a config with both logo and brand', async () => {
+    mount(ROOT_TAG, HideAnimationHost);
+    await settle();
+
+    const result = capturedResult?.();
+    if (result === undefined) throw new Error('hideAnimation signal was not captured');
+
+    expect(flattenStyle(result.container.style).backgroundColor).toBe(MANIFEST.background);
+    expect(result.container.onLayout).toBeTypeOf('function');
+
+    expect(result.logo.source).toBe(LOGO_SOURCE);
+    expect(flattenStyle(result.logo.style)).toEqual({
+      width: MANIFEST.logo.width,
+      height: MANIFEST.logo.height,
+    });
+    expect(result.logo.onLoadEnd).toBeTypeOf('function');
+
+    expect(result.brand.source).toBe(BRAND_SOURCE);
+    expect(flattenStyle(result.brand.style)).toMatchObject({
+      bottom: MANIFEST.brand.bottom,
+      width: MANIFEST.brand.width,
+      height: MANIFEST.brand.height,
+    });
+    expect(result.brand.onLoadEnd).toBeTypeOf('function');
+  });
+
+  it('fires hide() exactly once, only after layout + logo + brand + ready are all satisfied', async () => {
+    mount(ROOT_TAG, HideAnimationHost);
+    await settle();
+
+    const result = capturedResult;
+    if (result === undefined || capturedAnimate === undefined) {
+      throw new Error('hideAnimation signal was not captured');
+    }
+
+    result().container.onLayout();
+    expect(mockedHide).not.toHaveBeenCalled();
+
+    result().logo.onLoadEnd?.();
+    expect(mockedHide).not.toHaveBeenCalled();
+
+    // Brand is the last gate: only once it reports load-end does hide() fire.
+    result().brand.onLoadEnd?.();
+    await settle();
+
+    expect(mockedHide).toHaveBeenCalledOnce();
+    expect(mockedHide).toHaveBeenCalledWith({ fade: false });
+    expect(capturedAnimate).toHaveBeenCalledOnce();
+  });
+
+  it('does not fire hide() again after it has already fired', async () => {
+    mount(ROOT_TAG, HideAnimationHost);
+    await settle();
+
+    const result = capturedResult;
+    if (result === undefined || capturedReady === undefined) {
+      throw new Error('hideAnimation signal was not captured');
+    }
+
+    result().container.onLayout();
+    result().logo.onLoadEnd?.();
+    result().brand.onLoadEnd?.();
+    await settle();
+    expect(mockedHide).toHaveBeenCalledOnce();
+
+    // A later config change (ready flips off then back on) re-runs the effect's updateConfig,
+    // but the controller's own animateHasBeenCalled guard keeps hide() from firing twice.
+    capturedReady.set(false);
+    await settle();
+    capturedReady.set(true);
+    await settle();
+
+    expect(mockedHide).toHaveBeenCalledOnce();
+  });
+
+  it('reports source -1 and no onLoadEnd when config.logo is omitted', async () => {
+    mount(ROOT_TAG, HideAnimationNoLogoHost);
+    await settle();
+
+    const result = capturedResult?.();
+    if (result === undefined) throw new Error('hideAnimation signal was not captured');
+
+    expect(result.logo.source).toBe(-1);
+    expect(result.logo.onLoadEnd).toBeUndefined();
+    expect(result.brand.source).toBe(-1);
+    expect(result.brand.onLoadEnd).toBeUndefined();
+  });
+});

package/src/angular/services/hide-animation.service.ts

@@ -0,0 +1,35 @@
+import { computed, effect, inject, Injectable, Injector, type Signal } from '@angular/core';
+import {
+  computeHideAnimationStyles,
+  getHideAnimationConstants,
+  HideAnimationController,
+  type IHideAnimationConfig,
+  type IHideAnimationResult,
+} from '../../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.
+//
+//   readonly hideAnimation = inject(HideAnimationService).connect(() => this.config());
+//   // template: [style]="hideAnimation().container.style", (layout)="..." etc.
+@Injectable({ providedIn: 'root' })
+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.
+  private readonly injector = inject(Injector);
+
+  connect(getConfig: () => IHideAnimationConfig): Signal<IHideAnimationResult> {
+    const controller = new HideAnimationController(getConfig());
+    const constants = getHideAnimationConstants();
+
+    effect(() => controller.updateConfig(getConfig()), { injector: this.injector });
+
+    return computed(() => computeHideAnimationStyles(getConfig(), constants, controller));
+  }
+}

package/src/core/compute-hide-animation-styles.ts

@@ -0,0 +1,111 @@
+import { Platform } from '@symbiote-native/engine';
+import { isEdgeToEdge } from 'react-native-is-edge-to-edge';
+import type { HideAnimationController } from './hide-animation-controller';
+import type {
+  IHideAnimationConfig,
+  IHideAnimationConstants,
+  IHideAnimationImageProps,
+  IHideAnimationResult,
+} from './types';
+
+// react-native-bootsplash also branches on Platform.OS === 'web' here (react-native-web
+// support); SymbioteNative ships iOS + Android only, so that branch is dropped rather than
+// ported dead.
+const IS_EDGE_TO_EDGE = isEdgeToEdge();
+
+const SKIPPED_IMAGE_SOURCE = -1;
+
+// Faithful port of react-native-bootsplash's useHideAnimation style computation (its
+// src/index.ts useMemo body): container/logo/brand prop bags the app binds to its own
+// View/Image, unchanged across React/Vue/Angular since none of this touches lifecycle.
+export function computeHideAnimationStyles(
+  config: IHideAnimationConfig,
+  constants: IHideAnimationConstants,
+  controller: HideAnimationController,
+): IHideAnimationResult {
+  const { manifest, statusBarTranslucent, navigationBarTranslucent } = config;
+  const {
+    darkModeEnabled,
+    logoSizeRatio = 1,
+    navigationBarHeight = 0,
+    statusBarHeight = 0,
+  } = constants;
+
+  const skipLogo = config.logo == null;
+  const skipBrand = manifest.brand == null || config.brand == null;
+
+  const backgroundColor =
+    darkModeEnabled && manifest.darkBackground != null
+      ? manifest.darkBackground
+      : manifest.background;
+
+  const logoSource = skipLogo
+    ? undefined
+    : darkModeEnabled && config.darkLogo != null
+      ? config.darkLogo
+      : config.logo;
+
+  const brandSource = skipBrand
+    ? undefined
+    : darkModeEnabled && config.darkBrand != null
+      ? config.darkBrand
+      : config.brand;
+
+  const isAndroid = Platform.OS === 'android';
+
+  const container = {
+    style: {
+      alignItems: 'center' as const,
+      backgroundColor,
+      justifyContent: 'center' as const,
+      position: 'absolute' as const,
+      left: 0,
+      right: 0,
+      top: 0,
+      bottom: 0,
+      marginTop:
+        isAndroid && !IS_EDGE_TO_EDGE && !(statusBarTranslucent ?? false)
+          ? -statusBarHeight
+          : undefined,
+      marginBottom:
+        isAndroid && !IS_EDGE_TO_EDGE && !(navigationBarTranslucent ?? false)
+          ? -navigationBarHeight
+          : undefined,
+    },
+    onLayout: controller.onContainerLayout,
+  };
+
+  const logoSizeMultiplier = isAndroid ? logoSizeRatio : 1;
+
+  const logo: IHideAnimationImageProps =
+    logoSource == null
+      ? { source: SKIPPED_IMAGE_SOURCE }
+      : {
+          source: logoSource,
+          fadeDuration: 0,
+          resizeMode: 'contain',
+          style: {
+            width: manifest.logo.width * logoSizeMultiplier,
+            height: manifest.logo.height * logoSizeMultiplier,
+          },
+          onLoadEnd: controller.onLogoLoadEnd,
+        };
+
+  const brand: IHideAnimationImageProps =
+    brandSource == null || manifest.brand == null
+      ? { source: SKIPPED_IMAGE_SOURCE }
+      : {
+          source: brandSource,
+          fadeDuration: 0,
+          resizeMode: 'contain',
+          style: {
+            position: 'absolute',
+            bottom: manifest.brand.bottom,
+            width: manifest.brand.width,
+            height: manifest.brand.height,
+          },
+          onLoadEnd: controller.onBrandLoadEnd,
+        };
+
+  return { container, logo, brand };
+}

package/src/core/hide-animation-controller.ts

@@ -0,0 +1,70 @@
+import { hide } from './hide';
+import type { IHideAnimationConfig } from './types';
+
+type IReadinessState = {
+  layoutReady: boolean;
+  logoReady: boolean;
+  brandReady: boolean;
+  userReady: boolean;
+  animate: () => void;
+  animateHasBeenCalled: boolean;
+};
+
+// 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.
+export class HideAnimationController {
+  private readonly readiness: IReadinessState;
+
+  constructor(config: IHideAnimationConfig) {
+    this.readiness = {
+      layoutReady: false,
+      logoReady: config.logo == null,
+      brandReady: config.manifest.brand == null || config.brand == null,
+      userReady: config.ready ?? true,
+      animate: config.animate,
+      animateHasBeenCalled: false,
+    };
+  }
+
+  updateConfig(config: IHideAnimationConfig): void {
+    this.readiness.animate = config.animate;
+    this.readiness.userReady = config.ready ?? true;
+    this.maybeRunAnimate();
+  }
+
+  readonly onContainerLayout = (): void => {
+    this.readiness.layoutReady = true;
+    this.maybeRunAnimate();
+  };
+
+  readonly onLogoLoadEnd = (): void => {
+    this.readiness.logoReady = true;
+    this.maybeRunAnimate();
+  };
+
+  readonly onBrandLoadEnd = (): void => {
+    this.readiness.brandReady = true;
+    this.maybeRunAnimate();
+  };
+
+  private maybeRunAnimate(): void {
+    const state = this.readiness;
+
+    if (
+      state.layoutReady &&
+      state.logoReady &&
+      state.brandReady &&
+      state.userReady &&
+      !state.animateHasBeenCalled
+    ) {
+      state.animateHasBeenCalled = true;
+      hide({ fade: false })
+        .then(() => state.animate())
+        .catch(() => {});
+    }
+  }
+}

package/src/core/hide.ts

@@ -0,0 +1,4 @@
+// hide()/isVisible() carry zero React dependency upstream (react-native-bootsplash's own
+// src/index.ts calls straight into its TurboModule) — framework-agnostic as-is, so every
+// adapter re-exports this verbatim rather than re-wrapping it.
+export { hide, isVisible } from 'react-native-bootsplash';

package/src/core/index.ts

@@ -0,0 +1,13 @@
+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';

package/src/core/native-module.ts

@@ -0,0 +1,19 @@
+// react-native-bootsplash's package.json ships an `exports` map that only opens `.`,
+// `./expo`, `./package.json`, `./app.plugin.js` — its internal TurboModule spec
+// (dist/commonjs/specs/NativeRNBootSplash) is NOT a published subpath, so a deep import
+// would throw ERR_PACKAGE_PATH_NOT_EXPORTED. getEnforcingNativeModule reads the same
+// global TurboModule proxy the spec itself reads (by name), sidestepping the exports map
+// entirely — this is how we reach getConstants(), which the package's public JS API
+// (hide/isVisible/useHideAnimation) never exposes directly.
+import { getEnforcingNativeModule } from '@symbiote-native/engine';
+import type { IHideAnimationConstants } from './types';
+
+const RN_BOOT_SPLASH_MODULE_NAME = 'RNBootSplash';
+
+type IRNBootSplashSpec = {
+  getConstants(): IHideAnimationConstants;
+};
+
+export function getHideAnimationConstants(): IHideAnimationConstants {
+  return getEnforcingNativeModule<IRNBootSplashSpec>(RN_BOOT_SPLASH_MODULE_NAME).getConstants();
+}

package/src/core/types.ts

@@ -0,0 +1,62 @@
+import type { IImageSourceProp, IResizeMode } from '@symbiote-native/components';
+import type { IStyleProp, IViewStyle } from '@symbiote-native/engine';
+
+export type IHideConfig = {
+  fade?: boolean;
+};
+
+export type IManifest = {
+  background: string;
+  darkBackground?: string;
+  logo: {
+    width: number;
+    height: number;
+  };
+  brand?: {
+    bottom: number;
+    width: number;
+    height: number;
+  };
+};
+
+export type IHideAnimationConfig = {
+  manifest: IManifest;
+  ready?: boolean;
+
+  logo?: IImageSourceProp;
+  darkLogo?: IImageSourceProp;
+  brand?: IImageSourceProp;
+  darkBrand?: IImageSourceProp;
+
+  animate: () => void;
+
+  statusBarTranslucent?: boolean;
+  navigationBarTranslucent?: boolean;
+};
+
+export type IHideAnimationContainerProps = {
+  style: IStyleProp<IViewStyle>;
+  onLayout: () => void;
+};
+
+export type IHideAnimationImageProps = {
+  source: IImageSourceProp;
+  fadeDuration?: number;
+  resizeMode?: IResizeMode;
+  style?: IStyleProp<IViewStyle>;
+  onLoadEnd?: () => void;
+};
+
+export type IHideAnimationResult = {
+  container: IHideAnimationContainerProps;
+  logo: IHideAnimationImageProps;
+  brand: IHideAnimationImageProps;
+};
+
+// Mirrors react-native-bootsplash's NativeRNBootSplash Spec.getConstants() return shape.
+export type IHideAnimationConstants = {
+  darkModeEnabled: boolean;
+  logoSizeRatio?: number;
+  navigationBarHeight?: number;
+  statusBarHeight?: number;
+};

package/src/react/hooks/use-hide-animation.test.tsx

@@ -0,0 +1,114 @@
+// Co-located React-driven test (ADR 0025) for useHideAnimation. Mocks react-native-bootsplash's
+// hide()/isVisible() (imported straight from the npm package by core/hide.ts) and installs a
+// fake __turboModuleProxy so getHideAnimationConstants() resolves without a real native host.
+
+import { createElement, type ReactElement } from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount, View } from '@symbiote-native/react';
+import { installFabric } from '@symbiote-native/test-utils';
+import { useHideAnimation } from './use-hide-animation';
+import type { IHideAnimationConfig, IHideAnimationResult, IManifest } from '../../core';
+
+vi.mock('react-native-bootsplash', () => ({
+  hide: vi.fn(() => Promise.resolve()),
+  isVisible: vi.fn(() => true),
+}));
+
+const ROOT_TAG = 900;
+
+const FAKE_NATIVE_MODULE = { getConstants: () => ({ darkModeEnabled: false }) };
+
+function isPresent<T>(value: unknown): value is T {
+  return value !== null && value !== undefined;
+}
+
+Object.assign(globalThis, {
+  __turboModuleProxy: <T,>(name: string): T | null =>
+    name === 'RNBootSplash' && isPresent<T>(FAKE_NATIVE_MODULE) ? FAKE_NATIVE_MODULE : null,
+});
+
+const MANIFEST: IManifest = { background: '#fff', logo: { width: 100, height: 100 } };
+
+const results: IHideAnimationResult[] = [];
+
+function Probe(props: { config: IHideAnimationConfig }): ReactElement {
+  results.push(useHideAnimation(props.config));
+  return createElement(View);
+}
+
+const fabric = installFabric();
+
+beforeEach(() => {
+  fabric.reset();
+  results.length = 0;
+  vi.clearAllMocks();
+});
+
+afterEach(() => unmount(ROOT_TAG));
+
+describe('useHideAnimation', () => {
+  it('reports the skip sentinel and no onLoadEnd when logo is omitted', () => {
+    mount(ROOT_TAG, createElement(Probe, { config: { manifest: MANIFEST, animate: () => {} } }));
+
+    const last = results[results.length - 1];
+    expect(last.logo.source).toBe(-1);
+    expect(last.logo.onLoadEnd).toBeUndefined();
+  });
+
+  it('returns the full logo/brand shape when both are provided', () => {
+    const config: IHideAnimationConfig = {
+      manifest: { ...MANIFEST, brand: { bottom: 20, width: 60, height: 20 } },
+      logo: 123,
+      brand: 456,
+      animate: () => {},
+    };
+
+    mount(ROOT_TAG, createElement(Probe, { config }));
+
+    const last = results[results.length - 1];
+    expect(last.logo.source).toBe(123);
+    expect(last.logo.resizeMode).toBe('contain');
+    expect(last.brand.source).toBe(456);
+    expect(last.brand.resizeMode).toBe('contain');
+  });
+
+  it('hides exactly once, only after layout + logo load-end both resolve', async () => {
+    const { hide } = await import('react-native-bootsplash');
+    let animateCalls = 0;
+    const config: IHideAnimationConfig = {
+      manifest: MANIFEST,
+      logo: 1,
+      ready: true,
+      animate: () => {
+        animateCalls += 1;
+      },
+    };
+
+    mount(ROOT_TAG, createElement(Probe, { config }));
+    const result = results[results.length - 1];
+
+    expect(hide).not.toHaveBeenCalled();
+    result.container.onLayout();
+    expect(hide).not.toHaveBeenCalled();
+
+    result.logo.onLoadEnd?.();
+
+    expect(hide).toHaveBeenCalledTimes(1);
+    expect(hide).toHaveBeenCalledWith({ fade: false });
+    await vi.waitFor(() => expect(animateCalls).toBe(1));
+  });
+
+  it('does not hide again once already triggered', async () => {
+    const { hide } = await import('react-native-bootsplash');
+    const config: IHideAnimationConfig = { manifest: MANIFEST, ready: true, animate: () => {} };
+
+    mount(ROOT_TAG, createElement(Probe, { config }));
+    const result = results[results.length - 1];
+
+    result.container.onLayout();
+    await vi.waitFor(() => expect(hide).toHaveBeenCalledTimes(1));
+
+    result.container.onLayout();
+    expect(hide).toHaveBeenCalledTimes(1);
+  });
+});