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

package/src/controllers/validation/controller.ts

@@ -12,6 +12,7 @@ import type {
   ValidationProvider,
   ValidationResponse,
   WarningValidationResponse,
+  StrongOrWeakBinding,
 } from '../../validator';
 import { ValidationMiddleware, ValidatorRegistry } from '../../validator';
 import type { Logger } from '../../logger';
@@ -326,24 +327,33 @@ export class ValidationController implements BindingTracker {
           const strongValidation = this.getValidationForBinding(binding);
 
           // return validation issues directly on bindings first
-          if (strongValidation?.get()) return strongValidation.get();
+          if (strongValidation?.get()?.severity === 'error') {
+            return strongValidation.get();
+          }
 
           // if none, check to see any validations this binding may be a weak ref of and return
-          const newInvalidBindings: Set<BindingInstance> = new Set();
-          for (const [, weakValidation] of Array.from(this.validations)) {
+          const newInvalidBindings: Set<StrongOrWeakBinding> = new Set();
+          this.validations.forEach((weakValidation, strongBinding) => {
             if (
               caresAboutDataChanges(
                 new Set([binding]),
                 weakValidation.weakBindings
               ) &&
-              weakValidation?.get()
+              weakValidation?.get()?.severity === 'error'
             ) {
-              weakValidation?.weakBindings.forEach(
-                newInvalidBindings.add,
-                newInvalidBindings
-              );
+              weakValidation?.weakBindings.forEach((weakBinding) => {
+                weakBinding === strongBinding
+                  ? newInvalidBindings.add({
+                      binding: weakBinding,
+                      isStrong: true,
+                    })
+                  : newInvalidBindings.add({
+                      binding: weakBinding,
+                      isStrong: false,
+                    });
+              });
             }
-          }
+          });
 
           if (newInvalidBindings.size > 0) {
             return newInvalidBindings;
@@ -376,7 +386,10 @@ export class ValidationController implements BindingTracker {
           });
 
           if (originalValue !== withoutDefault) {
-            this.options.model.set([[binding, originalValue]]);
+            // Don't trigger updates when setting the default value
+            this.options.model.set([[binding, originalValue]], {
+              silent: true,
+            });
           }
 
           this.updateValidationsForBinding(
@@ -452,7 +465,7 @@ export class ValidationController implements BindingTracker {
             const response = this.validationRunner(
               validationObj,
               context,
-              binding
+              vBinding
             );
             return response ? { message: response.message } : undefined;
           });
@@ -582,7 +595,7 @@ export class ValidationController implements BindingTracker {
 
     const validations = new Map<BindingInstance, ValidationResponse>();
 
-    for (const b of this.getBindings()) {
+    this.getBindings().forEach((b) => {
       const invalid = this.getValidationForBinding(b)?.get();
 
       if (invalid) {
@@ -594,7 +607,7 @@ export class ValidationController implements BindingTracker {
 
         validations.set(b, invalid);
       }
-    }
+    });
 
     return {
       canTransition: validations.size === 0,

package/src/data/model.ts

@@ -41,6 +41,11 @@ export interface DataModelOptions {
    */
   ignoreDefaultValue?: boolean;
 
+  /**
+   * A flag to indicate that this update should happen silently
+   */
+  silent?: boolean;
+
   /** Other context associated with this request */
   context?: {
     /** The data model to use when getting other data from the context of this request */

package/src/expressions/evaluator.ts

@@ -1,6 +1,7 @@
 import { SyncWaterfallHook, SyncBailHook } from 'tapable-ts';
 import parse from './parser';
 import * as DEFAULT_EXPRESSION_HANDLERS from './evaluator-functions';
+import { isExpressionNode } from './types';
 import type {
   ExpressionNode,
   BinaryOperator,
@@ -9,7 +10,6 @@ import type {
   ExpressionContext,
   ExpressionHandler,
 } from './types';
-import { isExpressionNode } from '.';
 
 /** a && b -- but handles short cutting if the first value is false */
 const andandOperator: BinaryOperator = (ctx, a, b) => {

package/src/expressions/parser.ts

@@ -2,7 +2,7 @@
 /**
  * An expression to AST parser based on JSEP: http://jsep.from.so/
  */
-import type { ExpressionNode, ExpressionNodeType } from './types';
+import type { ExpressionNode, ExpressionNodeType, NodeLocation } from './types';
 import { ExpNodeOpaqueIdentifier } from './types';
 
 const PERIOD_CODE = 46; // '.'
@@ -80,6 +80,18 @@ function throwError(message: string, index: number) {
   throw err;
 }
 
+/** Create a new location marker that spans both nodes */
+function createSpanningLocation(start?: NodeLocation, end?: NodeLocation) {
+  if (!start || !end) {
+    return;
+  }
+
+  return {
+    start: start.start,
+    end: end.end,
+  };
+}
+
 /** Get return the longest key length of any object */
 function getMaxKeyLen(obj: object): number {
   let maxLen = 0;
@@ -121,7 +133,8 @@ function binaryPrecedence(opVal: string): number {
 function createBinaryExpression(
   operator: string | boolean,
   left: string,
-  right: string
+  right: string,
+  location?: NodeLocation
 ) {
   let type: ExpressionNodeType;
 
@@ -146,6 +159,7 @@ function createBinaryExpression(
     operator,
     left,
     right,
+    location,
   };
 }
 
@@ -190,6 +204,18 @@ export default function parseExpression(expr: string): ExpressionNode {
 
   let index = 0;
 
+  /** Create a location object  */
+  const getLocation = (startChar: number) => {
+    return {
+      start: {
+        character: startChar,
+      },
+      end: {
+        character: index,
+      },
+    };
+  };
+
   /** Grab the char at the index from the expression */
   function exprI(i: number) {
     return charAtFunc.call(expr, i);
@@ -217,13 +243,14 @@ export default function parseExpression(expr: string): ExpressionNode {
     let key;
     let value;
     let chCode;
+    const startCharIndex = index;
+
     // get rid of OCURL_CODE
     ++index;
 
     while (index < length) {
       gobbleSpaces();
       chCode = exprICode(index);
-
       // check for end
       if (chCode === CCURL_CODE) {
         // if we are at the end but a key was defined
@@ -244,7 +271,6 @@ export default function parseExpression(expr: string): ExpressionNode {
         key = gobbleStringLiteral();
         // remove spaces
         gobbleSpaces();
-
         // remove colon
         if (exprICode(index) === COLON_CODE) {
           index++;
@@ -258,7 +284,6 @@ export default function parseExpression(expr: string): ExpressionNode {
         attributes.push({ key, value });
         gobbleSpaces();
         chCode = exprICode(index);
-
         if (chCode === COMMA_CODE) {
           index++;
         } else if (chCode !== CCURL_CODE) {
@@ -282,6 +307,7 @@ export default function parseExpression(expr: string): ExpressionNode {
       __id: ExpNodeOpaqueIdentifier,
       type: 'Object',
       attributes,
+      location: getLocation(startCharIndex),
     };
   }
 
@@ -290,7 +316,6 @@ export default function parseExpression(expr: string): ExpressionNode {
    */
   function gobbleSpaces() {
     let ch = exprICode(index);
-
     // Space or tab
     while (ch === 32 || ch === 9) {
       ch = exprICode(++index);
@@ -303,6 +328,7 @@ export default function parseExpression(expr: string): ExpressionNode {
   function gobbleExpression(): ExpressionNode {
     const test = gobbleBinaryExpression();
     gobbleSpaces();
+    const startCharIndex = index;
 
     if (index < length && exprICode(index) === QUMARK_CODE) {
       // Ternary expression: test ? consequent : alternate
@@ -329,6 +355,7 @@ export default function parseExpression(expr: string): ExpressionNode {
           test,
           consequent,
           alternate,
+          location: getLocation(startCharIndex),
         };
       }
 
@@ -353,7 +380,6 @@ export default function parseExpression(expr: string): ExpressionNode {
     while (tcLen > 0) {
       if (Object.prototype.hasOwnProperty.call(binaryOps, toCheck)) {
         index += tcLen;
-
         return toCheck;
       }
 
@@ -395,7 +421,6 @@ export default function parseExpression(expr: string): ExpressionNode {
 
     // Properly deal with precedence using [recursive descent](http://www.engr.mun.ca/~theo/Misc/exp_parsing.htm)
     biop = gobbleBinaryOp();
-
     while (biop) {
       prec = binaryPrecedence(biop);
 
@@ -410,7 +435,12 @@ export default function parseExpression(expr: string): ExpressionNode {
         right = stack.pop();
         biop = stack.pop().value;
         left = stack.pop();
-        node = createBinaryExpression(biop, left, right);
+        node = createBinaryExpression(
+          biop,
+          left,
+          right,
+          createSpanningLocation(left.location, right.location)
+        );
         stack.push(node);
       }
 
@@ -428,7 +458,12 @@ export default function parseExpression(expr: string): ExpressionNode {
     node = stack[i];
 
     while (i > 1) {
-      node = createBinaryExpression(stack[i - 1].value, stack[i - 2], node);
+      node = createBinaryExpression(
+        stack[i - 1].value,
+        stack[i - 2],
+        node,
+        createSpanningLocation(stack[i - 2].location, node.location)
+      );
       i -= 2;
     }
 
@@ -442,6 +477,7 @@ export default function parseExpression(expr: string): ExpressionNode {
   function gobbleToken(): any {
     gobbleSpaces();
     const ch = exprICode(index);
+    const startCharIndex = index;
 
     if (isDecimalDigit(ch) || ch === PERIOD_CODE) {
       // Char code 46 is a dot `.` which can start off a numeric literal
@@ -478,13 +514,13 @@ export default function parseExpression(expr: string): ExpressionNode {
     while (tcLen > 0) {
       if (Object.prototype.hasOwnProperty.call(unaryOps, toCheck)) {
         index += tcLen;
-
         return {
           __id: ExpNodeOpaqueIdentifier,
           type: 'UnaryExpression',
           operator: toCheck,
           argument: gobbleToken(),
           prefix: true,
+          location: getLocation(startCharIndex),
         };
       }
 
@@ -500,6 +536,7 @@ export default function parseExpression(expr: string): ExpressionNode {
    */
   function gobbleNumericLiteral() {
     let num = '';
+    const startCharIndex = index;
 
     while (isDecimalDigit(exprICode(index))) {
       num += exprI(index++);
@@ -515,7 +552,6 @@ export default function parseExpression(expr: string): ExpressionNode {
     }
 
     let ch = exprI(index);
-
     if (ch === 'e' || ch === 'E') {
       // Exponent marker
       num += exprI(index++);
@@ -537,7 +573,6 @@ export default function parseExpression(expr: string): ExpressionNode {
     }
 
     const chCode = exprICode(index);
-
     // Check to make sure this isn't a variable name that start with a number (123abc)
     if (isIdentifierStart(chCode)) {
       throwError(
@@ -553,6 +588,7 @@ export default function parseExpression(expr: string): ExpressionNode {
       type: 'Literal',
       value: parseFloat(num),
       raw: num,
+      location: getLocation(startCharIndex),
     };
   }
 
@@ -564,6 +600,7 @@ export default function parseExpression(expr: string): ExpressionNode {
     const quote = exprI(index++);
     let str = '';
     let closed = false;
+    const startCharIndex = index;
 
     while (index < length) {
       let ch = exprI(index++);
@@ -613,6 +650,7 @@ export default function parseExpression(expr: string): ExpressionNode {
       type: 'Literal',
       value: str,
       raw: `${quote}${str}${quote}`,
+      location: getLocation(startCharIndex),
     };
   }
 
@@ -624,9 +662,9 @@ export default function parseExpression(expr: string): ExpressionNode {
     let str = '';
     let closed = false;
     let openBraceCount = 1;
+    const startCharIndex = index;
 
     index += 2; // Skip the {{
-
     while (index < length) {
       const ch = exprI(index++);
 
@@ -657,6 +695,7 @@ export default function parseExpression(expr: string): ExpressionNode {
       __id: ExpNodeOpaqueIdentifier,
       type: 'ModelRef',
       ref: str,
+      location: getLocation(startCharIndex),
     };
   }
 
@@ -678,7 +717,6 @@ export default function parseExpression(expr: string): ExpressionNode {
 
     while (index < length) {
       ch = exprICode(index);
-
       if (isIdentifierPart(ch)) {
         index++;
       } else {
@@ -694,6 +732,7 @@ export default function parseExpression(expr: string): ExpressionNode {
         type: 'Literal',
         value: (literals as any)[identifier],
         raw: identifier,
+        location: getLocation(start),
       };
     }
 
@@ -701,6 +740,7 @@ export default function parseExpression(expr: string): ExpressionNode {
       return {
         __id: ExpNodeOpaqueIdentifier,
         type: 'ThisExpression',
+        location: getLocation(start),
       };
     }
 
@@ -708,6 +748,7 @@ export default function parseExpression(expr: string): ExpressionNode {
       __id: ExpNodeOpaqueIdentifier,
       type: 'Identifier',
       name: identifier,
+      location: getLocation(start),
     };
   }
 
@@ -761,7 +802,7 @@ export default function parseExpression(expr: string): ExpressionNode {
     let charIndex = exprICode(index);
     let node: any =
       charIndex === OPAREN_CODE ? gobbleGroup() : gobbleIdentifier();
-
+    const startCharIndex = index;
     gobbleSpaces();
     charIndex = exprICode(index);
 
@@ -781,6 +822,7 @@ export default function parseExpression(expr: string): ExpressionNode {
           computed: false,
           object: node,
           property: gobbleIdentifier(),
+          location: getLocation(startCharIndex),
         };
       } else if (charIndex === OBRACK_CODE) {
         node = {
@@ -789,6 +831,7 @@ export default function parseExpression(expr: string): ExpressionNode {
           computed: true,
           object: node,
           property: gobbleExpression(),
+          location: getLocation(startCharIndex),
         };
 
         gobbleSpaces();
@@ -806,6 +849,7 @@ export default function parseExpression(expr: string): ExpressionNode {
           type: 'CallExpression',
           args: gobbleArguments(CPAREN_CODE),
           callTarget: node,
+          location: getLocation(startCharIndex),
         };
       }
 
@@ -817,7 +861,7 @@ export default function parseExpression(expr: string): ExpressionNode {
   }
 
   /**
-   * Responsible for parsing a group within parentheses `()`
+   * Responsible for parsing a group of things within parentheses `()`
    * This function assumes that it needs to gobble the opening parenthesis
    * and then tries to gobble everything within that parenthesis, assuming
    * that the next thing it should see is the close parenthesis. If not,
@@ -830,7 +874,6 @@ export default function parseExpression(expr: string): ExpressionNode {
 
     if (exprICode(index) === CPAREN_CODE) {
       index++;
-
       return node;
     }
 
@@ -843,12 +886,14 @@ export default function parseExpression(expr: string): ExpressionNode {
    * and then tries to gobble the expressions as arguments.
    */
   function gobbleArray() {
+    const startCharIndex = index;
     index++;
 
     return {
       __id: ExpNodeOpaqueIdentifier,
       type: 'ArrayExpression',
       elements: gobbleArguments(CBRACK_CODE),
+      location: getLocation(startCharIndex),
     };
   }
 
@@ -885,5 +930,6 @@ export default function parseExpression(expr: string): ExpressionNode {
     __id: ExpNodeOpaqueIdentifier,
     type: 'Compound',
     body: nodes,
+    location: getLocation(0),
   };
 }

package/src/expressions/types.ts

@@ -56,12 +56,31 @@ export function isExpressionNode(x: any): x is ExpressionNode {
   return typeof x === 'object' && x.__id === ExpNodeOpaqueIdentifier;
 }
 
+export interface NodePosition {
+  /** The character location */
+  character: number;
+}
+
+export interface NodeLocation {
+  // We only care about the character offset, not the line/column for now
+  // But making these objects allows us to add more (like line number) later
+
+  /** The start of the node */
+  start: NodePosition;
+
+  /** The end of the node */
+  end: NodePosition;
+}
+
 export interface BaseNode<T> {
   /** The thing to discriminate the AST type on */
   type: T;
 
   /** How to tell this apart from other objects */
   __id: typeof ExpNodeOpaqueIdentifier;
+
+  /** The location of the node in the source expression string */
+  location?: NodeLocation;
 }
 
 /** A helper interface for nodes that container left and right children */
@@ -88,13 +107,9 @@ export interface BinaryNode
   operator: string;
 }
 
-export interface LogicalNode extends BaseNode<'LogicalExpression'> {
-  /** The left hand side of the equation */
-  left: any;
-
-  /** The right hand side of the equation */
-  right: any;
-
+export interface LogicalNode
+  extends BaseNode<'LogicalExpression'>,
+    DirectionalNode {
   /** The logical operation to perform on the nodes */
   operator: string;
 }
@@ -104,7 +119,7 @@ export interface UnaryNode extends BaseNode<'UnaryExpression'> {
   operator: string;
 
   /** The single argument that the operation should be performed on */
-  argument: any;
+  argument: ExpressionNode;
 }
 
 export type ThisNode = BaseNode<'ThisExpression'>;
@@ -118,10 +133,10 @@ export interface ObjectNode extends BaseNode<'Object'> {
   /**  */
   attributes: Array<{
     /** The property name of the object */
-    key: any;
+    key: ExpressionNode;
 
     /** the associated value */
-    value: any;
+    value: ExpressionNode;
   }>;
 }
 
@@ -155,7 +170,7 @@ export interface CompoundNode extends BaseNode<'Compound'> {
 
 export interface CallExpressionNode extends BaseNode<'CallExpression'> {
   /** The arguments to the function */
-  args: any[];
+  args: ExpressionNode[];
 
   /** The function name */
   callTarget: IdentifierNode;
@@ -163,7 +178,7 @@ export interface CallExpressionNode extends BaseNode<'CallExpression'> {
 
 export interface ArrayExpressionNode extends BaseNode<'ArrayExpression'> {
   /** The items in an array */
-  elements: any[];
+  elements: ExpressionNode[];
 }
 
 export interface IdentifierNode extends BaseNode<'Identifier'> {

package/src/expressions/utils.ts

@@ -1,4 +1,9 @@
-import type { ExpressionHandler } from './types';
+import type {
+  ExpressionHandler,
+  ExpressionNode,
+  NodeLocation,
+  NodePosition,
+} from './types';
 
 /** Generates a function by removing the first context argument */
 export function withoutContext<T extends unknown[], Return>(
@@ -6,3 +11,121 @@ export function withoutContext<T extends unknown[], Return>(
 ): ExpressionHandler<T, Return> {
   return (_context, ...args) => fn(...args);
 }
+
+/** Checks if the location includes the target position  */
+function isInRange(position: NodePosition, location: NodeLocation) {
+  return (
+    position.character >= location.start.character &&
+    position.character <= location.end.character
+  );
+}
+
+/** Get the node in the expression that's closest to the desired position */
+export function findClosestNodeAtPosition(
+  node: ExpressionNode,
+  position: NodePosition
+): ExpressionNode | undefined {
+  // This is just mapping recursively over nodes in the tree
+
+  // eslint-disable-next-line default-case
+  switch (node.type) {
+    case 'Modification':
+    case 'Assignment':
+    case 'LogicalExpression':
+    case 'BinaryExpression': {
+      const check =
+        findClosestNodeAtPosition(node.left, position) ??
+        findClosestNodeAtPosition(node.right, position);
+      if (check) {
+        return check;
+      }
+
+      break;
+    }
+
+    case 'UnaryExpression': {
+      const checkArg = findClosestNodeAtPosition(node.argument, position);
+      if (checkArg) {
+        return checkArg;
+      }
+
+      break;
+    }
+
+    case 'MemberExpression': {
+      const checkObject =
+        findClosestNodeAtPosition(node.object, position) ??
+        findClosestNodeAtPosition(node.property, position);
+      if (checkObject) {
+        return checkObject;
+      }
+
+      break;
+    }
+
+    case 'ConditionalExpression': {
+      const checkObject =
+        findClosestNodeAtPosition(node.test, position) ??
+        findClosestNodeAtPosition(node.consequent, position) ??
+        findClosestNodeAtPosition(node.alternate, position);
+      if (checkObject) {
+        return checkObject;
+      }
+
+      break;
+    }
+
+    case 'ArrayExpression':
+    case 'Compound': {
+      const elements =
+        node.type === 'ArrayExpression' ? node.elements : node.body;
+
+      const anyElements = elements.find((e) =>
+        findClosestNodeAtPosition(e, position)
+      );
+
+      if (anyElements) {
+        return anyElements;
+      }
+
+      break;
+    }
+
+    case 'Object': {
+      const checkObject = node.attributes.reduce<ExpressionNode | undefined>(
+        (found, next) => {
+          return (
+            found ??
+            findClosestNodeAtPosition(next.key, position) ??
+            findClosestNodeAtPosition(next.value, position)
+          );
+        },
+        undefined
+      );
+
+      if (checkObject) {
+        return checkObject;
+      }
+
+      break;
+    }
+
+    case 'CallExpression': {
+      const anyArgs =
+        node.args.find((arg) => {
+          return findClosestNodeAtPosition(arg, position);
+        }) ?? findClosestNodeAtPosition(node.callTarget, position);
+
+      if (anyArgs) {
+        return anyArgs;
+      }
+
+      break;
+    }
+  }
+
+  // Lastly check for yourself
+  if (node.location && isInRange(position, node.location)) {
+    return node;
+  }
+}