@player-ui/player 0.10.4-next.2 → 0.10.4

package/package.json

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

package/src/view/builder/index.test.ts

@@ -32,6 +32,44 @@ describe("multiNode", () => {
     expect(v1.parent).toBe(result);
     expect(v2.parent).toBe(result);
   });
+
+  test("multinode with async node", () => {
+    const v1 = Builder.asyncNode("1");
+    const v2 = Builder.asyncNode("2");
+    const result = Builder.multiNode(v1, v2);
+
+    expect(result.type).toBe(NodeType.MultiNode);
+    expect(result.values[0]?.type).toBe("async");
+    expect(result.values[1]?.type).toBe("async");
+    expect(v1.parent).toBe(result);
+    expect(v2.parent).toBe(result);
+  });
+});
+
+test("async node", () => {
+  const result = Builder.asyncNode("1", false);
+  expect(result.type).toBe(NodeType.Async);
+  expect(result.id).toBe("1");
+  expect(result.flatten).toBe(false);
+
+  const result2 = Builder.asyncNode("2");
+  expect(result2.type).toBe(NodeType.Async);
+  expect(result2.id).toBe("2");
+  expect(result2.flatten).toBe(true);
+});
+
+test("asset wrapper", () => {
+  const result = Builder.assetWrapper({
+    type: NodeType.Asset,
+    value: {
+      id: "1",
+      type: "text",
+      value: "chat message",
+    },
+  });
+
+  expect(result.type).toBe(NodeType.Value);
+  expect(result.children?.[0]?.value.type).toBe("asset");
 });
 
 describe("addChild", () => {

package/src/view/builder/index.ts

@@ -17,6 +17,12 @@ export class Builder {
     };
   }
 
+  static assetWrapper<T extends Node.Node>(value: T): Node.Value {
+    const valueNode = Builder.value();
+    Builder.addChild(valueNode, "asset", value);
+    return valueNode;
+  }
+
   /**
    * Creates a value node
    *
@@ -33,10 +39,10 @@ export class Builder {
    * Creates a multiNode and associates the multiNode as the parent
    * of all the value nodes
    *
-   * @param values - the value or applicability nodes to put in the multinode
+   * @param values - the value, applicability or async nodes to put in the multinode
    */
   static multiNode(
-    ...values: (Node.Value | Node.Applicability)[]
+    ...values: (Node.Value | Node.Applicability | Node.Async)[]
   ): Node.MultiNode {
     const m: Node.MultiNode = {
       type: NodeType.MultiNode,
@@ -52,6 +58,25 @@ export class Builder {
     return m;
   }
 
+  /**
+   * Creates an async node
+   *
+   * @param id - the id of async node. It should be identical for each async node
+   */
+  static asyncNode(id: string, flatten = true): Node.Async {
+    return {
+      id,
+      type: NodeType.Async,
+      flatten: flatten,
+      value: {
+        type: NodeType.Value,
+        value: {
+          id,
+        },
+      },
+    };
+  }
+
   /**
    * Adds a child node to a node
    *

package/src/view/parser/types.ts

@@ -116,6 +116,10 @@ export declare namespace Node {
     id: string;
     /** The value representing the node */
     value: Node;
+    /**
+     * Should the content streamed in be flattened during resolving
+     */
+    flatten?: boolean;
   }
 
   export interface PluginOptions {

package/src/view/resolver/index.ts

@@ -12,7 +12,11 @@ import { DependencyModel, withParser } from "../../data";
 import type { Logger } from "../../logger";
 import type { Node } from "../parser";
 import { NodeType } from "../parser";
-import { caresAboutDataChanges, toNodeResolveOptions } from "./utils";
+import {
+  caresAboutDataChanges,
+  toNodeResolveOptions,
+  unpackAndPush,
+} from "./utils";
 import type { Resolve } from "./types";
 import { getNodeID } from "../parser/utils";
 
@@ -163,7 +167,6 @@ export class Resolver {
     );
     this.resolveCache = resolveCache;
     this.hooks.afterUpdate.call(updated.value);
-
     return updated.value;
   }
 
@@ -408,7 +411,24 @@ export class Resolver {
         );
 
         if (mTree.value !== undefined && mTree.value !== null) {
-          childValue.push(mTree.value);
+          /**
+           * async nodes' parent is a multi-node
+           * When the node to resolve is an async node and the flatten flag is true
+           * Add the content streamed in to the childValue of parent multi-node
+           * Array.isArray(mTree.value.asset.values) is the case when the content is an async asset
+           */
+          if (
+            mValue.type === NodeType.Async &&
+            mValue.flatten &&
+            mTree.value.asset &&
+            Array.isArray(mTree.value.asset.values)
+          ) {
+            mTree.value.asset.values.forEach((v: any) => {
+              unpackAndPush(v, childValue);
+            });
+          } else {
+            childValue.push(mTree.value);
+          }
         }
 
         mTree.dependencies.forEach((bindingDep) =>

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

@@ -10,6 +10,7 @@ export declare class Builder {
      * @param value - the value to put in the asset node
      */
     static asset<T extends AnyAssetType>(value: T): Node.Asset<T>;
+    static assetWrapper<T extends Node.Node>(value: T): Node.Value;
     /**
      * Creates a value node
      *
@@ -20,9 +21,15 @@ export declare class Builder {
      * Creates a multiNode and associates the multiNode as the parent
      * of all the value nodes
      *
-     * @param values - the value or applicability nodes to put in the multinode
+     * @param values - the value, applicability or async nodes to put in the multinode
      */
-    static multiNode(...values: (Node.Value | Node.Applicability)[]): Node.MultiNode;
+    static multiNode(...values: (Node.Value | Node.Applicability | Node.Async)[]): Node.MultiNode;
+    /**
+     * Creates an async node
+     *
+     * @param id - the id of async node. It should be identical for each async node
+     */
+    static asyncNode(id: string, flatten?: boolean): Node.Async;
     /**
      * Adds a child node to a node
      *

package/types/view/parser/types.d.ts

@@ -87,6 +87,10 @@ export declare namespace Node {
         id: string;
         /** The value representing the node */
         value: Node;
+        /**
+         * Should the content streamed in be flattened during resolving
+         */
+        flatten?: boolean;
     }
     interface PluginOptions {
         /** A list of plugins */