Lock your Dagger In Gradle Modules

AppComponent_Encapsulated.kt

@Component(
	dependencies = [
		FeatureComponent::class
	]
)
@Singleton
interface AppComponent {

	@Component.Factory
	interface Factory {
	
		fun create(
			featureComponent: FeatureComponent,
		): AppComponent
	}
}

Application_no_scope.kt

val featureComponent = DaggerFeatureComponent.factory().create()

val appComponent = DaggerAppComponent
   .factory()
   .create(featureComponent)

ApplicationComponent_Contract.kt

@Component(
  dependencies = [
    FeatureComponentContract::class // dependency on contract
  ]
)
@Singleton
interface AppComponent {

  @Component.Factory
  interface Factory {
    
    fun create(
      featureComponent: FeatureComponentContract, // dependency on contract
    ): AppComponent
  }
}

FeatureComponent_Contract.kt

interface FeatureComponentContract {
   val featureRepository: FeatureRepository
}

@Component(modules = [FeatureModule::class])
@FeatureScope
interface FeatureComponent : FeatureComponentContract {

  @Component.Factory
  interface Factory {
    fun create(): FeatureComponent
  }
}

FeatureComponent_Encapsultation.kt

@Component(modules = [FeatureModule::class])
interface FeatureComponent {
  
  @Component.Factory
  interface Factory {
    fun create(): FeatureComponent
  }

  // explicitly specify, otherwise can't provide outside of the component
  val featureRepository: FeatureRepository
}

FeatureModule.kt

@Module
object FeatureModule {
  
  @Provides
  fun provideLibraryManager() = LibraryManager()
}

FeatureModule_Binds.kt

@Module
abstract class FeatureModule {
  
  @Binds
  abstract fun bindsFeatureRepository(impl: FeatureRepositoryImpl): FeatureRepository
}

FeatureRepository.kt

class FeatureRepository @Inject constructor(
	private val libraryManager: LibraryManager
) {

	fun doSomething() {
		libraryManager.doSomething()
	}

}

FeatureRepository_Encapsulated.kt

interface FeatureRepository {
  fun doSomething()
}

internal class FeatureRepositoryImpl @Inject constructor() : FeatureRepository {

  override fun doSomething() {
    // ommitted
  }

}