@player-ui/player 0.8.0-next.3 → 0.8.0-next.5

package/src/view/plugins/multi-node.ts

@@ -0,0 +1,73 @@
+import { ViewInstance, ViewPlugin } from "../view";
+import type {
+  Parser,
+  Node,
+  ParseObjectOptions,
+  ParseObjectChildOptions,
+} from "../parser";
+import { NodeType } from "../parser";
+import { hasTemplateValues, hasTemplateKey } from "../parser/utils";
+
+/** A view plugin to resolve multi nodes */
+export default class MultiNodePlugin implements ViewPlugin {
+  applyParser(parser: Parser) {
+    parser.hooks.parseNode.tap(
+      "multi-node",
+      (
+        obj: any,
+        nodeType: Node.ChildrenTypes,
+        options: ParseObjectOptions,
+        childOptions?: ParseObjectChildOptions,
+      ) => {
+        if (
+          childOptions &&
+          !hasTemplateKey(childOptions.key) &&
+          Array.isArray(obj)
+        ) {
+          const values = obj
+            .map((childVal) =>
+              parser.parseObject(childVal, NodeType.Value, options),
+            )
+            .filter((child): child is Node.Node => !!child);
+
+          if (!values.length) {
+            return [];
+          }
+
+          const multiNode = parser.createASTNode(
+            {
+              type: NodeType.MultiNode,
+              override: !hasTemplateValues(
+                childOptions.parentObj,
+                childOptions.key,
+              ),
+              values,
+            },
+            obj,
+          );
+
+          if (!multiNode) {
+            return [];
+          }
+
+          if (multiNode.type === NodeType.MultiNode) {
+            multiNode.values.forEach((v) => {
+              v.parent = multiNode;
+            });
+          }
+
+          return [
+            {
+              path: [...childOptions.path, childOptions.key],
+              value: multiNode,
+            },
+          ];
+        }
+      },
+    );
+  }
+
+  apply(view: ViewInstance) {
+    view.hooks.parser.tap("multi-node", this.applyParser.bind(this));
+  }
+}

package/src/view/plugins/switch.ts

@@ -1,8 +1,14 @@
+import { ViewInstance, ViewPlugin } from "../view";
 import type { Options } from "./options";
-import type { Parser, Node, ParseObjectOptions } from "../parser";
+import type {
+  Parser,
+  Node,
+  ParseObjectOptions,
+  ParseObjectChildOptions,
+} from "../parser";
 import { EMPTY_NODE, NodeType } from "../parser";
 import type { Resolver } from "../resolver";
-import { ViewInstance, ViewPlugin } from "../view";
+import { hasSwitchKey } from "../parser/utils";
 
 /** A view plugin to resolve switches */
 export default class SwitchPlugin implements ViewPlugin {
@@ -23,6 +29,14 @@ export default class SwitchPlugin implements ViewPlugin {
     return EMPTY_NODE;
   }
 
+  private isSwitch(obj: any) {
+    return (
+      obj &&
+      (Object.prototype.hasOwnProperty.call(obj, "dynamicSwitch") ||
+        Object.prototype.hasOwnProperty.call(obj, "staticSwitch"))
+    );
+  }
+
   applyParser(parser: Parser) {
     /** Switches resolved during the parsing phase are static */
     parser.hooks.onCreateASTNode.tap("switch", (node) => {
@@ -33,75 +47,92 @@ export default class SwitchPlugin implements ViewPlugin {
       return node;
     });
 
-    parser.hooks.determineNodeType.tap("switch", (obj) => {
-      if (
-        Object.prototype.hasOwnProperty.call(obj, "dynamicSwitch") ||
-        Object.prototype.hasOwnProperty.call(obj, "staticSwitch")
-      ) {
-        return NodeType.Switch;
-      }
-    });
-
     parser.hooks.parseNode.tap(
       "switch",
       (
         obj: any,
         _nodeType: Node.ChildrenTypes,
         options: ParseObjectOptions,
-        determinedNodeType: null | NodeType,
+        childOptions?: ParseObjectChildOptions,
       ) => {
-        if (determinedNodeType === NodeType.Switch) {
-          const dynamic = "dynamicSwitch" in obj;
-          const switchContent =
-            "dynamicSwitch" in obj ? obj.dynamicSwitch : obj.staticSwitch;
-
-          const cases: Node.SwitchCase[] = [];
-
-          switchContent.forEach(
-            (switchCase: {
-              [x: string]: any;
-              /**
-               *
-               */
-              case: any;
-            }) => {
-              const { case: switchCaseExpr, ...switchBody } = switchCase;
-              const value = parser.parseObject(
-                switchBody,
-                NodeType.Value,
-                options,
-              );
-
-              if (value) {
-                cases.push({
-                  case: switchCaseExpr,
-                  value: value as Node.Value,
-                });
-              }
-            },
-          );
-
-          const switchAST = parser.hooks.onCreateASTNode.call(
+        if (
+          this.isSwitch(obj) ||
+          (childOptions && hasSwitchKey(childOptions.key))
+        ) {
+          const objToParse =
+            childOptions && hasSwitchKey(childOptions.key)
+              ? { [childOptions.key]: obj }
+              : obj;
+          const dynamic = "dynamicSwitch" in objToParse;
+          const switchContent = dynamic
+            ? objToParse.dynamicSwitch
+            : objToParse.staticSwitch;
+
+          const cases: Node.SwitchCase[] = switchContent
+            .map(
+              (switchCase: {
+                [x: string]: any;
+                /**
+                 *
+                 */
+                case: any;
+              }) => {
+                const { case: switchCaseExpr, ...switchBody } = switchCase;
+                const value = parser.parseObject(
+                  switchBody,
+                  NodeType.Value,
+                  options,
+                );
+
+                if (value) {
+                  return {
+                    case: switchCaseExpr,
+                    value: value as Node.Value,
+                  };
+                }
+
+                return;
+              },
+            )
+            .filter(Boolean);
+
+          const switchAST = parser.createASTNode(
             {
               type: NodeType.Switch,
               dynamic,
               cases,
             },
-            obj,
+            objToParse,
           );
 
-          if (switchAST?.type === NodeType.Switch) {
+          if (!switchAST || switchAST.type === NodeType.Empty) {
+            return childOptions ? [] : null;
+          }
+
+          if (switchAST.type === NodeType.Switch) {
             switchAST.cases.forEach((sCase) => {
-              // eslint-disable-next-line no-param-reassign
               sCase.value.parent = switchAST;
             });
           }
 
-          if (switchAST?.type === NodeType.Empty) {
-            return null;
+          if (childOptions) {
+            let path = [...childOptions.path, childOptions.key];
+            let value: any = switchAST;
+
+            if (
+              switchAST.type === NodeType.Value &&
+              switchAST.children?.length === 1 &&
+              switchAST.value === undefined
+            ) {
+              const firstChild = switchAST.children[0];
+              path = [...path, ...firstChild.path];
+              value = firstChild.value;
+            }
+
+            return [{ path, value }];
           }
 
-          return switchAST ?? null;
+          return switchAST;
         }
       },
     );

package/src/view/plugins/{template-plugin.ts → template.ts}

@@ -1,9 +1,16 @@
 import { SyncWaterfallHook } from "tapable-ts";
-import type { Node, ParseObjectOptions, Parser } from "../parser";
+import type { Template } from "@player-ui/types";
+import type {
+  Node,
+  ParseObjectOptions,
+  ParseObjectChildOptions,
+  Parser,
+} from "../parser";
 import { NodeType } from "../parser";
+import { ViewInstance, ViewPlugin } from "../view";
 import type { Options } from "./options";
 import type { Resolver } from "../resolver";
-import { ViewInstance, ViewPlugin } from "../view";
+import { hasTemplateKey } from "../parser/utils";
 
 export interface TemplateItemInfo {
   /** The index of the data for the current iteration of the template */
@@ -115,35 +122,42 @@ export default class TemplatePlugin implements ViewPlugin {
       return node;
     });
 
-    parser.hooks.determineNodeType.tap("template", (obj: any) => {
-      if (obj === "template") {
-        return NodeType.Template;
-      }
-    });
-
     parser.hooks.parseNode.tap(
       "template",
       (
         obj: any,
         _nodeType: Node.ChildrenTypes,
         options: ParseObjectOptions,
-        determinedNodeType: null | NodeType,
+        childOptions?: ParseObjectChildOptions,
       ) => {
-        if (determinedNodeType === NodeType.Template) {
-          const templateNode = parser.createASTNode(
-            {
-              type: NodeType.Template,
-              depth: options.templateDepth ?? 0,
-              data: obj.data,
-              template: obj.value,
-              dynamic: obj.dynamic ?? false,
-            },
-            obj,
-          );
-
-          if (templateNode) {
-            return templateNode;
-          }
+        if (childOptions && hasTemplateKey(childOptions.key)) {
+          return obj
+            .map((template: Template) => {
+              const templateAST = parser.createASTNode(
+                {
+                  type: NodeType.Template,
+                  depth: options.templateDepth ?? 0,
+                  data: template.data,
+                  template: template.value,
+                  dynamic: template.dynamic ?? false,
+                },
+                template,
+              );
+
+              if (!templateAST) return;
+
+              if (templateAST.type === NodeType.MultiNode) {
+                templateAST.values.forEach((v) => {
+                  v.parent = templateAST;
+                });
+              }
+
+              return {
+                path: [...childOptions.path, template.output],
+                value: templateAST,
+              };
+            })
+            .filter(Boolean);
         }
       },
     );

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

@@ -9,7 +9,11 @@ import { TapableLogger } from "../../../logger";
 import { Resolver } from "..";
 import type { Node } from "../../parser";
 import { NodeType, Parser } from "../../parser";
-import { StringResolverPlugin } from "../../plugins";
+import {
+  StringResolverPlugin,
+  MultiNodePlugin,
+  AssetPlugin,
+} from "../../plugins";
 
 describe("Dynamic AST Transforms", () => {
   const content = {
@@ -40,6 +44,8 @@ describe("Dynamic AST Transforms", () => {
       year: "2021",
     });
     const parser = new Parser();
+    new MultiNodePlugin().applyParser(parser);
+
     const bindingParser = new BindingParser();
     const inputBinding = bindingParser.parse("year");
     const rootNode = parser.parseObject(content);
@@ -218,6 +224,7 @@ describe("Dynamic AST Transforms", () => {
       year: "2021",
     });
     const parser = new Parser();
+    new AssetPlugin().applyParser(parser);
     const bindingParser = new BindingParser();
     const inputBinding = bindingParser.parse("year");
     const rootNode = parser.parseObject(view);
@@ -271,6 +278,7 @@ describe("Dynamic AST Transforms", () => {
       year: "2021",
     });
     const parser = new Parser();
+    new AssetPlugin().applyParser(parser);
     const bindingParser = new BindingParser();
     const rootNode = parser.parseObject(content);
 
@@ -354,6 +362,7 @@ describe("Duplicate IDs", () => {
       count2: 0,
     });
     const parser = new Parser();
+    new AssetPlugin().applyParser(parser);
     const bindingParser = new BindingParser();
     const rootNode = parser.parseObject(content, NodeType.View);
 
@@ -449,6 +458,8 @@ describe("Duplicate IDs", () => {
       count2: 0,
     });
     const parser = new Parser();
+    new MultiNodePlugin().applyParser(parser);
+
     const bindingParser = new BindingParser();
     const rootNode = parser.parseObject(content, NodeType.View);
 
@@ -512,6 +523,8 @@ describe("AST caching", () => {
 
     const model = new LocalModel();
     const parser = new Parser();
+    new MultiNodePlugin().applyParser(parser);
+
     const bindingParser = new BindingParser();
     const rootNode = parser.parseObject(content, NodeType.View);
     const resolver = new Resolver(rootNode!, {

package/src/view/view.ts

@@ -4,15 +4,10 @@ import type { BindingInstance, BindingFactory } from "../binding";
 import type { ValidationProvider, ValidationObject } from "../validator";
 import type { Logger } from "../logger";
 import type { Resolve } from "./resolver";
-import { Resolver, toNodeResolveOptions } from "./resolver";
+import { Resolver } from "./resolver";
 import type { Node } from "./parser";
 import { Parser } from "./parser";
-import {
-  TemplatePlugin,
-  StringResolverPlugin,
-  ApplicabilityPlugin,
-  SwitchPlugin,
-} from "./plugins";
+import { TemplatePlugin } from "./plugins";
 
 /**
  * Manages the view level validations

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

@@ -8,6 +8,11 @@ export interface ParseObjectOptions {
     /** how nested the templated is */
     templateDepth?: number;
 }
+export interface ParseObjectChildOptions {
+    key: string;
+    path: Node.PathSegment[];
+    parentObj: object;
+}
 /**
  * The Parser is the way to take an incoming view from the user and parse it into an AST.
  * It provides a few ways to interact with the parsing, including mutating an object before and after creation of an AST node
@@ -33,20 +38,10 @@ export declare class Parser {
          *   If null, we ignore this node all together
          */
         onCreateASTNode: SyncWaterfallHook<[Node.Node | null | undefined, object], Record<string, any>>;
-        determineNodeType: SyncBailHook<[string | object], NodeType, Record<string, any>>;
-        parseNode: SyncBailHook<[obj: object, nodeType: Node.ChildrenTypes, parseOptions: ParseObjectOptions, determinedNodeType: NodeType | null], Node.Node, Record<string, any>>;
+        parseNode: SyncBailHook<[obj: object, nodeType: Node.ChildrenTypes, parseOptions: ParseObjectOptions, childOptions?: ParseObjectChildOptions | undefined], Node.Node | Node.Child[], Record<string, any>>;
     };
     parseView(value: AnyAssetType): Node.View;
-    private parseAsync;
     createASTNode(node: Node.Node | null, value: any): Node.Node | null;
-    /**
-     * 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;
-    private hasSwitchKey;
     parseObject(obj: object, type?: Node.ChildrenTypes, options?: ParseObjectOptions): Node.Node | null;
 }
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,6 +1,15 @@
 import type { Node } from "./types";
-/** Check to see if the object contains async */
-export declare function hasAsync(obj: object): boolean;
+/**
+ * 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 declare function hasTemplateValues(obj: any, localKey: string): any;
+/** Check to see if the string is a valid switch key */
+export declare function hasSwitchKey(localKey: string): boolean;
+/** Check to see if the string is a valid template key */
+export declare function hasTemplateKey(localKey: string): boolean;
 /** Get the ID of the Node if there is one */
 export declare function getNodeID(node?: Node.Node | null): string | undefined;
 //# sourceMappingURL=utils.d.ts.map

package/types/view/plugins/applicability.d.ts

@@ -3,6 +3,7 @@ import type { Parser } from "../parser";
 import { ViewInstance, ViewPlugin } from "../view";
 /** A view plugin to remove inapplicable assets from the tree */
 export default class ApplicabilityPlugin implements ViewPlugin {
+    private isApplicability;
     applyResolver(resolver: Resolver): void;
     applyParser(parser: Parser): void;
     apply(view: ViewInstance): void;

package/types/view/plugins/asset.d.ts

@@ -0,0 +1,8 @@
+import { ViewInstance, ViewPlugin } from "../view";
+import type { Parser } from "../parser";
+/** A view plugin to resolve assets */
+export default class AssetPlugin implements ViewPlugin {
+    applyParser(parser: Parser): void;
+    apply(view: ViewInstance): void;
+}
+//# sourceMappingURL=asset.d.ts.map

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

@@ -1,5 +1,7 @@
-export { default as TemplatePlugin } from "./template-plugin";
+export { default as TemplatePlugin } from "./template";
 export { default as StringResolverPlugin } from "./string-resolver";
 export { default as ApplicabilityPlugin } from "./applicability";
 export { default as SwitchPlugin } from "./switch";
+export { default as MultiNodePlugin } from "./multi-node";
+export { default as AssetPlugin } from "./asset";
 //# sourceMappingURL=index.d.ts.map

package/types/view/plugins/multi-node.d.ts

@@ -0,0 +1,8 @@
+import { ViewInstance, ViewPlugin } from "../view";
+import type { Parser } from "../parser";
+/** A view plugin to resolve multi nodes */
+export default class MultiNodePlugin implements ViewPlugin {
+    applyParser(parser: Parser): void;
+    apply(view: ViewInstance): void;
+}
+//# sourceMappingURL=multi-node.d.ts.map

package/types/view/plugins/switch.d.ts

@@ -1,12 +1,13 @@
+import { ViewInstance, ViewPlugin } from "../view";
 import type { Options } from "./options";
 import type { Parser } from "../parser";
 import type { Resolver } from "../resolver";
-import { ViewInstance, ViewPlugin } from "../view";
 /** A view plugin to resolve switches */
 export default class SwitchPlugin implements ViewPlugin {
     private readonly options;
     constructor(options: Options);
     private resolveSwitch;
+    private isSwitch;
     applyParser(parser: Parser): void;
     applyResolver(resolver: Resolver): void;
     apply(view: ViewInstance): void;

package/types/view/plugins/{template-plugin.d.ts → template.d.ts}

@@ -1,8 +1,8 @@
 import { SyncWaterfallHook } from "tapable-ts";
 import type { Parser } from "../parser";
+import { ViewInstance, ViewPlugin } from "../view";
 import type { Options } from "./options";
 import type { Resolver } from "../resolver";
-import { ViewInstance, ViewPlugin } from "../view";
 export interface TemplateItemInfo {
     /** The index of the data for the current iteration of the template */
     index: number;
@@ -30,4 +30,4 @@ export default class TemplatePlugin implements ViewPlugin {
     applyResolverHooks(resolver: Resolver): void;
     apply(view: ViewInstance): void;
 }
-//# sourceMappingURL=template-plugin.d.ts.map
+//# sourceMappingURL=template.d.ts.map