@player-ui/async-node-plugin 0.7.5--canary.443.15842 → 0.7.5-next.0

package/dist/AsyncNodePlugin.native.js

@@ -1354,8 +1354,16 @@ var AsyncNodePlugin = function() {
         }
         return targetMap;
     };
-    var hasAsync = function hasAsync(obj) {
-        return Object.prototype.hasOwnProperty.call(obj, "async");
+    var hasTemplateValues = function hasTemplateValues(obj, localKey) {
+        return Object.hasOwnProperty.call(obj, "template") && Array.isArray(obj === null || obj === void 0 ? void 0 : obj.template) && obj.template.length && obj.template.find(function(tmpl) {
+            return tmpl.output === localKey;
+        });
+    };
+    var hasSwitchKey = function hasSwitchKey(localKey) {
+        return localKey === "staticSwitch" || localKey === "dynamicSwitch";
+    };
+    var hasTemplateKey = function hasTemplateKey(localKey) {
+        return localKey === "template";
     };
     var getNodeID = function getNodeID(node) {
         var _node_value;
@@ -1645,7 +1653,7 @@ var AsyncNodePlugin = function() {
             exports.merge = merge;
             exports.mergeDeep = mergeDeep;
             exports.mergeIn = mergeIn;
-            exports.omit = omit5;
+            exports.omit = omit4;
             exports.addDefaults = addDefaults;
             exports.default = void 0;
             var INVALID_ARGS = "INVALID_ARGS";
@@ -1819,7 +1827,7 @@ var AsyncNodePlugin = function() {
                 }
                 return setIn8(a, path, nextVal);
             }
-            function omit5(obj, attrs) {
+            function omit4(obj, attrs) {
                 var omitList = Array.isArray(attrs) ? attrs : [
                     attrs
                 ];
@@ -1905,7 +1913,7 @@ var AsyncNodePlugin = function() {
                 merge: merge,
                 mergeDeep: mergeDeep,
                 mergeIn: mergeIn,
-                omit: omit5,
+                omit: omit4,
                 addDefaults: addDefaults
             };
             var _default = timm;
@@ -2622,6 +2630,12 @@ 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;
@@ -4341,7 +4355,6 @@ var AsyncNodePlugin = function() {
          *   If undefined, the original value is used.
          *   If null, we ignore this node all together
          */ onCreateASTNode: new SyncWaterfallHook(),
-                determineNodeType: new SyncBailHook(),
                 parseNode: new SyncBailHook()
             };
         }
@@ -4356,21 +4369,6 @@ var AsyncNodePlugin = function() {
                     return viewNode;
                 }
             },
-            {
-                key: "parseAsync",
-                value: function parseAsync(obj, type, options) {
-                    var parsedAsync = this.parseObject((0, import_timm5.omit)(obj, "async"), type, options);
-                    var parsedNodeId = getNodeID(parsedAsync);
-                    if (parsedAsync !== null && parsedNodeId) {
-                        return this.createASTNode({
-                            id: parsedNodeId,
-                            type: "async",
-                            value: parsedAsync
-                        }, obj);
-                    }
-                    return null;
-                }
-            },
             {
                 key: "createASTNode",
                 value: function createASTNode(node, value) {
@@ -4381,25 +4379,6 @@ var AsyncNodePlugin = function() {
                     return tapped;
                 }
             },
-            {
-                /**
-     * Checks if there are templated values in the object
-     *
-     * @param obj - The Parsed Object to check to see if we have a template array type for
-     * @param localKey - The key being checked
-     */ key: "hasTemplateValues",
-                value: function hasTemplateValues(obj, localKey) {
-                    return Object.hasOwnProperty.call(obj, "template") && Array.isArray(obj === null || obj === void 0 ? void 0 : obj.template) && obj.template.length && obj.template.find(function(tmpl) {
-                        return tmpl.output === localKey;
-                    });
-                }
-            },
-            {
-                key: "hasSwitchKey",
-                value: function hasSwitchKey(localKey) {
-                    return localKey === "staticSwitch";
-                }
-            },
             {
                 key: "parseObject",
                 value: function parseObject(obj) {
@@ -4407,12 +4386,9 @@ var AsyncNodePlugin = function() {
                         templateDepth: 0
                     };
                     var _this = this;
-                    var nodeType = this.hooks.determineNodeType.call(obj);
-                    if (nodeType !== void 0) {
-                        var parsedNode = this.hooks.parseNode.call(obj, type, options, nodeType);
-                        if (parsedNode) {
-                            return parsedNode;
-                        }
+                    var parsedNode = this.hooks.parseNode.call(obj, type, options);
+                    if (parsedNode || parsedNode === null) {
+                        return parsedNode;
                     }
                     var parseLocalObject = function(currentValue, objToParse) {
                         var path = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [];
@@ -4442,166 +4418,42 @@ var AsyncNodePlugin = function() {
                             value: currentValue
                         };
                         var newValue = objEntries.reduce(function(accumulation, current) {
-                            var children2 = accumulation.children, rest = _object_without_properties(accumulation, [
-                                "children"
-                            ]);
+                            var value2 = accumulation.value;
+                            var children2 = accumulation.children;
                             var _current = _sliced_to_array(current, 2), localKey = _current[0], localValue = _current[1];
-                            if (localKey === "asset" && typeof localValue === "object") {
-                                var assetAST = _this.parseObject(localValue, "asset", options);
-                                if (assetAST) {
-                                    return _object_spread_props(_object_spread({}, rest), {
-                                        children: _to_consumable_array(children2).concat([
-                                            {
-                                                path: _to_consumable_array(path).concat([
-                                                    "asset"
-                                                ]),
-                                                value: assetAST
-                                            }
-                                        ])
-                                    });
-                                }
-                            } else if (_this.hooks.determineNodeType.call(localKey) === "template" && Array.isArray(localValue)) {
-                                var templateChildren = localValue.map(function(template) {
-                                    var _options_templateDepth, _template_dynamic;
-                                    var templateAST = _this.hooks.onCreateASTNode.call({
-                                        type: "template",
-                                        depth: (_options_templateDepth = options.templateDepth) !== null && _options_templateDepth !== void 0 ? _options_templateDepth : 0,
-                                        data: template.data,
-                                        template: template.value,
-                                        dynamic: (_template_dynamic = template.dynamic) !== null && _template_dynamic !== void 0 ? _template_dynamic : false
-                                    }, template);
-                                    if ((templateAST === null || templateAST === void 0 ? void 0 : templateAST.type) === "multi-node") {
-                                        templateAST.values.forEach(function(v) {
-                                            v.parent = templateAST;
-                                        });
-                                    }
-                                    if (templateAST) {
-                                        return {
-                                            path: _to_consumable_array(path).concat([
-                                                template.output
-                                            ]),
-                                            value: templateAST
-                                        };
-                                    }
-                                    return;
-                                }).filter(function(element) {
-                                    return !!element;
-                                });
-                                return _object_spread_props(_object_spread({}, rest), {
-                                    children: _to_consumable_array(children2).concat(_to_consumable_array(templateChildren))
-                                });
-                            } else if (localValue && _this.hooks.determineNodeType.call(localValue) === "switch" || _this.hasSwitchKey(localKey)) {
-                                var _localSwitch_children;
-                                var localSwitch = _this.hooks.parseNode.call(_this.hasSwitchKey(localKey) ? _define_property({}, localKey, localValue) : localValue, "value", options, "switch");
-                                if (localSwitch && localSwitch.type === "value" && ((_localSwitch_children = localSwitch.children) === null || _localSwitch_children === void 0 ? void 0 : _localSwitch_children.length) === 1 && localSwitch.value === void 0) {
-                                    var firstChild = localSwitch.children[0];
-                                    return _object_spread_props(_object_spread({}, rest), {
-                                        children: _to_consumable_array(children2).concat([
-                                            {
-                                                path: _to_consumable_array(path).concat([
-                                                    localKey
-                                                ], _to_consumable_array(firstChild.path)),
-                                                value: firstChild.value
-                                            }
-                                        ])
-                                    });
-                                }
-                                if (localSwitch) {
-                                    return _object_spread_props(_object_spread({}, rest), {
-                                        children: _to_consumable_array(children2).concat([
-                                            {
-                                                path: _to_consumable_array(path).concat([
-                                                    localKey
-                                                ]),
-                                                value: localSwitch
-                                            }
-                                        ])
-                                    });
-                                }
-                            } else if (localValue && hasAsync(localValue)) {
-                                var localAsync = _this.parseAsync(localValue, "value", options);
-                                if (localAsync) {
-                                    children2.push({
-                                        path: _to_consumable_array(path).concat([
-                                            localKey
-                                        ]),
-                                        value: localAsync
-                                    });
-                                }
-                            } else if (localValue && Array.isArray(localValue)) {
-                                var childValues = localValue.map(function(childVal) {
-                                    return _this.parseObject(childVal, "value", options);
-                                }).filter(function(child) {
-                                    return !!child;
-                                });
-                                if (childValues.length > 0) {
-                                    var multiNode = _this.hooks.onCreateASTNode.call({
-                                        type: "multi-node",
-                                        override: !_this.hasTemplateValues(localObj, localKey),
-                                        values: childValues
-                                    }, localValue);
-                                    if ((multiNode === null || multiNode === void 0 ? void 0 : multiNode.type) === "multi-node") {
-                                        multiNode.values.forEach(function(v) {
-                                            v.parent = multiNode;
-                                        });
-                                    }
-                                    if (multiNode) {
-                                        return _object_spread_props(_object_spread({}, rest), {
-                                            children: _to_consumable_array(children2).concat([
-                                                {
-                                                    path: _to_consumable_array(path).concat([
-                                                        localKey
-                                                    ]),
-                                                    value: multiNode
-                                                }
-                                            ])
-                                        });
-                                    }
-                                }
+                            var newChildren = _this.hooks.parseNode.call(localValue, "value", options, {
+                                path: path,
+                                key: localKey,
+                                parentObj: localObj
+                            });
+                            if (newChildren) {
+                                var _children2;
+                                (_children2 = children2).push.apply(_children2, _to_consumable_array(newChildren));
                             } else if (localValue && typeof localValue === "object") {
-                                var determineNodeType = _this.hooks.determineNodeType.call(localValue);
-                                if (determineNodeType === "applicability") {
-                                    var parsedNode = _this.hooks.parseNode.call(localValue, "value", options, determineNodeType);
-                                    if (parsedNode) {
-                                        return _object_spread_props(_object_spread({}, rest), {
-                                            children: _to_consumable_array(children2).concat([
-                                                {
-                                                    path: _to_consumable_array(path).concat([
-                                                        localKey
-                                                    ]),
-                                                    value: parsedNode
-                                                }
-                                            ])
-                                        });
-                                    }
-                                } else {
-                                    var result = parseLocalObject(accumulation.value, localValue, _to_consumable_array(path).concat([
-                                        localKey
-                                    ]));
-                                    return {
-                                        value: result.value,
-                                        children: _to_consumable_array(children2).concat(_to_consumable_array(result.children))
-                                    };
-                                }
+                                var _children21;
+                                var result = parseLocalObject(accumulation.value, localValue, _to_consumable_array(path).concat([
+                                    localKey
+                                ]));
+                                value2 = result.value;
+                                (_children21 = children2).push.apply(_children21, _to_consumable_array(result.children));
                             } else {
-                                var value2 = (0, import_timm5.setIn)(accumulation.value, _to_consumable_array(path).concat([
+                                value2 = (0, import_timm5.setIn)(accumulation.value, _to_consumable_array(path).concat([
                                     localKey
                                 ]), localValue);
-                                return {
-                                    children: children2,
-                                    value: value2
-                                };
                             }
-                            return accumulation;
+                            return {
+                                value: value2,
+                                children: children2
+                            };
                         }, defaultValue);
                         return newValue;
                     };
                     var _parseLocalObject = parseLocalObject(void 0, obj), value = _parseLocalObject.value, children = _parseLocalObject.children;
-                    var baseAst = value === void 0 && children.length === 0 ? void 0 : {
+                    var baseAst = value === void 0 && !children.length ? void 0 : {
                         type: type,
                         value: value
                     };
-                    if (baseAst !== void 0 && children.length > 0) {
+                    if (baseAst && children.length) {
                         var parent = baseAst;
                         parent.children = children;
                         children.forEach(function(child) {
@@ -5089,24 +4941,30 @@ var AsyncNodePlugin = function() {
                         }
                         return node;
                     });
-                    parser.hooks.determineNodeType.tap("template", function(obj) {
-                        if (obj === "template") {
-                            return "template";
-                        }
-                    });
-                    parser.hooks.parseNode.tap("template", function(obj, _nodeType, options, determinedNodeType) {
-                        if (determinedNodeType === "template") {
-                            var _options_templateDepth, _obj_dynamic;
-                            var templateNode = parser.createASTNode({
-                                type: "template",
-                                depth: (_options_templateDepth = options.templateDepth) !== null && _options_templateDepth !== void 0 ? _options_templateDepth : 0,
-                                data: obj.data,
-                                template: obj.value,
-                                dynamic: (_obj_dynamic = obj.dynamic) !== null && _obj_dynamic !== void 0 ? _obj_dynamic : false
-                            }, obj);
-                            if (templateNode) {
-                                return templateNode;
-                            }
+                    parser.hooks.parseNode.tap("template", function(obj, _nodeType, options, childOptions) {
+                        if (childOptions && hasTemplateKey(childOptions.key)) {
+                            return obj.map(function(template) {
+                                var _options_templateDepth, _template_dynamic;
+                                var templateAST = parser.createASTNode({
+                                    type: "template",
+                                    depth: (_options_templateDepth = options.templateDepth) !== null && _options_templateDepth !== void 0 ? _options_templateDepth : 0,
+                                    data: template.data,
+                                    template: template.value,
+                                    dynamic: (_template_dynamic = template.dynamic) !== null && _template_dynamic !== void 0 ? _template_dynamic : false
+                                }, template);
+                                if (!templateAST) return;
+                                if (templateAST.type === "multi-node") {
+                                    templateAST.values.forEach(function(v) {
+                                        v.parent = templateAST;
+                                    });
+                                }
+                                return {
+                                    path: _to_consumable_array(childOptions.path).concat([
+                                        template.output
+                                    ]),
+                                    value: templateAST
+                                };
+                            }).filter(Boolean);
                         }
                     });
                 }
@@ -5250,6 +5108,12 @@ var AsyncNodePlugin = function() {
             _class_call_check(this, ApplicabilityPlugin);
         }
         _create_class(ApplicabilityPlugin, [
+            {
+                key: "isApplicability",
+                value: function isApplicability(obj) {
+                    return obj && Object.prototype.hasOwnProperty.call(obj, "applicability");
+                }
+            },
             {
                 key: "applyResolver",
                 value: function applyResolver(resolver) {
@@ -5269,25 +5133,32 @@ var AsyncNodePlugin = function() {
             {
                 key: "applyParser",
                 value: function applyParser(parser) {
-                    parser.hooks.determineNodeType.tap("applicability", function(obj) {
-                        if (Object.prototype.hasOwnProperty.call(obj, "applicability")) {
-                            return "applicability";
-                        }
-                    });
-                    parser.hooks.parseNode.tap("applicability", function(obj, nodeType, options, determinedNodeType) {
-                        if (determinedNodeType === "applicability") {
+                    var _this = this;
+                    parser.hooks.parseNode.tap("applicability", function(obj, nodeType, options, childOptions) {
+                        if (_this.isApplicability(obj)) {
                             var parsedApplicability = parser.parseObject((0, import_timm7.omit)(obj, "applicability"), nodeType, options);
-                            if (parsedApplicability !== null) {
-                                var applicabilityNode = parser.createASTNode({
-                                    type: "applicability",
-                                    expression: obj.applicability,
-                                    value: parsedApplicability
-                                }, obj);
-                                if ((applicabilityNode === null || applicabilityNode === void 0 ? void 0 : applicabilityNode.type) === "applicability") {
-                                    applicabilityNode.value.parent = applicabilityNode;
-                                }
-                                return applicabilityNode;
+                            if (!parsedApplicability) {
+                                return childOptions ? [] : null;
+                            }
+                            var applicabilityNode = parser.createASTNode({
+                                type: "applicability",
+                                expression: obj.applicability,
+                                value: parsedApplicability
+                            }, obj);
+                            if (!applicabilityNode) {
+                                return childOptions ? [] : null;
                             }
+                            if (applicabilityNode.type === "applicability") {
+                                applicabilityNode.value.parent = applicabilityNode;
+                            }
+                            return childOptions ? [
+                                {
+                                    path: _to_consumable_array(childOptions.path).concat([
+                                        childOptions.key
+                                    ]),
+                                    value: applicabilityNode
+                                }
+                            ] : applicabilityNode;
                         }
                     });
                 }
@@ -5337,6 +5208,12 @@ var AsyncNodePlugin = function() {
                     return EMPTY_NODE;
                 }
             },
+            {
+                key: "isSwitch",
+                value: function isSwitch(obj) {
+                    return obj && (Object.prototype.hasOwnProperty.call(obj, "dynamicSwitch") || Object.prototype.hasOwnProperty.call(obj, "staticSwitch"));
+                }
+            },
             {
                 key: "applyParser",
                 value: function applyParser(parser) {
@@ -5347,42 +5224,56 @@ var AsyncNodePlugin = function() {
                         }
                         return node;
                     });
-                    parser.hooks.determineNodeType.tap("switch", function(obj) {
-                        if (Object.prototype.hasOwnProperty.call(obj, "dynamicSwitch") || Object.prototype.hasOwnProperty.call(obj, "staticSwitch")) {
-                            return "switch";
-                        }
-                    });
-                    parser.hooks.parseNode.tap("switch", function(obj, _nodeType, options, determinedNodeType) {
-                        if (determinedNodeType === "switch") {
-                            var dynamic = "dynamicSwitch" in obj;
-                            var switchContent = "dynamicSwitch" in obj ? obj.dynamicSwitch : obj.staticSwitch;
-                            var cases = [];
-                            switchContent.forEach(function(switchCase) {
+                    parser.hooks.parseNode.tap("switch", function(obj, _nodeType, options, childOptions) {
+                        if (_this.isSwitch(obj) || childOptions && hasSwitchKey(childOptions.key)) {
+                            var objToParse = childOptions && hasSwitchKey(childOptions.key) ? _define_property({}, childOptions.key, obj) : obj;
+                            var dynamic = "dynamicSwitch" in objToParse;
+                            var switchContent = dynamic ? objToParse.dynamicSwitch : objToParse.staticSwitch;
+                            var cases = switchContent.map(function(switchCase) {
                                 var switchCaseExpr = switchCase.case, switchBody = _object_without_properties(switchCase, [
                                     "case"
                                 ]);
                                 var value = parser.parseObject(switchBody, "value", options);
                                 if (value) {
-                                    cases.push({
+                                    return {
                                         case: switchCaseExpr,
                                         value: value
-                                    });
+                                    };
                                 }
-                            });
-                            var switchAST = parser.hooks.onCreateASTNode.call({
+                                return;
+                            }).filter(Boolean);
+                            var switchAST = parser.createASTNode({
                                 type: "switch",
                                 dynamic: dynamic,
                                 cases: cases
-                            }, obj);
-                            if ((switchAST === null || switchAST === void 0 ? void 0 : switchAST.type) === "switch") {
+                            }, objToParse);
+                            if (!switchAST || switchAST.type === "empty") {
+                                return childOptions ? [] : null;
+                            }
+                            if (switchAST.type === "switch") {
                                 switchAST.cases.forEach(function(sCase) {
                                     sCase.value.parent = switchAST;
                                 });
                             }
-                            if ((switchAST === null || switchAST === void 0 ? void 0 : switchAST.type) === "empty") {
-                                return null;
+                            if (childOptions) {
+                                var _switchAST_children;
+                                var path = _to_consumable_array(childOptions.path).concat([
+                                    childOptions.key
+                                ]);
+                                var value = switchAST;
+                                if (switchAST.type === "value" && ((_switchAST_children = switchAST.children) === null || _switchAST_children === void 0 ? void 0 : _switchAST_children.length) === 1 && switchAST.value === void 0) {
+                                    var firstChild = switchAST.children[0];
+                                    path = _to_consumable_array(path).concat(_to_consumable_array(firstChild.path));
+                                    value = firstChild.value;
+                                }
+                                return [
+                                    {
+                                        path: path,
+                                        value: value
+                                    }
+                                ];
                             }
-                            return switchAST !== null && switchAST !== void 0 ? switchAST : null;
+                            return switchAST;
                         }
                     });
                 }
@@ -5409,6 +5300,93 @@ var AsyncNodePlugin = function() {
         ]);
         return SwitchPlugin;
     }();
+    var MultiNodePlugin = /*#__PURE__*/ function() {
+        function MultiNodePlugin() {
+            _class_call_check(this, MultiNodePlugin);
+        }
+        _create_class(MultiNodePlugin, [
+            {
+                key: "applyParser",
+                value: function applyParser(parser) {
+                    parser.hooks.parseNode.tap("multi-node", function(obj, nodeType, options, childOptions) {
+                        if (childOptions && !hasTemplateKey(childOptions.key) && Array.isArray(obj)) {
+                            var values = obj.map(function(childVal) {
+                                return parser.parseObject(childVal, "value", options);
+                            }).filter(function(child) {
+                                return !!child;
+                            });
+                            if (!values.length) {
+                                return [];
+                            }
+                            var multiNode = parser.createASTNode({
+                                type: "multi-node",
+                                override: !hasTemplateValues(childOptions.parentObj, childOptions.key),
+                                values: values
+                            }, obj);
+                            if (!multiNode) {
+                                return [];
+                            }
+                            if (multiNode.type === "multi-node") {
+                                multiNode.values.forEach(function(v) {
+                                    v.parent = multiNode;
+                                });
+                            }
+                            return [
+                                {
+                                    path: _to_consumable_array(childOptions.path).concat([
+                                        childOptions.key
+                                    ]),
+                                    value: multiNode
+                                }
+                            ];
+                        }
+                    });
+                }
+            },
+            {
+                key: "apply",
+                value: function apply(view) {
+                    view.hooks.parser.tap("multi-node", this.applyParser.bind(this));
+                }
+            }
+        ]);
+        return MultiNodePlugin;
+    }();
+    var AssetPlugin = /*#__PURE__*/ function() {
+        function AssetPlugin() {
+            _class_call_check(this, AssetPlugin);
+        }
+        _create_class(AssetPlugin, [
+            {
+                key: "applyParser",
+                value: function applyParser(parser) {
+                    parser.hooks.parseNode.tap("asset", function(obj, nodeType, options, childOptions) {
+                        if ((childOptions === null || childOptions === void 0 ? void 0 : childOptions.key) === "asset" && typeof obj === "object") {
+                            var assetAST = parser.parseObject(obj, "asset", options);
+                            if (!assetAST) {
+                                return [];
+                            }
+                            return [
+                                {
+                                    path: _to_consumable_array(childOptions.path).concat([
+                                        childOptions.key
+                                    ]),
+                                    value: assetAST
+                                }
+                            ];
+                        }
+                    });
+                }
+            },
+            {
+                key: "apply",
+                value: function apply(view) {
+                    view.hooks.parser.tap("asset", this.applyParser.bind(this));
+                }
+            }
+        ]);
+        return AssetPlugin;
+    }();
     var FlowInstance = /*#__PURE__*/ function() {
         function FlowInstance(id, flow, options) {
             _class_call_check(this, FlowInstance);
@@ -7111,12 +7089,14 @@ var AsyncNodePlugin = function() {
                     player.hooks.viewController.tap(this.name, function(viewController) {
                         viewController.hooks.view.tap(_this.name, function(view) {
                             var pluginOptions = toNodeResolveOptions(view.resolverOptions);
+                            new AssetPlugin().apply(view);
                             new SwitchPlugin(pluginOptions).apply(view);
                             new ApplicabilityPlugin().apply(view);
                             new StringResolverPlugin().apply(view);
                             var templatePlugin = new TemplatePlugin(pluginOptions);
                             templatePlugin.apply(view);
                             view.hooks.onTemplatePluginCreated.call(templatePlugin);
+                            new MultiNodePlugin().apply(view);
                         });
                     });
                 }
@@ -7557,38 +7537,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;
@@ -7604,22 +7578,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
                                             ];
@@ -7633,51 +7604,56 @@ var AsyncNodePlugin = function() {
                 }
             },
             {
-                key: "apply",
-                value: function apply(view) {
+                key: "isAsync",
+                value: function isAsync(node) {
+                    return (node === null || node === void 0 ? void 0 : node.type) === NodeType.Async;
+                }
+            },
+            {
+                key: "isDeterminedAsync",
+                value: function isDeterminedAsync(obj) {
+                    return obj && Object.prototype.hasOwnProperty.call(obj, "async");
+                }
+            },
+            {
+                key: "applyParser",
+                value: function applyParser(parser) {
                     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;
+                    parser.hooks.parseNode.tap(this.name, function(obj, nodeType, options, childOptions) {
+                        if (_this.isDeterminedAsync(obj)) {
+                            var parsedAsync = parser.parseObject((0, import_timm10.omit)(obj, "async"), nodeType, options);
+                            var parsedNodeId = getNodeID(parsedAsync);
+                            if (parsedAsync === null || !parsedNodeId) {
+                                return childOptions ? [] : 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;
+                            var asyncAST = parser.createASTNode({
+                                id: parsedNodeId,
+                                type: NodeType.Async,
+                                value: parsedAsync
+                            }, obj);
+                            if (childOptions) {
+                                return asyncAST ? [
+                                    {
+                                        path: _to_consumable_array(childOptions.path).concat([
+                                            childOptions.key
+                                        ]),
+                                        value: asyncAST
+                                    }
+                                ] : [];
                             }
-                            return newNode;
-                        });
+                            return asyncAST;
+                        }
                     });
                 }
             },
+            {
+                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) {