From 12f89fc222bec26b28afb760cc3d54fdc3572c09 Mon Sep 17 00:00:00 2001
From: Marcello Galhardo <marcello.galhardo@gmail.com>
Date: Mon, 6 Jun 2022 18:58:28 +0200
Subject: [PATCH 1/8] Add `new` methods to support 11 to 22 parameters

---
 .../kotlin/org/koin/core/module/dsl/New.kt    | 84 +++++++++++++++++++
 1 file changed, 84 insertions(+)

diff --git a/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/New.kt b/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/New.kt
index c68c21cb9..257cf8a13 100644
--- a/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/New.kt
+++ b/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/New.kt
@@ -103,3 +103,87 @@ inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T
 inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Scope.new(
     constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
 ): R = constructor(get(), get(), get(), get(), get(), get(), get(), get(), get(), get())
+
+/**
+ * @see new
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11> Scope.new(
+    constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R,
+): R = constructor(get(), get(), get(), get(), get(), get(), get(), get(), get(), get(), get())
+
+/**
+ * @see new
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12> Scope.new(
+    constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R,
+): R = constructor(get(), get(), get(), get(), get(), get(), get(), get(), get(), get(), get(),get())
+
+/**
+ * @see new
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13> Scope.new(
+    constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R,
+): R = constructor(get(), get(), get(), get(), get(), get(), get(), get(), get(), get(), get(),get(), get())
+
+/**
+ * @see new
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14> Scope.new(
+    constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R,
+): R = constructor(get(), get(), get(), get(), get(), get(), get(), get(), get(), get(), get(),get(), get(), get())
+
+/**
+ * @see new
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15> Scope.new(
+    constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R,
+): R = constructor(get(), get(), get(), get(), get(), get(), get(), get(), get(), get(), get(),get(), get(), get(), get())
+
+/**
+ * @see new
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16> Scope.new(
+    constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R,
+): R = constructor(get(), get(), get(), get(), get(), get(), get(), get(), get(), get(), get(),get(), get(), get(), get(), get())
+
+/**
+ * @see new
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17> Scope.new(
+    constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R,
+): R = constructor(get(), get(), get(), get(), get(), get(), get(), get(), get(), get(), get(),get(), get(), get(), get(), get(), get())
+
+/**
+ * @see new
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18> Scope.new(
+    constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R,
+): R = constructor(get(), get(), get(), get(), get(), get(), get(), get(), get(), get(), get(),get(), get(), get(), get(), get(), get(), get())
+
+/**
+ * @see new
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19> Scope.new(
+    constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R,
+): R = constructor(get(), get(), get(), get(), get(), get(), get(), get(), get(), get(), get(),get(), get(), get(), get(), get(), get(), get(), get())
+
+/**
+ * @see new
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20> Scope.new(
+    constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R,
+): R = constructor(get(), get(), get(), get(), get(), get(), get(), get(), get(), get(), get(),get(), get(), get(), get(), get(), get(), get(), get(), get())
+
+/**
+ * @see new
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21> Scope.new(
+    constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R,
+): R = constructor(get(), get(), get(), get(), get(), get(), get(), get(), get(), get(), get(),get(), get(), get(), get(), get(), get(), get(), get(), get(), get())
+
+/**
+ * @see new
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> Scope.new(
+    constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R,
+): R = constructor(get(), get(), get(), get(), get(), get(), get(), get(), get(), get(), get(),get(), get(), get(), get(), get(), get(), get(), get(), get(), get(), get())

From 4ec7e41f313fbfc924ce1e422cd1c01772dc71cf Mon Sep 17 00:00:00 2001
From: Marcello Galhardo <marcello.galhardo@gmail.com>
Date: Mon, 6 Jun 2022 19:24:47 +0200
Subject: [PATCH 2/8] Make `withOptions` inline

---
 .../kotlin/org/koin/core/module/dsl/OptionDSL.kt           | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/OptionDSL.kt b/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/OptionDSL.kt
index 1fdf1fffc..f4c0c47d9 100644
--- a/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/OptionDSL.kt
+++ b/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/OptionDSL.kt
@@ -19,8 +19,7 @@ import kotlin.reflect.KClass
  *
  * @author Arnaud Giuliani
  */
-
-infix fun <T> KoinDefinition<T>.withOptions(
+inline infix fun <T> KoinDefinition<T>.withOptions(
     options: BeanDefinition<T>.() -> Unit
 ): KoinDefinition<T> {
     val factory = second
@@ -28,7 +27,7 @@ infix fun <T> KoinDefinition<T>.withOptions(
     val def = second.beanDefinition
     val primary = def.qualifier
     def.also(options)
-    if (def.qualifier != primary){
+    if (def.qualifier != primary) {
         module.indexPrimaryType(factory)
     }
     module.indexSecondaryTypes(factory)
@@ -76,4 +75,4 @@ fun BeanDefinition<*>.createdAtStart() {
 
 fun <T> BeanDefinition<T>.onClose(onClose: OnCloseCallback<T>) {
     callbacks = Callbacks(onClose)
-}
\ No newline at end of file
+}

From 87a436401aaa875dd17d6d056d62962eec4f0d63 Mon Sep 17 00:00:00 2001
From: Marcello Galhardo <marcello.galhardo@gmail.com>
Date: Mon, 6 Jun 2022 19:17:50 +0200
Subject: [PATCH 3/8] Add `singleOf` methods to support 11 to 22 parameters

---
 .../org/koin/core/module/dsl/SingleOf.kt      | 196 +++++++++---------
 1 file changed, 93 insertions(+), 103 deletions(-)

diff --git a/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/SingleOf.kt b/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/SingleOf.kt
index f245986d4..b59671322 100644
--- a/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/SingleOf.kt
+++ b/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/SingleOf.kt
@@ -19,10 +19,8 @@ package org.koin.core.module.dsl
 
 import org.koin.core.annotation.KoinInternalApi
 import org.koin.core.definition.BeanDefinition
-import org.koin.core.instance.InstanceFactory
 import org.koin.core.module.KoinDefinition
 import org.koin.core.module.Module
-import org.koin.core.module._singleInstanceFactory
 
 /**
  * Declare a [Module.single] definition by resolving a constructor reference for the dependency.
@@ -41,191 +39,183 @@ import org.koin.core.module._singleInstanceFactory
  *
  * @see new
  */
-
-
 inline fun <reified R> Module.singleOf(
     crossinline constructor: () -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> {
-    return setupInstance(_singleInstanceFactory(definition = { new(constructor) }), options)
-}
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R> Module.singleOf(
-    crossinline constructor: () -> R,
-): KoinDefinition<R> = single { new(constructor) }
+inline fun <reified R, reified T1> Module.singleOf(
+    crossinline constructor: (T1) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1> Module.singleOf(
-    crossinline constructor: (T1) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> {
-    return setupInstance(_singleInstanceFactory(definition = { new(constructor) }), options)
-}
+inline fun <reified R, reified T1, reified T2> Module.singleOf(
+    crossinline constructor: (T1, T2) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1> Module.singleOf(
-    crossinline constructor: (T1) -> R,
-): Pair<Module, InstanceFactory<R>> = single { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3> Module.singleOf(
+    crossinline constructor: (T1, T2, T3) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2> Module.singleOf(
-    crossinline constructor: (T1, T2) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> {
-    return setupInstance(_singleInstanceFactory(definition = { new(constructor) }), options)
-}
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2> Module.singleOf(
-    crossinline constructor: (T1, T2) -> R,
-): Pair<Module, InstanceFactory<R>> = single { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3> Module.singleOf(
-    crossinline constructor: (T1, T2, T3) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> {
-    return setupInstance(_singleInstanceFactory(definition = { new(constructor) }), options)
-}
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3> Module.singleOf(
-    crossinline constructor: (T1, T2, T3) -> R,
-): Pair<Module, InstanceFactory<R>> = single { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> {
-    return setupInstance(_singleInstanceFactory(definition = { new(constructor) }), options)
-}
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4) -> R,
-): Pair<Module, InstanceFactory<R>> = single { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> {
-    return setupInstance(_singleInstanceFactory(definition = { new(constructor) }), options)
-}
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
+    options: (BeanDefinition<R>.() -> Unit) = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
-): Pair<Module, InstanceFactory<R>> = single { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> {
-    return setupInstance(_singleInstanceFactory(definition = { new(constructor) }), options)
-}
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
-): Pair<Module, InstanceFactory<R>> = single { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> {
-    return setupInstance(_singleInstanceFactory(definition = { new(constructor) }), options)
-}
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
-): Pair<Module, InstanceFactory<R>> = single { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> {
-    return setupInstance(_singleInstanceFactory(definition = { new(constructor) }), options)
-}
-
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
-): Pair<Module, InstanceFactory<R>> = single { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> {
-    return setupInstance(_singleInstanceFactory(definition = { new(constructor) }), options)
-}
-
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
-): Pair<Module, InstanceFactory<R>> = single { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> {
-    return setupInstance(_singleInstanceFactory(definition = { new(constructor) }), options)
-}
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
+/**
+ * @see singleOf
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)
 
 /**
  * @see singleOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.singleOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
-): Pair<Module, InstanceFactory<R>> = single { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> Module.singleOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = single { new(constructor) }.withOptions(options)

From 0b9640f448576b86471db425b4b0d9868ba83455 Mon Sep 17 00:00:00 2001
From: Marcello Galhardo <marcello.galhardo@gmail.com>
Date: Mon, 6 Jun 2022 19:31:38 +0200
Subject: [PATCH 4/8] Add `factoryOf` methods to support 11 to 22 parameters

---
 .../org/koin/core/module/dsl/FactoryOf.kt     | 174 ++++++++++--------
 1 file changed, 95 insertions(+), 79 deletions(-)

diff --git a/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/FactoryOf.kt b/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/FactoryOf.kt
index 5ab9e81ba..c41dce96b 100644
--- a/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/FactoryOf.kt
+++ b/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/FactoryOf.kt
@@ -19,12 +19,8 @@ package org.koin.core.module.dsl
 
 import org.koin.core.annotation.KoinInternalApi
 import org.koin.core.definition.BeanDefinition
-import org.koin.core.instance.InstanceFactory
 import org.koin.core.module.KoinDefinition
 import org.koin.core.module.Module
-import org.koin.core.module._factoryInstanceFactory
-import org.koin.core.module._singleInstanceFactory
-import org.koin.core.qualifier.Qualifier
 
 /**
  * Declare a [Module.factory] definition by resolving a constructor reference for the dependency.
@@ -45,162 +41,182 @@ import org.koin.core.qualifier.Qualifier
  */
 inline fun <reified R> Module.factoryOf(
     crossinline constructor: () -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R> Module.factoryOf(
-    crossinline constructor: () -> R,
-): Pair<Module, InstanceFactory<R>> = factory { new(constructor) }
+inline fun <reified R, reified T1> Module.factoryOf(
+    crossinline constructor: (T1) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1> Module.factoryOf(
-    crossinline constructor: (T1) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R, reified T1, reified T2> Module.factoryOf(
+    crossinline constructor: (T1, T2) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
+
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1> Module.factoryOf(
-    crossinline constructor: (T1) -> R,
-): Pair<Module, InstanceFactory<R>> = factory { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2> Module.factoryOf(
-    crossinline constructor: (T1, T2) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2> Module.factoryOf(
-    crossinline constructor: (T1, T2) -> R,
-): Pair<Module, InstanceFactory<R>> = factory { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3) -> R,
-): Pair<Module, InstanceFactory<R>> = factory { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4) -> R,
-): Pair<Module, InstanceFactory<R>> = factory { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
-): Pair<Module, InstanceFactory<R>> = factory { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
-): Pair<Module, InstanceFactory<R>> = factory { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
-): Pair<Module, InstanceFactory<R>> = factory { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
-): Pair<Module, InstanceFactory<R>> = factory { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
-): Pair<Module, InstanceFactory<R>> = factory { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
 
 /**
  * @see factoryOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.factoryOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
-): Pair<Module, InstanceFactory<R>> = factory { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)
+
+/**
+ * @see factoryOf
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> Module.factoryOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = factory { new(constructor) }.withOptions(options)

From 16083bac14257b7ed3b6ca519ec3dd02759003ec Mon Sep 17 00:00:00 2001
From: Marcello Galhardo <marcello.galhardo@gmail.com>
Date: Mon, 6 Jun 2022 19:36:05 +0200
Subject: [PATCH 5/8] Add `scopedOf` methods to support 11 to 22 parameters

---
 .../org/koin/core/module/dsl/ScopedOf.kt      | 169 ++++++++++--------
 1 file changed, 94 insertions(+), 75 deletions(-)

diff --git a/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/ScopedOf.kt b/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/ScopedOf.kt
index 362c9e16b..4043e663e 100644
--- a/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/ScopedOf.kt
+++ b/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/ScopedOf.kt
@@ -44,162 +44,181 @@ import org.koin.dsl.ScopeDSL
  */
 inline fun <reified R> ScopeDSL.scopedOf(
     crossinline constructor: () -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = module.setupInstance(_scopedInstanceFactory(definition = { new(constructor) }, scopeQualifier = scopeQualifier), options)
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R> ScopeDSL.scopedOf(
-    crossinline constructor: () -> R,
-): KoinDefinition<R> = scoped { new(constructor) }
+inline fun <reified R, reified T1> ScopeDSL.scopedOf(
+    crossinline constructor: (T1) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1> ScopeDSL.scopedOf(
-    crossinline constructor: (T1) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = module.setupInstance(_scopedInstanceFactory(definition = { new(constructor) }, scopeQualifier = scopeQualifier), options)
+inline fun <reified R, reified T1, reified T2> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1> ScopeDSL.scopedOf(
-    crossinline constructor: (T1) -> R,
-): KoinDefinition<R> = scoped { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = module.setupInstance(_scopedInstanceFactory(definition = { new(constructor) }, scopeQualifier = scopeQualifier), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2) -> R,
-): KoinDefinition<R> = scoped { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = module.setupInstance(_scopedInstanceFactory(definition = { new(constructor) }, scopeQualifier = scopeQualifier), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3) -> R,
-): KoinDefinition<R> = scoped { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = module.setupInstance(_scopedInstanceFactory(definition = { new(constructor) }, scopeQualifier = scopeQualifier), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4) -> R,
-): KoinDefinition<R> = scoped { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = module.setupInstance(_scopedInstanceFactory(definition = { new(constructor) }, scopeQualifier = scopeQualifier), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
-): KoinDefinition<R> = scoped { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = module.setupInstance(_scopedInstanceFactory(definition = { new(constructor) }, scopeQualifier = scopeQualifier), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
-): KoinDefinition<R> = scoped { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = module.setupInstance(_scopedInstanceFactory(definition = { new(constructor) }, scopeQualifier = scopeQualifier), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
-): KoinDefinition<R> = scoped { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = module.setupInstance(_scopedInstanceFactory(definition = { new(constructor) }, scopeQualifier = scopeQualifier), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
-): KoinDefinition<R> = scoped { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = module.setupInstance(_scopedInstanceFactory(definition = { new(constructor) }, scopeQualifier = scopeQualifier), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
-): KoinDefinition<R> = scoped { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = module.setupInstance(_scopedInstanceFactory(definition = { new(constructor) }, scopeQualifier = scopeQualifier), options)
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
 
 /**
  * @see scopedOf
  */
-inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> ScopeDSL.scopedOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
-): KoinDefinition<R> = scoped { new(constructor) }
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)
+
+/**
+ * @see scopedOf
+ */
+inline fun <reified R, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> ScopeDSL.scopedOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = scoped { new(constructor) }.withOptions(options)

From 3f74a0868f3d7d0297f22e9edea46263c92a255f Mon Sep 17 00:00:00 2001
From: Marcello Galhardo <marcello.galhardo@gmail.com>
Date: Mon, 6 Jun 2022 19:39:47 +0200
Subject: [PATCH 6/8] Add `viewModelOf` methods to support 11 to 22 parameters

---
 .../androidx/viewmodel/dsl/ViewModelOf.kt     | 171 ++++++++++--------
 1 file changed, 96 insertions(+), 75 deletions(-)

diff --git a/android/koin-android/src/main/java/org/koin/androidx/viewmodel/dsl/ViewModelOf.kt b/android/koin-android/src/main/java/org/koin/androidx/viewmodel/dsl/ViewModelOf.kt
index a0935bacb..729c775e1 100644
--- a/android/koin-android/src/main/java/org/koin/androidx/viewmodel/dsl/ViewModelOf.kt
+++ b/android/koin-android/src/main/java/org/koin/androidx/viewmodel/dsl/ViewModelOf.kt
@@ -25,6 +25,8 @@ import org.koin.core.module.Module
 import org.koin.core.module._factoryInstanceFactory
 import org.koin.core.module.dsl.new
 import org.koin.core.module.dsl.setupInstance
+import org.koin.core.module.dsl.singleOf
+import org.koin.core.module.dsl.withOptions
 
 /**
  * Declare a [Module.viewModel] definition by resolving a constructor reference for the dependency.
@@ -45,162 +47,181 @@ import org.koin.core.module.dsl.setupInstance
  */
 inline fun <reified R : ViewModel> Module.viewModelOf(
     crossinline constructor: () -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel> Module.viewModelOf(
-    crossinline constructor: () -> R,
-): KoinDefinition<R> = viewModel { new(constructor) }
+inline fun <reified R : ViewModel, reified T1> Module.viewModelOf(
+    crossinline constructor: (T1) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1> Module.viewModelOf(
-    crossinline constructor: (T1) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ViewModel, reified T1, reified T2> Module.viewModelOf(
+    crossinline constructor: (T1, T2) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1> Module.viewModelOf(
-    crossinline constructor: (T1) -> R,
-): KoinDefinition<R> = viewModel { new(constructor) }
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2> Module.viewModelOf(
-    crossinline constructor: (T1, T2) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2> Module.viewModelOf(
-    crossinline constructor: (T1, T2) -> R,
-): KoinDefinition<R> = viewModel { new(constructor) }
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3) -> R,
-): KoinDefinition<R> = viewModel { new(constructor) }
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4) -> R,
-): KoinDefinition<R> = viewModel { new(constructor) }
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
-): KoinDefinition<R> = viewModel { new(constructor) }
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
-): KoinDefinition<R> = viewModel { new(constructor) }
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
-): KoinDefinition<R> = viewModel { new(constructor) }
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
-): KoinDefinition<R> = viewModel { new(constructor) }
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
-): KoinDefinition<R> = viewModel { new(constructor) }
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
 
 /**
  * @see viewModelOf
  */
-inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.viewModelOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
-): KoinDefinition<R> = viewModel { new(constructor) }
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)
+
+/**
+ * @see viewModelOf
+ */
+inline fun <reified R : ViewModel, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = viewModel { new(constructor) }.withOptions(options)

From 808a08b5f7c46e4d9e70a20f72bbbcef88a72216 Mon Sep 17 00:00:00 2001
From: Marcello Galhardo <marcello.galhardo@gmail.com>
Date: Mon, 6 Jun 2022 19:44:11 +0200
Subject: [PATCH 7/8] Add `workerOf` methods to support 11 to 22 parameters

---
 .../koin/androidx/workmanager/dsl/WorkerOf.kt | 203 ++++++++++--------
 1 file changed, 113 insertions(+), 90 deletions(-)

diff --git a/android/koin-androidx-workmanager/src/main/java/org/koin/androidx/workmanager/dsl/WorkerOf.kt b/android/koin-androidx-workmanager/src/main/java/org/koin/androidx/workmanager/dsl/WorkerOf.kt
index b9fab316e..fd0b4e2ac 100644
--- a/android/koin-androidx-workmanager/src/main/java/org/koin/androidx/workmanager/dsl/WorkerOf.kt
+++ b/android/koin-androidx-workmanager/src/main/java/org/koin/androidx/workmanager/dsl/WorkerOf.kt
@@ -17,7 +17,10 @@
 
 package org.koin.androidx.workmanager.dsl
 
+import androidx.lifecycle.ViewModel
 import androidx.work.ListenableWorker
+import org.koin.androidx.viewmodel.dsl.viewModel
+import org.koin.androidx.viewmodel.dsl.viewModelOf
 import org.koin.core.annotation.KoinInternalApi
 import org.koin.core.definition.BeanDefinition
 import org.koin.core.module.KoinDefinition
@@ -25,6 +28,7 @@ import org.koin.core.module.Module
 import org.koin.core.module._factoryInstanceFactory
 import org.koin.core.module.dsl.new
 import org.koin.core.module.dsl.setupInstance
+import org.koin.core.module.dsl.withOptions
 
 /**
  * Fragment Constructor DSL
@@ -35,161 +39,180 @@ import org.koin.core.module.dsl.setupInstance
 inline fun <reified R : ListenableWorker> Module.workerOf(
     crossinline constructor: () -> R,
     options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker> Module.workerOf(
-    crossinline constructor: () -> R,
-): KoinDefinition<*> = worker { new(constructor) }
+inline fun <reified R : ListenableWorker, reified T1> Module.workerOf(
+    crossinline constructor: (T1) -> R,
+    options: BeanDefinition<R>.() -> Unit
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1> Module.workerOf(
-    crossinline constructor: (T1) -> R,
+inline fun <reified R : ListenableWorker, reified T1, reified T2> Module.workerOf(
+    crossinline constructor: (T1, T2) -> R,
     options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1> Module.workerOf(
-    crossinline constructor: (T1) -> R,
-): KoinDefinition<*> = worker { new(constructor) }
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3> Module.workerOf(
+    crossinline constructor: (T1, T2, T3) -> R,
+    options: BeanDefinition<R>.() -> Unit
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2> Module.workerOf(
-    crossinline constructor: (T1, T2) -> R,
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4> Module.workerOf(
+    crossinline constructor: (T1, T2, T3, T4) -> R,
     options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2> Module.workerOf(
-    crossinline constructor: (T1, T2) -> R,
-): KoinDefinition<*> = worker { new(constructor) }
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5> Module.workerOf(
+    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
+    options: BeanDefinition<R>.() -> Unit
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3> Module.workerOf(
-    crossinline constructor: (T1, T2, T3) -> R,
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.workerOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
     options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3> Module.workerOf(
-    crossinline constructor: (T1, T2, T3) -> R,
-): KoinDefinition<*> = worker { new(constructor) }
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.workerOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
+    options: BeanDefinition<R>.() -> Unit
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4) -> R,
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.workerOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
     options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4) -> R,
-): KoinDefinition<*> = worker { new(constructor) }
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.workerOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
+    options: BeanDefinition<R>.() -> Unit
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.workerOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
     options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
-): KoinDefinition<*> = worker { new(constructor) }
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
-): KoinDefinition<*> = worker { new(constructor) }
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
-): KoinDefinition<*> = worker { new(constructor) }
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
-): KoinDefinition<*> = worker { new(constructor) }
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
-): KoinDefinition<*> = worker { new(constructor) }
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
 
 /**
- * @see fragmentOf
+ * @see workerOf
  */
-inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.workerOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
-): KoinDefinition<*> = worker { new(constructor) }
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)
+
+/**
+ * @see workerOf
+ */
+inline fun <reified R : ListenableWorker, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<*> = worker { new(constructor) }.withOptions(options)

From 9c0b60569c5287f6e993503f6de07b3ec19470b7 Mon Sep 17 00:00:00 2001
From: Marcello Galhardo <marcello.galhardo@gmail.com>
Date: Mon, 6 Jun 2022 19:46:42 +0200
Subject: [PATCH 8/8] Add `fragmentOf` methods to support 11 to 22 parameters

---
 .../koin/androidx/fragment/dsl/FragmentOf.kt  | 173 ++++++++++--------
 1 file changed, 98 insertions(+), 75 deletions(-)

diff --git a/android/koin-android/src/main/java/org/koin/androidx/fragment/dsl/FragmentOf.kt b/android/koin-android/src/main/java/org/koin/androidx/fragment/dsl/FragmentOf.kt
index d4912a152..018b4b931 100644
--- a/android/koin-android/src/main/java/org/koin/androidx/fragment/dsl/FragmentOf.kt
+++ b/android/koin-android/src/main/java/org/koin/androidx/fragment/dsl/FragmentOf.kt
@@ -18,6 +18,9 @@
 package org.koin.androidx.fragment.dsl
 
 import androidx.fragment.app.Fragment
+import androidx.lifecycle.ViewModel
+import org.koin.androidx.viewmodel.dsl.viewModel
+import org.koin.androidx.viewmodel.dsl.viewModelOf
 import org.koin.core.annotation.KoinInternalApi
 import org.koin.core.definition.BeanDefinition
 import org.koin.core.module.KoinDefinition
@@ -25,6 +28,7 @@ import org.koin.core.module.Module
 import org.koin.core.module._factoryInstanceFactory
 import org.koin.core.module.dsl.new
 import org.koin.core.module.dsl.setupInstance
+import org.koin.core.module.dsl.withOptions
 
 /**
  * Fragment Constructor DSL
@@ -34,162 +38,181 @@ import org.koin.core.module.dsl.setupInstance
  */
 inline fun <reified R : Fragment> Module.fragmentOf(
     crossinline constructor: () -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment> Module.fragmentOf(
-    crossinline constructor: () -> R,
-): KoinDefinition<R> = fragment { new(constructor) }
+inline fun <reified R : Fragment, reified T1> Module.fragmentOf(
+    crossinline constructor: (T1) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1> Module.fragmentOf(
-    crossinline constructor: (T1) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : Fragment, reified T1, reified T2> Module.fragmentOf(
+    crossinline constructor: (T1, T2) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1> Module.fragmentOf(
-    crossinline constructor: (T1) -> R,
-): KoinDefinition<R> = fragment { new(constructor) }
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3> Module.fragmentOf(
+    crossinline constructor: (T1, T2, T3) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2> Module.fragmentOf(
-    crossinline constructor: (T1, T2) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4> Module.fragmentOf(
+    crossinline constructor: (T1, T2, T3, T4) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2> Module.fragmentOf(
-    crossinline constructor: (T1, T2) -> R,
-): KoinDefinition<R> = fragment { new(constructor) }
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5> Module.fragmentOf(
+    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.fragmentOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3) -> R,
-): KoinDefinition<R> = fragment { new(constructor) }
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.fragmentOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.fragmentOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4) -> R,
-): KoinDefinition<R> = fragment { new(constructor) }
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.fragmentOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.fragmentOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4, T5) -> R,
-): KoinDefinition<R> = fragment { new(constructor) }
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6) -> R,
-): KoinDefinition<R> = fragment { new(constructor) }
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7) -> R,
-): KoinDefinition<R> = fragment { new(constructor) }
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8) -> R,
-): KoinDefinition<R> = fragment { new(constructor) }
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R,
-): KoinDefinition<R> = fragment { new(constructor) }
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
-    options: BeanDefinition<R>.() -> Unit
-): KoinDefinition<R> = setupInstance(_factoryInstanceFactory(definition = { new(constructor) }), options)
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
 
 /**
  * @see fragmentOf
  */
-inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10> Module.fragmentOf(
-    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R,
-): KoinDefinition<R> = fragment { new(constructor) }
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)
+
+/**
+ * @see fragmentOf
+ */
+inline fun <reified R : Fragment, reified T1, reified T2, reified T3, reified T4, reified T5, reified T6, reified T7, reified T8, reified T9, reified T10, reified T11, reified T12, reified T13, reified T14, reified T15, reified T16, reified T17, reified T18, reified T19, reified T20, reified T21, reified T22> Module.viewModelOf(
+    crossinline constructor: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R,
+    crossinline options: BeanDefinition<R>.() -> Unit = {},
+): KoinDefinition<R> = fragment { new(constructor) }.withOptions(options)