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

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

@@ -176,3 +176,47 @@ public class AsyncHook<T>: BaseJSHook where T: CreatedFromJSValue {
          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
+ 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)

plugins/async-node/ios/Sources/AsyncNodePlugin.swift

@@ -7,16 +7,14 @@
 
 import Foundation
 import JavaScriptCore
-
-#if SWIFT_PACKAGE
 import PlayerUI
-#endif
 
-public typealias AsyncHookHandler = (JSValue) async throws -> AsyncNodeHandlerType
+public typealias AsyncHookHandler = (JSValue, JSValue) async throws -> AsyncNodeHandlerType
 
 public enum AsyncNodeHandlerType {
     case multiNode([ReplacementNode])
     case singleNode(ReplacementNode)
+    case emptyNode
 }
 
 /**
@@ -42,57 +40,62 @@
         self.plugins = plugins
     }
 
-    override public func setup(context: JSContext) {
-        super.setup(context: context)
-
-        if let pluginRef = pluginRef {
-            self.hooks = AsyncNodeHook(onAsyncNode: AsyncHook(baseValue: pluginRef, name: "onAsyncNode"))
-        }
-
-        hooks?.onAsyncNode.tap({ node in
-            // hook value is the original node
-            guard let asyncHookHandler = self.asyncHookHandler else {
-                return JSValue()
-            }
-
-            let replacementNode = try await (asyncHookHandler)(node)
-
-            switch replacementNode {
-            case .multiNode(let replacementNodes):
-                let jsValueArray = replacementNodes.compactMap({ node in
-                    switch node {
-                    case .concrete(let jsValue):
-                        return jsValue
-                    case .encodable(let encodable):
-                        let encoder = JSONEncoder()
-                        do {
-                            let res = try encoder.encode(encodable)
-                            return context.evaluateScript("(\(String(data: res, encoding: .utf8) ?? ""))") as JSValue
-                        } catch {
-                            return nil
-                        }
-                    }
-                })
-
-                return context.objectForKeyedSubscript("Array").objectForKeyedSubscript("from").call(withArguments: [jsValueArray])
-
-            case .singleNode(let replacementNode):
-                switch replacementNode {
-
+func handleAsyncNodeReplacement(_ replacementNode: AsyncNodeHandlerType) -> JSValue? {
+    guard let context = context else {
+        return JSValue()
+    }
+        switch replacementNode {
+        case .multiNode(let replacementNodes):
+            let jsValueArray = replacementNodes.compactMap { node in
+                switch node {
+                case .concrete(let jsValue):
+                    return jsValue
                 case .encodable(let encodable):
                     let encoder = JSONEncoder()
                     do {
                         let res = try encoder.encode(encodable)
                         return context.evaluateScript("(\(String(data: res, encoding: .utf8) ?? ""))") as JSValue
                     } catch {
-                        break
+                        return nil
                     }
-                case .concrete(let jsValue):
-                    return jsValue
                 }
             }
+            return context.objectForKeyedSubscript("Array").objectForKeyedSubscript("from").call(withArguments: [jsValueArray])
+
+        case .singleNode(let replacementNode):
+            switch replacementNode {
+            case .encodable(let encodable):
+                let encoder = JSONEncoder()
+                do {
+                    let res = try encoder.encode(encodable)
+                    return context.evaluateScript("(\(String(data: res, encoding: .utf8) ?? ""))") as JSValue
+                } catch {
+                    return nil
+                }
+            case .concrete(let jsValue):
+                return jsValue
+            }
 
+        case .emptyNode:
             return nil
+        }
+        }
+
+    override public func setup(context: JSContext) {
+        super.setup(context: context)
+
+        if let pluginRef = pluginRef {
+            self.hooks = AsyncNodeHook(onAsyncNode: AsyncHook2(baseValue: pluginRef, name: "onAsyncNode"))
+        }
+
+        hooks?.onAsyncNode.tap({ node, callback in
+            // hook value is the original node
+            guard let asyncHookHandler = self.asyncHookHandler else {
+                return JSValue()
+            }
+
+            let replacementNode = try await (asyncHookHandler)(node, callback)
+            return self.handleAsyncNodeReplacement(replacementNode) ?? JSValue()
         })
     }
 
@@ -124,7 +127,7 @@
 }
 
 public struct AsyncNodeHook {
-    public let onAsyncNode: AsyncHook<JSValue>
+    public let onAsyncNode: AsyncHook2<JSValue, JSValue>
 }
 
 /**