@player-ui/async-node-plugin 0.10.4-next.2 → 0.10.4-next.3

package/dist/AsyncNodePlugin.native.js

@@ -2038,6 +2038,9 @@ var AsyncNodePlugin = function() {
         },
         AsyncNodePluginPlugin: function() {
             return AsyncNodePluginPlugin;
+        },
+        asyncTransform: function() {
+            return asyncTransform;
         }
     });
     var InterceptionManager = /*#__PURE__*/ function() {
@@ -4324,18 +4327,18 @@ var AsyncNodePlugin = function() {
         ]);
         return ValidatorRegistry;
     }();
-    var NodeType = /* @__PURE__ */ function(NodeType2) {
-        NodeType2["Asset"] = "asset";
-        NodeType2["View"] = "view";
-        NodeType2["Applicability"] = "applicability";
-        NodeType2["Template"] = "template";
-        NodeType2["Value"] = "value";
-        NodeType2["MultiNode"] = "multi-node";
-        NodeType2["Switch"] = "switch";
-        NodeType2["Async"] = "async";
-        NodeType2["Unknown"] = "unknown";
-        NodeType2["Empty"] = "empty";
-        return NodeType2;
+    var NodeType = /* @__PURE__ */ function(NodeType22) {
+        NodeType22["Asset"] = "asset";
+        NodeType22["View"] = "view";
+        NodeType22["Applicability"] = "applicability";
+        NodeType22["Template"] = "template";
+        NodeType22["Value"] = "value";
+        NodeType22["MultiNode"] = "multi-node";
+        NodeType22["Switch"] = "switch";
+        NodeType22["Async"] = "async";
+        NodeType22["Unknown"] = "unknown";
+        NodeType22["Empty"] = "empty";
+        return NodeType22;
     }(NodeType || {});
     var EMPTY_NODE = {
         type: "empty"
@@ -4473,6 +4476,15 @@ var AsyncNodePlugin = function() {
         ]);
         return Parser;
     }();
+    function unpackAndPush(item, initial) {
+        if (Array.isArray(item)) {
+            item.forEach(function(i) {
+                unpackAndPush(i, initial);
+            });
+        } else {
+            initial.push(item);
+        }
+    }
     var withContext = function(model) {
         return {
             get: function(binding, options) {
@@ -4693,7 +4705,13 @@ var AsyncNodePlugin = function() {
                         var newValues = resolvedAST.values.map(function(mValue) {
                             var mTree = _this.computeTree(mValue, rawParentToPassIn, dataChanges, cacheUpdate, resolveOptions, resolvedAST, prevASTMap);
                             if (mTree.value !== void 0 && mTree.value !== null) {
-                                childValue.push(mTree.value);
+                                if (mValue.type === "async" && mValue.flatten && mTree.value.asset && Array.isArray(mTree.value.asset.values)) {
+                                    mTree.value.asset.values.forEach(function(v) {
+                                        unpackAndPush(v, childValue);
+                                    });
+                                } else {
+                                    childValue.push(mTree.value);
+                                }
                             }
                             mTree.dependencies.forEach(function(bindingDep) {
                                 return childDependencies.add(bindingDep);
@@ -4848,6 +4866,112 @@ var AsyncNodePlugin = function() {
         ]);
         return ViewInstance;
     }();
+    var Builder = /*#__PURE__*/ function() {
+        function _Builder() {
+            _class_call_check(this, _Builder);
+        }
+        _create_class(_Builder, null, [
+            {
+                key: "asset",
+                value: /**
+     * Creates an asset node
+     *
+     * @param value - the value to put in the asset node
+     */ function asset(value) {
+                    return {
+                        type: "asset",
+                        value: value
+                    };
+                }
+            },
+            {
+                key: "assetWrapper",
+                value: function assetWrapper(value) {
+                    var valueNode = _Builder.value();
+                    _Builder.addChild(valueNode, "asset", value);
+                    return valueNode;
+                }
+            },
+            {
+                key: "value",
+                value: /**
+     * Creates a value node
+     *
+     * @param v - The object to put in the value node
+     */ function value(v) {
+                    return {
+                        type: "value",
+                        value: v
+                    };
+                }
+            },
+            {
+                key: "multiNode",
+                value: /**
+     * Creates a multiNode and associates the multiNode as the parent
+     * of all the value nodes
+     *
+     * @param values - the value, applicability or async nodes to put in the multinode
+     */ function multiNode() {
+                    for(var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++){
+                        values[_key] = arguments[_key];
+                    }
+                    var m = {
+                        type: "multi-node",
+                        override: true,
+                        values: values
+                    };
+                    values.forEach(function(v) {
+                        v.parent = m;
+                    });
+                    return m;
+                }
+            },
+            {
+                key: "asyncNode",
+                value: /**
+     * Creates an async node
+     *
+     * @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;
+                    return {
+                        id: id,
+                        type: "async",
+                        flatten: flatten2,
+                        value: {
+                            type: "value",
+                            value: {
+                                id: id
+                            }
+                        }
+                    };
+                }
+            },
+            {
+                key: "addChild",
+                value: /**
+     * Adds a child node to a node
+     *
+     * @param node - The node to add a child to
+     * @param path - The path at which to add the child
+     * @param child - The child node
+     */ function addChild(node, path, child) {
+                    child.parent = node;
+                    var newChild = {
+                        path: Array.isArray(path) ? path : [
+                            path
+                        ],
+                        value: child
+                    };
+                    node.children = node.children || [];
+                    node.children.push(newChild);
+                    return node;
+                }
+            }
+        ]);
+        return _Builder;
+    }();
     var TemplatePlugin = /*#__PURE__*/ function() {
         function TemplatePlugin(options) {
             _class_call_check(this, TemplatePlugin);
@@ -7485,6 +7609,28 @@ var AsyncNodePlugin = function() {
     // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/index.ts
     var import_queue_microtask2 = __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 id = "async-" + assetId;
+        var asyncNode = Builder.asyncNode(id, flatten2);
+        var multiNode;
+        var assetNode;
+        if (asset) {
+            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, [
+            "values"
+        ], multiNode);
+        return wrapperAsset;
+    };
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/index.ts
     var AsyncNodePlugin = /*#__PURE__*/ function() {
         function AsyncNodePlugin(options) {
             var _this = this;