From 7cf75729cabe882d25878a19378ba6f398dd5b6e Mon Sep 17 00:00:00 2001 From: Pavel Annin Date: Sat, 20 Jan 2024 09:19:07 +0300 Subject: [PATCH] - remove PreInitEffect - refactor naming - release 1.1.0 --- CHANGELOG.md | 13 +++ README.md | 18 +-- connectors/decompose/build.gradle.kts | 2 +- ...nnector.kt => KeemunComponentConnector.kt} | 48 ++++---- connectors/swift-ui/build.gradle.kts | 2 +- ...eConnector.kt => KeemunNativeConnector.kt} | 12 +- core/build.gradle.kts | 2 +- .../io/github/pavelannin/keemun/core/Types.kt | 12 +- .../keemun/core/connector/FeatureParams.kt | 14 +-- .../pavelannin/keemun/core/store/Store.kt | 19 ++-- .../keemun/core/store/StroreParams.kt | 105 +++--------------- .../keemun/core/completeness/Store.kt | 6 +- .../keemun/core/consistent/Store.kt | 4 +- dependencies.versions.toml | 4 +- sample/counter/FeatureCounter.podspec | 2 +- sample/counter/build.gradle.kts | 2 +- .../sample/counter/CounterFeatureScope.kt | 4 +- .../counter/features/counter/FeatureParams.kt | 2 +- .../sample/counter/CounterFeatureScope.kt | 4 +- 19 files changed, 97 insertions(+), 178 deletions(-) rename connectors/decompose/src/commonMain/kotlin/io/github/pavelannin/keemun/decompose/{KeemunComponentFeatureConnector.kt => KeemunComponentConnector.kt} (69%) rename connectors/swift-ui/src/iosMain/kotlin/io/github/pavelannin/keemun/swiftui/{KeemunNativeFeatureConnector.kt => KeemunNativeConnector.kt} (89%) diff --git a/CHANGELOG.md b/CHANGELOG.md index 01fe99a..413f9cb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,16 @@ +# v1.1.0 +## Core +- Renamed the `init` parameter to `start` from `StoreParams` +- Removed `PreInitEffect` from `StoreParams` +- Renamed `previous` to `savedState` from `Start` + +## Decompose +- Renamed `KeemunComponentFeatureConnector` to `KeemunComponentConnector` + +## SwiftUI +- Renamed `KeemunNativeFeatureConnector` to `KeemunNativeConnector` + + # v1.0.1 - Optimization of swiftui connector dependencies diff --git a/README.md b/README.md index a3d4e18..dec2941 100644 --- a/README.md +++ b/README.md @@ -138,22 +138,11 @@ val effectHandler = EffectHandler { effect, dispatch -> } ``` -## PreInitEffect -`PreInitEffect` is the place where logic necessary for initializing the `Store` is executed. `PreInitEffect` returns a type that is later -used for initialization. In most scenarios, there is no need to use `PreInitEffect`. - -**NOTE** `EffectHandler` is a suspend function that **blocks** the current thread. - -```kotlin -val preInitEffect = PreInitEffect { fetchCachedCounter() } -``` - ## Init -`Init` is the place for initialization. Its method takes `previousState` (if the state is being persisted) and `deps` (optionally received -from `PreInitEffect`), and returns the initializing `state` and the initial set of side-effects. +`Init` is the place for initialization. Its method takes `previousState` (if the state is being persisted), and returns the initializing `state` and the initial set of side-effects. ```kotlin -val init = Init { previous, deps -> +val init = Init { previous -> val state = previous ?: CounterState( syncCount = deps, asyncCount = deps, @@ -164,12 +153,11 @@ val init = Init { previous, deps -> ``` ## StoreParams -`StoreParams` is a container that holds `PreInitEffect`, `Init`, `Update`, and `EffectHandler` in one place for creating a `Store`. +`StoreParams` is a container that holds `Init`, `Update`, and `EffectHandler` in one place for creating a `Store`. `StoreParams` provides several convenient overridden functions for creating it with optional arguments. ```kotlin val storeParams = StoreParams( - preEffectInit = { }, init = { }, update = { }, effectHandler = { }, diff --git a/connectors/decompose/build.gradle.kts b/connectors/decompose/build.gradle.kts index 2bea4f3..3f7ee05 100644 --- a/connectors/decompose/build.gradle.kts +++ b/connectors/decompose/build.gradle.kts @@ -36,7 +36,7 @@ mavenPublishing { val artifactId = "keemun-decompose" publishToMavenCentral(SonatypeHost.S01) signAllPublications() - coordinates("io.github.pavelannin", artifactId, "1.0.1") + coordinates("io.github.pavelannin", artifactId, "1.1.0") pom { name.set(artifactId) description.set("Keemun is a multiplatform Kotlin framework that provides a way to write shared code using The Elm Architecture pattern.") diff --git a/connectors/decompose/src/commonMain/kotlin/io/github/pavelannin/keemun/decompose/KeemunComponentFeatureConnector.kt b/connectors/decompose/src/commonMain/kotlin/io/github/pavelannin/keemun/decompose/KeemunComponentConnector.kt similarity index 69% rename from connectors/decompose/src/commonMain/kotlin/io/github/pavelannin/keemun/decompose/KeemunComponentFeatureConnector.kt rename to connectors/decompose/src/commonMain/kotlin/io/github/pavelannin/keemun/decompose/KeemunComponentConnector.kt index 372fd69..3e99b75 100644 --- a/connectors/decompose/src/commonMain/kotlin/io/github/pavelannin/keemun/decompose/KeemunComponentFeatureConnector.kt +++ b/connectors/decompose/src/commonMain/kotlin/io/github/pavelannin/keemun/decompose/KeemunComponentConnector.kt @@ -19,66 +19,66 @@ import kotlinx.serialization.serializer * * @see FeatureConnector */ -interface KeemunComponentFeatureConnector : ComponentContext, CoroutineScopeOwner, FeatureConnector +interface KeemunComponentConnector : ComponentContext, CoroutineScopeOwner, FeatureConnector /** - * Creates a [KeemunComponentFeatureConnector]. + * Creates a [KeemunComponentConnector]. * - * @param componentContext The context for aggregating the creation of [KeemunComponentFeatureConnector]. + * @param componentContext The context for aggregating the creation of [KeemunComponentConnector]. * @param storeCreator The function for creating the [Store]. * @param stateSerializer The serializer used for saving and restoring the state. * - * @see KeemunComponentFeatureConnector + * @see KeemunComponentConnector */ -fun KeemunComponentFeatureConnector( +fun KeemunComponentConnector( componentContext: ComponentContext, - storeCreator: (previousState: State?, scope: CoroutineScope) -> Lazy>, + storeCreator: (savedState: State?, scope: CoroutineScope) -> Lazy>, stateSerializer: KSerializer, -): KeemunComponentFeatureConnector = DefaultComponentFeatureConnector( +): KeemunComponentConnector = DefaultComponentConnector( componentContext = componentContext, storeCreator = storeCreator, stateSerializer = stateSerializer, ) /** - * Creates a [KeemunComponentFeatureConnector]. + * Creates a [KeemunComponentConnector]. * - * @param componentContext The context for aggregating the creation of [KeemunComponentFeatureConnector]. + * @param componentContext The context for aggregating the creation of [KeemunComponentConnector]. * @param storeCreator The function for creating the [Store]. * - * @see KeemunComponentFeatureConnector + * @see KeemunComponentConnector */ @OptIn(InternalSerializationApi::class) -inline fun KeemunComponentFeatureConnector( +inline fun KeemunComponentConnector( componentContext: ComponentContext, - noinline storeCreator: (previousState: State?, scope: CoroutineScope) -> Lazy>, -) = KeemunComponentFeatureConnector( + noinline storeCreator: (savedState: State?, scope: CoroutineScope) -> Lazy>, +) = KeemunComponentConnector( componentContext = componentContext, storeCreator = storeCreator, stateSerializer = State::class.serializer(), ) /** - * Creates a [KeemunComponentFeatureConnector]. + * Creates a [KeemunComponentConnector]. * - * @param componentContext The context for aggregating the creation of [KeemunComponentFeatureConnector]. + * @param componentContext The context for aggregating the creation of [KeemunComponentConnector]. * @param featureParams Parameters used for creation. * @param stateSerializer The serializer used for saving and restoring the state. * - * @see KeemunComponentFeatureConnector + * @see KeemunComponentConnector */ @OptIn(InternalSerializationApi::class) -inline fun KeemunComponentFeatureConnector( +inline fun KeemunComponentConnector( componentContext: ComponentContext, featureParams: FeatureParams, stateSerializer: KSerializer = State::class.serializer(), -): KeemunComponentFeatureConnector = object : KeemunComponentFeatureConnector, +): KeemunComponentConnector = object : KeemunComponentConnector, ComponentContext by componentContext, CoroutineScopeOwner by componentContext.CoroutineScopeOwner(), - Store by KeemunComponentFeatureConnector( + Store by KeemunComponentConnector( componentContext = componentContext, - storeCreator = { previousState, scope -> - lazy { Store(previousState = previousState, params = featureParams.storeParams, coroutineScope = scope) }.let { lazyStore -> + storeCreator = { savedState, scope -> + lazy { Store(savedState = savedState, params = featureParams.storeParams, coroutineScope = scope) }.let { lazyStore -> when (featureParams.startedOptions) { FeatureStartedOptions.Eagerly -> lazyStore.apply { value } FeatureStartedOptions.Lazily -> lazyStore @@ -91,11 +91,11 @@ inline fun messageTransform = featureParams.externalMessageTransform, ){} -private class DefaultComponentFeatureConnector( +private class DefaultComponentConnector( componentContext: ComponentContext, - storeCreator: (previousState: State?, scope: CoroutineScope) -> Lazy>, + storeCreator: (savedState: State?, scope: CoroutineScope) -> Lazy>, stateSerializer: KSerializer, -) : KeemunComponentFeatureConnector, +) : KeemunComponentConnector, ComponentContext by componentContext, CoroutineScopeOwner by componentContext.CoroutineScopeOwner(), Store { diff --git a/connectors/swift-ui/build.gradle.kts b/connectors/swift-ui/build.gradle.kts index 0e5e8b2..7536381 100644 --- a/connectors/swift-ui/build.gradle.kts +++ b/connectors/swift-ui/build.gradle.kts @@ -27,7 +27,7 @@ mavenPublishing { val artifactId = "keemun-swiftui" publishToMavenCentral(SonatypeHost.S01) signAllPublications() - coordinates("io.github.pavelannin", artifactId, "1.0.1") + coordinates("io.github.pavelannin", artifactId, "1.1.0") pom { name.set(artifactId) description.set("Keemun is a multiplatform Kotlin framework that provides a way to write shared code using The Elm Architecture pattern.") diff --git a/connectors/swift-ui/src/iosMain/kotlin/io/github/pavelannin/keemun/swiftui/KeemunNativeFeatureConnector.kt b/connectors/swift-ui/src/iosMain/kotlin/io/github/pavelannin/keemun/swiftui/KeemunNativeConnector.kt similarity index 89% rename from connectors/swift-ui/src/iosMain/kotlin/io/github/pavelannin/keemun/swiftui/KeemunNativeFeatureConnector.kt rename to connectors/swift-ui/src/iosMain/kotlin/io/github/pavelannin/keemun/swiftui/KeemunNativeConnector.kt index a41c550..c35d3da 100644 --- a/connectors/swift-ui/src/iosMain/kotlin/io/github/pavelannin/keemun/swiftui/KeemunNativeFeatureConnector.kt +++ b/connectors/swift-ui/src/iosMain/kotlin/io/github/pavelannin/keemun/swiftui/KeemunNativeConnector.kt @@ -22,7 +22,7 @@ import kotlinx.coroutines.withContext * * @see FeatureConnector */ -class KeemunNativeFeatureConnector ( +class KeemunNativeConnector ( storeCreator: (scope: CoroutineScope) -> Lazy>, ): FeatureConnector, CoroutineScope by CoroutineScope(Dispatchers.Default) { private val store by storeCreator(this) @@ -44,18 +44,18 @@ class KeemunNativeFeatureConnector ( } /** - * Creates a [KeemunNativeFeatureConnector]. + * Creates a [KeemunNativeConnector]. * * @param featureParams Parameters used for creation. * - * @see KeemunNativeFeatureConnector + * @see KeemunNativeConnector */ -inline fun KeemunNativeFeatureConnector( +inline fun KeemunNativeConnector( featureParams: FeatureParams, -) = KeemunNativeFeatureConnector( +): KeemunNativeConnector = KeemunNativeConnector( storeCreator = { scope -> lazy { - Store(previousState = null, params = featureParams.storeParams, coroutineScope = scope) + Store(savedState = null, params = featureParams.storeParams, coroutineScope = scope) .transform(stateTransform = featureParams.viewStateTransform, messageTransform = featureParams.externalMessageTransform) }.let { lazyStore -> when (featureParams.startedOptions) { diff --git a/core/build.gradle.kts b/core/build.gradle.kts index 565582e..dc816a8 100644 --- a/core/build.gradle.kts +++ b/core/build.gradle.kts @@ -46,7 +46,7 @@ mavenPublishing { val artifactId = "keemun-core" publishToMavenCentral(SonatypeHost.S01) signAllPublications() - coordinates("io.github.pavelannin", artifactId, "1.0.1") + coordinates("io.github.pavelannin", artifactId, "1.1.0") pom { name.set(artifactId) description.set("Keemun is a multiplatform Kotlin framework that provides a way to write shared code using The Elm Architecture pattern.") diff --git a/core/src/commonMain/kotlin/io/github/pavelannin/keemun/core/Types.kt b/core/src/commonMain/kotlin/io/github/pavelannin/keemun/core/Types.kt index 3a93280..b9f33ab 100644 --- a/core/src/commonMain/kotlin/io/github/pavelannin/keemun/core/Types.kt +++ b/core/src/commonMain/kotlin/io/github/pavelannin/keemun/core/Types.kt @@ -3,16 +3,10 @@ package io.github.pavelannin.keemun.core import kotlinx.coroutines.CoroutineScope import kotlin.native.HiddenFromObjC -/** Effect that will return the necessary dependencies to initialize the state. */ +/** Returns default state and effects by previous state. */ @HiddenFromObjC -fun interface PreInitEffect { - suspend operator fun invoke(): Deps -} - -/** Returns default state and effects by previous state and dependencies. */ -@HiddenFromObjC -fun interface Init { - operator fun invoke(previous: State?, deps: Deps): Pair> +fun interface Start { + operator fun invoke(savedState: State?): Pair> } /** Creates a next state and side-effects from a message and current state. */ diff --git a/core/src/commonMain/kotlin/io/github/pavelannin/keemun/core/connector/FeatureParams.kt b/core/src/commonMain/kotlin/io/github/pavelannin/keemun/core/connector/FeatureParams.kt index 2f8b6b0..453ae61 100644 --- a/core/src/commonMain/kotlin/io/github/pavelannin/keemun/core/connector/FeatureParams.kt +++ b/core/src/commonMain/kotlin/io/github/pavelannin/keemun/core/connector/FeatureParams.kt @@ -22,7 +22,7 @@ import kotlin.native.ObjCName */ @ObjCName(swiftName = "KeemunFeatureParams") data class FeatureParams( - val storeParams: StoreParams, + val storeParams: StoreParams, val viewStateTransform: StateTransform, val externalMessageTransform: (ExternalMsg) -> Msg, val startedOptions: FeatureStartedOptions, @@ -31,10 +31,10 @@ data class FeatureParams FeatureParams( - storeParams: StoreParams, + storeParams: StoreParams, viewStateTransform: StateTransform, startedOptions: FeatureStartedOptions = FeatureStartedOptions.Lazily, -) = FeatureParams( +): FeatureParams = FeatureParams( storeParams = storeParams, viewStateTransform = viewStateTransform, externalMessageTransform = { it }, @@ -44,10 +44,10 @@ inline fun FeatureP /** @see FeatureParams */ @HiddenFromObjC inline fun FeatureParams( - storeParams: StoreParams, + storeParams: StoreParams, noinline externalMessageTransform: (ExternalMsg) -> Msg, startedOptions: FeatureStartedOptions = FeatureStartedOptions.Lazily, -) = FeatureParams( +): FeatureParams = FeatureParams( storeParams = storeParams, viewStateTransform = { it }, externalMessageTransform = externalMessageTransform, @@ -57,9 +57,9 @@ inline fun FeatureParams( /** @see FeatureParams */ @HiddenFromObjC inline fun FeatureParams( - storeParams: StoreParams, + storeParams: StoreParams, startedOptions: FeatureStartedOptions = FeatureStartedOptions.Lazily, -) = FeatureParams( +): FeatureParams = FeatureParams( storeParams = storeParams, viewStateTransform = { it }, externalMessageTransform = { it }, diff --git a/core/src/commonMain/kotlin/io/github/pavelannin/keemun/core/store/Store.kt b/core/src/commonMain/kotlin/io/github/pavelannin/keemun/core/store/Store.kt index ad66891..9cef860 100644 --- a/core/src/commonMain/kotlin/io/github/pavelannin/keemun/core/store/Store.kt +++ b/core/src/commonMain/kotlin/io/github/pavelannin/keemun/core/store/Store.kt @@ -10,7 +10,6 @@ import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.flow.onSubscription import kotlinx.coroutines.launch import kotlinx.coroutines.plus -import kotlinx.coroutines.runBlocking import kotlin.native.HiddenFromObjC import kotlin.native.ObjCName @@ -36,27 +35,27 @@ interface Store { /** * Creates an implementation of [Store]. * - * @param previousState Previous state. Not null if the process was killed by the system and restored to its previous state. + * @param savedState Previous saved state. Not null if the process was killed by the system and restored to its previous state. * @param params Parameters for creating [Store]. * @param coroutineScope The main scope on which all coroutines will be launched. * * @see Store */ @HiddenFromObjC -fun Store( - previousState: State?, - params: StoreParams, +fun Store( + savedState: State?, + params: StoreParams, coroutineScope: CoroutineScope, ): Store = DefaultStore( - previousState = previousState, + savedState = savedState, params = params, coroutineScope = coroutineScope, ) @HiddenFromObjC -private class DefaultStore( - previousState: State?, - private val params: StoreParams, +private class DefaultStore( + savedState: State?, + private val params: StoreParams, coroutineScope: CoroutineScope, ) : Store { private val _state: MutableStateFlow @@ -66,7 +65,7 @@ private class DefaultStore( - val preEffectInit: PreInitEffect, - val init: Init, +data class StoreParams( + val start: Start, val update: Update, val effectHandlers: Set>, ) -/** @see StoreParams */ -@HiddenFromObjC -inline fun StoreParams( - preEffectInit: PreInitEffect, - init: Init, - update: Update, - effectHandler: EffectHandler, -) = StoreParams( - preEffectInit = preEffectInit, - init = init, - update = update, - effectHandlers = setOf(effectHandler) -) - -/** @see StoreParams */ -@HiddenFromObjC -inline fun StoreParams( - crossinline init: (previous: State?) -> Pair>, - update: Update, - effectHandlers: Set>, -) = StoreParams( - preEffectInit = {}, - init = { previous, _ -> init(previous) }, - update = update, - effectHandlers = effectHandlers -) - /** @see StoreParams */ @HiddenFromObjC inline fun StoreParams( - crossinline init: (previous: State?) -> Pair>, + start: Start, update: Update, effectHandler: EffectHandler, -) = StoreParams( - preEffectInit = {}, - init = { previous, _ -> init(previous) }, +): StoreParams = StoreParams( + start = start, update = update, - effectHandlers = setOf(effectHandler), -) - -/** @see StoreParams */ -@HiddenFromObjC -inline fun StoreParams( - preEffectInit: PreInitEffect, - init: Init, - externalUpdate: Update, - internalUpdate: Update, - effectHandlers: Set>, -) = StoreParams( - preEffectInit = preEffectInit, - init = init, - update = { msg, state -> - when (msg) { - is ExternalMsg -> externalUpdate(msg, state) - is InternalMsg -> internalUpdate(msg, state) - else -> error("Unknown type $msg") - } - }, - effectHandlers = effectHandlers as Set> -) - -/** @see StoreParams */ -@HiddenFromObjC -inline fun StoreParams( - preEffectInit: PreInitEffect, - init: Init, - externalUpdate: Update, - internalUpdate: Update, - effectHandler: EffectHandler, -) = StoreParams( - preEffectInit = preEffectInit, - init = init, - update = { msg, state -> - when (msg) { - is ExternalMsg -> externalUpdate(msg, state) - is InternalMsg -> internalUpdate(msg, state) - else -> error("Unknown type $msg") - } - }, - effectHandler = effectHandler + effectHandlers = setOf(effectHandler) ) /** @see StoreParams */ @HiddenFromObjC -@Suppress("UNCHECKED_CAST") inline fun StoreParams( - crossinline init: (previous: State?) -> Pair>, + start: Start, externalUpdate: Update, internalUpdate: Update, effectHandlers: Set>, -) = StoreParams( - init = init, +): StoreParams = StoreParams( + start = start, update = { msg, state -> when (msg) { is ExternalMsg -> externalUpdate(msg, state) @@ -126,14 +52,13 @@ inline fun StoreParams( - crossinline init: (previous: State?) -> Pair>, + start: Start, externalUpdate: Update, internalUpdate: Update, effectHandler: EffectHandler, -) = StoreParams( - init = init, +): StoreParams = StoreParams( + start = start, update = { msg, state -> when (msg) { is ExternalMsg -> externalUpdate(msg, state) @@ -141,5 +66,5 @@ inline fun error("Unknown type $msg") } }, - effectHandler = effectHandler as EffectHandler + effectHandler = effectHandler ) diff --git a/core/src/commonTest/kotlin/io/github/pavelannin/keemun/core/completeness/Store.kt b/core/src/commonTest/kotlin/io/github/pavelannin/keemun/core/completeness/Store.kt index 1518738..e3f99fe 100644 --- a/core/src/commonTest/kotlin/io/github/pavelannin/keemun/core/completeness/Store.kt +++ b/core/src/commonTest/kotlin/io/github/pavelannin/keemun/core/completeness/Store.kt @@ -38,11 +38,11 @@ private val effectHandler = EffectHandler { } fun store(scope: CoroutineScope, repeatCount: Int) = Store( - previousState = null, + savedState = null, coroutineScope = scope, params = StoreParams( - init = { previous -> - val state = previous ?: CompletenessState(flow1 = 0, flow2 = 0, flow3 = 0) + start = { savedState -> + val state = savedState ?: CompletenessState(flow1 = 0, flow2 = 0, flow3 = 0) state to setOf( CompletenessEffect.StartIncFlow1(repeatCount), CompletenessEffect.StartIncFlow2(repeatCount), diff --git a/core/src/commonTest/kotlin/io/github/pavelannin/keemun/core/consistent/Store.kt b/core/src/commonTest/kotlin/io/github/pavelannin/keemun/core/consistent/Store.kt index a889b61..69e9b25 100644 --- a/core/src/commonTest/kotlin/io/github/pavelannin/keemun/core/consistent/Store.kt +++ b/core/src/commonTest/kotlin/io/github/pavelannin/keemun/core/consistent/Store.kt @@ -33,10 +33,10 @@ val update = Update { msg, mod } fun store(scope: CoroutineScope) = Store( - previousState = null, + savedState = null, coroutineScope = scope, params = StoreParams( - init = { previous -> (previous ?: ConsistentState(progress = false, loadedUser = null)) to emptySet() }, + start = { savedState -> (savedState ?: ConsistentState(progress = false, loadedUser = null)) to emptySet() }, update = update, effectHandler = { eff, dispatch -> when (eff) { diff --git a/dependencies.versions.toml b/dependencies.versions.toml index f53edbd..b3cb2f0 100644 --- a/dependencies.versions.toml +++ b/dependencies.versions.toml @@ -6,7 +6,7 @@ kotlin-serialization = "1.6.2" decompose = "2.2.1" androidX-compose-bom = "2023.10.01" androidX-compose = "1.5.4" -keemun = "1.0.1" +keemun = "1.1.0" [libraries] kotlin-std-common = { module = "org.jetbrains.kotlin:kotlin-stdlib-common", version.ref = "kotlin-language" } @@ -42,4 +42,4 @@ kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin-la kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin-language" } kotlin-cocoapods = { id = "org.jetbrains.kotlin.native.cocoapods", version.ref = "kotlin-language" } kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin-language" } -maven-publish = { id ="com.vanniktech.maven.publish", version = "0.25.3" } +maven-publish = { id ="com.vanniktech.maven.publish", version = "0.27.0" } diff --git a/sample/counter/FeatureCounter.podspec b/sample/counter/FeatureCounter.podspec index b5f07f4..22775aa 100644 --- a/sample/counter/FeatureCounter.podspec +++ b/sample/counter/FeatureCounter.podspec @@ -1,6 +1,6 @@ Pod::Spec.new do |spec| spec.name = 'FeatureCounter' - spec.version = '1.0' + spec.version = '1.1.0' spec.homepage = 'https://github.com/pavelannin/Keemun-Kotlin' spec.source = { :http=> ''} spec.authors = '' diff --git a/sample/counter/build.gradle.kts b/sample/counter/build.gradle.kts index cd07cf1..1dc8cfe 100644 --- a/sample/counter/build.gradle.kts +++ b/sample/counter/build.gradle.kts @@ -13,7 +13,7 @@ kotlin { cocoapods { name = "FeatureCounter" - version = "1.0" + version = "1.1.0" summary = "Multiplatform sample feature" homepage = "https://github.com/pavelannin/Keemun-Kotlin" ios.deploymentTarget = "13.0" diff --git a/sample/counter/src/androidMain/kotlin/io/github/pavelannin/keemun/sample/counter/CounterFeatureScope.kt b/sample/counter/src/androidMain/kotlin/io/github/pavelannin/keemun/sample/counter/CounterFeatureScope.kt index 00d589c..46321dd 100644 --- a/sample/counter/src/androidMain/kotlin/io/github/pavelannin/keemun/sample/counter/CounterFeatureScope.kt +++ b/sample/counter/src/androidMain/kotlin/io/github/pavelannin/keemun/sample/counter/CounterFeatureScope.kt @@ -3,7 +3,7 @@ package io.github.pavelannin.keemun.sample.counter import androidx.compose.runtime.Composable import com.arkivanov.decompose.ComponentContext import io.github.pavelannin.keemun.core.store.Store -import io.github.pavelannin.keemun.decompose.KeemunComponentFeatureConnector +import io.github.pavelannin.keemun.decompose.KeemunComponentConnector import io.github.pavelannin.keemun.sample.counter.features.counter.Counter import io.github.pavelannin.keemun.sample.counter.features.counter.CounterViewState import io.github.pavelannin.keemun.sample.counter.features.counter.ExternalMsg @@ -11,7 +11,7 @@ import io.github.pavelannin.keemun.sample.counter.features.counter.counterFeatur actual class CounterFeatureScope { - fun counter(componentContext: ComponentContext) = KeemunComponentFeatureConnector( + fun counter(componentContext: ComponentContext) = KeemunComponentConnector( componentContext = componentContext, featureParams = counterFeatureParams() ) diff --git a/sample/counter/src/commonMain/kotlin/io/github/pavelannin/keemun/sample/counter/features/counter/FeatureParams.kt b/sample/counter/src/commonMain/kotlin/io/github/pavelannin/keemun/sample/counter/features/counter/FeatureParams.kt index 673f7b8..38f8d57 100644 --- a/sample/counter/src/commonMain/kotlin/io/github/pavelannin/keemun/sample/counter/features/counter/FeatureParams.kt +++ b/sample/counter/src/commonMain/kotlin/io/github/pavelannin/keemun/sample/counter/features/counter/FeatureParams.kt @@ -7,7 +7,7 @@ import kotlinx.serialization.Serializable internal fun counterFeatureParams(): FeatureParams = FeatureParams( storeParams = StoreParams( - init = { previous -> (previous ?: CounterState(syncCount = 0, asyncCount = 0, isAsyncRunning = false)) to emptySet() }, + start = { savedState -> (savedState ?: CounterState(syncCount = 0, asyncCount = 0, isAsyncRunning = false)) to emptySet() }, externalUpdate = { msg, state -> when (msg) { ExternalMsg.IncrementSync -> diff --git a/sample/counter/src/iosMain/kotlin/io/github/pavelannin/keemun/sample/counter/CounterFeatureScope.kt b/sample/counter/src/iosMain/kotlin/io/github/pavelannin/keemun/sample/counter/CounterFeatureScope.kt index 810a290..3cb39da 100644 --- a/sample/counter/src/iosMain/kotlin/io/github/pavelannin/keemun/sample/counter/CounterFeatureScope.kt +++ b/sample/counter/src/iosMain/kotlin/io/github/pavelannin/keemun/sample/counter/CounterFeatureScope.kt @@ -1,8 +1,8 @@ package io.github.pavelannin.keemun.sample.counter import io.github.pavelannin.keemun.sample.counter.features.counter.counterFeatureParams -import io.github.pavelannin.keemun.swiftui.KeemunNativeFeatureConnector +import io.github.pavelannin.keemun.swiftui.KeemunNativeConnector actual class CounterFeatureScope { - fun counter() = KeemunNativeFeatureConnector(featureParams = counterFeatureParams()) + fun counter() = KeemunNativeConnector(featureParams = counterFeatureParams()) }