peachsim 0.1.939 → 0.1.1399

package/kotlin/ExpoSources/expo/modules/kotlin/sharedobjects/SharedObjectRegistry.kt

@@ -0,0 +1,57 @@
+package expo.modules.kotlin.sharedobjects
+
+import expo.modules.kotlin.exception.CodedException
+import kotlin.reflect.KClass
+
+value class SharedObjectId(val value: Int)
+
+internal class InvalidSharedObjectIdException : CodedException(
+    message = "Cannot convert provided JavaScriptObject to the SharedObject, because it doesn't contain valid id",
+)
+
+internal class UsingReleasedSharedObjectException : CodedException(
+    message = "Cannot use shared object that was already released",
+)
+
+// the JavaScript class a Class definition exports, by module and name
+internal class SharedObjectClass(val module: String, val name: String)
+
+// the native half of every shared object the process's JavaScript holds.
+// JavaScript keeps its objects by id; this side keeps the natives until
+// JavaScript releases them or collects their objects.
+internal class SharedObjectRegistry {
+    private var currentId = 1
+    private val objects = HashMap<Int, SharedObject>()
+    private val classes = HashMap<KClass<*>, SharedObjectClass>()
+    // events for the runtime to queue: the object, its event and payload
+    var emitter: ((SharedObject, String, List<Any?>) -> Unit)? = null
+
+    fun addClass(type: KClass<*>, exported: SharedObjectClass) {
+        classes[type] = exported
+    }
+
+    fun classOf(native: SharedObject): SharedObjectClass? = classes[native::class]
+
+    fun add(native: SharedObject): SharedObjectId {
+        val id = SharedObjectId(currentId++)
+        native.sharedObjectId = id
+        objects[id.value] = native
+        return id
+    }
+
+    fun delete(id: SharedObjectId) {
+        val native = objects.remove(id.value) ?: return
+        native.sharedObjectId = SharedObjectId(0)
+        native.sharedObjectDidRelease()
+    }
+
+    fun toNativeObject(id: SharedObjectId): SharedObject {
+        objects[id.value]?.let { return it }
+        if (id.value != 0 && id.value < currentId) throw UsingReleasedSharedObjectException()
+        throw InvalidSharedObjectIdException()
+    }
+
+    fun emit(native: SharedObject, event: String, payload: List<Any?>) {
+        emitter?.invoke(native, event, payload)
+    }
+}

package/kotlin/ExpoSources/expo/modules/kotlin/sharedobjects/SharedRef.kt

@@ -0,0 +1,19 @@
+package expo.modules.kotlin.sharedobjects
+
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.runtime.Runtime
+
+open class SharedRef<RefType>(
+    val ref: RefType,
+    runtime: Runtime? = null,
+) : SharedObject(runtime) {
+    constructor(ref: RefType, appContext: AppContext) : this(ref, appContext.runtime)
+
+    open val nativeRefType = "unknown"
+}
+
+@Suppress("UNCHECKED_CAST")
+inline fun <reified RefType> SharedRef<*>.cast(): SharedRef<RefType>? {
+    if (ref is RefType) return this as SharedRef<RefType>
+    return null
+}

package/kotlin/ExpoSources/expo/modules/kotlin/typedarray/ConcreteTypedArrays.kt

@@ -0,0 +1,158 @@
+package expo.modules.kotlin.typedarray
+
+import expo.modules.kotlin.jni.JavaScriptTypedArray
+
+@Suppress("NOTHING_TO_INLINE")
+private inline fun TypedArray.checkIfInRange(index: Int) {
+    if (index !in 0..<length) {
+        throw IndexOutOfBoundsException()
+    }
+}
+
+interface RawTypedArrayHolder {
+    val rawArray: JavaScriptTypedArray
+}
+
+class Int8Array(override val rawArray: JavaScriptTypedArray) :
+    TypedArray by rawArray, GenericTypedArray<Byte>, RawTypedArrayHolder {
+    override operator fun get(index: Int): Byte {
+        checkIfInRange(index)
+        return readByte(index * Byte.SIZE_BYTES)
+    }
+
+    override operator fun set(index: Int, value: Byte) {
+        checkIfInRange(index)
+        writeByte(index * Byte.SIZE_BYTES, value)
+    }
+}
+
+class Int16Array(override val rawArray: JavaScriptTypedArray) :
+    TypedArray by rawArray, GenericTypedArray<Short>, RawTypedArrayHolder {
+    override operator fun get(index: Int): Short {
+        checkIfInRange(index)
+        return read2Byte(index * Short.SIZE_BYTES)
+    }
+
+    override operator fun set(index: Int, value: Short) {
+        checkIfInRange(index)
+        write2Byte(index * Short.SIZE_BYTES, value)
+    }
+}
+
+class Int32Array(override val rawArray: JavaScriptTypedArray) :
+    TypedArray by rawArray, GenericTypedArray<Int>, RawTypedArrayHolder {
+    override operator fun get(index: Int): Int {
+        checkIfInRange(index)
+        return read4Byte(index * Int.SIZE_BYTES)
+    }
+
+    override operator fun set(index: Int, value: Int) {
+        checkIfInRange(index)
+        write4Byte(index * Int.SIZE_BYTES, value)
+    }
+}
+
+class Uint8Array(override val rawArray: JavaScriptTypedArray) :
+    TypedArray by rawArray, GenericTypedArray<UByte>, RawTypedArrayHolder {
+    override operator fun get(index: Int): UByte {
+        checkIfInRange(index)
+        return readByte(index * UByte.SIZE_BYTES).toUByte()
+    }
+
+    override operator fun set(index: Int, value: UByte) {
+        checkIfInRange(index)
+        writeByte(index * UByte.SIZE_BYTES, value.toByte())
+    }
+}
+
+class Uint8ClampedArray(override val rawArray: JavaScriptTypedArray) :
+    TypedArray by rawArray, GenericTypedArray<UByte>, RawTypedArrayHolder {
+    override operator fun get(index: Int): UByte {
+        checkIfInRange(index)
+        return readByte(index * UByte.SIZE_BYTES).toUByte()
+    }
+
+    override operator fun set(index: Int, value: UByte) {
+        checkIfInRange(index)
+        writeByte(index * UByte.SIZE_BYTES, value.toByte())
+    }
+}
+
+class Uint16Array(override val rawArray: JavaScriptTypedArray) :
+    TypedArray by rawArray, GenericTypedArray<UShort>, RawTypedArrayHolder {
+    override operator fun get(index: Int): UShort {
+        checkIfInRange(index)
+        return read2Byte(index * UShort.SIZE_BYTES).toUShort()
+    }
+
+    override operator fun set(index: Int, value: UShort) {
+        checkIfInRange(index)
+        write2Byte(index * UShort.SIZE_BYTES, value.toShort())
+    }
+}
+
+class Uint32Array(override val rawArray: JavaScriptTypedArray) :
+    TypedArray by rawArray, GenericTypedArray<UInt>, RawTypedArrayHolder {
+    override operator fun get(index: Int): UInt {
+        checkIfInRange(index)
+        return read4Byte(index * UInt.SIZE_BYTES).toUInt()
+    }
+
+    override operator fun set(index: Int, value: UInt) {
+        checkIfInRange(index)
+        write4Byte(index * UInt.SIZE_BYTES, value.toInt())
+    }
+}
+
+class Float32Array(override val rawArray: JavaScriptTypedArray) :
+    TypedArray by rawArray, GenericTypedArray<Float>, RawTypedArrayHolder {
+    override operator fun get(index: Int): Float {
+        checkIfInRange(index)
+        return readFloat(index * Float.SIZE_BYTES)
+    }
+
+    override operator fun set(index: Int, value: Float) {
+        checkIfInRange(index)
+        writeFloat(index * Float.SIZE_BYTES, value)
+    }
+}
+
+class Float64Array(override val rawArray: JavaScriptTypedArray) :
+    TypedArray by rawArray, GenericTypedArray<Double>, RawTypedArrayHolder {
+
+    override operator fun get(index: Int): Double {
+        checkIfInRange(index)
+        return readDouble(index * Double.SIZE_BYTES)
+    }
+
+    override operator fun set(index: Int, value: Double) {
+        checkIfInRange(index)
+        writeDouble(index * Double.SIZE_BYTES, value)
+    }
+}
+
+class BigInt64Array(override val rawArray: JavaScriptTypedArray) :
+    TypedArray by rawArray, GenericTypedArray<Long>, RawTypedArrayHolder {
+    override operator fun get(index: Int): Long {
+        checkIfInRange(index)
+        return read8Byte(index * Long.SIZE_BYTES)
+    }
+
+    override operator fun set(index: Int, value: Long) {
+        checkIfInRange(index)
+        write8Byte(index * Long.SIZE_BYTES, value)
+    }
+}
+
+class BigUint64Array(override val rawArray: JavaScriptTypedArray) :
+    TypedArray by rawArray, GenericTypedArray<ULong>, RawTypedArrayHolder {
+    override operator fun get(index: Int): ULong {
+        checkIfInRange(index)
+        return read8Byte(index * ULong.SIZE_BYTES).toULong()
+    }
+
+    override operator fun set(index: Int, value: ULong) {
+        checkIfInRange(index)
+        write8Byte(index * ULong.SIZE_BYTES, value.toLong())
+    }
+}

package/kotlin/ExpoSources/expo/modules/kotlin/typedarray/GenericTypedArray.kt

@@ -0,0 +1,8 @@
+package expo.modules.kotlin.typedarray
+
+interface GenericTypedArray<T> : TypedArray, Iterable<T> {
+    operator fun get(index: Int): T
+    operator fun set(index: Int, value: T)
+
+    override fun iterator(): Iterator<T> = TypedArrayIterator(this)
+}

package/kotlin/ExpoSources/expo/modules/kotlin/typedarray/TypedArray.kt

@@ -0,0 +1,29 @@
+package expo.modules.kotlin.typedarray
+
+import expo.modules.kotlin.jni.TypedArrayKind
+
+// upstream's typed array interface. toDirectBuffer is left out: Kotlin/Wasm
+// has no java.nio.
+interface TypedArray {
+    val kind: TypedArrayKind
+    val length: Int
+    val byteLength: Int
+    val byteOffset: Int
+
+    fun read(buffer: ByteArray, position: Int, size: Int)
+    fun write(buffer: ByteArray, position: Int, size: Int)
+
+    fun readByte(position: Int): Byte
+    fun read2Byte(position: Int): Short
+    fun read4Byte(position: Int): Int
+    fun read8Byte(position: Int): Long
+    fun readFloat(position: Int): Float
+    fun readDouble(position: Int): Double
+
+    fun writeByte(position: Int, value: Byte)
+    fun write2Byte(position: Int, value: Short)
+    fun write4Byte(position: Int, value: Int)
+    fun write8Byte(position: Int, value: Long)
+    fun writeFloat(position: Int, value: Float)
+    fun writeDouble(position: Int, value: Double)
+}

package/kotlin/ExpoSources/expo/modules/kotlin/typedarray/TypedArrayIterator.kt

@@ -0,0 +1,9 @@
+package expo.modules.kotlin.typedarray
+
+class TypedArrayIterator<T>(private val typedArray: GenericTypedArray<T>) : Iterator<T> {
+    private var current = 0
+
+    override fun hasNext(): Boolean = current < typedArray.length
+
+    override fun next(): T = typedArray[current++]
+}

package/kotlin/ExpoSources/expo/modules/kotlin/types/AnyType.kt

@@ -0,0 +1,155 @@
+package expo.modules.kotlin.types
+
+import dev.peach.expo.PeachExpoRuntime
+import dev.peach.expo.PeachExpoTypes
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.NullArgumentException
+import expo.modules.kotlin.exception.UnexpectedException
+import expo.modules.kotlin.jni.JavaScriptTypedArray
+import expo.modules.kotlin.sharedobjects.SharedObjectId
+import expo.modules.kotlin.sharedobjects.SharedRef
+import expo.modules.kotlin.typedarray.BigInt64Array
+import expo.modules.kotlin.typedarray.BigUint64Array
+import expo.modules.kotlin.typedarray.Float32Array
+import expo.modules.kotlin.typedarray.Float64Array
+import expo.modules.kotlin.typedarray.Int16Array
+import expo.modules.kotlin.typedarray.Int32Array
+import expo.modules.kotlin.typedarray.Int8Array
+import expo.modules.kotlin.typedarray.TypedArray
+import expo.modules.kotlin.typedarray.Uint16Array
+import expo.modules.kotlin.typedarray.Uint32Array
+import expo.modules.kotlin.typedarray.Uint8Array
+import expo.modules.kotlin.typedarray.Uint8ClampedArray
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+// an argument's desired type, as toArgsArray reads it from the reified DSL.
+// JavaScript values arrive as JSI hands them to the converters: numbers as
+// Double, objects as String-keyed maps, arrays as lists, undefined as null,
+// typed arrays as JavaScriptTypedArray and shared objects as their id.
+class AnyType(val kType: KType) {
+    val isNullable: Boolean get() = kType.isMarkedNullable
+
+    fun convert(value: Any?): Any? = convertValue(kType, value)
+
+    override fun toString(): String = kType.toString()
+}
+
+class TypeCastException(message: String) : CodedException(message = message) {
+    constructor(value: Any?, type: KType) : this("Cannot convert '${value}' to the Kotlin type '$type'")
+}
+
+@PublishedApi
+internal fun anyTypeOf(type: KType): AnyType = AnyType(type)
+
+inline fun <reified T> toAnyType(): AnyType = anyTypeOf(typeOf<T>())
+
+private fun number(value: Any?, type: KType): Double = value as? Double ?: throw ClassCastException("Cannot convert '$value' to '$type'")
+
+private fun argument(type: KType, index: Int): KType =
+    type.arguments.getOrNull(index)?.type ?: typeOf<Any?>()
+
+private fun convertValue(type: KType, raw: Any?): Any? {
+    if (raw == null) {
+        if (type.isMarkedNullable || type.classifier == Unit::class) return null
+        throw NullArgumentException()
+    }
+    val value = if (raw is SharedObjectId) PeachExpoRuntime.sharedObject(raw) else raw
+    val classifier = type.classifier as? KClass<*> ?: return value
+    return when (classifier) {
+        Any::class -> value
+        String::class -> value as? String ?: throw ClassCastException("Cannot convert '$value' to '$type'")
+        Boolean::class -> value as? Boolean ?: throw ClassCastException("Cannot convert '$value' to '$type'")
+        Double::class -> number(value, type)
+        Float::class -> number(value, type).toFloat()
+        Int::class -> number(value, type).toInt()
+        Long::class -> number(value, type).toLong()
+        Short::class -> number(value, type).toInt().toShort()
+        Byte::class -> number(value, type).toInt().toByte()
+        Number::class -> number(value, type)
+        Unit::class -> Unit
+        List::class, MutableList::class, ArrayList::class, Collection::class, Iterable::class ->
+            list(value, type).mapTo(ArrayList()) { convertValue(argument(type, 0), it) }
+        Set::class, MutableSet::class, HashSet::class, LinkedHashSet::class ->
+            list(value, type).mapTo(LinkedHashSet()) { convertValue(argument(type, 0), it) }
+        Map::class, MutableMap::class, HashMap::class, LinkedHashMap::class -> {
+            val map = value as? Map<*, *> ?: throw TypeCastException(value, type)
+            map.entries.associateTo(LinkedHashMap()) { (key, item) -> key to convertValue(argument(type, 1), item) }
+        }
+        Pair::class -> {
+            val items = list(value, type)
+            if (items.size != 2) throw TypeCastException(value, type)
+            Pair(convertValue(argument(type, 0), items[0]), convertValue(argument(type, 1), items[1]))
+        }
+        IntArray::class -> list(value, type).map { number(it, type).toInt() }.toIntArray()
+        LongArray::class -> list(value, type).map { number(it, type).toLong() }.toLongArray()
+        DoubleArray::class -> list(value, type).map { number(it, type) }.toDoubleArray()
+        FloatArray::class -> list(value, type).map { number(it, type).toFloat() }.toFloatArray()
+        BooleanArray::class -> list(value, type).map { it as? Boolean ?: throw TypeCastException(it, type) }.toBooleanArray()
+        // the single ByteArray frontend converter copies raw view bytes without a kind check
+        ByteArray::class -> (value as? JavaScriptTypedArray)?.bytes?.copyOf()
+            ?: throw TypeCastException(value, type)
+        TypedArray::class -> typedArray(value, type)
+        Int8Array::class -> Int8Array(typedArray(value, type))
+        Int16Array::class -> Int16Array(typedArray(value, type))
+        Int32Array::class -> Int32Array(typedArray(value, type))
+        Uint8Array::class -> Uint8Array(typedArray(value, type))
+        Uint8ClampedArray::class -> Uint8ClampedArray(typedArray(value, type))
+        Uint16Array::class -> Uint16Array(typedArray(value, type))
+        Uint32Array::class -> Uint32Array(typedArray(value, type))
+        Float32Array::class -> Float32Array(typedArray(value, type))
+        Float64Array::class -> Float64Array(typedArray(value, type))
+        BigInt64Array::class -> BigInt64Array(typedArray(value, type))
+        BigUint64Array::class -> BigUint64Array(typedArray(value, type))
+        SharedRef::class -> sharedRef(value, type)
+        Either::class, EitherOfThree::class, EitherOfFour::class -> either(classifier, type, value)
+        // records and enums convert through the host's generated registrations
+        else -> {
+            val converted = PeachExpoTypes.convert(classifier, value)
+            if (converted !== PeachExpoTypes.Unconverted) converted
+            else if (classifier.isInstance(value)) value
+            else throw ClassCastException("Cannot convert '$value' to '$type'")
+        }
+    }
+}
+
+// upstream converts to the first type that accepts the value and defers the rest
+private fun either(classifier: KClass<*>, type: KType, value: Any): Any {
+    val types = type.arguments.map { it.type ?: typeOf<Any>() }
+    var converted = false
+    val deferred: MutableList<DeferredValue> = types.mapTo(ArrayList()) { item ->
+        if (converted) {
+            UnconvertedValue(value) { convertValue(item, it) }
+        } else {
+            try {
+                ConvertedValue(convertValue(item, value)!!).also { converted = true }
+            } catch (_: Throwable) {
+                IncompatibleValue
+            }
+        }
+    }
+    if (!converted) throw UnexpectedException("Cannot cast '$value' to 'Either<${types.joinToString(separator = ", ")}>'")
+    return when (classifier) {
+        EitherOfFour::class -> EitherOfFour<Any, Any, Any, Any>(value, deferred, types)
+        EitherOfThree::class -> EitherOfThree<Any, Any, Any>(value, deferred, types)
+        else -> Either<Any, Any>(value, deferred, types)
+    }
+}
+
+private fun list(value: Any, type: KType): List<*> = value as? List<*> ?: throw TypeCastException(value, type)
+
+private fun typedArray(value: Any, type: KType): JavaScriptTypedArray =
+    value as? JavaScriptTypedArray ?: throw TypeCastException(value, type)
+
+internal class IncorrectRefTypeException(desiredType: KType, receivedClass: KClass<*>) : CodedException(
+    message = "Cannot convert received '$receivedClass' to the '$desiredType', because of the inner ref type mismatch",
+)
+
+// SharedRef<T> also checks its ref against T, unless T is a star
+private fun sharedRef(value: Any, type: KType): SharedRef<*> {
+    val ref = value as? SharedRef<*> ?: throw TypeCastException(value, type)
+    val inner = type.arguments.firstOrNull()?.type?.classifier as? KClass<*> ?: return ref
+    if (inner != Any::class && !inner.isInstance(ref.ref)) throw IncorrectRefTypeException(type, ref::class)
+    return ref
+}

package/kotlin/ExpoSources/expo/modules/kotlin/types/Either.kt

@@ -0,0 +1,91 @@
+@file:Suppress("UNCHECKED_CAST")
+
+package expo.modules.kotlin.types
+
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+
+sealed class DeferredValue
+
+data object IncompatibleValue : DeferredValue()
+
+class UnconvertedValue(
+    private val unconvertedValue: Any,
+    private val convert: (Any) -> Any?,
+) : DeferredValue() {
+    private var convertedValue: Any? = null
+
+    fun getConvertedValue(): Any {
+        if (convertedValue == null) convertedValue = convert(unconvertedValue)
+        return convertedValue!!
+    }
+}
+
+data class ConvertedValue(val convertedValue: Any) : DeferredValue()
+
+inline fun <reified T : Any> toKClass(): KClass<T> = T::class
+
+open class Either<FirstType : Any, SecondType : Any>(
+    private val bareValue: Any,
+    private val deferredValue: MutableList<DeferredValue>,
+    private val types: List<KType>,
+) {
+    internal fun `is`(index: Int): Boolean = when (val value = deferredValue[index]) {
+        is ConvertedValue -> true
+        IncompatibleValue -> false
+        is UnconvertedValue -> try {
+            deferredValue[index] = ConvertedValue(value.getConvertedValue())
+            true
+        } catch (_: Throwable) {
+            deferredValue[index] = IncompatibleValue
+            false
+        }
+    }
+
+    internal fun get(index: Int): Any = when (val value = deferredValue[index]) {
+        is ConvertedValue -> value.convertedValue
+        IncompatibleValue -> throw TypeCastException("Cannot cast '$bareValue' to '${types[index]}'")
+        is UnconvertedValue -> try {
+            value.getConvertedValue().also { deferredValue[index] = ConvertedValue(it) }
+        } catch (e: Throwable) {
+            deferredValue[index] = IncompatibleValue
+            throw TypeCastException("Cannot cast '$bareValue' to '${types[index]}' - ${e.message}")
+        }
+    }
+
+    fun `is`(@Suppress("UNUSED_PARAMETER") type: KClass<FirstType>): Boolean = `is`(0)
+
+    fun `is`(@Suppress("UNUSED_PARAMETER") type: KClass<SecondType>): Boolean = `is`(1)
+
+    fun get(@Suppress("UNUSED_PARAMETER") type: KClass<FirstType>): FirstType = get(0) as FirstType
+
+    fun get(@Suppress("UNUSED_PARAMETER") type: KClass<SecondType>): SecondType = get(1) as SecondType
+
+    fun first(): FirstType = get(0) as FirstType
+
+    fun second(): SecondType = get(1) as SecondType
+}
+
+open class EitherOfThree<FirstType : Any, SecondType : Any, ThirdType : Any>(
+    bareValue: Any,
+    deferredValue: MutableList<DeferredValue>,
+    types: List<KType>,
+) : Either<FirstType, SecondType>(bareValue, deferredValue, types) {
+    fun `is`(@Suppress("UNUSED_PARAMETER") type: KClass<ThirdType>): Boolean = `is`(2)
+
+    fun get(@Suppress("UNUSED_PARAMETER") type: KClass<ThirdType>) = get(2) as ThirdType
+
+    fun third(): ThirdType = get(2) as ThirdType
+}
+
+class EitherOfFour<FirstType : Any, SecondType : Any, ThirdType : Any, FourthType : Any>(
+    bareValue: Any,
+    deferredValue: MutableList<DeferredValue>,
+    types: List<KType>,
+) : EitherOfThree<FirstType, SecondType, ThirdType>(bareValue, deferredValue, types) {
+    fun `is`(@Suppress("UNUSED_PARAMETER") type: KClass<FourthType>): Boolean = `is`(3)
+
+    fun get(@Suppress("UNUSED_PARAMETER") type: KClass<FourthType>): FourthType = get(3) as FourthType
+
+    fun fourth(): FourthType = get(3) as FourthType
+}

package/kotlin/ExpoSources/expo/modules/kotlin/types/Enumerable.kt

@@ -0,0 +1,6 @@
+package expo.modules.kotlin.types
+
+/**
+ * An interface that allows converting raw values to enum cases.
+ */
+interface Enumerable

package/kotlin/ExpoSources/expo/modules/kotlin/viewevent/ViewEvent.kt

@@ -0,0 +1,54 @@
+package expo.modules.kotlin.viewevent
+
+import android.util.Log
+import expo.modules.kotlin.views.ExpoView
+import kotlin.reflect.KProperty
+
+typealias CoalescingKey<T> = (event: T) -> Short
+
+fun interface ViewEventCallback<T> {
+    operator fun invoke(arg: T)
+}
+
+// an event a view sends to its callback prop. a body that is not an object
+// reaches JavaScript as { payload }, as convertEventBody wraps it
+open class ViewEvent<T>(
+    private val name: String,
+    private val view: ExpoView,
+    private val coalescingKey: CoalescingKey<T>?,
+) : ViewEventCallback<T> {
+    private var isValidated = false
+
+    override operator fun invoke(arg: T) {
+        if (!isValidated) {
+            if (name !in view.callbacks) {
+                Log.w("ExpoModulesCore", "⚠️ Event $name wasn't exported from ${view::class}")
+                return
+            }
+            isValidated = true
+        }
+        val body: Any? = when (arg) {
+            null, is Unit -> null
+            is Map<*, *> -> arg
+            else -> mapOf("payload" to arg)
+        }
+        view.emitter?.invoke(name, body)
+    }
+}
+
+class ViewEventDelegate<T>(private val view: ExpoView, private val coalescingKey: CoalescingKey<T>?) {
+    fun getValue(property: KProperty<*>): ViewEventCallback<T> = ViewEvent(property.name, view, coalescingKey)
+
+    operator fun getValue(thisRef: ExpoView, property: KProperty<*>): ViewEventCallback<T> = getValue(property)
+}
+
+@Suppress("NOTHING_TO_INLINE")
+inline operator fun <T> ViewEventDelegate<T>.getValue(thisObj: Any?, property: KProperty<*>): ViewEventCallback<T> = getValue(property)
+
+@Suppress("FunctionName")
+inline fun <reified T> ExpoView.EventDispatcher(noinline coalescingKey: CoalescingKey<T>? = null): ViewEventDelegate<T> =
+    ViewEventDelegate(this, coalescingKey)
+
+@Suppress("FunctionName")
+fun ExpoView.EventDispatcher(coalescingKey: CoalescingKey<Map<String, Any>>? = null): ViewEventDelegate<Map<String, Any>> =
+    ViewEventDelegate(this, coalescingKey)

package/kotlin/ExpoSources/expo/modules/kotlin/views/ExpoView.kt

@@ -0,0 +1,23 @@
+package expo.modules.kotlin.views
+
+import android.content.Context
+import android.widget.LinearLayout
+import android.graphics.Canvas
+import expo.modules.kotlin.AppContext
+
+// upstream's native view root. both canvas-backed and compose Expo views
+// share the Android view lifecycle and exported props/events.
+abstract class ExpoView(context: Context, val appContext: AppContext) : LinearLayout(context) {
+    open val shouldUseAndroidLayout: Boolean = false
+
+    override fun dispatchDraw(canvas: Canvas) {
+        val checkpoint = canvas.save()
+        canvas.clipRect(paddingLeft, paddingTop, width - paddingRight, height - paddingBottom)
+        super.dispatchDraw(canvas)
+        canvas.restoreToCount(checkpoint)
+    }
+
+    // the runtime's sink for this view's events, set when the view is created
+    internal var emitter: ((name: String, body: Any?) -> Unit)? = null
+    internal var callbacks: List<String> = emptyList()
+}