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

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 {