@player-ui/async-node-plugin 0.13.0-next.7 → 0.14.0-next.0

package/dist/AsyncNodePlugin.native.js

@@ -1454,22 +1454,6 @@ var AsyncNodePlugin = function() {
             }
         });
     };
-    var unpackNode = function unpackNode(item) {
-        var _item_children_, _item_children, _item_children_1, _item_children1;
-        var unpacked = [];
-        if ("children" in item && ((_item_children = item.children) === null || _item_children === void 0 ? void 0 : (_item_children_ = _item_children[0]) === null || _item_children_ === void 0 ? void 0 : _item_children_.value.type) === "asset" && ((_item_children1 = item.children) === null || _item_children1 === void 0 ? void 0 : (_item_children_1 = _item_children1[0]) === null || _item_children_1 === void 0 ? void 0 : _item_children_1.value).children) {
-            var _item_children__value_children_, _item_children__value_children, _item_children_2, _item_children2;
-            if (((_item_children__value_children = ((_item_children2 = item.children) === null || _item_children2 === void 0 ? void 0 : (_item_children_2 = _item_children2[0]) === null || _item_children_2 === void 0 ? void 0 : _item_children_2.value).children) === null || _item_children__value_children === void 0 ? void 0 : (_item_children__value_children_ = _item_children__value_children[0]) === null || _item_children__value_children_ === void 0 ? void 0 : _item_children__value_children_.value.type) === "multi-node") {
-                var _item_children__value_children_1, _item_children__value_children1, _item_children_3, _item_children3;
-                ((_item_children__value_children1 = ((_item_children3 = item.children) === null || _item_children3 === void 0 ? void 0 : (_item_children_3 = _item_children3[0]) === null || _item_children_3 === void 0 ? void 0 : _item_children_3.value).children) === null || _item_children__value_children1 === void 0 ? void 0 : (_item_children__value_children_1 = _item_children__value_children1[0]) === null || _item_children__value_children_1 === void 0 ? void 0 : _item_children__value_children_1.value).values.forEach(function(value) {
-                    unpacked.push(value);
-                });
-            }
-        } else {
-            unpacked.push(item);
-        }
-        return unpacked;
-    };
     var hasSomethingToResolve = function hasSomethingToResolve(str) {
         return bindingResolveLookup(str) || expressionResolveLookup(str);
     };
@@ -1718,7 +1702,7 @@ var AsyncNodePlugin = function() {
             exports.merge = merge;
             exports.mergeDeep = mergeDeep;
             exports.mergeIn = mergeIn;
-            exports.omit = omit4;
+            exports.omit = omit3;
             exports.addDefaults = addDefaults;
             exports.default = void 0;
             var INVALID_ARGS = "INVALID_ARGS";
@@ -1892,7 +1876,7 @@ var AsyncNodePlugin = function() {
                 }
                 return setIn8(a, path, nextVal);
             }
-            function omit4(obj, attrs) {
+            function omit3(obj, attrs) {
                 var omitList = Array.isArray(attrs) ? attrs : [
                     attrs
                 ];
@@ -1978,7 +1962,7 @@ var AsyncNodePlugin = function() {
                 merge: merge,
                 mergeDeep: mergeDeep,
                 mergeIn: mergeIn,
-                omit: omit4,
+                omit: omit3,
                 addDefaults: addDefaults
             };
             var _default = timm;
@@ -2109,6 +2093,9 @@ var AsyncNodePlugin = function() {
         },
         asyncTransform: function() {
             return asyncTransform;
+        },
+        createAsyncTransform: function() {
+            return createAsyncTransform;
         }
     });
     var InterceptionManager = /*#__PURE__*/ function() {
@@ -2799,6 +2786,7 @@ var AsyncNodePlugin = function() {
             }
         };
         var identifier = function() {
+            var allowBoolValue = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
             if (!isIdentifierChar(ch)) {
                 return;
             }
@@ -2809,6 +2797,14 @@ var AsyncNodePlugin = function() {
                 }
                 value += ch;
             }
+            if (allowBoolValue) {
+                if (value === "true") {
+                    return toValue(true);
+                }
+                if (value === "false") {
+                    return toValue(false);
+                }
+            }
             if (value) {
                 var maybeNumber = Number(value);
                 value = isNaN(maybeNumber) ? value : maybeNumber;
@@ -2857,8 +2853,9 @@ var AsyncNodePlugin = function() {
             }
         };
         var simpleSegment = function() {
+            var allowBoolValue = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
             var _nestedPath, _ref;
-            return (_ref = (_nestedPath = nestedPath()) !== null && _nestedPath !== void 0 ? _nestedPath : expression()) !== null && _ref !== void 0 ? _ref : identifier();
+            return (_ref = (_nestedPath = nestedPath()) !== null && _nestedPath !== void 0 ? _nestedPath : expression()) !== null && _ref !== void 0 ? _ref : identifier(allowBoolValue);
         };
         var segment = function() {
             var segments = [];
@@ -2873,6 +2870,7 @@ var AsyncNodePlugin = function() {
             return toConcatenatedNode(segments);
         };
         var optionallyQuotedSegment = function() {
+            var allowBoolValue = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
             whitespace();
             if (ch === SINGLE_QUOTE || ch === DOUBLE_QUOTE) {
                 var singleQuote = ch === SINGLE_QUOTE;
@@ -2881,7 +2879,7 @@ var AsyncNodePlugin = function() {
                 next(singleQuote ? SINGLE_QUOTE : DOUBLE_QUOTE);
                 return id;
             }
-            return simpleSegment();
+            return simpleSegment(allowBoolValue);
         };
         var equals = function() {
             if (ch !== EQUALS) {
@@ -2901,7 +2899,7 @@ var AsyncNodePlugin = function() {
                     whitespace();
                     if (equals()) {
                         whitespace();
-                        var second = optionallyQuotedSegment();
+                        var second = optionallyQuotedSegment(true);
                         value = toQuery(value, second);
                         whitespace();
                     }
@@ -3089,7 +3087,7 @@ var AsyncNodePlugin = function() {
                     appendPathSegments(getValueForNode(resolvedNode));
                     break;
                 case "Value":
-                    appendPathSegments(resolvedNode.value);
+                    appendPathSegments(typeof resolvedNode.value === "boolean" ? String(resolvedNode.value) : resolvedNode.value);
                     break;
                 case "Query":
                     {
@@ -4669,23 +4667,8 @@ var AsyncNodePlugin = function() {
         function Parser() {
             _class_call_check(this, Parser);
             this.hooks = {
-                /**
-         * A hook to interact with an object _before_ parsing it into an AST
-         *
-         * @param value - The object we're are about to parse
-         * @returns - A new value to parse.
-         *  If undefined, the original value is used.
-         *  If null, we stop parsing this node.
-         */ onParseObject: new SyncWaterfallHook(),
-                /**
-         * A callback to interact with an AST _after_ we parse it into the AST
-         *
-         * @param value - The object we parsed
-         * @param node - The AST node we generated
-         * @returns - A new AST node to use
-         *   If undefined, the original value is used.
-         *   If null, we ignore this node all together
-         */ onCreateASTNode: new SyncWaterfallHook(),
+                onParseObject: new SyncWaterfallHook(),
+                onCreateASTNode: new SyncWaterfallHook(),
                 parseNode: new SyncBailHook()
             };
         }
@@ -4827,20 +4810,14 @@ var AsyncNodePlugin = function() {
         function Resolver(root, options) {
             _class_call_check(this, Resolver);
             this.hooks = {
-                /** A hook to allow skipping of the resolution tree for a specific node */ skipResolve: new SyncWaterfallHook(),
-                /** An event emitted before calculating the next update */ beforeUpdate: new SyncHook(),
-                /** An event emitted after calculating the next update */ afterUpdate: new SyncHook(),
-                /** The options passed to a node to resolve it to an object */ resolveOptions: new SyncWaterfallHook(),
-                /** A hook to transform the AST node into a new AST node before resolving it */ beforeResolve: new SyncWaterfallHook(),
-                /**
-         * A hook to transform an AST node into it's resolved value.
-         * This runs _before_ any children are resolved
-         */ resolve: new SyncWaterfallHook(),
-                /**
-         * A hook to transform the resolved value of an AST node.
-         * This runs _after_ all children nodes are resolved
-         */ afterResolve: new SyncWaterfallHook(),
-                /** Called at the very end of a node's tree being updated */ afterNodeUpdate: new SyncHook()
+                skipResolve: new SyncWaterfallHook(),
+                beforeUpdate: new SyncHook(),
+                afterUpdate: new SyncHook(),
+                resolveOptions: new SyncWaterfallHook(),
+                beforeResolve: new SyncWaterfallHook(),
+                resolve: new SyncWaterfallHook(),
+                afterResolve: new SyncWaterfallHook(),
+                afterNodeUpdate: new SyncHook()
             };
             this.root = root;
             this.options = options;
@@ -4848,6 +4825,7 @@ var AsyncNodePlugin = function() {
             this.ASTMap = /* @__PURE__ */ new Map();
             this.logger = options.logger;
             this.idCache = /* @__PURE__ */ new Set();
+            this.AsyncIdMap = /* @__PURE__ */ new Map();
         }
         _create_class(Resolver, [
             {
@@ -4858,13 +4836,27 @@ var AsyncNodePlugin = function() {
             },
             {
                 key: "update",
-                value: function update(changes) {
+                value: function update(changes, asyncChanges) {
+                    var _this = this;
                     this.hooks.beforeUpdate.call(changes);
                     var resolveCache = /* @__PURE__ */ new Map();
                     this.idCache.clear();
                     var prevASTMap = new Map(this.ASTMap);
                     this.ASTMap.clear();
-                    var updated = this.computeTree(this.root, void 0, changes, resolveCache, toNodeResolveOptions(this.options), void 0, prevASTMap);
+                    var prevAsyncIdMap = new Map(this.AsyncIdMap);
+                    var nextAsyncIdMap = /* @__PURE__ */ new Map();
+                    asyncChanges === null || asyncChanges === void 0 ? void 0 : asyncChanges.forEach(function(id) {
+                        var current = prevAsyncIdMap.get(id);
+                        while(current && prevASTMap.has(current)){
+                            var next = prevASTMap.get(current);
+                            if (next && _this.resolveCache.has(next)) {
+                                _this.resolveCache.delete(next);
+                            }
+                            current = current.parent;
+                        }
+                    });
+                    var updated = this.computeTree(this.root, void 0, changes, resolveCache, toNodeResolveOptions(this.options), void 0, prevASTMap, nextAsyncIdMap);
+                    this.AsyncIdMap = nextAsyncIdMap;
                     this.resolveCache = resolveCache;
                     this.hooks.afterUpdate.call(updated.value);
                     return updated.value;
@@ -4918,9 +4910,8 @@ var AsyncNodePlugin = function() {
             },
             {
                 key: "computeTree",
-                value: function computeTree(node, rawParent, dataChanges, cacheUpdate, options, partiallyResolvedParent, prevASTMap) {
+                value: function computeTree(node, rawParent, dataChanges, cacheUpdate, options, partiallyResolvedParent, prevASTMap, nextAsyncIdMap) {
                     var _this = this;
-                    var _partiallyResolvedParent_parent_parent, _partiallyResolvedParent_parent, _resolvedAST_parent, _partiallyResolvedParent_parent1;
                     var dependencyModel = new DependencyModel(options.data.model);
                     dependencyModel.trackSubset("core");
                     var depModelWithParser = withContext(withParser(dependencyModel, this.options.parseBinding));
@@ -4939,15 +4930,6 @@ var AsyncNodePlugin = function() {
                     var previousDeps = previousResult === null || previousResult === void 0 ? void 0 : previousResult.dependencies;
                     var dataChanged = caresAboutDataChanges(dataChanges, previousDeps);
                     var shouldUseLastValue = this.hooks.skipResolve.call(!dataChanged, node, resolveOptions);
-                    var clonedNode = _object_spread_props(_object_spread({}, this.cloneNode(node)), {
-                        parent: partiallyResolvedParent
-                    });
-                    var _this_hooks_beforeResolve_call;
-                    var resolvedAST = (_this_hooks_beforeResolve_call = this.hooks.beforeResolve.call(clonedNode, resolveOptions)) !== null && _this_hooks_beforeResolve_call !== void 0 ? _this_hooks_beforeResolve_call : {
-                        type: "empty"
-                    };
-                    var isNestedMultiNodeWithAsync = resolvedAST.type === "multi-node" && (partiallyResolvedParent === null || partiallyResolvedParent === void 0 ? void 0 : (_partiallyResolvedParent_parent = partiallyResolvedParent.parent) === null || _partiallyResolvedParent_parent === void 0 ? void 0 : (_partiallyResolvedParent_parent_parent = _partiallyResolvedParent_parent.parent) === null || _partiallyResolvedParent_parent_parent === void 0 ? void 0 : _partiallyResolvedParent_parent_parent.type) === "multi-node" && partiallyResolvedParent.parent.type === "value" && ((_resolvedAST_parent = resolvedAST.parent) === null || _resolvedAST_parent === void 0 ? void 0 : _resolvedAST_parent.type) === "asset" && resolvedAST.parent.value.id.includes("async");
-                    var isNestedMultiNode = resolvedAST.type === "multi-node" && (partiallyResolvedParent === null || partiallyResolvedParent === void 0 ? void 0 : (_partiallyResolvedParent_parent1 = partiallyResolvedParent.parent) === null || _partiallyResolvedParent_parent1 === void 0 ? void 0 : _partiallyResolvedParent_parent1.type) === "multi-node" && partiallyResolvedParent.type === "value";
                     if (previousResult && shouldUseLastValue) {
                         var update2 = _object_spread_props(_object_spread({}, previousResult), {
                             updated: false
@@ -4959,6 +4941,30 @@ var AsyncNodePlugin = function() {
                                 updated: false
                             });
                             cacheUpdate.set(AST, resolvedUpdate);
+                            if (resolvedUpdate.node.type === "async") {
+                                nextAsyncIdMap.set(resolvedUpdate.node.id, resolvedUpdate.node);
+                            }
+                            var _resolvedUpdate_node_asyncNodesResolved;
+                            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                            try {
+                                for(var _iterator = ((_resolvedUpdate_node_asyncNodesResolved = resolvedUpdate.node.asyncNodesResolved) !== null && _resolvedUpdate_node_asyncNodesResolved !== void 0 ? _resolvedUpdate_node_asyncNodesResolved : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                    var key = _step.value;
+                                    nextAsyncIdMap.set(key, resolvedUpdate.node);
+                                }
+                            } catch (err) {
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                            } finally{
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                            }
                             var handleChildNode = function(childNode) {
                                 var _prevASTMap_get;
                                 var originalChildNode = (_prevASTMap_get = prevASTMap.get(childNode)) !== null && _prevASTMap_get !== void 0 ? _prevASTMap_get : childNode;
@@ -4981,10 +4987,37 @@ var AsyncNodePlugin = function() {
                         repopulateASTMapFromCache(previousResult, node, rawParent);
                         return update2;
                     }
-                    if (isNestedMultiNodeWithAsync) {
-                        resolvedAST.parent = partiallyResolvedParent.parent;
-                    } else {
-                        resolvedAST.parent = partiallyResolvedParent;
+                    var clonedNode = _object_spread_props(_object_spread({}, this.cloneNode(node)), {
+                        parent: partiallyResolvedParent
+                    });
+                    var _this_hooks_beforeResolve_call;
+                    var resolvedAST = (_this_hooks_beforeResolve_call = this.hooks.beforeResolve.call(clonedNode, resolveOptions)) !== null && _this_hooks_beforeResolve_call !== void 0 ? _this_hooks_beforeResolve_call : {
+                        type: "empty"
+                    };
+                    resolvedAST.parent = partiallyResolvedParent;
+                    if (resolvedAST.type === "async") {
+                        nextAsyncIdMap.set(resolvedAST.id, resolvedAST);
+                    }
+                    var _resolvedAST_asyncNodesResolved;
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = ((_resolvedAST_asyncNodesResolved = resolvedAST.asyncNodesResolved) !== null && _resolvedAST_asyncNodesResolved !== void 0 ? _resolvedAST_asyncNodesResolved : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var id = _step.value;
+                            nextAsyncIdMap.set(id, resolvedAST);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
                     }
                     resolveOptions.node = resolvedAST;
                     this.ASTMap.set(resolvedAST, node);
@@ -4998,7 +5031,7 @@ var AsyncNodePlugin = function() {
                     if ("children" in resolvedAST) {
                         var _resolvedAST_children;
                         var newChildren = (_resolvedAST_children = resolvedAST.children) === null || _resolvedAST_children === void 0 ? void 0 : _resolvedAST_children.map(function(child) {
-                            var computedChildTree = _this.computeTree(child.value, node, dataChanges, cacheUpdate, resolveOptions, resolvedAST, prevASTMap);
+                            var computedChildTree = _this.computeTree(child.value, node, dataChanges, cacheUpdate, resolveOptions, resolvedAST, prevASTMap, nextAsyncIdMap);
                             var childTreeDeps = computedChildTree.dependencies, childNode = computedChildTree.node, childUpdated = computedChildTree.updated, childValue = computedChildTree.value;
                             childTreeDeps.forEach(function(binding) {
                                 return childDependencies.add(binding);
@@ -5019,40 +5052,18 @@ var AsyncNodePlugin = function() {
                         resolvedAST.children = newChildren;
                     } else if (resolvedAST.type === "multi-node") {
                         var childValue = [];
-                        var rawParentToPassIn = isNestedMultiNode ? partiallyResolvedParent === null || partiallyResolvedParent === void 0 ? void 0 : partiallyResolvedParent.parent : node;
-                        var hasAsync = resolvedAST.values.map(function(value, index) {
-                            return value.type === "async" ? index : -1;
-                        }).filter(function(index) {
-                            return index !== -1;
-                        });
-                        var newValues = resolvedAST.values.map(function(mValue) {
-                            var mTree = _this.computeTree(mValue, rawParentToPassIn, dataChanges, cacheUpdate, resolveOptions, resolvedAST, prevASTMap);
+                        var rawParentToPassIn = node;
+                        resolvedAST.values = resolvedAST.values.map(function(mValue) {
+                            var mTree = _this.computeTree(mValue, rawParentToPassIn, dataChanges, cacheUpdate, resolveOptions, resolvedAST, prevASTMap, nextAsyncIdMap);
                             if (mTree.value !== void 0 && mTree.value !== null) {
-                                if (mValue.type === "async" && mValue.flatten && mTree.value.asset && Array.isArray(mTree.value.asset.values)) {
-                                    unpackAndPush(mTree.value, childValue);
-                                } else {
-                                    childValue.push(mTree.value);
-                                }
+                                mTree.dependencies.forEach(function(bindingDep) {
+                                    return childDependencies.add(bindingDep);
+                                });
+                                updated = updated || mTree.updated;
+                                childValue.push(mTree.value);
                             }
-                            mTree.dependencies.forEach(function(bindingDep) {
-                                return childDependencies.add(bindingDep);
-                            });
-                            updated = updated || mTree.updated;
                             return mTree.node;
                         });
-                        if (hasAsync.length > 0) {
-                            var copy = newValues;
-                            hasAsync.forEach(function(index) {
-                                var _copy;
-                                if (copy[index]) (_copy = copy).splice.apply(_copy, [
-                                    index,
-                                    1
-                                ].concat(_to_consumable_array(unpackNode(copy[index]))));
-                            });
-                            resolvedAST.values = copy;
-                        } else {
-                            resolvedAST.values = newValues;
-                        }
                         resolved = childValue;
                     }
                     childDependencies.forEach(function(bindingDep) {
@@ -5073,7 +5084,7 @@ var AsyncNodePlugin = function() {
                         value: resolved,
                         dependencies: /* @__PURE__ */ new Set(_to_consumable_array(dependencyModel.getDependencies()).concat(_to_consumable_array(childDependencies)))
                     };
-                    this.hooks.afterNodeUpdate.call(node, isNestedMultiNode ? partiallyResolvedParent === null || partiallyResolvedParent === void 0 ? void 0 : partiallyResolvedParent.parent : rawParent, update);
+                    this.hooks.afterNodeUpdate.call(node, rawParent, update);
                     cacheUpdate.set(node, update);
                     return update;
                 }
@@ -5081,15 +5092,6 @@ var AsyncNodePlugin = function() {
         ]);
         return Resolver;
     }();
-    function unpackAndPush(item, initial) {
-        if (item.asset.values && Array.isArray(item.asset.values)) {
-            item.asset.values.forEach(function(i) {
-                unpackAndPush(i, initial);
-            });
-        } else {
-            initial.push(item);
-        }
-    }
     var CrossfieldProvider = /*#__PURE__*/ function() {
         function CrossfieldProvider(initialView, parser, logger) {
             _class_call_check(this, CrossfieldProvider);
@@ -5157,9 +5159,11 @@ var AsyncNodePlugin = function() {
         _create_class(ViewInstance, [
             {
                 key: "updateAsync",
-                value: function updateAsync() {
+                value: function updateAsync(asyncNode) {
                     var _this_resolver;
-                    var update = (_this_resolver = this.resolver) === null || _this_resolver === void 0 ? void 0 : _this_resolver.update();
+                    var update = (_this_resolver = this.resolver) === null || _this_resolver === void 0 ? void 0 : _this_resolver.update(/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set([
+                        asyncNode
+                    ]));
                     this.lastUpdate = update;
                     this.hooks.onUpdate.call(update);
                 }
@@ -5277,11 +5281,12 @@ var AsyncNodePlugin = function() {
      *
      * @param id - the id of async node. It should be identical for each async node
      */ function asyncNode(id) {
-                    var flatten2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+                    var flatten2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true, onValueReceived = arguments.length > 2 ? arguments[2] : void 0;
                     return {
                         id: id,
                         type: "async",
                         flatten: flatten2,
+                        onValueReceived: onValueReceived,
                         value: {
                             type: "value",
                             value: {
@@ -5827,7 +5832,7 @@ var AsyncNodePlugin = function() {
                 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)) {
+                        if ((childOptions === void 0 || !hasTemplateKey(childOptions.key)) && Array.isArray(obj)) {
                             var values = obj.map(function(childVal) {
                                 return parser.parseObject(childVal, "value", options);
                             }).filter(function(child) {
@@ -5838,7 +5843,7 @@ var AsyncNodePlugin = function() {
                             }
                             var multiNode = parser.createASTNode({
                                 type: "multi-node",
-                                override: !hasTemplateValues(childOptions.parentObj, childOptions.key),
+                                override: childOptions !== void 0 && !hasTemplateValues(childOptions.parentObj, childOptions.key),
                                 values: values
                             }, obj);
                             if (!multiNode) {
@@ -5849,7 +5854,7 @@ var AsyncNodePlugin = function() {
                                     v.parent = multiNode;
                                 });
                             }
-                            return [
+                            return childOptions === void 0 ? multiNode : [
                                 {
                                     path: _to_consumable_array(childOptions.path).concat([
                                         childOptions.key
@@ -8047,9 +8052,11 @@ var AsyncNodePlugin = function() {
     };
     // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/index.ts
     var import_queue_microtask3 = __toESM(require_queue_microtask());
-    var import_timm10 = __toESM(require_timm());
     // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/transform.ts
     var asyncTransform = function(assetId, wrapperAssetType, asset, flatten2) {
+        var path = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : [
+            "values"
+        ];
         var id = "async-" + assetId;
         var asyncNode = Builder.asyncNode(id, flatten2);
         var multiNode;
@@ -8064,11 +8071,142 @@ var AsyncNodePlugin = function() {
             id: wrapperAssetType + "-" + id,
             type: wrapperAssetType
         });
-        Builder.addChild(wrapperAsset, [
-            "values"
-        ], multiNode);
+        Builder.addChild(wrapperAsset, path, multiNode);
         return wrapperAsset;
     };
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/utils/extractNodeFromPath.ts
+    var getMatchValue = function(pathA, pathB) {
+        if (pathA.length > pathB.length) {
+            return 0;
+        }
+        var matchCount = 0;
+        for(var i = 0; i < pathA.length; i++){
+            if (pathA[i] === pathB[i]) {
+                matchCount++;
+            } else {
+                return 0;
+            }
+        }
+        return matchCount;
+    };
+    var extractNodeFromPath = function(node, path) {
+        if (path === void 0 || path.length === 0) {
+            return node;
+        }
+        if (!("children" in node && node.children)) {
+            return void 0;
+        }
+        var matchResult = 0;
+        var bestMatch;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = node.children[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var child = _step.value;
+                var matchValue = getMatchValue(child.path, path);
+                if (matchValue > matchResult) {
+                    matchResult = matchValue;
+                    bestMatch = child;
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        if (!bestMatch) {
+            return void 0;
+        }
+        if (matchResult >= path.length) {
+            return bestMatch.value;
+        }
+        return extractNodeFromPath(bestMatch.value, path.slice(matchResult));
+    };
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/utils/traverseAndReplace.ts
+    var traverseAndReplace = function(node, replaceFn) {
+        if (node.type === NodeType.MultiNode) {
+            var index = 0;
+            while(index < node.values.length){
+                var child = node.values[index];
+                if (!child) {
+                    index++;
+                    continue;
+                }
+                var result = replaceFn(child);
+                if (result.type === NodeType.MultiNode) {
+                    node.values = _to_consumable_array(node.values.slice(0, index)).concat(_to_consumable_array(result.values), _to_consumable_array(node.values.slice(index + 1)));
+                } else {
+                    node.values[index] = result;
+                    index++;
+                }
+            }
+            return node;
+        }
+        return replaceFn(node);
+    };
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/utils/unwrapAsset.ts
+    var unwrapAsset = function(node) {
+        var _node_children;
+        if (node.type !== NodeType.Value) {
+            return node;
+        }
+        var child = (_node_children = node.children) === null || _node_children === void 0 ? void 0 : _node_children.find(function(x) {
+            return x.path.length === 1 && x.path[0] === "asset";
+        });
+        if (!child) {
+            return node;
+        }
+        return child.value;
+    };
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/createAsyncTransform.ts
+    var defaultGetNodeId = function(node) {
+        return "async-".concat(node.value.id);
+    };
+    var createAsyncTransform = function(options) {
+        var transformAssetType = options.transformAssetType, wrapperAssetType = options.wrapperAssetType, getNestedAsset = options.getNestedAsset, _options_getAsyncNodeId = options.getAsyncNodeId, getAsyncNodeId = _options_getAsyncNodeId === void 0 ? defaultGetNodeId : _options_getAsyncNodeId, _options_path = options.path, path = _options_path === void 0 ? [
+            "values"
+        ] : _options_path, tmp = options.flatten, flatten2 = tmp === void 0 ? true : tmp;
+        var replaceNode = function(node) {
+            var unwrapped = unwrapAsset(node);
+            if (unwrapped.type !== NodeType.Asset || unwrapped.value.type !== transformAssetType) {
+                return node;
+            }
+            var transformed = asyncTransform2(unwrapped);
+            var _extractNodeFromPath;
+            return (_extractNodeFromPath = extractNodeFromPath(transformed, path)) !== null && _extractNodeFromPath !== void 0 ? _extractNodeFromPath : node;
+        };
+        var replacer = function(node) {
+            return traverseAndReplace(node, replaceNode);
+        };
+        var asyncTransform2 = function(node) {
+            var id = getAsyncNodeId(node);
+            var asset = getNestedAsset === null || getNestedAsset === void 0 ? void 0 : getNestedAsset(node);
+            var replaceFunction = flatten2 ? replacer : void 0;
+            var asyncNode = Builder.asyncNode(id, flatten2, replaceFunction);
+            var multiNode;
+            if (asset) {
+                var assetNode = Builder.assetWrapper(asset);
+                multiNode = Builder.multiNode(assetNode, asyncNode);
+            } else {
+                multiNode = Builder.multiNode(asyncNode);
+            }
+            var wrapperAsset = Builder.asset({
+                id: wrapperAssetType + "-" + id,
+                type: wrapperAssetType
+            });
+            Builder.addChild(wrapperAsset, path, multiNode);
+            return wrapperAsset;
+        };
+        return asyncTransform2;
+    };
     // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/index.ts
     var AsyncNodePluginSymbol = Symbol.for("AsyncNodePlugin");
     var _AsyncNodePlugin = /*#__PURE__*/ function() {
@@ -8155,6 +8293,9 @@ var AsyncNodePlugin = function() {
      */ key: "parseNodeAndUpdate",
                 value: function parseNodeAndUpdate(node, context, result, options) {
                     var parsedNode = options.parseNode && result ? options.parseNode(result) : void 0;
+                    if (parsedNode && node.onValueReceived) {
+                        parsedNode = node.onValueReceived(parsedNode);
+                    }
                     this.handleAsyncUpdate(node, context, parsedNode);
                 }
             },
@@ -8172,10 +8313,17 @@ var AsyncNodePlugin = function() {
                     var nodeResolveCache = context.nodeResolveCache, view = context.view;
                     if (nodeResolveCache.get(node.id) !== newNode) {
                         nodeResolveCache.set(node.id, newNode ? newNode : node);
-                        view.updateAsync();
+                        view.updateAsync(node.id);
                     }
                 }
             },
+            {
+                key: "hasValidMapping",
+                value: function hasValidMapping(node, context) {
+                    var nodeResolveCache = context.nodeResolveCache;
+                    return nodeResolveCache.has(node.id) && nodeResolveCache.get(node.id) !== node;
+                }
+            },
             {
                 /**
      * Handles the asynchronous API integration for resolving nodes.
@@ -8187,11 +8335,11 @@ var AsyncNodePlugin = function() {
                     var _this = this;
                     resolver.hooks.beforeResolve.tap(this.name, function(node, options) {
                         if (!_this.isAsync(node)) {
-                            return node;
+                            return node === null ? node : _this.resolveAsyncChildren(node, context);
                         }
                         var resolvedNode = context.nodeResolveCache.get(node.id);
                         if (resolvedNode !== void 0) {
-                            return resolvedNode;
+                            return _this.resolveAsyncChildren(resolvedNode, context);
                         }
                         if (context.inProgressNodes.has(node.id)) {
                             return node;
@@ -8204,6 +8352,52 @@ var AsyncNodePlugin = function() {
                     });
                 }
             },
+            {
+                /**
+     * Replaces child async nodes with their resolved content and flattens when necessary. Resolving the children directly helps manage the `parent` reference without needing as much work within the resolver itself.
+     * Handles async node chains as well to make sure all applicable nodes can get flattened.
+     * @param node - The node whose children need to be resolved.
+     * @param context - the async plugin context needed to reach into the cache
+     * @returns The same node but with async node children mapped to their resolved AST.
+     */ key: "resolveAsyncChildren",
+                value: function resolveAsyncChildren(node, context) {
+                    var _this = this;
+                    var _node_asyncNodesResolved;
+                    var asyncNodesResolved = (_node_asyncNodesResolved = node.asyncNodesResolved) !== null && _node_asyncNodesResolved !== void 0 ? _node_asyncNodesResolved : [];
+                    node.asyncNodesResolved = asyncNodesResolved;
+                    if (node.type === NodeType.MultiNode) {
+                        var index = 0;
+                        while(index < node.values.length){
+                            var childNode = node.values[index];
+                            if ((childNode === null || childNode === void 0 ? void 0 : childNode.type) !== NodeType.Async || !this.hasValidMapping(childNode, context)) {
+                                index++;
+                                continue;
+                            }
+                            var mappedNode = context.nodeResolveCache.get(childNode.id);
+                            asyncNodesResolved.push(childNode.id);
+                            if (mappedNode.type === NodeType.MultiNode && childNode.flatten) {
+                                mappedNode.values.forEach(function(v) {
+                                    return v.parent = node;
+                                });
+                                node.values = _to_consumable_array(node.values.slice(0, index)).concat(_to_consumable_array(mappedNode.values), _to_consumable_array(node.values.slice(index + 1)));
+                            } else {
+                                node.values[index] = mappedNode;
+                                mappedNode.parent = node;
+                            }
+                        }
+                    } else if ("children" in node) {
+                        var _node_children;
+                        (_node_children = node.children) === null || _node_children === void 0 ? void 0 : _node_children.forEach(function(c) {
+                            while(c.value.type === NodeType.Async && _this.hasValidMapping(c.value, context)){
+                                asyncNodesResolved.push(c.value.id);
+                                c.value = context.nodeResolveCache.get(c.value.id);
+                                c.value.parent = node;
+                            }
+                        });
+                    }
+                    return node;
+                }
+            },
             {
                 key: "runAsyncNode",
                 value: function runAsyncNode(node, context, options) {
@@ -8272,7 +8466,7 @@ var AsyncNodePlugin = function() {
             {
                 key: "isDeterminedAsync",
                 value: function isDeterminedAsync(obj) {
-                    return obj && Object.prototype.hasOwnProperty.call(obj, "async");
+                    return typeof obj === "object" && obj !== null && Object.prototype.hasOwnProperty.call(obj, "async");
                 }
             },
             {
@@ -8281,7 +8475,11 @@ var AsyncNodePlugin = function() {
                     var _this = this;
                     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 async = obj.async, flatten2 = obj.flatten, rest = _object_without_properties(obj, [
+                                "async",
+                                "flatten"
+                            ]);
+                            var parsedAsync = parser.parseObject(rest, nodeType, options);
                             var parsedNodeId = getNodeID(parsedAsync);
                             if (parsedAsync === null || !parsedNodeId) {
                                 return childOptions ? [] : null;
@@ -8289,7 +8487,8 @@ var AsyncNodePlugin = function() {
                             var asyncAST = parser.createASTNode({
                                 id: parsedNodeId,
                                 type: NodeType.Async,
-                                value: parsedAsync
+                                value: parsedAsync,
+                                flatten: flatten2
                             }, obj);
                             if (childOptions) {
                                 return asyncAST ? [