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

package/src/expressions/evaluator.ts

@@ -1,9 +1,9 @@
-import { SyncWaterfallHook, SyncBailHook } from 'tapable-ts';
-import { NestedError } from 'ts-nested-error';
-import { parseExpression } from './parser';
-import * as DEFAULT_EXPRESSION_HANDLERS from './evaluator-functions';
-import { isExpressionNode } from './types';
-import { isObjectExpression } from './utils';
+import { SyncWaterfallHook, SyncBailHook } from "tapable-ts";
+import { NestedError } from "ts-nested-error";
+import { parseExpression } from "./parser";
+import * as DEFAULT_EXPRESSION_HANDLERS from "./evaluator-functions";
+import { isExpressionNode } from "./types";
+import { isObjectExpression } from "./utils";
 import type {
   ExpressionNode,
   BinaryOperator,
@@ -11,7 +11,7 @@ import type {
   ExpressionType,
   ExpressionContext,
   ExpressionHandler,
-} from './types';
+} from "./types";
 
 /** a && b -- but handles short cutting if the first value is false */
 const andandOperator: BinaryOperator = (ctx, a, b) => {
@@ -29,45 +29,45 @@ ororOperator.resolveParams = false;
 
 const DEFAULT_BINARY_OPERATORS: Record<string, BinaryOperator> = {
   // TODO: A lot of these functions used to do type coercion. Not sure if we want to keep that behavior or not.
-  '+': (a: any, b: any) => a + b,
-  '-': (a: any, b: any) => a - b,
-  '*': (a: any, b: any) => a * b,
-  '/': (a: any, b: any) => a / b,
-  '%': (a: any, b: any) => a % b,
+  "+": (a: any, b: any) => a + b,
+  "-": (a: any, b: any) => a - b,
+  "*": (a: any, b: any) => a * b,
+  "/": (a: any, b: any) => a / b,
+  "%": (a: any, b: any) => a % b,
 
   // eslint-disable-next-line
-  '==': (a: any, b: any) => a == b,
+  "==": (a: any, b: any) => a == b,
 
   // eslint-disable-next-line
-  '!=': (a: any, b: any) => a != b,
-  '>': (a: any, b: any) => a > b,
-  '>=': (a: any, b: any) => a >= b,
-  '<': (a: any, b: any) => a < b,
-  '<=': (a: any, b: any) => a <= b,
-  '&&': andandOperator,
-  '||': ororOperator,
-  '!==': (a: any, b: any) => a !== b,
-  '===': (a: any, b: any) => a === b,
+  "!=": (a: any, b: any) => a != b,
+  ">": (a: any, b: any) => a > b,
+  ">=": (a: any, b: any) => a >= b,
+  "<": (a: any, b: any) => a < b,
+  "<=": (a: any, b: any) => a <= b,
+  "&&": andandOperator,
+  "||": ororOperator,
+  "!==": (a: any, b: any) => a !== b,
+  "===": (a: any, b: any) => a === b,
 
   // eslint-disable-next-line
-  '|': (a: any, b: any) => a | b,
+  "|": (a: any, b: any) => a | b,
 
   // eslint-disable-next-line
-  '&': (a: any, b: any) => a & b,
-  '+=': (a: any, b: any) => a + b,
-  '-=': (a: any, b: any) => a - b,
+  "&": (a: any, b: any) => a & b,
+  "+=": (a: any, b: any) => a + b,
+  "-=": (a: any, b: any) => a - b,
 
   // eslint-disable-next-line
-  '&=': (a: any, b: any) => a & b,
+  "&=": (a: any, b: any) => a & b,
 
   // eslint-disable-next-line
-  '|=': (a: any, b: any) => a | b,
+  "|=": (a: any, b: any) => a | b,
 };
 
 const DEFAULT_UNARY_OPERATORS: Record<string, UnaryOperator> = {
-  '-': (a: any) => -a,
-  '+': (a: any) => Number(a),
-  '!': (a: any) => !a,
+  "-": (a: any) => -a,
+  "+": (a: any) => Number(a),
+  "!": (a: any) => !a,
 };
 
 export interface HookOptions extends ExpressionContext {
@@ -78,16 +78,19 @@ export interface HookOptions extends ExpressionContext {
    * The caller is responsible for handling the error.
    */
   throwErrors?: boolean;
+
+  /** Whether expressions should be parsed strictly or not */
+  strict?: boolean;
 }
 
 export type ExpressionEvaluatorOptions = Omit<
   HookOptions,
-  'resolveNode' | 'evaluate'
+  "resolveNode" | "evaluate"
 >;
 
 export type ExpressionEvaluatorFunction = (
   exp: ExpressionType,
-  options?: ExpressionEvaluatorOptions
+  options?: ExpressionEvaluatorOptions,
 ) => any;
 
 /**
@@ -120,7 +123,7 @@ export class ExpressionEvaluator {
     binary: new Map(Object.entries(DEFAULT_BINARY_OPERATORS)),
     unary: new Map(Object.entries(DEFAULT_UNARY_OPERATORS)),
     expressions: new Map<string, ExpressionHandler<any, any>>(
-      Object.entries(DEFAULT_EXPRESSION_HANDLERS)
+      Object.entries(DEFAULT_EXPRESSION_HANDLERS),
     ),
   };
 
@@ -136,13 +139,13 @@ export class ExpressionEvaluator {
         this._execAST(node, this.defaultHookOptions),
     };
 
-    this.hooks.resolve.tap('ExpressionEvaluator', this._resolveNode.bind(this));
+    this.hooks.resolve.tap("ExpressionEvaluator", this._resolveNode.bind(this));
     this.evaluate = this.evaluate.bind(this);
   }
 
   public evaluate(
     expr: ExpressionType,
-    options?: ExpressionEvaluatorOptions
+    options?: ExpressionEvaluatorOptions,
   ): any {
     const resolvedOpts = this.hooks.resolveOptions.call({
       ...this.defaultHookOptions,
@@ -160,8 +163,8 @@ export class ExpressionEvaluator {
 
     // Check for literals
     if (
-      typeof expression === 'number' ||
-      typeof expression === 'boolean' ||
+      typeof expression === "number" ||
+      typeof expression === "boolean" ||
       expression === undefined ||
       expression === null
     ) {
@@ -176,7 +179,7 @@ export class ExpressionEvaluator {
     if (Array.isArray(expression)) {
       return expression.reduce(
         (_nothing, exp) => this.evaluate(exp, options),
-        null
+        null,
       );
     }
 
@@ -185,7 +188,7 @@ export class ExpressionEvaluator {
 
   public addExpressionFunction<T extends readonly unknown[], R>(
     name: string,
-    handler: ExpressionHandler<T, R>
+    handler: ExpressionHandler<T, R>,
   ): void {
     this.operators.expressions.set(name, handler);
   }
@@ -211,7 +214,7 @@ export class ExpressionEvaluator {
   }
 
   private _execString(exp: string, options: HookOptions) {
-    if (exp === '') {
+    if (exp === "") {
       return exp;
     }
 
@@ -226,7 +229,8 @@ export class ExpressionEvaluator {
 
     try {
       storedAST =
-        this.expressionsCache.get(matchedExp) ?? parseExpression(matchedExp);
+        this.expressionsCache.get(matchedExp) ??
+        parseExpression(matchedExp, { strict: options.strict });
       this.expressionsCache.set(matchedExp, storedAST);
     } catch (e: any) {
       if (options.throwErrors || !this.hooks.onError.call(e)) {
@@ -250,7 +254,7 @@ export class ExpressionEvaluator {
   private _resolveNode(
     _currentValue: any,
     node: ExpressionNode,
-    options: HookOptions
+    options: HookOptions,
   ) {
     const { resolveNode, model } = options;
 
@@ -259,23 +263,23 @@ export class ExpressionEvaluator {
       evaluate: (expr) => this.evaluate(expr, options),
     };
 
-    if (node.type === 'Literal') {
+    if (node.type === "Literal") {
       return node.value;
     }
 
-    if (node.type === 'Identifier') {
+    if (node.type === "Identifier") {
       return this.vars[node.name];
     }
 
-    if (node.type === 'Compound' || node.type === 'ThisExpression') {
+    if (node.type === "Compound" || node.type === "ThisExpression") {
       throw new Error(`Expression type: ${node.type} is not supported`);
     }
 
-    if (node.type === 'BinaryExpression' || node.type === 'LogicalExpression') {
+    if (node.type === "BinaryExpression" || node.type === "LogicalExpression") {
       const operator = this.operators.binary.get(node.operator);
 
       if (operator) {
-        if ('resolveParams' in operator) {
+        if ("resolveParams" in operator) {
           if (operator.resolveParams === false) {
             return operator(expressionContext, node.left, node.right);
           }
@@ -283,7 +287,7 @@ export class ExpressionEvaluator {
           return operator(
             expressionContext,
             resolveNode(node.left),
-            resolveNode(node.right)
+            resolveNode(node.right),
           );
         }
 
@@ -293,16 +297,16 @@ export class ExpressionEvaluator {
       return;
     }
 
-    if (node.type === 'UnaryExpression') {
+    if (node.type === "UnaryExpression") {
       const operator = this.operators.unary.get(node.operator);
 
       if (operator) {
-        if ('resolveParams' in operator) {
+        if ("resolveParams" in operator) {
           return operator(
             expressionContext,
             operator.resolveParams === false
               ? node.argument
-              : resolveNode(node.argument)
+              : resolveNode(node.argument),
           );
         }
 
@@ -312,7 +316,7 @@ export class ExpressionEvaluator {
       return;
     }
 
-    if (node.type === 'Object') {
+    if (node.type === "Object") {
       const { attributes } = node;
       const resolvedAttributes: any = {};
 
@@ -325,7 +329,7 @@ export class ExpressionEvaluator {
       return resolvedAttributes;
     }
 
-    if (node.type === 'CallExpression') {
+    if (node.type === "CallExpression") {
       const expressionName = node.callTarget.name;
 
       const operator = this.operators.expressions.get(expressionName);
@@ -334,7 +338,7 @@ export class ExpressionEvaluator {
         throw new Error(`Unknown expression function: ${expressionName}`);
       }
 
-      if ('resolveParams' in operator && operator.resolveParams === false) {
+      if ("resolveParams" in operator && operator.resolveParams === false) {
         return operator(expressionContext, ...node.args);
       }
 
@@ -343,26 +347,26 @@ export class ExpressionEvaluator {
       return operator(expressionContext, ...args);
     }
 
-    if (node.type === 'ModelRef') {
+    if (node.type === "ModelRef") {
       return model.get(node.ref, { context: { model: options.model } });
     }
 
-    if (node.type === 'MemberExpression') {
+    if (node.type === "MemberExpression") {
       const obj = resolveNode(node.object);
       const prop = resolveNode(node.property);
 
       return obj[prop];
     }
 
-    if (node.type === 'Assignment') {
-      if (node.left.type === 'ModelRef') {
+    if (node.type === "Assignment") {
+      if (node.left.type === "ModelRef") {
         const value = resolveNode(node.right);
         model.set([[node.left.ref, value]]);
 
         return value;
       }
 
-      if (node.left.type === 'Identifier') {
+      if (node.left.type === "Identifier") {
         const value = resolveNode(node.right);
         this.vars[node.left.name] = value;
         return value;
@@ -371,39 +375,39 @@ export class ExpressionEvaluator {
       return;
     }
 
-    if (node.type === 'ConditionalExpression') {
+    if (node.type === "ConditionalExpression") {
       const result = resolveNode(node.test) ? node.consequent : node.alternate;
 
       return resolveNode(result);
     }
 
-    if (node.type === 'ArrayExpression') {
+    if (node.type === "ArrayExpression") {
       return node.elements.map((ele) => resolveNode(ele));
     }
 
-    if (node.type === 'Modification') {
+    if (node.type === "Modification") {
       const operation = this.operators.binary.get(node.operator);
 
       if (operation) {
         let newValue;
 
-        if ('resolveParams' in operation) {
+        if ("resolveParams" in operation) {
           if (operation.resolveParams === false) {
             newValue = operation(expressionContext, node.left, node.right);
           } else {
             newValue = operation(
               expressionContext,
               resolveNode(node.left),
-              resolveNode(node.right)
+              resolveNode(node.right),
             );
           }
         } else {
           newValue = operation(resolveNode(node.left), resolveNode(node.right));
         }
 
-        if (node.left.type === 'ModelRef') {
+        if (node.left.type === "ModelRef") {
           model.set([[node.left.ref, newValue]]);
-        } else if (node.left.type === 'Identifier') {
+        } else if (node.left.type === "Identifier") {
           this.vars[node.left.name] = newValue;
         }
 

package/src/expressions/index.ts

@@ -1,4 +1,4 @@
-export * from './evaluator';
-export * from './types';
-export * from './utils';
-export * from './parser';
+export * from "./evaluator";
+export * from "./types";
+export * from "./utils";
+export * from "./parser";