@player-ui/player 0.13.0 → 0.14.0-next.0

package/dist/index.legacy-esm.js

@@ -85,7 +85,7 @@ var parse = (path) => {
       next();
     }
   };
-  const identifier = () => {
+  const identifier = (allowBoolValue = false) => {
     if (!isIdentifierChar(ch)) {
       return;
     }
@@ -96,6 +96,14 @@ var parse = (path) => {
       }
       value += ch;
     }
+    if (allowBoolValue) {
+      if (value === "true") {
+        return toValue(true);
+      }
+      if (value === "false") {
+        return toValue(false);
+      }
+    }
     if (value) {
       const maybeNumber = Number(value);
       value = isNaN(maybeNumber) ? value : maybeNumber;
@@ -143,7 +151,7 @@ var parse = (path) => {
       return modelRef;
     }
   };
-  const simpleSegment = () => nestedPath() ?? expression() ?? identifier();
+  const simpleSegment = (allowBoolValue = false) => nestedPath() ?? expression() ?? identifier(allowBoolValue);
   const segment = () => {
     const segments = [];
     let nextSegment = simpleSegment();
@@ -156,7 +164,7 @@ var parse = (path) => {
     }
     return toConcatenatedNode(segments);
   };
-  const optionallyQuotedSegment = () => {
+  const optionallyQuotedSegment = (allowBoolValue = false) => {
     whitespace();
     if (ch === SINGLE_QUOTE || ch === DOUBLE_QUOTE) {
       const singleQuote = ch === SINGLE_QUOTE;
@@ -165,7 +173,7 @@ var parse = (path) => {
       next(singleQuote ? SINGLE_QUOTE : DOUBLE_QUOTE);
       return id;
     }
-    return simpleSegment();
+    return simpleSegment(allowBoolValue);
   };
   const equals = () => {
     if (ch !== EQUALS) {
@@ -185,7 +193,7 @@ var parse = (path) => {
         whitespace();
         if (equals()) {
           whitespace();
-          const second = optionallyQuotedSegment();
+          const second = optionallyQuotedSegment(true);
           value = toQuery(value, second);
           whitespace();
         }
@@ -387,7 +395,9 @@ function resolveBindingAST(bindingPathNode, options, hooks) {
         appendPathSegments(getValueForNode(resolvedNode));
         break;
       case "Value":
-        appendPathSegments(resolvedNode.value);
+        appendPathSegments(
+          typeof resolvedNode.value === "boolean" ? String(resolvedNode.value) : resolvedNode.value
+        );
         break;
       case "Query": {
         const objToQuery = options.getValue(context.path) ?? [];
@@ -2689,24 +2699,7 @@ var EMPTY_NODE = {
 var Parser = class {
   constructor() {
     this.hooks = {
-      /**
-       * A hook to interact with an object _before_ parsing it into an AST
-       *
-       * @param value - The object we're are about to parse
-       * @returns - A new value to parse.
-       *  If undefined, the original value is used.
-       *  If null, we stop parsing this node.
-       */
       onParseObject: new SyncWaterfallHook4(),
-      /**
-       * A callback to interact with an AST _after_ we parse it into the AST
-       *
-       * @param value - The object we parsed
-       * @param node - The AST node we generated
-       * @returns - A new AST node to use
-       *   If undefined, the original value is used.
-       *   If null, we ignore this node all together
-       */
       onCreateASTNode: new SyncWaterfallHook4(),
       parseNode: new SyncBailHook3()
     };
@@ -2861,27 +2854,13 @@ var withContext = (model) => {
 var Resolver = class {
   constructor(root, options) {
     this.hooks = {
-      /** A hook to allow skipping of the resolution tree for a specific node */
       skipResolve: new SyncWaterfallHook5(),
-      /** An event emitted before calculating the next update */
       beforeUpdate: new SyncHook3(),
-      /** An event emitted after calculating the next update */
       afterUpdate: new SyncHook3(),
-      /** The options passed to a node to resolve it to an object */
       resolveOptions: new SyncWaterfallHook5(),
-      /** A hook to transform the AST node into a new AST node before resolving it */
       beforeResolve: new SyncWaterfallHook5(),
-      /**
-       * A hook to transform an AST node into it's resolved value.
-       * This runs _before_ any children are resolved
-       */
       resolve: new SyncWaterfallHook5(),
-      /**
-       * A hook to transform the resolved value of an AST node.
-       * This runs _after_ all children nodes are resolved
-       */
       afterResolve: new SyncWaterfallHook5(),
-      /** Called at the very end of a node's tree being updated */
       afterNodeUpdate: new SyncHook3()
     };
     this.root = root;
@@ -2890,16 +2869,29 @@ var Resolver = class {
     this.ASTMap = /* @__PURE__ */ new Map();
     this.logger = options.logger;
     this.idCache = /* @__PURE__ */ new Set();
+    this.AsyncIdMap = /* @__PURE__ */ new Map();
   }
   getSourceNode(convertedAST) {
     return this.ASTMap.get(convertedAST);
   }
-  update(changes) {
+  update(changes, asyncChanges) {
     this.hooks.beforeUpdate.call(changes);
     const resolveCache = /* @__PURE__ */ new Map();
     this.idCache.clear();
     const prevASTMap = new Map(this.ASTMap);
     this.ASTMap.clear();
+    const prevAsyncIdMap = new Map(this.AsyncIdMap);
+    const nextAsyncIdMap = /* @__PURE__ */ new Map();
+    asyncChanges?.forEach((id) => {
+      let current = prevAsyncIdMap.get(id);
+      while (current && prevASTMap.has(current)) {
+        const next = prevASTMap.get(current);
+        if (next && this.resolveCache.has(next)) {
+          this.resolveCache.delete(next);
+        }
+        current = current.parent;
+      }
+    });
     const updated = this.computeTree(
       this.root,
       void 0,
@@ -2907,8 +2899,10 @@ var Resolver = class {
       resolveCache,
       toNodeResolveOptions(this.options),
       void 0,
-      prevASTMap
+      prevASTMap,
+      nextAsyncIdMap
     );
+    this.AsyncIdMap = nextAsyncIdMap;
     this.resolveCache = resolveCache;
     this.hooks.afterUpdate.call(updated.value);
     return updated.value;
@@ -2953,7 +2947,7 @@ var Resolver = class {
     });
     return clonedNode;
   }
-  computeTree(node, rawParent, dataChanges, cacheUpdate, options, partiallyResolvedParent, prevASTMap) {
+  computeTree(node, rawParent, dataChanges, cacheUpdate, options, partiallyResolvedParent, prevASTMap, nextAsyncIdMap) {
     const dependencyModel = new DependencyModel(options.data.model);
     dependencyModel.trackSubset("core");
     const depModelWithParser = withContext(
@@ -2979,18 +2973,6 @@ var Resolver = class {
       node,
       resolveOptions
     );
-    const clonedNode = {
-      ...this.cloneNode(node),
-      parent: partiallyResolvedParent
-    };
-    const resolvedAST = this.hooks.beforeResolve.call(
-      clonedNode,
-      resolveOptions
-    ) ?? {
-      type: "empty" /* Empty */
-    };
-    const isNestedMultiNodeWithAsync = resolvedAST.type === "multi-node" /* MultiNode */ && partiallyResolvedParent?.parent?.parent?.type === "multi-node" /* MultiNode */ && partiallyResolvedParent.parent.type === "value" /* Value */ && resolvedAST.parent?.type === "asset" /* Asset */ && resolvedAST.parent.value.id.includes("async");
-    const isNestedMultiNode = resolvedAST.type === "multi-node" /* MultiNode */ && partiallyResolvedParent?.parent?.type === "multi-node" /* MultiNode */ && partiallyResolvedParent.type === "value" /* Value */;
     if (previousResult && shouldUseLastValue) {
       const update2 = {
         ...previousResult,
@@ -3004,6 +2986,12 @@ var Resolver = class {
           updated: false
         };
         cacheUpdate.set(AST, resolvedUpdate);
+        if (resolvedUpdate.node.type === "async" /* Async */) {
+          nextAsyncIdMap.set(resolvedUpdate.node.id, resolvedUpdate.node);
+        }
+        for (const key of resolvedUpdate.node.asyncNodesResolved ?? []) {
+          nextAsyncIdMap.set(key, resolvedUpdate.node);
+        }
         const handleChildNode = (childNode) => {
           const originalChildNode = prevASTMap.get(childNode) ?? childNode;
           const previousChildResult = this.getPreviousResult(originalChildNode);
@@ -3028,10 +3016,22 @@ var Resolver = class {
       repopulateASTMapFromCache(previousResult, node, rawParent);
       return update2;
     }
-    if (isNestedMultiNodeWithAsync) {
-      resolvedAST.parent = partiallyResolvedParent.parent;
-    } else {
-      resolvedAST.parent = partiallyResolvedParent;
+    const clonedNode = {
+      ...this.cloneNode(node),
+      parent: partiallyResolvedParent
+    };
+    const resolvedAST = this.hooks.beforeResolve.call(
+      clonedNode,
+      resolveOptions
+    ) ?? {
+      type: "empty" /* Empty */
+    };
+    resolvedAST.parent = partiallyResolvedParent;
+    if (resolvedAST.type === "async" /* Async */) {
+      nextAsyncIdMap.set(resolvedAST.id, resolvedAST);
+    }
+    for (const id of resolvedAST.asyncNodesResolved ?? []) {
+      nextAsyncIdMap.set(id, resolvedAST);
     }
     resolveOptions.node = resolvedAST;
     this.ASTMap.set(resolvedAST, node);
@@ -3055,7 +3055,8 @@ var Resolver = class {
           cacheUpdate,
           resolveOptions,
           resolvedAST,
-          prevASTMap
+          prevASTMap,
+          nextAsyncIdMap
         );
         const {
           dependencies: childTreeDeps,
@@ -3081,9 +3082,8 @@ var Resolver = class {
       resolvedAST.children = newChildren;
     } else if (resolvedAST.type === "multi-node" /* MultiNode */) {
       const childValue = [];
-      const rawParentToPassIn = isNestedMultiNode ? partiallyResolvedParent?.parent : node;
-      const hasAsync = resolvedAST.values.map((value, index) => value.type === "async" /* Async */ ? index : -1).filter((index) => index !== -1);
-      const newValues = resolvedAST.values.map((mValue) => {
+      const rawParentToPassIn = node;
+      resolvedAST.values = resolvedAST.values.map((mValue) => {
         const mTree = this.computeTree(
           mValue,
           rawParentToPassIn,
@@ -3091,31 +3091,18 @@ var Resolver = class {
           cacheUpdate,
           resolveOptions,
           resolvedAST,
-          prevASTMap
+          prevASTMap,
+          nextAsyncIdMap
         );
         if (mTree.value !== void 0 && mTree.value !== null) {
-          if (mValue.type === "async" /* Async */ && mValue.flatten && mTree.value.asset && Array.isArray(mTree.value.asset.values)) {
-            unpackAndPush(mTree.value, childValue);
-          } else {
-            childValue.push(mTree.value);
-          }
+          mTree.dependencies.forEach(
+            (bindingDep) => childDependencies.add(bindingDep)
+          );
+          updated = updated || mTree.updated;
+          childValue.push(mTree.value);
         }
-        mTree.dependencies.forEach(
-          (bindingDep) => childDependencies.add(bindingDep)
-        );
-        updated = updated || mTree.updated;
         return mTree.node;
       });
-      if (hasAsync.length > 0) {
-        const copy = newValues;
-        hasAsync.forEach((index) => {
-          if (copy[index])
-            copy.splice(index, 1, ...unpackNode(copy[index]));
-        });
-        resolvedAST.values = copy;
-      } else {
-        resolvedAST.values = newValues;
-      }
       resolved = childValue;
     }
     childDependencies.forEach(
@@ -3138,37 +3125,11 @@ var Resolver = class {
         ...childDependencies
       ])
     };
-    this.hooks.afterNodeUpdate.call(
-      node,
-      isNestedMultiNode ? partiallyResolvedParent?.parent : rawParent,
-      update
-    );
+    this.hooks.afterNodeUpdate.call(node, rawParent, update);
     cacheUpdate.set(node, update);
     return update;
   }
 };
-function unpackAndPush(item, initial) {
-  if (item.asset.values && Array.isArray(item.asset.values)) {
-    item.asset.values.forEach((i) => {
-      unpackAndPush(i, initial);
-    });
-  } else {
-    initial.push(item);
-  }
-}
-function unpackNode(item) {
-  const unpacked = [];
-  if ("children" in item && item.children?.[0]?.value.type === "asset" /* Asset */ && (item.children?.[0]?.value).children) {
-    if ((item.children?.[0]?.value).children?.[0]?.value.type === "multi-node" /* MultiNode */) {
-      ((item.children?.[0]?.value).children?.[0]?.value).values.forEach((value) => {
-        unpacked.push(value);
-      });
-    }
-  } else {
-    unpacked.push(item);
-  }
-  return unpacked;
-}
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/view.ts
 var CrossfieldProvider = class {
@@ -3222,8 +3183,8 @@ var ViewInstance = class {
     this.initialView = initialView;
     this.resolverOptions = resolverOptions;
   }
-  updateAsync() {
-    const update = this.resolver?.update();
+  updateAsync(asyncNode) {
+    const update = this.resolver?.update(/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set([asyncNode]));
     this.lastUpdate = update;
     this.hooks.onUpdate.call(update);
   }
@@ -3317,11 +3278,12 @@ var Builder = class _Builder {
    *
    * @param id - the id of async node. It should be identical for each async node
    */
-  static asyncNode(id, flatten2 = true) {
+  static asyncNode(id, flatten2 = true, onValueReceived) {
     return {
       id,
       type: "async" /* Async */,
       flatten: flatten2,
+      onValueReceived,
       value: {
         type: "value" /* Value */,
         value: {
@@ -3789,7 +3751,7 @@ var MultiNodePlugin = class {
     parser.hooks.parseNode.tap(
       "multi-node",
       (obj, nodeType, options, childOptions) => {
-        if (childOptions && !hasTemplateKey(childOptions.key) && Array.isArray(obj)) {
+        if ((childOptions === void 0 || !hasTemplateKey(childOptions.key)) && Array.isArray(obj)) {
           const values = obj.map(
             (childVal) => parser.parseObject(childVal, "value" /* Value */, options)
           ).filter((child) => !!child);
@@ -3799,10 +3761,7 @@ var MultiNodePlugin = class {
           const multiNode = parser.createASTNode(
             {
               type: "multi-node" /* MultiNode */,
-              override: !hasTemplateValues(
-                childOptions.parentObj,
-                childOptions.key
-              ),
+              override: childOptions !== void 0 && !hasTemplateValues(childOptions.parentObj, childOptions.key),
               values
             },
             obj
@@ -3815,7 +3774,7 @@ var MultiNodePlugin = class {
               v.parent = multiNode;
             });
           }
-          return [
+          return childOptions === void 0 ? multiNode : [
             {
               path: [...childOptions.path, childOptions.key],
               value: multiNode