Toolkit

https://github.com/yasanglass/toolkit
Admin
A personal development toolkit built with Kotlin Multiplatform, offering core functionalities and...
Tokens:21,295
Snippets:318
Trust Score:8.1
License:Apache-2.0
Update:2 months ago
Show doc for...
Tokens:
Raw
### Launch URL Synchronously

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/core-module.md

Example of launching a URL and capturing the result directly.

```kotlin
val result = urlLauncher.launch("https://example.com")
```

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

### Implement HomeViewAction

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Example implementation of screen-specific action classes.

```kotlin
sealed class HomeViewAction : ViewAction {
    data class OpenUrl(val url: String) : HomeViewAction()
    data object ShareContent : HomeViewAction()
}
```

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

### Implement HomeViewState

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Example implementation of a screen-specific state class.

```kotlin
data class HomeViewState(
    val isLoading: Boolean = false,
    val items: List<Item> = emptyList(),
    val errorMessage: String? = null
) : ViewState
```

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

### Implement HomeViewEvent

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Example implementation of screen-specific event classes.

```kotlin
sealed class HomeViewEvent : ViewEvent {
    data class NavigateTo(val destination: String) : HomeViewEvent()
    data object ShowToast : HomeViewEvent()
}
```

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

### Initialize Koin in Android

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/koin-module.md

Demonstrates how to start Koin within an Android Application class, including the toolkitModule and custom modules.

```kotlin
import org.koin.android.ext.koin.androidContext
import org.koin.core.context.startKoin
import glass.yasan.toolkit.koin.toolkitModule

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        
        startKoin {
            androidContext(this@MyApplication)
            modules(toolkitModule)
            // Add your own modules here
            modules(appModule)
        }
    }
}
```

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

### ResolvableString Usage Examples

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Demonstrates how to instantiate and resolve different types of ResolvableString variants.

```kotlin
val text: ResolvableString = ResolvableString.Literal("Hello")
val resolved = text.resolve()

val resourceString: ResolvableString = ResolvableString.Resource(Res.string.app_name)
val resourceResolved = resourceString.resolve()

val formatted: ResolvableString = ResolvableString.ResourceWithArgs(
    resource = Res.string.item_count,
    formatArgs = listOf(42)
)
val formattedResolved = formatted.resolve() // "42 items" (or localized)
```

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

### Launch URL with Failure Callback

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/core-module.md

Example of launching a URL with a provided callback to handle failures.

```kotlin
urlLauncher.launch("https://example.com") { failure ->
    Toast.makeText(context, "Failed to open URL", Toast.LENGTH_SHORT).show()
}
```

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

### Use HorizontalSpacer Component

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Example usage of the HorizontalSpacer.

```kotlin
HorizontalSpacer(width = 8.dp)
```

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

### Use VerticalSpacer Component

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Example usage of the VerticalSpacer.

```kotlin
VerticalSpacer(height = 12.dp)
```

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

### Usage of firstBlocking

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/core-module.md

Example of calling the firstBlocking extension on a Flow instance.

```kotlin
val value = flow.firstBlocking()
```

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

### Install Toolkit Dependencies

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Add the required modules to your build.gradle.kts file. Replace <version> with the latest version from Maven Central.

```kotlin
dependencies {
    // Core utilities
    implementation("glass.yasan.toolkit:core:<version>")
    
    // Compose UI and MVVM
    implementation("glass.yasan.toolkit:compose:<version>")
    
    // Developer profile components
    implementation("glass.yasan.toolkit:about:<version>")
    
    // Koin dependency injection
    implementation("glass.yasan.toolkit:koin:<version>")
}
```

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

### Use Spacer Component

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Example usage of the rectangular Spacer.

```kotlin
Spacer(height = 16.dp, width = 24.dp)
```

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

### Invoke Compose Builder

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Example of using a Compose composable to build complex UI content.

```kotlin
ToolkitDeveloperContent(
    modifier = Modifier.padding(16.dp),
    onTrackDeveloperLinkClick = { link -> ... }
)
```

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

### Implement VerticalAnimatedVisibility

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Usage example showing how to toggle content visibility with the VerticalAnimatedVisibility component.

```kotlin
VerticalAnimatedVisibility(
    visible = isExpanded,
    modifier = Modifier.fillMaxWidth()
) {
    Text("Expanded content")
}
```

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

### Integrate Toolkit Module in Compose

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/about-module.md

Requires Koin module initialization before usage. The example demonstrates embedding the developer banner and content components within a scrollable column.

```kotlin
// Install Koin modules first (see koin-module.md)
startKoin {
    modules(toolkitModule)
}

// In your composable
@Composable
fun ProfileScreen() {
    Column(
        modifier = Modifier
            .fillMaxSize()
            .verticalScroll(rememberScrollState())
    ) {
        ToolkitDeveloperBanner(
            modifier = Modifier.fillMaxWidth()
        )
        
        ToolkitDeveloperContent(
            modifier = Modifier
                .fillMaxWidth()
                .padding(16.dp),
            onTrackDeveloperLinkClick = { link ->
                // Log link clicks for analytics
                Log.d("Developer", "Clicked: ${link.name}")
            }
        )
    }
}
```

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

### Use spacerItem Extension

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Example usage of spacerItem within a LazyColumn.

```kotlin
LazyColumn {
    item { Text("Header") }
    spacerItem(height = 16.dp, width = 0.dp)
    item { Text("Content") }
}
```

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

### stateInEagerly

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Converts a Flow to StateFlow with eager sharing where subscriptions start immediately.

```APIDOC
## Flow<T>.stateInEagerly(initialValue: T)

### Description
Converts a Flow to StateFlow with eager sharing. Subscriptions start immediately.

### Parameters
- **initialValue** (T) - Required - Initial state value

### Returns
- **StateFlow<T>** - Eager sharing state flow
```

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

### Use horizontalSpacerItem Extension

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Example usage of horizontalSpacerItem within a LazyRow.

```kotlin
LazyRow {
    item { Text("Start") }
    horizontalSpacerItem(width = 12.dp)
    item { Text("End") }
}
```

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

### Use verticalSpacerItem Extension

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Example usage of verticalSpacerItem within a LazyColumn.

```kotlin
LazyColumn {
    items(items.size) { Text(items[it]) }
    verticalSpacerItem(height = 24.dp)
}
```

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

### ViewModel StateFlow Usage

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Example of using stateInWhileSubscribed within a ViewModel to manage state.

```kotlin
abstract class HomeViewModel : ToolkitViewModel<HomeViewState, HomeViewEvent, HomeViewAction>() {
    private val data = fetchDataFlow()
    
    val items = data.stateInWhileSubscribed(initialValue = emptyList())
}
```

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

### Initialize Koin

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Configure Koin for Android or Desktop/JVM environments using the toolkitModule.

```kotlin
import org.koin.android.ext.koin.androidContext
import org.koin.core.context.startKoin
import glass.yasan.toolkit.koin.toolkitModule

// Android
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            androidContext(this@MyApplication)
            modules(toolkitModule)
        }
    }
}

// Desktop/JVM
fun main() {
    startKoin {
        modules(toolkitModule)
    }
    // Your application
}
```

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

### Launch URL with DispatcherProvider

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/INDEX.md

Demonstrates using the DispatcherProvider and handling the result of a URL launch operation.

```kotlin
val dispatcher = DispatcherProvider.main
val result = urlLauncher.launch("https://example.com")
when (result) {
    is UrlLaunchResult.Success -> { /* URL opened */ }
    is UrlLaunchResult.Failure -> { /* Handle error */ }
}
```

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

### Initialize Koin with toolkitModule

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/koin-module.md

Register the toolkit module during application startup.

```kotlin
// In your application initialization
startKoin {
    modules(toolkitModule)
}
```

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

### Initialize Koin Dependency Injection

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/INDEX.md

Configures Koin with the toolkit module and Android context.

```kotlin
startKoin {
    androidContext(context)
    modules(toolkitModule)
}
```

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

### Handle URL Launch Results

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/core-module.md

Demonstrates how to use a when expression to handle the different outcomes of a URL launch operation.

```kotlin
when (val result = urlLauncher.launch("https://example.com")) {
    is UrlLaunchResult.Success -> println("Opened URL")
    is UrlLaunchResult.Failure.InvalidUrl -> println("Bad URL")
    is UrlLaunchResult.Failure.Unsupported -> println("No browser available")
    is UrlLaunchResult.Failure.Error -> println("Error: ${result.exception}")
}
```

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

### Use Platform-Specific Dispatchers

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/INDEX.md

Demonstrates using a DispatcherProvider to switch between I/O and CPU-bound contexts.

```kotlin
class DataService(
    private val dispatchers: DispatcherProvider
) {
    suspend fun fetchData() = withContext(dispatchers.io) { /* I/O */ }
    suspend fun process() = withContext(dispatchers.default) { /* CPU */ }
}
```

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

### Initialize and Use Developer Profile Composable

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/INDEX.md

Initializes Koin modules and demonstrates the usage of the ToolkitDeveloperContent composable.

```kotlin
// 1. Initialize Koin (once)
startKoin { modules(toolkitModule) }

// 2. Use in composable
@Composable
fun AboutScreen() {
    ToolkitDeveloperContent(
        onTrackDeveloperLinkClick = { link ->
            // Log analytics
        }
    )
}
```

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

### Implement AboutRepository

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/about-module.md

Default implementation of the repository, currently returning a static developer instance.

```kotlin
@InternalToolkitApi
public class AboutRepositoryImpl : AboutRepository {
    public override val developer: Flow<Developer> = flowOf(Developer())
}
```

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

### stateInLazily

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Converts a Flow to StateFlow with lazy sharing where subscriptions start on first collection.

```APIDOC
## Flow<T>.stateInLazily(initialValue: T)

### Description
Converts a Flow to StateFlow with lazy sharing. Subscriptions start on first collection.

### Parameters
- **initialValue** (T) - Required - Initial state value

### Returns
- **StateFlow<T>** - Lazy sharing state flow
```

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

### Implement MVVM with ToolkitViewModel

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/INDEX.md

Shows the implementation of a ViewModel using ToolkitViewModel and a Composable screen observing state and actions.

```kotlin
class MyViewModel : ToolkitViewModel<MyState, MyEvent, MyAction>() {
    override suspend fun onViewEvent(event: MyEvent) { /* Handle */ }
}

@Composable
fun MyScreen(vm: MyViewModel) {
    val state by vm.viewState.collectAsStateWithLifecycle()
    ViewActionEffect(vm.viewAction) { action -> /* Handle */ }
}
```

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

### Integrate Custom Koin Modules

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/koin-module.md

Define custom services and override default toolkit factories by including your module in the startKoin configuration.

```kotlin
val appModule = module {
    // Your custom singletons
    single { MyCustomService() }
    
    // Override toolkit factories with custom implementations
    factory<AboutRepository> { MyCustomAboutRepository() }
}

startKoin {
    modules(toolkitModule, appModule)
}
```

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

### UrlLauncher.launch(url: String, onFailure: (Failure) -> Unit)

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/core-module.md

Launches the specified URL and executes a callback function if the operation fails.

```APIDOC
## suspend fun launch(url: String, onFailure: (UrlLaunchResult.Failure) -> Unit)

### Description
Launches the URL and invokes the provided onFailure callback if the operation fails.

### Parameters
- **url** (String) - Required - The URL string to launch.
- **onFailure** ((UrlLaunchResult.Failure) -> Unit) - Required - Callback function invoked upon failure.

### Example
```kotlin
urlLauncher.launch("https://example.com") { failure ->
    println("Failed to open URL: $failure")
}
```
```

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

### Implement AboutRepository

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Provides a concrete implementation of the repository interface, currently returning static data.

```kotlin
class AboutRepositoryImpl : AboutRepository {
    override val developer: Flow<Developer> = flowOf(Developer())
}
```

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

### UrlLauncher.launch(url: String)

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/core-module.md

Launches the specified URL and returns a UrlLaunchResult indicating the outcome of the operation.

```APIDOC
## suspend fun launch(url: String): UrlLaunchResult

### Description
Launches the given URL and returns the result as a UrlLaunchResult object.

### Parameters
- **url** (String) - Required - The URL string to launch.

### Return
- **UrlLaunchResult** - Returns Success, or a Failure type (InvalidUrl, Unsupported, or Error).

### Example
```kotlin
val result = urlLauncher.launch("https://example.com")
```
```

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

### Create and Implement MVVM ViewModel

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/INDEX.md

Defines state, events, and actions for a ViewModel and demonstrates its integration within a Composable.

```kotlin
// Define state, events, actions
data class MyState(...) : ViewState
sealed class MyEvent : ViewEvent
sealed class MyAction : ViewAction

// Implement viewmodel
class MyViewModel : ToolkitViewModel<MyState, MyEvent, MyAction>() {
    override fun defaultViewState() = MyState()
    override suspend fun onViewEvent(event: MyEvent) { ... }
}

// Use in composable
@Composable
fun MyScreen(vm: MyViewModel) {
    val state by vm.viewState.collectAsStateWithLifecycle()
    ViewActionEffect(vm.viewAction) { /* Handle */ }
}
```

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

### Use UrlLauncher

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Handle URL launching within a ViewModel and process the resulting success or failure states.

```kotlin
class MyViewModel(
    private val urlLauncher: UrlLauncher
) {
    fun openLink(url: String) {
        viewModelScope.launch {
            when (val result = urlLauncher.launch(url)) {
                is UrlLaunchResult.Success -> println("Opened")
                is UrlLaunchResult.Failure.InvalidUrl -> println("Bad URL")
                is UrlLaunchResult.Failure.Unsupported -> println("No browser")
                is UrlLaunchResult.Failure.Error -> println("Error: ${result.exception}")
            }
        }
    }
}
```

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

### Implement Expect/Actual for Multiplatform

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Defines platform-specific implementations for the UrlLauncher interface.

```kotlin
expect class UrlLauncherImpl : UrlLauncher
actual class UrlLauncherImpl(context: Context) : UrlLauncher  // Android
actual class UrlLauncherImpl() : UrlLauncher                   // iOS
```

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

### Display ToolkitDeveloperContent

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/about-module.md

Displays the full developer profile, including biography and grouped links, with automatic data fetching via Koin.

```kotlin
@Composable
public fun ToolkitDeveloperContent(
    modifier: Modifier = Modifier,
    onTrackDeveloperLinkClick: (Developer.Link) -> Unit = {},
)
```

```kotlin
ToolkitDeveloperContent(
    modifier = Modifier
        .fillMaxWidth()
        .padding(16.dp),
    onTrackDeveloperLinkClick = { link ->
        analytics.trackEvent("developer_link_clicked", link.name)
    }
)
```

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

### Define URL launch function

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

The launch function returns a UrlLaunchResult to handle various outcomes like success, invalid URLs, or unsupported handlers.

```kotlin
suspend fun launch(url: String): UrlLaunchResult
```

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

### Apply Spacers in Layouts

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Demonstrates usage of VerticalSpacer and HorizontalSpacer in standard layouts and verticalSpacerItem within LazyColumn.

```kotlin
@Composable
fun MyLayout() {
    Column {
        Text("Header")
        VerticalSpacer(height = 16.dp)
        Text("Content")
        HorizontalSpacer(width = 8.dp)
        Text("More")
    }
}

@Composable
fun LazyListWithSpacing() {
    LazyColumn {
        items(10) { index ->
            Text("Item $index")
            if (index < 9) {
                verticalSpacerItem(height = 8.dp)
            }
        }
    }
}
```

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

### ToolkitDeveloperContent

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/about-module.md

Displays the complete developer profile including logo, biography, and organized links, fetching data automatically via Koin.

```APIDOC
## ToolkitDeveloperContent

### Description
Main composable that displays the complete developer profile with logo, biography, and organized links. Automatically fetches developer data from repository via Koin injection.

### Parameters
- **modifier** (Modifier) - Optional - Modifier for the content container (Default: Modifier)
- **onTrackDeveloperLinkClick** ((Developer.Link) -> Unit) - Optional - Callback invoked before launching each link (Default: {}) 

### Example
```kotlin
ToolkitDeveloperContent(
    modifier = Modifier.fillMaxWidth().padding(16.dp),
    onTrackDeveloperLinkClick = { link ->
        analytics.trackEvent("developer_link_clicked", link.name)
    }
)
```
```

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

### Launch a URL with Result Handling

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/INDEX.md

Injects a UrlLauncher and handles success or failure results within a coroutine scope.

```kotlin
val urlLauncher: UrlLauncher = koinInject()

Button(
    onClick = {
        scope.launch {
            when (urlLauncher.launch("https://example.com")) {
                is UrlLaunchResult.Success -> { /* Handle */ }
                is UrlLaunchResult.Failure -> { /* Handle */ }
            }
        }
    }
) { Text("Open") }
```

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

### Launch URLs with Error Handling

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Uses UrlLauncher to open web links with specific error handling for invalid URLs, unsupported schemes, or general exceptions.

```kotlin
val urlLauncher: UrlLauncher = koinInject()

Button(
    onClick = {
        scope.launch {
            urlLauncher.launch("https://example.com", onFailure = { failure ->
                when (failure) {
                    UrlLaunchResult.Failure.InvalidUrl -> showError("Invalid URL")
                    UrlLaunchResult.Failure.Unsupported -> showError("No browser")
                    is UrlLaunchResult.Failure.Error -> showError("Error: ${failure.exception}")
                }
            })
        }
    }
) {
    Text("Open Link")
}
```

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

### Project Directory Structure

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Visual representation of the toolkit module organization.

```text
toolkit/
├── core/              # Foundation utilities
├── compose/           # Compose UI components and MVVM
├── about/             # Developer profile system
└── koin/              # Dependency injection configuration
```

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

### Inject AboutRepository in a Composable

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/koin-module.md

Retrieve the repository instance within a Jetpack Compose screen using koinInject.

```kotlin
@Composable
fun DeveloperProfileScreen() {
    val aboutRepository: AboutRepository = koinInject()
    val developer by aboutRepository.developer.collectAsStateWithLifecycle(Developer())
    
    Text(developer.biography)
}
```

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

### Define Developer Domain Model

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Represents the core developer profile structure including name, biography, and links.

```kotlin
data class Developer(
    val name: String,
    val biography: String,
    val links: ImmutableList<Link>
)
```

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

### Configure Custom Branded Header

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Displays a branded logo with custom sizing and color theming.

```kotlin
@Composable
fun BrandedHeader() {
    Column(
        horizontalAlignment = Alignment.CenterHorizontally,
        modifier = Modifier.fillMaxWidth()
    ) {
        ToolkitDeveloperLogoVertical(
            modifier = Modifier.size(100.dp),
            color = Color.Blue
        )
        
        Text(
            "Built by Yasan Glass",
            fontSize = 14.sp,
            color = Color.Gray
        )
    }
}
```

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

### Implement Counter ViewModel and Composable

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Defines the state, events, and actions for a counter, implements the ViewModel logic, and demonstrates usage within a Compose screen.

```kotlin
// Define state
data class CounterViewState(
    val count: Int = 0
) : ViewState

// Define events
sealed class CounterViewEvent : ViewEvent {
    data object Increment : CounterViewEvent()
    data object Decrement : CounterViewEvent()
}

// Define actions
sealed class CounterViewAction : ViewAction {
    data class ShowToast(val message: String) : CounterViewAction()
}

// Implement viewmodel
class CounterViewModel : ToolkitViewModel<CounterViewState, CounterViewEvent, CounterViewAction>() {
    override fun defaultViewState() = CounterViewState()
    
    override suspend fun onViewEvent(event: CounterViewEvent) {
        when (event) {
            CounterViewEvent.Increment -> {
                updateViewState { copy(count = count + 1) }
                sendViewAction(CounterViewAction.ShowToast("Count increased"))
            }
            CounterViewEvent.Decrement -> {
                updateViewState { copy(count = count - 1) }
                sendViewAction(CounterViewAction.ShowToast("Count decreased"))
            }
        }
    }
}

// Use in composable
@Composable
fun CounterScreen(viewModel: CounterViewModel) {
    val state by viewModel.viewState.collectAsStateWithLifecycle()
    val sendEvent = rememberSendViewEvent(viewModel)
    
    ViewActionEffect(
        viewAction = viewModel.viewAction,
        onViewAction = { action ->
            when (action) {
                is CounterViewAction.ShowToast -> showToast(action.message)
            }
        }
    )
    
    Column {
        Text("Count: ${state.count}")
        Button(onClick = { sendEvent(CounterViewEvent.Increment) }) {
            Text("Increment")
        }
        Button(onClick = { sendEvent(CounterViewEvent.Decrement) }) {
            Text("Decrement")
        }
    }
}
```

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

### Configure Test Mocks

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Provides implementations for DispatcherProvider and AboutRepository for unit testing.

```kotlin
val testDispatcherProvider = object : DispatcherProvider {
    override val main = StandardTestDispatcher()
    override val io = StandardTestDispatcher()
    // ...
}

val testRepository = object : AboutRepository {
    override val developer = flowOf(testDeveloper)
}
```

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

### Define defaultViewState Method

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Abstract method to provide the initial state during initialization.

```kotlin
public abstract fun defaultViewState(): S
```

```kotlin
override fun defaultViewState() = HomeViewState()
```

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

### Define BooleanPreviewParameterProvider

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Implements PreviewParameterProvider to supply boolean values for Compose previews.

```kotlin
public class BooleanPreviewParameterProvider : PreviewParameterProvider<Boolean> {
    override val values: Sequence<Boolean> = sequenceOf(true, false)
}
```

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

### Implement TodoScreen with ViewModel

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Integrates a ViewModel into a Compose screen to manage state, handle user events, and process side effects.

```kotlin
@Composable
fun TodoScreen(viewModel: TodoViewModel) {
    val state by viewModel.viewState.collectAsStateWithLifecycle()
    val sendEvent = rememberSendViewEvent(viewModel)
    
    // Handle side effects (actions)
    ViewActionEffect(
        viewAction = viewModel.viewAction,
        onViewAction = { action ->
            when (action) {
                is TodoViewAction.ShowToast -> {
                    // Show toast
                }
                TodoViewAction.NavigateBack -> {
                    // Navigate
                }
            }
        }
    )
    
    Column(modifier = Modifier.fillMaxSize()) {
        // Error display
        state.errorMessage?.let { error ->
            Text(error, color = Color.Red)
            Button(onClick = { sendEvent(TodoViewEvent.ClearError) }) {
                Text("Dismiss")
            }
        }
        
        // Loading
        if (state.isLoading) {
            CircularProgressIndicator()
        }
        
        // Item list
        LazyColumn {
            items(state.items) { item ->
                Text(item, modifier = Modifier.padding(8.dp))
            }
        }
        
        // Add button
        var inputText by remember { mutableStateOf("") }
        Row {
            TextField(
                value = inputText,
                onValueChange = { inputText = it }
            )
            Button(onClick = {
                sendEvent(TodoViewEvent.AddItem(inputText))
                inputText = ""
            }) {
                Text("Add")
            }
        }
    }
}
```

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

### Use NullableBooleanPreviewParameterProvider in Preview

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Applies the nullable provider to a Composable preview.

```kotlin
@Preview(showBackground = true)
@Composable
fun MyComposablePreview(
    @PreviewParameter(NullableBooleanPreviewParameterProvider::class) state: Boolean?
) {
    MyComposable(state = state)
}
```

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

### Display Full Developer Profile

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Integrates ToolkitDeveloperBanner and ToolkitDeveloperContent with analytics tracking.

```kotlin
@Composable
fun AppAboutScreen() {
    Column(
        modifier = Modifier
            .fillMaxSize()
            .verticalScroll(rememberScrollState())
    ) {
        ToolkitDeveloperBanner()
        
        ToolkitDeveloperContent(
            modifier = Modifier
                .fillMaxWidth()
                .padding(16.dp),
            onTrackDeveloperLinkClick = { link ->
                analytics.track("developer_link_clicked", link.name)
            }
        )
    }
}
```

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

### Import Compose Module Types

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/types-reference.md

Use these imports to access Compose-specific UI state management, view models, and string resolution utilities.

```kotlin
import glass.yasan.toolkit.compose.string.ResolvableString
import glass.yasan.toolkit.compose.viewmodel.ViewState
import glass.yasan.toolkit.compose.viewmodel.ViewEvent
import glass.yasan.toolkit.compose.viewmodel.ViewAction
import glass.yasan.toolkit.compose.viewmodel.ToolkitViewModel
```

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

### Implement DefaultDispatcherProvider

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/core-module.md

Platform-specific implementation of the DispatcherProvider interface.

```kotlin
public expect class DefaultDispatcherProvider : DispatcherProvider {
    override val main: CoroutineDispatcher
    override val io: CoroutineDispatcher
    override val default: CoroutineDispatcher
    override val unconfined: CoroutineDispatcher
}
```

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

### Define the toolkitModule

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/koin-module.md

The primary Koin module configuration that includes platform-specific modules and defines core singleton and factory dependencies.

```kotlin
@OptIn(InternalToolkitApi::class)
public val toolkitModule: Module = module {
    includes(platformModule)
    
    single<DispatcherProvider> { createDefaultDispatcherProvider() }
    single<ApplicationScope> {
        CoroutineScope(SupervisorJob() + get<DispatcherProvider>().default)
    }
    
    factoryOf<AboutRepository>(::AboutRepositoryImpl)
}
```

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

### Module Dependency Graph

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/INDEX.md

Visual representation of the dependency hierarchy between project modules.

```text
compose → core
about → compose, core
koin → core, about
```

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

### Create DefaultDispatcherProvider Factory

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/core-module.md

Factory function to instantiate the platform-specific dispatcher provider.

```kotlin
public expect fun createDefaultDispatcherProvider(): DefaultDispatcherProvider
```

```kotlin
val dispatcherProvider = createDefaultDispatcherProvider()
viewModelScope.launch(dispatcherProvider.main) {
    // Update UI
}
```

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

### Declare platformModule

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/koin-module.md

Defines the expected platform-specific module in the common source set.

```kotlin
internal expect val platformModule: Module
```

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

### Display Developer Profile Content

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/INDEX.md

Displays the developer profile component with a custom click tracking handler.

```kotlin
ToolkitDeveloperContent(
    modifier = Modifier.padding(16.dp),
    onTrackDeveloperLinkClick = { link ->
        analytics.track("link_clicked", link.name)
    }
)
```

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

### Import Core Module Types

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/types-reference.md

Use these imports to access core utilities including URL launchers, coroutine dispatchers, and toolkit annotations.

```kotlin
import glass.yasan.toolkit.core.url.UrlLaunchResult
import glass.yasan.toolkit.core.url.UrlLauncher
import glass.yasan.toolkit.core.coroutines.DispatcherProvider
import glass.yasan.toolkit.core.coroutines.ApplicationScope
import glass.yasan.toolkit.core.annotation.ExperimentalToolkitApi
import glass.yasan.toolkit.core.annotation.InternalToolkitApi
```

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

### Import About Module Types

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/types-reference.md

Use these imports to access domain models and repository interfaces related to the About module.

```kotlin
import glass.yasan.toolkit.about.domain.model.Developer
import glass.yasan.toolkit.about.domain.repository.AboutRepository
```

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

### Display Documentation Statistics

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/README.md

Displays the breakdown of documentation files and line counts across various modules.

```text
Total Documentation Files: 9
Total Size: ~116 KB
Total Lines: 3,850+
Total Words: ~50,000

Breakdown:
- Core Module: 450 lines
- Compose Module: 800 lines
- About Module: 500 lines
- Koin Module: 300 lines
- Types Reference: 500 lines
- API Index: 400 lines
- Architecture: 650 lines
- Getting Started: 450 lines
- INDEX: 250 lines
```

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

### Display ToolkitDeveloperLogoVertical

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/about-module.md

Renders the developer logo in a vertical layout with theme-aware tinting.

```kotlin
@Composable
public fun ToolkitDeveloperLogoVertical(
    modifier: Modifier = Modifier,
    color: Color = KepkoTheme.colors.content
)
```

```kotlin
ToolkitDeveloperLogoVertical(
    modifier = Modifier
        .size(128.dp),
    color = Color.Blue
)
```

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

### Convert Flows to StateFlows

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Utilizes extension functions to convert cold Flows into StateFlows with different sharing strategies: eager, lazy, or subscription-based.

```kotlin
class MyViewModel(
    private val dataRepository: DataRepository
) : ToolkitViewModel<MyViewState, MyViewEvent, MyViewAction>() {
    
    // Eagerly shared - subscribers always active
    val data = dataRepository.dataFlow()
        .stateInEagerly(initialValue = emptyList())
    
    // Lazily shared - starts on first subscriber
    val counts = dataRepository.countFlow()
        .stateInLazily(initialValue = 0)
    
    // Subscription-based - stops when no subscribers
    val status = dataRepository.statusFlow()
        .stateInWhileSubscribed(
            stopTimeout = 5.seconds,
            initialValue = Status.Idle
        )
}
```

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

### createDefaultDispatcherProvider()

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/core-module.md

Factory function for creating the default dispatcher provider.

```APIDOC
## createDefaultDispatcherProvider()

### Description
Factory function for creating the default dispatcher provider. Platform-specific implementation.

### Example Usage
```kotlin
val dispatcherProvider = createDefaultDispatcherProvider()
viewModelScope.launch(dispatcherProvider.main) {
    // Update UI
}
```
```

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

### Implement ToolkitViewModel

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Implement the ViewModel logic by extending ToolkitViewModel and handling events and state updates.

```kotlin
class TodoViewModel(
    private val repository: TodoRepository
) : ToolkitViewModel<TodoViewState, TodoViewEvent, TodoViewAction>() {
    
    override fun defaultViewState() = TodoViewState()
    
    override suspend fun onViewEvent(event: TodoViewEvent) {
        when (event) {
            is TodoViewEvent.AddItem -> addItem(event.text)
            TodoViewEvent.LoadItems -> loadItems()
            TodoViewEvent.ClearError -> updateViewState { copy(errorMessage = null) }
        }
    }
    
    private suspend fun addItem(text: String) {
        if (text.isBlank()) {
            sendViewAction(TodoViewAction.ShowToast("Empty item"))
            return
        }
        
        updateViewState { copy(isLoading = true) }
        try {
            repository.addItem(text)
            loadItems()
        } catch (e: Exception) {
            updateViewState { 
                copy(
                    isLoading = false,
                    errorMessage = "Failed to add item"
                )
            }
            sendViewAction(TodoViewAction.ShowToast("Error: ${e.message}"))
        }
    }
    
    private suspend fun loadItems() {
        updateViewState { copy(isLoading = true) }
        try {
            val items = repository.getItems()
            updateViewState {
                copy(
                    items = items,
                    isLoading = false,
                    errorMessage = null
                )
            }
        } catch (e: Exception) {
            updateViewState {
                copy(
                    isLoading = false,
                    errorMessage = e.message
                )
            }
        }
    }
}
```

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

### Define Developer Link Model

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/about-module.md

Represents a link with a name and URL, supporting automatic type and group classification.

```kotlin
public data class Link(
    val name: String,
    val url: String,
)
```

```kotlin
public enum class Type {
    BLUESKY,
    CROWDIN,
    DISCORD,
    EMAIL,
    GITHUB,
    GUMROAD,
    MASTODON,
    PLAY_STORE,
    TELEGRAM,
    WEBSITE,
}
```

```kotlin
public val type: Type
```

```kotlin
public enum class Group {
    STANDALONE,
    CONTACT,
    COMMUNITY,
    CREATIONS,
    SOCIAL,
}
```

```kotlin
public val group: Group
```

```kotlin
public val icon: DrawableResource
```

```kotlin
val link = Developer.Link(
    name = "GitHub",
    url = "https://github.com/yasanglass"
)
println(link.type)   // Type.GITHUB
println(link.group)  // Group.CREATIONS
// link.icon is Res.drawable.ic_github
```

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

### Display ToolkitDeveloperLogoHorizontal

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/about-module.md

Renders the developer logo horizontally with theme-aware tinting.

```kotlin
@Composable
public fun ToolkitDeveloperLogoHorizontal(
    modifier: Modifier = Modifier,
    color: Color = KepkoTheme.colors.content
)
```

```kotlin
ToolkitDeveloperLogoHorizontal(
    modifier = Modifier
        .fillMaxWidth()
        .height(48.dp),
    color = Color.White
)
```

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

### Define UrlLauncher Interface

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/core-module.md

Defines the contract for URL launching, supporting both direct result returns and callback-based failure handling.

```kotlin
public interface UrlLauncher {
    public suspend fun launch(url: String): UrlLaunchResult
    
    public suspend fun launch(
        url: String,
        onFailure: (UrlLaunchResult.Failure) -> Unit
    )
}
```

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

### Define Developer Picture Models

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/types-reference.md

Data classes for managing developer picture metadata and Gravatar integration.

```kotlin
public data class Picture(
    val gravatar: Gravatar,
)
```

```kotlin
public data class Gravatar(
    private val id: String,  // MD5 hash of gravatar email
)
```

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

### ToolkitDeveloperContent Overloads

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Provides two variants of the main composable: one with dependency injection for integration and one pure version for testing.

```kotlin
@Composable
fun ToolkitDeveloperContent(modifier: Modifier, onTrackDeveloperLinkClick: (Link) -> Unit)
```

```kotlin
@Composable
private fun ToolkitDeveloperContent(developer: Developer, onDeveloperLinkClick: ...)
```

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

### Configure ApplicationScope

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Uses a SupervisorJob to ensure child coroutine failures do not cancel sibling operations.

```kotlin
CoroutineScope(SupervisorJob() + dispatcherProvider.default)
```

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

### Define NullableBooleanPreviewParameterProvider

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Implements PreviewParameterProvider to supply nullable boolean values for Compose previews.

```kotlin
public class NullableBooleanPreviewParameterProvider : PreviewParameterProvider<Boolean?> {
    override val values: Sequence<Boolean?> = sequenceOf(true, false, null)
}
```

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

### Implement onViewEvent

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Subclasses must implement this abstract method to handle incoming view events.

```kotlin
override suspend fun onViewEvent(event: HomeViewEvent) {
    when (event) {
        is HomeViewEvent.NavigateTo -> navigate(event.destination)
        HomeViewEvent.ShowToast -> updateViewState { copy(showToast = true) }
    }
}
```

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

### Use BooleanPreviewParameterProvider in Preview

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Applies the provider to a Composable preview using the @PreviewParameter annotation.

```kotlin
@Preview(showBackground = true)
@Composable
fun MyComposablePreview(
    @PreviewParameter(BooleanPreviewParameterProvider::class) enabled: Boolean
) {
    MyComposable(enabled = enabled)
}
```

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

### toolkitModule

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/koin-module.md

The primary Koin module that configures core toolkit dependencies. It includes platform-specific modules and provides singletons for DispatcherProvider and ApplicationScope, as well as a factory for AboutRepository.

```APIDOC
## toolkitModule

### Description
The main Koin module that configures core toolkit dependencies. This is the primary entry point for dependency injection in the toolkit.

### Exported Definitions
- **DispatcherProvider** (single) - Provides platform-specific coroutine dispatchers.
- **ApplicationScope** (single) - Application-level coroutine scope for lifecycle management.
- **AboutRepository** (factory) - Repository for developer profile data.

### Installation
```kotlin
startKoin {
    modules(toolkitModule)
}
```

### Usage Examples

#### Injecting DispatcherProvider
```kotlin
class MyViewModel(private val dispatcherProvider: DispatcherProvider) : ViewModel() {
    fun loadData() {
        viewModelScope.launch(dispatcherProvider.io) {
            // I/O operation
        }
    }
}
```

#### Injecting ApplicationScope
```kotlin
class MyApplication : Application() {
    private val appScope: ApplicationScope by inject()
    
    override fun onCreate() {
        super.onCreate()
        appScope.launch {
            // Long-running application operation
        }
    }
}
```

#### Injecting AboutRepository
```kotlin
@Composable
fun DeveloperProfileScreen() {
    val aboutRepository: AboutRepository = koinInject()
    val developer by aboutRepository.developer.collectAsStateWithLifecycle(Developer())
    
    Text(developer.biography)
}
```

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

### Define Koin Module

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Configures the toolkit dependency injection module including platform dependencies, dispatchers, and repository factories.

```kotlin
val toolkitModule = module {
    includes(platformModule)
    
    single<DispatcherProvider> { createDefaultDispatcherProvider() }
    single<ApplicationScope> {
        CoroutineScope(SupervisorJob() + get<DispatcherProvider>().default)
    }
    
    factory<AboutRepository>(::AboutRepositoryImpl)
}
```

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

### Define Extension Functions

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Provides fluent API extensions for Flow and Throwable types.

```kotlin
suspend fun Throwable.rethrowCancellation()
fun <T> Flow<T>.firstBlocking(): T
fun <T> Flow<T>.stateInEagerly(initialValue: T): StateFlow<T>
```

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

### Define MVVM Components

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Define the state, events, and actions required for the MVVM pattern.

```kotlin
// State - immutable snapshot of UI state
data class TodoViewState(
    val items: List<String> = emptyList(),
    val isLoading: Boolean = false,
    val errorMessage: String? = null
) : ViewState

// Events - user actions
sealed class TodoViewEvent : ViewEvent {
    data class AddItem(val text: String) : TodoViewEvent()
    data object LoadItems : TodoViewEvent()
    data object ClearError : TodoViewEvent()
}

// Actions - side effects
sealed class TodoViewAction : ViewAction {
    data class ShowToast(val message: String) : TodoViewAction()
    data object NavigateBack : TodoViewAction()
}
```

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

### Define Marker Interfaces

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Establishes a type-safe structure for MVVM components.

```kotlin
interface ViewState
interface ViewEvent
interface ViewAction
```

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

### Define AboutRepository Interface

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Defines the contract for retrieving developer profile data as a Flow.

```kotlin
interface AboutRepository {
    val developer: Flow<Developer>
}
```

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

### UrlLauncher Interface

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/api-index.md

The UrlLauncher interface provides methods to launch URLs within the application environment.

```APIDOC
## Interface: UrlLauncher

### Description
Provides functionality to launch URLs. Implementations handle the platform-specific logic for opening web links.

### Methods
- **launch(url: String)**: Launches the provided URL.
- **launch(url: String, onFailure: (Failure) -> Unit)**: Launches the provided URL with a callback for handling failures.
```

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

### BooleanPreviewParameterProvider

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Provides boolean preview variants (true, false) for Compose previews.

```APIDOC
## BooleanPreviewParameterProvider

### Description
A PreviewParameterProvider that provides boolean values (true, false) to be used with @PreviewParameter in Compose previews.

### Usage
```kotlin
@Preview
@Composable
fun MyComposablePreview(
    @PreviewParameter(BooleanPreviewParameterProvider::class) enabled: Boolean
) {
    MyComposable(enabled = enabled)
}
```
```

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

### JVM UrlLauncher Implementation

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/core-module.md

JVM-specific implementation of the UrlLauncher interface.

```kotlin
public actual class UrlLauncherImpl(
    private val dispatcherProvider: DispatcherProvider
) : UrlLauncher
```

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

### Define Developer Link Models

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/types-reference.md

Data class for individual links and their associated type and group enumerations.

```kotlin
public data class Link(
    val name: String,
    val url: String,
)
```

```kotlin
enum class Type {
    BLUESKY, CROWDIN, DISCORD, EMAIL, GITHUB,
    GUMROAD, MASTODON, PLAY_STORE, TELEGRAM, WEBSITE
}
```

```kotlin
enum class Group {
    STANDALONE, CONTACT, COMMUNITY, CREATIONS, SOCIAL
}
```

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

### Implement Custom Dispatcher Provider

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Defines a custom DispatcherProvider for testing purposes using StandardTestDispatcher.

```kotlin
class TestDispatcherProvider : DispatcherProvider {
    val testDispatcher = StandardTestDispatcher()
    
    override val main = testDispatcher
    override val io = testDispatcher
    override val default = testDispatcher
    override val unconfined = Dispatchers.Unconfined
}
```

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

### Define AboutRepository Interface

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/about-module.md

Interface for accessing developer information via a Flow.

```kotlin
public interface AboutRepository {
    public val developer: Flow<Developer>
}
```

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

### StateFlow Helper Definitions

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Definitions for helper methods used to convert Flows to StateFlows with different sharing strategies.

```kotlin
public fun <T> Flow<T>.stateInEagerly(initialValue: T): StateFlow<T>
```

```kotlin
public fun <T> Flow<T>.stateInLazily(initialValue: T): StateFlow<T>
```

```kotlin
public fun <T> Flow<T>.stateInWhileSubscribed(
    stopTimeout: Duration = 5.seconds,
    replayExpiration: Duration = Duration.INFINITE,
    initialValue: T,
): StateFlow<T>
```

```kotlin
public fun <T> Flow<T>.stateIn(
    started: SharingStarted,
    initialValue: T,
): StateFlow<T>
```

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

### Define URL Launch Failure States

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Uses a sealed interface to categorize URL launch failures for explicit handling.

```kotlin
sealed interface UrlLaunchResult.Failure {
    data object InvalidUrl       // Malformed URL
    data object Unsupported      // No handler
    data class Error(exception)  // Unexpected error
}
```

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

### ToolkitDeveloperLogoVertical

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/about-module.md

Displays the developer logo in a vertical layout with theme-aware color tinting.

```APIDOC
## ToolkitDeveloperLogoVertical

### Description
Displays the developer logo in vertical layout. Color is tinted based on the theme.

### Parameters
- **modifier** (Modifier) - Optional - Modifier for the image (Default: Modifier)
- **color** (Color) - Optional - Tint color for the logo (Default: KepkoTheme.colors.content)

### Example
```kotlin
ToolkitDeveloperLogoVertical(
    modifier = Modifier.size(128.dp),
    color = Color.Blue
)
```
```

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

### DispatcherProvider

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/core-module.md

Interface for accessing platform-specific coroutine dispatchers, enabling flexible dispatcher switching.

```APIDOC
## DispatcherProvider

### Description
Abstraction for accessing platform-specific coroutine dispatchers. Enables flexible dispatcher switching for testing and platform customization.

### Properties
- **main** (CoroutineDispatcher) - Main/UI thread dispatcher
- **io** (CoroutineDispatcher) - I/O operations dispatcher; for web targets, defaults to main
- **default** (CoroutineDispatcher) - Default background dispatcher
- **unconfined** (CoroutineDispatcher) - Unconfined dispatcher
```

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

### Define Repository Pattern

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Decouples data sources from the UI layer using an interface and implementation.

```kotlin
interface AboutRepository { val developer: Flow<Developer> }
class AboutRepositoryImpl : AboutRepository
```

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

### Extend ToolkitViewModel

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Creates a base ViewModel class that extends ToolkitViewModel to include logging functionality.

```kotlin
abstract class MyBaseViewModel<S : ViewState, E : ViewEvent, A : ViewAction>(
    protected val logger: Logger
) : ToolkitViewModel<S, E, A>() {
    
    protected fun logEvent(event: E) {
        logger.debug("Event: $event")
    }
    
    protected fun logStateChange(oldState: S, newState: S) {
        logger.debug("State: $oldState -> $newState")
    }
}
```

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

### stateIn

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Converts a Flow to StateFlow with a custom sharing strategy.

```APIDOC
## Flow<T>.stateIn(started: SharingStarted, initialValue: T)

### Description
Converts a Flow to StateFlow with custom sharing strategy.

### Parameters
- **started** (SharingStarted) - Required - Sharing strategy
- **initialValue** (T) - Required - Initial state value

### Returns
- **StateFlow<T>** - State flow with custom sharing
```

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

### iOS UrlLauncher Implementation

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/core-module.md

iOS-specific implementation of the UrlLauncher interface.

```kotlin
public actual class UrlLauncherImpl : UrlLauncher
```

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

### Define ViewEvent Interface

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Marker interface for transient user actions or system events.

```kotlin
public interface ViewEvent
```

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

### Override AboutRepository Implementation

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Provides a custom implementation of AboutRepository and registers it within a Koin module.

```kotlin
class CustomAboutRepository : AboutRepository {
    override val developer: Flow<Developer> = flow {
        val data = api.fetchDeveloper()
        emit(data)
    }
}

// In Koin module
val customModule = module {
    factory<AboutRepository> { CustomAboutRepository() }
}

startKoin {
    modules(toolkitModule, customModule)
}
```

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

### Implement Animated Visibility in Compose

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/getting-started.md

Uses VerticalAnimatedVisibility to toggle content display based on state.

```kotlin
@Composable
fun ExpandableCard(title: String, content: String) {
    var isExpanded by remember { mutableStateOf(false) }
    
    Column {
        Button(onClick = { isExpanded = !isExpanded }) {
            Text(title)
        }
        
        VerticalAnimatedVisibility(visible = isExpanded) {
            Text(content, modifier = Modifier.padding(16.dp))
        }
    }
}
```

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

### Convert Flow to StateFlow

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/architecture.md

Extension functions to simplify Flow-to-StateFlow conversion using various sharing strategies.

```kotlin
fun <T> Flow<T>.stateInEagerly(initialValue: T): StateFlow<T>
fun <T> Flow<T>.stateInLazily(initialValue: T): StateFlow<T>
fun <T> Flow<T>.stateInWhileSubscribed(...): StateFlow<T>
fun <T> Flow<T>.stateIn(started: SharingStarted, ...): StateFlow<T>
```

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

### NullableBooleanPreviewParameterProvider

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/compose-module.md

Provides nullable boolean preview variants (true, false, null) for Compose previews.

```APIDOC
## NullableBooleanPreviewParameterProvider

### Description
A PreviewParameterProvider that provides nullable boolean values (true, false, null) to be used with @PreviewParameter in Compose previews.

### Usage
```kotlin
@Preview
@Composable
fun MyComposablePreview(
    @PreviewParameter(NullableBooleanPreviewParameterProvider::class) state: Boolean?
) {
    MyComposable(state = state)
}
```
```

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

### Define Developer Data Model

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/types-reference.md

Data class representing a developer profile with immutable links.

```kotlin
public data class Developer(
    val name: String = "Yasan Glass",
    val biography: String = "Developer & Designer",
    val links: ImmutableList<Link> = persistentListOf(...)
)
```

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

### Define UrlLaunchResult sealed interface

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/types-reference.md

Represents the outcome of a URL launch operation using a discriminated union pattern.

```kotlin
public sealed interface UrlLaunchResult {
    public val isSuccess: Boolean get() = this is Success
    
    public data object Success : UrlLaunchResult
    
    public sealed interface Failure : UrlLaunchResult {
        public data object InvalidUrl : Failure
        public data object Unsupported : Failure
        public data class Error(val exception: Exception) : Failure
    }
}
```

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

### Define Developer Picture and Gravatar

Source: https://github.com/yasanglass/toolkit/blob/main/_autodocs/about-module.md

Structures for developer images, specifically supporting Gravatar profile integration.

```kotlin
public data class Picture(
    val gravatar: Gravatar,
)
```

```kotlin
public data class Gravatar(
    private val id: String,  // MD5 hash of gravatar profile email
)
```
Tokens:
Raw