or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

application.mdcomponents.mddependency-injection.mdglobal-context.mdindex.mdmodules.mdscopes.md
tile.json

tessl/maven-io-insert-koin--koin-core-wasm-js

Core dependency injection framework for Kotlin Multiplatform projects targeting WebAssembly JavaScript environments

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/io.insert-koin/koin-core@4.1.x?type=wasmJs

To install, run

npx @tessl/cli install tessl/maven-io-insert-koin--koin-core-wasm-js@4.1.0

index.mddocs/

Koin Core WASM JS

Koin Core WASM JS is a pragmatic dependency injection framework for Kotlin Multiplatform projects targeting WebAssembly JavaScript environments. It provides lightweight, DSL-based dependency injection with support for scopes, components, and lifecycle management optimized for WASM JS execution.

Package Information

  • Package Name: io.insert-koin:koin-core
  • Package Type: maven (Kotlin Multiplatform)
  • Language: Kotlin
  • Target: WebAssembly JavaScript (wasmJs)
  • Installation: Add to your build.gradle.kts:

WASM JS Note: This library is specifically compiled for WebAssembly JavaScript targets, providing optimal performance in WASM JS environments with single-threaded execution model.

dependencies {
    implementation("io.insert-koin:koin-core:4.1.0")
}

Core Imports

import org.koin.core.Koin
import org.koin.core.KoinApplication
import org.koin.core.component.KoinComponent
import org.koin.core.context.startKoin
import org.koin.core.context.stopKoin
import org.koin.core.module.Module
import org.koin.core.scope.Scope
import org.koin.dsl.koinApplication
import org.koin.dsl.module

Basic Usage

import org.koin.core.context.startKoin
import org.koin.core.context.stopKoin
import org.koin.core.component.KoinComponent
import org.koin.core.component.inject
import org.koin.dsl.module

// Define a service
class UserService {
    fun getUser(id: String) = "User $id"
}

// Define a module
val appModule = module {
    single { UserService() }
}

// Start Koin
startKoin {
    modules(appModule)
}

// Use dependency injection in a component
class UserController : KoinComponent {
    private val userService: UserService by inject()
    
    fun handleRequest(id: String): String {
        return userService.getUser(id)
    }
}

// Stop Koin when done
stopKoin()

Architecture

Koin Core WASM JS is built around several key components:

  • Application Management: KoinApplication handles configuration and lifecycle
  • Dependency Container: Koin manages instance resolution and scope lifecycles
  • Module System: Module organizes dependency definitions with DSL support
  • Component Integration: KoinComponent and KoinScopeComponent provide seamless integration
  • Scope Management: Scope enables scoped dependency lifecycles and isolation
  • DSL Support: Rich domain-specific language for configuration and definition
  • Global Context: Convenient global functions for application-wide dependency management

Capabilities

Application Configuration

Application lifecycle and configuration management for setting up dependency injection in your WASM JS application.

fun koinApplication(createEagerInstances: Boolean = true, appDeclaration: KoinAppDeclaration? = null): KoinApplication

class KoinApplication {
    val koin: Koin
    fun modules(vararg modules: Module): KoinApplication
    fun properties(values: Map<String, Any>): KoinApplication
    fun logger(logger: Logger): KoinApplication
    fun close()
}

Application Configuration

Module Definition

DSL-based module system for organizing and defining dependencies with lifecycle management.

fun module(createdAtStart: Boolean = false, moduleDeclaration: ModuleDeclaration): Module

class Module {
    val id: String
    val isLoaded: Boolean
    inline fun <reified T> single(qualifier: Qualifier? = null, createdAtStart: Boolean = false, noinline definition: Definition<T>): KoinDefinition<T>
    inline fun <reified T> factory(qualifier: Qualifier? = null, noinline definition: Definition<T>): KoinDefinition<T>
}

Module Definition

Dependency Injection

Core dependency injection functionality for resolving and managing object instances.

class Koin {
    inline fun <reified T : Any> get(qualifier: Qualifier? = null, noinline parameters: ParametersDefinition? = null): T
    inline fun <reified T : Any> inject(qualifier: Qualifier? = null, mode: LazyThreadSafetyMode = KoinPlatformTools.defaultLazyMode(), noinline parameters: ParametersDefinition? = null): Lazy<T>
    inline fun <reified T> declare(instance: T, qualifier: Qualifier? = null, secondaryTypes: List<KClass<*>> = emptyList(), allowOverride: Boolean = true)
}

Dependency Injection

Scope Management

Scoped dependency lifecycles for managing instances with controlled lifecycles and isolation.

class Scope {
    val scopeQualifier: Qualifier
    val id: ScopeID
    val closed: Boolean
    inline fun <reified T : Any> get(qualifier: Qualifier? = null, noinline parameters: ParametersDefinition? = null): T
    inline fun <reified T : Any> inject(qualifier: Qualifier? = null, mode: LazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED, noinline parameters: ParametersDefinition? = null): Lazy<T>
    fun close()
}

Scope Management

Component Integration

Component interfaces and extension functions for seamless dependency injection integration in your classes.

interface KoinComponent {
    fun getKoin(): Koin
}

interface KoinScopeComponent : KoinComponent {
    val scope: Scope
}

// Extension functions
inline fun <reified T : Any> KoinComponent.get(qualifier: Qualifier? = null, noinline parameters: ParametersDefinition? = null): T
inline fun <reified T : Any> KoinComponent.inject(qualifier: Qualifier? = null, mode: LazyThreadSafetyMode = KoinPlatformTools.defaultLazyMode(), noinline parameters: ParametersDefinition? = null): Lazy<T>

Component Integration

Global Context

Application-wide dependency management with convenient global functions for common operations.

fun startKoin(appDeclaration: KoinAppDeclaration): KoinApplication
fun startKoin(koinApplication: KoinApplication): KoinApplication
fun stopKoin()
fun loadKoinModules(modules: List<Module>)
fun unloadKoinModules(modules: List<Module>)

Global Context

Common Types

typealias KoinAppDeclaration = KoinApplication.() -> Unit
typealias ModuleDeclaration = Module.() -> Unit
typealias ParametersDefinition = () -> ParametersHolder
typealias ScopeID = String
typealias QualifierValue = String

interface Qualifier {
    val value: QualifierValue
}

class ParametersHolder {
    val values: List<Any?>
    operator fun <T> get(i: Int): T
    inline fun <reified T : Any> get(): T
    fun size(): Int
}

// Factory functions
fun named(name: String): StringQualifier
inline fun <reified T> named(): TypeQualifier
fun parametersOf(vararg parameters: Any?): ParametersHolder