expo-orb 0.1.0

package/android/src/main/java/expo/modules/orb/OrbView.kt

@@ -0,0 +1,368 @@
+package expo.modules.orb
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameNanos
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.blur
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.drawBehind
+import androidx.compose.ui.draw.scale
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.unit.dp
+import kotlin.math.PI
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.pow
+import kotlin.math.sin
+
+@Composable
+fun OrbView(
+    config: OrbConfiguration,
+    useSharedActivityState: Boolean = false,
+    modifier: Modifier = Modifier
+) {
+    // Frame-based animation state
+    var elapsedTime by remember { mutableStateOf(0.0) }
+    var frameTime by remember { mutableStateOf(System.nanoTime()) }
+
+    // Continuous animation loop
+    LaunchedEffect(Unit) {
+        val startTime = System.nanoTime()
+        while (true) {
+            withFrameNanos { currentTime ->
+                elapsedTime = (currentTime - startTime) / 1_000_000_000.0
+                frameTime = currentTime
+            }
+        }
+    }
+
+    // Interpolate activity
+    val activity = if (useSharedActivityState) {
+        interpolatedActivity(frameTime)
+    } else {
+        0.0
+    }
+
+    // Compute effective config from activity
+    val effectiveConfig = activityDerivedConfig(activity, config)
+
+    // Calculate breathing scale
+    val scale = breathingScale(frameTime, effectiveConfig)
+
+    // Outer container with padding to allow glow/shadow overflow
+    Box(
+        modifier = modifier
+            .graphicsLayer {
+                // Disable clipping to allow glow/shadow overflow
+                clip = false
+            }
+            .aspectRatio(1f)
+            .scale(scale),
+        contentAlignment = Alignment.Center
+    ) {
+        // Shadow layers (rendered outside the circle)
+        if (config.showShadow) {
+            RealisticShadow(
+                colors = config.backgroundColors,
+                modifier = Modifier
+                    .fillMaxSize()
+                    .graphicsLayer { clip = false }
+            )
+        }
+
+        // Main orb content clipped to circle
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .clip(CircleShape)
+        ) {
+            // Background gradient
+            if (config.showBackground) {
+                Box(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .background(
+                            brush = Brush.verticalGradient(
+                                colors = config.backgroundColors.reversed()
+                            )
+                        )
+                )
+            }
+
+            // Base depth glows
+            BaseDepthGlows(
+                effectiveConfig = effectiveConfig,
+                elapsedTime = elapsedTime,
+                modifier = Modifier.fillMaxSize()
+            )
+
+            // Wavy blobs
+            if (config.showWavyBlobs) {
+                WavyBlobLayer(
+                    elapsedTime = elapsedTime,
+                    modifier = Modifier.fillMaxSize()
+                )
+            }
+
+            // Core glow effects
+            if (config.showGlowEffects) {
+                CoreGlowEffects(
+                    effectiveConfig = effectiveConfig,
+                    elapsedTime = elapsedTime,
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .padding(8.dp)
+                )
+            }
+
+            // Particles
+            if (config.showParticles) {
+                ParticlesView(
+                    color = config.particleColor,
+                    particleCount = 10,
+                    speedRange = 10f..20f,
+                    sizeRange = 0.5f..1f,
+                    opacityRange = 0f..0.3f,
+                    elapsedTime = elapsedTime,
+                    modifier = Modifier.fillMaxSize()
+                )
+                ParticlesView(
+                    color = config.particleColor,
+                    particleCount = 10,
+                    speedRange = 20f..30f,
+                    sizeRange = 0.2f..1f,
+                    opacityRange = 0.3f..0.8f,
+                    elapsedTime = elapsedTime,
+                    modifier = Modifier.fillMaxSize()
+                )
+            }
+
+            // Inner glow overlay
+            InnerGlowOverlay(
+                modifier = Modifier.fillMaxSize()
+            )
+        }
+    }
+}
+
+private fun interpolatedActivity(currentTime: Long): Double {
+    val state = OrbSharedState
+    val target = state.targetActivity
+    val dt = (currentTime - state.lastUpdateTime) / 1_000_000_000.0  // Convert to seconds
+    state.lastUpdateTime = currentTime
+
+    // Smooth interpolation (same as iOS)
+    val factor = min(1.0, dt * 6.0)
+    val next = state.currentActivity + (target - state.currentActivity) * factor
+    state.currentActivity = next
+
+    return next
+}
+
+private fun activityDerivedConfig(activity: Double, config: OrbConfiguration): EffectiveConfig {
+    // IMPORTANT: Rotation speed must stay CONSTANT
+    val speed = 18.0
+    // Breathing speed CAN vary because we use cumulative phase
+    val breathingSpeed = 0.03 + activity * 0.25
+    // Idle: no breathing, Speaking: full breathing
+    val breathingIntensity = max(0.0, (activity - 0.2)) * 1.25
+    // Idle: barely visible glow, Speaking: bright
+    val coreGlowIntensity = 0.08 + activity * 1.8
+
+    return EffectiveConfig(
+        speed = speed,
+        breathingIntensity = breathingIntensity,
+        breathingSpeed = breathingSpeed,
+        coreGlowIntensity = coreGlowIntensity,
+        glowColor = config.glowColor
+    )
+}
+
+private fun breathingScale(currentTime: Long, effectiveConfig: EffectiveConfig): Float {
+    val intensity = max(0.0, min(1.0, effectiveConfig.breathingIntensity))
+    if (intensity == 0.0) {
+        return 1f
+    }
+
+    val state = OrbSharedState
+    val dt = (currentTime - state.lastBreathingUpdate) / 1_000_000_000.0
+    state.lastBreathingUpdate = currentTime
+
+    val speed = max(0.01, effectiveConfig.breathingSpeed)
+    state.breathingPhase += dt * speed * 2 * PI
+
+    // Punchy wave shape
+    val rawWave = sin(state.breathingPhase)
+    val wave = if (rawWave >= 0) {
+        rawWave.pow(0.6)
+    } else {
+        -abs(rawWave).pow(1.4)
+    }
+
+    val amplitude = intensity * 0.17
+    return (1.0 + amplitude * wave).toFloat()
+}
+
+@Composable
+private fun BaseDepthGlows(
+    effectiveConfig: EffectiveConfig,
+    elapsedTime: Double,
+    modifier: Modifier = Modifier
+) {
+    Box(modifier = modifier) {
+        SimpleRotatingGlow(
+            color = effectiveConfig.glowColor,
+            rotationSpeed = effectiveConfig.speed * 0.75,
+            direction = RotationDirection.COUNTER_CLOCKWISE,
+            elapsedTime = elapsedTime,
+            alpha = 0.5f,
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(4.dp)
+                .blur(8.dp)
+        )
+        SimpleRotatingGlow(
+            color = effectiveConfig.glowColor.copy(alpha = 0.5f),
+            rotationSpeed = effectiveConfig.speed * 0.25,
+            direction = RotationDirection.CLOCKWISE,
+            elapsedTime = elapsedTime,
+            alpha = 0.3f,
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(8.dp)
+                .blur(4.dp)
+        )
+    }
+}
+
+@Composable
+private fun CoreGlowEffects(
+    effectiveConfig: EffectiveConfig,
+    elapsedTime: Double,
+    modifier: Modifier = Modifier
+) {
+    Box(modifier = modifier) {
+        SimpleRotatingGlow(
+            color = effectiveConfig.glowColor,
+            rotationSpeed = effectiveConfig.speed * 1.2,
+            direction = RotationDirection.CLOCKWISE,
+            elapsedTime = elapsedTime,
+            alpha = (effectiveConfig.coreGlowIntensity * 0.8).toFloat(),
+            modifier = Modifier
+                .fillMaxSize()
+                .blur(12.dp)
+        )
+        SimpleRotatingGlow(
+            color = effectiveConfig.glowColor,
+            rotationSpeed = effectiveConfig.speed * 0.9,
+            direction = RotationDirection.CLOCKWISE,
+            elapsedTime = elapsedTime,
+            alpha = (effectiveConfig.coreGlowIntensity * 0.6).toFloat(),
+            modifier = Modifier
+                .fillMaxSize()
+                .blur(8.dp)
+        )
+    }
+}
+
+@Composable
+private fun WavyBlobLayer(
+    elapsedTime: Double,
+    modifier: Modifier = Modifier
+) {
+    val blobSpeed = 20.0
+
+    Box(modifier = modifier) {
+        WavyBlobView(
+            color = Color.White.copy(alpha = 0.4f),
+            loopDuration = 60.0 / blobSpeed * 1.75,
+            elapsedTime = elapsedTime,
+            modifier = Modifier
+                .fillMaxSize()
+                .scale(1.5f)
+                .offset(y = 40.dp)
+                .blur(2.dp)
+        )
+        WavyBlobView(
+            color = Color.White.copy(alpha = 0.25f),
+            loopDuration = 60.0 / blobSpeed * 2.25,
+            elapsedTime = elapsedTime,
+            modifier = Modifier
+                .fillMaxSize()
+                .scale(1.2f)
+                .offset(y = (-40).dp)
+                .graphicsLayer { rotationZ = 90f }
+                .blur(2.dp)
+        )
+    }
+}
+
+@Composable
+private fun InnerGlowOverlay(modifier: Modifier = Modifier) {
+    Canvas(modifier = modifier) {
+        val center = Offset(size.width / 2f, size.height / 2f)
+        val radius = min(size.width, size.height) / 2f
+
+        // Inner glow rings
+        drawCircle(
+            brush = Brush.verticalGradient(
+                colors = listOf(Color.Transparent, Color.White.copy(alpha = 0.15f)),
+            ),
+            radius = radius,
+            center = center
+        )
+    }
+}
+
+@Composable
+private fun RealisticShadow(
+    colors: List<Color>,
+    modifier: Modifier = Modifier
+) {
+    Box(modifier = modifier) {
+        // Soft outer shadow
+        Canvas(
+            modifier = Modifier
+                .fillMaxSize()
+                .offset(y = 8.dp)
+                .blur(24.dp)
+                .graphicsLayer { alpha = 0.3f }
+        ) {
+            drawCircle(
+                brush = Brush.verticalGradient(colors.reversed()),
+                radius = size.minDimension / 2f
+            )
+        }
+        // Closer shadow
+        Canvas(
+            modifier = Modifier
+                .fillMaxSize()
+                .offset(y = 4.dp)
+                .blur(12.dp)
+                .graphicsLayer { alpha = 0.5f }
+        ) {
+            drawCircle(
+                brush = Brush.verticalGradient(colors.reversed()),
+                radius = size.minDimension / 2f
+            )
+        }
+    }
+}

package/android/src/main/java/expo/modules/orb/ParticlesView.kt

@@ -0,0 +1,77 @@
+package expo.modules.orb
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.BlendMode
+import androidx.compose.ui.graphics.Color
+import kotlin.math.sin
+import kotlin.random.Random
+
+data class Particle(
+    val id: Int,
+    val startX: Float,
+    val startY: Float,
+    val speed: Float,
+    val size: Float,
+    val alpha: Float,
+    val phase: Float  // Random phase offset for variety
+)
+
+@Composable
+fun ParticlesView(
+    color: Color,
+    particleCount: Int = 10,
+    speedRange: ClosedFloatingPointRange<Float> = 10f..20f,
+    sizeRange: ClosedFloatingPointRange<Float> = 0.5f..1f,
+    opacityRange: ClosedFloatingPointRange<Float> = 0f..0.3f,
+    elapsedTime: Double,
+    modifier: Modifier = Modifier
+) {
+    // Generate stable particles on first composition
+    val particles = remember {
+        (0 until particleCount).map { id ->
+            Particle(
+                id = id,
+                startX = Random.nextFloat(),
+                startY = Random.nextFloat(),
+                speed = Random.nextFloat() * (speedRange.endInclusive - speedRange.start) + speedRange.start,
+                size = Random.nextFloat() * (sizeRange.endInclusive - sizeRange.start) + sizeRange.start,
+                alpha = Random.nextFloat() * (opacityRange.endInclusive - opacityRange.start) + opacityRange.start,
+                phase = Random.nextFloat() * 6.28f  // Random phase 0-2π
+            )
+        }
+    }
+
+    Canvas(modifier = modifier.fillMaxSize()) {
+        val width = size.width
+        val height = size.height
+
+        particles.forEach { particle ->
+            // Calculate particle position based on time
+            val cycleTime = 3.0 + particle.phase  // 3-6 second cycle
+            val progress = ((elapsedTime + particle.phase) % cycleTime) / cycleTime
+
+            // Drift upward with slight horizontal wobble
+            val x = particle.startX * width + sin(elapsedTime * 0.5 + particle.phase) * 20f
+            val y = height * (1f - progress.toFloat()) * particle.startY + height * (1f - progress.toFloat())
+
+            // Fade in/out based on lifecycle
+            val lifecycleAlpha = when {
+                progress < 0.2 -> (progress / 0.2).toFloat()  // Fade in
+                progress > 0.8 -> ((1.0 - progress) / 0.2).toFloat()  // Fade out
+                else -> 1f
+            } * particle.alpha
+
+            drawCircle(
+                color = color.copy(alpha = lifecycleAlpha),
+                radius = particle.size * 12f,
+                center = Offset(x.toFloat(), y.toFloat()),
+                blendMode = BlendMode.Plus
+            )
+        }
+    }
+}

package/android/src/main/java/expo/modules/orb/RotatingGlowView.kt

@@ -0,0 +1,90 @@
+package expo.modules.orb
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.BlendMode
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.rotate
+import kotlin.math.min
+
+enum class RotationDirection(val multiplier: Double) {
+    CLOCKWISE(1.0),
+    COUNTER_CLOCKWISE(-1.0)
+}
+
+@Composable
+fun RotatingGlowView(
+    color: Color,
+    rotationSpeed: Double = 30.0,
+    direction: RotationDirection,
+    elapsedTime: Double,
+    modifier: Modifier = Modifier,
+    blurRadius: Float = 0f
+) {
+    val safeSpeed = maxOf(0.01, rotationSpeed)
+    val rotation = (elapsedTime * safeSpeed * direction.multiplier).toFloat()
+
+    Canvas(modifier = modifier.fillMaxSize()) {
+        val sizePx = min(size.width, size.height)
+        val center = Offset(size.width / 2f, size.height / 2f)
+
+        rotate(rotation, pivot = center) {
+            // Main glow circle
+            drawCircle(
+                color = color,
+                radius = sizePx / 2f,
+                center = center,
+                alpha = 0.8f
+            )
+
+            // Cutout circle offset downward (creates crescent effect)
+            drawCircle(
+                color = Color.Transparent,
+                radius = sizePx * 0.655f,  // 1.31 / 2
+                center = Offset(center.x, center.y + sizePx * 0.31f),
+                blendMode = BlendMode.Clear
+            )
+        }
+    }
+}
+
+/**
+ * Simplified glow without complex masking - just a soft gradient circle
+ */
+@Composable
+fun SimpleRotatingGlow(
+    color: Color,
+    rotationSpeed: Double = 30.0,
+    direction: RotationDirection,
+    elapsedTime: Double,
+    alpha: Float = 1f,
+    modifier: Modifier = Modifier
+) {
+    val safeSpeed = maxOf(0.01, rotationSpeed)
+    val rotation = (elapsedTime * safeSpeed * direction.multiplier).toFloat()
+    // Clamp alpha to valid range 0-1
+    val safeAlpha = alpha.coerceIn(0f, 1f)
+
+    Canvas(modifier = modifier.fillMaxSize()) {
+        val sizePx = min(size.width, size.height)
+        val center = Offset(size.width / 2f, size.height / 2f)
+
+        rotate(rotation, pivot = center) {
+            // Draw offset glow to create rotating effect - subtle and smaller
+            drawCircle(
+                color = color.copy(alpha = (safeAlpha * 0.5f).coerceIn(0f, 1f)),
+                radius = sizePx * 0.25f,
+                center = Offset(center.x, center.y - sizePx * 0.12f)
+            )
+            drawCircle(
+                color = color.copy(alpha = (safeAlpha * 0.35f).coerceIn(0f, 1f)),
+                radius = sizePx * 0.18f,
+                center = Offset(center.x + sizePx * 0.08f, center.y + sizePx * 0.08f)
+            )
+        }
+    }
+}

package/android/src/main/java/expo/modules/orb/WavyBlobView.kt

@@ -0,0 +1,90 @@
+package expo.modules.orb
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import kotlin.math.PI
+import kotlin.math.atan2
+import kotlin.math.cos
+import kotlin.math.min
+import kotlin.math.sin
+
+data class BlobPoint(val x: Float, val y: Float)
+
+@Composable
+fun WavyBlobView(
+    color: Color,
+    loopDuration: Double = 1.0,
+    elapsedTime: Double,
+    modifier: Modifier = Modifier
+) {
+    // Initial blob points (6 points in a circle)
+    val basePoints = (0 until 6).map { index ->
+        val angle = (index.toDouble() / 6.0) * 2.0 * PI
+        BlobPoint(
+            x = (0.5 + cos(angle) * 0.9).toFloat(),
+            y = (0.5 + sin(angle) * 0.9).toFloat()
+        )
+    }
+
+    val angle = ((elapsedTime % loopDuration) / loopDuration) * 2.0 * PI
+
+    Canvas(modifier = modifier.fillMaxSize()) {
+        val sizePx = min(size.width, size.height)
+        val center = Offset(size.width / 2f, size.height / 2f)
+        val radius = sizePx * 0.45f
+
+        // Adjust points with sine wave movement
+        val adjustedPoints = basePoints.mapIndexed { index, point ->
+            val phaseOffset = index * PI / 3.0
+            val xOffset = sin(angle + phaseOffset) * 0.15
+            val yOffset = cos(angle + phaseOffset) * 0.15
+            Offset(
+                x = ((point.x - 0.5f + xOffset.toFloat()) * radius + center.x).toFloat(),
+                y = ((point.y - 0.5f + yOffset.toFloat()) * radius + center.y).toFloat()
+            )
+        }
+
+        val path = Path().apply {
+            moveTo(adjustedPoints[0].x, adjustedPoints[0].y)
+
+            for (i in adjustedPoints.indices) {
+                val next = (i + 1) % adjustedPoints.size
+
+                // Calculate angles for control points
+                val currentAngle = atan2(
+                    adjustedPoints[i].y - center.y,
+                    adjustedPoints[i].x - center.x
+                )
+                val nextAngle = atan2(
+                    adjustedPoints[next].y - center.y,
+                    adjustedPoints[next].x - center.x
+                )
+
+                val handleLength = radius * 0.33f
+
+                val control1 = Offset(
+                    x = adjustedPoints[i].x + cos(currentAngle + PI.toFloat() / 2f) * handleLength,
+                    y = adjustedPoints[i].y + sin(currentAngle + PI.toFloat() / 2f) * handleLength
+                )
+                val control2 = Offset(
+                    x = adjustedPoints[next].x + cos(nextAngle - PI.toFloat() / 2f) * handleLength,
+                    y = adjustedPoints[next].y + sin(nextAngle - PI.toFloat() / 2f) * handleLength
+                )
+
+                cubicTo(
+                    control1.x, control1.y,
+                    control2.x, control2.y,
+                    adjustedPoints[next].x, adjustedPoints[next].y
+                )
+            }
+            close()
+        }
+
+        drawPath(path = path, color = color)
+    }
+}

package/build/ExpoOrb.types.d.ts

@@ -0,0 +1,17 @@
+import type { ColorValue, StyleProp, ViewStyle } from 'react-native';
+export type ExpoOrbViewProps = {
+    backgroundColors?: ColorValue[];
+    glowColor?: ColorValue;
+    particleColor?: ColorValue;
+    coreGlowIntensity?: number;
+    breathingIntensity?: number;
+    breathingSpeed?: number;
+    showBackground?: boolean;
+    showWavyBlobs?: boolean;
+    showParticles?: boolean;
+    showGlowEffects?: boolean;
+    showShadow?: boolean;
+    speed?: number;
+    style?: StyleProp<ViewStyle>;
+};
+//# sourceMappingURL=ExpoOrb.types.d.ts.map

package/build/ExpoOrb.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoOrb.types.d.ts","sourceRoot":"","sources":["../src/ExpoOrb.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAErE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,gBAAgB,CAAC,EAAE,UAAU,EAAE,CAAC;IAChC,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,aAAa,CAAC,EAAE,UAAU,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAC9B,CAAC"}

package/build/ExpoOrb.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ExpoOrb.types.js.map

package/build/ExpoOrb.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoOrb.types.js","sourceRoot":"","sources":["../src/ExpoOrb.types.ts"],"names":[],"mappings":"","sourcesContent":["import type { ColorValue, StyleProp, ViewStyle } from 'react-native';\n\nexport type ExpoOrbViewProps = {\n  backgroundColors?: ColorValue[];\n  glowColor?: ColorValue;\n  particleColor?: ColorValue;\n  coreGlowIntensity?: number;\n  breathingIntensity?: number;\n  breathingSpeed?: number;\n  showBackground?: boolean;\n  showWavyBlobs?: boolean;\n  showParticles?: boolean;\n  showGlowEffects?: boolean;\n  showShadow?: boolean;\n  speed?: number;\n  style?: StyleProp<ViewStyle>;\n};\n"]}

package/build/ExpoOrbModule.d.ts

@@ -0,0 +1,17 @@
+import { NativeModule } from 'expo';
+declare class ExpoOrbModule extends NativeModule {
+    /**
+     * Set the activity level (0-1) for the orb animation.
+     * Uses a native function instead of a prop to bypass React's reconciliation
+     * and prevent view re-renders that cause animation flickering.
+     */
+    setActivity(activity: number): void;
+}
+declare const module: ExpoOrbModule;
+export default module;
+/**
+ * Set the orb activity level directly via native function.
+ * This bypasses React's prop system to prevent animation interference.
+ */
+export declare function setOrbActivity(activity: number): void;
+//# sourceMappingURL=ExpoOrbModule.d.ts.map

package/build/ExpoOrbModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoOrbModule.d.ts","sourceRoot":"","sources":["../src/ExpoOrbModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuB,MAAM,MAAM,CAAC;AAEzD,OAAO,OAAO,aAAc,SAAQ,YAAY;IAC9C;;;;OAIG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CACpC;AAED,QAAA,MAAM,MAAM,eAAgD,CAAC;AAE7D,eAAe,MAAM,CAAC;AAEtB;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAErD"}

package/build/ExpoOrbModule.js

@@ -0,0 +1,11 @@
+import { requireNativeModule } from 'expo';
+const module = requireNativeModule('ExpoOrb');
+export default module;
+/**
+ * Set the orb activity level directly via native function.
+ * This bypasses React's prop system to prevent animation interference.
+ */
+export function setOrbActivity(activity) {
+    module.setActivity(activity);
+}
+//# sourceMappingURL=ExpoOrbModule.js.map

package/build/ExpoOrbModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoOrbModule.js","sourceRoot":"","sources":["../src/ExpoOrbModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAWzD,MAAM,MAAM,GAAG,mBAAmB,CAAgB,SAAS,CAAC,CAAC;AAE7D,eAAe,MAAM,CAAC;AAEtB;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,QAAgB;IAC7C,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;AAC/B,CAAC","sourcesContent":["import { NativeModule, requireNativeModule } from 'expo';\n\ndeclare class ExpoOrbModule extends NativeModule {\n  /**\n   * Set the activity level (0-1) for the orb animation.\n   * Uses a native function instead of a prop to bypass React's reconciliation\n   * and prevent view re-renders that cause animation flickering.\n   */\n  setActivity(activity: number): void;\n}\n\nconst module = requireNativeModule<ExpoOrbModule>('ExpoOrb');\n\nexport default module;\n\n/**\n * Set the orb activity level directly via native function.\n * This bypasses React's prop system to prevent animation interference.\n */\nexport function setOrbActivity(activity: number): void {\n  module.setActivity(activity);\n}\n"]}