@player-ui/player 0.3.1-next.1 → 0.3.1

package/src/validator/binding-map-splice.ts

@@ -0,0 +1,59 @@
+import type { BindingInstance } from '../binding';
+
+/**
+ * Remove a binding, and any children from from the map
+ * If the binding is an array-item, then it will be spliced from the array and the others will be shifted down
+ *
+ * @param sourceMap - A map of bindings to values
+ * @param binding - The binding to remove from the map
+ */
+export function removeBindingAndChildrenFromMap<T>(
+  sourceMap: Map<BindingInstance, T>,
+  binding: BindingInstance
+): Map<BindingInstance, T> {
+  const targetMap = new Map(sourceMap);
+
+  const parentBinding = binding.parent();
+  const property = binding.key();
+
+  // Clear out any that are sub-bindings of this binding
+
+  targetMap.forEach((_value, trackedBinding) => {
+    if (binding === trackedBinding || binding.contains(trackedBinding)) {
+      targetMap.delete(trackedBinding);
+    }
+  });
+
+  if (typeof property === 'number') {
+    // Splice out this index from the rest
+
+    // Order matters here b/c we are shifting items in the array
+    // Start with the smallest index and work our way down
+    const bindingsToRewrite = Array.from(sourceMap.keys())
+      .filter((b) => {
+        if (parentBinding.contains(b)) {
+          const [childIndex] = b.relative(parentBinding);
+          return typeof childIndex === 'number' && childIndex > property;
+        }
+
+        return false;
+      })
+      .sort();
+
+    bindingsToRewrite.forEach((trackedBinding) => {
+      // If the tracked binding is a sub-binding of the parent binding, then we need to
+      // update the path to reflect the new index
+
+      const [childIndex, ...childPath] = trackedBinding.relative(parentBinding);
+
+      if (typeof childIndex === 'number') {
+        const newSegments = [childIndex - 1, ...childPath];
+        const newChildBinding = parentBinding.descendent(newSegments);
+        targetMap.set(newChildBinding, targetMap.get(trackedBinding) as T);
+        targetMap.delete(trackedBinding);
+      }
+    });
+  }
+
+  return targetMap;
+}

package/src/validator/index.ts

@@ -1,3 +1,4 @@
 export * from './validation-middleware';
 export * from './types';
 export * from './registry';
+export * from './binding-map-splice';

package/src/validator/types.ts

@@ -1,4 +1,4 @@
-import type { Validation } from '@player-ui/types';
+import type { Schema, Validation } from '@player-ui/types';
 
 import type { BindingInstance, BindingFactory } from '../binding';
 import type { DataModelWithParser } from '../data';
@@ -40,12 +40,17 @@ type RequiredValidationKeys = 'severity' | 'trigger';
 export type ValidationObject = Validation.Reference &
   Required<Pick<Validation.Reference, RequiredValidationKeys>>;
 
+export type ValidationObjectWithHandler = ValidationObject & {
+  /** A predefined handler for this validation object */
+  handler?: ValidatorFunction;
+};
+
 export interface ValidationProvider {
   getValidationsForBinding?(
     binding: BindingInstance
-  ): Array<ValidationObject> | undefined;
+  ): Array<ValidationObjectWithHandler> | undefined;
 
-  getValidationsForView?(): Array<ValidationObject> | undefined;
+  getValidationsForView?(): Array<ValidationObjectWithHandler> | undefined;
 }
 
 export interface ValidatorContext {
@@ -66,6 +71,9 @@ export interface ValidatorContext {
 
   /** The constants for messages */
   constants: ConstantsProvider;
+
+  /** The type in the schema that triggered the validation if there is one */
+  schemaType: Schema.DataType | undefined;
 }
 
 export type ValidatorFunction<Options = unknown> = (

package/src/validator/validation-middleware.ts

@@ -11,6 +11,17 @@ import { toModel } from '../data';
 import type { Logger } from '../logger';
 
 import type { ValidationResponse } from './types';
+import { removeBindingAndChildrenFromMap } from './binding-map-splice';
+
+/**
+ * A BindingInstance with an indicator of whether or not it's a strong binding
+ */
+export type StrongOrWeakBinding = {
+  /** BindingInstance in question */
+  binding: BindingInstance;
+  /** Boolean indicating whether the relevant BindingInstance is a strong binding */
+  isStrong: boolean;
+};
 
 /**
  * Returns a validation object if the data is invalid or an set of BindingsInstances if the binding itself is a weak ref of another invalid validation
@@ -18,7 +29,7 @@ import type { ValidationResponse } from './types';
 export type MiddlewareChecker = (
   binding: BindingInstance,
   model: DataModelImpl
-) => ValidationResponse | Set<BindingInstance> | undefined;
+) => ValidationResponse | Set<StrongOrWeakBinding> | undefined;
 
 /**
  * Middleware for the data-model that caches the results of invalid data
@@ -27,17 +38,21 @@ export class ValidationMiddleware implements DataModelMiddleware {
   public validator: MiddlewareChecker;
   public shadowModelPaths: Map<BindingInstance, any>;
   private logger?: Logger;
+  private shouldIncludeInvalid?: (options?: DataModelOptions) => boolean;
 
   constructor(
     validator: MiddlewareChecker,
     options?: {
       /** A logger instance */
       logger?: Logger;
+      /** Optional function to include data staged in shadowModel */
+      shouldIncludeInvalid?: (options?: DataModelOptions) => boolean;
     }
   ) {
     this.validator = validator;
     this.shadowModelPaths = new Map();
     this.logger = options?.logger;
+    this.shouldIncludeInvalid = options?.shouldIncludeInvalid;
   }
 
   public set(
@@ -48,8 +63,11 @@ export class ValidationMiddleware implements DataModelMiddleware {
     const asModel = toModel(this, { ...options, includeInvalid: true }, next);
     const nextTransaction: BatchSetTransaction = [];
 
+    const includedBindings = new Set<BindingInstance>();
+
     transaction.forEach(([binding, value]) => {
       this.shadowModelPaths.set(binding, value);
+      includedBindings.add(binding);
     });
 
     const invalidBindings: Array<BindingInstance> = [];
@@ -60,8 +78,17 @@ export class ValidationMiddleware implements DataModelMiddleware {
       if (validations === undefined) {
         nextTransaction.push([binding, value]);
       } else if (validations instanceof Set) {
-        invalidBindings.push(...validations);
-      } else {
+        validations.forEach((validation) => {
+          invalidBindings.push(validation.binding);
+          if (
+            !validation.isStrong &&
+            validation.binding.asString() === binding.asString()
+          ) {
+            nextTransaction.push([validation.binding, value]);
+          }
+        });
+      } else if (includedBindings.has(binding)) {
+        invalidBindings.push(binding);
         this.logger?.debug(
           `Invalid value for path: ${binding.asString()} - ${
             validations.severity
@@ -70,15 +97,22 @@ export class ValidationMiddleware implements DataModelMiddleware {
       }
     });
 
+    let validResults: Updates = [];
+
     if (next && nextTransaction.length > 0) {
       // defer clearing the shadow model to prevent validations that are run twice due to weak binding refs still needing the data
       nextTransaction.forEach(([binding]) =>
         this.shadowModelPaths.delete(binding)
       );
-      return next.set(nextTransaction, options);
+      const result = next.set(nextTransaction, options);
+      if (invalidBindings.length === 0) {
+        return result;
+      }
+
+      validResults = result;
     }
 
-    return invalidBindings.map((binding) => {
+    const invalidResults = invalidBindings.map((binding) => {
       return {
         binding,
         oldValue: asModel.get(binding),
@@ -86,6 +120,8 @@ export class ValidationMiddleware implements DataModelMiddleware {
         force: true,
       };
     });
+
+    return [...validResults, ...invalidResults];
   }
 
   public get(
@@ -95,7 +131,10 @@ export class ValidationMiddleware implements DataModelMiddleware {
   ) {
     let val = next?.get(binding, options);
 
-    if (options?.includeInvalid === true) {
+    if (
+      this.shouldIncludeInvalid?.(options) ??
+      options?.includeInvalid === true
+    ) {
       this.shadowModelPaths.forEach((shadowValue, shadowBinding) => {
         if (shadowBinding === binding) {
           val = shadowValue;
@@ -111,4 +150,17 @@ export class ValidationMiddleware implements DataModelMiddleware {
 
     return val;
   }
+
+  public delete(
+    binding: BindingInstance,
+    options?: DataModelOptions,
+    next?: DataModelImpl
+  ) {
+    this.shadowModelPaths = removeBindingAndChildrenFromMap(
+      this.shadowModelPaths,
+      binding
+    );
+
+    return next?.delete(binding, options);
+  }
 }

package/src/view/parser/index.ts

@@ -83,6 +83,21 @@ export class Parser {
     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
+   */
+  private hasTemplateValues(obj: any, localKey: string) {
+    return (
+      Object.hasOwnProperty.call(obj, 'template') &&
+      Array.isArray(obj?.template) &&
+      obj.template.length &&
+      obj.template.find((tmpl: any) => tmpl.output === localKey)
+    );
+  }
+
   public parseObject(
     obj: object,
     type: Node.ChildrenTypes = NodeType.Value,
@@ -120,7 +135,13 @@ export class Parser {
 
       const objEntries = Array.isArray(localObj)
         ? localObj.map((v, i) => [i, v])
-        : Object.entries(localObj);
+        : [
+            ...Object.entries(localObj),
+            ...Object.getOwnPropertySymbols(localObj).map((s) => [
+              s,
+              (localObj as any)[s],
+            ]),
+          ];
 
       const defaultValue: NestedObj = {
         children: [],
@@ -166,6 +187,13 @@ export class Parser {
                 template
               );
 
+              if (templateAST?.type === NodeType.MultiNode) {
+                templateAST.values.forEach((v) => {
+                  // eslint-disable-next-line no-param-reassign
+                  v.parent = templateAST;
+                });
+              }
+
               if (templateAST) {
                 return {
                   path: [...path, template.output],
@@ -193,6 +221,26 @@ export class Parser {
             NodeType.Switch
           );
 
+          if (
+            localSwitch &&
+            localSwitch.type === NodeType.Value &&
+            localSwitch.children?.length === 1 &&
+            localSwitch.value === undefined
+          ) {
+            const firstChild = localSwitch.children[0];
+
+            return {
+              ...rest,
+              children: [
+                ...children,
+                {
+                  path: [...path, localKey, ...firstChild.path],
+                  value: firstChild.value,
+                },
+              ],
+            };
+          }
+
           if (localSwitch) {
             return {
               ...rest,
@@ -216,7 +264,7 @@ export class Parser {
             const multiNode = this.hooks.onCreateASTNode.call(
               {
                 type: NodeType.MultiNode,
-                override: true,
+                override: !this.hasTemplateValues(localObj, localKey),
                 values: childValues,
               },
               localValue
@@ -249,7 +297,7 @@ export class Parser {
           if (determineNodeType === NodeType.Applicability) {
             const parsedNode = this.hooks.parseNode.call(
               localValue,
-              type,
+              NodeType.Value,
               options,
               determineNodeType
             );

package/src/view/plugins/applicability.ts

@@ -16,7 +16,7 @@ export default class ApplicabilityPlugin implements ViewPlugin {
         if (node?.type === NodeType.Applicability) {
           const isApplicable = options.evaluate(node.expression);
 
-          if (!isApplicable) {
+          if (isApplicable === false) {
             return null;
           }
 

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

@@ -87,15 +87,19 @@ export function resolveAllRefs(
 }
 
 /** Traverse up the node tree finding the first available 'path' */
-const findBasePath = (node: Node.Node): Node.PathSegment[] => {
+const findBasePath = (
+  node: Node.Node,
+  resolver: Resolver
+): Node.PathSegment[] => {
   const parentNode = node.parent;
   if (!parentNode) {
     return [];
   }
 
   if ('children' in parentNode) {
+    const original = resolver.getSourceNode(node);
     return (
-      parentNode.children?.find((child) => child.value === node)?.path ?? []
+      parentNode.children?.find((child) => child.value === original)?.path ?? []
     );
   }
 
@@ -103,11 +107,17 @@ const findBasePath = (node: Node.Node): Node.PathSegment[] => {
     return [];
   }
 
-  return findBasePath(parentNode);
+  return findBasePath(parentNode, resolver);
 };
 
 /** A plugin that resolves all string references for each node */
 export default class StringResolverPlugin implements ViewPlugin {
+  private propertiesToSkipCache: Map<string, Set<string>>;
+
+  constructor() {
+    this.propertiesToSkipCache = new Map();
+  }
+
   applyResolver(resolver: Resolver) {
     resolver.hooks.resolve.tap('string-resolver', (value, node, options) => {
       if (node.type === NodeType.Empty || node.type === NodeType.Unknown) {
@@ -120,13 +130,29 @@ export default class StringResolverPlugin implements ViewPlugin {
         node.type === NodeType.View
       ) {
         /** Use specified properties to skip during string resolution, or default */
-        const propsToSkip = new Set<string>(
-          node.plugins?.stringResolver?.propertiesToSkip
-            ? node.plugins?.stringResolver?.propertiesToSkip
-            : []
-        );
+        let propsToSkip: Set<string>;
+        if (node.type === NodeType.Asset || node.type === NodeType.View) {
+          propsToSkip = new Set(
+            node.plugins?.stringResolver?.propertiesToSkip ?? ['exp']
+          );
+          if (node.value?.id) {
+            this.propertiesToSkipCache.set(node.value.id, propsToSkip);
+          }
+        } else if (
+          node.parent?.type === NodeType.MultiNode &&
+          (node.parent?.parent?.type === NodeType.Asset ||
+            node.parent?.parent?.type === NodeType.View) &&
+          node.parent.parent.value?.id &&
+          this.propertiesToSkipCache.has(node.parent.parent.value.id)
+        ) {
+          propsToSkip = this.propertiesToSkipCache.get(
+            node.parent.parent.value.id
+          ) as Set<string>;
+        } else {
+          propsToSkip = new Set(['exp']);
+        }
 
-        const nodePath = findBasePath(node);
+        const nodePath = findBasePath(node, resolver);
 
         /** If the path includes something that is supposed to be skipped, this node should be skipped too. */
         if (

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

@@ -95,16 +95,11 @@ export default class TemplatePlugin implements ViewPlugin {
     });
 
     const result: Node.MultiNode = {
-      parent: node.parent,
       type: NodeType.MultiNode,
+      override: false,
       values,
     };
 
-    result.values.forEach((innerNode) => {
-      // eslint-disable-next-line no-param-reassign
-      innerNode.parent = result;
-    });
-
     return result;
   }