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

package/src/view/plugins/applicability.ts

@@ -1,15 +1,15 @@
-import { omit } from 'timm';
-import type { ViewPlugin, View } from './plugin';
-import type { Options } from './options';
-import type { Resolver } from '../resolver';
-import type { Node, ParseObjectOptions, Parser } from '../parser';
-import { NodeType } from '../parser';
+import { omit } from "timm";
+import type { Options } from "./options";
+import type { Resolver } from "../resolver";
+import type { Node, ParseObjectOptions, Parser } from "../parser";
+import { NodeType } from "../parser";
+import { ViewInstance, ViewPlugin } from "../view";
 
 /** A view plugin to remove inapplicable assets from the tree */
 export default class ApplicabilityPlugin implements ViewPlugin {
   applyResolver(resolver: Resolver) {
     resolver.hooks.beforeResolve.tap(
-      'applicability',
+      "applicability",
       (node: Node.Node | null, options: Options) => {
         let newNode = node;
 
@@ -24,31 +24,31 @@ export default class ApplicabilityPlugin implements ViewPlugin {
         }
 
         return newNode;
-      }
+      },
     );
   }
 
   applyParser(parser: Parser) {
     /** Switches resolved during the parsing phase are static */
-    parser.hooks.determineNodeType.tap('applicability', (obj: any) => {
-      if (Object.prototype.hasOwnProperty.call(obj, 'applicability')) {
+    parser.hooks.determineNodeType.tap("applicability", (obj: any) => {
+      if (Object.prototype.hasOwnProperty.call(obj, "applicability")) {
         return NodeType.Applicability;
       }
     });
 
     parser.hooks.parseNode.tap(
-      'applicability',
+      "applicability",
       (
         obj: any,
         nodeType: Node.ChildrenTypes,
         options: ParseObjectOptions,
-        determinedNodeType: null | NodeType
+        determinedNodeType: null | NodeType,
       ) => {
         if (determinedNodeType === NodeType.Applicability) {
           const parsedApplicability = parser.parseObject(
-            omit(obj, 'applicability'),
+            omit(obj, "applicability"),
             nodeType,
-            options
+            options,
           );
           if (parsedApplicability !== null) {
             const applicabilityNode = parser.createASTNode(
@@ -57,7 +57,7 @@ export default class ApplicabilityPlugin implements ViewPlugin {
                 expression: (obj as any).applicability,
                 value: parsedApplicability,
               },
-              obj
+              obj,
             );
 
             if (applicabilityNode?.type === NodeType.Applicability) {
@@ -67,12 +67,12 @@ export default class ApplicabilityPlugin implements ViewPlugin {
             return applicabilityNode;
           }
         }
-      }
+      },
     );
   }
 
-  apply(view: View) {
-    view.hooks.resolver.tap('applicability', this.applyResolver.bind(this));
-    view.hooks.parser.tap('applicability', this.applyParser.bind(this));
+  apply(view: ViewInstance) {
+    view.hooks.resolver.tap("applicability", this.applyResolver.bind(this));
+    view.hooks.parser.tap("applicability", this.applyParser.bind(this));
   }
 }

package/src/view/plugins/index.ts

@@ -1,5 +1,4 @@
-export { default as TemplatePlugin } from './template-plugin';
-export { default as StringResolverPlugin } from './string-resolver';
-export { default as ApplicabilityPlugin } from './applicability';
-export { default as SwitchPlugin } from './switch';
-export type { ViewPlugin } from './plugin';
+export { default as TemplatePlugin } from "./template-plugin";
+export { default as StringResolverPlugin } from "./string-resolver";
+export { default as ApplicabilityPlugin } from "./applicability";
+export { default as SwitchPlugin } from "./switch";

package/src/view/plugins/options.ts

@@ -1,4 +1,4 @@
-import type { Resolve } from '../resolver';
+import type { Resolve } from "../resolver";
 
 /** Config options that are required to resolve/update a view */
 export type Options = Resolve.NodeResolveOptions;

package/src/view/plugins/string-resolver.ts

@@ -1,10 +1,10 @@
-import { set } from 'timm';
-import { resolveDataRefs } from '../../string-resolver';
-import type { Options } from './options';
-import type { View, ViewPlugin } from './plugin';
-import type { Node } from '../parser';
-import { NodeType } from '../parser';
-import type { Resolver } from '../resolver';
+import { set } from "timm";
+import { resolveDataRefs } from "../../string-resolver";
+import type { Options } from "./options";
+import type { Node } from "../parser";
+import { NodeType } from "../parser";
+import type { Resolver } from "../resolver";
+import { ViewInstance, ViewPlugin } from "../view";
 
 /** Create a function that checks for a start/end sequence in a string */
 const createPatternMatcher = (start: string, end: string) => {
@@ -25,8 +25,8 @@ const createPatternMatcher = (start: string, end: string) => {
   };
 };
 
-const bindingResolveLookup = createPatternMatcher('{{', '}}');
-const expressionResolveLookup = createPatternMatcher('@[', ']@');
+const bindingResolveLookup = createPatternMatcher("{{", "}}");
+const expressionResolveLookup = createPatternMatcher("@[", "]@");
 
 /** Check to see if a string contains a reference to dynamic content */
 function hasSomethingToResolve(str: string) {
@@ -47,17 +47,17 @@ function resolveString(str: string, resolveOptions: Options) {
 export function resolveAllRefs(
   node: any,
   resolveOptions: Options,
-  propertiesToSkip: Set<string | number>
+  propertiesToSkip: Set<string | number>,
 ): any {
   if (
     node === null ||
     node === undefined ||
-    (typeof node !== 'object' && typeof node !== 'string')
+    (typeof node !== "object" && typeof node !== "string")
   ) {
     return node;
   }
 
-  if (typeof node === 'string') {
+  if (typeof node === "string") {
     return resolveString(node, resolveOptions);
   }
 
@@ -72,9 +72,9 @@ export function resolveAllRefs(
 
     let newVal = val;
 
-    if (typeof val === 'object') {
+    if (typeof val === "object") {
       newVal = resolveAllRefs(val, resolveOptions, propertiesToSkip);
-    } else if (typeof val === 'string') {
+    } else if (typeof val === "string") {
       newVal = resolveString(val, resolveOptions);
     }
 
@@ -89,14 +89,14 @@ export function resolveAllRefs(
 /** Traverse up the node tree finding the first available 'path' */
 const findBasePath = (
   node: Node.Node,
-  resolver: Resolver
+  resolver: Resolver,
 ): Node.PathSegment[] => {
   const parentNode = node.parent;
   if (!parentNode) {
     return [];
   }
 
-  if ('children' in parentNode) {
+  if ("children" in parentNode) {
     const original = resolver.getSourceNode(node);
     return (
       parentNode.children?.find((child) => child.value === original)?.path ?? []
@@ -119,7 +119,7 @@ export default class StringResolverPlugin implements ViewPlugin {
   }
 
   applyResolver(resolver: Resolver) {
-    resolver.hooks.resolve.tap('string-resolver', (value, node, options) => {
+    resolver.hooks.resolve.tap("string-resolver", (value, node, options) => {
       if (node.type === NodeType.Empty || node.type === NodeType.Unknown) {
         return null;
       }
@@ -133,7 +133,7 @@ export default class StringResolverPlugin implements ViewPlugin {
         let propsToSkip: Set<string>;
         if (node.type === NodeType.Asset || node.type === NodeType.View) {
           propsToSkip = new Set(
-            node.plugins?.stringResolver?.propertiesToSkip ?? ['exp']
+            node.plugins?.stringResolver?.propertiesToSkip ?? ["exp"],
           );
           if (node.value?.id) {
             this.propertiesToSkipCache.set(node.value.id, propsToSkip);
@@ -146,10 +146,10 @@ export default class StringResolverPlugin implements ViewPlugin {
           this.propertiesToSkipCache.has(node.parent.parent.value.id)
         ) {
           propsToSkip = this.propertiesToSkipCache.get(
-            node.parent.parent.value.id
+            node.parent.parent.value.id,
           ) as Set<string>;
         } else {
-          propsToSkip = new Set(['exp']);
+          propsToSkip = new Set(["exp"]);
         }
 
         const nodePath = findBasePath(node, resolver);
@@ -169,7 +169,7 @@ export default class StringResolverPlugin implements ViewPlugin {
     });
   }
 
-  apply(view: View) {
-    view.hooks.resolver.tap('string-resolver', this.applyResolver.bind(this));
+  apply(view: ViewInstance) {
+    view.hooks.resolver.tap("string-resolver", this.applyResolver.bind(this));
   }
 }

package/src/view/plugins/switch.ts

@@ -1,8 +1,8 @@
-import type { View, ViewPlugin } from './plugin';
-import type { Options } from './options';
-import type { Parser, Node, ParseObjectOptions } from '../parser';
-import { EMPTY_NODE, NodeType } from '../parser';
-import type { Resolver } from '../resolver';
+import type { Options } from "./options";
+import type { Parser, Node, ParseObjectOptions } from "../parser";
+import { EMPTY_NODE, NodeType } from "../parser";
+import type { Resolver } from "../resolver";
+import { ViewInstance, ViewPlugin } from "../view";
 
 /** A view plugin to resolve switches */
 export default class SwitchPlugin implements ViewPlugin {
@@ -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;
       }
@@ -26,7 +25,7 @@ export default class SwitchPlugin implements ViewPlugin {
 
   applyParser(parser: Parser) {
     /** Switches resolved during the parsing phase are static */
-    parser.hooks.onCreateASTNode.tap('switch', (node) => {
+    parser.hooks.onCreateASTNode.tap("switch", (node) => {
       if (node && node.type === NodeType.Switch && !node.dynamic) {
         return this.resolveSwitch(node, this.options);
       }
@@ -34,27 +33,27 @@ export default class SwitchPlugin implements ViewPlugin {
       return node;
     });
 
-    parser.hooks.determineNodeType.tap('switch', (obj) => {
+    parser.hooks.determineNodeType.tap("switch", (obj) => {
       if (
-        Object.prototype.hasOwnProperty.call(obj, 'dynamicSwitch') ||
-        Object.prototype.hasOwnProperty.call(obj, 'staticSwitch')
+        Object.prototype.hasOwnProperty.call(obj, "dynamicSwitch") ||
+        Object.prototype.hasOwnProperty.call(obj, "staticSwitch")
       ) {
         return NodeType.Switch;
       }
     });
 
     parser.hooks.parseNode.tap(
-      'switch',
+      "switch",
       (
         obj: any,
-        nodeType: Node.ChildrenTypes,
+        _nodeType: Node.ChildrenTypes,
         options: ParseObjectOptions,
-        determinedNodeType: null | NodeType
+        determinedNodeType: null | NodeType,
       ) => {
         if (determinedNodeType === NodeType.Switch) {
-          const dynamic = 'dynamicSwitch' in obj;
+          const dynamic = "dynamicSwitch" in obj;
           const switchContent =
-            'dynamicSwitch' in obj ? obj.dynamicSwitch : obj.staticSwitch;
+            "dynamicSwitch" in obj ? obj.dynamicSwitch : obj.staticSwitch;
 
           const cases: Node.SwitchCase[] = [];
 
@@ -70,7 +69,7 @@ export default class SwitchPlugin implements ViewPlugin {
               const value = parser.parseObject(
                 switchBody,
                 NodeType.Value,
-                options
+                options,
               );
 
               if (value) {
@@ -79,7 +78,7 @@ export default class SwitchPlugin implements ViewPlugin {
                   value: value as Node.Value,
                 });
               }
-            }
+            },
           );
 
           const switchAST = parser.hooks.onCreateASTNode.call(
@@ -88,7 +87,7 @@ export default class SwitchPlugin implements ViewPlugin {
               dynamic,
               cases,
             },
-            obj
+            obj,
           );
 
           if (switchAST?.type === NodeType.Switch) {
@@ -104,13 +103,13 @@ export default class SwitchPlugin implements ViewPlugin {
 
           return switchAST ?? null;
         }
-      }
+      },
     );
   }
 
   applyResolver(resolver: Resolver) {
     /** Switches resolved during the parsing phase are dynamic */
-    resolver.hooks.beforeResolve.tap('switch', (node, options) => {
+    resolver.hooks.beforeResolve.tap("switch", (node, options) => {
       if (node && node.type === NodeType.Switch && node.dynamic) {
         return this.resolveSwitch(node, options);
       }
@@ -119,8 +118,8 @@ export default class SwitchPlugin implements ViewPlugin {
     });
   }
 
-  apply(view: View) {
-    view.hooks.parser.tap('switch', this.applyParser.bind(this));
-    view.hooks.resolver.tap('switch', this.applyResolver.bind(this));
+  apply(view: ViewInstance) {
+    view.hooks.parser.tap("switch", this.applyParser.bind(this));
+    view.hooks.resolver.tap("switch", this.applyResolver.bind(this));
   }
 }

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

@@ -1,10 +1,9 @@
-import { SyncWaterfallHook } from 'tapable-ts';
-import type { Node, ParseObjectOptions, Parser } from '../parser';
-import { NodeType } from '../parser';
-import type { ViewPlugin } from '.';
-import type { View } from './plugin';
-import type { Options } from './options';
-import type { Resolver } from '../resolver';
+import { SyncWaterfallHook } from "tapable-ts";
+import type { Node, ParseObjectOptions, Parser } from "../parser";
+import { NodeType } from "../parser";
+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 */
@@ -24,7 +23,7 @@ export interface TemplateSubstitution {
 
 export type TemplateSubstitutionsFunc = (
   baseSubstitutions: TemplateSubstitution[],
-  templateItemInfo: TemplateItemInfo
+  templateItemInfo: TemplateItemInfo,
 ) => TemplateSubstitution[];
 
 /** A view plugin to resolve/manage templates */
@@ -44,7 +43,7 @@ export default class TemplatePlugin implements ViewPlugin {
   private parseTemplate(
     parseObject: any,
     node: Node.Template,
-    options: Options
+    options: Options,
   ): Node.Node | null {
     const { template, depth } = node;
     const data = options.data.model.get(node.data);
@@ -64,7 +63,7 @@ export default class TemplatePlugin implements ViewPlugin {
         this.hooks.resolveTemplateSubstitutions.call(
           [
             {
-              expression: new RegExp(`_index${depth || ''}_`),
+              expression: new RegExp(`_index${depth || ""}_`),
               value: String(index),
             },
           ],
@@ -72,14 +71,14 @@ export default class TemplatePlugin implements ViewPlugin {
             depth,
             data: dataItem,
             index,
-          }
+          },
         );
       let templateStr = JSON.stringify(template);
 
       for (const { expression, value } of templateSubstitutions) {
-        let flags = 'g';
-        if (typeof expression === 'object') {
-          flags = `${expression.flags}${expression.global ? '' : 'g'}`;
+        let flags = "g";
+        if (typeof expression === "object") {
+          flags = `${expression.flags}${expression.global ? "" : "g"}`;
         }
 
         templateStr = templateStr.replace(new RegExp(expression, flags), value);
@@ -104,31 +103,31 @@ export default class TemplatePlugin implements ViewPlugin {
   }
 
   applyParser(parser: Parser) {
-    parser.hooks.onCreateASTNode.tap('template', (node) => {
+    parser.hooks.onCreateASTNode.tap("template", (node) => {
       if (node && node.type === NodeType.Template && !node.dynamic) {
         return this.parseTemplate(
           parser.parseObject.bind(parser),
           node,
-          this.options
+          this.options,
         );
       }
 
       return node;
     });
 
-    parser.hooks.determineNodeType.tap('template', (obj: any) => {
-      if (obj === 'template') {
+    parser.hooks.determineNodeType.tap("template", (obj: any) => {
+      if (obj === "template") {
         return NodeType.Template;
       }
     });
 
     parser.hooks.parseNode.tap(
-      'template',
+      "template",
       (
         obj: any,
-        nodeType: Node.ChildrenTypes,
+        _nodeType: Node.ChildrenTypes,
         options: ParseObjectOptions,
-        determinedNodeType: null | NodeType
+        determinedNodeType: null | NodeType,
       ) => {
         if (determinedNodeType === NodeType.Template) {
           const templateNode = parser.createASTNode(
@@ -139,19 +138,19 @@ export default class TemplatePlugin implements ViewPlugin {
               template: obj.value,
               dynamic: obj.dynamic ?? false,
             },
-            obj
+            obj,
           );
 
           if (templateNode) {
             return templateNode;
           }
         }
-      }
+      },
     );
   }
 
   applyResolverHooks(resolver: Resolver) {
-    resolver.hooks.beforeResolve.tap('template', (node, options) => {
+    resolver.hooks.beforeResolve.tap("template", (node, options) => {
       if (node && node.type === NodeType.Template && node.dynamic) {
         return this.parseTemplate(options.parseNode, node, options);
       }
@@ -160,8 +159,8 @@ export default class TemplatePlugin implements ViewPlugin {
     });
   }
 
-  apply(view: View) {
-    view.hooks.parser.tap('template', this.applyParser.bind(this));
-    view.hooks.resolver.tap('template', this.applyResolverHooks.bind(this));
+  apply(view: ViewInstance) {
+    view.hooks.parser.tap("template", this.applyParser.bind(this));
+    view.hooks.resolver.tap("template", this.applyResolverHooks.bind(this));
   }
 }