This PR fixes the Ability to resolve with nothing issue

plugins/async-node/core/src/index.test.ts

@@ -1,9 +1,10 @@
 import { expect, test } from "vitest";
 import type { Node, InProgressState } from "@player-ui/player";
-import { Player } from "@player-ui/player";
+import { Player } from '@player-ui/player';
 import { waitFor } from "@testing-library/react";
 import { AsyncNodePlugin, AsyncNodePluginPlugin } from "./index";
 
+
 const basicFRFWithActions = {
   id: "test-flow",
   views: [
@@ -37,6 +38,90 @@ const basicFRFWithActions = {
   },
 };
 
+const asyncNodeTest = async (resolvedValue: any, expectedActionType: string) => {
+  const plugin = new AsyncNodePlugin({
+    plugins: [new AsyncNodePluginPlugin()]
+  });
+
+  let deferredResolve: ((value: any) => void) | undefined;
+
+  plugin.hooks.onAsyncNode.tap('test', async (node: Node.Node) => {
+    return new Promise((resolve) => {
+      deferredResolve = resolve;
+    });
+  });
+
+  let updateNumber = 0;
+
+  const player = new Player({ plugins: [plugin] });
+
+  player.hooks.viewController.tap('async-node-test', (vc) => {
+    vc.hooks.view.tap('async-node-test', (view) => {
+      view.hooks.onUpdate.tap('async-node-test', () => {
+        updateNumber++;
+      });
+    });
+  });
+
+  player.hooks.viewController.tap('async-node-test', (vc) => {
+    vc.hooks.view.tap('async-node-test', (view) => {
+      view.hooks.resolver.tap('async-node-test', () => {
+        updateNumber++;
+      });
+    });
+  });
+
+  player.start(basicFRFWithActions as any);
+
+  let view = (player.getState() as InProgressState).controllers.view.currentView
+    ?.lastUpdate;
+
+  expect(view).toBeDefined();
+  expect(view?.actions[0].asset.type).toBe('action');
+  expect(view?.actions[1]).toBeUndefined();
+
+  await waitFor(() => {
+    expect(deferredResolve).toBeDefined();
+  });
+
+  // Consumer responds with null/undefined
+  if (deferredResolve) {
+    deferredResolve(resolvedValue);
+  }
+
+  await waitFor(() => {
+    expect(updateNumber).toBe(2);
+  });
+
+  view = (player.getState() as InProgressState).controllers.view.currentView
+    ?.lastUpdate;
+
+  expect(view?.actions[0].asset.type).toBe('action');
+  expect(view?.actions[1]?.asset.type).toBe(expectedActionType);
+  expect(view?.actions[2]?.asset.type).toBe(expectedActionType);
+
+  await waitFor(() => {
+    expect(updateNumber).toBe(3);
+  });
+
+  view = (player.getState() as InProgressState).controllers.view.currentView
+    ?.lastUpdate;
+
+  expect(view?.actions[0].asset.type).toBe('action');
+  expect(view?.actions[1]?.asset.type).toBe(expectedActionType);
+  expect(view?.actions[2]?.asset.type).toBe(expectedActionType);
+  expect(view?.actions[3]?.asset.type).toBe(expectedActionType);
+  expect(updateNumber).toBe(3); // Replace with the actual expected number of updates
+};
+
+test('should return current node view when the resolved node is null', async () => {
+  await asyncNodeTest(null, undefined);
+});
+
+test('should return current node view when the resolved node is undefined', async () => {
+  await asyncNodeTest(undefined, undefined);
+});
+
 test("replaces async nodes with provided node", async () => {
   const plugin = new AsyncNodePlugin({
     plugins: [new AsyncNodePluginPlugin()],

plugins/async-node/core/src/index.ts

@@ -66,7 +66,7 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
 
   name = "AsyncNode";
 
-  private resolvedMapping = new Map<string, Node.Node>();
+  private resolvedMapping = new Map<string, any>();
 
   private currentView: ViewInstance | undefined;
 
@@ -167,10 +167,8 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
                 ? options.parseNode(result)
                 : undefined;
 
-            if (parsedNode) {
-              this.resolvedMapping.set(node.id, parsedNode);
-              view.updateAsync();
-            }
+            this.resolvedMapping.set(node.id, parsedNode);
+            view.updateAsync();
           });
 
           return node;
@@ -184,4 +182,4 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
   applyPlugin(asyncNodePlugin: AsyncNodePlugin): void {
     this.basePlugin = asyncNodePlugin;
   }
-}
+}