@player-ui/async-node-plugin 1.1.1--canary.934.41671 → 1.1.1--canary.937.41794

package/src/index.ts

@@ -10,17 +10,33 @@ import type {
   ViewPlugin,
   Resolver,
   Resolve,
+  ViewController,
 } from "@player-ui/player";
 import { AsyncSeriesBailHook, SyncBailHook } from "tapable-ts";
 import queueMicrotask from "queue-microtask";
-import { AsyncNodeError } from "./AsyncNodeError";
-import { AsyncNodeInfo, AsyncPluginContext } from "./internal-types";
-import { getNodeFromError } from "./utils";
 
 export * from "./types";
 export * from "./transform";
 export * from "./createAsyncTransform";
 
+/** Object type for storing data related to a single `apply` of the `AsyncNodePluginPlugin`
+ * This object should be setup once per ViewInstance to keep any cached info just for that view to avoid conflicts of shared async node ids across different view states.
+ */
+type AsyncPluginContext = {
+  /** Map of async node id to resolved content */
+  nodeResolveCache: Map<string, Node.Node>;
+  /** The view instance this context is attached to. */
+  view: ViewInstance;
+  /** The view controller this context is attached to. */
+  viewController: ViewController;
+  /** Map of async node id to promises being used to resolve them */
+  inProgressNodes: Set<string>;
+  /** Map of async node ids to the original node they represent.
+   * In some cases, async nodes are transformed into from other node types so the original reference is needed in order to trigger an update on the view when the async node changes.
+   */
+  originalNodeCache: Map<string, Set<Node.Node>>;
+};
+
 export interface AsyncNodePluginOptions {
   /** A set of plugins to load  */
   plugins?: AsyncNodeViewPlugin[];
@@ -126,10 +142,10 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
     node: Node.Async,
     context: AsyncPluginContext,
     result: any,
-    parseFunction?: (content: any) => Node.Node | null,
+    options: Resolve.NodeResolveOptions,
   ) {
     let parsedNode =
-      parseFunction && result ? parseFunction(result) : undefined;
+      options.parseNode && result ? options.parseNode(result) : undefined;
 
     if (parsedNode && node.onValueReceived) {
       parsedNode = node.onValueReceived(parsedNode);
@@ -152,41 +168,22 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
     context: AsyncPluginContext,
     newNode?: Node.Node | null,
   ) {
-    const { asyncNodeCache: asyncNodeInfo, viewController } = context;
-    const entry = asyncNodeInfo.get(node.id);
-    if (!entry) {
-      throw new Error("Failed to update async content. Cache entry not found");
-    }
-    if (entry.resolvedContent !== newNode) {
-      entry.resolvedContent = newNode ? newNode : entry.asyncNode;
-      viewController.updateViewAST(entry.updateNodes);
+    const { nodeResolveCache, viewController, originalNodeCache } = context;
+    if (nodeResolveCache.get(node.id) !== newNode) {
+      nodeResolveCache.set(node.id, newNode ? newNode : node);
+      const originalNode = originalNodeCache.get(node.id) ?? new Set([node]);
+      viewController.updateViewAST(originalNode);
     }
   }
 
   private hasValidMapping(
-    cacheEntry: AsyncNodeInfo,
-  ): cacheEntry is Required<AsyncNodeInfo> {
-    return (
-      cacheEntry.resolvedContent !== undefined &&
-      cacheEntry.resolvedContent !== cacheEntry.asyncNode
-    );
-  }
-
-  private getOrCreateAsyncNodeCacheEntry(
     node: Node.Async,
     context: AsyncPluginContext,
-  ): AsyncNodeInfo {
-    const { asyncNodeCache: asyncNodeInfo } = context;
-    let entry = asyncNodeInfo.get(node.id);
-    if (!entry) {
-      entry = {
-        asyncNode: node,
-        updateNodes: new Set(),
-      };
-      asyncNodeInfo.set(node.id, entry);
-    }
-
-    return entry;
+  ): boolean {
+    const { nodeResolveCache } = context;
+    return (
+      nodeResolveCache.has(node.id) && nodeResolveCache.get(node.id) !== node
+    );
   }
 
   /**
@@ -196,32 +193,17 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
    * @param view
    */
   applyResolver(resolver: Resolver, context: AsyncPluginContext): void {
-    const { assetIdCache } = context;
-    resolver.hooks.afterNodeUpdate.tap(this.name, (original, _, update) => {
-      if (
-        update.node.type !== NodeType.Asset &&
-        update.node.type !== NodeType.View
-      ) {
-        return;
-      }
-
-      assetIdCache.set(update.value.id, original);
-    });
-
     resolver.hooks.beforeResolve.tap(this.name, (node, options) => {
       if (!this.isAsync(node)) {
         return node === null ? node : this.resolveAsyncChildren(node, context);
       }
-
-      const entry = this.getOrCreateAsyncNodeCacheEntry(node, context);
-
       if (options.node) {
-        entry.updateNodes = new Set([options.node]);
-        context.generatedByMap.set(options.node, node.id);
+        context.originalNodeCache.set(node.id, new Set([options.node]));
       }
 
-      if (entry.resolvedContent !== undefined) {
-        return this.resolveAsyncChildren(entry.resolvedContent, context);
+      const resolvedNode = context.nodeResolveCache.get(node.id);
+      if (resolvedNode !== undefined) {
+        return this.resolveAsyncChildren(resolvedNode, context);
       }
 
       if (context.inProgressNodes.has(node.id)) {
@@ -254,24 +236,20 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
       let index = 0;
       while (index < node.values.length) {
         const childNode = node.values[index];
-        if (childNode?.type !== NodeType.Async) {
+        if (
+          childNode?.type !== NodeType.Async ||
+          !this.hasValidMapping(childNode, context)
+        ) {
           index++;
           continue;
         }
-        const entry = this.getOrCreateAsyncNodeCacheEntry(childNode, context);
 
-        if (!this.hasValidMapping(entry)) {
-          index++;
-          continue;
-        }
-
-        const mappedNode = entry.resolvedContent;
+        const mappedNode = context.nodeResolveCache.get(childNode.id)!;
         const nodeSet = new Set<Node.Node>();
         if (mappedNode.type === NodeType.MultiNode && childNode.flatten) {
           mappedNode.values.forEach((v: Node.Node) => {
             v.parent = node;
             nodeSet.add(v);
-            context.originalParentMap.set(v, childNode);
           });
           node.values = [
             ...node.values.slice(0, index),
@@ -283,23 +261,17 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
           mappedNode.parent = node;
           nodeSet.add(mappedNode);
         }
-        entry.updateNodes = nodeSet;
-        for (const n of nodeSet) {
-          context.generatedByMap.set(n, childNode.id);
-        }
+        context.originalNodeCache.set(childNode.id, nodeSet);
       }
     } else if ("children" in node) {
       node.children?.forEach((c) => {
         // Similar to above, using a while loop lets us handle when async nodes produce more async nodes.
-        while (c.value.type === NodeType.Async) {
-          const entry = this.getOrCreateAsyncNodeCacheEntry(c.value, context);
-          if (!this.hasValidMapping(entry)) {
-            break;
-          }
-
-          const mappedNode = entry.resolvedContent;
-          entry.updateNodes = new Set([mappedNode]);
-          context.generatedByMap.set(mappedNode, c.value.id);
+        while (
+          c.value.type === NodeType.Async &&
+          this.hasValidMapping(c.value, context)
+        ) {
+          const mappedNode = context.nodeResolveCache.get(c.value.id)!;
+          context.originalNodeCache.set(c.value.id, new Set([mappedNode]));
           c.value = mappedNode;
           c.value.parent = node;
         }
@@ -315,51 +287,38 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
     options: Resolve.NodeResolveOptions,
   ) {
     try {
-      // Track whether the callback pushed content while the hook was pending;
-      // if so it wins over the bail return (avoids the last-writer-wins race
-      // that intermittently dropped streamed rows).
-      let deliveredViaCallback = false;
-
       const result = await this.basePlugin?.hooks.onAsyncNode.call(
         node,
-        (streamedResult) => {
-          deliveredViaCallback = true;
-          this.parseNodeAndUpdate(
-            node,
-            context,
-            streamedResult,
-            options.parseNode,
-          );
+        (result) => {
+          this.parseNodeAndUpdate(node, context, result, options);
         },
       );
 
       // Stop tracking before the next update is triggered
       context.inProgressNodes.delete(node.id);
-
-      // Once the callback has delivered content it is the source of truth, so a
-      // stale/empty bail return must not clobber it. Skip unless no callback ran
-      // (!deliveredViaCallback) and the return carries content (result != null).
-      if (!deliveredViaCallback && result != null) {
-        this.parseNodeAndUpdate(node, context, result, options.parseNode);
-      }
+      this.parseNodeAndUpdate(node, context, result, options);
     } catch (e: unknown) {
-      const cause = e instanceof Error ? e : new Error(String(e));
-      const playerState = this.basePlugin?.getPlayerInstance()?.getState();
-
-      if (playerState?.status !== "in-progress") {
-        options.logger?.warn(
-          "[AsyncNodePlugin]: An error occured during async node resolution, but the player instance is no londer running. Exception: ",
-          cause,
-        );
+      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);
+        }
+
         return;
       }
 
-      const error = new AsyncNodeError(
-        node,
-        "An error occured during async node resolution. See cause for details.",
-        cause,
+      options.logger?.error(
+        "Async node handling failed and resolved with a fallback. Error:",
+        error,
       );
-      playerState.controllers.error.captureError(error);
+
+      // Stop tracking before the next update is triggered
+      context.inProgressNodes.delete(node.id);
+      this.parseNodeAndUpdate(node, context, result, options);
     }
   }
 
@@ -426,112 +385,15 @@ export class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
   }
 
   applyPlayer(player: Player): void {
-    // TODO: Need a better mechanism for storing the current context.
-    let currentContext: AsyncPluginContext | undefined = undefined;
-    let parser: Parser | undefined = undefined;
-
-    player.hooks.errorController.tap("async", (errorController) => {
-      errorController.hooks.onError.tap("async", (playerError) => {
-        if (currentContext === undefined) {
-          return undefined;
-        }
-
-        /** Try to handle the error using the onAsyncNodeError hook. Returns true if new content is provided. */
-        const tryHandleError = (asyncNode: Node.Async): boolean => {
-          if (this.basePlugin === undefined) {
-            player.logger.warn(
-              `[AsyncNodePlugin]: No plugin detected. Error handling will fail`,
-            );
-          }
-
-          let result: any = undefined;
-          result = this.basePlugin?.hooks.onAsyncNodeError.call(
-            playerError,
-            asyncNode,
-          );
-
-          if (result === undefined) {
-            return false;
-          }
-
-          player.logger?.warn(
-            "[AsyncNodePlugin]: Async node handling failed and resolved with a fallback. Cause:",
-            playerError.message,
-          );
-
-          // Stop tracking before the next update is triggered
-          currentContext!.inProgressNodes.delete(asyncNode.id);
-          this.parseNodeAndUpdate(
-            asyncNode,
-            currentContext!,
-            result,
-            parser?.parseObject.bind(parser),
-          );
-
-          return true;
-        };
-
-        const getNextNode = (node: Node.Node): Node.Node | undefined => {
-          const parent =
-            currentContext?.originalParentMap.get(node) ?? node.parent;
-
-          if (!parent) {
-            return undefined;
-          }
-
-          // asyncNodeCache has current asyncNode reference more up to date with what's happening in the resolver. Sometimes AsyncNodeError has old references so this helps us move up the tree more accurately
-          return this.isAsync(parent)
-            ? currentContext?.asyncNodeCache.get(parent.id)?.asyncNode
-            : parent;
-        };
-
-        let node = getNodeFromError(playerError, currentContext);
-        // If the node is an async node try, to handle errors with it first.
-        if (node?.type === NodeType.Async && tryHandleError(node)) {
-          return true;
-        }
-
-        // Loop through the nodes to see if something is generated by something else. Continue until the error is handled or there are no more nodes to check
-        while (node !== undefined) {
-          const generatedBy = currentContext.generatedByMap.get(node);
-          if (generatedBy) {
-            const entry = currentContext.asyncNodeCache.get(generatedBy);
-
-            if (!entry) {
-              node = getNextNode(node);
-              continue;
-            }
-
-            const { asyncNode } = entry;
-
-            // Don't return false when the error isn't handled to allow for cases where one async is generated by another. Give different nodes a chance to try to recover from the error.
-            if (tryHandleError(asyncNode)) {
-              return true;
-            }
-          }
-
-          node = getNextNode(node);
-        }
-
-        return undefined;
-      });
-    });
-
     player.hooks.viewController.tap("async", (viewController) => {
       viewController.hooks.view.tap("async", (view) => {
-        view.hooks.parser.tap(this.name, (p) => {
-          parser = p;
-        });
         const context: AsyncPluginContext = {
+          nodeResolveCache: new Map(),
           inProgressNodes: new Set(),
           view,
           viewController,
-          generatedByMap: new Map(),
-          assetIdCache: new Map(),
-          asyncNodeCache: new Map(),
-          originalParentMap: new Map(),
+          originalNodeCache: new Map(),
         };
-        currentContext = context;
 
         view.hooks.resolver.tap("async", (resolver) => {
           this.applyResolver(resolver, context);

package/src/utils/index.ts

@@ -2,5 +2,3 @@ export * from "./extractNodeFromPath";
 export * from "./traverseAndReplace";
 export * from "./unwrapAsset";
 export * from "./requiresAssetWrapper";
-export * from "./isAsyncPlayerError";
-export * from "./getNodeFromError";

package/types/index.d.ts

@@ -1,9 +1,25 @@
-import type { Player, PlayerPlugin, Node, ViewInstance, Parser, ViewPlugin, Resolver } from "@player-ui/player";
+import type { Player, PlayerPlugin, Node, ViewInstance, Parser, ViewPlugin, Resolver, ViewController } from "@player-ui/player";
 import { AsyncSeriesBailHook, SyncBailHook } from "tapable-ts";
-import { AsyncPluginContext } from "./internal-types";
 export * from "./types";
 export * from "./transform";
 export * from "./createAsyncTransform";
+/** Object type for storing data related to a single `apply` of the `AsyncNodePluginPlugin`
+ * This object should be setup once per ViewInstance to keep any cached info just for that view to avoid conflicts of shared async node ids across different view states.
+ */
+type AsyncPluginContext = {
+    /** Map of async node id to resolved content */
+    nodeResolveCache: Map<string, Node.Node>;
+    /** The view instance this context is attached to. */
+    view: ViewInstance;
+    /** The view controller this context is attached to. */
+    viewController: ViewController;
+    /** Map of async node id to promises being used to resolve them */
+    inProgressNodes: Set<string>;
+    /** Map of async node ids to the original node they represent.
+     * In some cases, async nodes are transformed into from other node types so the original reference is needed in order to trigger an update on the view when the async node changes.
+     */
+    originalNodeCache: Map<string, Set<Node.Node>>;
+};
 export interface AsyncNodePluginOptions {
     /** A set of plugins to load  */
     plugins?: AsyncNodeViewPlugin[];
@@ -64,7 +80,6 @@ export declare class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
      */
     private handleAsyncUpdate;
     private hasValidMapping;
-    private getOrCreateAsyncNodeCacheEntry;
     /**
      * Handles the asynchronous API integration for resolving nodes.
      * This method sets up a hook on the resolver's `beforeResolve` event to process async nodes.

package/types/utils/index.d.ts

@@ -2,6 +2,4 @@ export * from "./extractNodeFromPath";
 export * from "./traverseAndReplace";
 export * from "./unwrapAsset";
 export * from "./requiresAssetWrapper";
-export * from "./isAsyncPlayerError";
-export * from "./getNodeFromError";
 //# sourceMappingURL=index.d.ts.map

package/src/AsyncNodeError.ts

@@ -1,30 +0,0 @@
-import {
-  ErrorSeverity,
-  type Node,
-  type PlayerErrorMetadata,
-} from "@player-ui/player";
-
-export const ASYNC_ERROR_TYPE = "ASYNC-PLUGIN";
-export type AsyncErrorMetadata = {
-  node: Node.Async;
-};
-export class AsyncNodeError
-  extends Error
-  implements PlayerErrorMetadata<AsyncErrorMetadata>
-{
-  readonly type: string = ASYNC_ERROR_TYPE;
-  readonly severity: ErrorSeverity = ErrorSeverity.ERROR;
-  readonly metadata: AsyncErrorMetadata;
-
-  constructor(
-    node: Node.Async,
-    message?: string,
-    public readonly cause?: Error | undefined,
-  ) {
-    super(message);
-
-    this.metadata = {
-      node,
-    };
-  }
-}

package/src/internal-types.ts

@@ -1,30 +0,0 @@
-import type { Node, ViewController, ViewInstance } from "@player-ui/player";
-
-export type AsyncNodeInfo = {
-  /** The async node */
-  asyncNode: Node.Async;
-  /** All nodes that need to be updated when the async content changes. This could be the async node itself, or a node that created it (i.e. an asset node that transformed into an async node). */
-  updateNodes: Set<Node.Node>;
-  /** The resolved content for this async node */
-  resolvedContent?: Node.Node;
-};
-
-/** Object type for storing data related to a single `apply` of the `AsyncNodePluginPlugin`
- * This object should be setup once per ViewInstance to keep any cached info just for that view to avoid conflicts of shared async node ids across different view states.
- */
-export type AsyncPluginContext = {
-  /** The view instance this context is attached to. */
-  view: ViewInstance;
-  /** The view controller this context is attached to. */
-  viewController: ViewController;
-  /** Set of async node ids that are currently being managed by an incomplete promise. */
-  inProgressNodes: Set<string>;
-  /** Map of async node ids to related info for that node. */
-  asyncNodeCache: Map<string, AsyncNodeInfo>;
-  /** Maps asset ids to its original node. Used to then search for what if could be generated by. */
-  assetIdCache: Map<string, Node.Node>;
-  /** Maps nodes to the async id that generated them. */
-  generatedByMap: Map<Node.Node, string>;
-  /** Map to track the original parent of nodes that were flattened into another. This is needed to track which async nodes actually generated these nodes. */
-  originalParentMap: Map<Node.Node, Node.Node>;
-};