@player-ui/player 0.8.0--canary.307.9621 → 0.8.0-next.0

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

@@ -0,0 +1,264 @@
+import { describe, expect, beforeEach, test } from "vitest";
+import { BindingParser } from "../../../binding";
+import { LocalModel, withParser } from "../../../data";
+import { SchemaController } from "../../../schema";
+import { NodeType, Parser } from "../index";
+import { SwitchPlugin, ApplicabilityPlugin, TemplatePlugin } from "../..";
+import type { Options } from "../../plugins/options";
+import { ExpressionEvaluator } from "../../../expressions";
+import type { DataModelWithParser } from "../../../data";
+
+const parseBinding = new BindingParser().parse;
+describe("generates the correct AST", () => {
+  let model: DataModelWithParser;
+  let expressionEvaluator: ExpressionEvaluator;
+  let options: Options;
+  let parser: Parser;
+
+  beforeEach(() => {
+    model = withParser(new LocalModel(), parseBinding);
+    expressionEvaluator = new ExpressionEvaluator({
+      model,
+    });
+    parser = new Parser();
+    options = {
+      evaluate: expressionEvaluator.evaluate,
+      schema: new SchemaController(),
+      data: {
+        format: (binding, val) => val,
+        formatValue: (val) => val,
+        model,
+      },
+    };
+    new TemplatePlugin(options).applyParser(parser);
+    new ApplicabilityPlugin().applyParser(parser);
+    new SwitchPlugin(options).applyParser(parser);
+  });
+
+  test("works with basic objects", () => {
+    expect(parser.parseObject({ foo: "bar" })).toStrictEqual({
+      type: NodeType.Value,
+      value: {
+        foo: "bar",
+      },
+    });
+  });
+
+  test("works with objects that have symbols", () => {
+    const testSymbol = Symbol("foo");
+    expect(parser.parseObject({ [testSymbol]: "bar" })).toStrictEqual({
+      type: NodeType.Value,
+      value: {
+        [testSymbol]: "bar",
+      },
+    });
+  });
+
+  test("works with applicability things", () => {
+    expect(
+      parser.parseObject({ foo: "bar", applicability: "{{baz}}" }),
+    ).toMatchSnapshot();
+
+    expect(
+      parser.parseObject({
+        asset: {
+          values: [
+            {
+              applicability: "{{foo}}",
+              value: "foo",
+            },
+            {
+              value: "bar",
+            },
+          ],
+        },
+      }),
+    ).toMatchSnapshot();
+
+    expect(
+      parser.parseObject({
+        asset: {
+          someProp: {
+            applicability: "{{foo}}",
+            label: {
+              value: "label",
+            },
+            description: {
+              value: "description",
+            },
+          },
+        },
+      }),
+    ).toMatchSnapshot();
+
+    expect(
+      parser.parseObject({
+        asset: {
+          someProp: {
+            asset: {
+              applicability: "{{foo}}",
+              type: "someAsset",
+            },
+          },
+        },
+      }),
+    ).toMatchSnapshot();
+  });
+
+  test("parses an object", () => {
+    expect(parser.parseObject({ asset: { type: "bar" } })).toMatchSnapshot();
+  });
+
+  test("parses an exp array", () => {
+    expect(
+      parser.parseObject(
+        {
+          id: "foo",
+          type: "action",
+          exp: ['{{please}} = "work"'],
+        },
+        NodeType.Asset,
+      ),
+    ).toMatchSnapshot();
+  });
+
+  test("keeps null values when parsing object", () => {
+    expect(parser.parseObject({ foo: "bar", baz: null })).toStrictEqual({
+      type: NodeType.Value,
+      value: {
+        foo: "bar",
+        baz: null,
+      },
+    });
+  });
+});
+
+describe("parseView", () => {
+  let model: DataModelWithParser;
+  let expressionEvaluator: ExpressionEvaluator;
+  let options: Options;
+  let parser: Parser;
+
+  beforeEach(() => {
+    model = withParser(new LocalModel(), parseBinding);
+    expressionEvaluator = new ExpressionEvaluator({
+      model,
+    });
+    parser = new Parser();
+    options = {
+      evaluate: expressionEvaluator.evaluate,
+      schema: new SchemaController(),
+      data: {
+        format: (binding, val) => val,
+        formatValue: (val) => val,
+        model,
+      },
+    };
+    new TemplatePlugin(options).applyParser(parser);
+    new ApplicabilityPlugin().applyParser(parser);
+    new SwitchPlugin(options).applyParser(parser);
+  });
+
+  test("parses a simple view", () => {
+    expect(
+      parser.parseView({
+        id: "foo-view",
+        type: "viewtype",
+        fields: {
+          asset: {
+            id: "foo-asset",
+            type: "collection",
+            values: [
+              {
+                asset: {
+                  id: "text-asset",
+                  type: "text",
+                  value: "bar",
+                },
+              },
+              {
+                asset: {
+                  applicability: "foo.bar",
+                  id: "input-asset",
+                  type: "input",
+                },
+              },
+              {},
+            ],
+          },
+        },
+      } as any),
+    ).toMatchSnapshot();
+  });
+});
+
+describe("generates the correct AST when using switch plugin", () => {
+  const toughStaticSwitchView = {
+    id: "toughView",
+    type: "view",
+    title: {
+      staticSwitch: [
+        {
+          case: "'true'",
+          asset: {
+            id: "businessprofile-tile-screen-yoy-subtitle",
+            type: "text",
+            value:
+              "If it's changed since last year, let us know. Feel free to pick more than one.",
+          },
+        },
+      ],
+    },
+  };
+
+  const toughStaticSwitchMultiNodeView = {
+    id: "toughView",
+    type: "view",
+    title: {
+      asset: {
+        id: "someMultiNode",
+        type: "type",
+        values: [
+          {
+            staticSwitch: [
+              {
+                case: "'true'",
+                asset: {
+                  id: "businessprofile-tile-screen-yoy-subtitle-1",
+                  type: "text",
+                  value:
+                    "If it's changed since last year, let us know. Feel free to pick more than one.",
+                },
+              },
+            ],
+          },
+          {
+            asset: {
+              id: "businessprofile-tile-screen-yoy-subtitle-2",
+              type: "text",
+              value: "More text",
+            },
+          },
+        ],
+      },
+    },
+  };
+
+  const switchPlugin = new SwitchPlugin({
+    evaluate: () => {
+      return true;
+    },
+  } as any);
+  const parser = new Parser();
+  switchPlugin.applyParser(parser);
+
+  test("works with asset wrapped objects", () => {
+    expect(parser.parseObject(toughStaticSwitchView)).toMatchSnapshot();
+  });
+
+  test("works with objects in a multiNode", () => {
+    expect(
+      parser.parseObject(toughStaticSwitchMultiNodeView),
+    ).toMatchSnapshot();
+  });
+});

package/src/view/parser/index.ts

@@ -1,12 +1,12 @@
-import { omit, 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';
+import { omit, 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';
+export * from "./types";
+export * from "./utils";
 
 export const EMPTY_NODE: Node.Empty = {
   type: NodeType.Empty,
@@ -59,7 +59,7 @@ export class Parser {
         obj: object,
         nodeType: Node.ChildrenTypes,
         parseOptions: ParseObjectOptions,
-        determinedNodeType: NodeType | null
+        determinedNodeType: NodeType | null,
       ],
       Node.Node
     >(),
@@ -69,7 +69,7 @@ export class Parser {
     const viewNode = this.parseObject(value, NodeType.View);
 
     if (!viewNode) {
-      throw new Error('Unable to parse object into a view');
+      throw new Error("Unable to parse object into a view");
     }
 
     return viewNode as Node.View;
@@ -78,9 +78,9 @@ export class Parser {
   private parseAsync(
     obj: object,
     type: Node.ChildrenTypes,
-    options: ParseObjectOptions
+    options: ParseObjectOptions,
   ): Node.Node | null {
-    const parsedAsync = this.parseObject(omit(obj, 'async'), type, options);
+    const parsedAsync = this.parseObject(omit(obj, "async"), type, options);
     const parsedNodeId = getNodeID(parsedAsync);
     if (parsedAsync !== null && parsedNodeId) {
       return this.createASTNode(
@@ -89,7 +89,7 @@ export class Parser {
           type: NodeType.Async,
           value: parsedAsync,
         },
-        obj
+        obj,
       );
     }
 
@@ -114,17 +114,21 @@ export class Parser {
    */
   private hasTemplateValues(obj: any, localKey: string) {
     return (
-      Object.hasOwnProperty.call(obj, 'template') &&
+      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 }
+    options: ParseObjectOptions = { templateDepth: 0 },
   ): Node.Node | null {
     const nodeType = this.hooks.determineNodeType.call(obj);
 
@@ -133,19 +137,22 @@ export class Parser {
         obj,
         type,
         options,
-        nodeType
+        nodeType,
       );
       if (parsedNode) {
         return parsedNode;
       }
     }
 
+    /**
+     *
+     */
     const parseLocalObject = (
       currentValue: any,
       objToParse: unknown,
-      path: string[] = []
+      path: string[] = [],
     ): NestedObj => {
-      if (typeof objToParse !== 'object' || objToParse === null) {
+      if (typeof objToParse !== "object" || objToParse === null) {
         return { value: objToParse, children: [] };
       }
 
@@ -173,11 +180,11 @@ export class Parser {
       const newValue = objEntries.reduce((accumulation, current): NestedObj => {
         const { children, ...rest } = accumulation;
         const [localKey, localValue] = current;
-        if (localKey === 'asset' && typeof localValue === 'object') {
+        if (localKey === "asset" && typeof localValue === "object") {
           const assetAST = this.parseObject(
             localValue,
             NodeType.Asset,
-            options
+            options,
           );
 
           if (assetAST) {
@@ -186,7 +193,7 @@ export class Parser {
               children: [
                 ...children,
                 {
-                  path: [...path, 'asset'],
+                  path: [...path, "asset"],
                   value: assetAST,
                 },
               ],
@@ -206,7 +213,7 @@ export class Parser {
                   template: template.value,
                   dynamic: template.dynamic ?? false,
                 },
-                template
+                template,
               );
 
               if (templateAST?.type === NodeType.MultiNode) {
@@ -233,14 +240,18 @@ export class Parser {
             children: [...children, ...templateChildren],
           } as NestedObj;
         } else if (
-          localValue &&
-          this.hooks.determineNodeType.call(localValue) === NodeType.Switch
+          (localValue &&
+            this.hooks.determineNodeType.call(localValue) ===
+              NodeType.Switch) ||
+          this.hasSwitchKey(localKey)
         ) {
           const localSwitch = this.hooks.parseNode.call(
-            localValue,
+            this.hasSwitchKey(localKey)
+              ? { [localKey]: localValue }
+              : localValue,
             NodeType.Value,
             options,
-            NodeType.Switch
+            NodeType.Switch,
           );
 
           if (
@@ -279,7 +290,7 @@ export class Parser {
           const localAsync = this.parseAsync(
             localValue,
             NodeType.Value,
-            options
+            options,
           );
           if (localAsync) {
             children.push({
@@ -290,7 +301,7 @@ export class Parser {
         } else if (localValue && Array.isArray(localValue)) {
           const childValues = localValue
             .map((childVal) =>
-              this.parseObject(childVal, NodeType.Value, options)
+              this.parseObject(childVal, NodeType.Value, options),
             )
             .filter((child): child is Node.Node => !!child);
 
@@ -301,7 +312,7 @@ export class Parser {
                 override: !this.hasTemplateValues(localObj, localKey),
                 values: childValues,
               },
-              localValue
+              localValue,
             );
 
             if (multiNode?.type === NodeType.MultiNode) {
@@ -310,7 +321,6 @@ export class Parser {
                 v.parent = multiNode;
               });
             }
-
             if (multiNode) {
               return {
                 ...rest,
@@ -324,7 +334,7 @@ export class Parser {
               };
             }
           }
-        } else if (localValue && typeof localValue === 'object') {
+        } else if (localValue && typeof localValue === "object") {
           const determineNodeType =
             this.hooks.determineNodeType.call(localValue);
 
@@ -333,7 +343,7 @@ export class Parser {
               localValue,
               NodeType.Value,
               options,
-              determineNodeType
+              determineNodeType,
             );
             if (parsedNode) {
               return {
@@ -361,7 +371,7 @@ export class Parser {
           const value = setIn(
             accumulation.value,
             [...path, localKey],
-            localValue
+            localValue,
           );
 
           return {

package/src/view/parser/types.ts

@@ -1,17 +1,17 @@
-import type { Asset as AssetType, Expression, Binding } from '@player-ui/types';
+import type { Asset as AssetType, Expression, Binding } from "@player-ui/types";
 
 export type AnyAssetType = AssetType<string>;
 export enum NodeType {
-  Asset = 'asset',
-  View = 'view',
-  Applicability = 'applicability',
-  Template = 'template',
-  Value = 'value',
-  MultiNode = 'multi-node',
-  Switch = 'switch',
-  Async = 'async',
-  Unknown = 'unknown',
-  Empty = 'empty',
+  Asset = "asset",
+  View = "view",
+  Applicability = "applicability",
+  Template = "template",
+  Value = "value",
+  MultiNode = "multi-node",
+  Switch = "switch",
+  Async = "async",
+  Unknown = "unknown",
+  Empty = "empty",
 }
 export declare namespace Node {
   export type ChildrenTypes = NodeType.Asset | NodeType.Value | NodeType.View;

package/src/view/parser/utils.ts

@@ -1,8 +1,8 @@
-import type { Node } from './types';
+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');
+  return Object.prototype.hasOwnProperty.call(obj, "async");
 }
 
 /** Get the ID of the Node if there is one */
@@ -12,9 +12,9 @@ export function getNodeID(node?: Node.Node | null): string | undefined {
   }
 
   if (
-    'value' in node &&
-    typeof node.value === 'object' &&
-    typeof node.value?.id === 'string'
+    "value" in node &&
+    typeof node.value === "object" &&
+    typeof node.value?.id === "string"
   ) {
     return node.value.id;
   }