@player-ui/async-node-plugin 0.13.0-next.1 → 0.13.0-next.3

package/dist/AsyncNodePlugin.native.js

@@ -2576,9 +2576,10 @@ var AsyncNodePlugin = function() {
     var import_timm7 = __toESM(require_timm(), 1);
     var import_timm8 = __toESM(require_timm(), 1);
     var import_p_defer = __toESM(require_p_defer(), 1);
+    var import_queue_microtask = __toESM(require_queue_microtask(), 1);
     var import_p_defer2 = __toESM(require_p_defer(), 1);
     var import_timm9 = __toESM(require_timm(), 1);
-    var import_queue_microtask = __toESM(require_queue_microtask(), 1);
+    var import_queue_microtask2 = __toESM(require_queue_microtask(), 1);
     // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/@player-ui+partial-match-registry@0.0.0/node_modules/@player-ui/partial-match-registry/dist/index.mjs
     var import_sorted_array = __toESM(require_sorted_array(), 1);
     function traverseObj(object) {
@@ -6079,13 +6080,13 @@ var AsyncNodePlugin = function() {
             this.isTransitioning = false;
             this.hooks = {
                 beforeStart: new SyncBailHook(),
-                /** A callback when the onStart node was present */ onStart: new SyncHook(),
-                /** A callback when the onEnd node was present */ onEnd: new SyncHook(),
-                /** A hook to intercept and block a transition */ skipTransition: new SyncBailHook(),
-                /** A chance to manipulate the flow-node used to calculate the given transition used  */ beforeTransition: new SyncWaterfallHook(),
-                /** A chance to manipulate the flow-node calculated after a transition */ resolveTransitionNode: new SyncWaterfallHook(),
-                /** A callback when a transition from 1 state to another was made */ transition: new SyncHook(),
-                /** A callback to run actions after a transition occurs */ afterTransition: new SyncHook()
+                onStart: new SyncHook(),
+                onEnd: new SyncHook(),
+                skipTransition: new SyncBailHook(),
+                beforeTransition: new SyncWaterfallHook(),
+                resolveTransitionNode: new SyncWaterfallHook(),
+                transition: new SyncHook(),
+                afterTransition: new SyncHook()
             };
             this.id = id;
             this.flow = flow;
@@ -7175,7 +7176,7 @@ var AsyncNodePlugin = function() {
                     }
                     if (!this.pendingUpdate.scheduled && !silent) {
                         this.pendingUpdate.scheduled = true;
-                        (0, import_queue_microtask.default)(function() {
+                        (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;
                             _this.pendingUpdate = void 0;
@@ -7844,95 +7845,41 @@ var AsyncNodePlugin = function() {
                                 validationController.reset();
                             }
                         });
-                        flow.hooks.afterTransition.tap("player", function(flowInstance) {
+                        flow.hooks.afterTransition.tap("player-action-states", function(flowInstance) {
                             var _flowInstance_currentState;
                             var value = (_flowInstance_currentState = flowInstance.currentState) === null || _flowInstance_currentState === void 0 ? void 0 : _flowInstance_currentState.value;
-                            if (value && value.state_type === "ACTION") {
+                            if (value && value.state_type === "ASYNC_ACTION") {
                                 var exp = value.exp;
-                                var result = expressionEvaluator.evaluate(exp);
-                                if (isPromiseLike(result)) {
+                                try {
+                                    var result = expressionEvaluator.evaluateAsync(exp);
+                                    if (isPromiseLike(result)) {
+                                        if (value.await) {
+                                            (0, import_queue_microtask.default)(function() {
+                                                result.then(function(r) {
+                                                    return flowController === null || flowController === void 0 ? void 0 : flowController.transition(String(r));
+                                                }).catch(flowResultDeferred.reject);
+                                            });
+                                        } else {
+                                            _this.logger.warn("Unawaited promise used as return value in in non-async context, transitioning with '*' value");
+                                            flowController === null || flowController === void 0 ? void 0 : flowController.transition(String(result));
+                                        }
+                                    } else {
+                                        _this.logger.warn("Non async expression used in async action node");
+                                        flowController === null || flowController === void 0 ? void 0 : flowController.transition(String(result));
+                                    }
+                                } catch (e) {
+                                    flowResultDeferred.reject(e);
+                                }
+                            } else if (value && value.state_type === "ACTION") {
+                                var exp1 = value.exp;
+                                var result1 = expressionEvaluator.evaluate(exp1);
+                                if (isPromiseLike(result1)) {
                                     _this.logger.warn("Async expression used as return value in in non-async context, transitioning with '*' value");
                                 }
-                                flowController === null || flowController === void 0 ? void 0 : flowController.transition(String(result));
+                                flowController === null || flowController === void 0 ? void 0 : flowController.transition(String(result1));
                             }
                             expressionEvaluator.reset();
                         });
-                        var _this1 = _this;
-                        flow.hooks.afterTransition.tap("player", function() {
-                            var _ref = _async_to_generator(function(flowInstance) {
-                                var _flowInstance_currentState, value, exp, result, e;
-                                return _ts_generator(this, function(_state) {
-                                    switch(_state.label){
-                                        case 0:
-                                            value = (_flowInstance_currentState = flowInstance.currentState) === null || _flowInstance_currentState === void 0 ? void 0 : _flowInstance_currentState.value;
-                                            if (!(value && value.state_type === "ASYNC_ACTION")) return [
-                                                3,
-                                                8
-                                            ];
-                                            exp = value.exp;
-                                            _state.label = 1;
-                                        case 1:
-                                            _state.trys.push([
-                                                1,
-                                                7,
-                                                ,
-                                                8
-                                            ]);
-                                            result = expressionEvaluator.evaluateAsync(exp);
-                                            if (!isPromiseLike(result)) return [
-                                                3,
-                                                5
-                                            ];
-                                            if (!value.await) return [
-                                                3,
-                                                3
-                                            ];
-                                            return [
-                                                4,
-                                                result
-                                            ];
-                                        case 2:
-                                            result = _state.sent();
-                                            return [
-                                                3,
-                                                4
-                                            ];
-                                        case 3:
-                                            _this1.logger.warn("Unawaited promise used as return value in in non-async context, transitioning with '*' value");
-                                            _state.label = 4;
-                                        case 4:
-                                            return [
-                                                3,
-                                                6
-                                            ];
-                                        case 5:
-                                            _this1.logger.warn("Non async expression used in async action node");
-                                            _state.label = 6;
-                                        case 6:
-                                            flowController === null || flowController === void 0 ? void 0 : flowController.transition(String(result));
-                                            return [
-                                                3,
-                                                8
-                                            ];
-                                        case 7:
-                                            e = _state.sent();
-                                            flowResultDeferred.reject(e);
-                                            return [
-                                                3,
-                                                8
-                                            ];
-                                        case 8:
-                                            expressionEvaluator.reset();
-                                            return [
-                                                2
-                                            ];
-                                    }
-                                });
-                            });
-                            return function(flowInstance) {
-                                return _ref.apply(this, arguments);
-                            };
-                        }());
                     });
                     this.hooks.dataController.call(dataController);
                     validationController.setOptions({
@@ -8096,7 +8043,7 @@ var AsyncNodePlugin = function() {
         commit: COMMIT
     };
     // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/async-node/core/src/index.ts
-    var import_queue_microtask2 = __toESM(require_queue_microtask());
+    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) {
@@ -8125,7 +8072,8 @@ var AsyncNodePlugin = function() {
             var _this = this;
             _class_call_check(this, AsyncNodePlugin);
             this.hooks = {
-                onAsyncNode: new AsyncParallelBailHook()
+                onAsyncNode: new AsyncParallelBailHook(),
+                onAsyncNodeError: new SyncBailHook()
             };
             this.name = "AsyncNode";
             if (options === null || options === void 0 ? void 0 : options.plugins) {
@@ -8159,10 +8107,17 @@ var AsyncNodePlugin = function() {
             }
         }
         _create_class(AsyncNodePlugin, [
+            {
+                key: "getPlayerInstance",
+                value: function getPlayerInstance() {
+                    return this.playerInstance;
+                }
+            },
             {
                 key: "apply",
                 value: function apply(player) {
                     var _this = this;
+                    this.playerInstance = player;
                     player.hooks.viewController.tap(this.name, function(viewController) {
                         viewController.hooks.view.tap(_this.name, function(view) {
                             var _this_plugins;
@@ -8181,25 +8136,36 @@ var AsyncNodePlugin = function() {
             _class_call_check(this, AsyncNodePluginPlugin);
             this.asyncNode = new AsyncParallelBailHook();
             this.name = "AsyncNode";
-            this.resolvedMapping = /* @__PURE__ */ new Map();
         }
         _create_class(AsyncNodePluginPlugin, [
             {
                 /**
+     * Parses the node from the result and triggers an asynchronous view update if necessary.
+     * @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: "parseNodeAndUpdate",
+                value: function parseNodeAndUpdate(node, context, result, options) {
+                    var parsedNode = options.parseNode && result ? options.parseNode(result) : void 0;
+                    this.handleAsyncUpdate(node, context, parsedNode);
+                }
+            },
+            {
+                /**
      * 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 newNode The new node to replace the async node.
      * @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();
+                value: function handleAsyncUpdate(node, context, newNode) {
+                    var nodeResolveCache = context.nodeResolveCache, view = context.view;
+                    if (nodeResolveCache.get(node.id) !== newNode) {
+                        nodeResolveCache.set(node.id, newNode ? newNode : node);
+                        view.updateAsync();
                     }
                 }
             },
@@ -8210,47 +8176,80 @@ var AsyncNodePlugin = function() {
      * @param resolver The resolver instance to attach the hook to.
      * @param view
      */ key: "applyResolver",
-                value: function applyResolver(resolver) {
+                value: function applyResolver(resolver, context) {
                     var _this = this;
                     resolver.hooks.beforeResolve.tap(this.name, function(node, options) {
-                        var resolvedNode;
-                        if (_this.isAsync(node)) {
-                            var mappedValue = _this.resolvedMapping.get(node.id);
-                            if (mappedValue) {
-                                resolvedNode = mappedValue;
-                            }
-                        } else {
-                            resolvedNode = null;
-                        }
-                        var newNode = resolvedNode || node;
-                        if (!resolvedNode && (node === null || node === void 0 ? void 0 : node.type) === NodeType.Async) {
-                            var _this1 = _this;
-                            (0, import_queue_microtask2.default)(/*#__PURE__*/ _async_to_generator(function() {
-                                var _this_basePlugin, result;
-                                return _ts_generator(this, function(_state) {
-                                    switch(_state.label){
-                                        case 0:
-                                            return [
-                                                4,
-                                                (_this_basePlugin = _this1.basePlugin) === null || _this_basePlugin === void 0 ? void 0 : _this_basePlugin.hooks.onAsyncNode.call(node, function(result2) {
-                                                    _this1.handleAsyncUpdate(node, result2, options, _this1.currentView);
-                                                })
-                                            ];
-                                        case 1:
-                                            result = _state.sent();
-                                            _this1.handleAsyncUpdate(node, result, options, _this1.currentView);
-                                            return [
-                                                2
-                                            ];
-                                    }
-                                });
-                            }));
+                        if (!_this.isAsync(node)) {
                             return node;
                         }
-                        return newNode;
+                        var resolvedNode = context.nodeResolveCache.get(node.id);
+                        if (resolvedNode !== void 0) {
+                            return resolvedNode;
+                        }
+                        (0, import_queue_microtask3.default)(function() {
+                            return _this.runAsyncNode(node, context, options);
+                        });
+                        return node;
                     });
                 }
             },
+            {
+                key: "runAsyncNode",
+                value: function runAsyncNode(node, context, options) {
+                    var _this = this;
+                    return _async_to_generator(function() {
+                        var _this_basePlugin, result, e, _this_basePlugin1, _options_logger, error, result1, _this_basePlugin_getPlayerInstance, _this_basePlugin2, playerState;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    _state.trys.push([
+                                        0,
+                                        2,
+                                        ,
+                                        3
+                                    ]);
+                                    return [
+                                        4,
+                                        (_this_basePlugin = _this.basePlugin) === null || _this_basePlugin === void 0 ? void 0 : _this_basePlugin.hooks.onAsyncNode.call(node, function(result2) {
+                                            _this.parseNodeAndUpdate(node, context, result2, options);
+                                        })
+                                    ];
+                                case 1:
+                                    result = _state.sent();
+                                    _this.parseNodeAndUpdate(node, context, result, options);
+                                    return [
+                                        3,
+                                        3
+                                    ];
+                                case 2:
+                                    e = _state.sent();
+                                    error = _instanceof(e, Error) ? e : new Error(String(e));
+                                    result1 = (_this_basePlugin1 = _this.basePlugin) === null || _this_basePlugin1 === void 0 ? void 0 : _this_basePlugin1.hooks.onAsyncNodeError.call(error, node);
+                                    if (result1 === void 0) {
+                                        ;
+                                        playerState = (_this_basePlugin2 = _this.basePlugin) === null || _this_basePlugin2 === void 0 ? void 0 : (_this_basePlugin_getPlayerInstance = _this_basePlugin2.getPlayerInstance()) === null || _this_basePlugin_getPlayerInstance === void 0 ? void 0 : _this_basePlugin_getPlayerInstance.getState();
+                                        if ((playerState === null || playerState === void 0 ? void 0 : playerState.status) === "in-progress") {
+                                            playerState.fail(error);
+                                        }
+                                        return [
+                                            2
+                                        ];
+                                    }
+                                    (_options_logger = options.logger) === null || _options_logger === void 0 ? void 0 : _options_logger.error("Async node handling failed and resolved with a fallback. Error:", error);
+                                    _this.parseNodeAndUpdate(node, context, result1, options);
+                                    return [
+                                        3,
+                                        3
+                                    ];
+                                case 3:
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    })();
+                }
+            },
             {
                 key: "isAsync",
                 value: function isAsync(node) {
@@ -8297,9 +8296,15 @@ var AsyncNodePlugin = function() {
             {
                 key: "apply",
                 value: function apply(view) {
-                    this.currentView = view;
+                    var _this = this;
+                    var context = {
+                        nodeResolveCache: /* @__PURE__ */ new Map(),
+                        view: view
+                    };
                     view.hooks.parser.tap("async", this.applyParser.bind(this));
-                    view.hooks.resolver.tap("async", this.applyResolver.bind(this));
+                    view.hooks.resolver.tap("async", function(resolver) {
+                        _this.applyResolver(resolver, context);
+                    });
                 }
             },
             {