@player-ui/player 0.8.0-next.4 → 0.8.0-next.6

package/package.json

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

package/src/plugins/default-view-plugin.ts

@@ -1,6 +1,8 @@
 import type { Player, PlayerPlugin } from "../player";
 import {
   ApplicabilityPlugin,
+  AssetPlugin,
+  MultiNodePlugin,
   StringResolverPlugin,
   SwitchPlugin,
   TemplatePlugin,
@@ -17,12 +19,14 @@ export class DefaultViewPlugin implements PlayerPlugin {
     player.hooks.viewController.tap(this.name, (viewController) => {
       viewController.hooks.view.tap(this.name, (view) => {
         const pluginOptions = toNodeResolveOptions(view.resolverOptions);
+        new AssetPlugin().apply(view);
         new SwitchPlugin(pluginOptions).apply(view);
         new ApplicabilityPlugin().apply(view);
         new StringResolverPlugin().apply(view);
         const templatePlugin = new TemplatePlugin(pluginOptions);
         templatePlugin.apply(view);
         view.hooks.onTemplatePluginCreated.call(templatePlugin);
+        new MultiNodePlugin().apply(view);
       });
     });
   }

package/src/view/__tests__/view.immutable.test.ts

@@ -3,7 +3,12 @@ import { LocalModel, withParser, PipelinedDataModel } from "../../data";
 import { ExpressionEvaluator } from "../../expressions";
 import { BindingParser } from "../../binding";
 import { SchemaController } from "../../schema";
-import { ApplicabilityPlugin, StringResolverPlugin, ViewInstance } from "..";
+import {
+  ApplicabilityPlugin,
+  AssetPlugin,
+  StringResolverPlugin,
+  ViewInstance,
+} from "..";
 import { NodeType } from "../parser";
 
 const parseBinding = new BindingParser().parse;
@@ -34,6 +39,7 @@ test("uses the exact same object if nothing changes", () => {
   );
 
   new StringResolverPlugin().apply(view);
+  new AssetPlugin().apply(view);
 
   view.hooks.resolver.tap("input", (resolver) => {
     resolver.hooks.resolve.tap("input", (value, astNode, options) => {
@@ -205,6 +211,7 @@ test("hardcore immutability", () => {
   );
 
   new StringResolverPlugin().apply(view);
+  new AssetPlugin().apply(view);
 
   const resolved = view.update();
 

package/src/view/__tests__/view.test.ts

@@ -4,6 +4,7 @@ import { ExpressionEvaluator } from "../../expressions";
 import { BindingParser } from "../../binding";
 import { SchemaController } from "../../schema";
 import {
+  MultiNodePlugin,
   StringResolverPlugin,
   SwitchPlugin,
   ViewInstance,
@@ -80,7 +81,7 @@ describe("view", () => {
       expect(updated).toBe(resolved);
     });
 
-    test("works with no valid switch cases in an array", () => {
+    test("works with no valid static switch cases in an array", () => {
       const model = withParser(new LocalModel({}), parseBinding);
       const evaluator = new ExpressionEvaluator({ model });
       const schema = new SchemaController();
@@ -122,6 +123,7 @@ describe("view", () => {
 
       const pluginOptions = toNodeResolveOptions(view.resolverOptions);
       new SwitchPlugin(pluginOptions).apply(view);
+      new MultiNodePlugin().apply(view);
       new StringResolverPlugin().apply(view);
 
       const resolved = view.update();
@@ -132,6 +134,60 @@ describe("view", () => {
       });
     });
 
+    test("works with no valid dynamic switch cases in an array", () => {
+      const model = withParser(new LocalModel({}), parseBinding);
+      const evaluator = new ExpressionEvaluator({ model });
+      const schema = new SchemaController();
+
+      const view = new ViewInstance(
+        {
+          id: "test",
+          type: "view",
+          title: [
+            {
+              dynamicSwitch: [
+                {
+                  case: false,
+                  asset: {
+                    id: "false-case",
+                    type: "text",
+                    value: "some text",
+                  },
+                },
+                {
+                  case: false,
+                  asset: {
+                    id: "false-case-2",
+                    type: "text",
+                    value: "some text",
+                  },
+                },
+              ],
+            },
+          ],
+        },
+        {
+          model,
+          parseBinding,
+          evaluator,
+          schema,
+        },
+      );
+
+      const pluginOptions = toNodeResolveOptions(view.resolverOptions);
+      new SwitchPlugin(pluginOptions).apply(view);
+      new MultiNodePlugin().apply(view);
+      new StringResolverPlugin().apply(view);
+
+      const resolved = view.update();
+
+      expect(resolved).toStrictEqual({
+        id: "test",
+        title: [],
+        type: "view",
+      });
+    });
+
     it("does not return a field object if the case does not resolve an asset", () => {
       const model = withParser(
         new LocalModel({
@@ -381,6 +437,7 @@ describe("view", () => {
 
       const pluginOptions = toNodeResolveOptions(view.resolverOptions);
       new SwitchPlugin(pluginOptions).apply(view);
+      new MultiNodePlugin().apply(view);
       new StringResolverPlugin().apply(view);
 
       const resolved = view.update();
@@ -735,6 +792,7 @@ describe("view", () => {
 
       const pluginOptions = toNodeResolveOptions(view.resolverOptions);
       new SwitchPlugin(pluginOptions).apply(view);
+      new MultiNodePlugin().apply(view);
       new StringResolverPlugin().apply(view);
 
       const resolved = view.update();

package/src/view/parser/__tests__/parser.test.ts

@@ -3,7 +3,13 @@ import { BindingParser } from "../../../binding";
 import { LocalModel, withParser } from "../../../data";
 import { SchemaController } from "../../../schema";
 import { NodeType, Parser } from "../index";
-import { SwitchPlugin, ApplicabilityPlugin, TemplatePlugin } from "../..";
+import {
+  SwitchPlugin,
+  ApplicabilityPlugin,
+  TemplatePlugin,
+  MultiNodePlugin,
+  AssetPlugin,
+} from "../..";
 import type { Options } from "../../plugins/options";
 import { ExpressionEvaluator } from "../../../expressions";
 import type { DataModelWithParser } from "../../../data";
@@ -30,9 +36,11 @@ describe("generates the correct AST", () => {
         model,
       },
     };
+    new AssetPlugin().applyParser(parser);
     new TemplatePlugin(options).applyParser(parser);
     new ApplicabilityPlugin().applyParser(parser);
     new SwitchPlugin(options).applyParser(parser);
+    new MultiNodePlugin().applyParser(parser);
   });
 
   test("works with basic objects", () => {
@@ -154,8 +162,10 @@ describe("parseView", () => {
         model,
       },
     };
+    new AssetPlugin().applyParser(parser);
     new TemplatePlugin(options).applyParser(parser);
     new ApplicabilityPlugin().applyParser(parser);
+    new MultiNodePlugin().applyParser(parser);
     new SwitchPlugin(options).applyParser(parser);
   });
 
@@ -249,8 +259,13 @@ describe("generates the correct AST when using switch plugin", () => {
       return true;
     },
   } as any);
+  const multiNodePlugin = new MultiNodePlugin();
+  const assetPlugin = new AssetPlugin();
+
   const parser = new Parser();
   switchPlugin.applyParser(parser);
+  multiNodePlugin.applyParser(parser);
+  assetPlugin.applyParser(parser);
 
   test("works with asset wrapped objects", () => {
     expect(parser.parseObject(toughStaticSwitchView)).toMatchSnapshot();

package/src/view/parser/index.ts

@@ -1,9 +1,7 @@
-import { omit, setIn } from "timm";
+import { setIn } from "timm";
 import { SyncBailHook, SyncWaterfallHook } from "tapable-ts";
-import type { Template } from "@player-ui/types";
 import type { AnyAssetType, Node } from "./types";
 import { NodeType } from "./types";
-import { getNodeID, hasAsync } from "./utils";
 
 export * from "./types";
 export * from "./utils";
@@ -17,6 +15,12 @@ export interface ParseObjectOptions {
   templateDepth?: number;
 }
 
+export interface ParseObjectChildOptions {
+  key: string;
+  path: Node.PathSegment[];
+  parentObj: object;
+}
+
 interface NestedObj {
   /** The values of a nested local object */
   children: Node.Child[];
@@ -52,16 +56,14 @@ export class Parser {
       [Node.Node | undefined | null, object]
     >(),
 
-    determineNodeType: new SyncBailHook<[object | string], NodeType>(),
-
     parseNode: new SyncBailHook<
       [
         obj: object,
         nodeType: Node.ChildrenTypes,
         parseOptions: ParseObjectOptions,
-        determinedNodeType: NodeType | null,
+        childOptions?: ParseObjectChildOptions,
       ],
-      Node.Node
+      Node.Node | Node.Child[]
     >(),
   };
 
@@ -75,27 +77,6 @@ export class Parser {
     return viewNode as Node.View;
   }
 
-  private parseAsync(
-    obj: object,
-    type: Node.ChildrenTypes,
-    options: ParseObjectOptions,
-  ): Node.Node | null {
-    const parsedAsync = this.parseObject(omit(obj, "async"), type, options);
-    const parsedNodeId = getNodeID(parsedAsync);
-    if (parsedAsync !== null && parsedNodeId) {
-      return this.createASTNode(
-        {
-          id: parsedNodeId,
-          type: NodeType.Async,
-          value: parsedAsync,
-        },
-        obj,
-      );
-    }
-
-    return null;
-  }
-
   public createASTNode(node: Node.Node | null, value: any): Node.Node | null {
     const tapped = this.hooks.onCreateASTNode.call(node, value);
 
@@ -106,47 +87,21 @@ export class Parser {
     return tapped;
   }
 
-  /**
-   * Checks if there are templated values in the object
-   *
-   * @param obj - The Parsed Object to check to see if we have a template array type for
-   * @param localKey - The key being checked
-   */
-  private hasTemplateValues(obj: any, localKey: string) {
-    return (
-      Object.hasOwnProperty.call(obj, "template") &&
-      Array.isArray(obj?.template) &&
-      obj.template.length &&
-      obj.template.find((tmpl: any) => tmpl.output === localKey)
-    );
-  }
-
-  private hasSwitchKey(localKey: string) {
-    return localKey === ("staticSwitch" || "dynamicSwitch");
-  }
-
   public parseObject(
     obj: object,
     type: Node.ChildrenTypes = NodeType.Value,
     options: ParseObjectOptions = { templateDepth: 0 },
   ): Node.Node | null {
-    const nodeType = this.hooks.determineNodeType.call(obj);
-
-    if (nodeType !== undefined) {
-      const parsedNode = this.hooks.parseNode.call(
-        obj,
-        type,
-        options,
-        nodeType,
-      );
-      if (parsedNode) {
-        return parsedNode;
-      }
+    const parsedNode = this.hooks.parseNode.call(
+      obj,
+      type,
+      options,
+    ) as Node.Node | null;
+
+    if (parsedNode || parsedNode === null) {
+      return parsedNode;
     }
 
-    /**
-     *
-     */
     const parseLocalObject = (
       currentValue: any,
       objToParse: unknown,
@@ -178,209 +133,39 @@ export class Parser {
       };
 
       const newValue = objEntries.reduce((accumulation, current): NestedObj => {
-        const { children, ...rest } = accumulation;
+        let { value } = accumulation;
+        const { children } = accumulation;
         const [localKey, localValue] = current;
-        if (localKey === "asset" && typeof localValue === "object") {
-          const assetAST = this.parseObject(
-            localValue,
-            NodeType.Asset,
-            options,
-          );
-
-          if (assetAST) {
-            return {
-              ...rest,
-              children: [
-                ...children,
-                {
-                  path: [...path, "asset"],
-                  value: assetAST,
-                },
-              ],
-            };
-          }
-        } else if (
-          this.hooks.determineNodeType.call(localKey) === NodeType.Template &&
-          Array.isArray(localValue)
-        ) {
-          const templateChildren = localValue
-            .map((template: Template) => {
-              const templateAST = this.hooks.onCreateASTNode.call(
-                {
-                  type: NodeType.Template,
-                  depth: options.templateDepth ?? 0,
-                  data: template.data,
-                  template: template.value,
-                  dynamic: template.dynamic ?? false,
-                },
-                template,
-              );
-
-              if (templateAST?.type === NodeType.MultiNode) {
-                templateAST.values.forEach((v) => {
-                  // eslint-disable-next-line no-param-reassign
-                  v.parent = templateAST;
-                });
-              }
-
-              if (templateAST) {
-                return {
-                  path: [...path, template.output],
-                  value: templateAST,
-                };
-              }
-
-              // eslint-disable-next-line no-useless-return
-              return;
-            })
-            .filter((element) => !!element);
-
-          return {
-            ...rest,
-            children: [...children, ...templateChildren],
-          } as NestedObj;
-        } else if (
-          (localValue &&
-            this.hooks.determineNodeType.call(localValue) ===
-              NodeType.Switch) ||
-          this.hasSwitchKey(localKey)
-        ) {
-          const localSwitch = this.hooks.parseNode.call(
-            this.hasSwitchKey(localKey)
-              ? { [localKey]: localValue }
-              : localValue,
-            NodeType.Value,
-            options,
-            NodeType.Switch,
-          );
 
-          if (
-            localSwitch &&
-            localSwitch.type === NodeType.Value &&
-            localSwitch.children?.length === 1 &&
-            localSwitch.value === undefined
-          ) {
-            const firstChild = localSwitch.children[0];
-
-            return {
-              ...rest,
-              children: [
-                ...children,
-                {
-                  path: [...path, localKey, ...firstChild.path],
-                  value: firstChild.value,
-                },
-              ],
-            };
-          }
-
-          if (localSwitch) {
-            return {
-              ...rest,
-              children: [
-                ...children,
-                {
-                  path: [...path, localKey],
-                  value: localSwitch,
-                },
-              ],
-            };
-          }
-        } else if (localValue && hasAsync(localValue)) {
-          const localAsync = this.parseAsync(
-            localValue,
-            NodeType.Value,
-            options,
-          );
-          if (localAsync) {
-            children.push({
-              path: [...path, localKey],
-              value: localAsync,
-            });
-          }
-        } else if (localValue && Array.isArray(localValue)) {
-          const childValues = localValue
-            .map((childVal) =>
-              this.parseObject(childVal, NodeType.Value, options),
-            )
-            .filter((child): child is Node.Node => !!child);
-
-          if (childValues.length > 0) {
-            const multiNode = this.hooks.onCreateASTNode.call(
-              {
-                type: NodeType.MultiNode,
-                override: !this.hasTemplateValues(localObj, localKey),
-                values: childValues,
-              },
-              localValue,
-            );
-
-            if (multiNode?.type === NodeType.MultiNode) {
-              multiNode.values.forEach((v) => {
-                // eslint-disable-next-line no-param-reassign
-                v.parent = multiNode;
-              });
-            }
-            if (multiNode) {
-              return {
-                ...rest,
-                children: [
-                  ...children,
-                  {
-                    path: [...path, localKey],
-                    value: multiNode,
-                  },
-                ],
-              };
-            }
-          }
+        const newChildren = this.hooks.parseNode.call(
+          localValue,
+          NodeType.Value,
+          options,
+          {
+            path,
+            key: localKey,
+            parentObj: localObj,
+          },
+        ) as Node.Child[];
+
+        if (newChildren) {
+          children.push(...newChildren);
         } else if (localValue && typeof localValue === "object") {
-          const determineNodeType =
-            this.hooks.determineNodeType.call(localValue);
+          const result = parseLocalObject(accumulation.value, localValue, [
+            ...path,
+            localKey,
+          ]);
 
-          if (determineNodeType === NodeType.Applicability) {
-            const parsedNode = this.hooks.parseNode.call(
-              localValue,
-              NodeType.Value,
-              options,
-              determineNodeType,
-            );
-            if (parsedNode) {
-              return {
-                ...rest,
-                children: [
-                  ...children,
-                  {
-                    path: [...path, localKey],
-                    value: parsedNode,
-                  },
-                ],
-              };
-            }
-          } else {
-            const result = parseLocalObject(accumulation.value, localValue, [
-              ...path,
-              localKey,
-            ]);
-            return {
-              value: result.value,
-              children: [...children, ...result.children],
-            };
-          }
+          value = result.value;
+          children.push(...result.children);
         } else {
-          const value = setIn(
-            accumulation.value,
-            [...path, localKey],
-            localValue,
-          );
-
-          return {
-            children,
-            value,
-          };
+          value = setIn(accumulation.value, [...path, localKey], localValue);
         }
 
-        return accumulation;
+        return {
+          value,
+          children,
+        };
       }, defaultValue);
 
       return newValue;
@@ -389,18 +174,17 @@ export class Parser {
     const { value, children } = parseLocalObject(undefined, obj);
 
     const baseAst =
-      value === undefined && children.length === 0
+      value === undefined && !children.length
         ? undefined
         : {
             type,
             value,
           };
 
-    if (baseAst !== undefined && children.length > 0) {
-      const parent = baseAst as Node.BaseWithChildren<any>;
+    if (baseAst && children.length) {
+      const parent: Node.BaseWithChildren<any> = baseAst;
       parent.children = children;
       children.forEach((child) => {
-        // eslint-disable-next-line no-param-reassign
         child.value.parent = parent;
       });
     }

package/src/view/parser/utils.ts

@@ -1,8 +1,28 @@
 import type { Node } from "./types";
 
-/** Check to see if the object contains async */
-export function hasAsync(obj: object): boolean {
-  return Object.prototype.hasOwnProperty.call(obj, "async");
+/**
+ * Checks if there are templated values in the object
+ *
+ * @param obj - The Parsed Object to check to see if we have a template array type for
+ * @param localKey - The key being checked
+ */
+export function hasTemplateValues(obj: any, localKey: string) {
+  return (
+    Object.hasOwnProperty.call(obj, "template") &&
+    Array.isArray(obj?.template) &&
+    obj.template.length &&
+    obj.template.find((tmpl: any) => tmpl.output === localKey)
+  );
+}
+
+/** Check to see if the string is a valid switch key */
+export function hasSwitchKey(localKey: string) {
+  return localKey === "staticSwitch" || localKey === "dynamicSwitch";
+}
+
+/** Check to see if the string is a valid template key */
+export function hasTemplateKey(localKey: string) {
+  return localKey === "template";
 }
 
 /** Get the ID of the Node if there is one */