@jbrowse/jexl 5.0.2 → 6.0.0

package/src/grammar.ts

@@ -56,9 +56,9 @@ export interface BinaryOp {
 
 export type UnaryOpEval = (right: JexlValue) => JexlValue
 
+/** A prefix operator, which binds tighter than any binary one. */
 export interface UnaryOp {
   type: 'unaryOp'
-  precedence: number
   eval: UnaryOpEval
 }
 
@@ -82,6 +82,7 @@ export interface SimpleElement {
     | 'question'
     | 'semicolon'
     | 'arrow'
+    | 'assign'
 }
 
 export type GrammarElement = BinaryOp | UnaryOp | SimpleElement
@@ -174,6 +175,7 @@ export const getGrammar = (): Grammar => ({
     '?': { type: 'question' },
     ';': { type: 'semicolon' },
     '=>': { type: 'arrow' },
+    '=': { type: 'assign' },
     '+': {
       type: 'binaryOp',
       precedence: 30,
@@ -299,15 +301,7 @@ export const getGrammar = (): Grammar => ({
     },
     '!': {
       type: 'unaryOp',
-      precedence: Infinity,
       eval: (right) => !right
-    },
-    '=': {
-      type: 'binaryOp',
-      precedence: 2,
-      eval: (_left, _right) => {
-        throw new Error('Assignment handled specially')
-      }
     }
   },
 

package/src/operators.ts

@@ -74,20 +74,24 @@ export function pairwise(
   return out
 }
 
-const patterns = new Map<string, RegExp>()
-const MAX_PATTERNS = 1000
-
 /**
  * The regular expression a pattern string stands for. A leading `(?i)`, the
  * inline flag PCRE, Python and Go read, makes it case-insensitive.
  */
+export function toRegExp(pattern: string) {
+  return pattern.startsWith('(?i)')
+    ? new RegExp(pattern.slice(4), 'i')
+    : new RegExp(pattern)
+}
+
+const patterns = new Map<string, RegExp>()
+const MAX_PATTERNS = 1000
+
 function regex(pattern: string) {
   let re = patterns.get(pattern)
   if (!re) {
     try {
-      re = pattern.startsWith('(?i)')
-        ? new RegExp(pattern.slice(4), 'i')
-        : new RegExp(pattern)
+      re = toRegExp(pattern)
     } catch {
       throw new Error(`Invalid regular expression: ${pattern}`)
     }

package/src/parser/Parser.ts

@@ -9,7 +9,6 @@ import type Lexer from '../Lexer.ts'
 import type { Grammar } from '../grammar.ts'
 import type {
   AstNode,
-  AstNodeUnion,
   ConditionalExpression,
   Lambda,
   Literal,
@@ -29,8 +28,6 @@ const omittedAlternateBefore = new Set([
   'semicolon'
 ])
 
-export { JexlSyntaxError } from '../errors.ts'
-
 /**
  * Converts the tokens from the {@link Lexer} into an Abstract Syntax Tree, for
  * {@link compileAst} to lower to closures. A Pratt parser: each level of the
@@ -79,7 +76,7 @@ class Parser {
    * @returns the expression tree, or null for an expression with no tokens
    * @throws {JexlSyntaxError} if the tokens do not form exactly one expression
    */
-  complete(): AstNodeUnion | null {
+  complete(): AstNode | null {
     if (this._tokens.length === 0) {
       return null
     }
@@ -90,7 +87,7 @@ class Parser {
     return ast
   }
 
-  _sequence(): AstNodeUnion {
+  _sequence(): AstNode {
     const first = this._assignment()
     if (this._peek()?.type !== 'semicolon') {
       return first
@@ -106,13 +103,12 @@ class Parser {
     return { type: 'SequenceExpression', expressions }
   }
 
-  _assignment(): AstNodeUnion {
+  _assignment(): AstNode {
     if (this._atLambda()) {
       return this._lambda()
     }
     const left = this._ternary()
-    const token = this._peek()
-    if (token?.type !== 'binaryOp' || token.value !== '=') {
+    if (this._peek()?.type !== 'assign') {
       return left
     }
     if (left.type !== 'Identifier' || left.from) {
@@ -176,7 +172,7 @@ class Parser {
     return { type: 'Lambda', params, body }
   }
 
-  _ternary(): AstNodeUnion {
+  _ternary(): AstNode {
     const test = this._binary(-Infinity)
     if (!this._eat('question')) {
       return test
@@ -198,11 +194,11 @@ class Parser {
    * One exactly at `floor` binds only when it continues a right-associative
    * chain, which is how `a ^ b ^ c` groups from the right.
    */
-  _binary(floor: number, rightAssociative = false): AstNodeUnion {
+  _binary(floor: number, rightAssociative = false): AstNode {
     let left = this._unary()
     for (;;) {
       const token = this._peek()
-      if (token?.type !== 'binaryOp' || token.value === '=') {
+      if (token?.type !== 'binaryOp') {
         return left
       }
       const operator = token.value as string
@@ -224,7 +220,7 @@ class Parser {
   }
 
   /** `a ?? b || c` has no grouping a reader can guess; JS refuses it too. */
-  _mixesNullish(operator: string, ...operands: AstNodeUnion[]) {
+  _mixesNullish(operator: string, ...operands: AstNode[]) {
     return operands.some(
       (operand) =>
         operand.type === 'BinaryExpression' &&
@@ -235,22 +231,20 @@ class Parser {
     )
   }
 
-  _unary(): AstNodeUnion {
+  _unary(): AstNode {
     const token = this._peek()
     if (token?.type !== 'unaryOp') {
       return this._postfix(this._primary())
     }
     this._pos++
-    const operator = token.value as string
-    const op = this._grammar.elements[operator]
     return {
       type: 'UnaryExpression',
-      operator,
-      right: this._binary(op?.type === 'unaryOp' ? op.precedence : Infinity)
+      operator: token.value as string,
+      right: this._unary()
     }
   }
 
-  _postfix(subject: AstNodeUnion): AstNodeUnion {
+  _postfix(subject: AstNode): AstNode {
     let node = subject
     for (;;) {
       switch (this._peek()?.type) {
@@ -294,7 +288,7 @@ class Parser {
     }
   }
 
-  _primary(): AstNodeUnion {
+  _primary(): AstNode {
     const token = this._next()
     switch (token.type) {
       case 'literal': {

package/src/print.ts

@@ -3,34 +3,20 @@
  * Copyright 2020 Tom Shawver
  */
 
-import type { AstNode, AstNodeUnion, BinaryExpression } from './types.ts'
+import { identRegex } from './Lexer.ts'
+import { getGrammar } from './grammar.ts'
 
-type Node = AstNodeUnion
+import type { AstNode, BinaryExpression } from './types.ts'
 
-const PRECEDENCE: Record<string, number> = {
-  '=': 2,
-  '||': 10,
-  '??': 10,
-  '&&': 11,
-  '==': 20,
-  '!=': 20,
-  '~': 20,
-  '!~': 20,
-  '<': 20,
-  '<=': 20,
-  '>': 20,
-  '>=': 20,
-  in: 20,
-  '+': 30,
-  '-': 30,
-  '*': 40,
-  '/': 40,
-  '//': 40,
-  '%': 50,
-  '^': 50
+const { elements } = getGrammar()
+
+// print knows where only the built-in operators bind, so a host's own ones
+// print with their operands parenthesized
+function builtIn(operator: string) {
+  const element = elements[operator]
+  return element?.type === 'binaryOp' ? element : undefined
 }
 
-const RIGHT_ASSOCIATIVE = new Set(['^'])
 const LOGICAL = new Set(['||', '&&'])
 
 // how tightly each form binds, mirroring the Parser's levels: `;`, then `=`
@@ -41,12 +27,15 @@ const CONDITIONAL = 2
 const CUSTOM_BINARY = 3
 const UNARY = 100
 
-const letter = String.raw`a-zA-Zа-яА-Я_À-ÖØ-öø-ÿ$`
-const IDENTIFIER = new RegExp(`^[${letter}][${letter}0-9]*$`)
-const WORDS = new Set(['in', 'true', 'false', 'null'])
+const WORDS = new Set([
+  'true',
+  'false',
+  'null',
+  ...Object.keys(elements).filter((word) => identRegex.test(word))
+])
 
 export function isName(text: string) {
-  return IDENTIFIER.test(text) && !WORDS.has(text)
+  return identRegex.test(text) && !WORDS.has(text)
 }
 
 export function key(name: string) {
@@ -57,7 +46,7 @@ export function quote(text: string) {
   return `'${text.replaceAll('\\', '\\\\').replaceAll("'", String.raw`\'`)}'`
 }
 
-function precedenceOf(node: Node) {
+function precedenceOf(node: AstNode) {
   switch (node.type) {
     case 'SequenceExpression': {
       return SEQUENCE
@@ -71,7 +60,7 @@ function precedenceOf(node: Node) {
       return node.alternate ? CONDITIONAL : SEQUENCE
     }
     case 'BinaryExpression': {
-      return PRECEDENCE[node.operator] ?? CUSTOM_BINARY
+      return builtIn(node.operator)?.precedence ?? CUSTOM_BINARY
     }
     case 'UnaryExpression': {
       return UNARY
@@ -82,27 +71,31 @@ function precedenceOf(node: Node) {
   }
 }
 
-function within(ast: AstNode, least: number) {
-  const text = print(ast)
-  return precedenceOf(ast as Node) < least ? `(${text})` : text
+function within(node: AstNode, least: number) {
+  const text = print(node)
+  return precedenceOf(node) < least ? `(${text})` : text
 }
 
-function binaryOperand(parent: BinaryExpression, ast: AstNode, left: boolean) {
-  const own = PRECEDENCE[parent.operator]
-  if (own === undefined) {
-    return within(ast, UNARY)
+function binaryOperand(
+  parent: BinaryExpression,
+  child: AstNode,
+  left: boolean
+) {
+  const op = builtIn(parent.operator)
+  if (!op) {
+    return within(child, UNARY)
   }
-  const child = ast as Node
+  const own = op.precedence
   const theirs = precedenceOf(child)
   const chained =
     child.type === 'BinaryExpression' &&
-    RIGHT_ASSOCIATIVE.has(parent.operator) &&
-    RIGHT_ASSOCIATIVE.has(child.operator)
+    !!op.rightAssociative &&
+    !!builtIn(child.operator)?.rightAssociative
   const mixesNullish =
     child.type === 'BinaryExpression' &&
     ((parent.operator === '??' && LOGICAL.has(child.operator)) ||
       (child.operator === '??' && LOGICAL.has(parent.operator)))
-  const text = print(ast)
+  const text = print(child)
   return theirs < own || (theirs === own && left === chained) || mixesNullish
     ? `(${text})`
     : text
@@ -112,16 +105,21 @@ function binaryOperand(parent: BinaryExpression, ast: AstNode, left: boolean) {
  * Renders a tree back to expression text, for messages and suggestions. The
  * text parses back to the same tree.
  */
-export function print(ast: AstNode): string {
-  const node = ast as Node
+export function print(node: AstNode): string {
   switch (node.type) {
     case 'Literal': {
       const { value } = node
-      return typeof value === 'string'
-        ? quote(value)
-        : Object.is(value, -0)
-          ? '-0'
-          : String(value)
+      if (typeof value === 'string') {
+        return quote(value)
+      }
+      // a number too large for a double reads as Infinity, which is a name
+      return Object.is(value, -0)
+        ? '-0'
+        : value === Infinity
+          ? '1e999'
+          : value === -Infinity
+            ? '-1e999'
+            : String(value)
     }
     case 'Identifier': {
       return node.from
@@ -132,16 +130,16 @@ export function print(ast: AstNode): string {
       return `${within(node.subject, Infinity)}[${within(node.expr, ASSIGNMENT)}]`
     }
     case 'BinaryExpression': {
-      return `${binaryOperand(node, node.left, true)} ${node.operator} ${binaryOperand(node, node.right!, false)}`
+      return `${binaryOperand(node, node.left, true)} ${node.operator} ${binaryOperand(node, node.right, false)}`
     }
     case 'UnaryExpression': {
       const { operator } = node
-      const right = within(node.right!, UNARY)
+      const right = within(node.right, UNARY)
       // the Lexer folds a minus before a digit into the number
       if (operator === '-' && /^\d/.test(right)) {
         return `-(${right})`
       }
-      return IDENTIFIER.test(operator)
+      return identRegex.test(operator)
         ? `${operator} ${right}`
         : operator + right
     }
@@ -189,7 +187,7 @@ export function print(ast: AstNode): string {
       return expressions.length === 1 ? `${text};` : text
     }
     case 'AssignmentExpression': {
-      return `${node.left.value} = ${within(node.right!, ASSIGNMENT)}`
+      return `${node.left.value} = ${within(node.right, ASSIGNMENT)}`
     }
     case 'Lambda': {
       const params =

package/src/types.ts

@@ -27,41 +27,36 @@ export interface Token {
   raw: string
 }
 
-export interface AstNode {
-  type: string
-  right?: AstNode
-}
-
-export interface Literal extends AstNode {
+export interface Literal {
   type: 'Literal'
   value: string | number | boolean | null
 }
 
-export interface Identifier extends AstNode {
+export interface Identifier {
   type: 'Identifier'
   value: string
   from?: AstNode
 }
 
-export interface BinaryExpression extends AstNode {
+export interface BinaryExpression {
   type: 'BinaryExpression'
   operator: string
   left: AstNode
-  right?: AstNode
+  right: AstNode
 }
 
-export interface UnaryExpression extends AstNode {
+export interface UnaryExpression {
   type: 'UnaryExpression'
   operator: string
-  right?: AstNode
+  right: AstNode
 }
 
-export interface ArrayLiteral extends AstNode {
+export interface ArrayLiteral {
   type: 'ArrayLiteral'
   value: AstNode[]
 }
 
-export interface ObjectLiteral extends AstNode {
+export interface ObjectLiteral {
   type: 'ObjectLiteral'
   value: Record<string, AstNode>
 }
@@ -70,48 +65,49 @@ export type TemplateLiteralPart =
   | { type: 'static'; value: string }
   | { type: 'expression'; value: AstNode }
 
-export interface TemplateLiteral extends AstNode {
+export interface TemplateLiteral {
   type: 'TemplateLiteral'
   parts: TemplateLiteralPart[]
 }
 
-export interface FunctionCall extends AstNode {
+export interface FunctionCall {
   type: 'FunctionCall'
   name: string
   args: AstNode[]
 }
 
-export interface FilterExpression extends AstNode {
+export interface FilterExpression {
   type: 'FilterExpression'
   expr: AstNode
   subject: AstNode
 }
 
-export interface ConditionalExpression extends AstNode {
+export interface ConditionalExpression {
   type: 'ConditionalExpression'
   test: AstNode
   consequent?: AstNode
   alternate?: AstNode
 }
 
-export interface SequenceExpression extends AstNode {
+export interface SequenceExpression {
   type: 'SequenceExpression'
   expressions: AstNode[]
 }
 
-export interface AssignmentExpression extends AstNode {
+export interface AssignmentExpression {
   type: 'AssignmentExpression'
   operator: '='
   left: Identifier
+  right: AstNode
 }
 
-export interface Lambda extends AstNode {
+export interface Lambda {
   type: 'Lambda'
   params: string[]
   body: AstNode
 }
 
-export type AstNodeUnion =
+export type AstNode =
   | Literal
   | Identifier
   | BinaryExpression
@@ -126,7 +122,7 @@ export type AstNodeUnion =
   | AssignmentExpression
   | Lambda
 
-export type NodeByType<T extends AstNodeUnion['type']> = Extract<
-  AstNodeUnion,
+export type NodeByType<T extends AstNode['type']> = Extract<
+  AstNode,
   { type: T }
 >