@player-ui/async-node-plugin 0.15.3-next.3 → 0.15.4--canary.881.37421

package/dist/index.legacy-esm.js

@@ -3,32 +3,22 @@ import { NodeType as NodeType5, getNodeID } from "@player-ui/player";
 import { AsyncSeriesBailHook, SyncBailHook } from "tapable-ts";
 import queueMicrotask from "queue-microtask";
 
-// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/transform.ts
-import { Builder } from "@player-ui/player";
-var asyncTransform = (assetId, wrapperAssetType, asset, flatten, path = ["values"]) => {
-  const id = "async-" + assetId;
-  const asyncNode = Builder.asyncNode(id, flatten);
-  let multiNode;
-  let assetNode;
-  if (asset) {
-    assetNode = Builder.assetWrapper(asset);
-    multiNode = Builder.multiNode(assetNode, asyncNode);
-  } else {
-    multiNode = Builder.multiNode(asyncNode);
-  }
-  const wrapperAsset = Builder.asset({
-    id: wrapperAssetType + "-" + id,
-    type: wrapperAssetType
-  });
-  Builder.addChild(wrapperAsset, path, multiNode);
-  return wrapperAsset;
-};
-
-// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/createAsyncTransform.ts
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/AsyncNodeError.ts
 import {
-  Builder as Builder2,
-  NodeType as NodeType4
+  ErrorSeverity
 } from "@player-ui/player";
+var ASYNC_ERROR_TYPE = "ASYNC-PLUGIN";
+var AsyncNodeError = class extends Error {
+  constructor(node, message, cause) {
+    super(message);
+    this.cause = cause;
+    this.type = ASYNC_ERROR_TYPE;
+    this.severity = ErrorSeverity.ERROR;
+    this.metadata = {
+      node
+    };
+  }
+};
 
 // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/utils/extractNodeFromPath.ts
 var getMatchValue = (pathA, pathB) => {
@@ -125,7 +115,59 @@ var requiresAssetWrapper = (node) => {
   return node.value.type === NodeType3.Asset;
 };
 
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/utils/isAsyncPlayerError.ts
+var isAsyncPlayerError = (error) => {
+  return error.type === ASYNC_ERROR_TYPE;
+};
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/utils/getNodeFromError.ts
+import { ErrorTypes } from "@player-ui/player";
+var getNodeFromError = (playerError, context) => {
+  if (playerError.type === ErrorTypes.RENDER) {
+    const { assetId } = playerError.metadata ?? {};
+    if (typeof assetId !== "string") {
+      return void 0;
+    }
+    return context.assetIdCache.get(assetId);
+  }
+  if (playerError.type === ErrorTypes.VIEW) {
+    const { node } = playerError.metadata ?? {};
+    if (typeof node === "object" && node !== null && !Array.isArray(node)) {
+      return node;
+    }
+  }
+  if (isAsyncPlayerError(playerError) && playerError.metadata !== void 0) {
+    return context.asyncNodeCache.get(playerError.metadata.node.id)?.asyncNode;
+  }
+  return void 0;
+};
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/transform.ts
+import { Builder } from "@player-ui/player";
+var asyncTransform = (assetId, wrapperAssetType, asset, flatten, path = ["values"]) => {
+  const id = "async-" + assetId;
+  const asyncNode = Builder.asyncNode(id, flatten);
+  let multiNode;
+  let assetNode;
+  if (asset) {
+    assetNode = Builder.assetWrapper(asset);
+    multiNode = Builder.multiNode(assetNode, asyncNode);
+  } else {
+    multiNode = Builder.multiNode(asyncNode);
+  }
+  const wrapperAsset = Builder.asset({
+    id: wrapperAssetType + "-" + id,
+    type: wrapperAssetType
+  });
+  Builder.addChild(wrapperAsset, path, multiNode);
+  return wrapperAsset;
+};
+
 // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/createAsyncTransform.ts
+import {
+  Builder as Builder2,
+  NodeType as NodeType4
+} from "@player-ui/player";
 var defaultGetNodeId = (node) => {
   return `async-${node.value.id}`;
 };
@@ -235,8 +277,8 @@ var AsyncNodePluginPlugin = class {
    * @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.
    */
-  parseNodeAndUpdate(node, context, result, options) {
-    let parsedNode = options.parseNode && result ? options.parseNode(result) : void 0;
+  parseNodeAndUpdate(node, context, result, parseFunction) {
+    let parsedNode = parseFunction && result ? parseFunction(result) : void 0;
     if (parsedNode && node.onValueReceived) {
       parsedNode = node.onValueReceived(parsedNode);
     }
@@ -252,16 +294,30 @@ var AsyncNodePluginPlugin = class {
    * @param view The view instance where the node resides. This can be undefined if the view is not currently active.
    */
   handleAsyncUpdate(node, context, newNode) {
-    const { nodeResolveCache, viewController, originalNodeCache } = context;
-    if (nodeResolveCache.get(node.id) !== newNode) {
-      nodeResolveCache.set(node.id, newNode ? newNode : node);
-      const originalNode = originalNodeCache.get(node.id) ?? /* @__PURE__ */ new Set([node]);
-      viewController.updateViewAST(originalNode);
+    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);
     }
   }
-  hasValidMapping(node, context) {
-    const { nodeResolveCache } = context;
-    return nodeResolveCache.has(node.id) && nodeResolveCache.get(node.id) !== node;
+  hasValidMapping(cacheEntry) {
+    return cacheEntry.resolvedContent !== void 0 && cacheEntry.resolvedContent !== cacheEntry.asyncNode;
+  }
+  getOrCreateAsyncNodeCacheEntry(node, context) {
+    const { asyncNodeCache: asyncNodeInfo } = context;
+    let entry = asyncNodeInfo.get(node.id);
+    if (!entry) {
+      entry = {
+        asyncNode: node,
+        updateNodes: /* @__PURE__ */ new Set()
+      };
+      asyncNodeInfo.set(node.id, entry);
+    }
+    return entry;
   }
   /**
    * Handles the asynchronous API integration for resolving nodes.
@@ -270,16 +326,24 @@ var AsyncNodePluginPlugin = class {
    * @param view
    */
   applyResolver(resolver, context) {
+    const { assetIdCache } = context;
+    resolver.hooks.afterNodeUpdate.tap(this.name, (original, _, update) => {
+      if (update.node.type !== NodeType5.Asset && update.node.type !== NodeType5.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) {
-        context.originalNodeCache.set(node.id, /* @__PURE__ */ new Set([options.node]));
+        entry.updateNodes = /* @__PURE__ */ new Set([options.node]);
+        context.generatedByMap.set(options.node, node.id);
       }
-      const resolvedNode = context.nodeResolveCache.get(node.id);
-      if (resolvedNode !== void 0) {
-        return this.resolveAsyncChildren(resolvedNode, context);
+      if (entry.resolvedContent !== void 0) {
+        return this.resolveAsyncChildren(entry.resolvedContent, context);
       }
       if (context.inProgressNodes.has(node.id)) {
         return node;
@@ -303,16 +367,22 @@ var AsyncNodePluginPlugin = class {
       let index = 0;
       while (index < node.values.length) {
         const childNode = node.values[index];
-        if (childNode?.type !== NodeType5.Async || !this.hasValidMapping(childNode, context)) {
+        if (childNode?.type !== NodeType5.Async) {
           index++;
           continue;
         }
-        const mappedNode = context.nodeResolveCache.get(childNode.id);
+        const entry = this.getOrCreateAsyncNodeCacheEntry(childNode, context);
+        if (!this.hasValidMapping(entry)) {
+          index++;
+          continue;
+        }
+        const mappedNode = entry.resolvedContent;
         const nodeSet = /* @__PURE__ */ new Set();
         if (mappedNode.type === NodeType5.MultiNode && childNode.flatten) {
           mappedNode.values.forEach((v) => {
             v.parent = node;
             nodeSet.add(v);
+            context.originalParentMap.set(v, childNode);
           });
           node.values = [
             ...node.values.slice(0, index),
@@ -324,13 +394,21 @@ var AsyncNodePluginPlugin = class {
           mappedNode.parent = node;
           nodeSet.add(mappedNode);
         }
-        context.originalNodeCache.set(childNode.id, nodeSet);
+        entry.updateNodes = nodeSet;
+        for (const n of nodeSet) {
+          context.generatedByMap.set(n, childNode.id);
+        }
       }
     } else if ("children" in node) {
       node.children?.forEach((c) => {
-        while (c.value.type === NodeType5.Async && this.hasValidMapping(c.value, context)) {
-          const mappedNode = context.nodeResolveCache.get(c.value.id);
-          context.originalNodeCache.set(c.value.id, /* @__PURE__ */ new Set([mappedNode]));
+        while (c.value.type === NodeType5.Async) {
+          const entry = this.getOrCreateAsyncNodeCacheEntry(c.value, context);
+          if (!this.hasValidMapping(entry)) {
+            break;
+          }
+          const mappedNode = entry.resolvedContent;
+          entry.updateNodes = /* @__PURE__ */ new Set([mappedNode]);
+          context.generatedByMap.set(mappedNode, c.value.id);
           c.value = mappedNode;
           c.value.parent = node;
         }
@@ -343,27 +421,27 @@ var AsyncNodePluginPlugin = class {
       const result = await this.basePlugin?.hooks.onAsyncNode.call(
         node,
         (result2) => {
-          this.parseNodeAndUpdate(node, context, result2, options);
+          this.parseNodeAndUpdate(node, context, result2, options.parseNode);
         }
       );
       context.inProgressNodes.delete(node.id);
-      this.parseNodeAndUpdate(node, context, result, options);
+      this.parseNodeAndUpdate(node, context, result, options.parseNode);
     } catch (e) {
-      const error = e instanceof Error ? e : new Error(String(e));
-      const result = this.basePlugin?.hooks.onAsyncNodeError.call(error, node);
-      if (result === void 0) {
-        const playerState = this.basePlugin?.getPlayerInstance()?.getState();
-        if (playerState?.status === "in-progress") {
-          playerState.fail(error);
-        }
+      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
+        );
         return;
       }
-      options.logger?.error(
-        "Async node handling failed and resolved with a fallback. Error:",
-        error
+      const error = new AsyncNodeError(
+        node,
+        "An error occured during async node resolution. See cause for details.",
+        cause
       );
-      context.inProgressNodes.delete(node.id);
-      this.parseNodeAndUpdate(node, context, result, options);
+      playerState.controllers.error.captureError(error);
     }
   }
   isAsync(node) {
@@ -409,15 +487,84 @@ var AsyncNodePluginPlugin = class {
     view.hooks.parser.tap("async", this.applyParser.bind(this));
   }
   applyPlayer(player) {
+    let currentContext = void 0;
+    let parser = void 0;
+    player.hooks.errorController.tap("async", (errorController) => {
+      errorController.hooks.onError.tap("async", (playerError) => {
+        if (currentContext === void 0) {
+          return void 0;
+        }
+        const tryHandleError = (asyncNode) => {
+          if (this.basePlugin === void 0) {
+            player.logger.warn(
+              `[AsyncNodePlugin]: No plugin detected. Error handling will fail`
+            );
+          }
+          let result = void 0;
+          result = this.basePlugin?.hooks.onAsyncNodeError.call(
+            playerError,
+            asyncNode
+          );
+          if (result === void 0) {
+            return false;
+          }
+          player.logger?.warn(
+            "[AsyncNodePlugin]: Async node handling failed and resolved with a fallback. Cause:",
+            playerError.message
+          );
+          currentContext.inProgressNodes.delete(asyncNode.id);
+          this.parseNodeAndUpdate(
+            asyncNode,
+            currentContext,
+            result,
+            parser?.parseObject.bind(parser)
+          );
+          return true;
+        };
+        const getNextNode = (node2) => {
+          const parent = currentContext?.originalParentMap.get(node2) ?? node2.parent;
+          if (!parent) {
+            return void 0;
+          }
+          return this.isAsync(parent) ? currentContext?.asyncNodeCache.get(parent.id)?.asyncNode : parent;
+        };
+        let node = getNodeFromError(playerError, currentContext);
+        if (node?.type === NodeType5.Async && tryHandleError(node)) {
+          return true;
+        }
+        while (node !== void 0) {
+          const generatedBy = currentContext.generatedByMap.get(node);
+          if (generatedBy) {
+            const entry = currentContext.asyncNodeCache.get(generatedBy);
+            if (!entry) {
+              node = getNextNode(node);
+              continue;
+            }
+            const { asyncNode } = entry;
+            if (tryHandleError(asyncNode)) {
+              return true;
+            }
+          }
+          node = getNextNode(node);
+        }
+        return void 0;
+      });
+    });
     player.hooks.viewController.tap("async", (viewController) => {
       viewController.hooks.view.tap("async", (view) => {
+        view.hooks.parser.tap(this.name, (p) => {
+          parser = p;
+        });
         const context = {
-          nodeResolveCache: /* @__PURE__ */ new Map(),
           inProgressNodes: /* @__PURE__ */ new Set(),
           view,
           viewController,
-          originalNodeCache: /* @__PURE__ */ new Map()
+          generatedByMap: /* @__PURE__ */ new Map(),
+          assetIdCache: /* @__PURE__ */ new Map(),
+          asyncNodeCache: /* @__PURE__ */ new Map(),
+          originalParentMap: /* @__PURE__ */ new Map()
         };
+        currentContext = context;
         view.hooks.resolver.tap("async", (resolver) => {
           this.applyResolver(resolver, context);
         });