@player-ui/reference-assets-plugin 0.13.0-next.5 → 0.13.0-next.6

package/dist/ReferenceAssetsPlugin.native.js

@@ -2815,6 +2815,67 @@ var ReferenceAssetsPlugin = function() {
         ]);
         return SyncWaterfallHook;
     }(Hook);
+    var AsyncParallelBailHook = /*#__PURE__*/ function(Hook) {
+        _inherits(AsyncParallelBailHook, Hook);
+        var _super = _create_super(AsyncParallelBailHook);
+        function AsyncParallelBailHook() {
+            _class_call_check(this, AsyncParallelBailHook);
+            return _super.apply(this, arguments);
+        }
+        _create_class(AsyncParallelBailHook, [
+            {
+                key: "call",
+                value: function call() {
+                    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                        args[_key] = arguments[_key];
+                    }
+                    var _this = this;
+                    return _async_to_generator(function() {
+                        var _this_interceptions, ctx, rtn, e;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    ctx = {};
+                                    (_this_interceptions = _this.interceptions).call.apply(_this_interceptions, [
+                                        ctx
+                                    ].concat(_to_consumable_array(args)));
+                                    _state.label = 1;
+                                case 1:
+                                    _state.trys.push([
+                                        1,
+                                        3,
+                                        ,
+                                        4
+                                    ]);
+                                    return [
+                                        4,
+                                        Promise.race(_this.taps.map(function(tap) {
+                                            return callTap(tap, args, ctx);
+                                        }))
+                                    ];
+                                case 2:
+                                    rtn = _state.sent();
+                                    _this.interceptions.result(rtn);
+                                    return [
+                                        2,
+                                        rtn
+                                    ];
+                                case 3:
+                                    e = _state.sent();
+                                    _this.interceptions.error(e);
+                                    throw e;
+                                case 4:
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    })();
+                }
+            }
+        ]);
+        return AsyncParallelBailHook;
+    }(Hook);
     // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/@player-ui+player@0.0.0/node_modules/@player-ui/player/dist/index.mjs
     var import_ts_nested_error = __toESM(require_nested_error(), 1);
     var import_ts_nested_error2 = __toESM(require_nested_error(), 1);
@@ -4874,6 +4935,19 @@ var ReferenceAssetsPlugin = 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;
+    }(NodeType || {});
     var EMPTY_NODE = {
         type: "empty"
     };
@@ -8280,6 +8354,266 @@ var ReferenceAssetsPlugin = function() {
         ], multiNode);
         return wrapperAsset;
     };
+    var AsyncNodePluginSymbol = Symbol.for("AsyncNodePlugin");
+    var _AsyncNodePlugin = /*#__PURE__*/ function() {
+        function _AsyncNodePlugin2(options, asyncHandler) {
+            var _this = this;
+            _class_call_check(this, _AsyncNodePlugin2);
+            this.symbol = _AsyncNodePlugin2.Symbol;
+            this.hooks = {
+                onAsyncNode: new AsyncParallelBailHook(),
+                onAsyncNodeError: new SyncBailHook()
+            };
+            this.name = "AsyncNode";
+            if (options === null || options === void 0 ? void 0 : options.plugins) {
+                this.plugins = options.plugins;
+                options.plugins.forEach(function(plugin) {
+                    plugin.applyPlugin(_this);
+                });
+            }
+            if (asyncHandler) {
+                this.hooks.onAsyncNode.tap("async", function() {
+                    var _ref = _async_to_generator(function(node, callback) {
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    return [
+                                        4,
+                                        asyncHandler(node, callback)
+                                    ];
+                                case 1:
+                                    return [
+                                        2,
+                                        _state.sent()
+                                    ];
+                            }
+                        });
+                    });
+                    return function(node, callback) {
+                        return _ref.apply(this, arguments);
+                    };
+                }());
+            }
+        }
+        _create_class(_AsyncNodePlugin2, [
+            {
+                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;
+                            (_this_plugins = _this.plugins) === null || _this_plugins === void 0 ? void 0 : _this_plugins.forEach(function(plugin) {
+                                plugin.apply(view);
+                            });
+                        });
+                    });
+                }
+            }
+        ]);
+        return _AsyncNodePlugin2;
+    }();
+    _AsyncNodePlugin.Symbol = AsyncNodePluginSymbol;
+    var AsyncNodePlugin = _AsyncNodePlugin;
+    var AsyncNodePluginPlugin = /*#__PURE__*/ function() {
+        function AsyncNodePluginPlugin() {
+            _class_call_check(this, AsyncNodePluginPlugin);
+            this.asyncNode = new AsyncParallelBailHook();
+            this.name = "AsyncNode";
+        }
+        _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 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, context, newNode) {
+                    var nodeResolveCache = context.nodeResolveCache, view = context.view;
+                    if (nodeResolveCache.get(node.id) !== newNode) {
+                        nodeResolveCache.set(node.id, newNode ? newNode : node);
+                        view.updateAsync();
+                    }
+                }
+            },
+            {
+                /**
+     * Handles the asynchronous API integration for resolving nodes.
+     * This method sets up a hook on the resolver's `beforeResolve` event to process async nodes.
+     * @param resolver The resolver instance to attach the hook to.
+     * @param view
+     */ key: "applyResolver",
+                value: function applyResolver(resolver, context) {
+                    var _this = this;
+                    resolver.hooks.beforeResolve.tap(this.name, function(node, options) {
+                        if (!_this.isAsync(node)) {
+                            return node;
+                        }
+                        var resolvedNode = context.nodeResolveCache.get(node.id);
+                        if (resolvedNode !== void 0) {
+                            return resolvedNode;
+                        }
+                        if (context.inProgressNodes.has(node.id)) {
+                            return node;
+                        }
+                        context.inProgressNodes.add(node.id);
+                        (0, import_queue_microtask3.default)(function() {
+                            _this.runAsyncNode(node, context, options).finally();
+                        });
+                        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();
+                                    context.inProgressNodes.delete(node.id);
+                                    _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);
+                                    context.inProgressNodes.delete(node.id);
+                                    _this.parseNodeAndUpdate(node, context, result1, options);
+                                    return [
+                                        3,
+                                        3
+                                    ];
+                                case 3:
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    })();
+                }
+            },
+            {
+                key: "isAsync",
+                value: function isAsync(node) {
+                    return (node === null || node === void 0 ? void 0 : node.type) === NodeType.Async;
+                }
+            },
+            {
+                key: "isDeterminedAsync",
+                value: function isDeterminedAsync(obj) {
+                    return obj && Object.prototype.hasOwnProperty.call(obj, "async");
+                }
+            },
+            {
+                key: "applyParser",
+                value: function applyParser(parser) {
+                    var _this = this;
+                    parser.hooks.parseNode.tap(this.name, function(obj, nodeType, options, childOptions) {
+                        if (_this.isDeterminedAsync(obj)) {
+                            var parsedAsync = parser.parseObject((0, import_timm10.omit)(obj, "async"), nodeType, options);
+                            var parsedNodeId = getNodeID(parsedAsync);
+                            if (parsedAsync === null || !parsedNodeId) {
+                                return childOptions ? [] : null;
+                            }
+                            var asyncAST = parser.createASTNode({
+                                id: parsedNodeId,
+                                type: NodeType.Async,
+                                value: parsedAsync
+                            }, obj);
+                            if (childOptions) {
+                                return asyncAST ? [
+                                    {
+                                        path: _to_consumable_array(childOptions.path).concat([
+                                            childOptions.key
+                                        ]),
+                                        value: asyncAST
+                                    }
+                                ] : [];
+                            }
+                            return asyncAST;
+                        }
+                    });
+                }
+            },
+            {
+                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: "applyPlugin",
+                value: function applyPlugin(asyncNodePlugin) {
+                    this.basePlugin = asyncNodePlugin;
+                }
+            }
+        ]);
+        return AsyncNodePluginPlugin;
+    }();
     // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/reference-assets/core/src/assets/chat-message/transform.ts
     var transform2 = function(asset) {
         var _asset_children_, _asset_children;
@@ -8290,13 +8624,155 @@ var ReferenceAssetsPlugin = function() {
         return asyncTransform(asset.value.id, "collection", newAsset);
     };
     var chatMessageTransform = compose(composeBefore(transform2));
-    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/reference-assets/core/src/plugin.ts
-    var ReferenceAssetsPlugin = /*#__PURE__*/ function() {
-        function ReferenceAssetsPlugin() {
-            _class_call_check(this, ReferenceAssetsPlugin);
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/@player-ui+meta-plugin@0.0.0/node_modules/@player-ui/meta-plugin/dist/index.mjs
+    var MetaPlugin = /*#__PURE__*/ function() {
+        function MetaPlugin() {
+            var plugins = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+            _class_call_check(this, MetaPlugin);
+            this.name = "meta-plugin";
+            this.plugins = plugins;
+        }
+        _create_class(MetaPlugin, [
+            {
+                key: "apply",
+                value: function apply(player) {
+                    this.plugins.forEach(function(plugin) {
+                        return player.registerPlugin(plugin);
+                    });
+                }
+            }
+        ]);
+        return MetaPlugin;
+    }();
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/node_modules/.aspect_rules_js/@player-ui+expression-plugin@0.0.0/node_modules/@player-ui/expression-plugin/dist/index.mjs
+    var ExpressionPlugin = /*#__PURE__*/ function() {
+        function ExpressionPlugin(expressionMap) {
+            _class_call_check(this, ExpressionPlugin);
+            this.name = "ExpressionPlugin";
+            this.expressions = expressionMap;
+        }
+        _create_class(ExpressionPlugin, [
+            {
+                key: "apply",
+                value: function apply(player) {
+                    var _this = this;
+                    player.hooks.expressionEvaluator.tap(this.name, function(expEvaluator) {
+                        _this.expressions.forEach(function(handler, name) {
+                            expEvaluator.addExpressionFunction(name, handler);
+                        });
+                    });
+                }
+            }
+        ]);
+        return ExpressionPlugin;
+    }();
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/reference-assets/core/src/plugins/chat-ui-demo-plugin.ts
+    var createContentFromMessage = function(message, id) {
+        return {
+            asset: {
+                type: "chat-message",
+                id: id,
+                value: {
+                    asset: {
+                        type: "text",
+                        id: "".concat(id, "-value"),
+                        value: message
+                    }
+                }
+            }
+        };
+    };
+    var ChatUiDemoPlugin = /*#__PURE__*/ function() {
+        function ChatUiDemoPlugin() {
+            _class_call_check(this, ChatUiDemoPlugin);
+            this.name = "chat-ui-demo-plugin";
+        }
+        _create_class(ChatUiDemoPlugin, [
+            {
+                key: "apply",
+                value: function apply(player) {
+                    var asyncNodePlugin = player.findPlugin(AsyncNodePlugin.Symbol);
+                    if (!asyncNodePlugin) {
+                        player.logger.warn("Failed to apply '".concat(this.name, "'. Reason: Could not find AsyncNodePlugin."));
+                        return;
+                    }
+                    var deferredPromises = {};
+                    var allPromiseKeys = [];
+                    var counter = 0;
+                    var sendMessage = function(context, message, nodeId) {
+                        if (nodeId && !(nodeId in deferredPromises)) {
+                            var _context_logger;
+                            (_context_logger = context.logger) === null || _context_logger === void 0 ? void 0 : _context_logger.warn("'send' expression called with unrecognized id '".concat(nodeId, "'"));
+                            return;
+                        }
+                        if (!nodeId && allPromiseKeys.length === 0) {
+                            var _context_logger1;
+                            (_context_logger1 = context.logger) === null || _context_logger1 === void 0 ? void 0 : _context_logger1.warn("'send' called with no waiting async nodes");
+                            return;
+                        }
+                        var keys = nodeId ? [
+                            nodeId
+                        ] : allPromiseKeys;
+                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                var id = _step.value;
+                                var content = createContentFromMessage(message, "message-".concat(counter++));
+                                var resolveFunction = deferredPromises[id];
+                                resolveFunction === null || resolveFunction === void 0 ? void 0 : resolveFunction(content);
+                                delete deferredPromises[id];
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        if (nodeId) {
+                            var index = allPromiseKeys.indexOf(nodeId);
+                            allPromiseKeys.splice(index, 1);
+                        } else {
+                            allPromiseKeys = [];
+                        }
+                    };
+                    asyncNodePlugin.hooks.onAsyncNode.tap(this.name, function(node) {
+                        return new Promise(function(res) {
+                            deferredPromises[node.id] = res;
+                            allPromiseKeys.push(node.id);
+                        });
+                    });
+                    player.hooks.view.tap(this.name, function(_) {
+                        deferredPromises = {};
+                        allPromiseKeys = [];
+                        counter = 0;
+                    });
+                    var expressionPlugin = new ExpressionPlugin(/* @__PURE__ */ new Map([
+                        [
+                            "send",
+                            sendMessage
+                        ]
+                    ]));
+                    player.registerPlugin(expressionPlugin);
+                }
+            }
+        ]);
+        return ChatUiDemoPlugin;
+    }();
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/reference-assets/core/src/plugins/reference-assets-transform-plugin.ts
+    var ReferenceAssetsTransformPlugin = /*#__PURE__*/ function() {
+        function ReferenceAssetsTransformPlugin() {
+            _class_call_check(this, ReferenceAssetsTransformPlugin);
             this.name = "reference-assets-transforms";
         }
-        _create_class(ReferenceAssetsPlugin, [
+        _create_class(ReferenceAssetsTransformPlugin, [
             {
                 key: "apply",
                 value: function apply(player) {
@@ -8341,6 +8817,31 @@ var ReferenceAssetsPlugin = function() {
                 }
             }
         ]);
+        return ReferenceAssetsTransformPlugin;
+    }();
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/reference-assets/core/src/plugin.ts
+    var ReferenceAssetsPlugin = /*#__PURE__*/ function() {
+        function ReferenceAssetsPlugin() {
+            _class_call_check(this, ReferenceAssetsPlugin);
+            this.name = "reference-assets-plugin";
+            this.metaPlugin = new MetaPlugin([
+                new AsyncNodePlugin({
+                    plugins: [
+                        new AsyncNodePluginPlugin()
+                    ]
+                }),
+                new ReferenceAssetsTransformPlugin(),
+                new ChatUiDemoPlugin()
+            ]);
+        }
+        _create_class(ReferenceAssetsPlugin, [
+            {
+                key: "apply",
+                value: function apply(player) {
+                    player.registerPlugin(this.metaPlugin);
+                }
+            }
+        ]);
         return ReferenceAssetsPlugin;
     }();
     return __toCommonJS(src_exports);