expo-modules-core 0.4.9 → 0.6.2

package/android/src/main/java/expo/modules/kotlin/ExpoModulesHelper.kt

@@ -0,0 +1,18 @@
+package expo.modules.kotlin
+
+import android.util.Log
+
+class ExpoModulesHelper {
+  companion object {
+    @Suppress("unchecked_cast")
+    val modulesProvider by lazy {
+      try {
+        val expoModules = Class.forName("expo.modules.ExpoModulesPackageList")
+        expoModules.newInstance() as ModulesProvider
+      } catch (e: Exception) {
+        Log.e("ExpoModulesHelper", "Couldn't get expo modules list.", e)
+        null
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/KPromiseWrapper.kt

@@ -0,0 +1,24 @@
+package expo.modules.kotlin
+
+import android.os.Bundle
+import com.facebook.react.bridge.Arguments
+
+class KPromiseWrapper(
+  private val bridgePromise: com.facebook.react.bridge.Promise
+) : Promise {
+
+  override fun resolve(value: Any?) {
+    bridgePromise.resolve(
+      when (value) {
+        is Unit -> null
+        is Bundle -> Arguments.fromBundle(value as Bundle?)
+        is List<*> -> Arguments.fromList(value as List<*>?)
+        else -> value
+      }
+    )
+  }
+
+  override fun reject(code: String, message: String?, cause: Throwable?) {
+    bridgePromise.reject(code, message, cause)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/KotlinInteropModuleRegistry.kt

@@ -0,0 +1,98 @@
+package expo.modules.kotlin
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.uimanager.ViewManager
+import expo.modules.kotlin.views.GroupViewManagerWrapper
+import expo.modules.kotlin.views.SimpleViewManagerWrapper
+import expo.modules.kotlin.views.ViewManagerWrapperDelegate
+import expo.modules.kotlin.views.ViewWrapperDelegateHolder
+import java.lang.ref.WeakReference
+
+private typealias ModuleName = String
+private typealias ModuleConstants = Map<String, Any?>
+private typealias ModuleMethodInfo = Map<String, Any?>
+
+class KotlinInteropModuleRegistry(
+  modulesProvider: ModulesProvider,
+  legacyModuleRegistry: expo.modules.core.ModuleRegistry,
+  reactContext: WeakReference<ReactApplicationContext>
+) {
+  private val appContext = AppContext(modulesProvider, legacyModuleRegistry, reactContext)
+
+  private val registry: ModuleRegistry
+    get() = appContext.registry
+
+  fun hasModule(name: String): Boolean = registry.hasModule(name)
+
+  fun callMethod(moduleName: String, method: String, arguments: ReadableArray, promise: Promise) {
+    registry
+      .getModuleHolder(moduleName)
+      ?.call(method, arguments, promise)
+  }
+
+  fun exportedModulesConstants(): Map<ModuleName, ModuleConstants> {
+    return registry
+      .map { holder ->
+        holder.name to holder.definition.constantsProvider()
+      }
+      .toMap()
+  }
+
+  fun exportMethods(exportKey: (String, List<ModuleMethodInfo>) -> Unit = { _, _ -> }): Map<ModuleName, List<ModuleMethodInfo>> {
+    return registry
+      .map { holder ->
+        val methodsInfo = holder.definition.methods.map { (name, method) ->
+          mapOf(
+            "name" to name,
+            "argumentsCount" to method.argsCount
+          )
+        }
+        exportKey(holder.name, methodsInfo)
+        holder.name to methodsInfo
+      }
+      .toMap()
+  }
+
+  fun exportViewManagers(): List<ViewManager<*, *>> {
+    return registry
+      .filter { it.definition.viewManagerDefinition != null }
+      .map {
+        val wrapperDelegate = ViewManagerWrapperDelegate(it)
+        when (it.definition.viewManagerDefinition!!.getViewManagerType()) {
+          expo.modules.core.ViewManager.ViewManagerType.SIMPLE -> SimpleViewManagerWrapper(wrapperDelegate)
+          expo.modules.core.ViewManager.ViewManagerType.GROUP -> GroupViewManagerWrapper(wrapperDelegate)
+        }
+      }
+  }
+
+  fun extractViewManagersDelegateHolders(viewManagers: List<ViewManager<*, *>>): List<ViewWrapperDelegateHolder> =
+    viewManagers.filterIsInstance<ViewWrapperDelegateHolder>()
+
+  /**
+   * Since React Native v0.55, {@link com.facebook.react.ReactPackage#createViewManagers(ReactApplicationContext)}
+   * gets called only once per lifetime of {@link com.facebook.react.ReactInstanceManager}.
+   * However, in our new architecture, users can make a bind between ViewManager and module
+   * (for instance, they can use `this` in prop definition). This will lead to bugs, cause
+   * the instance that was bound with the prop method won't be the same as the instance returned by module registry.
+   * To fix that we need to update all modules holder in exported view managers.
+   */
+  fun updateModuleHoldersInViewManagers(viewWrapperHolders: List<ViewWrapperDelegateHolder>) {
+    viewWrapperHolders
+      .map { it.viewWrapperDelegate }
+      .forEach { holderWrapper ->
+        holderWrapper.moduleHolder = requireNotNull(registry.getModuleHolder(holderWrapper.moduleHolder.name)) {
+          "Cannot update the module holder for ${holderWrapper.moduleHolder.name}."
+        }
+      }
+  }
+
+  fun exportedViewManagersNames(): List<String> =
+    registry
+      .filter { it.definition.viewManagerDefinition != null }
+      .map { it.definition.name }
+
+  fun onDestroy() {
+    appContext.onDestroy()
+  }
+}

package/android/src/main/java/expo/modules/kotlin/ModuleHolder.kt

@@ -0,0 +1,41 @@
+package expo.modules.kotlin
+
+import com.facebook.react.bridge.ReadableArray
+import expo.modules.core.utilities.ifNull
+import expo.modules.kotlin.events.BasicEventListener
+import expo.modules.kotlin.events.EventListenerWithPayload
+import expo.modules.kotlin.events.EventListenerWithSenderAndPayload
+import expo.modules.kotlin.events.EventName
+import expo.modules.kotlin.exception.MethodNotFoundException
+import expo.modules.kotlin.modules.Module
+
+class ModuleHolder(val module: Module) {
+  val definition = module.definition()
+  val name get() = definition.name
+
+  fun call(methodName: String, args: ReadableArray, promise: Promise) {
+    val method = definition.methods[methodName].ifNull {
+      promise.reject(MethodNotFoundException(methodName, definition.name))
+      return
+    }
+
+    method.call(args, promise)
+  }
+
+  fun post(eventName: EventName) {
+    val listener = definition.eventListeners[eventName] ?: return
+    (listener as? BasicEventListener)?.call()
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  fun <Payload> post(eventName: EventName, payload: Payload) {
+    val listener = definition.eventListeners[eventName] ?: return
+    (listener as? EventListenerWithPayload<Payload>)?.call(payload)
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  fun <Sender, Payload> post(eventName: EventName, sender: Sender, payload: Payload) {
+    val listener = definition.eventListeners[eventName] ?: return
+    (listener as? EventListenerWithSenderAndPayload<Sender, Payload>)?.call(sender, payload)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/ModuleRegistry.kt

@@ -0,0 +1,56 @@
+package expo.modules.kotlin
+
+import expo.modules.kotlin.events.EventName
+import expo.modules.kotlin.modules.Module
+import java.lang.ref.WeakReference
+
+class ModuleRegistry(
+  private val appContext: WeakReference<AppContext>
+) : Iterable<ModuleHolder> {
+  private val registry = mutableMapOf<String, ModuleHolder>()
+
+  fun register(module: Module) {
+    val holder = ModuleHolder(module)
+    module._appContext = requireNotNull(appContext.get()) { "Cannot create a module for invalid app context." }
+    holder.post(EventName.MODULE_CREATE)
+    registry[holder.name] = holder
+  }
+
+  fun register(provider: ModulesProvider) = apply {
+    provider.getModulesList().forEach { type ->
+      val module = type.newInstance()
+      register(module)
+    }
+  }
+
+  fun hasModule(name: String): Boolean = registry.containsKey(name)
+
+  fun getModule(name: String): Module? = registry[name]?.module
+
+  fun getModuleHolder(name: String): ModuleHolder? = registry[name]
+
+  fun getModuleHolder(module: Module): ModuleHolder? =
+    registry.values.find { it.module === module }
+
+  fun post(eventName: EventName) {
+    forEach {
+      it.post(eventName)
+    }
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  fun <Sender> post(eventName: EventName, sender: Sender) {
+    forEach {
+      it.post(eventName, sender)
+    }
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  fun <Sender, Payload> post(eventName: EventName, sender: Sender, payload: Payload) {
+    forEach {
+      it.post(eventName, sender, payload)
+    }
+  }
+
+  override fun iterator(): Iterator<ModuleHolder> = registry.values.iterator()
+}

package/android/src/main/java/expo/modules/kotlin/ModulesProvider.kt

@@ -0,0 +1,7 @@
+package expo.modules.kotlin
+
+import expo.modules.kotlin.modules.Module
+
+interface ModulesProvider {
+  fun getModulesList(): List<Class<out Module>>
+}

package/android/src/main/java/expo/modules/kotlin/Promise.kt

@@ -0,0 +1,13 @@
+package expo.modules.kotlin
+
+import expo.modules.kotlin.exception.CodedException
+
+interface Promise {
+  fun resolve(value: Any?)
+
+  fun reject(code: String, message: String?, cause: Throwable?)
+
+  fun reject(exception: CodedException) {
+    reject(exception.code, exception.message, exception.cause)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/ReactLifecycleDelegate.kt

@@ -0,0 +1,39 @@
+package expo.modules.kotlin
+
+import android.app.Activity
+import android.content.Intent
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.LifecycleEventListener
+import java.lang.ref.WeakReference
+
+/**
+ * We had to extract this from AppContext, because otherwise, we can't access AppContext
+ * in a package that doesn't depend on the React Native directly.
+ * Due to:
+ * Cannot access 'com.facebook.react.bridge.LifecycleEventListener'
+ * which is a supertype of 'expo.modules.kotlin.AppContext'.
+ * Check your module classpath for missing or conflicting dependencies
+ */
+class ReactLifecycleDelegate(appContext: AppContext) : LifecycleEventListener, ActivityEventListener {
+  private val appContextHolder = WeakReference(appContext)
+
+  override fun onHostResume() {
+    appContextHolder.get()?.onHostResume()
+  }
+
+  override fun onHostPause() {
+    appContextHolder.get()?.onHostPause()
+  }
+
+  override fun onHostDestroy() {
+    appContextHolder.get()?.onHostDestroy()
+  }
+
+  override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+    appContextHolder.get()?.onActivityResult(activity, requestCode, resultCode, data)
+  }
+
+  override fun onNewIntent(intent: Intent?) {
+    appContextHolder.get()?.onNewIntent(intent)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/ReadableArrayIterator.kt

@@ -0,0 +1,14 @@
+package expo.modules.kotlin
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableArray
+
+class ReadableArrayIterator(private val array: ReadableArray) : Iterator<Dynamic> {
+  var current = 0
+
+  override fun hasNext(): Boolean = current < array.size()
+
+  override fun next(): Dynamic = array.getDynamic(current++)
+}
+
+fun ReadableArray.iterator(): ReadableArrayIterator = ReadableArrayIterator(this)

package/android/src/main/java/expo/modules/kotlin/ReadableTypeExtensions.kt

@@ -0,0 +1,18 @@
+package expo.modules.kotlin
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import kotlin.reflect.KType
+import kotlin.reflect.full.createType
+
+fun ReadableType.toKType(): KType {
+  return when (this) {
+    ReadableType.Null -> Any::class.createType(nullable = true)
+    ReadableType.Boolean -> Boolean::class.createType()
+    ReadableType.Number -> Number::class.createType()
+    ReadableType.String -> String::class.createType()
+    ReadableType.Map -> ReadableMap::class.createType()
+    ReadableType.Array -> ReadableArray::class.createType()
+  }
+}

package/android/src/main/java/expo/modules/kotlin/allocators/ObjectConstructor.kt

@@ -0,0 +1,5 @@
+package expo.modules.kotlin.allocators
+
+fun interface ObjectConstructor<T> {
+  fun construct(): T
+}

package/android/src/main/java/expo/modules/kotlin/allocators/ObjectConstructorFactory.kt

@@ -0,0 +1,31 @@
+package expo.modules.kotlin.allocators
+
+/**
+ * This class was created based on https://github.com/google/gson/blob/master/gson/src/main/java/com/google/gson/internal/ConstructorConstructor.java.
+ */
+class ObjectConstructorFactory {
+  fun <T> get(clazz: Class<T>): ObjectConstructor<T> =
+    tryToUseDefaultConstructor(clazz) ?: useUnsafeAllocator(clazz)
+
+  private fun <T> tryToUseDefaultConstructor(clazz: Class<T>): ObjectConstructor<T>? {
+    return try {
+      val ctor = clazz.getDeclaredConstructor()
+      if (!ctor.isAccessible) {
+        ctor.isAccessible = true
+      }
+
+      ObjectConstructor {
+        ctor.newInstance() as T
+      }
+    } catch (e: NoSuchMethodException) {
+      null
+    }
+  }
+
+  private fun <T> useUnsafeAllocator(clazz: Class<T>): ObjectConstructor<T> {
+    val allocator = UnsafeAllocator.createAllocator(clazz)
+    return ObjectConstructor {
+      allocator.newInstance()
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/allocators/UnsafeAllocator.kt

@@ -0,0 +1,49 @@
+package expo.modules.kotlin.allocators
+
+import android.annotation.SuppressLint
+import java.io.ObjectStreamClass
+import kotlin.jvm.Throws
+
+/**
+ * Base on https://github.com/google/gson/blob/master/gson/src/main/java/com/google/gson/internal/UnsafeAllocator.java.
+ */
+fun interface UnsafeAllocator<T> {
+  @Throws(Exception::class)
+  fun newInstance(): T
+
+  companion object {
+    @SuppressLint("DiscouragedPrivateApi")
+    @Suppress("UNCHECKED_CAST")
+    fun <T> createAllocator(clazz: Class<T>): UnsafeAllocator<T> {
+      // try DalvikVM
+      try {
+        val getConstructorId = ObjectStreamClass::class.java.getDeclaredMethod("getConstructorId", Class::class.java)
+        getConstructorId.isAccessible = true
+        val constructorId = getConstructorId.invoke(null, Object::class.java) as Int
+        val newInstance = ObjectStreamClass::class.java.getDeclaredMethod("newInstance", Class::class.java, Int::class.java)
+        newInstance.isAccessible = true
+        return UnsafeAllocator {
+          newInstance.invoke(null, clazz, constructorId) as T
+        }
+      } catch (_: Throwable) {
+      }
+
+      // try JVM (for unit tests)
+      try {
+        val unsafeClass = Class.forName("sun.misc.Unsafe")
+        val theUnsafe = unsafeClass.getDeclaredField("theUnsafe")
+        theUnsafe.isAccessible = true
+        val unsafeObj = theUnsafe.get(null)
+        val allocateInstance = unsafeClass.getMethod("allocateInstance", Class::class.java)
+        return UnsafeAllocator {
+          allocateInstance.invoke(unsafeObj, clazz) as T
+        }
+      } catch (_: Throwable) {
+      }
+
+      return UnsafeAllocator {
+        throw IllegalArgumentException("Cannot allocate $clazz")
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/events/EventListener.kt

@@ -0,0 +1,39 @@
+package expo.modules.kotlin.events
+
+sealed class EventListener(val eventName: EventName)
+
+/**
+ * Listener for events without sender and payload.
+ */
+class BasicEventListener(
+  eventName: EventName,
+  val body: () -> Unit
+) : EventListener(eventName) {
+  fun call() {
+    body()
+  }
+}
+
+/**
+ * Listener for events with payload.
+ */
+class EventListenerWithPayload<Payload>(
+  eventName: EventName,
+  val body: (Payload) -> Unit
+) : EventListener(eventName) {
+  fun call(sender: Payload) {
+    body(sender)
+  }
+}
+
+/**
+ * Listener for events that specify sender and payload.
+ */
+class EventListenerWithSenderAndPayload<Sender, Payload>(
+  eventName: EventName,
+  val body: (Sender, Payload) -> Unit
+) : EventListener(eventName) {
+  fun call(sender: Sender, payload: Payload) {
+    body(sender, payload)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/events/EventName.kt

@@ -0,0 +1,31 @@
+package expo.modules.kotlin.events
+
+enum class EventName {
+  MODULE_CREATE,
+  MODULE_DESTROY,
+
+  /**
+   * Called when the host activity receives a resume event (e.g. Activity.onResume)
+   */
+  ACTIVITY_ENTERS_FOREGROUND,
+
+  /**
+   * Called when host activity receives pause event (e.g. Activity.onPause)
+   */
+  ACTIVITY_ENTERS_BACKGROUND,
+
+  /**
+   * Called when host activity receives destroy event (e.g. Activity.onDestroy)
+   */
+  ACTIVITY_DESTROYS,
+
+  /**
+   * Called when a new intent is passed to the activity
+   */
+  ON_NEW_INTENT,
+
+  /**
+   * Called when other activity returns
+   */
+  ON_ACTIVITY_RESULT
+}

package/android/src/main/java/expo/modules/kotlin/events/EventsDefinition.kt

@@ -0,0 +1,3 @@
+package expo.modules.kotlin.events
+
+class EventsDefinition(val names: Array<out String>)

package/android/src/main/java/expo/modules/kotlin/events/KEventEmitterWrapper.kt

@@ -0,0 +1,26 @@
+package expo.modules.kotlin.events
+
+import android.os.Bundle
+import expo.modules.core.interfaces.services.EventEmitter
+import expo.modules.kotlin.ModuleHolder
+
+/**
+ * In Swift, we check if the event is supported. Otherwise, we can't send such event through the bridge.
+ * However, in Kotlin this is unnecessary, but to make our API consistent, we added similar check.
+ * But because of that, we had to create a wrapper for EventEmitter.
+ */
+class KEventEmitterWrapper(
+  private val moduleHolder: ModuleHolder,
+  private val legacyEventEmitter: EventEmitter
+) : EventEmitter by legacyEventEmitter {
+  override fun emit(eventName: String, eventBody: Bundle?) {
+    require(
+      moduleHolder
+        .definition
+        .eventsDefinition
+        ?.names
+        ?.contains(eventName) == true
+    ) { "Unsupported event: $eventName." }
+    legacyEventEmitter.emit(eventName, eventBody)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/events/OnActivityResultPayload.kt

@@ -0,0 +1,8 @@
+package expo.modules.kotlin.events
+
+import android.content.Intent
+
+/**
+ * Payload for the `onActivityResult` event.
+ */
+data class OnActivityResultPayload(val requestCode: Int, val resultCode: Int, val data: Intent?)

package/android/src/main/java/expo/modules/kotlin/exception/CodedException.kt

@@ -0,0 +1,70 @@
+package expo.modules.kotlin.exception
+
+import java.util.*
+import kotlin.reflect.KType
+
+/**
+ * A class for errors specifying its `code` and providing the `description`.
+ */
+open class CodedException(
+  message: String?,
+  cause: Throwable?
+) : Exception(message, cause) {
+  // We need that secondary property, cause we can't access
+  // the javaClass property in the constructor.
+  private var providedCode: String? = null
+
+  val code
+    get() = providedCode ?: inferCode(javaClass)
+
+  constructor(code: String, message: String, cause: Throwable?) : this(message, cause) {
+    providedCode = code
+  }
+
+  constructor(message: String) : this(message, null)
+
+  constructor(cause: Throwable) : this(cause.localizedMessage, cause)
+
+  constructor() : this(null, null)
+
+  companion object {
+    /**
+     * The code is inferred from the class name — e.g. the code of `ModuleNotFoundException` becomes `ERR_MODULE_NOT_FOUND`.
+     */
+    private fun inferCode(clazz: Class<*>): String {
+      val name = requireNotNull(clazz.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")
+        .toUpperCase(Locale.ROOT)
+    }
+  }
+}
+
+internal class IncompatibleArgTypeException(
+  argumentType: KType,
+  desiredType: KType,
+  cause: Throwable? = null
+) : CodedException(
+  message = "Argument type $argumentType is not compatible with expected type $desiredType.",
+  cause = cause
+)
+
+internal class MissingTypeConverter(
+  forType: KType
+) : CodedException(
+  message = "Cannot find type converter for $forType.",
+)
+
+internal class InvalidArgsNumberException(received: Int, expected: Int) :
+  CodedException(message = "Received $received arguments, but $expected was expected.")
+
+internal class MethodNotFoundException(methodName: String, moduleName: String) :
+  CodedException(message = "Cannot fund method $methodName in module $moduleName")
+
+internal class NullArgumentException(desiredType: KType) :
+  CodedException(message = "Cannot assigned null to not nullable type $desiredType")
+
+internal class UnexpectedException(val throwable: Throwable) :
+  CodedException(throwable)

package/android/src/main/java/expo/modules/kotlin/methods/AnyMethod.kt

@@ -0,0 +1,50 @@
+package expo.modules.kotlin.methods
+
+import com.facebook.react.bridge.ReadableArray
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.InvalidArgsNumberException
+import expo.modules.kotlin.exception.UnexpectedException
+import expo.modules.kotlin.iterator
+import expo.modules.kotlin.recycle
+import expo.modules.kotlin.types.AnyType
+import kotlin.jvm.Throws
+
+abstract class AnyMethod(
+  protected val name: String,
+  private val desiredArgsTypes: Array<AnyType>
+) {
+  fun call(args: ReadableArray, promise: Promise) {
+    if (desiredArgsTypes.size != args.size()) {
+      promise.reject(InvalidArgsNumberException(args.size(), desiredArgsTypes.size))
+      return
+    }
+    try {
+      val convertedArgs = convertArgs(args)
+      callImplementation(convertedArgs, promise)
+    } catch (codedError: CodedException) {
+      promise.reject(codedError)
+    } catch (e: Throwable) {
+      promise.reject(UnexpectedException(e))
+    }
+  }
+
+  @Throws(CodedException::class)
+  internal abstract fun callImplementation(args: Array<out Any?>, promise: Promise)
+
+  val argsCount get() = desiredArgsTypes.size
+
+  @Throws(CodedException::class)
+  private fun convertArgs(args: ReadableArray): Array<out Any?> {
+    val finalArgs = Array<Any?>(desiredArgsTypes.size) { null }
+    val argIterator = args.iterator()
+    desiredArgsTypes
+      .withIndex()
+      .forEach { (index, type) ->
+        argIterator.next().recycle {
+          finalArgs[index] = type.convert(this)
+        }
+      }
+    return finalArgs
+  }
+}

package/android/src/main/java/expo/modules/kotlin/methods/Method.kt

@@ -0,0 +1,14 @@
+package expo.modules.kotlin.methods
+
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.types.AnyType
+
+class Method(
+  name: String,
+  argsType: Array<AnyType>,
+  private val body: (args: Array<out Any?>) -> Any?
+) : AnyMethod(name, argsType) {
+  override fun callImplementation(args: Array<out Any?>, promise: Promise) {
+    promise.resolve(body(args))
+  }
+}