import ProgramData.userName

object ProgramData : KFileDataStorage() {
    val userName by property<String>()  // shortcut for property<String?> { null }
}

fun main() {
    if(userName == null) {
        println("Hi dear user, how should I call you?")
        userName = readLine() ?: "Anonymous"
        println("Okay ${userName}, see you")
    } else {
        println("Glad to see you again, $userName")
    }
}

object CookiesStorage : KLocalDataStorage() {
    val uniqueADId by property { Random.nextLong() }
}

fun main() {
    console.log("🙈 I'm tracking you, ${CookiesStorage.uniqueADId}!")
}

// Initialize context first:
class App : Application() {
    override fun onCreate() {
        super.onCreate()
        KDS.onCreate(app = this)
    }
}
...
object SharedStorage : KSharedDataStorage() {
    var clicks by int { 0 }
}
...
import SharedStorage.clicks

class MainActivity : Activity() {
    override fun onCreate(bundle: Bundle?) {
        ...
        main.setOnClickListener {
            updateClicks(++clicks)
        }
    }
}

You can also store android app state with the library

class MainActivity : Activity() {
    private val state = object : KBundleDataStorage() {
        var score by int { 0 }  // This will be automatically saved and restored
    }
    
    override fun onCreate(bundle: Bundle?) = state.fillState(bundle) {
        super.onCreate(bundle)
    }
    // OR
    override fun onCreate(bundle: Bundle?) {
        super.onCreate(bundle)
        state.restoreInstanceState(bundle)
    }
    
    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        state.saveInstanceState(outState)
    }
}

Custom property are also allowed there made with serialization to string followed by bundle.putString

There is also an API to use mutable objects

data class Item (
    var foo: Foo? = null
)

object MainStorage : ... {
    val item by property(::Item)
}

// Launches an asynchronous commit after block()
fun editItem() = MainStorage.mutate {
    item.foo = ...
}
// Suspends until commit
suspend fun editItem() = MainStorage.mutateCommit {
    item.foo = ...
}
// Blocking mutation
fun editItem() = MainStorage.mutateBlocking {
    item.foo = ...
}

suspend fun main() {
    // Launches a commit and cancels the previous one
    MainStorage.launchCommit()
    // Suspends until commit
    MainStorage.commit()
    // Blocking commit
    MainStorage.commitBlocking()
}

There are some (experimental for now) entities which may automatically perform save operation on mutate:

object MainStorage : ... {
    val list by storageList<Boolean>()
    val map by storageMap<String, Int>()
    val set by storageSet { mutableSetOf(1, 2, 3) }
}

fun main() {
    // Then any mutation on this entities will perform save
    // The saving operation will same as operation when assigning variable to new value
    // It means that in KFileDataStorage async save will be invoked, while in KLocalDataStorage blocking `put` method
    MainStorage.list += true
}

Androidx MutableState

object ComposeStorage : ... {
    val username by mutableState<String>()
}
...
@Composable
fun UserNameText() {
    val username by remember { ComposeStorage.username }
    Text (
        text = username
    )
}

KVision ObservableValue

object AppData : KLocalDataStorage() {
    val clicks by observableValue { 0 }
}

class App : Application() {
    override fun start() {
        root(id = "root") {
            vPanel {
                h1(AppData.clicks) { clicks ->
                    + "Clicked $clicks times"
                }
                button(text = "Click!") {
                    onClick {
                        // Changes still handled by storage
                        clicks.value++
                    }
                }
            }
        }
    }
}

fun main() = startApplication(::App)

Coroutines MutableStateFlow

object CoroutinesStorage : ... {
    // Use it everywhere you need to save state flow values
    val stateFlow by mutableStateFlow<String>()
}