fix(compose): recompile haptic pattern when Jindong keys change (#84)

* fix(compose): recompile haptic pattern when Jindong keys change

* chore: remove useless comments

* test: separate RecordingHapticExecutor from test code

* docs: correct Android impl and Repeat count behavior in DSL reference

* docs: document reactive recompilation in the quick-start guide

Author: l2hyunwoo

documentation/content/docs/api/jindong-compose/composable-dsl/haptic.mdx

@@ -129,8 +129,8 @@ Jindong(trigger) {
 
 | Platform | Implementation |
 |----------|----------------|
-| Android | `VibrationEffect.createOneShot()` |
-| iOS | `CHHapticEvent` with `HapticTransient` or `HapticContinuous` |
+| Android | `VibrationEffect.createWaveform()` |
+| iOS | `CHHapticEvent` (`HapticContinuous`) played via `CHHapticEngine` |
 
 ## Notes
 

documentation/content/docs/api/jindong-compose/composable-dsl/repeat-with-index.mdx

@@ -167,7 +167,7 @@ RepeatWithIndex(5) { i -> Haptic((50 + i * 10).ms) }
 
 - Index is 0-based (0 to count-1)
 - Each iteration generates a separate node
-- `count` must be a positive value.
+- A `count` of 0 or less simply produces no output
 - The index can be used in any expression within the content block
 
 ## See Also

documentation/content/docs/api/jindong-compose/composable-dsl/repeat.mdx

@@ -166,7 +166,7 @@ RepeatWithIndex(5) { index ->
 ## Notes
 
 - `count` of 0 produces no output
-- If count is negative, it can cause app crash.
+- A negative `count` throws `IllegalArgumentException` (it must be non-negative)
 - Each iteration runs sequentially
 - Content block is evaluated `count` times at composition
 - All iterations have the same pattern

documentation/content/docs/guide/quick-start.mdx

@@ -253,6 +253,25 @@ Jindong(buttonClickCount) { ... }
 Jindong(System.currentTimeMillis()) { ... }
 ```
 
+### Reactive Patterns
+
+When a key changes, the content block is recompiled with the current state, so a
+value the block captures must also be one of the keys for the pattern to reflect it:
+
+```kotlin
+var level by remember { mutableStateOf(1) }
+
+// `level` is captured AND a key, so the pattern grows as `level` changes
+Jindong(level) {
+    RepeatWithIndex(level) { index ->
+        Haptic(50.ms, HapticIntensity.Custom(1f - index * 0.1f))
+    }
+}
+```
+
+If a captured value is not in the keys, the pattern keeps the value from the last
+key change instead of updating.
+
 ## Next Steps
 
 - [Jindong API](/docs/api/jindong-compose/jindong) - Deep dive into the main API

gradle/libs.versions.toml

@@ -21,6 +21,7 @@ kover = "0.9.4"
 [libraries]
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
 compose-runtime = { module = "org.jetbrains.compose.runtime:runtime", version.ref = "composeRuntime" }
+compose-ui-test = { module = "org.jetbrains.compose.ui:ui-test", version.ref = "composeMultiplatform" }
 kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
 kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "coroutines" }
 kotest-framework-engine = { module = "io.kotest:kotest-framework-engine", version.ref = "kotest" }

jindong-compose/build.gradle.kts

@@ -69,6 +69,8 @@ kotlin {
         commonTest.dependencies {
             implementation(libs.kotest.framework.engine)
             implementation(libs.kotest.assertions.core)
+            implementation(libs.compose.ui.test)
+            implementation(libs.kotlinx.coroutines.test)
         }
     }
 }

jindong-compose/src/commonMain/kotlin/io/github/compose/jindong/Jindong.kt

@@ -56,7 +56,7 @@ fun Jindong(
   vararg keys: Any?,
   content: @Composable JindongScope.() -> Unit,
 ) {
-  val pattern = rememberHapticPattern(content)
+  val pattern = rememberHapticPattern(*keys) { content() }
   val executor = LocalHapticExecutor.current
 
   LaunchedEffect(*keys) {

jindong-compose/src/commonMain/kotlin/io/github/compose/jindong/RememberHapticPattern.kt

@@ -22,6 +22,7 @@ import io.github.compose.jindong.core.model.HapticPattern
 /**
  * Compiles and memoizes a haptic DSL pattern.
  *
+ * @param keys Inputs that invalidate the memoized pattern when changed
  * @param content DSL block defining the haptic pattern
  * @return The compiled [HapticPattern]
  *
@@ -30,7 +31,8 @@ import io.github.compose.jindong.core.model.HapticPattern
  */
 @Composable
 internal fun rememberHapticPattern(
+  vararg keys: Any?,
   content: @Composable JindongScope.() -> Unit,
-): HapticPattern = remember {
+): HapticPattern = remember(*keys) {
   compilePattern(content)
 }

jindong-compose/src/commonTest/kotlin/io/github/compose/jindong/JindongReactiveTest.kt

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2026 compose-jindong
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+@file:OptIn(ExperimentalTestApi::class)
+
+package io.github.compose.jindong
+
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.test.ExperimentalTestApi
+import androidx.compose.ui.test.runComposeUiTest
+import io.github.compose.jindong.core.ms
+import io.github.compose.jindong.dsl.Haptic
+import io.github.compose.jindong.dsl.RepeatWithIndex
+import io.github.compose.jindong.executor.LocalHapticExecutor
+import io.github.compose.jindong.executor.RecordingHapticExecutor
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+
+class JindongReactiveTest :
+  FunSpec({
+    test("Jindong recompiles its pattern when the key changes") {
+      runComposeUiTest {
+        val recorder = RecordingHapticExecutor()
+        val countState = mutableStateOf(2)
+
+        setContent {
+          val count by countState
+          CompositionLocalProvider(LocalHapticExecutor provides recorder) {
+            Jindong(count) {
+              RepeatWithIndex(count) {
+                Haptic(50.ms)
+              }
+            }
+          }
+        }
+
+        waitForIdle()
+        // Initial key = 2 -> RepeatWithIndex emits 2 events.
+        recorder.executedPatterns.last().events.size shouldBe 2
+
+        countState.value = 5
+        waitForIdle()
+
+        // After the key changes to 5, the captured content must recompile to 5 events,
+        // not return the stale first-compile result.
+        recorder.executedPatterns.last().events.size shouldBe 5
+      }
+    }
+  })

jindong-compose/src/commonTest/kotlin/io/github/compose/jindong/executor/RecordingHapticExecutor.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2026 compose-jindong
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.github.compose.jindong.executor
+
+import io.github.compose.jindong.Jindong
+import io.github.compose.jindong.core.executor.HapticExecutor
+import io.github.compose.jindong.core.executor.HapticHandle
+import io.github.compose.jindong.core.model.HapticPattern
+
+/**
+ * Records executed patterns so a test can inspect what [Jindong] played for a given key.
+ */
+internal class RecordingHapticExecutor : HapticExecutor {
+  override val isSupported: Boolean = true
+
+  val executedPatterns = mutableListOf<HapticPattern>()
+
+  override suspend fun execute(pattern: HapticPattern) {
+    executedPatterns += pattern
+  }
+
+  override fun executeAsync(pattern: HapticPattern): HapticHandle = NoopHapticHandle
+
+  override fun release() = Unit
+
+  internal object NoopHapticHandle : HapticHandle {
+    override val isActive: Boolean = false
+    override fun cancel() = Unit
+  }
+}