expo-orb 0.1.0 → 0.2.2

package/android/src/main/java/expo/modules/breathing/BreathingTextCue.kt

@@ -0,0 +1,51 @@
+package expo.modules.breathing
+
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.togetherWith
+import androidx.compose.foundation.layout.Box
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Shadow
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.sp
+
+@Composable
+fun BreathingTextCue(
+    text: String,
+    color: Color,
+    modifier: Modifier = Modifier
+) {
+    Box(
+        modifier = modifier,
+        contentAlignment = Alignment.Center
+    ) {
+        AnimatedContent(
+            targetState = text,
+            transitionSpec = {
+                fadeIn() togetherWith fadeOut()
+            },
+            label = "BreathingTextCue"
+        ) { currentText ->
+            Text(
+                text = currentText,
+                style = TextStyle(
+                    color = color,
+                    fontSize = 24.sp,
+                    fontWeight = FontWeight.SemiBold,
+                    shadow = Shadow(
+                        color = Color.Black.copy(alpha = 0.5f),
+                        offset = Offset(0f, 2f),
+                        blurRadius = 8f
+                    )
+                )
+            )
+        }
+    }
+}

package/android/src/main/java/expo/modules/breathing/ExpoBreathingExerciseModule.kt

@@ -0,0 +1,177 @@
+package expo.modules.breathing
+
+import android.graphics.Color as AndroidColor
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class ExpoBreathingExerciseModule : Module() {
+    override fun definition() = ModuleDefinition {
+        Name("ExpoBreathingExercise")
+
+        Events("onPhaseChange", "onExerciseComplete")
+
+        Function("startBreathingExercise") { pattern: Map<String, Any?> ->
+            startExercise(pattern)
+        }
+
+        Function("stopBreathingExercise") {
+            BreathingSharedState.reset()
+        }
+
+        Function("pauseBreathingExercise") {
+            val state = BreathingSharedState
+            if (state.state == BreathingExerciseState.RUNNING) {
+                state.state = BreathingExerciseState.PAUSED
+                state.pauseTime = System.nanoTime()
+            }
+        }
+
+        Function("resumeBreathingExercise") {
+            val state = BreathingSharedState
+            val pauseTime = state.pauseTime
+            if (state.state == BreathingExerciseState.PAUSED && pauseTime != null) {
+                val pauseDuration = System.nanoTime() - pauseTime
+                state.phaseStartTime += pauseDuration
+                state.exerciseStartTime += pauseDuration
+                state.state = BreathingExerciseState.RUNNING
+                state.pauseTime = null
+            }
+        }
+
+        View(ExpoBreathingExerciseView::class) {
+            Events("onPhaseChange", "onExerciseComplete")
+
+            Prop("blobColors") { view: ExpoBreathingExerciseView, colors: List<Any> ->
+                val parsedColors = colors.map { parseColor(it) }
+                view.setBlobColors(parsedColors)
+            }
+
+            Prop("innerBlobColor") { view: ExpoBreathingExerciseView, color: Any ->
+                view.setInnerBlobColor(parseColor(color))
+            }
+
+            Prop("progressRingColor") { view: ExpoBreathingExerciseView, color: Any ->
+                view.setProgressRingColor(parseColor(color))
+            }
+
+            Prop("textColor") { view: ExpoBreathingExerciseView, color: Any ->
+                view.setTextColor(parseColor(color))
+            }
+
+            Prop("showProgressRing") { view: ExpoBreathingExerciseView, value: Boolean ->
+                view.setShowProgressRing(value)
+            }
+
+            Prop("showTextCue") { view: ExpoBreathingExerciseView, value: Boolean ->
+                view.setShowTextCue(value)
+            }
+
+            Prop("showInnerBlob") { view: ExpoBreathingExerciseView, value: Boolean ->
+                view.setShowInnerBlob(value)
+            }
+
+            Prop("showShadow") { view: ExpoBreathingExerciseView, value: Boolean ->
+                view.setShowShadow(value)
+            }
+
+            Prop("showParticles") { view: ExpoBreathingExerciseView, value: Boolean ->
+                view.setShowParticles(value)
+            }
+
+            Prop("showWavyBlobs") { view: ExpoBreathingExerciseView, value: Boolean ->
+                view.setShowWavyBlobs(value)
+            }
+
+            Prop("showGlowEffects") { view: ExpoBreathingExerciseView, value: Boolean ->
+                view.setShowGlowEffects(value)
+            }
+
+            Prop("glowColor") { view: ExpoBreathingExerciseView, color: Any ->
+                view.setGlowColor(parseColor(color))
+            }
+
+            Prop("particleColor") { view: ExpoBreathingExerciseView, color: Any ->
+                view.setParticleColor(parseColor(color))
+            }
+
+            Prop("pointCount") { view: ExpoBreathingExerciseView, value: Int ->
+                view.setPointCount(value)
+            }
+
+            Prop("wobbleIntensity") { view: ExpoBreathingExerciseView, value: Double ->
+                view.setWobbleIntensity(value)
+            }
+        }
+    }
+
+    private fun startExercise(pattern: Map<String, Any?>) {
+        val state = BreathingSharedState
+        state.reset()
+
+        // Parse phases
+        @Suppress("UNCHECKED_CAST")
+        val phasesArray = pattern["phases"] as? List<Map<String, Any?>> ?: return
+
+        val phases = phasesArray.mapNotNull { phaseDict ->
+            val phaseString = phaseDict["phase"] as? String ?: return@mapNotNull null
+            val duration = (phaseDict["duration"] as? Number)?.toDouble() ?: return@mapNotNull null
+            val targetScale = (phaseDict["targetScale"] as? Number)?.toDouble() ?: return@mapNotNull null
+            val label = phaseDict["label"] as? String ?: return@mapNotNull null
+
+            val phase = when (phaseString) {
+                "inhale" -> BreathPhase.INHALE
+                "holdIn" -> BreathPhase.HOLD_IN
+                "exhale" -> BreathPhase.EXHALE
+                "holdOut" -> BreathPhase.HOLD_OUT
+                else -> return@mapNotNull null
+            }
+
+            BreathPhaseConfig(
+                phase = phase,
+                duration = duration / 1000.0,  // Convert ms to seconds
+                targetScale = targetScale,
+                label = label
+            )
+        }
+
+        if (phases.isEmpty()) return
+
+        // Parse cycles
+        state.totalCycles = (pattern["cycles"] as? Number)?.toInt()
+
+        // Setup state
+        state.phases = phases
+        state.currentPhaseIndex = 0
+        state.currentCycle = 0
+        state.phaseStartTime = System.nanoTime()
+        state.exerciseStartTime = System.nanoTime()
+
+        // Set initial phase values
+        val firstPhase = phases[0]
+        state.currentPhase = firstPhase.phase
+        state.currentLabel = firstPhase.label
+        state.startScale = 1.0
+        state.targetScale = firstPhase.targetScale
+        state.currentScale = 1.0
+        state.phaseProgress = 0.0
+
+        // Set initial wobble intensity
+        state.wobbleIntensity = when (firstPhase.phase) {
+            BreathPhase.INHALE, BreathPhase.EXHALE -> 1.0
+            BreathPhase.HOLD_IN, BreathPhase.HOLD_OUT -> 0.3
+            BreathPhase.IDLE -> 0.5
+        }
+
+        state.state = BreathingExerciseState.RUNNING
+    }
+
+    private fun parseColor(value: Any): Int {
+        return when (value) {
+            is String -> AndroidColor.parseColor(value)
+            is Int -> value
+            is Double -> value.toInt()
+            is Long -> value.toInt()
+            else -> AndroidColor.WHITE
+        }
+    }
+}

package/android/src/main/java/expo/modules/breathing/ExpoBreathingExerciseView.kt

@@ -0,0 +1,144 @@
+package expo.modules.breathing
+
+import android.content.Context
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.unit.dp
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.viewevent.EventDispatcher
+import expo.modules.kotlin.views.ExpoView
+
+class ExpoBreathingExerciseView(context: Context, appContext: AppContext) : ExpoView(context, appContext) {
+
+    // Mutable state for configuration
+    private var config by mutableStateOf(BreathingConfiguration())
+
+    private val onPhaseChange by EventDispatcher()
+    private val onExerciseComplete by EventDispatcher()
+
+    private val composeView = ComposeView(context).apply {
+        setContent {
+            BreathingExerciseViewContent()
+        }
+    }
+
+    init {
+        // Allow effects to render outside view bounds
+        clipChildren = false
+        clipToPadding = false
+        composeView.clipChildren = false
+        composeView.clipToPadding = false
+        addView(composeView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+
+        // Setup callbacks
+        setupCallbacks()
+    }
+
+    private fun setupCallbacks() {
+        BreathingSharedState.onPhaseChange = { phase, label, phaseIndex, cycle ->
+            onPhaseChange(
+                mapOf(
+                    "phase" to phase.value,
+                    "label" to label,
+                    "phaseIndex" to phaseIndex,
+                    "cycle" to cycle
+                )
+            )
+        }
+
+        BreathingSharedState.onExerciseComplete = { totalCycles, totalDuration ->
+            onExerciseComplete(
+                mapOf(
+                    "totalCycles" to totalCycles,
+                    "totalDuration" to totalDuration
+                )
+            )
+        }
+    }
+
+    @Composable
+    private fun BreathingExerciseViewContent() {
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(24.dp),
+            contentAlignment = Alignment.Center
+        ) {
+            BreathingExerciseView(
+                config = config,
+                modifier = Modifier.fillMaxSize()
+            )
+        }
+    }
+
+    fun setBlobColors(colors: List<Int>) {
+        config = config.copy(
+            blobColors = colors.map { Color(it) }
+        )
+    }
+
+    fun setInnerBlobColor(color: Int) {
+        config = config.copy(innerBlobColor = Color(color))
+    }
+
+    fun setProgressRingColor(color: Int) {
+        config = config.copy(progressRingColor = Color(color))
+    }
+
+    fun setTextColor(color: Int) {
+        config = config.copy(textColor = Color(color))
+    }
+
+    fun setShowProgressRing(value: Boolean) {
+        config = config.copy(showProgressRing = value)
+    }
+
+    fun setShowTextCue(value: Boolean) {
+        config = config.copy(showTextCue = value)
+    }
+
+    fun setShowInnerBlob(value: Boolean) {
+        config = config.copy(showInnerBlob = value)
+    }
+
+    fun setShowShadow(value: Boolean) {
+        config = config.copy(showShadow = value)
+    }
+
+    fun setPointCount(value: Int) {
+        config = config.copy(pointCount = maxOf(6, value))
+    }
+
+    fun setWobbleIntensity(value: Double) {
+        config = config.copy(wobbleIntensity = value.coerceIn(0.0, 1.0))
+    }
+
+    fun setGlowColor(color: Int) {
+        config = config.copy(glowColor = Color(color))
+    }
+
+    fun setParticleColor(color: Int) {
+        config = config.copy(particleColor = Color(color))
+    }
+
+    fun setShowParticles(value: Boolean) {
+        config = config.copy(showParticles = value)
+    }
+
+    fun setShowWavyBlobs(value: Boolean) {
+        config = config.copy(showWavyBlobs = value)
+    }
+
+    fun setShowGlowEffects(value: Boolean) {
+        config = config.copy(showGlowEffects = value)
+    }
+}

package/android/src/main/java/expo/modules/breathing/MorphingBlobView.kt

@@ -0,0 +1,128 @@
+package expo.modules.breathing
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import kotlin.math.PI
+import kotlin.math.cos
+import kotlin.math.min
+import kotlin.math.sin
+import kotlin.math.tan
+
+@Composable
+fun MorphingBlobView(
+    baseRadius: Float,
+    pointCount: Int,
+    offsets: List<Double>,
+    colors: List<Color>,
+    innerColor: Color,
+    showInnerBlob: Boolean,
+    modifier: Modifier = Modifier
+) {
+    Canvas(modifier = modifier) {
+        val size = min(this.size.width, this.size.height)
+        val center = Offset(this.size.width / 2f, this.size.height / 2f)
+        val effectiveRadius = baseRadius * size / 2f
+
+        // Draw main blob
+        val mainPath = createBlobPath(center, effectiveRadius, pointCount, offsets)
+        drawPath(
+            path = mainPath,
+            brush = Brush.radialGradient(
+                colors = colors,
+                center = center,
+                radius = effectiveRadius
+            )
+        )
+
+        // Draw inner blob for depth
+        if (showInnerBlob) {
+            val innerPath = createBlobPath(
+                center = center,
+                baseRadius = effectiveRadius * 0.6f,
+                pointCount = pointCount,
+                offsets = offsets.map { it * 0.7 }
+            )
+            drawPath(
+                path = innerPath,
+                color = innerColor
+            )
+        }
+    }
+}
+
+private fun DrawScope.createBlobPath(
+    center: Offset,
+    baseRadius: Float,
+    pointCount: Int,
+    offsets: List<Double>
+): Path {
+    val path = Path()
+    if (pointCount < 3) return path
+
+    // Generate points around the circle with offsets
+    val points = mutableListOf<Offset>()
+    for (i in 0 until pointCount) {
+        val angle = (i.toDouble() / pointCount) * 2 * PI - PI / 2
+        val offset = if (i < offsets.size) offsets[i] else 0.0
+        val radius = baseRadius * (1.0 + offset).toFloat()
+
+        points.add(
+            Offset(
+                x = center.x + (cos(angle) * radius).toFloat(),
+                y = center.y + (sin(angle) * radius).toFloat()
+            )
+        )
+    }
+
+    // Tangent coefficient for smooth cubic bezier curves
+    val tangentCoeff = ((4.0 / 3.0) * tan(PI / (2.0 * pointCount))).toFloat()
+
+    // Start at first point
+    path.moveTo(points[0].x, points[0].y)
+
+    // Draw cubic bezier curves between each pair of points
+    for (i in 0 until pointCount) {
+        val current = points[i]
+        val next = points[(i + 1) % pointCount]
+
+        // Calculate angles for tangent directions
+        val currentAngle = (i.toDouble() / pointCount) * 2 * PI - PI / 2
+        val nextAngle = (((i + 1) % pointCount).toDouble() / pointCount) * 2 * PI - PI / 2
+
+        // Current point's radius and tangent
+        val currentOffset = if (i < offsets.size) offsets[i] else 0.0
+        val currentRadius = baseRadius * (1.0 + currentOffset).toFloat()
+        val currentTangentLength = currentRadius * tangentCoeff
+
+        // Next point's radius and tangent
+        val nextOffset = if ((i + 1) % pointCount < offsets.size) offsets[(i + 1) % pointCount] else 0.0
+        val nextRadius = baseRadius * (1.0 + nextOffset).toFloat()
+        val nextTangentLength = nextRadius * tangentCoeff
+
+        // Control points are perpendicular to radial direction
+        val control1 = Offset(
+            x = current.x + (cos(currentAngle + PI / 2) * currentTangentLength).toFloat(),
+            y = current.y + (sin(currentAngle + PI / 2) * currentTangentLength).toFloat()
+        )
+
+        val control2 = Offset(
+            x = next.x + (cos(nextAngle - PI / 2) * nextTangentLength).toFloat(),
+            y = next.y + (sin(nextAngle - PI / 2) * nextTangentLength).toFloat()
+        )
+
+        path.cubicTo(
+            control1.x, control1.y,
+            control2.x, control2.y,
+            next.x, next.y
+        )
+    }
+
+    path.close()
+    return path
+}

package/android/src/main/java/expo/modules/breathing/ProgressRingView.kt

@@ -0,0 +1,50 @@
+package expo.modules.breathing
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.StrokeCap
+import androidx.compose.ui.graphics.drawscope.Stroke
+import kotlin.math.min
+
+@Composable
+fun ProgressRingView(
+    progress: Double,
+    color: Color,
+    lineWidth: Float,
+    modifier: Modifier = Modifier
+) {
+    Canvas(modifier = modifier) {
+        val size = min(this.size.width, this.size.height)
+        val radius = (size - lineWidth) / 2f
+        val center = Offset(this.size.width / 2f, this.size.height / 2f)
+        val topLeft = Offset(center.x - radius, center.y - radius)
+        val arcSize = Size(radius * 2, radius * 2)
+
+        // Background ring
+        drawArc(
+            color = color.copy(alpha = 0.2f),
+            startAngle = 0f,
+            sweepAngle = 360f,
+            useCenter = false,
+            topLeft = topLeft,
+            size = arcSize,
+            style = Stroke(width = lineWidth)
+        )
+
+        // Progress arc
+        val clampedProgress = progress.coerceIn(0.0, 1.0).toFloat()
+        drawArc(
+            color = color,
+            startAngle = -90f,  // Start from top
+            sweepAngle = 360f * clampedProgress,
+            useCenter = false,
+            topLeft = topLeft,
+            size = arcSize,
+            style = Stroke(width = lineWidth, cap = StrokeCap.Round)
+        )
+    }
+}

package/build/ExpoBreathingExercise.types.d.ts

@@ -0,0 +1,48 @@
+import type { ColorValue, StyleProp, ViewStyle } from 'react-native';
+export type BreathPhase = 'inhale' | 'holdIn' | 'exhale' | 'holdOut';
+export interface BreathPhaseConfig {
+    phase: BreathPhase;
+    duration: number;
+    targetScale: number;
+    label: string;
+}
+export interface BreathingPattern {
+    phases: BreathPhaseConfig[];
+    cycles?: number;
+}
+export type BreathingPreset = 'relaxing' | 'box' | 'energizing' | 'calming';
+export interface PhaseChangeEvent {
+    phase: BreathPhase;
+    label: string;
+    phaseIndex: number;
+    cycle: number;
+}
+export interface ExerciseCompleteEvent {
+    totalCycles: number;
+    totalDuration: number;
+}
+export interface ExpoBreathingExerciseViewProps {
+    blobColors?: ColorValue[];
+    innerBlobColor?: ColorValue;
+    glowColor?: ColorValue;
+    particleColor?: ColorValue;
+    progressRingColor?: ColorValue;
+    textColor?: ColorValue;
+    showProgressRing?: boolean;
+    showTextCue?: boolean;
+    showInnerBlob?: boolean;
+    showShadow?: boolean;
+    showParticles?: boolean;
+    showWavyBlobs?: boolean;
+    showGlowEffects?: boolean;
+    pointCount?: number;
+    wobbleIntensity?: number;
+    onPhaseChange?: (event: {
+        nativeEvent: PhaseChangeEvent;
+    }) => void;
+    onExerciseComplete?: (event: {
+        nativeEvent: ExerciseCompleteEvent;
+    }) => void;
+    style?: StyleProp<ViewStyle>;
+}
+//# sourceMappingURL=ExpoBreathingExercise.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBreathingExercise.types.d.ts","sourceRoot":"","sources":["../src/ExpoBreathingExercise.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAErE,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAErE,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,KAAK,GAAG,YAAY,GAAG,SAAS,CAAC;AAE5E,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,8BAA8B;IAC7C,UAAU,CAAC,EAAE,UAAU,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,aAAa,CAAC,EAAE,UAAU,CAAC;IAC3B,iBAAiB,CAAC,EAAE,UAAU,CAAC;IAC/B,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,WAAW,EAAE,gBAAgB,CAAA;KAAE,KAAK,IAAI,CAAC;IACnE,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,WAAW,EAAE,qBAAqB,CAAA;KAAE,KAAK,IAAI,CAAC;IAC7E,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAC9B"}

package/build/ExpoBreathingExercise.types.js

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

package/build/ExpoBreathingExercise.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBreathingExercise.types.js","sourceRoot":"","sources":["../src/ExpoBreathingExercise.types.ts"],"names":[],"mappings":"","sourcesContent":["import type { ColorValue, StyleProp, ViewStyle } from 'react-native';\n\nexport type BreathPhase = 'inhale' | 'holdIn' | 'exhale' | 'holdOut';\n\nexport interface BreathPhaseConfig {\n  phase: BreathPhase;\n  duration: number;      // milliseconds\n  targetScale: number;   // e.g., 1.0 to 1.3\n  label: string;         // \"Breathe In\"\n}\n\nexport interface BreathingPattern {\n  phases: BreathPhaseConfig[];\n  cycles?: number;       // undefined = infinite\n}\n\nexport type BreathingPreset = 'relaxing' | 'box' | 'energizing' | 'calming';\n\nexport interface PhaseChangeEvent {\n  phase: BreathPhase;\n  label: string;\n  phaseIndex: number;\n  cycle: number;\n}\n\nexport interface ExerciseCompleteEvent {\n  totalCycles: number;\n  totalDuration: number;\n}\n\nexport interface ExpoBreathingExerciseViewProps {\n  blobColors?: ColorValue[];\n  innerBlobColor?: ColorValue;\n  glowColor?: ColorValue;\n  particleColor?: ColorValue;\n  progressRingColor?: ColorValue;\n  textColor?: ColorValue;\n  showProgressRing?: boolean;\n  showTextCue?: boolean;\n  showInnerBlob?: boolean;\n  showShadow?: boolean;\n  showParticles?: boolean;\n  showWavyBlobs?: boolean;\n  showGlowEffects?: boolean;\n  pointCount?: number;           // Morphing points (default: 8)\n  wobbleIntensity?: number;      // 0-1\n  onPhaseChange?: (event: { nativeEvent: PhaseChangeEvent }) => void;\n  onExerciseComplete?: (event: { nativeEvent: ExerciseCompleteEvent }) => void;\n  style?: StyleProp<ViewStyle>;\n}\n"]}

package/build/ExpoBreathingExerciseModule.d.ts

@@ -0,0 +1,16 @@
+import { NativeModule } from 'expo';
+import type { BreathingPattern, BreathingPreset } from './ExpoBreathingExercise.types';
+declare class ExpoBreathingExerciseModuleType extends NativeModule {
+    startBreathingExercise(pattern: BreathingPattern): void;
+    stopBreathingExercise(): void;
+    pauseBreathingExercise(): void;
+    resumeBreathingExercise(): void;
+}
+declare const module: ExpoBreathingExerciseModuleType;
+export default module;
+export declare function startBreathingExercise(pattern: BreathingPattern): void;
+export declare function stopBreathingExercise(): void;
+export declare function pauseBreathingExercise(): void;
+export declare function resumeBreathingExercise(): void;
+export declare function getBreathingPreset(preset: BreathingPreset): BreathingPattern;
+//# sourceMappingURL=ExpoBreathingExerciseModule.d.ts.map

package/build/ExpoBreathingExerciseModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBreathingExerciseModule.d.ts","sourceRoot":"","sources":["../src/ExpoBreathingExerciseModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuB,MAAM,MAAM,CAAC;AACzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEvF,OAAO,OAAO,+BAAgC,SAAQ,YAAY;IAChE,sBAAsB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IACvD,qBAAqB,IAAI,IAAI;IAC7B,sBAAsB,IAAI,IAAI;IAC9B,uBAAuB,IAAI,IAAI;CAChC;AAED,QAAA,MAAM,MAAM,iCAAgF,CAAC;AAE7F,eAAe,MAAM,CAAC;AAEtB,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAEtE;AAED,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C;AAED,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAoCD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,eAAe,GAAG,gBAAgB,CAE5E"}

package/build/ExpoBreathingExerciseModule.js

@@ -0,0 +1,52 @@
+import { requireNativeModule } from 'expo';
+const module = requireNativeModule('ExpoBreathingExercise');
+export default module;
+export function startBreathingExercise(pattern) {
+    module.startBreathingExercise(pattern);
+}
+export function stopBreathingExercise() {
+    module.stopBreathingExercise();
+}
+export function pauseBreathingExercise() {
+    module.pauseBreathingExercise();
+}
+export function resumeBreathingExercise() {
+    module.resumeBreathingExercise();
+}
+const BREATHING_PRESETS = {
+    relaxing: {
+        phases: [
+            { phase: 'inhale', duration: 4000, targetScale: 1.35, label: 'Breathe In' },
+            { phase: 'holdIn', duration: 7000, targetScale: 1.35, label: 'Hold' },
+            { phase: 'exhale', duration: 8000, targetScale: 0.75, label: 'Breathe Out' },
+        ],
+        cycles: 4,
+    },
+    box: {
+        phases: [
+            { phase: 'inhale', duration: 4000, targetScale: 1.35, label: 'Breathe In' },
+            { phase: 'holdIn', duration: 4000, targetScale: 1.35, label: 'Hold' },
+            { phase: 'exhale', duration: 4000, targetScale: 0.75, label: 'Breathe Out' },
+            { phase: 'holdOut', duration: 4000, targetScale: 0.75, label: 'Hold' },
+        ],
+        cycles: 4,
+    },
+    energizing: {
+        phases: [
+            { phase: 'inhale', duration: 2000, targetScale: 1.35, label: 'Breathe In' },
+            { phase: 'exhale', duration: 2000, targetScale: 0.75, label: 'Breathe Out' },
+        ],
+        cycles: 10,
+    },
+    calming: {
+        phases: [
+            { phase: 'inhale', duration: 4000, targetScale: 1.35, label: 'Breathe In' },
+            { phase: 'exhale', duration: 6000, targetScale: 0.75, label: 'Breathe Out' },
+        ],
+        cycles: 6,
+    },
+};
+export function getBreathingPreset(preset) {
+    return BREATHING_PRESETS[preset];
+}
+//# sourceMappingURL=ExpoBreathingExerciseModule.js.map