I’m getting:

Type mismatch: inferred type is org.w3c.dom.Element but dom.Element was expected

with this code:

fun main() {
    createRoot(document.createElement("div").also { document.body!!.appendChild(it) })
        .render(App.create())
}

when bumping from kotlin-wrappers pre.430 to pre.431. What’s the new API? could you update kotlin-mui-showcase?

Basic question:

urlStr.urlEncoded()

is turning my URL into this:

https%3A%2F%<http://2Fpokeapi.co|2Fpokeapi.co>%2Fapi%2Fv2%2Fpokemon%3Flimit%3D10

which is invalid. What’s the right and http4k idiomatic way to do it?

How can I create a KSTypeReference from a class?

📣 Kotlin 1.8.20-RC is out with: ✅ New Kotlin K2 compiler updates ✅ AutoCloseable interface and Base64 encoding in stdlib ✅ New JVM incremental compilation enabled by default ✅ New Kotlin/Wasm compiler backend What’s new | Changelog Help us put the finishing touches 🪄 on the RC by reporting any lingering issues in YouTrack

has anyone seen this error?

-----------
* What went wrong:
Execution failed for task ':sample-android:runKtlintCheckOverKotlinScripts'.
> A failure occurred while executing org.jlleitschuh.gradle.ktlint.worker.KtLintWorkAction
   > com/pinterest/ktlint/core/KtLint$Params

Is there a Kotlin multiplatform JSON library with JSON primitives similar to JVM's

org.json

(

JSONObject

,

JSONArray

, etc.)? I'm looking to adapt some test code which traverses these JSON primitive types.

are there any KMP voice/audio recording libraries? We would like to use it atleast for the desktop .

Hey everyone, I'm creating a KMP library and want to publish it to my local Maven repository to add this library as a dependency on an Android project. Here is the structure I'm using:

.
└── Library/
    ├── shared/
    │   ├── featureA (module)/
    │   │   └── build.gradle.kts
    │   ├── featureB (module)/
    │   │   └── build.gradle.kts
    │   └── src/commonMain/kotlin/com/example/library/
    │       └── Library.kt
    └── build.gradle.kts

The

shared/src/build.gradle.kts

depends on both

featureA

and

featureB

, and it also contains the publishing configurations, like below:

plugins {
    // Other plugins
    id("maven-publish")
}

group = "com.example"
version = "1.0"

publishing {
    repositories {
        mavenLocal()
    }
}

kotlin {
    androidTarget {
        // Other configs
        publishLibraryVariants("release")
    }
    // Other configs
    sourceSets {
        commonMain.dependencies {
            api(projects.shared.featureA)
            api(projects.shared.featureB)
        }
    }
}

After running the

publishAndroidReleasePublicationToMavenLocalRepository

gradle task, the artefacts are properly created, and I can add this dependency to my Android project, like below:

implementation("com.example:shared-android:1.0")

However, I can only access the classes that are inside

shared/src

and not the ones in

featureA

or

featureB

. Unless I also publish them as a separate library and import them into the Android project. What I expect is to publish a single artefact where I can access all the exposed classes/interfaces that are declared as

api

dependencies in the

shared/src/build.gradle.kts

Does anyone know if this is feasible?

I am writing a suspend-based wrapper around Caffeine's AsyncLoadingCache, which natively understands cache-loading functions that return CompletableFutures. My class has a

get()

method which launches a coroutine using

CoroutineScope.future{}

. That coroutine should not be scoped to the

get()

method's lifetime, because if

get()

is called concurrently with the same key, both

get()

calls will end up waiting on the same CompletableFuture, so cancelling the first coroutine shouldn't cause the second coroutine to fail. So I'm currently passing a

CoroutineScope

into the constructor of the cache and using that to launch the `future`s. However, my current implementation means that if any of the calls inside

future{}

fail, the long-lived CoroutineScope associated with the cache is canceled, which I don't want. What I want basically is a supervisor scope nested inside the passed-in CoroutineScope, created at cache construction time. But

supervisorScope

doesn't seem to be what I want — I can't call that at cache construction time because I don't want to actually wait before returning like a supervisorScope does! Is there some other API I should be using here? I feel like maybe the answer is

SupervisorJob()

but I am still kinda confused about the distinction between Job and CoroutineScope — I can make a

SupervisorJob(coroutineScope.coroutineContext[Job])

but I'm confused about how to extract a CoroutineScope from it that I can use for launching coroutines.

Hello guys! I'm trying to update Koin from

3.3.0

to

3.5.0

in a project. But I'm getting this error bellow.

java.lang.NoSuchMethodError: No static method koinApplication(Lkotlin/jvm/functions/Function1;)Lorg/koin/core/KoinApplication; in class Lorg/koin/dsl/KoinApplicationKt; or its super classes (declaration of 'org.koin.dsl.KoinApplicationKt' appears in /data/app/~~-v7ltggb26ocufcc-xLlsg==/y.x.a.b.c.dev-powQHZcztrJNPbtiu3sZ-g==/base.apk!classes22.dex)

I think it's because I'm implementing a third party library who uses a old koin version. How can I get around?