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

package/dist/index.legacy-esm.js

@@ -2386,7 +2386,7 @@ import dlv from "dlv";
 import { dequal } from "dequal";
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/parser/index.ts
-import { omit as omit2, setIn as setIn4 } from "timm";
+import { setIn as setIn4 } from "timm";
 import { SyncBailHook as SyncBailHook3, SyncWaterfallHook as SyncWaterfallHook4 } from "tapable-ts";
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/parser/types.ts
@@ -2405,8 +2405,14 @@ var NodeType = /* @__PURE__ */ ((NodeType2) => {
 })(NodeType || {});
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/parser/utils.ts
-function hasAsync(obj) {
-  return Object.prototype.hasOwnProperty.call(obj, "async");
+function hasTemplateValues(obj, localKey) {
+  return Object.hasOwnProperty.call(obj, "template") && Array.isArray(obj?.template) && obj.template.length && obj.template.find((tmpl) => tmpl.output === localKey);
+}
+function hasSwitchKey(localKey) {
+  return localKey === "staticSwitch";
+}
+function hasTemplateKey(localKey) {
+  return localKey === "template";
 }
 function getNodeID(node) {
   if (!node) {
@@ -2443,7 +2449,6 @@ var Parser = class {
        *   If null, we ignore this node all together
        */
       onCreateASTNode: new SyncWaterfallHook4(),
-      determineNodeType: new SyncBailHook3(),
       parseNode: new SyncBailHook3()
     };
   }
@@ -2454,21 +2459,6 @@ var Parser = class {
     }
     return viewNode;
   }
-  parseAsync(obj, type, options) {
-    const parsedAsync = this.parseObject(omit2(obj, "async"), type, options);
-    const parsedNodeId = getNodeID(parsedAsync);
-    if (parsedAsync !== null && parsedNodeId) {
-      return this.createASTNode(
-        {
-          id: parsedNodeId,
-          type: "async" /* Async */,
-          value: parsedAsync
-        },
-        obj
-      );
-    }
-    return null;
-  }
   createASTNode(node, value) {
     const tapped = this.hooks.onCreateASTNode.call(node, value);
     if (tapped === void 0) {
@@ -2476,30 +2466,14 @@ var Parser = class {
     }
     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
-   */
-  hasTemplateValues(obj, localKey) {
-    return Object.hasOwnProperty.call(obj, "template") && Array.isArray(obj?.template) && obj.template.length && obj.template.find((tmpl) => tmpl.output === localKey);
-  }
-  hasSwitchKey(localKey) {
-    return localKey === "staticSwitch";
-  }
   parseObject(obj, type = "value" /* Value */, options = { templateDepth: 0 }) {
-    const nodeType = this.hooks.determineNodeType.call(obj);
-    if (nodeType !== void 0) {
-      const parsedNode = this.hooks.parseNode.call(
-        obj,
-        type,
-        options,
-        nodeType
-      );
-      if (parsedNode) {
-        return parsedNode;
-      }
+    const parsedNode = this.hooks.parseNode.call(
+      obj,
+      type,
+      options
+    );
+    if (parsedNode || parsedNode === null) {
+      return parsedNode;
     }
     const parseLocalObject = (currentValue, objToParse, path = []) => {
       if (typeof objToParse !== "object" || objToParse === null) {
@@ -2521,182 +2495,44 @@ var Parser = class {
         value: currentValue
       };
       const newValue = objEntries.reduce((accumulation, current) => {
-        const { children: children2, ...rest } = accumulation;
+        let { value: value2 } = accumulation;
+        const { children: children2 } = accumulation;
         const [localKey, localValue] = current;
-        if (localKey === "asset" && typeof localValue === "object") {
-          const assetAST = this.parseObject(
-            localValue,
-            "asset" /* Asset */,
-            options
-          );
-          if (assetAST) {
-            return {
-              ...rest,
-              children: [
-                ...children2,
-                {
-                  path: [...path, "asset"],
-                  value: assetAST
-                }
-              ]
-            };
-          }
-        } else if (this.hooks.determineNodeType.call(localKey) === "template" /* Template */ && Array.isArray(localValue)) {
-          const templateChildren = localValue.map((template) => {
-            const templateAST = this.hooks.onCreateASTNode.call(
-              {
-                type: "template" /* Template */,
-                depth: options.templateDepth ?? 0,
-                data: template.data,
-                template: template.value,
-                dynamic: template.dynamic ?? false
-              },
-              template
-            );
-            if (templateAST?.type === "multi-node" /* MultiNode */) {
-              templateAST.values.forEach((v) => {
-                v.parent = templateAST;
-              });
-            }
-            if (templateAST) {
-              return {
-                path: [...path, template.output],
-                value: templateAST
-              };
-            }
-            return;
-          }).filter((element) => !!element);
-          return {
-            ...rest,
-            children: [...children2, ...templateChildren]
-          };
-        } else if (localValue && this.hooks.determineNodeType.call(localValue) === "switch" /* Switch */ || this.hasSwitchKey(localKey)) {
-          const localSwitch = this.hooks.parseNode.call(
-            this.hasSwitchKey(localKey) ? { [localKey]: localValue } : localValue,
-            "value" /* Value */,
-            options,
-            "switch" /* Switch */
-          );
-          if (localSwitch && localSwitch.type === "value" /* Value */ && localSwitch.children?.length === 1 && localSwitch.value === void 0) {
-            const firstChild = localSwitch.children[0];
-            return {
-              ...rest,
-              children: [
-                ...children2,
-                {
-                  path: [...path, localKey, ...firstChild.path],
-                  value: firstChild.value
-                }
-              ]
-            };
-          }
-          if (localSwitch) {
-            return {
-              ...rest,
-              children: [
-                ...children2,
-                {
-                  path: [...path, localKey],
-                  value: localSwitch
-                }
-              ]
-            };
-          }
-        } else if (localValue && hasAsync(localValue)) {
-          const localAsync = this.parseAsync(
-            localValue,
-            "value" /* Value */,
-            options
-          );
-          if (localAsync) {
-            children2.push({
-              path: [...path, localKey],
-              value: localAsync
-            });
-          }
-        } else if (localValue && Array.isArray(localValue)) {
-          const childValues = localValue.map(
-            (childVal) => this.parseObject(childVal, "value" /* Value */, options)
-          ).filter((child) => !!child);
-          if (childValues.length > 0) {
-            const multiNode = this.hooks.onCreateASTNode.call(
-              {
-                type: "multi-node" /* MultiNode */,
-                override: !this.hasTemplateValues(localObj, localKey),
-                values: childValues
-              },
-              localValue
-            );
-            if (multiNode?.type === "multi-node" /* MultiNode */) {
-              multiNode.values.forEach((v) => {
-                v.parent = multiNode;
-              });
-            }
-            if (multiNode) {
-              return {
-                ...rest,
-                children: [
-                  ...children2,
-                  {
-                    path: [...path, localKey],
-                    value: multiNode
-                  }
-                ]
-              };
-            }
+        const newChildren = this.hooks.parseNode.call(
+          localValue,
+          "value" /* Value */,
+          options,
+          {
+            path,
+            key: localKey,
+            parentObj: localObj
           }
+        );
+        if (newChildren) {
+          children2.push(...newChildren);
         } else if (localValue && typeof localValue === "object") {
-          const determineNodeType = this.hooks.determineNodeType.call(localValue);
-          if (determineNodeType === "applicability" /* Applicability */) {
-            const parsedNode = this.hooks.parseNode.call(
-              localValue,
-              "value" /* Value */,
-              options,
-              determineNodeType
-            );
-            if (parsedNode) {
-              return {
-                ...rest,
-                children: [
-                  ...children2,
-                  {
-                    path: [...path, localKey],
-                    value: parsedNode
-                  }
-                ]
-              };
-            }
-          } else {
-            const result = parseLocalObject(accumulation.value, localValue, [
-              ...path,
-              localKey
-            ]);
-            return {
-              value: result.value,
-              children: [...children2, ...result.children]
-            };
-          }
+          const result = parseLocalObject(accumulation.value, localValue, [
+            ...path,
+            localKey
+          ]);
+          value2 = result.value;
+          children2.push(...result.children);
         } else {
-          const value2 = setIn4(
-            accumulation.value,
-            [...path, localKey],
-            localValue
-          );
-          return {
-            children: children2,
-            value: value2
-          };
+          value2 = setIn4(accumulation.value, [...path, localKey], localValue);
         }
-        return accumulation;
+        return {
+          value: value2,
+          children: children2
+        };
       }, defaultValue);
       return newValue;
     };
     const { value, children } = parseLocalObject(void 0, obj);
-    const baseAst = value === void 0 && children.length === 0 ? void 0 : {
+    const baseAst = value === void 0 && !children.length ? void 0 : {
       type,
       value
     };
-    if (baseAst !== void 0 && children.length > 0) {
+    if (baseAst && children.length) {
       const parent = baseAst;
       parent.children = children;
       children.forEach((child) => {
@@ -3206,7 +3042,7 @@ var Builder = class {
   }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/template-plugin.ts
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/template.ts
 import { SyncWaterfallHook as SyncWaterfallHook6 } from "tapable-ts";
 var TemplatePlugin = class {
   constructor(options) {
@@ -3272,28 +3108,33 @@ var TemplatePlugin = class {
       }
       return node;
     });
-    parser.hooks.determineNodeType.tap("template", (obj) => {
-      if (obj === "template") {
-        return "template" /* Template */;
-      }
-    });
     parser.hooks.parseNode.tap(
       "template",
-      (obj, _nodeType, options, determinedNodeType) => {
-        if (determinedNodeType === "template" /* Template */) {
-          const templateNode = parser.createASTNode(
-            {
-              type: "template" /* Template */,
-              depth: options.templateDepth ?? 0,
-              data: obj.data,
-              template: obj.value,
-              dynamic: obj.dynamic ?? false
-            },
-            obj
-          );
-          if (templateNode) {
-            return templateNode;
-          }
+      (obj, _nodeType, options, childOptions) => {
+        if (childOptions && hasTemplateKey(childOptions.key)) {
+          return obj.map((template) => {
+            const templateAST = parser.createASTNode(
+              {
+                type: "template" /* Template */,
+                depth: options.templateDepth ?? 0,
+                data: template.data,
+                template: template.value,
+                dynamic: template.dynamic ?? false
+              },
+              template
+            );
+            if (!templateAST)
+              return;
+            if (templateAST.type === "multi-node" /* MultiNode */) {
+              templateAST.values.forEach((v) => {
+                v.parent = templateAST;
+              });
+            }
+            return {
+              path: [...childOptions.path, template.output],
+              value: templateAST
+            };
+          }).filter(Boolean);
         }
       }
     );
@@ -3417,8 +3258,11 @@ var StringResolverPlugin = class {
 };
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/applicability.ts
-import { omit as omit3 } from "timm";
+import { omit as omit2 } from "timm";
 var ApplicabilityPlugin = class {
+  isApplicability(obj) {
+    return obj && Object.prototype.hasOwnProperty.call(obj, "applicability");
+  }
   applyResolver(resolver) {
     resolver.hooks.beforeResolve.tap(
       "applicability",
@@ -3436,34 +3280,38 @@ var ApplicabilityPlugin = class {
     );
   }
   applyParser(parser) {
-    parser.hooks.determineNodeType.tap("applicability", (obj) => {
-      if (Object.prototype.hasOwnProperty.call(obj, "applicability")) {
-        return "applicability" /* Applicability */;
-      }
-    });
     parser.hooks.parseNode.tap(
       "applicability",
-      (obj, nodeType, options, determinedNodeType) => {
-        if (determinedNodeType === "applicability" /* Applicability */) {
+      (obj, nodeType, options, childOptions) => {
+        if (this.isApplicability(obj)) {
           const parsedApplicability = parser.parseObject(
-            omit3(obj, "applicability"),
+            omit2(obj, "applicability"),
             nodeType,
             options
           );
-          if (parsedApplicability !== null) {
-            const applicabilityNode = parser.createASTNode(
-              {
-                type: "applicability" /* Applicability */,
-                expression: obj.applicability,
-                value: parsedApplicability
-              },
-              obj
-            );
-            if (applicabilityNode?.type === "applicability" /* Applicability */) {
-              applicabilityNode.value.parent = applicabilityNode;
-            }
-            return applicabilityNode;
+          if (!parsedApplicability) {
+            return childOptions ? [] : null;
+          }
+          const applicabilityNode = parser.createASTNode(
+            {
+              type: "applicability" /* Applicability */,
+              expression: obj.applicability,
+              value: parsedApplicability
+            },
+            obj
+          );
+          if (!applicabilityNode) {
+            return childOptions ? [] : null;
+          }
+          if (applicabilityNode.type === "applicability" /* Applicability */) {
+            applicabilityNode.value.parent = applicabilityNode;
           }
+          return childOptions ? [
+            {
+              path: [...childOptions.path, childOptions.key],
+              value: applicabilityNode
+            }
+          ] : applicabilityNode;
         }
       }
     );
@@ -3488,6 +3336,9 @@ var SwitchPlugin = class {
     }
     return EMPTY_NODE;
   }
+  isSwitch(obj) {
+    return obj && (Object.prototype.hasOwnProperty.call(obj, "dynamicSwitch") || Object.prototype.hasOwnProperty.call(obj, "staticSwitch"));
+  }
   applyParser(parser) {
     parser.hooks.onCreateASTNode.tap("switch", (node) => {
       if (node && node.type === "switch" /* Switch */ && !node.dynamic) {
@@ -3495,19 +3346,14 @@ var SwitchPlugin = class {
       }
       return node;
     });
-    parser.hooks.determineNodeType.tap("switch", (obj) => {
-      if (Object.prototype.hasOwnProperty.call(obj, "dynamicSwitch") || Object.prototype.hasOwnProperty.call(obj, "staticSwitch")) {
-        return "switch" /* Switch */;
-      }
-    });
     parser.hooks.parseNode.tap(
       "switch",
-      (obj, _nodeType, options, determinedNodeType) => {
-        if (determinedNodeType === "switch" /* Switch */) {
-          const dynamic = "dynamicSwitch" in obj;
-          const switchContent = "dynamicSwitch" in obj ? obj.dynamicSwitch : obj.staticSwitch;
-          const cases = [];
-          switchContent.forEach(
+      (obj, _nodeType, options, childOptions) => {
+        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 = switchContent.map(
             (switchCase) => {
               const { case: switchCaseExpr, ...switchBody } = switchCase;
               const value = parser.parseObject(
@@ -3516,30 +3362,41 @@ var SwitchPlugin = class {
                 options
               );
               if (value) {
-                cases.push({
+                return {
                   case: switchCaseExpr,
                   value
-                });
+                };
               }
+              return;
             }
-          );
-          const switchAST = parser.hooks.onCreateASTNode.call(
+          ).filter(Boolean);
+          const switchAST = parser.createASTNode(
             {
               type: "switch" /* Switch */,
               dynamic,
               cases
             },
-            obj
+            objToParse
           );
-          if (switchAST?.type === "switch" /* Switch */) {
+          if (!switchAST || switchAST.type === "empty" /* Empty */) {
+            return childOptions ? [] : null;
+          }
+          if (switchAST.type === "switch" /* Switch */) {
             switchAST.cases.forEach((sCase) => {
               sCase.value.parent = switchAST;
             });
           }
-          if (switchAST?.type === "empty" /* Empty */) {
-            return null;
+          if (childOptions) {
+            let path = [...childOptions.path, childOptions.key];
+            let value = switchAST;
+            if (switchAST.type === "value" /* Value */ && switchAST.children?.length === 1 && switchAST.value === void 0) {
+              const firstChild = switchAST.children[0];
+              path = [...path, ...firstChild.path];
+              value = firstChild.value;
+            }
+            return [{ path, value }];
           }
-          return switchAST ?? null;
+          return switchAST;
         }
       }
     );
@@ -3558,6 +3415,79 @@ var SwitchPlugin = class {
   }
 };
 
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/multi-node.ts
+var MultiNodePlugin = class {
+  applyParser(parser) {
+    parser.hooks.parseNode.tap(
+      "multi-node",
+      (obj, nodeType, options, childOptions) => {
+        if (childOptions && !hasTemplateKey(childOptions.key) && Array.isArray(obj)) {
+          const values = obj.map(
+            (childVal) => parser.parseObject(childVal, "value" /* Value */, options)
+          ).filter((child) => !!child);
+          if (!values.length) {
+            return [];
+          }
+          const multiNode = parser.createASTNode(
+            {
+              type: "multi-node" /* MultiNode */,
+              override: !hasTemplateValues(
+                childOptions.parentObj,
+                childOptions.key
+              ),
+              values
+            },
+            obj
+          );
+          if (!multiNode) {
+            return [];
+          }
+          if (multiNode.type === "multi-node" /* MultiNode */) {
+            multiNode.values.forEach((v) => {
+              v.parent = multiNode;
+            });
+          }
+          return [
+            {
+              path: [...childOptions.path, childOptions.key],
+              value: multiNode
+            }
+          ];
+        }
+      }
+    );
+  }
+  apply(view) {
+    view.hooks.parser.tap("multi-node", this.applyParser.bind(this));
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/asset.ts
+var AssetPlugin = class {
+  applyParser(parser) {
+    parser.hooks.parseNode.tap(
+      "asset",
+      (obj, nodeType, options, childOptions) => {
+        if (childOptions?.key === "asset" && typeof obj === "object") {
+          const assetAST = parser.parseObject(obj, "asset" /* Asset */, options);
+          if (!assetAST) {
+            return [];
+          }
+          return [
+            {
+              path: [...childOptions.path, childOptions.key],
+              value: assetAST
+            }
+          ];
+        }
+      }
+    );
+  }
+  apply(view) {
+    view.hooks.parser.tap("asset", this.applyParser.bind(this));
+  }
+};
+
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/player.ts
 import { setIn as setIn7 } from "timm";
 import deferred from "p-defer";
@@ -5047,12 +4977,14 @@ var DefaultViewPlugin = class {
     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);
       });
     });
   }
@@ -5397,6 +5329,7 @@ _Player.info = {
 var Player = _Player;
 export {
   ApplicabilityPlugin,
+  AssetPlugin,
   AssetTransformCorePlugin,
   BINDING_BRACKETS_REGEX,
   BindingInstance,
@@ -5416,6 +5349,7 @@ export {
   FlowInstance,
   LocalModel,
   LocalStateStore,
+  MultiNodePlugin,
   NOOPDataModel,
   NOOP_MODEL,
   NOT_STARTED_STATE,
@@ -5449,7 +5383,9 @@ export {
   findNextExp,
   getBindingSegments,
   getNodeID,
-  hasAsync,
+  hasSwitchKey,
+  hasTemplateKey,
+  hasTemplateValues,
   isBinding,
   isErrorWithLocation,
   isExpressionNode,