@player-ui/async-node-plugin 0.8.0-next.3 → 0.8.0-next.4

package/dist/AsyncNodePlugin.native.js

@@ -7563,38 +7563,32 @@ var AsyncNodePlugin = function() {
         }
         _create_class(AsyncNodePluginPlugin, [
             {
-                key: "isAsync",
-                value: function isAsync(node) {
-                    return (node === null || node === void 0 ? void 0 : node.type) === NodeType.Async;
-                }
-            },
-            {
-                key: "applyParser",
-                value: function applyParser(parser) {
-                    parser.hooks.determineNodeType.tap(this.name, function(obj) {
-                        if (Object.prototype.hasOwnProperty.call(obj, "async")) {
-                            return NodeType.Async;
-                        }
-                    });
-                    parser.hooks.parseNode.tap(this.name, function(obj, nodeType, options, determinedNodeType) {
-                        if (determinedNodeType === NodeType.Async) {
-                            var parsedAsync = parser.parseObject((0, import_timm10.omit)(obj, "async"), nodeType, options);
-                            var parsedNodeId = getNodeID(parsedAsync);
-                            if (parsedAsync !== null && parsedNodeId) {
-                                return parser.createASTNode({
-                                    id: parsedNodeId,
-                                    type: NodeType.Async,
-                                    value: parsedAsync
-                                }, obj);
-                            }
-                            return null;
-                        }
-                    });
+                /**
+     * 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 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, 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();
+                    }
                 }
             },
             {
-                key: "applyResolverHooks",
-                value: function applyResolverHooks(resolver) {
+                /**
+     * Handles the asynchronous API integration for resolving nodes.
+     * This method sets up a hook on the resolver's `beforeResolve` event to process async nodes.
+     * @param resolver The resolver instance to attach the hook to.
+     * @param view
+     */ key: "applyResolver",
+                value: function applyResolver(resolver) {
                     var _this = this;
                     resolver.hooks.beforeResolve.tap(this.name, function(node, options) {
                         var resolvedNode;
@@ -7610,22 +7604,19 @@ var AsyncNodePlugin = function() {
                         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, parsedNode, _this_currentView;
+                                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)
+                                                (_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();
-                                            parsedNode = options.parseNode && result ? options.parseNode(result) : void 0;
-                                            if (parsedNode) {
-                                                ;
-                                                _this1.resolvedMapping.set(node.id, parsedNode);
-                                                (_this_currentView = _this1.currentView) === null || _this_currentView === void 0 ? void 0 : _this_currentView.updateAsync();
-                                            }
+                                            _this1.handleAsyncUpdate(node, result, options, _this1.currentView);
                                             return [
                                                 2
                                             ];
@@ -7639,51 +7630,43 @@ var AsyncNodePlugin = function() {
                 }
             },
             {
-                key: "apply",
-                value: function apply(view) {
-                    var _this = this;
-                    view.hooks.parser.tap("template", this.applyParser.bind(this));
-                    view.hooks.resolver.tap("template", function(resolver) {
-                        resolver.hooks.beforeResolve.tap(_this.name, function(node, options) {
-                            var resolvedNode;
-                            if (_this.isAsync(node)) {
-                                var mappedValue = _this.resolvedMapping.get(node.id);
-                                if (mappedValue) {
-                                    resolvedNode = mappedValue;
-                                }
-                            } else {
-                                resolvedNode = null;
-                            }
-                            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, parsedNode;
-                                    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)
-                                                ];
-                                            case 1:
-                                                result = _state.sent();
-                                                parsedNode = options.parseNode && result ? options.parseNode(result) : void 0;
-                                                _this1.resolvedMapping.set(node.id, parsedNode ? parsedNode : node);
-                                                view.updateAsync();
-                                                return [
-                                                    2
-                                                ];
-                                        }
-                                    });
-                                }));
-                                return node;
+                key: "isAsync",
+                value: function isAsync(node) {
+                    return (node === null || node === void 0 ? void 0 : node.type) === NodeType.Async;
+                }
+            },
+            {
+                key: "applyParser",
+                value: function applyParser(parser) {
+                    parser.hooks.determineNodeType.tap(this.name, function(obj) {
+                        if (Object.prototype.hasOwnProperty.call(obj, "async")) {
+                            return NodeType.Async;
+                        }
+                    });
+                    parser.hooks.parseNode.tap(this.name, function(obj, nodeType, options, determinedNodeType) {
+                        if (determinedNodeType === NodeType.Async) {
+                            var parsedAsync = parser.parseObject((0, import_timm10.omit)(obj, "async"), nodeType, options);
+                            var parsedNodeId = getNodeID(parsedAsync);
+                            if (parsedAsync !== null && parsedNodeId) {
+                                return parser.createASTNode({
+                                    id: parsedNodeId,
+                                    type: NodeType.Async,
+                                    value: parsedAsync
+                                }, obj);
                             }
-                            return newNode;
-                        });
+                            return null;
+                        }
                     });
                 }
             },
+            {
+                key: "apply",
+                value: function apply(view) {
+                    this.currentView = view;
+                    view.hooks.parser.tap("async", this.applyParser.bind(this));
+                    view.hooks.resolver.tap("async", this.applyResolver.bind(this));
+                }
+            },
             {
                 key: "applyPlugin",
                 value: function applyPlugin(asyncNodePlugin) {