@player-ui/async-node-plugin 0.11.3--canary.666.23588 → 0.11.3--canary.660.23595

package/src/index.ts

@@ -11,7 +11,7 @@ import type {
   Resolver,
   Resolve,
 } from "@player-ui/player";
-import { AsyncParallelBailHook, SyncBailHook } from "tapable-ts";
+import { AsyncParallelBailHook } from "tapable-ts";
 import queueMicrotask from "queue-microtask";
 import { omit } from "timm";
 
@@ -34,21 +34,12 @@ export type AsyncHandler = (
   callback?: (result: any) => void,
 ) => Promise<any>;
 
-/** Hook declaration for the AsyncNodePlugin */
-type AsyncNodeHooks = {
-  /** Async hook to get content for an async node */
-  onAsyncNode: AsyncParallelBailHook<[Node.Async, (result: any) => void], any>;
-  /** Sync hook to manage errors coming from the onAsyncNode hook. Return a fallback node or null to render a fallback. The first argument of passed in the call is the error thrown. */
-  onAsyncNodeError: SyncBailHook<[Error, Node.Async], Node.Node | null>;
-};
-
 /**
  * Async node plugin used to resolve async nodes in the content
  * If an async node is present, allow users to provide a replacement node to be rendered when ready
  */
 export class AsyncNodePlugin implements PlayerPlugin {
   private plugins: AsyncNodeViewPlugin[] | undefined;
-  private playerInstance: Player | undefined;
 
   constructor(options: AsyncNodePluginOptions, asyncHandler?: AsyncHandler) {
     if (options?.plugins) {
@@ -68,20 +59,16 @@ export class AsyncNodePlugin implements PlayerPlugin {
     }
   }
 
-  public readonly hooks: AsyncNodeHooks = {
-    onAsyncNode: new AsyncParallelBailHook(),
-    onAsyncNodeError: new SyncBailHook(),
+  public readonly hooks = {
+    onAsyncNode: new AsyncParallelBailHook<
+      [Node.Async, (result: any) => void],
+      any
+    >(),
   };
 
-  getPlayerInstance(): Player | undefined {
-    return this.playerInstance;
-  }
-
   name = "AsyncNode";
 
-  apply(player: Player): void {
-    this.playerInstance = player;
-
+  apply(player: Player) {
     player.hooks.viewController.tap(this.name, (viewController) => {
       viewController.hooks.view.tap(this.name, (view) => {
         this.plugins?.forEach((plugin) => {
@@ -93,10 +80,10 @@ export class AsyncNodePlugin implements PlayerPlugin {
 }
 
 export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
-  public asyncNode: AsyncParallelBailHook<
+  public asyncNode = new AsyncParallelBailHook<
     [Node.Async, (result: any) => void],
     any
-  > = new AsyncParallelBailHook();
+  >();
   private basePlugin: AsyncNodePlugin | undefined;
 
   name = "AsyncNode";
@@ -106,13 +93,16 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
   private currentView: ViewInstance | undefined;
 
   /**
-   * Parses the node from the result and triggers an asynchronous view update if necessary.
+   * Updates the node asynchronously based on the result provided.
+   * This method is responsible for handling the update logic of asynchronous nodes.
+   * It checks if the node needs to be updated based on the new result and updates the mapping accordingly.
+   * If an update is necessary, it triggers an asynchronous update on the view.
    * @param node The asynchronous node that might be updated.
    * @param result The result obtained from resolving the async node. This could be any data structure or value.
    * @param options Options provided for node resolution, including a potential parseNode function to process the result.
    * @param view The view instance where the node resides. This can be undefined if the view is not currently active.
    */
-  private parseNodeAndUpdate(
+  private handleAsyncUpdate(
     node: Node.Async,
     result: any,
     options: Resolve.NodeResolveOptions,
@@ -121,25 +111,8 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
     const parsedNode =
       options.parseNode && result ? options.parseNode(result) : undefined;
 
-    this.handleAsyncUpdate(node, parsedNode, view);
-  }
-
-  /**
-   * Updates the node asynchronously based on the result provided.
-   * This method is responsible for handling the update logic of asynchronous nodes.
-   * It checks if the node needs to be updated based on the new result and updates the mapping accordingly.
-   * If an update is necessary, it triggers an asynchronous update on the view.
-   * @param node The asynchronous node that might be updated.
-   * @param newNode The new node to replace the async node.
-   * @param view The view instance where the node resides. This can be undefined if the view is not currently active.
-   */
-  private handleAsyncUpdate(
-    node: Node.Async,
-    newNode?: Node.Node | null,
-    view?: ViewInstance,
-  ) {
-    if (this.resolvedMapping.get(node.id) !== newNode) {
-      this.resolvedMapping.set(node.id, newNode ? newNode : node);
+    if (this.resolvedMapping.get(node.id) !== parsedNode) {
+      this.resolvedMapping.set(node.id, parsedNode ? parsedNode : node);
       view?.updateAsync();
     }
   }
@@ -150,55 +123,34 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
    * @param resolver The resolver instance to attach the hook to.
    * @param view
    */
-  applyResolver(resolver: Resolver): void {
+  applyResolver(resolver: Resolver) {
     resolver.hooks.beforeResolve.tap(this.name, (node, options) => {
-      if (!this.isAsync(node)) {
-        return node;
-      }
-
-      const resolvedNode = this.resolvedMapping.get(node.id);
-      if (resolvedNode !== undefined) {
-        return resolvedNode;
+      let resolvedNode;
+      if (this.isAsync(node)) {
+        const mappedValue = this.resolvedMapping.get(node.id);
+        if (mappedValue) {
+          resolvedNode = mappedValue;
+        }
+      } else {
+        resolvedNode = null;
       }
 
-      queueMicrotask(() => this.runAsyncNode(node, options));
-
-      return node;
-    });
-  }
-
-  private async runAsyncNode(
-    node: Node.Async,
-    options: Resolve.NodeResolveOptions,
-  ) {
-    try {
-      const result = await this.basePlugin?.hooks.onAsyncNode.call(
-        node,
-        (result) => {
-          this.parseNodeAndUpdate(node, result, options, this.currentView);
-        },
-      );
-      this.parseNodeAndUpdate(node, result, options, this.currentView);
-    } catch (e: unknown) {
-      const error = e instanceof Error ? e : new Error(String(e));
-      const result = this.basePlugin?.hooks.onAsyncNodeError.call(error, node);
-
-      if (result === undefined) {
-        const playerState = this.basePlugin?.getPlayerInstance()?.getState();
-
-        if (playerState?.status === "in-progress") {
-          playerState.fail(error);
-        }
+      const newNode = resolvedNode || node;
+      if (!resolvedNode && node?.type === NodeType.Async) {
+        queueMicrotask(async () => {
+          const result = await this.basePlugin?.hooks.onAsyncNode.call(
+            node,
+            (result) => {
+              this.handleAsyncUpdate(node, result, options, this.currentView);
+            },
+          );
+          this.handleAsyncUpdate(node, result, options, this.currentView);
+        });
 
-        return;
+        return node;
       }
-
-      options.logger?.error(
-        "Async node handling failed and resolved with a fallback. Error:",
-        error,
-      );
-      this.handleAsyncUpdate(node, result, this.currentView);
-    }
+      return newNode;
+    });
   }
 
   private isAsync(node: Node.Node | null): node is Node.Async {
@@ -209,7 +161,7 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
     return obj && Object.prototype.hasOwnProperty.call(obj, "async");
   }
 
-  applyParser(parser: Parser): void {
+  applyParser(parser: Parser) {
     parser.hooks.parseNode.tap(
       this.name,
       (

package/types/index.d.ts

@@ -1,5 +1,5 @@
 import type { Player, PlayerPlugin, Node, ViewInstance, Parser, ViewPlugin, Resolver } from "@player-ui/player";
-import { AsyncParallelBailHook, SyncBailHook } from "tapable-ts";
+import { AsyncParallelBailHook } from "tapable-ts";
 export * from "./types";
 export * from "./transform";
 export interface AsyncNodePluginOptions {
@@ -12,50 +12,33 @@ export interface AsyncNodeViewPlugin extends ViewPlugin {
     asyncNode: AsyncParallelBailHook<[Node.Async, (result: any) => void], any>;
 }
 export type AsyncHandler = (node: Node.Async, callback?: (result: any) => void) => Promise<any>;
-/** Hook declaration for the AsyncNodePlugin */
-type AsyncNodeHooks = {
-    /** Async hook to get content for an async node */
-    onAsyncNode: AsyncParallelBailHook<[Node.Async, (result: any) => void], any>;
-    /** Sync hook to manage errors coming from the onAsyncNode hook. Return a fallback node or null to render a fallback. The first argument of passed in the call is the error thrown. */
-    onAsyncNodeError: SyncBailHook<[Error, Node.Async], Node.Node | null>;
-};
 /**
  * Async node plugin used to resolve async nodes in the content
  * If an async node is present, allow users to provide a replacement node to be rendered when ready
  */
 export declare class AsyncNodePlugin implements PlayerPlugin {
     private plugins;
-    private playerInstance;
     constructor(options: AsyncNodePluginOptions, asyncHandler?: AsyncHandler);
-    readonly hooks: AsyncNodeHooks;
-    getPlayerInstance(): Player | undefined;
+    readonly hooks: {
+        onAsyncNode: AsyncParallelBailHook<[Node.Async, (result: any) => void], any, Record<string, any>>;
+    };
     name: string;
     apply(player: Player): void;
 }
 export declare class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
-    asyncNode: AsyncParallelBailHook<[
-        Node.Async,
-        (result: any) => void
-    ], any>;
+    asyncNode: AsyncParallelBailHook<[Node.Async, (result: any) => void], any, Record<string, any>>;
     private basePlugin;
     name: string;
     private resolvedMapping;
     private currentView;
-    /**
-     * Parses the node from the result and triggers an asynchronous view update if necessary.
-     * @param node The asynchronous node that might be updated.
-     * @param result The result obtained from resolving the async node. This could be any data structure or value.
-     * @param options Options provided for node resolution, including a potential parseNode function to process the result.
-     * @param view The view instance where the node resides. This can be undefined if the view is not currently active.
-     */
-    private parseNodeAndUpdate;
     /**
      * Updates the node asynchronously based on the result provided.
      * This method is responsible for handling the update logic of asynchronous nodes.
      * It checks if the node needs to be updated based on the new result and updates the mapping accordingly.
      * If an update is necessary, it triggers an asynchronous update on the view.
      * @param node The asynchronous node that might be updated.
-     * @param newNode The new node to replace the async node.
+     * @param result The result obtained from resolving the async node. This could be any data structure or value.
+     * @param options Options provided for node resolution, including a potential parseNode function to process the result.
      * @param view The view instance where the node resides. This can be undefined if the view is not currently active.
      */
     private handleAsyncUpdate;
@@ -66,7 +49,6 @@ export declare class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
      * @param view
      */
     applyResolver(resolver: Resolver): void;
-    private runAsyncNode;
     private isAsync;
     private isDeterminedAsync;
     applyParser(parser: Parser): void;