@symbiote-native/splash-screen 0.0.0-canary-20260724081123

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+# @symbiote-native/splash-screen
+
+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
+(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.
+
+## Install
+
+```bash
+npm install @symbiote-native/splash-screen
+```
+
+Only this package — never `react-native-bootsplash` directly. `@symbiote-native/splash-screen`
+depends on it and ships as the sole autolinked native proxy (`react-native.config.cjs` +
+`symbiote-splash-screen.podspec`), the same one-dependency packaging as `@symbiote-native/slider`
+(see the `symbiote-third-party-native-view` skill).
+
+## Shape
+
+```
+src/core/       hide()/isVisible() (re-exported as-is — zero React upstream), the readiness-gate
+                HideAnimationController, and computeHideAnimationStyles: a faithful port of
+                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/angular/    @symbiote-native/splash-screen/angular — HideAnimationService (signals)
+```
+
+`hide()`/`isVisible()` are re-exported straight from `react-native-bootsplash` since the upstream
+functions already have zero React dependency. `useHideAnimation` returns `{ container, logo,
+brand }` prop bags the app binds to its own `View`/`Image` — the same contract upstream ships,
+kept identical across adapters (Angular's service returns the same three values as Signals).
+
+## Required manual step: wiring the native init call
+
+The upstream asset generator (see below) does **not** automate this — you must add it yourself,
+in every app that uses this package:
+
+**iOS** — `ios/YourApp/AppDelegate.swift`, inside `customize(_ rootView:)`:
+
+```swift
+import RNBootSplash
+
+override func customize(_ rootView: RCTRootView) {
+  super.customize(rootView)
+  RNBootSplash.initWithStoryboard("BootSplash", rootView: rootView)
+}
+```
+
+**Android** — `android/app/src/main/java/.../MainActivity.kt`, inside `onCreate`:
+
+```kotlin
+import com.zoontek.rnbootsplash.RNBootSplash
+
+override fun onCreate(savedInstanceState: Bundle?) {
+  RNBootSplash.init(this, R.style.BootTheme)
+  super.onCreate(savedInstanceState)
+}
+```
+
+Skipping this step means the native splash is never shown, and `hide()`/`useHideAnimation` have
+nothing to hide.
+
+## Asset generation CLI
+
+```bash
+npx symbiote-splash-screen generate <logo> [options]
+```
+
+A thin rebrand of `react-native-bootsplash`'s own generator (`bin: symbiote-splash-screen`,
+spawned as a child process of its real `cli.js` since that script sits outside upstream's
+`exports` map) — it writes native Android/iOS/web project files (drawables, `styles.xml`'s
+`Theme.BootSplash`, `LaunchScreen.storyboard`, `Info.plist`'s launch-screen key) plus
+`assets/bootsplash/manifest.json` (the same shape `IManifest` expects: `background`,
+`logo.{width,height}`, optional `darkBackground`/`brand`), independent of which adapter the app
+uses. Zero reimplementation; run `--help` for the full flag list (`--brand`, `--dark-*`, etc. —
+the multi-density/dark-mode addon flags require a paid `--license-key` from the upstream author;
+pass it through as-is, this package doesn't attempt to replicate it).
+
+## Use it
+
+`hide()` is the simple case — call it once your JS tree has mounted:
+
+```tsx
+// React — examples/react/App.tsx
+import { hide } from '@symbiote-native/splash-screen/react';
+
+useEffect(() => {
+  hide();
+}, []);
+```
+
+```vue
+<!-- Vue — examples/vue-sfc/App.vue -->
+<script setup lang="ts">
+import { onMounted } from 'vue';
+import { hide } from '@symbiote-native/splash-screen/vue';
+
+onMounted(() => hide());
+</script>
+```
+
+```ts
+// Angular — examples/angular/App.ts
+import { hide } from '@symbiote-native/splash-screen/angular';
+// call once from the root component's constructor/ngOnInit.
+```
+
+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
+`View`/`Image`:
+
+```tsx
+import { useHideAnimation } from '@symbiote-native/splash-screen/react';
+import manifest from '../assets/bootsplash/manifest.json';
+
+const { container, logo } = useHideAnimation({
+  manifest,
+  logo: require('../assets/bootsplash/logo.png'),
+  animate: () => {
+    /* your own fade-out, e.g. an Animated.timing to opacity 0 */
+  },
+});
+```
+
+See the docs-site package page (`docs/packages/splash-screen`) for the full config surface and
+the Vue/Angular equivalents.
+
+## 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
+`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
+project's testing model).
+
+## Out of scope
+
+- The Expo config plugin (`app.plugin.js`, upstream's `/expo` entry) — this repo doesn't target
+  Expo.

package/build/angular/index.d.ts

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

package/build/angular/index.js

@@ -0,0 +1,5 @@
+// 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/index.js';
+export { HideAnimationService } from './services/hide-animation.service/index.js';

package/build/angular/services/hide-animation.service/index.d.ts

@@ -0,0 +1,6 @@
+import { type Signal } from '@angular/core';
+import { type IHideAnimationConfig, type IHideAnimationResult } from '../../../core';
+export declare class HideAnimationService {
+    private readonly injector;
+    connect(getConfig: () => IHideAnimationConfig): Signal<IHideAnimationResult>;
+}

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

@@ -0,0 +1,74 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { computed, effect, inject, Injectable, Injector } from '@angular/core';
+import { computeHideAnimationStyles, getHideAnimationConstants, 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.
+//
+//   readonly hideAnimation = inject(HideAnimationService).connect(() => this.config());
+//   // template: [style]="hideAnimation().container.style", (layout)="..." etc.
+let HideAnimationService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var HideAnimationService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            HideAnimationService = _classThis = _classDescriptor.value;
+            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.
+        injector = inject(Injector);
+        connect(getConfig) {
+            const controller = new HideAnimationController(getConfig());
+            const constants = getHideAnimationConstants();
+            effect(() => controller.updateConfig(getConfig()), { injector: this.injector });
+            return computed(() => computeHideAnimationStyles(getConfig(), constants, controller));
+        }
+    };
+    return HideAnimationService = _classThis;
+})();
+export { HideAnimationService };

package/build/core/compute-hide-animation-styles.d.ts

@@ -0,0 +1,3 @@
+import type { HideAnimationController } from './hide-animation-controller';
+import type { IHideAnimationConfig, IHideAnimationConstants, IHideAnimationResult } from './types';
+export declare function computeHideAnimationStyles(config: IHideAnimationConfig, constants: IHideAnimationConstants, controller: HideAnimationController): IHideAnimationResult;

package/build/core/compute-hide-animation-styles.js

@@ -0,0 +1,77 @@
+import { Platform } from '@symbiote-native/engine';
+import { isEdgeToEdge } from 'react-native-is-edge-to-edge';
+// 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, constants, controller) {
+    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',
+            backgroundColor,
+            justifyContent: 'center',
+            position: 'absolute',
+            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 = 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 = 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/build/core/hide-animation-controller.d.ts

@@ -0,0 +1,10 @@
+import type { IHideAnimationConfig } from './types';
+export declare class HideAnimationController {
+    private readonly readiness;
+    constructor(config: IHideAnimationConfig);
+    updateConfig(config: IHideAnimationConfig): void;
+    readonly onContainerLayout: () => void;
+    readonly onLogoLoadEnd: () => void;
+    readonly onBrandLoadEnd: () => void;
+    private maybeRunAnimate;
+}

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

@@ -0,0 +1,50 @@
+import { hide } from './hide.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.
+export class HideAnimationController {
+    readiness;
+    constructor(config) {
+        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) {
+        this.readiness.animate = config.animate;
+        this.readiness.userReady = config.ready ?? true;
+        this.maybeRunAnimate();
+    }
+    onContainerLayout = () => {
+        this.readiness.layoutReady = true;
+        this.maybeRunAnimate();
+    };
+    onLogoLoadEnd = () => {
+        this.readiness.logoReady = true;
+        this.maybeRunAnimate();
+    };
+    onBrandLoadEnd = () => {
+        this.readiness.brandReady = true;
+        this.maybeRunAnimate();
+    };
+    maybeRunAnimate() {
+        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/build/core/hide.d.ts

@@ -0,0 +1 @@
+export { hide, isVisible } from 'react-native-bootsplash';

package/build/core/hide.js

@@ -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/build/core/index.d.ts

@@ -0,0 +1,5 @@
+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/build/core/index.js

@@ -0,0 +1,4 @@
+export { hide, isVisible } from './hide.js';
+export { HideAnimationController } from './hide-animation-controller.js';
+export { computeHideAnimationStyles } from './compute-hide-animation-styles.js';
+export { getHideAnimationConstants } from './native-module.js';

package/build/core/native-module.d.ts

@@ -0,0 +1,2 @@
+import type { IHideAnimationConstants } from './types';
+export declare function getHideAnimationConstants(): IHideAnimationConstants;

package/build/core/native-module.js

@@ -0,0 +1,12 @@
+// 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';
+const RN_BOOT_SPLASH_MODULE_NAME = 'RNBootSplash';
+export function getHideAnimationConstants() {
+    return getEnforcingNativeModule(RN_BOOT_SPLASH_MODULE_NAME).getConstants();
+}

package/build/core/types.d.ts

@@ -0,0 +1,51 @@
+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;
+};
+export type IHideAnimationConstants = {
+    darkModeEnabled: boolean;
+    logoSizeRatio?: number;
+    navigationBarHeight?: number;
+    statusBarHeight?: number;
+};

package/build/core/types.js

@@ -0,0 +1 @@
+export {};

package/build/react/hooks/use-hide-animation/index.d.ts

@@ -0,0 +1,2 @@
+import { type IHideAnimationConfig, type IHideAnimationResult } from '../../../core';
+export declare function useHideAnimation(config: IHideAnimationConfig): IHideAnimationResult;

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

@@ -0,0 +1,29 @@
+// 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.
+//
+// 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';
+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);
+}

package/build/react/index.d.ts

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

package/build/react/index.js

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

package/build/vue/composables/use-hide-animation/index.d.ts

@@ -0,0 +1,3 @@
+import { type ComputedRef } from '@vue/runtime-core';
+import { type IHideAnimationConfig, type IHideAnimationResult } from '../../../core';
+export declare function useHideAnimation(getConfig: () => IHideAnimationConfig): ComputedRef<IHideAnimationResult>;

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

@@ -0,0 +1,21 @@
+// 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.
+//
+// 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.
+import { computed, watchEffect } from '@vue/runtime-core';
+import { computeHideAnimationStyles, getHideAnimationConstants, 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));
+}

package/build/vue/index.d.ts

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

package/build/vue/index.js

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

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

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

package/build-ngc/angular/index.js

@@ -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';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,+FAA+F;AAC/F,0FAA0F;AAC1F,iGAAiG;AACjG,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC"}

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

@@ -0,0 +1,9 @@
+import { type Signal } from '@angular/core';
+import { type IHideAnimationConfig, type IHideAnimationResult } from '../../../core';
+import * as i0 from "@angular/core";
+export declare class HideAnimationService {
+    private readonly injector;
+    connect(getConfig: () => IHideAnimationConfig): Signal<IHideAnimationResult>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HideAnimationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HideAnimationService>;
+}