jvm and ios-async-node-ability-to-remove-resolved-async-node

ios/core/Sources/Types/Hooks/Hook.swift

@@ -1,6 +1,6 @@
 //
 //  Hook.swift
-//  
+//
 //
 //  Created by Borawski, Harris on 2/12/20.
 //
@@ -11,16 +11,16 @@
 /// A base for implementing JS backed hooks
 open class BaseJSHook {
     private let baseValue: JSValue
-
+    
     /// The JS reference to the hook
     public var hook: JSValue { baseValue.objectForKeyedSubscript("hooks").objectForKeyedSubscript(name) }
-
+    
     /// The JSContext for the hook
     public var context: JSContext { hook.context }
-
+    
     /// The name of the hook
     public let name: String
-
+    
     /// Retrieves a hook by name from an object in JS
     /// - Parameters:
     ///   - baseValue: The object that has `hooks`
@@ -39,9 +39,9 @@
     /**
      Attach a closure to the hook, so when the hook is fired in the JS runtime
      we receive the event in the native runtime
-
+     
      - parameters:
-        - hook: A function to run when the JS hook is fired
+     - hook: A function to run when the JS hook is fired
      */
     public func tap(_ hook: @escaping (T) -> Void) {
         let tapMethod: @convention(block) (JSValue?) -> Void = { value in
@@ -51,7 +51,7 @@
             else { return }
             hook(hookValue)
         }
-
+        
         self.hook.invokeMethod("tap", withArguments: [name, JSValue(object: tapMethod, in: context) as Any])
     }
 }
@@ -64,9 +64,9 @@
     /**
      Attach a closure to the hook, so when the hook is fired in the JS runtime
      we receive the event in the native runtime
-
+     
      - parameters:
-        - hook: A function to run when the JS hook is fired
+     - hook: A function to run when the JS hook is fired
      */
     public func tap(_ hook: @escaping (T, U) -> Void) {
         let tapMethod: @convention(block) (JSValue?, JSValue?) -> Void = { value, value2 in
@@ -78,7 +78,7 @@
             else { return }
             hook(hookValue, hookValue2)
         }
-
+        
         self.hook.invokeMethod("tap", withArguments: [name, JSValue(object: tapMethod, in: context) as Any])
     }
 }
@@ -91,9 +91,9 @@
     /**
      Attach a closure to the hook, so when the hook is fired in the JS runtime
      we receive the event in the native runtime
-
+     
      - parameters:
-        - hook: A function to run when the JS hook is fired
+     - hook: A function to run when the JS hook is fired
      */
     public func tap(_ hook: @escaping (T) -> Void) {
         let tapMethod: @convention(block) (JSValue?) -> Void = { value in
@@ -103,7 +103,7 @@
             else { return }
             hook(hookValue)
         }
-
+        
         self.hook.invokeMethod("tap", withArguments: [name, JSValue(object: tapMethod, in: context) as Any])
     }
 }
@@ -116,13 +116,13 @@
     /**
      Attach a closure to the hook, so when the hook is fired in the JS runtime
      we receive the event in the native runtime
-
+     
      - parameters:
-        - hook: A function to run when the JS hook is fired
+     - hook: A function to run when the JS hook is fired
      */
     public func tap(_ hook: @escaping (T, U) -> Void) {
         let tapMethod: @convention(block) (JSValue?, JSValue?) -> Void = { value, value2 in
-
+            
             let decoder = JSONDecoder()
             guard
                 let val = value,
@@ -132,7 +132,7 @@
             else { return }
             hook(hookValue, hookValue2)
         }
-
+        
         self.hook.invokeMethod("tap", withArguments: [name, JSValue(object: tapMethod, in: context) as Any])
     }
 }
@@ -143,36 +143,81 @@
  */
 public class AsyncHook<T>: BaseJSHook where T: CreatedFromJSValue {
     private var handler: AsyncHookHandler?
-
+    
     public typealias AsyncHookHandler = (T) async throws -> JSValue?
-
+    
     /**
      Attach a closure to the hook, so when the hook is fired in the JS runtime
      we receive the event in the native runtime
-
+     
      - parameters:
-        - hook: A function to run when the JS hook is fired
+     - hook: A function to run when the JS hook is fired
      */
     public func tap(_ hook: @escaping AsyncHookHandler) {
         let tapMethod: @convention(block) (JSValue?) -> JSValue = { value in
-             guard
-                 let val = value,
-                 let hookValue = T.createInstance(value: val) as? T
-             else { return JSValue() }
-
-             let promise =
-             JSUtilities.createPromise(context: self.context, handler: { (resolve, _) in
-                 Task {
-                     let result = try await hook(hookValue)
-                     DispatchQueue.main.async {
-                         resolve(result as Any)
-                     }
-                 }
-             })
-
-             return promise ?? JSValue()
-         }
+            guard
+                let val = value,
+                let hookValue = T.createInstance(value: val) as? T
+            else { return JSValue() }
+
+            let promise =
+            JSUtilities.createPromise(context: self.context, handler: { (resolve, _) in
+                Task {
+                    let result = try await hook(hookValue)
+                    DispatchQueue.main.async {
+                        resolve(result as Any)
+                    }
+                }
+            })
+
+            return promise ?? JSValue()
+        }
+
+        self.hook.invokeMethod("tap", withArguments: [name, JSValue(object: tapMethod, in: context) as Any])
+    }
+}
 
-         self.hook.invokeMethod("tap", withArguments: [name, JSValue(object: tapMethod, in: context) as Any])
-     }
+/**
+ This class represents an object in the JS runtime that can be tapped into
+ to receive JS events that has 2 parameters and
+ returns a promise that resolves when the asynchronous task is completed
+ */
+public class AsyncHook2<T, U>: BaseJSHook where T: CreatedFromJSValue, U: CreatedFromJSValue {
+    private var handler: AsyncHookHandler?
+
+    public typealias AsyncHookHandler = (T, U) async throws -> JSValue?
+
+    /**
+     Attach a closure to the hook, so when the hook is fired in the JS runtime
+     we receive the event in the native runtime
+
+     - parameters:
+     - hook: A function to run when the JS hook is fired
+     */
+    public func tap(_ hook: @escaping AsyncHookHandler) {
+        let tapMethod: @convention(block) (JSValue?,JSValue?) -> JSValue = { value, value2 in
+            guard
+                let val = value,
+                let val2 = value2,
+                let hookValue = T.createInstance(value: val) as? T,
+                let hookValue2 = U.createInstance(value: val2) as? U
+            else { return JSValue() }
+
+
+            let promise =
+            JSUtilities.createPromise(context: self.context, handler: { (resolve, _) in
+                Task {
+                    let result = try await hook(hookValue, hookValue2)
+                    DispatchQueue.main.async {
+                        resolve(result as Any)
+                    }
+                }
+            })
+
+            return promise ?? JSValue()
+        }
+
+        self.hook.invokeMethod("tap", withArguments: [name, JSValue(object: tapMethod, in: context) as Any])
+    }
 }
+

jvm/core/src/main/kotlin/com/intuit/playerui/core/bridge/Promise.kt

@@ -178,7 +178,7 @@ public val Runtime<*>.Promise: Promise.Api get() = getObject("Promise")?.let { p
 } ?: throw PlayerRuntimeException("'Promise' not defined in runtime")
 
 /** Helper to bridge complex [Promise] logic with the JS promise constructor */
-public fun <T : Any> Runtime<*>.Promise(block: suspend ((T) -> Unit, (Throwable) -> Unit) -> Unit): Promise {
+public fun <T : Any?> Runtime<*>.Promise(block: suspend ((T) -> Unit, (Throwable) -> Unit) -> Unit): Promise {
     val key = "promiseHandler_${UUID.randomUUID().toString().replace("-", "")}"
     add(key) { resolve: Invokable<Any?>, reject: Invokable<Any?> ->
         runtime.scope.launch {

jvm/core/src/main/kotlin/com/intuit/playerui/core/bridge/hooks/NodeAsyncParallelBailHook2.kt

@@ -0,0 +1,40 @@
+package com.intuit.playerui.core.bridge.hooks
+
+import com.intuit.hooks.AsyncParallelBailHook
+import com.intuit.hooks.BailResult
+import com.intuit.hooks.HookContext
+import com.intuit.playerui.core.bridge.Node
+import com.intuit.playerui.core.bridge.serialization.serializers.NodeWrapperSerializer
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializable
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@Serializable(with = NodeAsyncParallelBailHook2.Serializer::class)
+public class NodeAsyncParallelBailHook2<T1, T2, R : Any?>(
+    override val node: Node,
+    serializer1: KSerializer<T1>,
+    serializer2: KSerializer<T2>,
+) : AsyncParallelBailHook<suspend (HookContext, T1, T2) -> BailResult<R>, R>(), AsyncNodeHook<R> {
+
+    init {
+        init(serializer1, serializer2)
+    }
+
+    override suspend fun callAsync(context: HookContext, serializedArgs: Array<Any?>): R {
+        require(serializedArgs.size == 2) { "Expected exactly two arguments, but got ${serializedArgs.size}" }
+        val (p1, p2) = serializedArgs
+        val result = call(10) { f, _ ->
+            f(context, p1 as T1, p2 as T2)
+        } as R
+        return result
+    }
+
+    internal class Serializer<T1, T2, R : Any>(
+        private val serializer1: KSerializer<T1>,
+        private val serializer2: KSerializer<T2>,
+        `_`: KSerializer<R>,
+    ) : NodeWrapperSerializer<NodeAsyncParallelBailHook2<T1, T2, R>>({
+        NodeAsyncParallelBailHook2(it, serializer1, serializer2)
+    })
+}

jvm/core/src/main/kotlin/com/intuit/playerui/core/bridge/hooks/NodeHook.kt

@@ -39,7 +39,7 @@ internal interface NodeHook<R> : NodeWrapper {
     fun call(context: HookContext, serializedArgs: Array<Any?>): R
 }
 
-internal interface AsyncNodeHook<R : Any> : NodeHook<Promise> {
+internal interface AsyncNodeHook<R : Any?> : NodeHook<Promise> {
     override fun call(context: HookContext, serializedArgs: Array<Any?>): Promise = node.runtime.Promise { resolve, reject ->
         val result = callAsync(context, serializedArgs)
         resolve(result)