@player-ui/async-node-plugin 0.15.4--canary.881.37421 → 0.15.4--canary.884.37483

package/dist/index.legacy-esm.js

@@ -3,23 +3,33 @@ 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/AsyncNodeError.ts
-import {
-  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/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";
+
 // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/utils/extractNodeFromPath.ts
 var getMatchValue = (pathA, pathB) => {
   if (pathA.length > pathB.length) {
@@ -115,59 +125,7 @@ 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}`;
 };
@@ -277,8 +235,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, parseFunction) {
-    let parsedNode = parseFunction && result ? parseFunction(result) : void 0;
+  parseNodeAndUpdate(node, context, result, options) {
+    let parsedNode = options.parseNode && result ? options.parseNode(result) : void 0;
     if (parsedNode && node.onValueReceived) {
       parsedNode = node.onValueReceived(parsedNode);
     }
@@ -294,30 +252,16 @@ 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 { 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) ?? /* @__PURE__ */ new Set([node]);
+      viewController.updateViewAST(originalNode);
     }
   }
-  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;
+  hasValidMapping(node, context) {
+    const { nodeResolveCache } = context;
+    return nodeResolveCache.has(node.id) && nodeResolveCache.get(node.id) !== node;
   }
   /**
    * Handles the asynchronous API integration for resolving nodes.
@@ -326,24 +270,16 @@ 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) {
-        entry.updateNodes = /* @__PURE__ */ new Set([options.node]);
-        context.generatedByMap.set(options.node, node.id);
+        context.originalNodeCache.set(node.id, /* @__PURE__ */ new Set([options.node]));
       }
-      if (entry.resolvedContent !== void 0) {
-        return this.resolveAsyncChildren(entry.resolvedContent, context);
+      const resolvedNode = context.nodeResolveCache.get(node.id);
+      if (resolvedNode !== void 0) {
+        return this.resolveAsyncChildren(resolvedNode, context);
       }
       if (context.inProgressNodes.has(node.id)) {
         return node;
@@ -367,22 +303,16 @@ var AsyncNodePluginPlugin = class {
       let index = 0;
       while (index < node.values.length) {
         const childNode = node.values[index];
-        if (childNode?.type !== NodeType5.Async) {
+        if (childNode?.type !== NodeType5.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 = /* @__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),
@@ -394,21 +324,13 @@ var AsyncNodePluginPlugin = class {
           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) => {
-        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);
+        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]));
           c.value = mappedNode;
           c.value.parent = node;
         }
@@ -421,27 +343,27 @@ var AsyncNodePluginPlugin = class {
       const result = await this.basePlugin?.hooks.onAsyncNode.call(
         node,
         (result2) => {
-          this.parseNodeAndUpdate(node, context, result2, options.parseNode);
+          this.parseNodeAndUpdate(node, context, result2, options);
         }
       );
       context.inProgressNodes.delete(node.id);
-      this.parseNodeAndUpdate(node, context, result, options.parseNode);
+      this.parseNodeAndUpdate(node, context, result, options);
     } catch (e) {
-      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 === void 0) {
+        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);
+      context.inProgressNodes.delete(node.id);
+      this.parseNodeAndUpdate(node, context, result, options);
     }
   }
   isAsync(node) {
@@ -487,84 +409,15 @@ 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,
-          generatedByMap: /* @__PURE__ */ new Map(),
-          assetIdCache: /* @__PURE__ */ new Map(),
-          asyncNodeCache: /* @__PURE__ */ new Map(),
-          originalParentMap: /* @__PURE__ */ new Map()
+          originalNodeCache: /* @__PURE__ */ new Map()
         };
-        currentContext = context;
         view.hooks.resolver.tap("async", (resolver) => {
           this.applyResolver(resolver, context);
         });