@jbrowse/jexl 4.0.0 → 5.0.0

package/esm/parser/states.js

@@ -1,140 +0,0 @@
-/*
- * Jexl
- * Copyright 2020 Tom Shawver
- */
-import * as h from "./handlers.js";
-/**
- * The tokens that may follow a finished operand: an operator to combine it
- * with, a dot or subscript to keep drilling into it, a question mark opening a
- * ternary, or a semicolon ending the statement. Shared by every state that
- * sits on a complete value, which is also why each of them is completable.
- */
-const afterOperand = {
-    binaryOp: { toState: 'expectOperand' },
-    dot: { toState: 'traverse' },
-    openBracket: { toState: 'filter' },
-    question: { toState: 'ternaryMid', handler: h.ternaryStart },
-    semicolon: { handler: h.semicolon }
-};
-/**
- * A mapping of all states in the finite state machine to a set of instructions
- * for handling or transitioning into other states. Each state can be handled
- * in one of two schemes: a tokenType map, or a subHandler.
- *
- * Standard expression elements are handled through the tokenType object. This
- * is an object map of all legal token types to encounter in this state (and
- * any unexpected token types will generate a thrown error) to an options
- * object that defines how they're handled.  The available options are:
- *
- *      {string} toState: The name of the state to which to transition
- *          immediately after handling this token
- *      {string} handler: The handler function to call when this token type is
- *          encountered in this state.  If omitted, the default handler
- *          matching the token's "type" property will be called. If the handler
- *          function does not exist, no call will be made and no error will be
- *          generated.  This is useful for tokens whose sole purpose is to
- *          transition to other states.
- *
- * States that consume a subexpression should define a subHandler, the
- * function to be called with an expression tree argument when the
- * subexpression is complete. Completeness is determined through the
- * endStates object, which maps tokens on which an expression should end to the
- * state to which to transition once the subHandler function has been called.
- *
- * Additionally, any state in which it is legal to mark the AST as completed
- * should have a 'completable' property set to boolean true.  Attempting to
- * call {@link Parser#complete} in any state without this property will result
- * in a thrown Error.
- *
- * @type {{}}
- */
-export const states = {
-    expectOperand: {
-        tokenTypes: {
-            literal: { toState: 'expectBinOp' },
-            templateString: { toState: 'expectBinOp' },
-            identifier: { toState: 'identifier' },
-            unaryOp: {},
-            openParen: { toState: 'subExpression' },
-            openCurl: { toState: 'expectObjKey', handler: h.objStart },
-            dot: { toState: 'traverse' },
-            openBracket: { toState: 'arrayVal', handler: h.arrayStart }
-        }
-    },
-    expectBinOp: {
-        tokenTypes: afterOperand,
-        completable: true
-    },
-    expectObjKey: {
-        tokenTypes: {
-            literal: { toState: 'expectKeyValSep', handler: h.objKey },
-            identifier: { toState: 'expectKeyValSep', handler: h.objKey },
-            closeCurl: { toState: 'expectBinOp' }
-        }
-    },
-    expectKeyValSep: {
-        tokenTypes: {
-            colon: { toState: 'objVal' }
-        }
-    },
-    identifier: {
-        tokenTypes: {
-            ...afterOperand,
-            // a name is the only operand that can be followed by an argument list,
-            // since a function is called by name rather than evaluated as a value
-            openParen: { toState: 'argVal', handler: h.functionCall }
-        },
-        completable: true
-    },
-    traverse: {
-        tokenTypes: {
-            identifier: { toState: 'identifier' }
-        }
-    },
-    filter: {
-        subHandler: h.filter,
-        endStates: {
-            closeBracket: 'identifier'
-        }
-    },
-    subExpression: {
-        subHandler: h.subExpression,
-        endStates: {
-            closeParen: 'expectBinOp'
-        }
-    },
-    argVal: {
-        subHandler: h.argVal,
-        endStates: {
-            comma: 'argVal',
-            // a call's result is an ordinary operand: it can be operated on or
-            // drilled into, but not called again, since only a name can be called
-            closeParen: 'expectBinOp'
-        }
-    },
-    objVal: {
-        subHandler: h.objVal,
-        endStates: {
-            comma: 'expectObjKey',
-            closeCurl: 'expectBinOp'
-        }
-    },
-    arrayVal: {
-        subHandler: h.arrayVal,
-        endStates: {
-            comma: 'arrayVal',
-            closeBracket: 'expectBinOp'
-        }
-    },
-    ternaryMid: {
-        subHandler: h.ternaryMid,
-        endStates: {
-            colon: 'ternaryEnd'
-        }
-    },
-    ternaryEnd: {
-        subHandler: h.ternaryEnd,
-        completable: true
-    }
-};
-//# sourceMappingURL=states.js.map

package/esm/parser/states.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"states.js","sourceRoot":"","sources":["../../src/parser/states.ts"],"names":[],"mappings":"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"}

package/src/parser/handlers.ts

@@ -1,372 +0,0 @@
-/*
- * Jexl
- * Copyright 2020 Tom Shawver
- */
-
-import { precedenceOf } from '../grammar.ts'
-// circular with Parser.ts, which is fine: the binding is only read from inside
-// a handler, long after both modules have finished evaluating
-import Parser from './Parser.ts'
-
-import type {
-  ArrayLiteral,
-  AssignmentExpression,
-  AstNode,
-  BinaryExpression,
-  ConditionalExpression,
-  FilterExpression,
-  FunctionCall,
-  Identifier,
-  Literal,
-  ObjectLiteral,
-  TemplateLiteral,
-  Token,
-  UnaryExpression
-} from '../types.ts'
-
-/**
- * Handles a subexpression that's used to define a transform argument's value.
- * @param {{type: <string>}} ast The subexpression tree
- */
-export function argVal(this: Parser, ast: AstNode | null) {
-  if (ast) {
-    ;(this._cursor as FunctionCall).args.push(ast)
-  }
-}
-
-/**
- * Handles new array literals by adding them as a new node in the AST,
- * initialized with an empty array.
- */
-export function arrayStart(this: Parser) {
-  const node: ArrayLiteral = {
-    type: 'ArrayLiteral',
-    value: []
-  }
-  this._placeAtCursor(node)
-}
-
-/**
- * Handles a subexpression representing an element of an array literal.
- * @param {{type: <string>}} ast The subexpression tree
- */
-export function arrayVal(this: Parser, ast: AstNode | null) {
-  if (ast) {
-    ;(this._cursor as ArrayLiteral).value.push(ast)
-  }
-}
-
-/**
- * Handles tokens of type 'binaryOp', indicating an operation that has two
- * inputs: a left side and a right side.
- * @param {{type: <string>}} token A token object
- */
-export function binaryOp(this: Parser, token: Token) {
-  if (token.value === '=') {
-    // `from` marks a member access such as `a.b`; only a bare name can be
-    // assigned to, since the compiled closure writes straight into the context
-    if (
-      this._cursor?.type !== 'Identifier' ||
-      (this._cursor as Identifier).from
-    ) {
-      throw new Error('Left side of assignment must be a variable name')
-    }
-
-    const node: AssignmentExpression = {
-      type: 'AssignmentExpression',
-      operator: '=',
-      left: this._cursor as Identifier
-    }
-    this._cursor = this._cursor._parent
-    this._placeAtCursor(node)
-    return
-  }
-
-  const tokenValue = token.value as string
-  const precedence = precedenceOf(this._grammar.elements[tokenValue])
-  let parent = this._cursor?._parent
-  while (parent) {
-    const parentExpr = parent as BinaryExpression
-    if (!parentExpr.operator) {
-      break
-    }
-    // a prefix operator binds tighter than any binary one, so `-x ^ 2` groups
-    // as `(-x) ^ 2` — the same way `-2 ^ 2` already does, since the Lexer folds
-    // that sign into the literal. Looking `-` up in the grammar finds its
-    // binary precedence instead, which is lower than `^`'s and gave `-(x ^ 2)`
-    const parentPrecedence =
-      parent.type === 'UnaryExpression'
-        ? Infinity
-        : precedenceOf(this._grammar.elements[parentExpr.operator])
-    if (parentPrecedence < precedence) {
-      break
-    }
-    this._cursor = parent
-    parent = parent._parent
-  }
-  const node: BinaryExpression = {
-    type: 'BinaryExpression',
-    operator: tokenValue,
-    left: this._cursor!
-  }
-  this._setParent(this._cursor!, node)
-  this._cursor = parent
-  this._placeAtCursor(node)
-}
-
-/**
- * Handles successive nodes in an identifier chain.  More specifically, it
- * sets values that determine how the following identifier gets placed in the
- * AST.
- */
-export function dot(this: Parser) {
-  const cursor = this._cursor
-  // a dot continues an identifier chain. With nothing to continue — no cursor,
-  // or an operator still waiting on its right-hand side — it would instead open
-  // a relative path, the leading dot of `list[.price > 5]`. This fork removed
-  // array filtering expressions, which are the only construct that gives a
-  // relative path a root to resolve against, so it is rejected here rather than
-  // parsed into a tree that can only fail once it is evaluated.
-  if (
-    !cursor ||
-    cursor.type === 'UnaryExpression' ||
-    (cursor.type === 'BinaryExpression' && !cursor.right)
-  ) {
-    throw new Error(`Relative paths are not supported: ${this._exprStr}`)
-  }
-  this._nextIdentEncapsulate = true
-}
-
-/**
- * Handles a subexpression used for filtering an array returned by an
- * identifier chain.
- * @param {{type: <string>}} ast The subexpression tree
- */
-export function filter(this: Parser, ast: AstNode | null) {
-  const node: FilterExpression = {
-    type: 'FilterExpression',
-    expr: ast!,
-    subject: this._cursor!
-  }
-  this._placeBeforeCursor(node)
-}
-
-/**
- * Handles identifier tokens when used to indicate the name of a function to
- * be called.
- *
- * A call written against a value, `a.b(x)`, becomes `b(a, x)`: jexl functions
- * live in one global pool and have no receiver, so the value the name was read
- * from is passed as the first argument instead. Every function in the pool is
- * already written that way — `get(feature, key)`, `split(str, sep)` — which is
- * what makes the two spellings equivalent. Previously the receiver was simply
- * dropped, so `refName.split(' ')` quietly called `split(' ')`.
- */
-export function functionCall(this: Parser) {
-  const cursor = this._cursor
-  if (cursor?.type !== 'Identifier') {
-    // reached by `a[expr]()`, whose subject is a filter rather than a name;
-    // there is nothing to look up in the function pool
-    throw new Error(`Functions must be called by name: ${this._exprStr}`)
-  }
-  const { from, value } = cursor as Identifier
-  const node: FunctionCall = {
-    type: 'FunctionCall',
-    name: value,
-    args: from ? [from] : []
-  }
-  this._placeBeforeCursor(node)
-}
-
-/**
- * Handles identifier tokens by adding them as a new node in the AST.
- * @param {{type: <string>}} token A token object
- */
-export function identifier(this: Parser, token: Token) {
-  const node: Identifier = {
-    type: 'Identifier',
-    value: token.value as string
-  }
-  if (this._nextIdentEncapsulate) {
-    node.from = this._cursor!
-    this._placeBeforeCursor(node)
-    this._nextIdentEncapsulate = false
-  } else {
-    this._placeAtCursor(node)
-  }
-}
-
-/**
- * Handles literal values, such as strings, booleans, and numerics, by adding
- * them as a new node in the AST.
- * @param {{type: <string>}} token A token object
- */
-export function literal(this: Parser, token: Token) {
-  const node: Literal = {
-    type: 'Literal',
-    value: token.value as string | number | boolean
-  }
-  this._placeAtCursor(node)
-}
-
-/**
- * Handles template string tokens by parsing their interpolation expressions
- * and creating a TemplateLiteral AST node.
- * @param {{type: <string>}} token A token object
- */
-export function templateString(this: Parser, token: Token) {
-  const parts: TemplateLiteral['parts'] = []
-  const tokenParts = Array.isArray(token.value) ? token.value : []
-
-  for (const part of tokenParts) {
-    if (part.type === 'static') {
-      parts.push({
-        type: 'static',
-        value: this._lexer._unescapeTemplateString(part.value)
-      })
-    } else {
-      const subTokens = this._lexer.tokenize(part.value)
-      const subParser = new Parser(this._grammar, this._lexer)
-      subParser.addTokens(subTokens)
-      const subAst = subParser.complete()
-
-      if (!subAst) {
-        throw new Error('Empty interpolation in template string')
-      }
-
-      parts.push({
-        type: 'expression',
-        value: subAst
-      })
-    }
-  }
-
-  const node: TemplateLiteral = {
-    type: 'TemplateLiteral',
-    parts
-  }
-  this._placeAtCursor(node)
-}
-
-/**
- * Queues a new object literal key to be written once a value is collected.
- * @param {{type: <string>}} token A token object
- */
-export function objKey(this: Parser, token: Token) {
-  this._curObjKey = token.value as string
-}
-
-/**
- * Handles new object literals by adding them as a new node in the AST,
- * initialized with an empty object.
- */
-export function objStart(this: Parser) {
-  const node: ObjectLiteral = {
-    type: 'ObjectLiteral',
-    value: {}
-  }
-  this._placeAtCursor(node)
-}
-
-/**
- * Handles an object value by adding its AST to the queued key on the object
- * literal node currently at the cursor.
- * @param {{type: <string>}} ast The subexpression tree
- */
-export function objVal(this: Parser, ast: AstNode | null) {
-  // defined rather than assigned so that the key "__proto__" becomes an
-  // ordinary entry of the node's key map instead of re-pointing its prototype,
-  // which dropped the entry before it could be compiled
-  Object.defineProperty(
-    (this._cursor as ObjectLiteral).value,
-    this._curObjKey!,
-    {
-      value: ast!,
-      writable: true,
-      enumerable: true,
-      configurable: true
-    }
-  )
-}
-
-/**
- * Handles traditional subexpressions, delineated with the groupStart and
- * groupEnd elements.
- * @param {{type: <string>}} ast The subexpression tree
- */
-export function subExpression(this: Parser, ast: AstNode | null) {
-  this._placeAtCursor(ast!)
-}
-
-/**
- * Handles a completed alternate subexpression of a ternary operator.
- * @param {{type: <string>}} ast The subexpression tree
- */
-export function ternaryEnd(this: Parser, ast: AstNode | null) {
-  ;(this._cursor as ConditionalExpression).alternate = ast ?? undefined
-}
-
-/**
- * Handles a completed consequent subexpression of a ternary operator.
- * @param {{type: <string>}} ast The subexpression tree
- */
-export function ternaryMid(this: Parser, ast: AstNode | null) {
-  ;(this._cursor as ConditionalExpression).consequent = ast ?? undefined
-}
-
-/**
- * Handles the start of a new ternary expression by encapsulating the tree so
- * far in a ConditionalExpression node, and using it as the test element.
- *
- * Every operator binds tighter than the conditional and so belongs in the test
- * — except `=`, which binds looser. `x = a ? b : c` therefore assigns the
- * conditional rather than testing the assignment, which had stored `a` in `x`.
- */
-export function ternaryStart(this: Parser) {
-  let assignment: AstNode | undefined
-  let test = this._tree!
-  while (test.type === 'AssignmentExpression' && test.right) {
-    assignment = test
-    test = test.right
-  }
-
-  const node: ConditionalExpression = {
-    type: 'ConditionalExpression',
-    test
-  }
-  if (assignment) {
-    assignment.right = node
-    this._setParent(node, assignment)
-  } else {
-    this._tree = node
-  }
-  this._cursor = node
-}
-
-/**
- * Handles token of type 'unaryOp', indicating that the operation has only
- * one input: a right side.
- * @param {{type: <string>}} token A token object
- */
-export function unaryOp(this: Parser, token: Token) {
-  const node: UnaryExpression = {
-    type: 'UnaryExpression',
-    operator: token.value as string
-  }
-  this._placeAtCursor(node)
-}
-
-/**
- * Handles semicolon separator between expressions
- */
-export function semicolon(this: Parser) {
-  if (!this._sequenceExpressions) {
-    this._sequenceExpressions = [this._tree!]
-  } else {
-    this._sequenceExpressions.push(this._tree!)
-  }
-
-  this._tree = null
-  this._cursor = null
-  this._state = 'expectOperand'
-}

package/src/parser/states.ts

@@ -1,159 +0,0 @@
-/*
- * Jexl
- * Copyright 2020 Tom Shawver
- */
-
-import * as h from './handlers.ts'
-
-import type { AstNode, Token } from '../types.ts'
-import type Parser from './Parser.ts'
-
-interface TokenTypeOptions {
-  toState?: string
-  handler?: (this: Parser, token: Token) => void
-}
-
-interface StateDefinition {
-  tokenTypes?: Record<string, TokenTypeOptions>
-  subHandler?: (this: Parser, ast: AstNode | null) => void
-  endStates?: Record<string, string>
-  completable?: boolean
-}
-
-type States = Record<string, StateDefinition>
-
-/**
- * The tokens that may follow a finished operand: an operator to combine it
- * with, a dot or subscript to keep drilling into it, a question mark opening a
- * ternary, or a semicolon ending the statement. Shared by every state that
- * sits on a complete value, which is also why each of them is completable.
- */
-const afterOperand: Record<string, TokenTypeOptions> = {
-  binaryOp: { toState: 'expectOperand' },
-  dot: { toState: 'traverse' },
-  openBracket: { toState: 'filter' },
-  question: { toState: 'ternaryMid', handler: h.ternaryStart },
-  semicolon: { handler: h.semicolon }
-}
-
-/**
- * A mapping of all states in the finite state machine to a set of instructions
- * for handling or transitioning into other states. Each state can be handled
- * in one of two schemes: a tokenType map, or a subHandler.
- *
- * Standard expression elements are handled through the tokenType object. This
- * is an object map of all legal token types to encounter in this state (and
- * any unexpected token types will generate a thrown error) to an options
- * object that defines how they're handled.  The available options are:
- *
- *      {string} toState: The name of the state to which to transition
- *          immediately after handling this token
- *      {string} handler: The handler function to call when this token type is
- *          encountered in this state.  If omitted, the default handler
- *          matching the token's "type" property will be called. If the handler
- *          function does not exist, no call will be made and no error will be
- *          generated.  This is useful for tokens whose sole purpose is to
- *          transition to other states.
- *
- * States that consume a subexpression should define a subHandler, the
- * function to be called with an expression tree argument when the
- * subexpression is complete. Completeness is determined through the
- * endStates object, which maps tokens on which an expression should end to the
- * state to which to transition once the subHandler function has been called.
- *
- * Additionally, any state in which it is legal to mark the AST as completed
- * should have a 'completable' property set to boolean true.  Attempting to
- * call {@link Parser#complete} in any state without this property will result
- * in a thrown Error.
- *
- * @type {{}}
- */
-export const states: States = {
-  expectOperand: {
-    tokenTypes: {
-      literal: { toState: 'expectBinOp' },
-      templateString: { toState: 'expectBinOp' },
-      identifier: { toState: 'identifier' },
-      unaryOp: {},
-      openParen: { toState: 'subExpression' },
-      openCurl: { toState: 'expectObjKey', handler: h.objStart },
-      dot: { toState: 'traverse' },
-      openBracket: { toState: 'arrayVal', handler: h.arrayStart }
-    }
-  },
-  expectBinOp: {
-    tokenTypes: afterOperand,
-    completable: true
-  },
-  expectObjKey: {
-    tokenTypes: {
-      literal: { toState: 'expectKeyValSep', handler: h.objKey },
-      identifier: { toState: 'expectKeyValSep', handler: h.objKey },
-      closeCurl: { toState: 'expectBinOp' }
-    }
-  },
-  expectKeyValSep: {
-    tokenTypes: {
-      colon: { toState: 'objVal' }
-    }
-  },
-  identifier: {
-    tokenTypes: {
-      ...afterOperand,
-      // a name is the only operand that can be followed by an argument list,
-      // since a function is called by name rather than evaluated as a value
-      openParen: { toState: 'argVal', handler: h.functionCall }
-    },
-    completable: true
-  },
-  traverse: {
-    tokenTypes: {
-      identifier: { toState: 'identifier' }
-    }
-  },
-  filter: {
-    subHandler: h.filter,
-    endStates: {
-      closeBracket: 'identifier'
-    }
-  },
-  subExpression: {
-    subHandler: h.subExpression,
-    endStates: {
-      closeParen: 'expectBinOp'
-    }
-  },
-  argVal: {
-    subHandler: h.argVal,
-    endStates: {
-      comma: 'argVal',
-      // a call's result is an ordinary operand: it can be operated on or
-      // drilled into, but not called again, since only a name can be called
-      closeParen: 'expectBinOp'
-    }
-  },
-  objVal: {
-    subHandler: h.objVal,
-    endStates: {
-      comma: 'expectObjKey',
-      closeCurl: 'expectBinOp'
-    }
-  },
-  arrayVal: {
-    subHandler: h.arrayVal,
-    endStates: {
-      comma: 'arrayVal',
-      closeBracket: 'expectBinOp'
-    }
-  },
-  ternaryMid: {
-    subHandler: h.ternaryMid,
-    endStates: {
-      colon: 'ternaryEnd'
-    }
-  },
-  ternaryEnd: {
-    subHandler: h.ternaryEnd,
-    completable: true
-  }
-}