@player-ui/async-node-plugin 0.11.2--canary.649.23032 → 0.11.2-next.1

package/dist/AsyncNodePlugin.native.js

@@ -3579,9 +3579,6 @@ var AsyncNodePlugin = function() {
         },
         setDataVal: function() {
             return setDataVal;
-        },
-        waitFor: function() {
-            return waitFor;
         }
     });
     var setDataVal = function(_context, binding, value) {
@@ -3609,27 +3606,6 @@ var AsyncNodePlugin = function() {
         return null;
     };
     conditional.resolveParams = false;
-    var waitFor = function() {
-        var _ref = _async_to_generator(function(ctx, promise) {
-            return _ts_generator(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            promise
-                        ];
-                    case 1:
-                        return [
-                            2,
-                            _state.sent()
-                        ];
-                }
-            });
-        });
-        return function waitFor(ctx, promise) {
-            return _ref.apply(this, arguments);
-        };
-    }();
     var andandOperator = function(ctx, a, b) {
         return ctx.evaluate(a) && ctx.evaluate(b);
     };
@@ -3735,12 +3711,7 @@ var AsyncNodePlugin = function() {
             this.operators = {
                 binary: new Map(Object.entries(DEFAULT_BINARY_OPERATORS)),
                 unary: new Map(Object.entries(DEFAULT_UNARY_OPERATORS)),
-                expressions: new Map(_to_consumable_array(Object.entries(evaluator_functions_exports)).concat([
-                    [
-                        "await",
-                        waitFor
-                    ]
-                ]))
+                expressions: new Map(Object.entries(evaluator_functions_exports))
             };
             this.defaultHookOptions = _object_spread_props(_object_spread({}, defaultOptions), {
                 evaluate: function(expr) {
@@ -3750,12 +3721,7 @@ var AsyncNodePlugin = function() {
                     return _this._execAST(node, _this.defaultHookOptions);
                 }
             });
-            this.hooks.resolve.tap("ExpressionEvaluator", function(result, node, options) {
-                if (options.async) {
-                    return _this._resolveNodeAsync(result, node, options);
-                }
-                return _this._resolveNode(result, node, options);
-            });
+            this.hooks.resolve.tap("ExpressionEvaluator", this._resolveNode.bind(this));
             this.evaluate = this.evaluate.bind(this);
         }
         _create_class(ExpressionEvaluator, [
@@ -3793,14 +3759,6 @@ var AsyncNodePlugin = function() {
                     return this._execString(String(expression), resolvedOpts);
                 }
             },
-            {
-                key: "evaluateAsync",
-                value: function evaluateAsync(expr, options) {
-                    return this.evaluate(expr, _object_spread_props(_object_spread({}, options), {
-                        async: true
-                    }));
-                }
-            },
             {
                 key: "addExpressionFunction",
                 value: function addExpressionFunction(name, handler) {
@@ -3846,10 +3804,8 @@ var AsyncNodePlugin = function() {
                     var matches = exp.match(/^@\[(.*)\]@$/);
                     var matchedExp = exp;
                     if (matches) {
-                        var _Array_from = _sliced_to_array(Array.from(matches), 2), matched = _Array_from[1];
-                        if (matched) {
-                            matchedExp = matched;
-                        }
+                        var ref;
+                        ref = _sliced_to_array(Array.from(matches), 2), matchedExp = ref[1], ref;
                     }
                     var storedAST;
                     try {
@@ -4010,452 +3966,6 @@ var AsyncNodePlugin = function() {
                         return resolveNode(node.left);
                     }
                 }
-            },
-            {
-                key: "_resolveNodeAsync",
-                value: function _resolveNodeAsync(_currentValue, node, options) {
-                    var _this = this;
-                    return _async_to_generator(function() {
-                        var resolveNode, model, expressionContext, operator, _tmp, _tmp1, operator1, _tmp2, _tmp3, attributes, resolvedAttributes, expressionName, operator2, args, obj, prop, value, value1, result, operation, newValue, _tmp4, _tmp5;
-                        return _ts_generator(this, function(_state) {
-                            switch(_state.label){
-                                case 0:
-                                    resolveNode = options.resolveNode, model = options.model;
-                                    expressionContext = _object_spread_props(_object_spread({}, options), {
-                                        evaluate: function(expr) {
-                                            return _this.evaluate(expr, options);
-                                        }
-                                    });
-                                    if (!(node.type === "BinaryExpression" || node.type === "LogicalExpression")) return [
-                                        3,
-                                        7
-                                    ];
-                                    operator = _this.operators.binary.get(node.operator);
-                                    if (!operator) return [
-                                        3,
-                                        6
-                                    ];
-                                    if (!("resolveParams" in operator)) return [
-                                        3,
-                                        3
-                                    ];
-                                    if (operator.resolveParams === false) {
-                                        return [
-                                            2,
-                                            operator(expressionContext, node.left, node.right)
-                                        ];
-                                    }
-                                    _tmp = [
-                                        expressionContext
-                                    ];
-                                    return [
-                                        4,
-                                        resolveNode(node.left)
-                                    ];
-                                case 1:
-                                    _tmp = _tmp.concat([
-                                        _state.sent()
-                                    ]);
-                                    return [
-                                        4,
-                                        resolveNode(node.right)
-                                    ];
-                                case 2:
-                                    return [
-                                        2,
-                                        operator.apply(void 0, _tmp.concat([
-                                            _state.sent()
-                                        ]))
-                                    ];
-                                case 3:
-                                    return [
-                                        4,
-                                        resolveNode(node.left)
-                                    ];
-                                case 4:
-                                    _tmp1 = [
-                                        _state.sent()
-                                    ];
-                                    return [
-                                        4,
-                                        resolveNode(node.right)
-                                    ];
-                                case 5:
-                                    return [
-                                        2,
-                                        operator.apply(void 0, _tmp1.concat([
-                                            _state.sent()
-                                        ]))
-                                    ];
-                                case 6:
-                                    return [
-                                        2
-                                    ];
-                                case 7:
-                                    if (!(node.type === "UnaryExpression")) return [
-                                        3,
-                                        14
-                                    ];
-                                    operator1 = _this.operators.unary.get(node.operator);
-                                    if (!operator1) return [
-                                        3,
-                                        13
-                                    ];
-                                    if (!("resolveParams" in operator1)) return [
-                                        3,
-                                        11
-                                    ];
-                                    _tmp2 = [
-                                        expressionContext
-                                    ];
-                                    if (!(operator1.resolveParams === false)) return [
-                                        3,
-                                        8
-                                    ];
-                                    _tmp3 = node.argument;
-                                    return [
-                                        3,
-                                        10
-                                    ];
-                                case 8:
-                                    return [
-                                        4,
-                                        resolveNode(node.argument)
-                                    ];
-                                case 9:
-                                    _tmp3 = _state.sent();
-                                    _state.label = 10;
-                                case 10:
-                                    return [
-                                        2,
-                                        operator1.apply(void 0, _tmp2.concat([
-                                            _tmp3
-                                        ]))
-                                    ];
-                                case 11:
-                                    return [
-                                        4,
-                                        resolveNode(node.argument)
-                                    ];
-                                case 12:
-                                    return [
-                                        2,
-                                        operator1.apply(void 0, [
-                                            _state.sent()
-                                        ])
-                                    ];
-                                case 13:
-                                    return [
-                                        2
-                                    ];
-                                case 14:
-                                    if (!(node.type === "Object")) return [
-                                        3,
-                                        16
-                                    ];
-                                    attributes = node.attributes;
-                                    resolvedAttributes = {};
-                                    return [
-                                        4,
-                                        Promise.all(attributes.map(function() {
-                                            var _ref = _async_to_generator(function(attr) {
-                                                var key, value;
-                                                return _ts_generator(this, function(_state) {
-                                                    switch(_state.label){
-                                                        case 0:
-                                                            return [
-                                                                4,
-                                                                resolveNode(attr.key)
-                                                            ];
-                                                        case 1:
-                                                            key = _state.sent();
-                                                            return [
-                                                                4,
-                                                                resolveNode(attr.value)
-                                                            ];
-                                                        case 2:
-                                                            value = _state.sent();
-                                                            resolvedAttributes[key] = value;
-                                                            return [
-                                                                2
-                                                            ];
-                                                    }
-                                                });
-                                            });
-                                            return function(attr) {
-                                                return _ref.apply(this, arguments);
-                                            };
-                                        }()))
-                                    ];
-                                case 15:
-                                    _state.sent();
-                                    return [
-                                        2,
-                                        resolvedAttributes
-                                    ];
-                                case 16:
-                                    if (!(node.type === "CallExpression")) return [
-                                        3,
-                                        18
-                                    ];
-                                    expressionName = node.callTarget.name;
-                                    operator2 = _this.operators.expressions.get(expressionName);
-                                    if (!operator2) {
-                                        throw new Error("Unknown expression function: ".concat(expressionName));
-                                    }
-                                    if ("resolveParams" in operator2 && operator2.resolveParams === false) {
-                                        return [
-                                            2,
-                                            operator2.apply(void 0, [
-                                                expressionContext
-                                            ].concat(_to_consumable_array(node.args)))
-                                        ];
-                                    }
-                                    return [
-                                        4,
-                                        Promise.all(node.args.map(function() {
-                                            var _ref = _async_to_generator(function(n) {
-                                                return _ts_generator(this, function(_state) {
-                                                    switch(_state.label){
-                                                        case 0:
-                                                            return [
-                                                                4,
-                                                                resolveNode(n)
-                                                            ];
-                                                        case 1:
-                                                            return [
-                                                                2,
-                                                                _state.sent()
-                                                            ];
-                                                    }
-                                                });
-                                            });
-                                            return function(n) {
-                                                return _ref.apply(this, arguments);
-                                            };
-                                        }()))
-                                    ];
-                                case 17:
-                                    args = _state.sent();
-                                    return [
-                                        2,
-                                        operator2.apply(void 0, [
-                                            expressionContext
-                                        ].concat(_to_consumable_array(args)))
-                                    ];
-                                case 18:
-                                    if (node.type === "ModelRef") {
-                                        return [
-                                            2,
-                                            model.get(node.ref, {
-                                                context: {
-                                                    model: options.model
-                                                }
-                                            })
-                                        ];
-                                    }
-                                    if (!(node.type === "MemberExpression")) return [
-                                        3,
-                                        21
-                                    ];
-                                    return [
-                                        4,
-                                        resolveNode(node.object)
-                                    ];
-                                case 19:
-                                    obj = _state.sent();
-                                    return [
-                                        4,
-                                        resolveNode(node.property)
-                                    ];
-                                case 20:
-                                    prop = _state.sent();
-                                    return [
-                                        2,
-                                        obj[prop]
-                                    ];
-                                case 21:
-                                    if (!(node.type === "Assignment")) return [
-                                        3,
-                                        26
-                                    ];
-                                    if (!(node.left.type === "ModelRef")) return [
-                                        3,
-                                        23
-                                    ];
-                                    return [
-                                        4,
-                                        resolveNode(node.right)
-                                    ];
-                                case 22:
-                                    value = _state.sent();
-                                    model.set([
-                                        [
-                                            node.left.ref,
-                                            value
-                                        ]
-                                    ]);
-                                    return [
-                                        2,
-                                        value
-                                    ];
-                                case 23:
-                                    if (!(node.left.type === "Identifier")) return [
-                                        3,
-                                        25
-                                    ];
-                                    return [
-                                        4,
-                                        resolveNode(node.right)
-                                    ];
-                                case 24:
-                                    value1 = _state.sent();
-                                    _this.vars[node.left.name] = value1;
-                                    return [
-                                        2,
-                                        value1
-                                    ];
-                                case 25:
-                                    return [
-                                        2
-                                    ];
-                                case 26:
-                                    if (!(node.type === "ConditionalExpression")) return [
-                                        3,
-                                        28
-                                    ];
-                                    return [
-                                        4,
-                                        resolveNode(node.test)
-                                    ];
-                                case 27:
-                                    result = _state.sent() ? node.consequent : node.alternate;
-                                    return [
-                                        2,
-                                        resolveNode(result)
-                                    ];
-                                case 28:
-                                    if (node.type === "ArrayExpression") {
-                                        return [
-                                            2,
-                                            Promise.all(node.elements.map(function() {
-                                                var _ref = _async_to_generator(function(ele) {
-                                                    return _ts_generator(this, function(_state) {
-                                                        switch(_state.label){
-                                                            case 0:
-                                                                return [
-                                                                    4,
-                                                                    resolveNode(ele)
-                                                                ];
-                                                            case 1:
-                                                                return [
-                                                                    2,
-                                                                    _state.sent()
-                                                                ];
-                                                        }
-                                                    });
-                                                });
-                                                return function(ele) {
-                                                    return _ref.apply(this, arguments);
-                                                };
-                                            }()))
-                                        ];
-                                    }
-                                    if (!(node.type === "Modification")) return [
-                                        3,
-                                        38
-                                    ];
-                                    operation = _this.operators.binary.get(node.operator);
-                                    if (!operation) return [
-                                        3,
-                                        37
-                                    ];
-                                    if (!("resolveParams" in operation)) return [
-                                        3,
-                                        33
-                                    ];
-                                    if (!(operation.resolveParams === false)) return [
-                                        3,
-                                        29
-                                    ];
-                                    newValue = operation(expressionContext, node.left, node.right);
-                                    return [
-                                        3,
-                                        32
-                                    ];
-                                case 29:
-                                    _tmp4 = [
-                                        expressionContext
-                                    ];
-                                    return [
-                                        4,
-                                        resolveNode(node.left)
-                                    ];
-                                case 30:
-                                    _tmp4 = _tmp4.concat([
-                                        _state.sent()
-                                    ]);
-                                    return [
-                                        4,
-                                        resolveNode(node.right)
-                                    ];
-                                case 31:
-                                    newValue = operation.apply(void 0, _tmp4.concat([
-                                        _state.sent()
-                                    ]));
-                                    _state.label = 32;
-                                case 32:
-                                    return [
-                                        3,
-                                        36
-                                    ];
-                                case 33:
-                                    return [
-                                        4,
-                                        resolveNode(node.left)
-                                    ];
-                                case 34:
-                                    _tmp5 = [
-                                        _state.sent()
-                                    ];
-                                    return [
-                                        4,
-                                        resolveNode(node.right)
-                                    ];
-                                case 35:
-                                    newValue = operation.apply(void 0, _tmp5.concat([
-                                        _state.sent()
-                                    ]));
-                                    _state.label = 36;
-                                case 36:
-                                    if (node.left.type === "ModelRef") {
-                                        model.set([
-                                            [
-                                                node.left.ref,
-                                                newValue
-                                            ]
-                                        ]);
-                                    } else if (node.left.type === "Identifier") {
-                                        _this.vars[node.left.name] = newValue;
-                                    }
-                                    return [
-                                        2,
-                                        newValue
-                                    ];
-                                case 37:
-                                    return [
-                                        2,
-                                        resolveNode(node.left)
-                                    ];
-                                case 38:
-                                    return [
-                                        2,
-                                        _this._resolveNode(_currentValue, node, options)
-                                    ];
-                            }
-                        });
-                    })();
-                }
             }
         ]);
         return ExpressionEvaluator;
@@ -8020,56 +7530,15 @@ var AsyncNodePlugin = function() {
                                 validationController.reset();
                             }
                         });
-                        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 === "ACTION")) return [
-                                                3,
-                                                4
-                                            ];
-                                            exp = value.exp;
-                                            _state.label = 1;
-                                        case 1:
-                                            _state.trys.push([
-                                                1,
-                                                3,
-                                                ,
-                                                4
-                                            ]);
-                                            return [
-                                                4,
-                                                expressionEvaluator.evaluateAsync(exp)
-                                            ];
-                                        case 2:
-                                            result = _state.sent();
-                                            flowController === null || flowController === void 0 ? void 0 : flowController.transition(String(result));
-                                            return [
-                                                3,
-                                                4
-                                            ];
-                                        case 3:
-                                            e = _state.sent();
-                                            flowResultDeferred.reject(e);
-                                            return [
-                                                3,
-                                                4
-                                            ];
-                                        case 4:
-                                            expressionEvaluator.reset();
-                                            return [
-                                                2
-                                            ];
-                                    }
-                                });
-                            });
-                            return function(flowInstance) {
-                                return _ref.apply(this, arguments);
-                            };
-                        }());
+                        flow.hooks.afterTransition.tap("player", 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") {
+                                var exp = value.exp;
+                                flowController === null || flowController === void 0 ? void 0 : flowController.transition(String(expressionEvaluator === null || expressionEvaluator === void 0 ? void 0 : expressionEvaluator.evaluate(exp)));
+                            }
+                            expressionEvaluator.reset();
+                        });
                     });
                     this.hooks.dataController.call(dataController);
                     validationController.setOptions({