peachsim 0.1.939 → 0.1.1399

package/kotlin/ExpoSources/dev/peach/expo/PeachExpoTypes.kt

@@ -0,0 +1,173 @@
+@file:Suppress("UNCHECKED_CAST")
+
+package dev.peach.expo
+
+import android.content.Context
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.EnumNoSuchValueException
+import expo.modules.kotlin.exception.FieldCastException
+import expo.modules.kotlin.exception.FieldRequiredException
+import expo.modules.kotlin.exception.IncompatibleArgTypeException
+import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.types.AnyType
+import expo.modules.kotlin.types.TypeCastException
+import expo.modules.kotlin.views.AnyViewProp
+import expo.modules.kotlin.views.ExpoView
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+// the app's records, enums and compose views, registered by code the host
+// generates from their sources: upstream's compile-time introspection, since
+// Kotlin/Wasm has no reflection to find @Field properties, enum parameters,
+// constructors or MutableState props.
+object PeachExpoTypes {
+    class RecordField(
+        val key: String,
+        val type: KType,
+        val required: Boolean,
+        val read: ((Any) -> Any?)?,
+        // a field with no initializer is written after construction
+        val write: ((Any, Any?) -> Unit)?,
+    )
+
+    class RecordType(val name: String, val create: () -> Any, val fields: List<RecordField>)
+
+    class EnumType(val type: KClass<*>, val entries: List<Enum<*>>, val fields: Int, val parameter: String?, val value: ((Enum<*>) -> Any?)?)
+
+    private class Frame(val type: KClass<*>?, val name: String, val values: Map<*, *>?)
+
+    class ViewType(val create: (Context, AppContext) -> ExpoView, val props: List<AnyViewProp>)
+
+    private class ViewClass(val props: KClass<*>?, val create: (Context, AppContext) -> ExpoView)
+
+    private val views = HashMap<KClass<*>, ViewClass>()
+    private val composeProps = HashMap<KClass<*>, List<AnyViewProp>>()
+    private val records = HashMap<KClass<*>, RecordType>()
+    private val enums = HashMap<KClass<*>, EnumType>()
+    // records under construction; a frame with no values builds defaults
+    private val frames = ArrayList<Frame>()
+
+    fun <V : ExpoView> view(type: KClass<V>, props: KClass<*>?, create: (Context, AppContext) -> V) {
+        views[type] = ViewClass(props, create)
+    }
+
+    fun composeProps(type: KClass<*>, props: List<AnyViewProp>) {
+        composeProps[type] = props
+    }
+
+    fun viewType(type: KClass<*>): ViewType {
+        val view = views[type] ?: throw CodedException(
+            "ERR_VIEW_NOT_SUPPORTED",
+            "Expo view ${type.simpleName} has no registered constructor",
+            null,
+        )
+        return ViewType(view.create, view.props?.let { composeProps[it] }.orEmpty())
+    }
+
+    fun <R : Any> record(type: KClass<R>, name: String, create: () -> R, fields: List<RecordField>) {
+        records[type] = RecordType(name, create, fields)
+    }
+
+    inline fun <R : Any, reified T> field(
+        key: String,
+        required: Boolean,
+        noinline read: ((R) -> T)?,
+        noinline write: ((R, T) -> Unit)?,
+    ): RecordField = RecordField(
+        key,
+        typeOf<T>(),
+        required,
+        read?.let { get -> { record: Any -> get(record as R) } },
+        write?.let { set -> { record: Any, value: Any? -> set(record as R, value as T) } },
+    )
+
+    fun <E : Enum<E>> enum(type: KClass<E>, entries: Array<E>, fields: Int, parameter: String?, value: ((E) -> Any?)?) {
+        enums[type] = EnumType(type, entries.toList(), fields, parameter, value?.let { get -> { entry: Enum<*> -> get(entry as E) } })
+    }
+
+    // a @Field initializer or constructor default: the incoming value when the
+    // converter is building this record, otherwise the declared default
+    inline fun <reified T> initial(owner: KClass<*>, key: String, required: Boolean, noinline default: () -> T): T =
+        initialValue(owner, key, required, typeOf<T>(), default) as T
+
+    @PublishedApi
+    internal fun initialValue(owner: KClass<*>, key: String, required: Boolean, type: KType, default: () -> Any?): Any? {
+        val frame = frames.lastOrNull()
+        val values = frame?.values
+        if (frame == null || values == null || frame.type != owner) return default()
+        if (!values.containsKey(key)) {
+            if (required) throw FieldRequiredException(key)
+            return withDefaults(default)
+        }
+        return fieldValue(frame.name, key, type, values[key])
+    }
+
+    private fun fieldValue(record: String, key: String, type: KType, value: Any?): Any? =
+        exceptionDecorator({ cause -> FieldCastException(key, type, record, cause) }) {
+            AnyType(type).convert(value)
+        }
+
+    private fun withDefaults(default: () -> Any?): Any? {
+        frames.add(Frame(null, "", null))
+        try {
+            return default()
+        } finally {
+            frames.removeAt(frames.lastIndex)
+        }
+    }
+
+    fun convert(classifier: KClass<*>, value: Any): Any? {
+        records[classifier]?.let { record ->
+            val values = value as? Map<*, *> ?: throw TypeCastException("Cannot cast '$value' to '${record.name}'")
+            frames.add(Frame(classifier, record.name, values))
+            val instance = try {
+                record.create()
+            } finally {
+                frames.removeAt(frames.lastIndex)
+            }
+            for (field in record.fields) {
+                val write = field.write ?: continue
+                if (!values.containsKey(field.key)) {
+                    if (field.required) throw FieldRequiredException(field.key)
+                    continue
+                }
+                write(instance, fieldValue(record.name, field.key, field.type, values[field.key]))
+            }
+            return instance
+        }
+        val enum = enums[classifier] ?: return Unconverted
+        return when (enum.fields) {
+            0 -> enum.entries.find { it.name == value } ?: throw EnumNoSuchValueException(classifier, enum.entries, value)
+            1 -> {
+                val read = enum.value!!
+                val unwrapped = if (read(enum.entries.first()) is String) value as String
+                else if (value is Double) value.toInt() else value as Int
+                requireNotNull(enum.entries.find { read(it) == unwrapped }) {
+                    "Couldn't convert '$value' to ${classifier.simpleName} where ${enum.parameter} is the enum parameter"
+                }
+            }
+            else -> throw IncompatibleArgTypeException(value::class, classifier)
+        }
+    }
+
+    // a Kotlin value as JavaScript sees it: a record's fields, an enum's value
+    fun toJS(value: Any): Any? {
+        if (value is Enum<*>) {
+            val enum = enums[value::class] ?: return value.name
+            return when (enum.fields) {
+                0 -> value.name
+                1 -> enum.value!!(value)
+                else -> throw IllegalStateException("Enum '${value::class.simpleName}' cannot be used as return type (incompatible with JS)")
+            }
+        }
+        val record = records[value::class] ?: return Unconverted
+        val result = LinkedHashMap<String, Any?>()
+        for (field in record.fields) result[field.key] = (field.read ?: continue)(value)
+        return result
+    }
+
+    // a value no registered type owns
+    object Unconverted
+}

package/kotlin/ExpoSources/expo/modules/kotlin/AppContext.kt

@@ -0,0 +1,20 @@
+package expo.modules.kotlin
+
+import expo.modules.kotlin.runtime.Runtime
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+
+// the app context every module of one process shares. its queues all run on
+// the guest's single event loop, where Android's modules queue and main
+// thread also take turns.
+class AppContext internal constructor() {
+    val mainQueue: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+    val modulesQueue: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+    val backgroundCoroutineScope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+    val runtime: Runtime = Runtime(this)
+}
+
+interface AppContextProvider {
+    val appContext: AppContext
+}

package/kotlin/ExpoSources/expo/modules/kotlin/Promise.kt

@@ -0,0 +1,19 @@
+package expo.modules.kotlin
+
+import expo.modules.kotlin.exception.CodedException
+
+interface Promise {
+    fun resolve(value: Any?)
+    fun resolve() = resolve(null)
+    fun resolve(result: Int) = resolve(result as Any?)
+    fun resolve(result: Boolean) = resolve(result as Any?)
+    fun resolve(result: Double) = resolve(result as Any?)
+    fun resolve(result: Float) = resolve(result as Any?)
+    fun resolve(result: String) = resolve(result as Any?)
+    fun resolve(result: Collection<Any?>) = resolve(result as Any?)
+    fun resolve(result: Map<String, Any?>) = resolve(result as Any?)
+    fun reject(code: String?, message: String?, cause: Throwable?)
+    fun reject(exception: CodedException) {
+        reject(exception.code, exception.message, exception.cause)
+    }
+}

package/kotlin/ExpoSources/expo/modules/kotlin/classcomponent/ClassComponentBuilder.kt

@@ -0,0 +1,198 @@
+@file:Suppress("FunctionName", "UNCHECKED_CAST")
+
+package expo.modules.kotlin.classcomponent
+
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.functions.AsyncFunctionComponent
+import expo.modules.kotlin.functions.AsyncFunctionWithPromiseComponent
+import expo.modules.kotlin.functions.SyncFunctionComponent
+import expo.modules.kotlin.functions.createAsyncFunctionComponent
+import expo.modules.kotlin.functions.AsyncFunctionBuilder
+import expo.modules.kotlin.objects.ObjectDefinitionBuilder
+import expo.modules.kotlin.objects.ObjectDefinitionData
+import expo.modules.kotlin.objects.PropertyComponentBuilderWithThis
+import expo.modules.kotlin.types.toAnyType
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+
+// generated arities 0 to 8, as upstream's ClassComponentBuilder declares
+
+class ClassDefinitionData(
+    val name: String,
+    internal val ownerClass: KClass<*>,
+    internal val constructor: SyncFunctionComponent?,
+    internal val staticSyncFunctions: Map<String, SyncFunctionComponent>,
+    internal val staticAsyncFunctions: Map<String, AsyncFunctionComponent>,
+    internal val objectDefinition: ObjectDefinitionData,
+)
+
+class ClassComponentBuilder<SharedObjectType : Any>(
+    val name: String,
+    @PublishedApi internal val ownerClass: KClass<SharedObjectType>,
+    @PublishedApi internal val ownerType: KType,
+) : ObjectDefinitionBuilder() {
+    var constructor: SyncFunctionComponent? = null
+    @PublishedApi internal val staticSyncFunctions = mutableMapOf<String, SyncFunctionComponent>()
+    @PublishedApi internal val staticAsyncFunctions = mutableMapOf<String, AsyncFunctionComponent>()
+    private val staticAsyncFunctionBuilders = mutableMapOf<String, AsyncFunctionBuilder>()
+
+    fun buildClass(): ClassDefinitionData {
+        val hasOwnerType = ownerClass != Unit::class
+        // a shared object class with events forwards its listeners' first and
+        // last subscriptions to the native object
+        if (hasOwnerType && eventNames.isNotEmpty()) {
+            for ((name, start) in listOf("__expo_onStartListeningToEvent" to true, "__expo_onStopListeningToEvent" to false)) {
+                syncFunctions[name] = SyncFunctionComponent(name, arrayOf(anyTypeOfOwner(), toAnyType<String>())) {
+                    val self = it[0] as expo.modules.kotlin.sharedobjects.SharedObject
+                    if (start) self.onStartListeningToEvent(it[1] as String) else self.onStopListeningToEvent(it[1] as String)
+                }.also { function -> function.enumerable(false) }
+            }
+        }
+        val objectData = buildObject()
+        for (function in objectData.syncFunctions.values + objectData.asyncFunctions.values) {
+            function.ownerType = ownerType
+            function.canTakeOwner = true
+        }
+        for (property in objectData.properties.values) {
+            property.getter?.let { it.ownerType = ownerType; it.canTakeOwner = true }
+            property.setter?.let { it.ownerType = ownerType; it.canTakeOwner = true }
+        }
+        return ClassDefinitionData(
+            name,
+            ownerClass,
+            constructor,
+            staticSyncFunctions.toMap(),
+            staticAsyncFunctions + staticAsyncFunctionBuilders.mapValues { (_, builder) -> builder.build() },
+            objectData,
+        )
+    }
+
+    @PublishedApi internal fun anyTypeOfOwner() = expo.modules.kotlin.types.anyTypeOf(ownerType)
+
+    inline fun <reified T> Property(name: String, crossinline body: (owner: SharedObjectType) -> T): PropertyComponentBuilderWithThis<SharedObjectType> =
+        PropertyComponentBuilderWithThis<SharedObjectType>(ownerType, name).also {
+            it.get(body)
+            properties[name] = it
+        }
+
+    override fun Property(name: String): PropertyComponentBuilderWithThis<SharedObjectType> =
+        PropertyComponentBuilderWithThis<SharedObjectType>(ownerType, name).also { properties[name] = it }
+
+    fun StaticAsyncFunction(name: String) = AsyncFunctionBuilder(name).also { staticAsyncFunctionBuilders[name] = it }
+
+
+    inline fun Constructor(crossinline body: () -> SharedObjectType): SyncFunctionComponent =
+        SyncFunctionComponent("constructor", emptyArray()) { body() }.also { constructor = it }
+
+    inline fun <reified P0> Constructor(crossinline body: (p0: P0) -> SharedObjectType): SyncFunctionComponent =
+        SyncFunctionComponent("constructor", arrayOf(toAnyType<P0>())) { body(it[0] as P0) }.also { constructor = it }
+
+    inline fun <reified P0, reified P1> Constructor(crossinline body: (p0: P0, p1: P1) -> SharedObjectType): SyncFunctionComponent =
+        SyncFunctionComponent("constructor", arrayOf(toAnyType<P0>(), toAnyType<P1>())) { body(it[0] as P0, it[1] as P1) }.also { constructor = it }
+
+    inline fun <reified P0, reified P1, reified P2> Constructor(crossinline body: (p0: P0, p1: P1, p2: P2) -> SharedObjectType): SyncFunctionComponent =
+        SyncFunctionComponent("constructor", arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }.also { constructor = it }
+
+    inline fun <reified P0, reified P1, reified P2, reified P3> Constructor(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> SharedObjectType): SyncFunctionComponent =
+        SyncFunctionComponent("constructor", arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also { constructor = it }
+
+    inline fun <reified P0, reified P1, reified P2, reified P3, reified P4> Constructor(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> SharedObjectType): SyncFunctionComponent =
+        SyncFunctionComponent("constructor", arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also { constructor = it }
+
+    inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> Constructor(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> SharedObjectType): SyncFunctionComponent =
+        SyncFunctionComponent("constructor", arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also { constructor = it }
+
+    inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> Constructor(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> SharedObjectType): SyncFunctionComponent =
+        SyncFunctionComponent("constructor", arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }.also { constructor = it }
+
+    inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> Constructor(crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> SharedObjectType): SyncFunctionComponent =
+        SyncFunctionComponent("constructor", arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>(), toAnyType<P7>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }.also { constructor = it }
+
+    inline fun StaticFunction(name: String, crossinline body: () -> Any?): SyncFunctionComponent =
+        SyncFunctionComponent(name, emptyArray()) { body() }.also { staticSyncFunctions[name] = it }
+
+    inline fun StaticAsyncFunction(name: String, crossinline body: () -> Any?): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, emptyArray()) { body() }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R> StaticFunction(name: String, crossinline body: () -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, emptyArray()) { body() }.also { staticSyncFunctions[name] = it }
+
+    inline fun <R> StaticAsyncFunction(name: String, crossinline body: () -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, emptyArray()) { body() }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0> StaticFunction(name: String, crossinline body: (p0: P0) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>())) { body(it[0] as P0) }.also { staticSyncFunctions[name] = it }
+
+    inline fun <R, reified P0> StaticAsyncFunction(name: String, crossinline body: (p0: P0) -> R): AsyncFunctionComponent =
+        if (P0::class == Promise::class) {
+            AsyncFunctionWithPromiseComponent(name, emptyArray()) { _, promise -> body(promise as P0) }
+        } else {
+            createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>())) { body(it[0] as P0) }
+        }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0> StaticAsyncFunction(name: String, crossinline body: (p0: P0, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>())) { it, promise -> body(it[0] as P0, promise) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1> StaticFunction(name: String, crossinline body: (p0: P0, p1: P1) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>())) { body(it[0] as P0, it[1] as P1) }.also { staticSyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>())) { body(it[0] as P0, it[1] as P1) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>())) { it, promise -> body(it[0] as P0, it[1] as P1, promise) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2> StaticFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }.also { staticSyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>())) { it, promise -> body(it[0] as P0, it[1] as P1, it[2] as P2, promise) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3> StaticFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also { staticSyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>())) { it, promise -> body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, promise) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4> StaticFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also { staticSyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>())) { it, promise -> body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, promise) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> StaticFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also { staticSyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>())) { it, promise -> body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, promise) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> StaticFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }.also { staticSyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>())) { it, promise -> body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, promise) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> StaticFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R): SyncFunctionComponent =
+        SyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>(), toAnyType<P7>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }.also { staticSyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R): AsyncFunctionComponent =
+        createAsyncFunctionComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>(), toAnyType<P7>())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }.also { staticAsyncFunctions[name] = it }
+
+    inline fun <R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> StaticAsyncFunction(name: String, crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, promise: Promise) -> R): AsyncFunctionComponent =
+        AsyncFunctionWithPromiseComponent(name, arrayOf(toAnyType<P0>(), toAnyType<P1>(), toAnyType<P2>(), toAnyType<P3>(), toAnyType<P4>(), toAnyType<P5>(), toAnyType<P6>(), toAnyType<P7>())) { it, promise -> body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7, promise) }.also { staticAsyncFunctions[name] = it }
+}

package/kotlin/ExpoSources/expo/modules/kotlin/exception/CodedException.kt

@@ -0,0 +1,126 @@
+package expo.modules.kotlin.exception
+
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+
+// expo-modules-core's coded errors: the code a promise rejects with, inferred
+// from the class name when none is given
+fun Throwable?.toCodedException(): CodedException = when (this) {
+    null -> UnexpectedException("Unknown error")
+    is CodedException -> this
+    else -> UnexpectedException(this)
+}
+
+open class CodedException(message: String?, cause: Throwable? = null) : Exception(message, cause) {
+    private var providedCode: String? = null
+
+    val code: String
+        get() = providedCode ?: inferCode(this::class)
+
+    constructor(code: String?, message: String?, cause: Throwable?) : this(message = message, cause = cause) {
+        providedCode = code
+    }
+
+    constructor(cause: Throwable) : this(message = cause.message, cause = cause)
+
+    constructor() : this(null, null)
+
+    companion object {
+        // ModuleNotFoundException becomes ERR_MODULE_NOT_FOUND
+        fun inferCode(type: KClass<*>): String {
+            val name = requireNotNull(type.simpleName) { "Cannot infer code name from class name. We don't support anonymous classes." }
+            return "ERR_" + name
+                .replace("(Exception)$".toRegex(), "")
+                .replace("(.)([A-Z])".toRegex(), "$1_$2")
+                .uppercase()
+        }
+    }
+}
+
+inline fun <reified T : CodedException> errorCodeOf(): String = CodedException.inferCode(T::class)
+
+class UnexpectedException(message: String?, cause: Throwable? = null) : CodedException(message = message, cause) {
+    constructor(throwable: Throwable) : this(throwable.toString(), throwable)
+    constructor(message: String) : this(message, null)
+}
+
+internal class InvalidArgsNumberException(received: Int, expected: Int, required: Int = expected) : CodedException(
+    message = if (required < expected) {
+        "Received $received arguments, but $expected was expected and at least $required is required"
+    } else {
+        "Received $received arguments, but $expected was expected"
+    }
+)
+
+internal class NullArgumentException : CodedException(message = "Cannot assigned null to not nullable type.")
+
+internal class MethodNotFoundException : CodedException(message = "Method does not exist.")
+
+open class DecoratedException(message: String, cause: CodedException) : CodedException(
+    cause.code,
+    message = "$message\n→ Caused by: ${cause.message ?: cause}",
+    cause
+)
+
+internal class FunctionCallException(methodName: String, moduleName: String, cause: CodedException) : DecoratedException(
+    message = "Call to function '$moduleName.$methodName' has been rejected.",
+    cause
+)
+
+internal class PropSetException(propName: String, viewType: KClass<*>, cause: CodedException) : DecoratedException(
+    message = "Cannot set prop '$propName' on view '$viewType'",
+    cause
+)
+
+internal class ArgumentCastException(desiredType: String, argIndex: Int, providedType: String, cause: CodedException) : DecoratedException(
+    message = "The ${formatOrdinalNumber(argIndex + 1)} argument cannot be cast to type $desiredType (received $providedType)",
+    cause
+) {
+    companion object {
+        fun formatOrdinalNumber(number: Int) = "$number" + when {
+            (number % 100 in 11..13) -> "th"
+            (number % 10) == 1 -> "st"
+            (number % 10) == 2 -> "nd"
+            (number % 10) == 3 -> "rd"
+            else -> "th"
+        }
+    }
+}
+
+internal class IncompatibleArgTypeException(argumentType: KClass<*>, desiredType: KClass<*>, cause: Throwable? = null) :
+    CodedException("Argument type '$argumentType' is not compatible with expected type '$desiredType'.", cause)
+
+internal class EnumNoSuchValueException(enumType: KClass<*>, enumConstants: List<Enum<*>>, value: Any?) : CodedException(
+    "'$value' is not present in ${enumType.simpleName} enum, it must be one of: ${enumConstants.joinToString(separator = ", ") { "'${it.name}'" }}"
+)
+
+internal class FieldRequiredException(property: String) :
+    CodedException(message = "Value for field '$property' is required, got nil")
+
+internal class FieldCastException(fieldName: String, fieldType: KType, recordType: String, cause: CodedException) : DecoratedException(
+    message = "Cannot cast value for field '$fieldName' ('$fieldType') in record '$recordType'.",
+    cause
+)
+
+inline fun <T> exceptionDecorator(decoratorBlock: (e: CodedException) -> Throwable, block: () -> T): T {
+    try {
+        return block()
+    } catch (e: CodedException) {
+        throw decoratorBlock(e)
+    } catch (e: Throwable) {
+        throw decoratorBlock(UnexpectedException(e))
+    }
+}
+
+class Exceptions {
+    class AppContextLost : CodedException(message = "The app context has been lost")
+    class RuntimeLost : CodedException(message = "The runtime has been lost")
+    class ReactContextLost : CodedException(message = "The react context has been lost")
+    open class ModuleNotFound(type: KClass<*>) : CodedException(message = "$type module not found, make sure that everything is linked correctly")
+    class SimulatorNotSupported : CodedException(message = "This operation is not supported on the simulator")
+    class MissingPermissions(vararg permissions: String) : CodedException(message = "Missing permissions: ${permissions.joinToString(separator = ", ")}")
+    class MissingActivity : CodedException(message = "The current activity is no longer available")
+    class MissingRootView : CodedException(message = "The root view is missing")
+    class IllegalArgument(message: String, cause: Throwable? = null) : CodedException(message, cause)
+    class IllegalStateException(message: String, cause: Throwable? = null) : CodedException(message, cause)
+}