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

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<(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)
+    })
+}

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

@@ -12,11 +12,12 @@ import JavaScriptCore
 import PlayerUI
 #endif
 
-public typealias AsyncHookHandler = (JSValue) async throws -> AsyncNodeHandlerType
+public typealias AsyncHookHandler = (JSValue?) async throws -> AsyncNodeHandlerType
 
 public enum AsyncNodeHandlerType {
     case multiNode([ReplacementNode])
     case singleNode(ReplacementNode)
+    case nullOrUndefinedNode(ReplacementNode)
 }
 
 /**
@@ -42,58 +43,70 @@ public class AsyncNodePlugin: JSBasePlugin, NativePlugin {
         self.plugins = plugins
     }
 
-    override public func setup(context: JSContext) {
-        super.setup(context: context)
+   override public func setup(context: JSContext) {
+           super.setup(context: context)
 
-        if let pluginRef = pluginRef {
-            self.hooks = AsyncNodeHook(onAsyncNode: AsyncHook(baseValue: pluginRef, name: "onAsyncNode"))
-        }
+           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 {
-
-                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
-                    }
-                case .concrete(let jsValue):
-                    return jsValue
-                }
-            }
-
-            return nil
-        })
+           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)
+               var result: 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)
+                               result = context.evaluateScript("(\(String(data: res, encoding: .utf8) ?? ""))") as JSValue
+                               return result
+                           } catch {
+                               return nil
+                           }
+                       }
+                   })
+
+                   result = 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)
+                           result = context.evaluateScript("(\(String(data: res, encoding: .utf8) ?? ""))") as JSValue
+                       } catch {
+                           result = nil
+                       }
+                   case .concrete(let jsValue):
+                       return jsValue
+                   }
+
+              case .nullOrUndefinedNode(let replacementNode):
+                  switch replacementNode {
+                  case .encodable(let encodable):
+                      let encoder = JSONEncoder()
+                          let res = try encoder.encode(encodable)
+                          result = context.evaluateScript("(\(String(data: res, encoding: .utf8) ?? ""))") as JSValue
+                  case .concrete(let jsValue):
+                      return jsValue
+                  }
+
+               }
+
+               return result
+           })
     }
 
     /**
@@ -191,4 +204,4 @@ public class AsyncNodePluginPlugin: JSBasePlugin {
         )
         #endif
     }
-}
+}

plugins/async-node/ios/Tests/AsynNodePluginTests.swift

@@ -1,10 +1,3 @@
-//
-//  AsyncNodePluginTests.swift
-//  PlayerUI
-//
-//  Created by Zhao Xia Wu on 2024-02-05.
-//
-
 import Foundation
 import XCTest
 import SwiftUI
@@ -36,7 +29,6 @@ class AsyncNodePluginTests: XCTestCase {
         XCTAssertNotNil(plugin.pluginRef)
     }
 
-
     func testAsyncNodeWithAnotherAsyncNodeDelay() {
         let handlerExpectation = XCTestExpectation(description: "first data did not change")
 
@@ -292,6 +284,166 @@ class AsyncNodePluginTests: XCTestCase {
         XCTAssert(count == 3)
         XCTAssertEqual(expectedMultiNode2Text, "new node from the hook 2")
     }
+
+    func testAsyncNodeWithNullNode() {
+        let handlerExpectation = XCTestExpectation(description: "null node handled")
+
+        let context = JSContext()
+
+        let resolveHandler: AsyncHookHandler = { node in
+            handlerExpectation.fulfill()
+            XCTAssertNil(node)
+            return .singleNode(.concrete(JSValue()))
+        }
+
+        let asyncNodePluginPlugin = AsyncNodePluginPlugin()
+        let plugin = AsyncNodePlugin(plugins: [asyncNodePluginPlugin], resolveHandler)
+
+        plugin.context = context
+
+        XCTAssertNotNil(asyncNodePluginPlugin.context)
+
+        let player = HeadlessPlayerImpl(plugins: [ReferenceAssetsPlugin(), plugin], context: context ?? JSContext())
+
+        player.start(flow: .asyncNodeJson, completion: {_ in})
+
+        wait(for: [handlerExpectation], timeout: 5)
+    }
+
+    func testAsyncNodeWithUndefinedNode() {
+        let handlerExpectation = XCTestExpectation(description: "undefined node handled")
+
+        let context = JSContext()
+
+        let resolveHandler: AsyncHookHandler = { node in
+            handlerExpectation.fulfill()
+            XCTAssertNil(node)
+            return .singleNode(.concrete(JSValue()))
+        }
+
+        let asyncNodePluginPlugin = AsyncNodePluginPlugin()
+        let plugin = AsyncNodePlugin(plugins: [asyncNodePluginPlugin], resolveHandler)
+
+        plugin.context = context
+
+        XCTAssertNotNil(asyncNodePluginPlugin.context)
+
+        let player = HeadlessPlayerImpl(plugins: [ReferenceAssetsPlugin(), plugin], context: context ?? JSContext())
+
+        player.start(flow: .asyncNodeJson, completion: {_ in})
+
+        wait(for: [handlerExpectation], timeout: 5)
+    }
+
+        func testHandleMultipleUpdatesThroughCallbackMechanism() {
+            let handlerExpectation = XCTestExpectation(description: "first data did not change")
+
+            let context = JSContext()
+            var count = 0
+
+            let resolve: AsyncHookHandler = { _ in
+                handlerExpectation.fulfill()
+
+                if count == 1 {
+                    return .multiNode([
+                        ReplacementNode.concrete(context?.evaluateScript("""
+                            (
+                                {"asset": {"id": "text", "type": "text", "value":"1st value in the multinode"}}
+                               )
+                            """) ?? JSValue()),
+                        ReplacementNode.encodable(AsyncNode(id: "id"))])
+                } else if count == 2 {
+                    return .multiNode([
+                        ReplacementNode.encodable(AssetPlaceholderNode(asset: PlaceholderNode(id: "text-2", type: "text", value: "2nd value in the multinode"))),
+                        ReplacementNode.encodable(AsyncNode(id: "id-1"))])
+                } else if count == 3 {
+                    return .singleNode(ReplacementNode.encodable(
+                        AssetPlaceholderNode(asset: PlaceholderNode(id: "text", type: "text", value: "3rd value in the multinode"))
+                    ))
+                }
+
+                return .singleNode(ReplacementNode.concrete(context?.evaluateScript("") ?? JSValue()))
+            }
+
+            let asyncNodePluginPlugin = AsyncNodePluginPlugin()
+            let plugin = AsyncNodePlugin(plugins: [asyncNodePluginPlugin], resolve)
+
+            plugin.context = context
+
+            XCTAssertNotNil(asyncNodePluginPlugin.context)
+
+            let player = HeadlessPlayerImpl(plugins: [ReferenceAssetsPlugin(), plugin], context: context ?? JSContext())
+
+            let textExpectation = XCTestExpectation(description: "newText found")
+            let textExpectation2 = XCTestExpectation(description: "newText found")
+            let textExpectation3 = XCTestExpectation(description: "newText found")
+
+            var expectedMultiNode1Text: String = ""
+            var expectedMultiNode2Text: String = ""
+            var expectedMultiNode3Text: String = ""
+
+            player.hooks?.viewController.tap({ (viewController) in
+                viewController.hooks.view.tap { (view) in
+                    view.hooks.onUpdate.tap { val in
+                        count += 1
+
+                        if count == 2 {
+                            let newText1 = val
+                                .objectForKeyedSubscript("values")
+                                .objectAtIndexedSubscript(1)
+                                .objectForKeyedSubscript("asset")
+                                .objectForKeyedSubscript("value")
+                            guard let textString1 = newText1?.toString() else { return XCTFail("newText was not a string") }
+
+                            expectedMultiNode1Text = textString1
+                            textExpectation.fulfill()
+                        }
+
+                        if count == 3 {
+                            let newText2 = val
+                                .objectForKeyedSubscript("values")
+                                .objectAtIndexedSubscript(2)
+                                .objectForKeyedSubscript("asset")
+                                .objectForKeyedSubscript("value")
+                            guard let textString2 = newText2?.toString() else { return XCTFail("newText was not a string") }
+
+                            expectedMultiNode2Text = textString2
+
+                            textExpectation2.fulfill()
+                        }
+
+                        if count == 4 {
+                            let newText3 = val
+                                .objectForKeyedSubscript("values")
+                                .objectAtIndexedSubscript(3)
+                                .objectForKeyedSubscript("asset")
+                                .objectForKeyedSubscript("value")
+                            guard let textString3 = newText3?.toString() else { return XCTFail("newText was not a string") }
+
+                            expectedMultiNode3Text = textString3
+                            textExpectation3.fulfill()
+                        }
+                    }
+                }
+            })
+
+            player.start(flow: .asyncNodeJson, completion: { _ in})
+
+            wait(for: [handlerExpectation, textExpectation], timeout: 5)
+
+            XCTAssert(count == 2)
+            XCTAssertEqual(expectedMultiNode1Text, "1st value in the multinode")
+
+            wait(for: [textExpectation2], timeout: 6)
+
+            XCTAssert(count == 3)
+            XCTAssertEqual(expectedMultiNode2Text, "2nd value in the multinode")
+
+            wait(for: [textExpectation3], timeout: 7)
+
+            XCTAssert(count == 4)
+            XCTAssertEqual(expectedMultiNode3Text, "3rd value in the multinode")
+        }
 }
 
 extension String {
@@ -358,4 +510,4 @@ struct PlaceholderNode: Codable, Equatable, AssetData {
         self.type = type
         self.value = value
     }
-}
+}