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

package/src/expressions/parser.ts

@@ -2,8 +2,13 @@
 /**
  * An expression to AST parser based on JSEP: http://jsep.from.so/
  */
-import type { ExpressionNode, ExpressionNodeType, NodeLocation } from './types';
-import { ExpNodeOpaqueIdentifier } from './types';
+import type {
+  ErrorWithLocation,
+  ExpressionNode,
+  ExpressionNodeType,
+  NodeLocation,
+} from "./types";
+import { ExpNodeOpaqueIdentifier } from "./types";
 
 const PERIOD_CODE = 46; // '.'
 const COMMA_CODE = 44; // ','
@@ -27,51 +32,43 @@ const t = true;
 
 // Use a quickly-accessible map to store all of the unary operators
 // Values are set to `true` (it really doesn't matter)
-const unaryOps = { '-': t, '!': t, '~': t, '+': t };
+const unaryOps = { "-": t, "!": t, "~": t, "+": t };
 
 // Also use a map for the binary operations but set their values to their
 // binary precedence for quick reference:
 // see [Operator precedence](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)
 const binaryOps: Record<string, number> = {
-  '=': 3,
-  '+=': 3,
-  '-=': 3,
-  '&=': 3,
-  '|=': 3,
+  "=": 3,
+  "+=": 3,
+  "-=": 3,
+  "&=": 3,
+  "|=": 3,
   // Conditional: 4,
-  '||': 5,
-  '&&': 6,
-  '|': 7,
-  '^': 8,
-  '&': 9,
-  '==': 10,
-  '!=': 10,
-  '===': 10,
-  '!==': 10,
-  '<': 11,
-  '>': 11,
-  '<=': 11,
-  '>=': 11,
-  '<<': 12,
-  '>>': 12,
-  '>>>': 12,
-  '+': 13,
-  '-': 13,
-  '*': 14,
-  '/': 14,
-  '%': 14,
+  "||": 5,
+  "&&": 6,
+  "|": 7,
+  "^": 8,
+  "&": 9,
+  "==": 10,
+  "!=": 10,
+  "===": 10,
+  "!==": 10,
+  "<": 11,
+  ">": 11,
+  "<=": 11,
+  ">=": 11,
+  "<<": 12,
+  ">>": 12,
+  ">>>": 12,
+  "+": 13,
+  "-": 13,
+  "*": 14,
+  "/": 14,
+  "%": 14,
 };
 
-interface ErrorWithLocation extends Error {
-  /** The place in the string where the error occurs */
-  index: number;
-
-  /** a helpful description */
-  description: string;
-}
-
 /** Wrap the message and index in an error and throw it */
-function throwError(message: string, index: number) {
+function throwError(message: string, index: number): ErrorWithLocation {
   const err = new Error(`${message} at character ${index}`);
 
   (err as ErrorWithLocation).index = index;
@@ -119,7 +116,7 @@ const literals = {
 } as const;
 
 // Except for `this`, which is special. This could be changed to something like `'self'` as well
-const thisStr = 'this';
+const thisStr = "this";
 
 /** Returns the precedence of a binary operator or `0` if it isn't a binary operator */
 function binaryPrecedence(opVal: string): number {
@@ -134,23 +131,23 @@ function createBinaryExpression(
   operator: string | boolean,
   left: string,
   right: string,
-  location?: NodeLocation
+  location?: NodeLocation,
 ) {
   let type: ExpressionNodeType;
 
-  if (operator === '||' || operator === '&&') {
-    type = 'LogicalExpression';
-  } else if (operator === '=') {
-    type = 'Assignment';
+  if (operator === "||" || operator === "&&") {
+    type = "LogicalExpression";
+  } else if (operator === "=") {
+    type = "Assignment";
   } else if (
-    operator === '+=' ||
-    operator === '-=' ||
-    operator === '&=' ||
-    operator === '|='
+    operator === "+=" ||
+    operator === "-=" ||
+    operator === "&=" ||
+    operator === "|="
   ) {
-    type = 'Modification';
+    type = "Modification";
   } else {
-    type = 'BinaryExpression';
+    type = "BinaryExpression";
   }
 
   return {
@@ -200,7 +197,7 @@ export function parseExpression(
   options?: {
     /** If true (the default), will throw on invalid expressions */
     strict?: boolean;
-  }
+  },
 ): ExpressionNode {
   const strictMode = options?.strict ?? true;
 
@@ -263,7 +260,7 @@ export function parseExpression(
       if (chCode === CCURL_CODE) {
         // if we are at the end but a key was defined
         if (key) {
-          throwError('A key was defined but a value was not', index);
+          throwError("A key was defined but a value was not", index);
         }
 
         index++;
@@ -272,7 +269,7 @@ export function parseExpression(
       } else if (shouldDefineKey) {
         // check for key
         if (chCode !== SQUOTE_CODE && chCode !== DQUOTE_CODE) {
-          throwError('An object must start wtih a key', index);
+          throwError("An object must start wtih a key", index);
         }
 
         // get key
@@ -284,7 +281,7 @@ export function parseExpression(
           index++;
           shouldDefineKey = false;
         } else {
-          throwError('A colon must follow an object key', index);
+          throwError("A colon must follow an object key", index);
         }
       } else {
         value = gobbleExpression();
@@ -295,7 +292,7 @@ export function parseExpression(
         if (chCode === COMMA_CODE) {
           index++;
         } else if (chCode !== CCURL_CODE) {
-          throwError('Please add a comma to add another key', index);
+          throwError("Please add a comma to add another key", index);
         }
 
         shouldDefineKey = true;
@@ -313,7 +310,7 @@ export function parseExpression(
 
     return {
       __id: ExpNodeOpaqueIdentifier,
-      type: 'Object',
+      type: "Object",
       attributes,
       location: getLocation(startCharIndex),
     };
@@ -344,7 +341,7 @@ export function parseExpression(
       const consequent = gobbleExpression();
 
       if (!consequent) {
-        throwError('Expected expression', index);
+        throwError("Expected expression", index);
       }
 
       gobbleSpaces();
@@ -354,12 +351,12 @@ export function parseExpression(
         const alternate = gobbleExpression();
 
         if (!alternate) {
-          throwError('Expected expression', index);
+          throwError("Expected expression", index);
         }
 
         return {
           __id: ExpNodeOpaqueIdentifier,
-          type: 'ConditionalExpression',
+          type: "ConditionalExpression",
           test,
           consequent,
           alternate,
@@ -367,7 +364,7 @@ export function parseExpression(
         };
       }
 
-      throwError('Expected :', index);
+      throwError("Expected :", index);
     }
 
     return test;
@@ -447,7 +444,7 @@ export function parseExpression(
           biop,
           left,
           right,
-          createSpanningLocation(left.location, right.location)
+          createSpanningLocation(left.location, right.location),
         );
         stack.push(node);
       }
@@ -470,7 +467,7 @@ export function parseExpression(
         stack[i - 1].value,
         stack[i - 2],
         node,
-        createSpanningLocation(stack[i - 2].location, node.location)
+        createSpanningLocation(stack[i - 2].location, node.location),
       );
       i -= 2;
     }
@@ -524,7 +521,7 @@ export function parseExpression(
         index += tcLen;
         return {
           __id: ExpNodeOpaqueIdentifier,
-          type: 'UnaryExpression',
+          type: "UnaryExpression",
           operator: toCheck,
           argument: gobbleToken(),
           prefix: true,
@@ -543,7 +540,7 @@ export function parseExpression(
    * keep track of everything in the numeric literal and then calling `parseFloat` on that string
    */
   function gobbleNumericLiteral() {
-    let num = '';
+    let num = "";
     const startCharIndex = index;
 
     while (isDecimalDigit(exprICode(index))) {
@@ -560,12 +557,12 @@ export function parseExpression(
     }
 
     let ch = exprI(index);
-    if (ch === 'e' || ch === 'E') {
+    if (ch === "e" || ch === "E") {
       // Exponent marker
       num += exprI(index++);
       ch = exprI(index);
 
-      if (ch === '+' || ch === '-') {
+      if (ch === "+" || ch === "-") {
         // Exponent sign
         num += exprI(index++);
       }
@@ -585,15 +582,15 @@ export function parseExpression(
     if (isIdentifierStart(chCode)) {
       throwError(
         `Variable names cannot start with a number (${num}${exprI(index)})`,
-        index
+        index,
       );
     } else if (chCode === PERIOD_CODE) {
-      throwError('Unexpected period', index);
+      throwError("Unexpected period", index);
     }
 
     return {
       __id: ExpNodeOpaqueIdentifier,
-      type: 'Literal',
+      type: "Literal",
       value: parseFloat(num),
       raw: num,
       location: getLocation(startCharIndex),
@@ -606,7 +603,7 @@ export function parseExpression(
    */
   function gobbleStringLiteral() {
     const quote = exprI(index++);
-    let str = '';
+    let str = "";
     let closed = false;
     const startCharIndex = index;
 
@@ -618,7 +615,7 @@ export function parseExpression(
         break;
       }
 
-      if (ch !== '\\') {
+      if (ch !== "\\") {
         str += ch;
         continue;
       }
@@ -627,23 +624,23 @@ export function parseExpression(
       ch = exprI(index++);
 
       switch (ch) {
-        case 'n':
-          str += '\n';
+        case "n":
+          str += "\n";
           break;
-        case 'r':
-          str += '\r';
+        case "r":
+          str += "\r";
           break;
-        case 't':
-          str += '\t';
+        case "t":
+          str += "\t";
           break;
-        case 'b':
-          str += '\b';
+        case "b":
+          str += "\b";
           break;
-        case 'f':
-          str += '\f';
+        case "f":
+          str += "\f";
           break;
-        case 'v':
-          str += '\u000B';
+        case "v":
+          str += "\u000B";
           break;
         default:
       }
@@ -655,7 +652,7 @@ export function parseExpression(
 
     return {
       __id: ExpNodeOpaqueIdentifier,
-      type: 'Literal',
+      type: "Literal",
       value: str,
       raw: `${quote}${str}${quote}`,
       location: getLocation(startCharIndex),
@@ -667,7 +664,7 @@ export function parseExpression(
    * e.g. {{foo.bar.ref}}
    */
   function gobbleModelRef() {
-    let str = '';
+    let str = "";
     let closed = false;
     let openBraceCount = 1;
     const startCharIndex = index;
@@ -676,7 +673,7 @@ export function parseExpression(
     while (index < length) {
       const ch = exprI(index++);
 
-      if (ch === '}' && exprICode(index) === CCURL_CODE) {
+      if (ch === "}" && exprICode(index) === CCURL_CODE) {
         index++;
         openBraceCount--;
 
@@ -685,10 +682,10 @@ export function parseExpression(
           break;
         }
 
-        str += '}}';
-      } else if (ch === '{' && exprICode(index) === OCURL_CODE) {
+        str += "}}";
+      } else if (ch === "{" && exprICode(index) === OCURL_CODE) {
         openBraceCount++;
-        str += '{{';
+        str += "{{";
         index++;
       } else {
         str += ch;
@@ -701,7 +698,7 @@ export function parseExpression(
 
     return {
       __id: ExpNodeOpaqueIdentifier,
-      type: 'ModelRef',
+      type: "ModelRef",
       ref: str,
       location: getLocation(startCharIndex),
     };
@@ -737,7 +734,7 @@ export function parseExpression(
     if (Object.prototype.hasOwnProperty.call(literals, identifier)) {
       return {
         __id: ExpNodeOpaqueIdentifier,
-        type: 'Literal',
+        type: "Literal",
         value: (literals as any)[identifier],
         raw: identifier,
         location: getLocation(start),
@@ -747,14 +744,14 @@ export function parseExpression(
     if (identifier === thisStr) {
       return {
         __id: ExpNodeOpaqueIdentifier,
-        type: 'ThisExpression',
+        type: "ThisExpression",
         location: getLocation(start),
       };
     }
 
     return {
       __id: ExpNodeOpaqueIdentifier,
-      type: 'Identifier',
+      type: "Identifier",
       name: identifier,
       location: getLocation(start),
     };
@@ -790,14 +787,14 @@ export function parseExpression(
 
       node = gobbleExpression();
 
-      if (!node || node.type === 'Compound') {
-        throwError('Expected comma', index);
+      if (!node || node.type === "Compound") {
+        throwError("Expected comma", index);
       }
 
       args.push(node);
     }
 
-    if (charIndex !== termination) {
+    if (strictMode && charIndex !== termination) {
       throwError(`Expected ${String.fromCharCode(termination)}`, index);
     }
 
@@ -830,7 +827,7 @@ export function parseExpression(
 
         node = {
           __id: ExpNodeOpaqueIdentifier,
-          type: 'MemberExpression',
+          type: "MemberExpression",
           computed: false,
           object: node,
           property: gobbleIdentifier(),
@@ -839,7 +836,7 @@ export function parseExpression(
       } else if (charIndex === OBRACK_CODE) {
         node = {
           __id: ExpNodeOpaqueIdentifier,
-          type: 'MemberExpression',
+          type: "MemberExpression",
           computed: true,
           object: node,
           property: gobbleExpression(),
@@ -850,7 +847,7 @@ export function parseExpression(
         charIndex = exprICode(index);
 
         if (charIndex !== CBRACK_CODE) {
-          throwError('Unclosed [', index);
+          throwError("Unclosed [", index);
         }
 
         index++;
@@ -858,7 +855,7 @@ export function parseExpression(
         // A function call is being made; gobble all the arguments
         node = {
           __id: ExpNodeOpaqueIdentifier,
-          type: 'CallExpression',
+          type: "CallExpression",
           args: gobbleArguments(CPAREN_CODE),
           callTarget: node,
           location: getLocation(startCharIndex),
@@ -889,7 +886,7 @@ export function parseExpression(
       return node;
     }
 
-    throwError('Unclosed (', index);
+    throwError("Unclosed (", index);
   }
 
   /**
@@ -903,7 +900,7 @@ export function parseExpression(
 
     return {
       __id: ExpNodeOpaqueIdentifier,
-      type: 'ArrayExpression',
+      type: "ArrayExpression",
       elements: gobbleArguments(CBRACK_CODE),
       location: getLocation(startCharIndex),
     };
@@ -929,7 +926,7 @@ export function parseExpression(
         nodes.push(node);
         // If we weren't able to find a binary expression and are out of room, then
         // the expression passed in probably has too much
-      } else if (index < length) {
+      } else if (strictMode && index < length) {
         throwError(`Unexpected "${exprI(index)}"`, index);
       }
     }
@@ -941,7 +938,7 @@ export function parseExpression(
 
     return {
       __id: ExpNodeOpaqueIdentifier,
-      type: 'Compound',
+      type: "Compound",
       body: nodes,
       location: getLocation(0),
     };
@@ -952,7 +949,7 @@ export function parseExpression(
 
     return {
       __id: ExpNodeOpaqueIdentifier,
-      type: 'Compound',
+      type: "Compound",
       body: nodes,
       location: getLocation(0),
       error: e,

package/src/expressions/types.ts

@@ -1,5 +1,5 @@
-import type { DataModelWithParser } from '../data';
-import type { Logger } from '../logger';
+import type { DataModelWithParser } from "../data";
+import type { Logger } from "../logger";
 
 export type ExpressionObjectType = {
   /** The expression to eval */
@@ -52,16 +52,16 @@ export interface ExpressionContext {
 
 export type ExpressionHandler<
   T extends readonly unknown[] = unknown[],
-  R = void
+  R = void,
 > = ((context: ExpressionContext, ...args: T) => R) &
   Partial<OperatorProcessingOptions>;
 
-export const ExpNodeOpaqueIdentifier = Symbol('Expression Node ID');
+export const ExpNodeOpaqueIdentifier = Symbol("Expression Node ID");
 
 /** Checks if the input is an already processed Expression node */
 export function isExpressionNode(x: any): x is ExpressionNode {
   return (
-    typeof x === 'object' &&
+    typeof x === "object" &&
     x !== null &&
     !Array.isArray(x) &&
     x.__id === ExpNodeOpaqueIdentifier
@@ -110,7 +110,7 @@ export interface DirectionalNode {
   right: ExpressionNode;
 }
 
-export interface LiteralNode extends BaseNode<'Literal'> {
+export interface LiteralNode extends BaseNode<"Literal"> {
   /** A node that holds a literal value */
   value: string | number;
 
@@ -119,20 +119,20 @@ export interface LiteralNode extends BaseNode<'Literal'> {
 }
 
 export interface BinaryNode
-  extends BaseNode<'BinaryExpression'>,
+  extends BaseNode<"BinaryExpression">,
     DirectionalNode {
   /** The operation to perform on the nodes */
   operator: string;
 }
 
 export interface LogicalNode
-  extends BaseNode<'LogicalExpression'>,
+  extends BaseNode<"LogicalExpression">,
     DirectionalNode {
   /** The logical operation to perform on the nodes */
   operator: string;
 }
 
-export interface UnaryNode extends BaseNode<'UnaryExpression'> {
+export interface UnaryNode extends BaseNode<"UnaryExpression"> {
   /** The operation to perform on the node */
   operator: string;
 
@@ -140,14 +140,14 @@ export interface UnaryNode extends BaseNode<'UnaryExpression'> {
   argument: ExpressionNode;
 }
 
-export type ThisNode = BaseNode<'ThisExpression'>;
+export type ThisNode = BaseNode<"ThisExpression">;
 
-export interface ModelRefNode extends BaseNode<'ModelRef'> {
+export interface ModelRefNode extends BaseNode<"ModelRef"> {
   /** The binding that the model reference points to */
   ref: string;
 }
 
-export interface ObjectNode extends BaseNode<'Object'> {
+export interface ObjectNode extends BaseNode<"Object"> {
   /**  */
   attributes: Array<{
     /** The property name of the object */
@@ -158,7 +158,7 @@ export interface ObjectNode extends BaseNode<'Object'> {
   }>;
 }
 
-export interface MemberExpressionNode extends BaseNode<'MemberExpression'> {
+export interface MemberExpressionNode extends BaseNode<"MemberExpression"> {
   /** The object to be introspected */
   object: ExpressionNode;
 
@@ -170,7 +170,7 @@ export interface MemberExpressionNode extends BaseNode<'MemberExpression'> {
 }
 
 export interface ConditionalExpressionNode
-  extends BaseNode<'ConditionalExpression'> {
+  extends BaseNode<"ConditionalExpression"> {
   /** The test for the ternary */
   test: ExpressionNode;
 
@@ -181,12 +181,12 @@ export interface ConditionalExpressionNode
   alternate: ExpressionNode;
 }
 
-export interface CompoundNode extends BaseNode<'Compound'> {
+export interface CompoundNode extends BaseNode<"Compound"> {
   /** The contents of the compound expression */
   body: ExpressionNode[];
 }
 
-export interface CallExpressionNode extends BaseNode<'CallExpression'> {
+export interface CallExpressionNode extends BaseNode<"CallExpression"> {
   /** The arguments to the function */
   args: ExpressionNode[];
 
@@ -194,20 +194,20 @@ export interface CallExpressionNode extends BaseNode<'CallExpression'> {
   callTarget: IdentifierNode;
 }
 
-export interface ArrayExpressionNode extends BaseNode<'ArrayExpression'> {
+export interface ArrayExpressionNode extends BaseNode<"ArrayExpression"> {
   /** The items in an array */
   elements: ExpressionNode[];
 }
 
-export interface IdentifierNode extends BaseNode<'Identifier'> {
+export interface IdentifierNode extends BaseNode<"Identifier"> {
   /** The variable name */
   name: string;
 }
 
-export type AssignmentNode = BaseNode<'Assignment'> & DirectionalNode;
+export type AssignmentNode = BaseNode<"Assignment"> & DirectionalNode;
 
 export interface ModificationNode
-  extends BaseNode<'Modification'>,
+  extends BaseNode<"Modification">,
     DirectionalNode {
   /** The operator for the modification */
   operator: string;
@@ -230,4 +230,12 @@ export type ExpressionNode =
   | ModificationNode
   | ObjectNode;
 
-export type ExpressionNodeType = ExpressionNode['type'];
+export type ExpressionNodeType = ExpressionNode["type"];
+
+export interface ErrorWithLocation extends Error {
+  /** The place in the string where the error occurs */
+  index: number;
+
+  /** a helpful description */
+  description: string;
+}