@player-ui/player 0.4.0-next.8 → 0.4.0-next.9

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,7 @@ 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
@@ -37,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(
@@ -58,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> = [];
@@ -79,7 +87,8 @@ export class ValidationMiddleware implements DataModelMiddleware {
             nextTransaction.push([validation.binding, value]);
           }
         });
-      } else {
+      } else if (includedBindings.has(binding)) {
+        invalidBindings.push(binding);
         this.logger?.debug(
           `Invalid value for path: ${binding.asString()} - ${
             validations.severity
@@ -88,6 +97,8 @@ 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]) =>
@@ -97,9 +108,11 @@ export class ValidationMiddleware implements DataModelMiddleware {
       if (invalidBindings.length === 0) {
         return result;
       }
+
+      validResults = result;
     }
 
-    return invalidBindings.map((binding) => {
+    const invalidResults = invalidBindings.map((binding) => {
       return {
         binding,
         oldValue: asModel.get(binding),
@@ -107,6 +120,8 @@ export class ValidationMiddleware implements DataModelMiddleware {
         force: true,
       };
     });
+
+    return [...validResults, ...invalidResults];
   }
 
   public get(
@@ -116,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;
@@ -132,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,
@@ -172,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],
@@ -199,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,
@@ -222,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
@@ -255,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,7 +107,7 @@ 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 */
@@ -148,7 +152,7 @@ export default class StringResolverPlugin implements ViewPlugin {
           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;
   }
 

package/src/view/resolver/index.ts

@@ -1,5 +1,5 @@
 import { SyncWaterfallHook, SyncHook } from 'tapable-ts';
-import { setIn, addLast } from 'timm';
+import { setIn, addLast, clone } from 'timm';
 import dlv from 'dlv';
 import { dequal } from 'dequal';
 import type { BindingInstance, BindingLike } from '../../binding';
@@ -42,6 +42,12 @@ const withContext = (model: DataModelWithParser): DataModelWithParser => {
         ...options,
       });
     },
+    delete: (binding: BindingLike, options?: DataModelOptions): void => {
+      return model.delete(binding, {
+        context: { model },
+        ...options,
+      });
+    },
   };
 };
 
@@ -141,6 +147,7 @@ export class Resolver {
     this.hooks.beforeUpdate.call(changes);
     const resolveCache = new Map<Node.Node, Resolve.ResolvedNode>();
     this.idCache.clear();
+    const prevASTMap = new Map(this.ASTMap);
     this.ASTMap.clear();
 
     const updated = this.computeTree(
@@ -148,7 +155,9 @@ export class Resolver {
       undefined,
       changes,
       resolveCache,
-      toNodeResolveOptions(this.options)
+      toNodeResolveOptions(this.options),
+      undefined,
+      prevASTMap
     );
     this.resolveCache = resolveCache;
     this.hooks.afterUpdate.call(updated.value);
@@ -156,6 +165,10 @@ export class Resolver {
     return updated.value;
   }
 
+  public getResolveCache() {
+    return new Map(this.resolveCache);
+  }
+
   private getNodeID(node?: Node.Node): string | undefined {
     if (!node) {
       return;
@@ -206,12 +219,29 @@ export class Resolver {
     return this.resolveCache.get(node);
   }
 
+  private cloneNode(node: any) {
+    const clonedNode = clone(node);
+
+    Object.keys(clonedNode).forEach((key) => {
+      if (key === 'parent') return;
+
+      const value = clonedNode[key];
+      if (typeof value === 'object' && value !== null) {
+        clonedNode[key] = Array.isArray(value) ? [...value] : { ...value };
+      }
+    });
+
+    return clonedNode;
+  }
+
   private computeTree(
     node: Node.Node,
     parent: Node.Node | undefined,
     dataChanges: Set<BindingInstance> | undefined,
     cacheUpdate: Map<Node.Node, Resolve.ResolvedNode>,
-    options: Resolve.NodeResolveOptions
+    options: Resolve.NodeResolveOptions,
+    parentNode: Node.Node | undefined,
+    prevASTMap: Map<Node.Node, Node.Node>
   ): NodeUpdate {
     const dependencyModel = new DependencyModel(options.data.model);
 
@@ -254,43 +284,65 @@ export class Resolver {
 
       /** Recursively repopulate the AST map given some AST Node and it's resolved AST representation */
       const repopulateASTMapFromCache = (
-        resolvedAST: Node.Node,
-        AST: Node.Node
+        resolvedNode: Resolve.ResolvedNode,
+        AST: Node.Node,
+        ASTParent: Node.Node | undefined
       ) => {
+        const { node: resolvedAST } = resolvedNode;
         this.ASTMap.set(resolvedAST, AST);
+        const resolvedUpdate = {
+          ...resolvedNode,
+          updated: false,
+        };
+        cacheUpdate.set(AST, resolvedUpdate);
+
+        /** Helper function for recursing over child node */
+        const handleChildNode = (childNode: Node.Node) => {
+          // In order to get the correct results, we need to use the node references from the last update.
+          const originalChildNode = prevASTMap.get(childNode) ?? childNode;
+          const previousChildResult = this.getPreviousResult(originalChildNode);
+          if (!previousChildResult) return;
+
+          repopulateASTMapFromCache(
+            previousChildResult,
+            originalChildNode,
+            AST
+          );
+        };
+
         if ('children' in resolvedAST) {
-          resolvedAST.children?.forEach(({ value: childAST }) => {
-            const { node: childResolvedAST } =
-              this.getPreviousResult(childAST) || {};
-            if (!childResolvedAST) return;
-
-            repopulateASTMapFromCache(childResolvedAST, childAST);
-
-            if (childResolvedAST.type === NodeType.MultiNode) {
-              childResolvedAST.values.forEach((mChildAST) => {
-                const { node: mChildResolvedAST } =
-                  this.getPreviousResult(mChildAST) || {};
-                if (!mChildResolvedAST) return;
-
-                repopulateASTMapFromCache(mChildResolvedAST, mChildAST);
-              });
-            }
-          });
+          resolvedAST.children?.forEach(({ value: childAST }) =>
+            handleChildNode(childAST)
+          );
+        } else if (resolvedAST.type === NodeType.MultiNode) {
+          resolvedAST.values.forEach(handleChildNode);
         }
+
+        this.hooks.afterNodeUpdate.call(AST, ASTParent, resolvedUpdate);
       };
 
-      const resolvedAST = previousResult.node;
-      repopulateASTMapFromCache(resolvedAST, node);
+      // Point the root of the cached node to the new resolved node.
+      previousResult.node.parent = parentNode;
 
-      this.hooks.afterNodeUpdate.call(node, parent, update);
+      repopulateASTMapFromCache(previousResult, node, parent);
 
       return update;
     }
 
-    const resolvedAST = this.hooks.beforeResolve.call(node, resolveOptions) ?? {
+    // Shallow clone the node so that changes to it during the resolve steps don't impact the original.
+    // We are trusting that this becomes a deep clone once the whole node tree has been traversed.
+    const clonedNode = {
+      ...this.cloneNode(node),
+      parent: parentNode,
+    };
+    const resolvedAST = this.hooks.beforeResolve.call(
+      clonedNode,
+      resolveOptions
+    ) ?? {
       type: NodeType.Empty,
     };
 
+    resolvedAST.parent = parentNode;
     resolveOptions.node = resolvedAST;
 
     this.ASTMap.set(resolvedAST, node);
@@ -311,43 +363,25 @@ export class Resolver {
     dependencyModel.trackSubset('children');
 
     if ('children' in resolvedAST) {
-      resolvedAST.children?.forEach((child) => {
+      const newChildren = resolvedAST.children?.map((child) => {
         const computedChildTree = this.computeTree(
           child.value,
           node,
           dataChanges,
           cacheUpdate,
-          resolveOptions
+          resolveOptions,
+          resolvedAST,
+          prevASTMap
         );
-        let { updated: childUpdated, value: childValue } = computedChildTree;
-        const { node: childNode, dependencies: childTreeDeps } =
-          computedChildTree;
+        const {
+          dependencies: childTreeDeps,
+          node: childNode,
+          updated: childUpdated,
+          value: childValue,
+        } = computedChildTree;
 
         childTreeDeps.forEach((binding) => childDependencies.add(binding));
 
-        if (childNode.type === NodeType.MultiNode) {
-          childValue = [];
-          childNode.values.forEach((mValue) => {
-            const mTree = this.computeTree(
-              mValue,
-              node,
-              dataChanges,
-              cacheUpdate,
-              resolveOptions
-            );
-
-            if (mTree.value !== undefined && mTree.value !== null) {
-              childValue.push(mTree.value);
-            }
-
-            mTree.dependencies.forEach((bindingDep) =>
-              childDependencies.add(bindingDep)
-            );
-
-            childUpdated = childUpdated || mTree.updated;
-          });
-        }
-
         if (childValue) {
           if (childNode.type === NodeType.MultiNode && !childNode.override) {
             const arr = addLast(
@@ -361,7 +395,38 @@ export class Resolver {
         }
 
         updated = updated || childUpdated;
+
+        return { ...child, value: childNode };
       });
+
+      resolvedAST.children = newChildren;
+    } else if (resolvedAST.type === NodeType.MultiNode) {
+      const childValue: any = [];
+      const newValues = resolvedAST.values.map((mValue) => {
+        const mTree = this.computeTree(
+          mValue,
+          node,
+          dataChanges,
+          cacheUpdate,
+          resolveOptions,
+          resolvedAST,
+          prevASTMap
+        );
+        if (mTree.value !== undefined && mTree.value !== null) {
+          childValue.push(mTree.value);
+        }
+
+        mTree.dependencies.forEach((bindingDep) =>
+          childDependencies.add(bindingDep)
+        );
+
+        updated = updated || mTree.updated;
+
+        return mTree.node;
+      });
+
+      resolvedAST.values = newValues;
+      resolved = childValue;
     }
 
     childDependencies.forEach((bindingDep) =>

package/src/view/resolver/types.ts

@@ -13,6 +13,7 @@ import type {
   DataModelImpl,
   DataModelOptions,
 } from '../../data';
+import type { ConstantsProvider } from '../../controllers/constants';
 import type { TransitionFunction } from '../../controllers';
 import type { ExpressionEvaluator, ExpressionType } from '../../expressions';
 import type { ValidationResponse } from '../../validator';
@@ -20,30 +21,64 @@ import type { Logger } from '../../logger';
 import type { SchemaController } from '../../schema';
 import type { Node } from '../parser';
 
+export interface ValidationGetResolveOptions {
+  /**
+   * If we should ignore any non-blocking validations in the return
+   * @default true
+   */
+  ignoreNonBlocking?: boolean;
+}
+
+export interface PlayerUtils {
+  findPlugin<Plugin = unknown>(symbol: symbol): Plugin | undefined;
+}
+
 export declare namespace Resolve {
   export interface Validation {
     /** Fetch the data-type for the given binding */
     type(binding: BindingLike): Schema.DataType | undefined;
 
     /** Get all currently applicable validation errors */
-    getAll(): Map<BindingInstance, ValidationResponse> | undefined;
+    getAll(
+      options?: ValidationGetResolveOptions
+    ): Map<BindingInstance, ValidationResponse> | undefined;
 
     /** Internal Method to lookup if there is a validation for the given binding */
-    _getValidationForBinding(
-      binding: BindingLike
-    ): ValidationResponse | undefined;
+    _getValidationForBinding(binding: BindingLike):
+      | {
+          /** Get the validation for the given binding */
+          get: (
+            options?: ValidationGetResolveOptions
+          ) => ValidationResponse | undefined;
+
+          /** Get all validations for the given binding */
+          getAll: (
+            options?: ValidationGetResolveOptions
+          ) => Array<ValidationResponse>;
+        }
+      | undefined;
 
     /** Get field level error for the specific binding */
     get(
       binding: BindingLike,
       options?: {
         /** If this binding should also be tracked for validations */
-        track: boolean;
-      }
+        track?: boolean;
+      } & ValidationGetResolveOptions
     ): ValidationResponse | undefined;
 
+    getValidationsForBinding(
+      binding: BindingLike,
+      options?: {
+        /** If this binding should also be tracked for validations */
+        track?: boolean;
+      } & ValidationGetResolveOptions
+    ): Array<ValidationResponse>;
+
     /** Get errors for all children regardless of section */
-    getChildren(type: ValidationTypes.DisplayTarget): Array<ValidationResponse>;
+    getChildren(
+      type?: ValidationTypes.DisplayTarget
+    ): Array<ValidationResponse>;
 
     /** Get errors for all children solely in this section */
     getValidationsForSection(): Array<ValidationResponse>;
@@ -62,6 +97,9 @@ export declare namespace Resolve {
     /** A logger to use */
     logger?: Logger;
 
+    /** Utils for various useful operations */
+    utils?: PlayerUtils;
+
     /** An optional set of validation features */
     validation?: Validation;
 
@@ -73,6 +111,9 @@ export declare namespace Resolve {
 
     /** The hub for data invariants and metaData associated with the data model */
     schema: SchemaController;
+
+    /** The constants for messages */
+    constants?: ConstantsProvider;
   }
 
   export interface NodeDataOptions {