NikolaDespotoski

@Composable
fun SampleScreen(modifier: Modifier = Modifier) {
    Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
        //when modifierLocalConsumer { } block is called, next composition 
       // will make this local prop non null.
        val myScope by remember { mutableStateOf<MyScope?>(null) }
            Column {
                MyLayout(
                    modifier = Modifier
                        .padding(innerPadding)

NikolaDespotoski

val ModifierLocalMyScope =
    modifierLocalOf<MyScope> { error("Scope not provided") }

@Composable
fun MyLayout(
    modifier: Modifier = Modifier,
    properties: MyProperties = MyProperties(),
    colors: MyLayoutColors = MyLayoutDefaults.colors(),
    content: @Composable (MyScope.() -> Unit)
) {

NikolaDespotoski

/**
 * Searches largest parent with [LayoutCoordinates]
 *
 * @param selector property selector
 *
 * @return Largest parent in the tree [LayoutCoordinates] starting from calling
 *  receiver and searching up the tree until the last parent is visited. If receiver object doesn't
 *  have parent, it assumes this is the max.
 */
inline fun <reified P : Comparable<P>> LayoutCoordinates.maxOf(selector: LayoutCoordinates.() -> P): LayoutCoordinates {

NikolaDespotoski

@file:OptIn(ExperimentalComposeUiApi::class)

import androidx.annotation.DrawableRes
import androidx.annotation.IdRes
import androidx.annotation.RawRes
import androidx.annotation.StringRes
import androidx.compose.ui.ExperimentalComposeUiApi
import androidx.compose.ui.Modifier
import androidx.compose.ui.input.pointer.PointerEventPass
import androidx.compose.ui.input.pointer.PointerInputChange

NikolaDespotoski

/**
 * Should warn when making unattended a viewmodel function in a composable without considering
 * potential recompositions
 *
 *   Should warn when:
 *
 *   @Composable
 *   fun MyComposable(viewModel : MyViewModel) {
 *
 *       viewModel.startOperation()

NikolaDespotoski

import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.DrawModifier
import androidx.compose.ui.geometry.Rect
import androidx.compose.ui.graphics.BlendMode
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.ColorFilter
import androidx.compose.ui.graphics.Paint
import androidx.compose.ui.graphics.drawscope.ContentDrawScope
import androidx.compose.ui.graphics.drawscope.drawIntoCanvas

NikolaDespotoski

import androidx.camera.core.CameraSelector
import androidx.camera.view.CameraController
import androidx.camera.view.LifecycleCameraController
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.compositionLocalOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

NikolaDespotoski

/**
 * Converts [MlKitAnalyzer.Result] into [kotlin.Result]
 * @param detector Any [Detector]
 * @returns [kotlin.Result] 
 */
fun <T> MlKitAnalyzer.Result.toResult(detector: Detector<T>): Result<T> =
    kotlin.runCatching {
        val value = getValue(detector) ?: throw getThrowable(detector)!!
        value
    }

NikolaDespotoski

/**
 * Cancels current flow when the predicate is matched, throws [CancellationException] up in 
 * current coroutine. 
 * @param cause class that will be used as cause for [CancellationException]
 * @param predicate if result of this function is [true] then the flow is stopped
 */
inline fun <T> Flow<T>.cancelWhen(
    cause: KClass<out Throwable>? = null,
    crossinline predicate: (T) -> Boolean
): Flow<T> = transform {

NikolaDespotoski

import com.google.devtools.ksp.getClassDeclarationByName
import com.google.devtools.ksp.processing.Resolver
import com.google.devtools.ksp.symbol.*

/**
 * Reified function to check if receiver [KSType] is assignable from [T] class
 */
inline fun <reified T> KSType.isAssignableFrom(resolver: Resolver): Boolean {
    val classDeclaration = requireNotNull(resolver.getClassDeclarationByName<T>()) {
        "Unable to resolve ${KSClassDeclaration::class.simpleName} for type ${T::class.simpleName}"