fix #1316 and #1016 - add KClass relative API for module, to avoid in…

…line API for native

core/koin-core/src/commonMain/kotlin/org/koin/core/module/Module.kt

@@ -110,16 +110,14 @@ class Module(
     }
 
     @KoinInternalApi
-    @PublishedApi
-    internal fun indexPrimaryType(instanceFactory: InstanceFactory<*>) {
+    fun indexPrimaryType(instanceFactory: InstanceFactory<*>) {
         val def = instanceFactory.beanDefinition
         val mapping = indexKey(def.primaryType, def.qualifier, def.scopeQualifier)
         saveMapping(mapping, instanceFactory)
     }
 
     @KoinInternalApi
-    @PublishedApi
-    internal fun indexSecondaryTypes(instanceFactory: InstanceFactory<*>) {
+    fun indexSecondaryTypes(instanceFactory: InstanceFactory<*>) {
         val def = instanceFactory.beanDefinition
         def.secondaryTypes.forEach { clazz ->
             val mapping = indexKey(clazz, def.qualifier, def.scopeQualifier)
@@ -128,8 +126,7 @@ class Module(
     }
 
     @KoinInternalApi
-    @PublishedApi
-    internal fun prepareForCreationAtStart(instanceFactory: SingleInstanceFactory<*>) {
+    fun prepareForCreationAtStart(instanceFactory: SingleInstanceFactory<*>) {
         eagerInstances.add(instanceFactory)
     }
 

core/koin-core/src/nativeMain/kotlin/org/koin/core/module/ModuleExt.kt

@@ -0,0 +1,71 @@
+@file:OptIn(KoinInternalApi::class, KoinInternalApi::class)
+
+package org.koin.core.module
+
+import org.koin.core.annotation.KoinInternalApi
+import org.koin.core.definition.BeanDefinition
+import org.koin.core.definition.Definition
+import org.koin.core.definition.Kind
+import org.koin.core.instance.FactoryInstanceFactory
+import org.koin.core.instance.SingleInstanceFactory
+import org.koin.core.qualifier.Qualifier
+import org.koin.core.registry.ScopeRegistry
+import kotlin.reflect.KClass
+
+/**
+ * Module extension for Native to allow use of Module API without inlined KClass Type
+ *
+ * @author Arnaud Giuliani
+ */
+
+internal fun <T : Any> Module.createDefinition(
+    kind: Kind = Kind.Singleton,
+    kClass: KClass<T>,
+    qualifier: Qualifier? = null,
+    definition: Definition<T>,
+    secondaryTypes: List<KClass<*>> = emptyList(),
+    scopeQualifier: Qualifier = ScopeRegistry.rootScopeQualifier
+): BeanDefinition<T> {
+    return BeanDefinition(
+        scopeQualifier,
+        kClass,
+        qualifier,
+        definition,
+        kind,
+        secondaryTypes = secondaryTypes
+    )
+}
+
+/**
+ * Create a factory
+ */
+fun <T : Any> Module.factory(
+    kClass: KClass<T>,
+    qualifier: Qualifier? = null,
+    definition: Definition<T>,
+    scopeQualifier: Qualifier = ScopeRegistry.rootScopeQualifier
+): KoinDefinition<T> {
+    val def = createDefinition(Kind.Factory,kClass,qualifier,definition, scopeQualifier = scopeQualifier)
+    val factory = FactoryInstanceFactory(def)
+    indexPrimaryType(factory)
+    return Pair(this, factory)
+}
+
+/**
+ * Create a Single
+ */
+fun <T : Any> Module.single(
+    kClass: KClass<T>,
+    qualifier: Qualifier? = null,
+    definition: Definition<T>,
+    createdAtStart: Boolean = false,
+    scopeQualifier: Qualifier = ScopeRegistry.rootScopeQualifier
+): KoinDefinition<T> {
+    val def = createDefinition(Kind.Singleton,kClass,qualifier,definition, scopeQualifier = scopeQualifier)
+    val factory = SingleInstanceFactory(def)
+    indexPrimaryType(factory)
+    if (createdAtStart){
+        prepareForCreationAtStart(factory)
+    }
+    return Pair(this, factory)
+}