@player-ui/player 0.11.1-next.0 → 0.11.2-next.0

package/package.json

@@ -6,12 +6,12 @@
     "types"
   ],
   "name": "@player-ui/player",
-  "version": "0.11.1-next.0",
+  "version": "0.11.2-next.0",
   "main": "dist/cjs/index.cjs",
   "dependencies": {
-    "@player-ui/partial-match-registry": "0.11.1-next.0",
-    "@player-ui/make-flow": "0.11.1-next.0",
-    "@player-ui/types": "0.11.1-next.0",
+    "@player-ui/partial-match-registry": "0.11.2-next.0",
+    "@player-ui/make-flow": "0.11.2-next.0",
+    "@player-ui/types": "0.11.2-next.0",
     "@types/dlv": "^1.1.4",
     "dequal": "^2.0.2",
     "dlv": "^1.1.3",

package/src/view/resolver/index.ts

@@ -1,5 +1,5 @@
-import { SyncWaterfallHook, SyncHook } from "tapable-ts";
-import { setIn, addLast, clone } from "timm";
+import { SyncHook, SyncWaterfallHook } from "tapable-ts";
+import { addLast, clone, setIn } from "timm";
 import dlv from "dlv";
 import { dequal } from "dequal";
 import type { BindingInstance, BindingLike } from "../../binding";
@@ -10,13 +10,8 @@ import type {
 } from "../../data";
 import { DependencyModel, withParser } from "../../data";
 import type { Logger } from "../../logger";
-import type { Node } from "../parser";
-import { NodeType } from "../parser";
-import {
-  caresAboutDataChanges,
-  toNodeResolveOptions,
-  unpackAndPush,
-} from "./utils";
+import { Node, NodeType } from "../parser";
+import { caresAboutDataChanges, toNodeResolveOptions } from "./utils";
 import type { Resolve } from "./types";
 import { getNodeID } from "../parser/utils";
 
@@ -276,6 +271,13 @@ export class Resolver {
       type: NodeType.Empty,
     };
 
+    const isNestedMultiNodeWithAsync =
+      resolvedAST.type === NodeType.MultiNode &&
+      partiallyResolvedParent?.parent?.parent?.type === NodeType.MultiNode &&
+      partiallyResolvedParent.parent.type === NodeType.Value &&
+      resolvedAST.parent?.type === NodeType.Asset &&
+      resolvedAST.parent.value.id.includes("async");
+
     const isNestedMultiNode =
       resolvedAST.type === NodeType.MultiNode &&
       partiallyResolvedParent?.parent?.type === NodeType.MultiNode &&
@@ -334,7 +336,11 @@ export class Resolver {
       return update;
     }
 
-    resolvedAST.parent = partiallyResolvedParent;
+    if (isNestedMultiNodeWithAsync) {
+      resolvedAST.parent = partiallyResolvedParent.parent;
+    } else {
+      resolvedAST.parent = partiallyResolvedParent;
+    }
 
     resolveOptions.node = resolvedAST;
 
@@ -399,6 +405,10 @@ export class Resolver {
         ? partiallyResolvedParent?.parent
         : node;
 
+      const hasAsync = resolvedAST.values
+        .map((value, index) => (value.type === NodeType.Async ? index : -1))
+        .filter((index) => index !== -1);
+
       const newValues = resolvedAST.values.map((mValue) => {
         const mTree = this.computeTree(
           mValue,
@@ -423,6 +433,7 @@ export class Resolver {
             mTree.value.asset &&
             Array.isArray(mTree.value.asset.values)
           ) {
+            // This flatten function only changed the values not node structure
             unpackAndPush(mTree.value, childValue);
           } else {
             childValue.push(mTree.value);
@@ -438,7 +449,16 @@ export class Resolver {
         return mTree.node;
       });
 
-      resolvedAST.values = newValues;
+      if (hasAsync.length > 0) {
+        // this likely turned into a nested multinode, attempt to flatten in node structure
+        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;
     }
 
@@ -477,3 +497,40 @@ export class Resolver {
     return update;
   }
 }
+
+/**
+ * helper function to flatten a potential nested array and combine with initial array
+ */
+function unpackAndPush(item: any | any[], initial: any[]): void {
+  if (item.asset.values && Array.isArray(item.asset.values)) {
+    item.asset.values.forEach((i: any) => {
+      unpackAndPush(i, initial);
+    });
+  } else {
+    initial.push(item);
+  }
+}
+
+function unpackNode(item: Node.Node) {
+  const unpacked: Node.Node[] = [];
+  if (
+    "children" in item &&
+    item.children?.[0]?.value.type === NodeType.Asset &&
+    (item.children?.[0]?.value as Node.Asset).children
+  ) {
+    if (
+      (item.children?.[0]?.value as Node.Asset).children?.[0]?.value.type ===
+      NodeType.MultiNode
+    ) {
+      (
+        (item.children?.[0]?.value as Node.Asset).children?.[0]
+          ?.value as Node.MultiNode
+      ).values.forEach((value) => {
+        unpacked.push(value);
+      });
+    }
+  } else {
+    unpacked.push(item);
+  }
+  return unpacked;
+}

package/src/view/resolver/utils.ts

@@ -55,16 +55,3 @@ export function toNodeResolveOptions(
       resolverOptions.evaluator.evaluate(exp, resolverOptions),
   };
 }
-
-/**
- * helper function to flatten a potential nested array and combine with initial array
- */
-export function unpackAndPush(item: any | any[], initial: any[]) {
-  if (item.asset.values && Array.isArray(item.asset.values)) {
-    item.asset.values.forEach((i: any) => {
-      unpackAndPush(i, initial);
-    });
-  } else {
-    initial.push(item);
-  }
-}

package/types/view/resolver/index.d.ts

@@ -1,6 +1,6 @@
-import { SyncWaterfallHook, SyncHook } from "tapable-ts";
+import { SyncHook, SyncWaterfallHook } from "tapable-ts";
 import type { BindingInstance } from "../../binding";
-import type { Node } from "../parser";
+import { Node } from "../parser";
 import type { Resolve } from "./types";
 export * from "./types";
 export * from "./utils";

package/types/view/resolver/utils.d.ts

@@ -4,8 +4,4 @@ import type { Resolve } from "./types";
 export declare function caresAboutDataChanges(dataChanges?: Set<BindingInstance>, dependencies?: Set<BindingInstance>): boolean;
 /** Convert the options object for a resolver to one for a node */
 export declare function toNodeResolveOptions(resolverOptions: Resolve.ResolverOptions): Resolve.NodeResolveOptions;
-/**
- * helper function to flatten a potential nested array and combine with initial array
- */
-export declare function unpackAndPush(item: any | any[], initial: any[]): void;
 //# sourceMappingURL=utils.d.ts.map