@player-ui/async-node-plugin 0.15.0-next.4 → 0.15.0-next.6

package/dist/AsyncNodePlugin.native.js

@@ -4821,7 +4821,6 @@ 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, [
             {
@@ -4832,27 +4831,44 @@ var AsyncNodePlugin = function() {
             },
             {
                 key: "update",
-                value: function update(changes, asyncChanges) {
-                    var _this = this;
-                    this.hooks.beforeUpdate.call(changes);
+                value: function update(dataChanges, nodeChanges) {
+                    this.hooks.beforeUpdate.call(dataChanges);
                     var resolveCache = /* @__PURE__ */ new Map();
                     this.idCache.clear();
                     var prevASTMap = new Map(this.ASTMap);
                     this.ASTMap.clear();
-                    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);
+                    var realNodeChanges = /* @__PURE__ */ new Set();
+                    var _nodeChanges_values;
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = ((_nodeChanges_values = nodeChanges === null || nodeChanges === void 0 ? void 0 : nodeChanges.values()) !== null && _nodeChanges_values !== void 0 ? _nodeChanges_values : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var node = _step.value;
+                            var current = node;
+                            while(current){
+                                var _prevASTMap_get;
+                                var original = (_prevASTMap_get = prevASTMap.get(current)) !== null && _prevASTMap_get !== void 0 ? _prevASTMap_get : current;
+                                if (realNodeChanges.has(original)) {
+                                    break;
+                                }
+                                realNodeChanges.add(original);
+                                current = current.parent;
                             }
-                            current = current.parent;
                         }
-                    });
-                    var updated = this.computeTree(this.root, void 0, changes, resolveCache, toNodeResolveOptions(this.options), void 0, prevASTMap, nextAsyncIdMap);
-                    this.AsyncIdMap = nextAsyncIdMap;
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    var updated = this.computeTree(this.root, void 0, dataChanges, resolveCache, toNodeResolveOptions(this.options), void 0, prevASTMap, realNodeChanges);
                     this.resolveCache = resolveCache;
                     this.hooks.afterUpdate.call(updated.value);
                     return updated.value;
@@ -4906,7 +4922,7 @@ var AsyncNodePlugin = function() {
             },
             {
                 key: "computeTree",
-                value: function computeTree(node, rawParent, dataChanges, cacheUpdate, options, partiallyResolvedParent, prevASTMap, nextAsyncIdMap) {
+                value: function computeTree(node, rawParent, dataChanges, cacheUpdate, options, partiallyResolvedParent, prevASTMap, nodeChanges) {
                     var _this = this;
                     var dependencyModel = new DependencyModel(options.data.model);
                     dependencyModel.trackSubset("core");
@@ -4924,8 +4940,9 @@ var AsyncNodePlugin = function() {
                     }), node);
                     var previousResult = this.getPreviousResult(node);
                     var previousDeps = previousResult === null || previousResult === void 0 ? void 0 : previousResult.dependencies;
+                    var isChanged = nodeChanges.has(node);
                     var dataChanged = caresAboutDataChanges(dataChanges, previousDeps);
-                    var shouldUseLastValue = this.hooks.skipResolve.call(!dataChanged, node, resolveOptions);
+                    var shouldUseLastValue = this.hooks.skipResolve.call(!dataChanged && !isChanged, node, resolveOptions);
                     if (previousResult && shouldUseLastValue) {
                         var update2 = _object_spread_props(_object_spread({}, previousResult), {
                             updated: false
@@ -4937,30 +4954,6 @@ 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;
@@ -4991,30 +4984,6 @@ var AsyncNodePlugin = function() {
                         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);
                     var resolved = this.hooks.resolve.call(void 0, resolvedAST, resolveOptions);
@@ -5027,7 +4996,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, nextAsyncIdMap);
+                            var computedChildTree = _this.computeTree(child.value, node, dataChanges, cacheUpdate, resolveOptions, resolvedAST, prevASTMap, nodeChanges);
                             var childTreeDeps = computedChildTree.dependencies, childNode = computedChildTree.node, childUpdated = computedChildTree.updated, childValue = computedChildTree.value;
                             childTreeDeps.forEach(function(binding) {
                                 return childDependencies.add(binding);
@@ -5050,7 +5019,7 @@ var AsyncNodePlugin = function() {
                         var childValue = [];
                         var rawParentToPassIn = node;
                         resolvedAST.values = resolvedAST.values.map(function(mValue) {
-                            var mTree = _this.computeTree(mValue, rawParentToPassIn, dataChanges, cacheUpdate, resolveOptions, resolvedAST, prevASTMap, nextAsyncIdMap);
+                            var mTree = _this.computeTree(mValue, rawParentToPassIn, dataChanges, cacheUpdate, resolveOptions, resolvedAST, prevASTMap, nodeChanges);
                             if (mTree.value !== void 0 && mTree.value !== null) {
                                 mTree.dependencies.forEach(function(bindingDep) {
                                     return childDependencies.add(bindingDep);
@@ -5154,19 +5123,17 @@ var AsyncNodePlugin = function() {
         }
         _create_class(ViewInstance, [
             {
-                key: "updateAsync",
+                /** @deprecated use ViewController.updateViewAST */ key: "updateAsync",
                 value: function updateAsync(asyncNode) {
                     var _this_resolver;
-                    var update = (_this_resolver = this.resolver) === null || _this_resolver === void 0 ? void 0 : _this_resolver.update(/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set([
-                        asyncNode
-                    ]));
+                    var update = (_this_resolver = this.resolver) === null || _this_resolver === void 0 ? void 0 : _this_resolver.update();
                     this.lastUpdate = update;
                     this.hooks.onUpdate.call(update);
                 }
             },
             {
                 key: "update",
-                value: function update(changes) {
+                value: function update(changes, nodeChanges) {
                     var _this_resolver;
                     if (this.rootNode === void 0) {
                         this.validationProvider = new CrossfieldProvider(this.initialView, this.resolverOptions.parseBinding, this.resolverOptions.logger);
@@ -5184,7 +5151,7 @@ var AsyncNodePlugin = function() {
                         }));
                         this.hooks.resolver.call(this.resolver);
                     }
-                    var update = (_this_resolver = this.resolver) === null || _this_resolver === void 0 ? void 0 : _this_resolver.update(changes);
+                    var update = (_this_resolver = this.resolver) === null || _this_resolver === void 0 ? void 0 : _this_resolver.update(changes, nodeChanges);
                     if (this.lastUpdate === update) {
                         return this.lastUpdate;
                     }
@@ -7102,6 +7069,10 @@ var AsyncNodePlugin = function() {
         ]);
         return ValidationController;
     }();
+    var mergeSets = function(setA, setB) {
+        var _setA_values, _setB_values;
+        return /* @__PURE__ */ new Set(_to_consumable_array((_setA_values = setA === null || setA === void 0 ? void 0 : setA.values()) !== null && _setA_values !== void 0 ? _setA_values : []).concat(_to_consumable_array((_setB_values = setB === null || setB === void 0 ? void 0 : setB.values()) !== null && _setB_values !== void 0 ? _setB_values : [])));
+    };
     var ViewController = /*#__PURE__*/ function() {
         function ViewController(initialViews, options) {
             var _this = this;
@@ -7131,7 +7102,7 @@ var AsyncNodePlugin = function() {
                 var silent = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
                 if (_this1.currentView) {
                     if (_this1.optimizeUpdates) {
-                        _this1.queueUpdate(updates, silent);
+                        _this1.queueUpdate(updates, void 0, silent);
                     } else {
                         _this1.currentView.update();
                     }
@@ -7161,25 +7132,26 @@ var AsyncNodePlugin = function() {
         _create_class(ViewController, [
             {
                 key: "queueUpdate",
-                value: function queueUpdate(bindings) {
+                value: function queueUpdate(bindings, nodes) {
                     var _this = this;
-                    var silent = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
-                    var _this_pendingUpdate;
-                    if ((_this_pendingUpdate = this.pendingUpdate) === null || _this_pendingUpdate === void 0 ? void 0 : _this_pendingUpdate.changedBindings) {
-                        this.pendingUpdate.changedBindings = /* @__PURE__ */ new Set(_to_consumable_array(this.pendingUpdate.changedBindings).concat(_to_consumable_array(bindings)));
-                    } else {
+                    var silent = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+                    if (!this.pendingUpdate) {
                         this.pendingUpdate = {
-                            changedBindings: bindings,
                             scheduled: false
                         };
                     }
+                    this.pendingUpdate = _object_spread_props(_object_spread({}, this.pendingUpdate), {
+                        changedBindings: mergeSets(this.pendingUpdate.changedBindings, bindings),
+                        changedNodes: mergeSets(this.pendingUpdate.changedNodes, nodes)
+                    });
                     if (!this.pendingUpdate.scheduled && !silent) {
                         this.pendingUpdate.scheduled = true;
                         (0, import_queue_microtask2.default)(function() {
-                            var _this_pendingUpdate, _this_currentView;
-                            var updates = (_this_pendingUpdate = _this.pendingUpdate) === null || _this_pendingUpdate === void 0 ? void 0 : _this_pendingUpdate.changedBindings;
+                            var _this_currentView;
+                            var _this_pendingUpdate;
+                            var _ref = (_this_pendingUpdate = _this.pendingUpdate) !== null && _this_pendingUpdate !== void 0 ? _this_pendingUpdate : {}, changedBindings = _ref.changedBindings, changedNodes = _ref.changedNodes;
                             _this.pendingUpdate = void 0;
-                            (_this_currentView = _this.currentView) === null || _this_currentView === void 0 ? void 0 : _this_currentView.update(updates);
+                            (_this_currentView = _this.currentView) === null || _this_currentView === void 0 ? void 0 : _this_currentView.update(changedBindings, changedNodes);
                         });
                     }
                 }
@@ -7256,6 +7228,15 @@ var AsyncNodePlugin = function() {
                         new MultiNodePlugin()
                     ];
                 }
+            },
+            {
+                /** Marks all AST nodes in `nodes` as changed, triggering the view to update and re-resolve these nodes. View updates are triggered asynchronously and many calls to this in a short time will batch into a single update.
+     *
+     * NOTE: In most cases view updates are handled automatically by changes to data or any other built-in functionality that would require a view update. Only call this function if absolutely necessary.
+     */ key: "updateViewAST",
+                value: function updateViewAST(nodes) {
+                    this.queueUpdate(void 0, nodes);
+                }
             }
         ]);
         return ViewController;
@@ -7628,8 +7609,8 @@ var AsyncNodePlugin = function() {
         ref: Symbol("not-started"),
         status: "not-started"
     };
-    var PLAYER_VERSION = true ? "0.15.0-next.4" : "unknown";
-    var COMMIT = true ? "12cdc54a63c8c74be236c6493bd8ab37a1ff2161" : "unknown";
+    var PLAYER_VERSION = true ? "0.15.0-next.6" : "unknown";
+    var COMMIT = true ? "9b22cee7078ed75d77b3c31bc306c758ea07da8b" : "unknown";
     var _Player = /*#__PURE__*/ function() {
         function _Player2(config) {
             var _this = this;
@@ -8274,7 +8255,12 @@ var AsyncNodePlugin = function() {
                 key: "apply",
                 value: function apply(player) {
                     var _this = this;
+                    var _this_plugins;
                     this.playerInstance = player;
+                    (_this_plugins = this.plugins) === null || _this_plugins === void 0 ? void 0 : _this_plugins.forEach(function(plugin) {
+                        var _plugin_applyPlayer;
+                        (_plugin_applyPlayer = plugin.applyPlayer) === null || _plugin_applyPlayer === void 0 ? void 0 : _plugin_applyPlayer.call(plugin, player);
+                    });
                     player.hooks.viewController.tap(this.name, function(viewController) {
                         viewController.hooks.view.tap(_this.name, function(view) {
                             var _this_plugins;
@@ -8323,10 +8309,14 @@ var AsyncNodePlugin = function() {
      * @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, context, newNode) {
-                    var nodeResolveCache = context.nodeResolveCache, view = context.view;
+                    var nodeResolveCache = context.nodeResolveCache, viewController = context.viewController, originalNodeCache = context.originalNodeCache;
                     if (nodeResolveCache.get(node.id) !== newNode) {
                         nodeResolveCache.set(node.id, newNode ? newNode : node);
-                        view.updateAsync(node.id);
+                        var _originalNodeCache_get;
+                        var originalNode = (_originalNodeCache_get = originalNodeCache.get(node.id)) !== null && _originalNodeCache_get !== void 0 ? _originalNodeCache_get : /* @__PURE__ */ new Set([
+                            node
+                        ]);
+                        viewController.updateViewAST(originalNode);
                     }
                 }
             },
@@ -8350,12 +8340,13 @@ var AsyncNodePlugin = function() {
                         if (!_this.isAsync(node)) {
                             return node === null ? node : _this.resolveAsyncChildren(node, context);
                         }
+                        if (options.node) {
+                            context.originalNodeCache.set(node.id, /* @__PURE__ */ new Set([
+                                options.node
+                            ]));
+                        }
                         var resolvedNode = context.nodeResolveCache.get(node.id);
                         if (resolvedNode !== void 0) {
-                            if (resolvedNode.asyncNodesResolved === void 0) {
-                                resolvedNode.asyncNodesResolved = [];
-                            }
-                            resolvedNode.asyncNodesResolved.push(node.id);
                             return _this.resolveAsyncChildren(resolvedNode, context);
                         }
                         if (context.inProgressNodes.has(node.id)) {
@@ -8379,35 +8370,39 @@ var AsyncNodePlugin = function() {
      */ 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 _this1, _loop = function() {
                             var childNode = node.values[index];
-                            if ((childNode === null || childNode === void 0 ? void 0 : childNode.type) !== NodeType.Async || !this.hasValidMapping(childNode, context)) {
+                            if ((childNode === null || childNode === void 0 ? void 0 : childNode.type) !== NodeType.Async || !_this1.hasValidMapping(childNode, context)) {
                                 index++;
-                                continue;
+                                return "continue";
                             }
                             var mappedNode = context.nodeResolveCache.get(childNode.id);
-                            asyncNodesResolved.push(childNode.id);
+                            var nodeSet = /* @__PURE__ */ new Set();
                             if (mappedNode.type === NodeType.MultiNode && childNode.flatten) {
                                 mappedNode.values.forEach(function(v) {
-                                    return v.parent = node;
+                                    v.parent = node;
+                                    nodeSet.add(v);
                                 });
                                 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;
+                                nodeSet.add(mappedNode);
                             }
-                        }
+                            context.originalNodeCache.set(childNode.id, nodeSet);
+                        };
+                        var index = 0;
+                        while(index < node.values.length)_this1 = this, _loop();
                     } 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);
+                                var mappedNode = context.nodeResolveCache.get(c.value.id);
+                                context.originalNodeCache.set(c.value.id, /* @__PURE__ */ new Set([
+                                    mappedNode
+                                ]));
+                                c.value = mappedNode;
                                 c.value.parent = node;
                             }
                         });
@@ -8527,15 +8522,26 @@ var AsyncNodePlugin = function() {
             {
                 key: "apply",
                 value: function apply(view) {
-                    var _this = this;
-                    var context = {
-                        nodeResolveCache: /* @__PURE__ */ new Map(),
-                        inProgressNodes: /* @__PURE__ */ new Set(),
-                        view: view
-                    };
                     view.hooks.parser.tap("async", this.applyParser.bind(this));
-                    view.hooks.resolver.tap("async", function(resolver) {
-                        _this.applyResolver(resolver, context);
+                }
+            },
+            {
+                key: "applyPlayer",
+                value: function applyPlayer(player) {
+                    var _this = this;
+                    player.hooks.viewController.tap("async", function(viewController) {
+                        viewController.hooks.view.tap("async", function(view) {
+                            var context = {
+                                nodeResolveCache: /* @__PURE__ */ new Map(),
+                                inProgressNodes: /* @__PURE__ */ new Set(),
+                                view: view,
+                                viewController: viewController,
+                                originalNodeCache: /* @__PURE__ */ new Map()
+                            };
+                            view.hooks.resolver.tap("async", function(resolver) {
+                                _this.applyResolver(resolver, context);
+                            });
+                        });
                     });
                 }
             },