@player-ui/async-node-plugin 0.11.3--canary.666.24070 → 0.11.3--canary.666.24188

package/dist/AsyncNodePlugin.native.js

@@ -7793,7 +7793,6 @@ var AsyncNodePlugin = function() {
             _class_call_check(this, AsyncNodePluginPlugin);
             this.asyncNode = new AsyncParallelBailHook();
             this.name = "AsyncNode";
-            this.resolvedMapping = /* @__PURE__ */ new Map();
         }
         _create_class(AsyncNodePluginPlugin, [
             {
@@ -7804,9 +7803,9 @@ var AsyncNodePlugin = function() {
      * @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.
      */ key: "parseNodeAndUpdate",
-                value: function parseNodeAndUpdate(node, result, options, view) {
+                value: function parseNodeAndUpdate(node, context, result, options, view) {
                     var parsedNode = options.parseNode && result ? options.parseNode(result) : void 0;
-                    this.handleAsyncUpdate(node, parsedNode, view);
+                    this.handleAsyncUpdate(node, context, parsedNode, view);
                 }
             },
             {
@@ -7819,9 +7818,10 @@ var AsyncNodePlugin = function() {
      * @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.
      */ key: "handleAsyncUpdate",
-                value: function handleAsyncUpdate(node, newNode, view) {
-                    if (this.resolvedMapping.get(node.id) !== newNode) {
-                        this.resolvedMapping.set(node.id, newNode ? newNode : node);
+                value: function handleAsyncUpdate(node, context, newNode, view) {
+                    var nodeResolveCache = context.nodeResolveCache;
+                    if (nodeResolveCache.get(node.id) !== newNode) {
+                        nodeResolveCache.set(node.id, newNode ? newNode : node);
                         view === null || view === void 0 ? void 0 : view.updateAsync();
                     }
                 }
@@ -7833,18 +7833,18 @@ var AsyncNodePlugin = function() {
      * @param resolver The resolver instance to attach the hook to.
      * @param view
      */ key: "applyResolver",
-                value: function applyResolver(resolver) {
+                value: function applyResolver(resolver, context) {
                     var _this = this;
                     resolver.hooks.beforeResolve.tap(this.name, function(node, options) {
                         if (!_this.isAsync(node)) {
                             return node;
                         }
-                        var resolvedNode = _this.resolvedMapping.get(node.id);
+                        var resolvedNode = context.nodeResolveCache.get(node.id);
                         if (resolvedNode !== void 0) {
                             return resolvedNode;
                         }
                         (0, import_queue_microtask2.default)(function() {
-                            return _this.runAsyncNode(node, options);
+                            return _this.runAsyncNode(node, context, options);
                         });
                         return node;
                     });
@@ -7852,7 +7852,7 @@ var AsyncNodePlugin = function() {
             },
             {
                 key: "runAsyncNode",
-                value: function runAsyncNode(node, options) {
+                value: function runAsyncNode(node, context, options) {
                     var _this = this;
                     return _async_to_generator(function() {
                         var _this_basePlugin, result, e, _this_basePlugin1, _options_logger, error, result1, _this_basePlugin_getPlayerInstance, _this_basePlugin2, playerState;
@@ -7868,12 +7868,12 @@ var AsyncNodePlugin = function() {
                                     return [
                                         4,
                                         (_this_basePlugin = _this.basePlugin) === null || _this_basePlugin === void 0 ? void 0 : _this_basePlugin.hooks.onAsyncNode.call(node, function(result2) {
-                                            _this.parseNodeAndUpdate(node, result2, options, _this.currentView);
+                                            _this.parseNodeAndUpdate(node, context, result2, options, _this.currentView);
                                         })
                                     ];
                                 case 1:
                                     result = _state.sent();
-                                    _this.parseNodeAndUpdate(node, result, options, _this.currentView);
+                                    _this.parseNodeAndUpdate(node, context, result, options, _this.currentView);
                                     return [
                                         3,
                                         3
@@ -7893,7 +7893,7 @@ var AsyncNodePlugin = function() {
                                         ];
                                     }
                                     (_options_logger = options.logger) === null || _options_logger === void 0 ? void 0 : _options_logger.error("Async node handling failed and resolved with a fallback. Error:", error);
-                                    _this.parseNodeAndUpdate(node, result1, options, _this.currentView);
+                                    _this.parseNodeAndUpdate(node, context, result1, options, _this.currentView);
                                     return [
                                         3,
                                         3
@@ -7953,9 +7953,15 @@ var AsyncNodePlugin = function() {
             {
                 key: "apply",
                 value: function apply(view) {
+                    var _this = this;
                     this.currentView = view;
+                    var context = {
+                        nodeResolveCache: /* @__PURE__ */ new Map()
+                    };
                     view.hooks.parser.tap("async", this.applyParser.bind(this));
-                    view.hooks.resolver.tap("async", this.applyResolver.bind(this));
+                    view.hooks.resolver.tap("async", function(resolver) {
+                        _this.applyResolver(resolver, context);
+                    });
                 }
             },
             {