Parse multi node switch fixv1

core/player/src/view/__tests__/view.test.ts

@@ -70,6 +70,54 @@ describe('view', () => {
       expect(updated).toBe(resolved);
     });
 
+    test('works with no valid 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: [
+            {
+              staticSwitch: [
+                {
+                  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 resolved = view.update();
+
+      expect(resolved).toStrictEqual({
+        id: 'test',
+        type: 'view',
+      });
+    });
+
     it('does not return a field object if the case does not resolve an asset', () => {
       const model = withParser(
         new LocalModel({

core/player/src/view/parser/index.ts

@@ -121,6 +121,10 @@ export class Parser {
     );
   }
 
+  private hasSwitchKey(localKey: string) {
+    return localKey === ('staticSwitch' || 'dynamicSwitch');
+  }
+
   public parseObject(
     obj: object,
     type: Node.ChildrenTypes = NodeType.Value,
@@ -173,6 +177,7 @@ export class Parser {
       const newValue = objEntries.reduce((accumulation, current): NestedObj => {
         const { children, ...rest } = accumulation;
         const [localKey, localValue] = current;
+
         if (localKey === 'asset' && typeof localValue === 'object') {
           const assetAST = this.parseObject(
             localValue,
@@ -233,11 +238,15 @@ 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
@@ -310,7 +319,6 @@ export class Parser {
                 v.parent = multiNode;
               });
             }
-
             if (multiNode) {
               return {
                 ...rest,

core/player/src/view/plugins/switch.ts

@@ -15,7 +15,6 @@ export default class SwitchPlugin implements ViewPlugin {
   private resolveSwitch(node: Node.Switch, options: Options): Node.Node {
     for (const switchCase of node.cases) {
       const isApplicable = options.evaluate(switchCase.case);
-
       if (isApplicable) {
         return switchCase.value;
       }