Workflow

https://github.com/square/workflow-kotlin
Admin
Workflow is an application framework for Kotlin that provides architectural primitives for building...
Tokens:49,865
Snippets:225
Trust Score:9.4
License:Apache-2.0
Update:11 months ago
Show doc for...
Tokens:
Raw
### Setup TutorialActivity and ViewModel in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial1.md

Sets up the TutorialActivity to render the WelcomeWorkflow using an AndroidX ViewModel. The ViewModel manages the workflow's renderings via a lazy Flow, ensuring survival across configuration changes.

```kotlin
class TutorialActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val model: TutorialViewModel by viewModels()

    setContentView(
      WorkflowLayout(this).apply {
        take(lifecycle, model.renderings)
      }
    )
  }

  class TutorialViewModel(savedState: SavedStateHandle) : ViewModel() {
    @OptIn(WorkflowExperimentalRuntime::class)
    val renderings: Flow<Screen> by lazy {
      renderWorkflowIn(
        workflow = WelcomeWorkflow,
        scope = viewModelScope,
        savedStateHandle = savedState,
        runtimeConfig = RuntimeConfigOptions.ALL
      )
    }
  }
}
```

--------------------------------

### TodoListWorkflow Initial State with ShowList Step (Kotlin)

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial3.md

Sets the initial state for the `TodoListWorkflow`. It initializes the `todos` list with a sample item and sets the initial `step` to `Step.ShowList`, ensuring the workflow starts by displaying the list of todos.

```kotlin
object TodoListWorkflow : StatefulWorkflow<ListProps, State, Back, List<Screen>>() {

  // …

  override fun initialState(
    props: ListProps,
    snapshot: Snapshot?
  ) = State(
    todos = listOf(
      TodoModel(
        title = "Take the cat for a walk",
        note = "Cats really need their outside sunshine time. Don't forget to walk " +
          "Charlie. Hamilton is less excited about the prospect."
      )
    ),
    step = Step.ShowList
  )

// …
}
```

--------------------------------

### Initialize TodoListScreen and its Runner in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial2.md

This code snippet defines the initial structure for `TodoListScreen` and its associated `todoListScreenRunner`. The `TodoListScreen` is a placeholder, and the `todoListScreenRunner` sets up the `RecyclerView` and its adapter. This serves as a starting point before populating the screen with actual data.

```kotlin
data class TodoListScreen( 
  val TBD: String = ""
) : AndroidScreen<TodoListScreen> {
  override val viewFactory = 
    ScreenViewFactory.fromViewBinding(TodoListViewBinding::inflate, ::todoListScreenRunner)
}

private fun todoListScreenRunner(
  todoListBinding: TodoListViewBinding
): ScreenViewRunner<TodoListScreen> {
  // This outer scope is run only once, right after the view is inflated.
  val adapter = TodoListAdapter()

  todoListBinding.todoList.layoutManager = LinearLayoutManager(todoListBinding.root.context)
  todoListBinding.todoList.adapter = adapter

  return ScreenViewRunner { screen: TodoListScreen, _ ->
    // This inner lambda is run on each update.
  }
}
```

--------------------------------

### Install Markdown Linter

Source: https://github.com/square/workflow-kotlin/blob/main/RELEASING.md

Installs the 'mdl' (markdownlint) gem, a tool used for linting Markdown files to ensure consistent formatting. This is a prerequisite for running the documentation linter locally.

```bash
gem install mdl
```

--------------------------------

### Start RootWorkflow in Activity (Kotlin)

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial2.md

Updates the TutorialActivity to initiate the application's rendering flow using the RootNavigationWorkflow. It also adds a reportNavigation call to log navigation events.

```kotlin
  val renderings: Flow<Screen> by lazy {
    renderWorkflowIn(
      workflow = RootNavigationWorkflow,
      scope = viewModelScope,
      savedStateHandle = savedState
    ).reportNavigation {
      Log.i("navigate", it.toString())
    }
  }
```

--------------------------------

### Run Workflow Trace Viewer via Gradle

Source: https://github.com/square/workflow-kotlin/blob/main/workflow-trace-viewer/README.md

This command executes the Workflow Trace Viewer application using Gradle. Ensure you have Gradle installed and are in the project's root directory.

```shell
./gradlew :workflow-trace-viewer:run
```

--------------------------------

### Define initial TodoListWorkflow state in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial2.md

This snippet demonstrates how to define the `TodoListWorkflow` and its initial state. It includes a placeholder `State` data class and sets an initial value for it. This is a preliminary setup before adding actual todo items.

```kotlin
object TodoListWorkflow : StatefulWorkflow<Unit, State, Nothing, TodoListScreen>() {

  data class State(val placeholder: String = "")

  override fun initialState(
    props: Unit,
    snapshot: Snapshot?
  ): State = State("initial")

  override fun render(
    renderProps: Unit,
    renderState: State,
    context: RenderContext
  ): TodoListScreen {
    return TodoListScreen()
  }

  override fun snapshotState(state: State) = null
}

```

--------------------------------

### Identity Workflow Implementation for Compose Integration

Source: https://github.com/square/workflow-kotlin/blob/main/design-docs/compose-based-workflows-design.md

An example implementation of a workflow that acts as an identity wrapper, demonstrating a round-trip from workflow to compose and back. This showcases how different pieces of the integration wire up, using `renderWorkflow` within a composable context.

```kotlin
class IdentityWorkflow(
  private val child: Workflow<Props, Output, Rendering>
) : StatelessWorkflow<Props, Output, Rendering> {
  override fun render(props: Props, context: RenderContext): Rendering {
    return context.renderComposable { 
      renderWorkflow(child, props, onOutput = { output ->
        context.eventSink.send(action { setOutput(output) })
      })
    }
  }
}
```

--------------------------------

### Workflow to Compose: Usage Example in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/design-docs/compose-based-workflows-design.md

Demonstrates how to use `renderComposable` within a `MyWorkflow` class. It shows how to manage state using `rememberSaveable` and emit actions via the `actionSink` when events occur in the Composable.

```kotlin
class MyWorkflow : StatelessWorkflow {
  override fun render(props, context): Rendering {
    return context.renderComposable(key = "my-composable-key") {
      // rememberSaveable values are saved and restored via the workflow
      // snapshot mechanism.
      var someState by rememberSaveable { mutableStateOf("") }

      MyComposable(
        foo, props.something,
        onEvent = {
          // Outputs are emitted by just sending directly into the action sink.
          context.actionSink.send(action {
            setOutput(…)
          })
        }
      )
    }
  }
}
```

--------------------------------

### Realistic Sample: ComposeWorkflow with State and Effects in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/design-docs/compose-based-workflows-design.md

A detailed example of a `ComposeWorkflow` demonstrating state management using `rememberSaveable`, collecting data from a `StateFlow` using `collectAsState`, rendering child workflows, and emitting outputs.

```kotlin
class RootWorkflow @Inject constructor(
  // MyWorkflow is defined below – it's a workflow, but compose.
  private val child: SampleComposeWorkflow
) : StatelessWorkflow {
  override fun render(props, context): Rendering {
    // Here from a traditional workflow, render a compose one:
    context.renderChild(child, childProps, handler = { … })
  }
}

// Just some shared service object, defined somewhere else in the codebase.
interface Service {
  val values: StateFlow<String>
}

data class SampleRendering(
  val label: String,
  val onClick: () -> Unit
)

class SampleComposeWorkflow @Inject constructor(
  private val injectedService: Service,
  private val child: Workflow<String, String, String>
) : ComposeWorkflow<
  /* PropsT */ String,
  /* OutputT */ String,
  /* RenderingT */ SampleRendering
>() {

  @Composable
  override fun produceRendering(
    props: String,
    emitOutput: (String) -> Unit
  ): SampleRendering {
    // ComposeWorkflows use native compose idioms to manage state, including
    // saving state to be restored later. We don't need to implement the
    // snapshotState method or make aggregate state holders Parcelizable.
    var clickCount by rememberSaveable { mutableIntStateOf(0) }

    // They also use native compose idioms to work with Flows and perform
    // effects. To do this in a traditional workflow this is much more verbose:
    // you'd need to read the flow in initialState and then drop(1) before
    // collecting in the render method.
    val serviceValue by injectedService.values.collectAsState()

    // And they can render child workflows, just like traditional workflows.
    // This child can be any type of Workflow: Stateless, Stateful, Compose, it
    // doesn't matter.
    // This is equivalent to calling BaseRenderContext.renderChild().
    // Note that there's no explicit key: the child key is tied to where it's
    // called in the composition, the same way other composable state is keyed.
    val childRendering = renderWorkflow(
      workflow = child,
      props = "child props",
      // This is equivalent to the handler parameter on renderChild().
      onOutput = {
        myState = ???
        emitOutput("child emitted output: $it")
      }
    )

    return SampleRendering(
      // Reading clickCount and serviceValue here mean that when those values are
      // changed, it will trigger a render pass in the hosting workflow tree,
      // which will recompose this method.
      label = "props=$props, " +
        "clickCount=$clickCount, " +
        "serviceValue=$serviceValue, " +
        "childRendering=$childRendering",
      // Note the lack of rememberLamda: Compose automatically memoizes lambdas
      // created inside a composable, so we get that for free.
      onClick = {
        // Instead of using WorkflowAction's state property, you can just update
        // snapshot state objects directly.
        clickCount++

        // This is equivalent to calling setOutput from a WorkflowAction.
        emitOutput("clicked!")
      }
    )
  }
}
```

--------------------------------

### Test TodoEditWorkflow Back Press Discard in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial5.md

This example shows how to test the back press functionality of `TodoEditWorkflow`. It sets up the initial props, renders the workflow, simulates a back press, and verifies that the `DiscardChanges` output is emitted.

```kotlin
class TodoEditWorkflowTest {
  @Test fun `back press discards`() {
    val props = Props(TodoModel(title = "Title", note = "Note"))

    TodoEditWorkflow.testRender(props)
      .render {
        it.onBackPressed()
      }.verifyActionResult {
        assertSame(DiscardChanges, it?.value)
      }
  }
}
```

--------------------------------

### Define Workflow State and Initial State in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial1.md

This snippet demonstrates how to define the internal state of a workflow using a data class and how to provide an initial state for the workflow. It's crucial for initializing the workflow's data when it starts. Dependencies include the `StateT` type and `StatefulWorkflow`.

```kotlin
object WelcomeWorkflow : StatefulWorkflow<Unit, State, Output, WelcomeScreen>() {

  data class State(
    val prompt: String
  )

  // …

  override fun initialState(
    props: Unit,
    snapshot: Snapshot?
  ): State = State(prompt = "Hello Workflow!")

  override fun render(
    renderProps: Unit,
    renderState: State,
    context: RenderContext
  ): WelcomeScreen = WelcomeScreen(
    promptText = renderState.prompt,
    onLogInTapped = {}
  )


  // …
}

```

--------------------------------

### Integrate TodoListWorkflow into Activity in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial2.md

This snippet shows how to integrate the `TodoListWorkflow` into the application's activity. It uses `renderWorkflowIn` to start rendering the workflow within a `viewModelScope`, utilizing the `savedStateHandle`. The `renderings` property, a `Flow<Screen>`, will emit the `TodoListScreen` when it's ready to be displayed.

```kotlin
  val renderings: Flow<Screen> by lazy {
    renderWorkflowIn(
      workflow = TodoListWorkflow,
      scope = viewModelScope,
      savedStateHandle = savedState
    )
  }

```

--------------------------------

### Get Android App Runtime Configuration

Source: https://github.com/square/workflow-kotlin/blob/main/workflow-config/README.md

Retrieves the workflow runtime configuration for Android applications. This utility is used to fetch the configured `RuntimeConfig` which needs to be passed to `renderWorkflowIn` or `renderAsState`.

```kotlin
val runtimeConfig = AndroidRuntimeConfigTools.getAppWorkflowRuntimeConfig()
```

--------------------------------

### Define WelcomeWorkflow in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial1.md

This code defines the `WelcomeWorkflow` class, a stateful workflow for the welcome screen. It includes placeholder implementations for `State`, `Output`, `initialState`, `render`, and `snapshotState`, which need to be completed.

```kotlin
object WelcomeWorkflow : StatefulWorkflow<Unit, State, Output, WelcomeScreen>() {

  object State
  object Output

  override fun initialState(
    props: Unit,
    snapshot: Snapshot?
  ): State = TODO("Initialize state")

  override fun render(
    renderProps: Unit,
    renderState: State,
    context: RenderContext
  ): Screen {
    TODO("Render")
  }

  override fun snapshotState(state: State): Snapshot? = Snapshot.write {
    TODO("Save state")
  }
}
```

--------------------------------

### Get JVM Test Runtime Configuration

Source: https://github.com/square/workflow-kotlin/blob/main/workflow-config/README.md

Retrieves the test runtime configuration for JVM-based tests. This utility is used when a runtime other than the default `WorkflowTestRuntime` is selected via Gradle properties.

```kotlin
val runtimeConfig = JvmTestRuntimeConfigTools.getTestRuntimeConfig()
```

--------------------------------

### Define WelcomeScreen in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial1.md

This code defines the `WelcomeScreen` class, which implements the `AndroidScreen` interface. It sets up the view factory using view binding and provides a placeholder for the `welcomeScreenRunner` function to update the UI elements.

```kotlin
import workflow.tutorial.views.databinding.WelcomeViewBinding

data class WelcomeScreen(
  // TODO: add properties needed to update WelcomeViewBinding
) : AndroidScreen<WelcomeScreen> {

  override val viewFactory = 
    ScreenViewFactory.fromViewBinding(WelcomeViewBinding::inflate, ::welcomeScreenRunner)
}

private fun welcomeScreenRunner(
  private val viewBinding: WelcomeViewBinding
) = ScreenViewRunner<WelcomeScreen> { screen: WelcomeScreen, environment: ViewEnvironment ->
  TODO("Update viewBinding from screen")
}
```

--------------------------------

### Directly Use ScreenComposableFactory for Decoupled UI

Source: https://github.com/square/workflow-kotlin/blob/main/workflow-ui/compose/README.md

Demonstrates using `ScreenComposableFactory` directly to decouple screen rendering types from their Compose UI code. This example creates a factory for `ContactScreen` and integrates it into the `ViewEnvironment` for rendering.

```kotlin
import androidx.compose.foundation.layout.Column
import androidx.compose.material.Text
import androidx.compose.runtime.Composable

data class ContactScreen(
  val name: String,
  val phoneNumber: String
): Screen

val contactUiFactory = ScreenComposableFactory<ContactScreen> { screen ->
  Column {
    Text(screen.name)
    Text(screen.phoneNumber)
  }
}

private val viewEnvironment = ViewEnvironment.EMPTY +
    (ViewRegistry to ViewRegistry(contactUiFactory))
    .withComposeInteropSupport()

renderWorkflowIn(
    workflow = HelloWorkflow.mapRendering {
      it.withEnvironment(viewEnvironment)
    },
    scope = viewModelScope,
    savedStateHandle = savedState,
)
```

--------------------------------

### Implement ScreenViewRunner for View Updates

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial1.md

Provides a `welcomeScreenRunner` function that creates a `ScreenViewRunner`. This runner is responsible for updating the UI elements of a `WelcomeViewBinding` based on the data provided by a `WelcomeScreen` object. It sets the prompt text and configures the click listener for the login button.

```kotlin
private fun welcomeScreenRunner(
  viewBinding: WelcomeViewBinding
) = ScreenViewRunner { screen: WelcomeScreen, _ ->
  viewBinding.prompt.text = screen.promptText
  viewBinding.logIn.setOnClickListener {
    screen.onLogInTapped(viewBinding.username.text.toString())
  }
}
```

--------------------------------

### Kotlin Integration Test for RootNavigationWorkflow

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial5.md

This snippet demonstrates an integration test for a RootNavigationWorkflow using `launchForTestingFromStartWith`. It simulates user interactions by awaiting renderings, updating screen states, and asserting expected outcomes. This test verifies the flow between different screens and ensures data updates correctly.

```kotlin
class RootNavigationWorkflowTest {

  // …

  @Test fun `app flow`() {
    RootNavigationWorkflow.launchForTestingFromStartWith {
      // First rendering is just the welcome screen. Update the name.
      awaitNextRendering().let { rendering ->
        assertEquals(1, rendering.frames.size)
        val welcomeScreen = rendering.frames[0] as WelcomeScreen

        // Enter a name and tap login
        welcomeScreen.onLogInTapped("Ada")
      }

      // Expect the todo list to be rendered. Edit the first todo.
      awaitNextRendering().let { rendering ->
        assertEquals(2, rendering.frames.size)
        assertTrue(rendering.frames[0] is WelcomeScreen)
        val todoScreen = rendering.frames[1] as TodoListScreen
        assertEquals(1, todoScreen.todoTitles.size)

        // Select the first todo.
        todoScreen.onRowPressed(0)
      }

      // Selected a todo to edit. Expect the todo edit screen.
      awaitNextRendering().let { rendering ->
        assertEquals(3, rendering.frames.size)
        assertTrue(rendering.frames[0] is WelcomeScreen)
        assertTrue(rendering.frames[1] is TodoListScreen)
        val editScreen = rendering.frames[2] as TodoEditScreen

        // Enter a title and save.
        editScreen.title.textValue = "New Title"
        editScreen.onSavePressed()
      }

      // Expect the todo list. Validate the title was updated.
      awaitNextRendering().let { rendering ->
        assertEquals(2, rendering.frames.size)
        assertTrue(rendering.frames[0] is WelcomeScreen)
        val todoScreen = rendering.frames[1] as TodoListScreen

        assertEquals(1, todoScreen.todoTitles.size)
        assertEquals("New Title", todoScreen.todoTitles[0])
      }
    }
  }
}
```

--------------------------------

### Test RootNavigationWorkflow Welcome State Rendering (Kotlin)

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial5.md

Tests the initial 'ShowingWelcome' state of the RootNavigationWorkflow. It mocks the expected WelcomeWorkflow, asserts the rendering of the WelcomeScreen, and verifies that no action is produced during this initial render.

```kotlin
class RootNavigationWorkflowTest {

  @Test fun `welcome rendering`() {
    RootNavigationWorkflow
      // Start in the ShowingWelcome state
      .testRender(initialState = ShowingWelcome, props = Unit)
      // The `WelcomeWorkflow` is expected to be started in this render.
      .expectWorkflow(
        workflowType = WelcomeWorkflow::class,
        rendering = WelcomeScreen(
          promptText = "Well hello there!",
          onLogInTapped = {}
        )
      )
      // Now, validate that there is a single item in the BackStackScreen,
      // which is our welcome screen.
      .render { rendering ->
        val frames = rendering.frames
        assertEquals(1, frames.size)

        val welcomeScreen = frames[0] as WelcomeScreen
        assertEquals("Well hello there!", welcomeScreen.promptText)
      }
      // Assert that no action was produced during this render,
      // meaning our state remains unchanged
      .verifyActionResult { _, output ->
        assertNull(output)
      }
  }
}
```

--------------------------------

### Define Root Navigation Workflow (Kotlin)

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial2.md

Defines the RootNavigationWorkflow as a StatefulWorkflow that renders a Screen. It delegates rendering to a child WelcomeWorkflow and handles its output type. Initially, it's set up to display the WelcomeScreen.

```kotlin
object RootNavigationWorkflow : StatefulWorkflow<Unit, Unit, Nothing, Screen>() {

  override fun initialState(
    props: Unit,
    snapshot: Snapshot?
  ): Unit = Unit

  override fun render(
    renderProps: Unit,
    renderState: Unit,
    context: RenderContext
  ): Screen {
    // Render a child workflow of type WelcomeWorkflow. When renderChild is called, the
    // infrastructure will start a child workflow session if one is not already running.
    val welcomeScreen = context.renderChild(WelcomeWorkflow) { output ->
    }
    return welcomeScreen
  }

  override fun snapshotState(state: Unit): Snapshot? = null
}
```

--------------------------------

### Test RootNavigationWorkflow Login Transition (Kotlin)

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial5.md

Tests the transition from the 'ShowingWelcome' state to the 'ShowingTodo' state in RootNavigationWorkflow. It simulates a login event by providing an output from the mocked WelcomeWorkflow and verifies the resulting state change.

```kotlin
  @Test fun `login event`() {
    RootNavigationWorkflow
      // Start in the Welcome state
      .testRender(initialState = ShowingWelcome, props = Unit)
      // The WelcomeWorkflow is expected to be started in this render.
      .expectWorkflow(
        workflowType = WelcomeWorkflow::class,
        rendering = WelcomeScreen(
          promptText = "yo",
          onLogInTapped = {}
        ),
        // Simulate the WelcomeWorkflow sending an output of LoggedIn
        // as if the "log in" button was tapped.
        output = WorkflowOutput(LoggedIn(username = "Ada"))
      )
      // Now, validate that there is a single item in the BackStackScreen,
      // which is our welcome screen (prior to the output).
      .render { rendering ->
        val backstack = rendering.frames
        assertEquals(1, backstack.size)

        val welcomeScreen = backstack[0] as WelcomeScreen
      }
      // Assert that the state transitioned to Todo.
      .verifyActionResult { newState, _ ->
        assertEquals(ShowingTodo(username = "Ada"), newState)
      }
```

--------------------------------

### Define WelcomeScreen Data Model

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial1.md

Defines a Kotlin data class `WelcomeScreen` that implements `AndroidScreen`. This class serves as a view model for a UI screen, holding displayable text and an event handler for user interactions. It includes parameters for the prompt text and a callback for a login tap event.

```kotlin
import com.squareup.workflow1.ui.AndroidScreen
import com.squareup.workflow1.ui.ScreenViewFactory
import com.squareup.workflow1.ui.ScreenViewRunner
import com.squareup.workflow1.ui.ViewEnvironment

/**
 * @param promptText message to show the user
 * @param onLogInTapped Log In button event handler
 */
data class WelcomeScreen(
  val promptText: String,
  val onLogInTapped: (String) -> Unit
) : AndroidScreen<WelcomeScreen> {
  override val viewFactory = ScreenViewFactory.fromViewBinding(WelcomeViewBinding::inflate, ::welcomeScreenRunner)
}
```

--------------------------------

### Create a Worker that Transforms Output in Kotlin

Source: https://context7.com/square/workflow-kotlin/llms.txt

Demonstrates how to transform the output of an existing Worker using the `transform` function. This example creates a `DataSyncWorker` and then applies a transformation to convert its `SyncProgress` output into a flow of Float representing percentage completion.

```kotlin
// Worker that transforms output
class DataSyncWorker(private val api: ApiService) : Worker<SyncProgress> {
    override fun run() = flow {
        emit(SyncProgress.Starting)
        val data = api.fetchData()
        emit(SyncProgress.Processing(0.5f))
        api.uploadData(data)
        emit(SyncProgress.Complete)
    }
}

val percentageWorker = DataSyncWorker(api).transform { flow ->
    flow.map { progress ->
        when (progress) {
            is SyncProgress.Starting -> 0.0f
            is SyncProgress.Processing -> progress.percent
            is SyncProgress.Complete -> 1.0f
        }
    }
}
```

--------------------------------

### Render Child Workflow - Compose Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/design-docs/workflow-idioms-in-compose.md

Illustrates rendering a child workflow in a Compose context using Kotlin. It mirrors the Workflow Kotlin example, adapting the child workflow integration for Compose's `@Composable` functions and `ComposeWorkflow`.

```kotlin
interface MyChild : Workflow<ChildProps, ChildOutput, ChildRendering>

data class Props(val propsForChild: ChildProps)
data class Output(val outputFromChild: ChildOutput)
data class Rendering(val renderingFromChild: ChildRendering)

class MyWorkflow @Inject constructor(
  private val child: MyChild
) : ComposeWorkflow<Props, Output, Rendering>() {
  @Composable
  override fun produceRendering(props, emitOutput): Rendering {
    val childRendering = renderWorkflow(
      props = props.propsForChild,
      onOutput = { childOutput ->
        emitOutput(Output(childOutput))
      }
    )

    return Rendering(
      renderingFromChild = childRendering
    )
  }
}
```

--------------------------------

### Define WelcomeWorkflow in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial1.md

Defines the WelcomeWorkflow which provides a rendering for the application state. It opts out of persistence by returning null from snapshotState.

```kotlin
object WelcomeWorkflow : StatefulWorkflow<Unit, State, Output, WelcomeScreen>() {

  // …

  override fun render(
    renderProps: Unit,
    renderState: State,
    context: RenderContext
  ): WelcomeScreen = WelcomeScreen(
    promptText = "",
    onLogInTapped = {}
  )



  override fun snapshotState(state: State): Snapshot? = null
}
```

--------------------------------

### Run Workflow in Coroutine Scope (Kotlin)

Source: https://context7.com/square/workflow-kotlin/llms.txt

Provides a suspend function example for running a workflow in a non-Android environment using a `CoroutineScope`. It sets up props, collects renderings, and prints them to the console. Dependencies include `CoroutineScope`, `Dispatchers.Default`, `Job`, and `MutableStateFlow`.

```kotlin
suspend fun runWorkflow() {
    val scope = CoroutineScope(Dispatchers.Default + Job())
    val props = MutableStateFlow(MyProps())

    val renderings = renderWorkflowIn(
        workflow = myWorkflow,
        scope = scope,
        props = props,
        onOutput = { output ->
            println("Workflow output: $output")
        }
    )

    renderings.collect { (rendering, snapshot) ->
        println("New rendering: $rendering")
    }
}
```

--------------------------------

### Define Root Navigation State and Actions (Kotlin)

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial2.md

Defines the internal state and actions for the RootNavigationWorkflow. The state tracks whether the 'Welcome' or 'ShowingTodo' screen is displayed, including the username for the 'ShowingTodo' state. Actions for 'logIn' and 'logOut' are defined to transition between these states.

```kotlin
object RootNavigationWorkflow : StatefulWorkflow<Unit, State, Nothing, WelcomeScreen>() {

  sealed interface State {
    object ShowingWelcome : State
    data class ShowingTodo(val username: String) : State
  }

  override fun initialState(
    props: Unit,
    snapshot: Snapshot?
  ): State = ShowingWelcome

  // …

  private fun logIn(username: String) = action("logIn") {
    state = ShowingTodo(username)
  }

  private val logOut = action("logOut") {
    state = ShowingWelcome
  }
}
```

--------------------------------

### Emit LoggedIn Output on Button Tap in Welcome Workflow

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial2.md

Demonstrates how to set an output from the `WelcomeWorkflow` when a 'Log In' button is tapped. It includes a check for an empty username and emits a `LoggedIn` output with the provided name if valid.

```kotlin
  ): WelcomeScreen = WelcomeScreen(
    promptText = renderState.prompt,
    onLogInTapped = context.eventHandler("onLogInTapped") { name ->
      if (name.isEmpty()) {
        state = state.copy(prompt = "name required to log in")
      } else {
        setOutput(LoggedIn(name))
      }
    }
  )
```

--------------------------------

### Define TodoWorkflow Actions in Kotlin

Source: https://context7.com/square/workflow-kotlin/llms.txt

Demonstrates how to define custom actions for state management within a TodoWorkflow. It includes actions for adding, toggling, and saving todo items, as well as starting an edit mode. These actions modify the workflow's state and can emit outputs.

```kotlin
class TodoWorkflow : StatefulWorkflow<Unit, TodoState, TodoOutput, TodoRendering>() {

    data class TodoState(
        val items: List<TodoItem>,
        val editingId: String? = null
    )

    // Action that adds a new todo item
    private fun addTodo(text: String) = action("add-todo") {
        state = state.copy(
            items = state.items + TodoItem(
                id = generateId(),
                text = text,
                completed = false
            )
        )
    }

    // Action that toggles completion status
    private fun toggleTodo(id: String) = action("toggle-todo") {
        state = state.copy(
            items = state.items.map { item ->
                if (item.id == id) item.copy(completed = !item.completed)
                else item
            }
        )
    }

    // Action that updates text and emits output
    private fun saveTodo(id: String, newText: String) = action("save-todo") {
        val updated = state.items.find { it.id == id }?.copy(text = newText)
        if (updated != null) {
            state = state.copy(
                items = state.items.map { if (it.id == id) updated else it },
                editingId = null
            )
            setOutput(TodoOutput.TodoSaved(id))
        }
    }

    // Safe action that only runs if state is still the expected type
    private fun startEditing(currentItems: List<TodoItem>, id: String) =
        safeAction<TodoState>("start-editing") { currentState ->
            // This only runs if state hasn't changed to a different type
            // Useful for handling potentially stale events
            state = currentState.copy(editingId = id)
        }

    override fun initialState(props: Unit, snapshot: Snapshot?) = TodoState(emptyList())

    override fun render(
        renderProps: Unit,
        renderState: TodoState,
        context: RenderContext<Unit, TodoState, TodoOutput>
    ): TodoRendering {
        return TodoRendering(
            items = renderState.items.map { item ->
                TodoItemRendering(
                    text = item.text,
                    completed = item.completed,
                    isEditing = item.id == renderState.editingId,
                    onToggle = context.eventHandler {
                        actionSink.send(toggleTodo(item.id))
                    },
                    onEdit = context.eventHandler {
                        actionSink.send(startEditing(renderState.items, item.id))
                    },
                    onSave = context.eventHandler { newText: String ->
                        actionSink.send(saveTodo(item.id, newText))
                    }
                )
            },
            onAdd = context.eventHandler { text: String ->
                actionSink.send(addTodo(text))
            }
        )
    }

    override fun snapshotState(state: TodoState) = Snapshot.of(state.items)
}
```

--------------------------------

### Handle LoggedIn Output in RootNavigationWorkflow

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial2.md

Shows how the `RootNavigationWorkflow` handles the `LoggedIn` output emitted by the `WelcomeWorkflow`. The output is mapped to a `logIn` action within the parent workflow, facilitating navigation or state changes.

```kotlin
  override fun render(
    renderProps: Unit,
    renderState: State,
    context: RenderContext
  ): WelcomeScreen {
    // Render a child workflow of type WelcomeWorkflow. When renderChild is called, the
    // infrastructure will start a child workflow session if one is not already running.
    val welcomeScreen = context.renderChild(WelcomeWorkflow) { output ->
      // When WelcomeWorkflow emits its LoggedIn output, map that to our logIn action.
      logIn(output.username)
    }
    return welcomeScreen
  }
```

--------------------------------

### Define TodoListScreen and its View Runner in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial2.md

Defines the `TodoListScreen` data class, which represents the UI for the todo list. It includes a `viewFactory` that inflates `TodoListViewBinding` and sets up a `RecyclerView` with a `TodoListAdapter`. The `todoListScreenRunner` function is responsible for initializing the adapter and handling screen updates by providing the list of todo titles.

```kotlin
data class TodoListScreen(
  val todoTitles: List<String>
) : AndroidScreen<TodoListScreen> {
  override val viewFactory = 
    ScreenViewFactory.fromViewBinding(TodoListViewBinding::inflate, ::todoListScreenRunner)
}

private fun todoListScreenRunner(
  todoListBinding: TodoListViewBinding
): ScreenViewRunner<TodoListScreen> {
  val adapter = TodoListAdapter()

  todoListBinding.todoList.layoutManager = LinearLayoutManager(todoListBinding.root.context)
  todoListBinding.todoList.adapter = adapter

  return ScreenViewRunner { screen: TodoListScreen, _ ->
    adapter.todoList = screen.todoTitles
    adapter.notifyDataSetChanged()
 }
}
```

--------------------------------

### Configure Kotlin Multiplatform Targets via Gradle

Source: https://github.com/square/workflow-kotlin/blob/main/workflow-core/README.md

This example demonstrates how to configure the build and test targets for a Kotlin Multiplatform project using Gradle properties. It allows specifying targets like 'jvm', 'ios', or 'js', with 'kmp' as the default to include all targets. This is useful for customizing builds based on specific needs.

```bash
./gradlew build -Pworkflow.targets=jvm
```

--------------------------------

### Build and Publish Snapshot Artifacts with Gradle

Source: https://github.com/square/workflow-kotlin/blob/main/RELEASING.md

Provides the bash command to clean, build, and publish snapshot artifacts to Sonatype. This command assumes the gradle.properties file is correctly configured with the '-SNAPSHOT' suffix.

```bash
./gradlew clean build && ./gradlew publish
```

--------------------------------

### Render RootNavigationWorkflow with BackStackScreen

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial2.md

Updates the RootNavigationWorkflow to use BackStackScreen as its render type, enabling declarative animation of screen changes. It conditionally renders welcome and todo list screens based on the state and handles child workflow outputs.

```kotlin
object RootNavigationWorkflow : StatefulWorkflow<Unit, State, Nothing, BackStackScreen<*>>() {

  // …

  override fun render(
    renderProps: Unit,
    renderState: State,
    context: RenderContext
  ): BackStackScreen<*> {
    // We always render the welcomeScreen regardless of the current state.
    // It's either showing or else we may want to pop back to it.
    val welcomeScreen = context.renderChild(WelcomeWorkflow) { loggedIn ->
      // When WelcomeWorkflow emits LoggedIn, enqueue our log in action.
      logIn(loggedIn.username)
    }

    return when (renderState) {
      is ShowingWelcome -> {
        BackStackScreen(welcomeScreen)
      }

      is ShowingTodo -> {
        val todoBackStack = context.renderChild(
          child = TodoListWorkflow,
          props = ListProps(renderState.username),
          handler = {
            // When TodoNavigationWorkflow emits Back, enqueue our log out action.
            logOut
          }
        )
        listOf(welcomeScreen, todoBackStack).toBackStackScreen()
      }
    }
  }

```

--------------------------------

### Test Failed Login and Error Prompt in WelcomeWorkflow (Kotlin)

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial5.md

Tests the `WelcomeWorkflow` to verify that an attempted login with an empty username does not emit any output and subsequently displays an error prompt. It uses `verifyActionResult` to check for no output and `testNextRender` to assert the error message.

```kotlin
  @Test fun `failed log in`() {
    WelcomeWorkflow.testRender(props = Unit)
      .render { screen ->
        // Simulate a log in button tap with an empty name.
        screen.onLogInTapped("")
      }
      .verifyActionResult { _, output ->
        // No output will be emitted, as the name is empty.
        assertNull(output)
      }
      .testNextRender()
      .render { screen ->
        // There is an error prompt.
        assertEquals("name required to log in", screen.promptText)
      }
  }
```

--------------------------------

### Integrate TodoListWorkflow into RootNavigationWorkflow

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial3.md

Updates the RootNavigationWorkflow to handle the List<Screen> output from TodoListWorkflow. It renders the TodoListWorkflow and incorporates its returned list of screens into the BackStackScreen, ensuring proper navigation.

```kotlin
object RootNavigationWorkflow : StatefulWorkflow<Unit, State, Nothing, BackStackScreen<*>>() {

  // ...

  override fun render(
    renderProps: Unit,
    renderState: State,
    context: RenderContext
  ): BackStackScreen<*> {
      // …

      is ShowingTodo -> {
        val todoBackStack = context.renderChild(
          child = TodoListWorkflow,
          props = ListProps(renderState.username),
          handler = {
            // When TodoNavigationWorkflow emits Back, enqueue our log out action.
            logOut
          }
        )
        (listOf(welcomeScreen) + todoBackStack).toBackStackScreen()
      }
    }

    // …
  }


```

--------------------------------

### Launch Workflow Runtime in Android Activity (Kotlin)

Source: https://context7.com/square/workflow-kotlin/llms.txt

Shows how to launch the workflow runtime within an Android `ComponentActivity`. It sets up props, renders the workflow, handles outputs like logout or errors, and observes renderings to update the UI and save snapshots for restoration. Dependencies include `lifecycleScope`, `ComponentActivity`, `SavedInstanceState`, `Toast`, and `MutableStateFlow`.

```kotlin
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Create props flow
        val propsFlow = MutableStateFlow(AppProps(userId = getCurrentUserId()))

        // Launch workflow runtime
        val renderingsAndSnapshots = renderWorkflowIn(
            workflow = appWorkflow,
            scope = lifecycleScope,
            props = propsFlow,
            initialSnapshot = savedInstanceState?.getParcelable("workflow_snapshot"),
            interceptors = listOf(LoggingWorkflowInterceptor()),
            runtimeConfig = RuntimeConfigOptions.DEFAULT_CONFIG,
            onOutput = { output ->
                when (output) {
                    is AppOutput.Logout -> {
                        clearSession()
                        recreate()
                    }
                    is AppOutput.ShowError -> {
                        Toast.makeText(this, output.message, Toast.LENGTH_LONG).show()
                    }
                }
            }
        )

        // Observe renderings
        lifecycleScope.launch {
            renderingsAndSnapshots.collect { (rendering, snapshot) ->
                // Update UI with rendering
                updateUi(rendering)

                // Save snapshot for restoration
                currentSnapshot = snapshot
            }
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState) 
        currentSnapshot?.let {
            outState.putParcelable("workflow_snapshot", it)
        }
    }
}

```

--------------------------------

### Implement TodoListWorkflow in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial2.md

Implements the `TodoListWorkflow`, a `StatefulWorkflow` responsible for managing the state and rendering the `TodoListScreen`. It defines `TodoModel` for individual todo items and the workflow's `State` which holds a list of these models. The `initialState` is populated with sample data, and the `render` function maps the todo titles from the state to be displayed on the screen. `snapshotState` is currently not implemented.

```kotlin
object TodoListWorkflow : StatefulWorkflow<Unit, State, Nothing, TodoListScreen>() {

  data class TodoModel(
    val title: String,
    val note: String
  )

  data class State(
    val todos: List<TodoModel>
  )

  override fun initialState(
    props: Unit,
    snapshot: Snapshot?
  ) = State(
    listOf(
      TodoModel(
        title = "Take the cat for a walk",
        note = "Cats really need their outside sunshine time. Don't forget to walk " +
          "Charlie. Hamilton is less excited about the prospect."
      )
    )
  )

  override fun render(
    renderProps: Unit,
    renderState: State,
    context: RenderContext
  ): TodoListScreen {
    val titles = renderState.todos.map { it.title }

    return TodoListScreen(
      todoTitles = titles,
    )
  }

  override fun snapshotState(state: State) = null
}
```

--------------------------------

### Implement TodoEditScreen with Data and Callbacks (Kotlin)

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial3.md

Enhances the TodoEditScreen by adding properties for the todo item's title and note, using TextController for efficient text management. It also includes callback functions for back navigation and saving, and updates the view runner to bind these properties and event handlers to the UI elements.

```kotlin
data class TodoEditScreen(
  /** The title of this todo item. */
  val title: TextController,
  /** The contents, or "note" of the todo. */
  val note: TextController,

  val onBackPressed: () -> Unit,
  val onSavePressed: () -> Unit
) : AndroidScreen<TodoEditScreen> {
  override val viewFactory = 
    ScreenViewFactory.fromViewBinding(TodoEditViewBinding::inflate, ::todoEditScreenRunner)
}

private fun todoEditScreenRunner(
  binding: TodoEditViewBinding
) = ScreenViewRunner { screen: TodoEditScreen, _ ->
  binding.root.setBackHandler(screen.onBackPressed)
  binding.save.setOnClickListener { screen.onSavePressed() }

  screen.title.control(binding.todoTitle)
  screen.note.control(binding.todoNote)
}
```

--------------------------------

### Test Successful Login Action in WelcomeWorkflow (Kotlin)

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial5.md

Tests the `WelcomeWorkflow` to ensure that a successful login action emits the correct user name as output. It simulates tapping the login button and verifies the output using `verifyActionResult`.

```kotlin
class WelcomeWorkflowTest {
  @Test fun `successful log in`() {
    WelcomeWorkflow
      .testRender(props = Unit)
      // Simulate a log in button tap.
      .render { screen ->
        screen.onLogInTapped("Ada")
      }
      // Validate that LoggedIn was sent.
      .verifyActionResult { _, output ->
        assertEquals(LoggedIn("Ada"), output?.value)
      }
  }
}
```

--------------------------------

### Define TodoEditScreen UI Structure (Kotlin)

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial3.md

Defines the basic structure of the TodoEditScreen, which serves as the rendering type and layout runner for editing todo items. It includes placeholders for properties needed to update the UI and specifies the view factory for inflation and running the screen.

```kotlin
data class TodoEditScreen(
  // TODO: add properties needed to update TodoEditViewBinding
) : AndroidScreen<TodoEditScreen> {
  override val viewFactory = 
    ScreenViewFactory.fromViewBinding(TodoEditViewBinding::inflate, ::todoEditScreenRunner)
}

private fun todoEditScreenRunner(
  binding: TodoEditViewBinding
) = ScreenViewRunner { screen: TodoEditScreen, _ ->
  // TODO
}
```

--------------------------------

### Test Workflow Rendering with RenderTester (Kotlin)

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial5.md

Uses the `testRender` extension on `Workflow` to create a `RenderTester`. This allows testing the output of the `render()` method and chaining assertions on the rendering. It can also verify state changes and actions triggered by screen interactions.

```kotlin
workflow.testRender(props = Props())
  .render { rendering ->
    assertEquals("expected text on rendering", rendering.text)
  }
```

```kotlin
workflow.testRender(props = Props())
  .render { rendering ->
    assertEquals("expected text on rendering", rendering.text)
    rendering.updateText("updated")
  }
  .verifyActionResult { newState, output ->
    assertEquals(State(text = "updated"), newState)
  }
```

--------------------------------

### Define TodoListWorkflow Props, State, and Outputs (Kotlin)

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial4.md

Defines the properties, state, and output events for the TodoListWorkflow. It now accepts todos as props and defines outputs for back press and todo selection.

```kotlin
object TodoListWorkflow : StatefulWorkflow<ListProps, State, Output, TodoListScreen>() {

  data class ListProps(
    val username: String,
    val todos: List<TodoModel>
  )

  object State

  sealed interface Output {
    object BackPressed : Output
    data class TodoSelected(val index: Int) : Output
  }

  override fun initialState(
    props: ListProps,
    snapshot: Snapshot?
  )

  override fun render(
    renderProps: ListProps,
    renderState: State,
    context: RenderContext
  ): TodoListScreen {
    // …
  }

  override fun snapshotState(state: State): Snapshot? = null

  // …

}
```

--------------------------------

### Implement TodoEditWorkflow Render Method and Outputs

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial3.md

Implements the render method for TodoEditWorkflow to return a TodoEditScreen and defines Output types for discarding or saving changes. Event handlers for save and back buttons are included to emit the appropriate Output.

```kotlin
object TodoEditWorkflow : StatefulWorkflow<EditProps, State, Output, TodoEditScreen>() {

  // …

  sealed interface Output {
    object DiscardChanges : Output
    data class SaveChanges(val todo: TodoModel) : Output
  }

  // …

  override fun render(
    renderProps: Props,
    renderState: State,
    context: RenderContext
  ): TodoEditScreen = TodoEditScreen(
    title = renderState.editedTitle,
    note = renderState.editedNote,
    onSavePressed = context.eventHandler("onSavePressed") {
      setOutput(SaveChanges(state.toModel()))
    },
    onBackPressed = context.eventHandler("onBackPressed") {
      setOutput(DiscardChanges)
    }
  )

  // …
}
```

--------------------------------

### Comprehensive Workflow Test with RenderTester

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial5.md

Illustrates a complete workflow test scenario using RenderTester. It chains expectWorkflow, expectWorker, render assertions, and verifyActionResult to test the entire lifecycle of a workflow, including its rendering, state changes, and outputs.

```kotlin
workflow
  .testRender(
    props = Props(),
    initialState = State()
  )
  .expectWorkflow(
    workflowType = ChildWorkflow::class,
    rendering = ChildScreen(),
    output = WorkflowOutput(Closed)
  )
  .expectWorker(
    worker = TestWorker(),
    output = WorkflowOutput(Finished)
  )
  .render { rendering ->
    assertEquals("expected text on rendering", rendering.text)
  }
  .verifyActionResult { newState, output ->
    assertEquals(State(text = "updated"), newState)
    assertEquals(Completed, output?.value)
  }
```

--------------------------------

### Splitting Baseline Profiles with Java Tool

Source: https://github.com/square/workflow-kotlin/blob/main/benchmarks/README.md

Command-line usage of a Java utility to split baseline profile files based on checkout paths. This allows for modular integration of performance profiles into different application modules.

```bash
java -jar splitBaselineProfiles-all.jar --profilePath ~/path/to/profile.txt --checkoutPath ~/Development/workflow-kotlin/
```

--------------------------------

### Test WorkflowAction Apply Function in Kotlin

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial5.md

This snippet illustrates how to unit test a `WorkflowAction`'s `apply` function using the `applyTo` extension method. It shows how to provide props and state, and then inspect the resulting `newState` and optional `output` to ensure correct state transitions and output emission.

```kotlin
val (newState: State, output: WorkflowOutput<Output>?) = TestedWorkflow.someAction()
  .applyTo(
    props = Props(…),
    state = State(…)
  )

if (output != null) {
  // The action set an output.
} else {
  // The action did not call setOutput.
}
```

--------------------------------

### Test Workflow Integration with Turbine

Source: https://context7.com/square/workflow-kotlin/llms.txt

Demonstrates integration testing of a complete login flow using WorkflowTurbine. It verifies navigation from the initial login screen to the main screen after successful authentication. This requires the core workflow library and testing utilities.

```kotlin
class AppWorkflowIntegrationTest {
    @Test
    fun `complete login flow navigates to main screen`() = runTest {
        val appWorkflow = AppWorkflow(
            loginWorkflow = LoginWorkflow(FakeAuthService()),
            mainWorkflow = MainWorkflow()
        )

        appWorkflow.testFromStart { turbine ->
            // Initial rendering should show login
            turbine.awaitNextRendering().let { rendering ->
                assertThat(rendering).isInstanceOf(AppRendering.ShowLogin::class.java)
            }

            // Submit login credentials
            turbine.sendAction { rendering ->
                (rendering as AppRendering.ShowLogin).loginRendering.onSubmit(
                    "user@example.com",
                    "password"
                )
            }

            // Wait for login to complete and main screen to show
            turbine.awaitNextRendering().let { rendering ->
                assertThat(rendering).isInstanceOf(AppRendering.ShowMain::class.java)
            }
        }
    }
}
```

--------------------------------

### Add Workflow Dependencies to build.gradle

Source: https://github.com/square/workflow-kotlin/blob/main/samples/tutorial/Tutorial1.md

Adds necessary dependencies for AndroidX ViewModel and Activity KTX to the build.gradle file, enabling integration with the Workflow runtime.

```groovy
dependencies {
  // ...
  implementation deps.activityktx
  implementation deps.viewmodelktx
  implementation deps.viewmodelsavedstate
}
```
Tokens:
Raw