feat: impl SequenceNode that executes its children sequentially (#7)

* feat: impl leaf node DelayNode

* feat: impl SequenceNode that executes its children sequentially

* refactor: apply assertSoftly

* chore: apply spotless check

* fix: remove unnecessary test case

Author: wisemuji

jindong/src/commonMain/kotlin/io/github/jindong/node/DelayNode.kt

@@ -0,0 +1,32 @@
+/*
+ * 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.jindong.node
+
+/**
+ * A leaf node representing a time delay with no haptic output.
+ *
+ * This node has no children and returns an empty list when [collectEvents] is called.
+ * The duration is used by parent nodes (e.g., [SequenceNode]) to advance timing.
+ *
+ * @property durationMs Duration of the delay in milliseconds
+ */
+internal class DelayNode(
+  val durationMs: Long,
+) : HapticNode {
+  override val children: MutableList<HapticNode> = mutableListOf()
+
+  override fun collectEvents(startTimeMs: Long): List<ScheduledHapticEvent> = emptyList()
+}

jindong/src/commonMain/kotlin/io/github/jindong/node/SequenceNode.kt

@@ -0,0 +1,71 @@
+/*
+ * 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.jindong.node
+
+/**
+ * A container node that executes its children sequentially.
+ *
+ * Each child starts after the previous one completes. The timing is calculated
+ * by tracking the maximum end time of events from each child.
+ *
+ * Special handling for [DelayNode]: advances time without generating events.
+ *
+ * Example:
+ * ```
+ * Sequence {
+ *     Haptic(100.ms)   // starts at 0ms, ends at 100ms
+ *     Delay(50.ms)     // no event, advances to 150ms
+ *     Haptic(200.ms)   // starts at 150ms, ends at 350ms
+ * }
+ * ```
+ */
+internal class SequenceNode : HapticNode {
+  override val children: MutableList<HapticNode> = mutableListOf()
+
+  override fun collectEvents(startTimeMs: Long): List<ScheduledHapticEvent> {
+    val (_, events) = children.fold(
+      initial = TimingState(currentTimeMs = startTimeMs, events = emptyList()),
+    ) { state, child ->
+      processChildNode(child, state)
+    }
+    return events
+  }
+
+  private fun processChildNode(child: HapticNode, state: TimingState): TimingState = if (child is DelayNode) {
+    state.copy(currentTimeMs = state.currentTimeMs + child.durationMs)
+  } else {
+    val childEvents = child.collectEvents(state.currentTimeMs)
+    val nextStartTime = calculateNextStartTime(childEvents, state.currentTimeMs)
+    TimingState(
+      currentTimeMs = nextStartTime,
+      events = state.events + childEvents,
+    )
+  }
+
+  private fun calculateNextStartTime(
+    events: List<ScheduledHapticEvent>,
+    currentTimeMs: Long,
+  ): Long = if (events.isEmpty()) {
+    currentTimeMs
+  } else {
+    events.maxOf { it.startTimeMs + it.durationMs }
+  }
+
+  private data class TimingState(
+    val currentTimeMs: Long,
+    val events: List<ScheduledHapticEvent>,
+  )
+}

jindong/src/commonTest/kotlin/io/github/jindong/node/DelayNodeTest.kt

@@ -0,0 +1,61 @@
+/*
+ * 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.jindong.node
+
+import io.kotest.assertions.assertSoftly
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.collections.shouldBeEmpty
+import io.kotest.matchers.shouldBe
+
+class DelayNodeTest :
+  FunSpec({
+    test("collectEvents should return empty list") {
+      val node = DelayNode(durationMs = 100)
+
+      val events = node.collectEvents(startTimeMs = 0)
+
+      events.shouldBeEmpty()
+    }
+
+    test("collectEvents should return empty list regardless of startTimeMs") {
+      val node = DelayNode(durationMs = 200)
+
+      val events = node.collectEvents(startTimeMs = 500)
+
+      events.shouldBeEmpty()
+    }
+
+    test("children should always be empty for leaf node") {
+      val node = DelayNode(durationMs = 150)
+
+      node.children.shouldBeEmpty()
+    }
+
+    test("durationMs should be preserved") {
+      val node = DelayNode(durationMs = 300)
+
+      node.durationMs shouldBe 300
+    }
+
+    test("should support zero duration") {
+      val node = DelayNode(durationMs = 0)
+
+      assertSoftly {
+        node.durationMs shouldBe 0
+        node.collectEvents(startTimeMs = 0).shouldBeEmpty()
+      }
+    }
+  })

jindong/src/commonTest/kotlin/io/github/jindong/node/HapticEventNodeTest.kt

@@ -53,7 +53,7 @@ class HapticEventNodeTest :
       val events = node.collectEvents(startTimeMs = 0)
 
       events shouldHaveSize 1
-      with(events[0]) {
+      assertSoftly(events.single()) {
         durationMs shouldBe 250
         intensity shouldBe 0.3f
         iosParameters?.sharpness shouldBe 0.7f

jindong/src/commonTest/kotlin/io/github/jindong/node/ScheduledHapticEventTest.kt

@@ -54,10 +54,12 @@ class ScheduledHapticEventTest :
         iosParameters = iosParams,
       )
 
-      event.startTimeMs shouldBe 100
-      event.durationMs shouldBe 200
-      event.intensity shouldBe 0.5f
-      event.iosParameters shouldBe iosParams
-      event.iosParameters?.sharpness shouldBe 0.9f
+      assertSoftly(event) {
+        startTimeMs shouldBe 100
+        durationMs shouldBe 200
+        intensity shouldBe 0.5f
+        iosParameters shouldBe iosParams
+        iosParameters?.sharpness shouldBe 0.9f
+      }
     }
   })