@player-ui/async-node-plugin 0.11.3--canary.666.23690 → 0.11.3--canary.642.23780

package/dist/AsyncNodePlugin.native.js

@@ -7731,8 +7731,7 @@ var AsyncNodePlugin = function() {
             var _this = this;
             _class_call_check(this, AsyncNodePlugin);
             this.hooks = {
-                onAsyncNode: new AsyncParallelBailHook(),
-                onAsyncNodeError: new SyncBailHook()
+                onAsyncNode: new AsyncParallelBailHook()
             };
             this.name = "AsyncNode";
             if (options === null || options === void 0 ? void 0 : options.plugins) {
@@ -7766,17 +7765,10 @@ var AsyncNodePlugin = function() {
             }
         }
         _create_class(AsyncNodePlugin, [
-            {
-                key: "getPlayerInstance",
-                value: function getPlayerInstance() {
-                    return this.playerInstance;
-                }
-            },
             {
                 key: "apply",
                 value: function apply(player) {
                     var _this = this;
-                    this.playerInstance = player;
                     player.hooks.viewController.tap(this.name, function(viewController) {
                         viewController.hooks.view.tap(_this.name, function(view) {
                             var _this_plugins;
@@ -7800,30 +7792,19 @@ var AsyncNodePlugin = function() {
         _create_class(AsyncNodePluginPlugin, [
             {
                 /**
-     * 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.
-     */ key: "parseNodeAndUpdate",
-                value: function parseNodeAndUpdate(node, result, options, view) {
-                    var parsedNode = options.parseNode && result ? options.parseNode(result) : void 0;
-                    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 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.
      */ 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, result, options, view) {
+                    var parsedNode = options.parseNode && result ? options.parseNode(result) : void 0;
+                    if (this.resolvedMapping.get(node.id) !== parsedNode) {
+                        this.resolvedMapping.set(node.id, parsedNode ? parsedNode : node);
                         view === null || view === void 0 ? void 0 : view.updateAsync();
                     }
                 }
@@ -7838,77 +7819,44 @@ var AsyncNodePlugin = function() {
                 value: function applyResolver(resolver) {
                     var _this = this;
                     resolver.hooks.beforeResolve.tap(this.name, function(node, options) {
-                        if (!_this.isAsync(node)) {
-                            return node;
+                        var resolvedNode;
+                        if (_this.isAsync(node)) {
+                            var mappedValue = _this.resolvedMapping.get(node.id);
+                            if (mappedValue) {
+                                resolvedNode = mappedValue;
+                            }
+                        } else {
+                            resolvedNode = null;
                         }
-                        var resolvedNode = _this.resolvedMapping.get(node.id);
-                        if (resolvedNode !== void 0) {
-                            return resolvedNode;
+                        var newNode = resolvedNode || node;
+                        if (!resolvedNode && (node === null || node === void 0 ? void 0 : node.type) === NodeType.Async) {
+                            var _this1 = _this;
+                            (0, import_queue_microtask2.default)(/*#__PURE__*/ _async_to_generator(function() {
+                                var _this_basePlugin, result;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                (_this_basePlugin = _this1.basePlugin) === null || _this_basePlugin === void 0 ? void 0 : _this_basePlugin.hooks.onAsyncNode.call(node, function(result2) {
+                                                    _this1.handleAsyncUpdate(node, result2, options, _this1.currentView);
+                                                })
+                                            ];
+                                        case 1:
+                                            result = _state.sent();
+                                            _this1.handleAsyncUpdate(node, result, options, _this1.currentView);
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            }));
+                            return node;
                         }
-                        (0, import_queue_microtask2.default)(function() {
-                            return _this.runAsyncNode(node, options);
-                        });
-                        return node;
+                        return newNode;
                     });
                 }
             },
-            {
-                key: "runAsyncNode",
-                value: function runAsyncNode(node, 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;
-                        return _ts_generator(this, function(_state) {
-                            switch(_state.label){
-                                case 0:
-                                    _state.trys.push([
-                                        0,
-                                        2,
-                                        ,
-                                        3
-                                    ]);
-                                    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);
-                                        })
-                                    ];
-                                case 1:
-                                    result = _state.sent();
-                                    _this.parseNodeAndUpdate(node, result, options, _this.currentView);
-                                    return [
-                                        3,
-                                        3
-                                    ];
-                                case 2:
-                                    e = _state.sent();
-                                    error = _instanceof(e, Error) ? e : new Error(String(e));
-                                    result1 = (_this_basePlugin1 = _this.basePlugin) === null || _this_basePlugin1 === void 0 ? void 0 : _this_basePlugin1.hooks.onAsyncNodeError.call(error, node);
-                                    if (result1 === void 0) {
-                                        ;
-                                        playerState = (_this_basePlugin2 = _this.basePlugin) === null || _this_basePlugin2 === void 0 ? void 0 : (_this_basePlugin_getPlayerInstance = _this_basePlugin2.getPlayerInstance()) === null || _this_basePlugin_getPlayerInstance === void 0 ? void 0 : _this_basePlugin_getPlayerInstance.getState();
-                                        if ((playerState === null || playerState === void 0 ? void 0 : playerState.status) === "in-progress") {
-                                            playerState.fail(error);
-                                        }
-                                        return [
-                                            2
-                                        ];
-                                    }
-                                    (_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.handleAsyncUpdate(node, result1, _this.currentView);
-                                    return [
-                                        3,
-                                        3
-                                    ];
-                                case 3:
-                                    return [
-                                        2
-                                    ];
-                            }
-                        });
-                    })();
-                }
-            },
             {
                 key: "isAsync",
                 value: function isAsync(node) {