@symbiote-native/splash-screen 0.1.1 → 0.1.3

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';
+export { HideAnimationService } from './services/hide-animation.service';

package/build/angular/services/hide-animation.service.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.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';
+// 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';
+// 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';
+export { HideAnimationController } from './hide-animation-controller';
+export { computeHideAnimationStyles } from './compute-hide-animation-styles';
+export { getHideAnimationConstants } from './native-module';

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.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.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';
+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';
+export { useHideAnimation } from './hooks/use-hide-animation';

package/build/vue/composables/use-hide-animation.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.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';
+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';
+export { useHideAnimation } from './composables/use-hide-animation';

package/codegen-specs/NativeRNBootSplash.ts

@@ -0,0 +1,15 @@
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+
+export interface Spec extends TurboModule {
+  getConstants(): {
+    darkModeEnabled: boolean;
+    logoSizeRatio?: number;
+    navigationBarHeight?: number;
+    statusBarHeight?: number;
+  };
+  hide(fade: boolean): Promise<void>;
+  isVisible(): boolean;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>("RNBootSplash");

package/codegen-specs/NativeRNBootSplash.web.ts

@@ -0,0 +1,47 @@
+import type { Spec } from "./NativeRNBootSplash";
+
+function resolveAfter(delay: number) {
+  return new Promise((resolve) => setTimeout(resolve, delay));
+}
+
+function removeNode(node: Node | null) {
+  const parent = node?.parentNode;
+
+  if (node != null && parent != null) {
+    parent.removeChild(node);
+  }
+}
+
+export default {
+  getConstants: () => ({
+    darkModeEnabled:
+      typeof window !== "undefined" &&
+      "matchMedia" in window &&
+      window.matchMedia("(prefers-color-scheme: dark)").matches,
+  }),
+
+  hide: (fade) =>
+    document.fonts.ready.then(() => {
+      const container = document.getElementById("bootsplash");
+      const style = document.getElementById("bootsplash-style");
+
+      if (container == null || !fade) {
+        removeNode(container);
+        removeNode(style);
+      } else {
+        container.style.transitionProperty = "opacity";
+        container.style.transitionDuration = "250ms";
+        container.style.opacity = "0";
+
+        return resolveAfter(250).then(() => {
+          removeNode(container);
+          removeNode(style);
+        });
+      }
+    }),
+
+  isVisible: () => {
+    const container = document.getElementById("bootsplash");
+    return container != null;
+  },
+} satisfies Spec;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/splash-screen",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Third-party splash-screen native module wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, and Angular adapters.",
   "repository": {
     "type": "git",
@@ -42,6 +42,7 @@
     "src",
     "build",
     "build-ngc",
+    "codegen-specs",
     "cli.cjs",
     "react-native.config.cjs",
     "symbiote-splash-screen.podspec"
@@ -52,7 +53,7 @@
   "codegenConfig": {
     "name": "RNBootSplashSpec",
     "type": "modules",
-    "jsSrcsDir": "node_modules/react-native-bootsplash/src/specs",
+    "jsSrcsDir": "codegen-specs",
     "android": {
       "javaPackageName": "com.zoontek.rnbootsplash"
     }
@@ -60,8 +61,8 @@
   "dependencies": {
     "react-native-bootsplash": "^7.3.2",
     "react-native-is-edge-to-edge": "^1.3.1",
-    "@symbiote-native/components": "0.2.2",
-    "@symbiote-native/engine": "0.1.3"
+    "@symbiote-native/components": "0.2.3",
+    "@symbiote-native/engine": "0.1.4"
   },
   "peerDependencies": {
     "@angular/core": ">=20",
@@ -69,9 +70,9 @@
     "react": ">=19.0.0",
     "react-native": ">=0.86",
     "vue": ">=3.5.0",
-    "@symbiote-native/angular": "0.3.2",
-    "@symbiote-native/vue": "0.3.2",
-    "@symbiote-native/react": "0.2.3"
+    "@symbiote-native/angular": "0.3.3",
+    "@symbiote-native/react": "0.2.4",
+    "@symbiote-native/vue": "0.3.3"
   },
   "peerDependenciesMeta": {
     "@symbiote-native/angular": {
@@ -105,10 +106,10 @@
     "@vue/runtime-core": "^3.5.13",
     "react": "19.2.3",
     "typescript": "~6.0.0",
-    "@symbiote-native/react": "0.2.3",
-    "@symbiote-native/angular": "0.3.2",
+    "@symbiote-native/angular": "0.3.3",
+    "@symbiote-native/react": "0.2.4",
     "@symbiote-native/test-utils": "0.1.5",
-    "@symbiote-native/vue": "0.3.2"
+    "@symbiote-native/vue": "0.3.3"
   },
   "scripts": {
     "typecheck": "tsc --build",

package/symbiote-splash-screen.podspec

@@ -3,7 +3,10 @@ require 'fileutils'
 
 package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
 
-native_splash_screen_package_json = `node --print "require.resolve('react-native-bootsplash/package.json', { paths: [process.argv[1]] })" "#{__dir__}"`.strip
+# __dir__ is the pod's app-facing node_modules symlink under pnpm; react-native-bootsplash
+# only sits as a flat sibling in the REAL .pnpm store directory, so resolution must walk up
+# from the realpath, not the symlink (walking up from the symlink never reaches it).
+native_splash_screen_package_json = `node --print "require.resolve('react-native-bootsplash/package.json', { paths: [process.argv[1]] })" "#{File.realpath(__dir__)}"`.strip
 native_splash_screen_root = File.dirname(native_splash_screen_package_json)
 
 # CocoaPods' file glob never crosses a symlink (Sandbox::PathList#read_file_system walks the