@player-ui/async-node-plugin 0.7.5--canary.452.15858 → 0.7.42--canary.443.15975

package/dist/AsyncNodePlugin.native.js

@@ -2622,12 +2622,6 @@ var AsyncNodePlugin = function() {
                 value: function clear() {
                     this.store = createSortedArray();
                 }
-            },
-            {
-                /** Check if the registry is empty*/ key: "isRegistryEmpty",
-                value: function isRegistryEmpty() {
-                    return this.store.array.length === 0;
-                }
             }
         ]);
         return Registry;
@@ -7563,32 +7557,38 @@ var AsyncNodePlugin = function() {
         }
         _create_class(AsyncNodePluginPlugin, [
             {
-                /**
-     * 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: "isAsync",
+                value: function isAsync(node) {
+                    return (node === null || node === void 0 ? void 0 : node.type) === NodeType.Async;
                 }
             },
             {
-                /**
-     * 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) {
+                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;
+                        }
+                    });
+                }
+            },
+            {
+                key: "applyResolverHooks",
+                value: function applyResolverHooks(resolver) {
                     var _this = this;
                     resolver.hooks.beforeResolve.tap(this.name, function(node, options) {
                         var resolvedNode;
@@ -7604,19 +7604,22 @@ 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;
+                                var _this_basePlugin, result, parsedNode, _this_currentView;
                                 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);
-                                                })
+                                                (_this_basePlugin = _this1.basePlugin) === null || _this_basePlugin === void 0 ? void 0 : _this_basePlugin.hooks.onAsyncNode.call(node)
                                             ];
                                         case 1:
                                             result = _state.sent();
-                                            _this1.handleAsyncUpdate(node, result, options, _this1.currentView);
+                                            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();
+                                            }
                                             return [
                                                 2
                                             ];
@@ -7629,42 +7632,50 @@ var AsyncNodePlugin = function() {
                     });
                 }
             },
-            {
-                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;
-                        }
-                    });
-                }
-            },
             {
                 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));
+                    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;
+                            }
+                            return newNode;
+                        });
+                    });
                 }
             },
             {