1.0.0-beta.13

• Disallowed duplicate parameter names in function definitions, i.e., ($a, $a) => expr is now prohibited
• Improved suggestions for the ternary operator (?:)
• Fixed suggestions for and, or and ?? operators
• Fixed a compilation error for the generated code of function expressions in stat mode in some cases
• Fixed a runtime error for a comparator function in some scenarios
• Fixed support for TypedArrays with slice notation and methods such as numbers(), avg(), count(), sum(), median(), variance(), stdev() and percentile()
• Added missing package exports for package.json and dist/*

1.0.0-beta.12

• Added support for _ as numeric separator for all kinds of number, e.g. 1_000, 0xa0b1_c2d3
• Extended shorthand syntax to define object entries (see Shorthand syntax for entries)

  {
      sum(),              // equavalent to: `sum: sum()`
      foo.[x > 5],        // equavalent to: `foo: foo | .[x > 5]`
      baz is number ?: 0, // equavalent to: `baz: baz | is number ?: 0`
      $var.size()         // equavalent to: `var: var | .size()`
  }
  

• Improved error handling for variable references, including providing query's range of the problem reference in errors
• Fixed acessing to global variables when a variable has no definition

1.0.0-beta.11

• Added support for treating TypedArrays as regular arrays
• Fixed lastIndexOf() method behavior when fromIndex is zero; previously, the search incorrectly started from the end of an array instead of the zero position
• Fixed group() method to include elements with an empty array as a key in the group with key: undefined; previously, such elements were omitted from the result
• Modified the behavior of slice notation:
  • When the value is a string, the result remains a string (was an array of chars)
  • When from is greater than to and step is not specified, step defaults to -1 (i.e. $[3:1] is the same as $[1:3:-1])
  • When from is greater than to and step is specified, the sign of the step is inverted (i.e. $[5:1:-2] is the same as $[1:5:2])

1.0.0-beta.10

• Introduced basic support for function arguments in the syntax, allowing $arg => expr and ($a, $b) => expr forms to be supported
• Changed the behavior of this in custom methods and assertions defined as functions to include a context reference to the query context. Additionally, introduced this.method(name, ...args) and this.assertion(name, ...args) methods to call a custom method or use an assertion.
• Added support for special variables $$ and # in custom methods and assertions defined as strings (Jora queries).
• Updated the pipeline operator grammar to allow starting a query with it, e.g. | expr is now a valid query
• Fixed a query compilation error when $ was used as an object entry, e.g. { $, prop: 1 }
• Fixed bracket notation and pick() method when used with a function to apply bool() to the result of the function
• Reverted the precedence of the pipeline operator to be lower than that of the ternary operator for consistency with other operators

1.0.0-beta.9

• Removed support for a legacy syntax for functions, i.e. <expr>
• Changed the precedence of the pipeline operator to match that of the ternary operator to prevent parsing errors in certain cases
• Disallowed whitespace between a method name and open parenthesis
• Allowed keywords as a property getter in query chains when a dot is before the keyword. For example, .has.and.is is now a valid query, while has.and is not valid due to the missing dot before has.
• Added support for keyword literals (null, undefined, true, false, NaN and Infinity), numbers and strings as property name in an object literal when a value is not specified, i.e. { null } is the same as { "null": $["null"] }
• Added suggestions listing for keyword literals as property name in an object literal
• Fixed suggestions listing inside empty parentheses
• Fixed suggestions listing for is operator in tolerant mode when right part is empty
• Fixed duplicates in has operator suggestions
• Removed missed experimental if, then and else keyword tokens in parser

1.0.0-beta.8 Assertions and lots of new query methods

• Reduced parser size by 10Kb
• Changed setup() function to take options parameter instead of custom methods dictionary, i.e. setup(methods) → setup({ methods })
• Added assertions option for jora() and setup() functions to specify additional assertion functions, i.e. jora(..., { assetions }) and setup({ assertions })
• Forbidden to override built-in methods and assertions, now setup() and query() functions throws when a custom method or an assertion has the same name as built-in one
• Extended query result object in stat mode to provide a result value of the query execution as value property (i.e. jora(query, { stat: true })().value)
• Renamed SortingFunction AST node type into CompareFunction
• Renamed Unary AST node type into Prefix
• Added Assertion and Postfix AST node types
• Added nullish coalescing operator (??)
• Added is operator
• Added replace() method
• Added min() and max() methods
• Added numbers(), sum(), avg(), count(), variance(), stdev(), percentile() (with alias p()) and median() methods
• Added indexOf() and lastIndexOf() methods
• Added toLowerCase(), toUpperCase() and trim() methods
• Added math methods abs(), acos(), acosh(), asin(), asinh(), atan(), atan2(), atanh(), cbrt(), ceil(), clz32(), cos(), cosh(), exp(), expm1(), floor(), fround(), hypot(), imul(), ln() (Math.log() in JavaScript), log10(), ln1p() (Math.log1p() in JavaScript), log2(), pow(), round(), sign(), sin(), sinh(), sqrt(), tan(), tanh() and trunc() (see details in docs)
• Modified the ternary operator to allow optional components. The : can be omitted if the last part is excluded. For instance, the following are now valid syntaxes: expr ? : [], expr ? 1, and expr?. When omitted, the default structure will be: $ ? $ : undefined
• Changed the comparator function grammar to allow any expression in the definition, not just a query chain. This eliminates the need for parentheses in many cases. For example, a + b desc is now a valid definition, whereas previously it required parentheses: (a + b) desc (since evaluated as a + (b desc)).
• Changed precedence of function definitions to be lower than that of the pipeline operator and comparator function definitions (i.e., the lowest precedence). For example, the expression => a | b now evaluates as => (a | b) instead of (=> a) | b as before, meaning it returns a function instead of the value of b.
• Changed split() method to support arrays, in that case pattern can be a function or any value
• Fixed in, not in, has and has no operators to handle NaN values correctly, e.g. NaN in [1, NaN, 3] returns true now

1.0.0-beta.7

• Fixed syntax.tokenize() method to use a tolerant parser when tolerantMode parameter is true
• Fixed parsing failures in tolerant mode on blocks [], .[], (), .() and ..() when their body starts with an operator, a keyword, etc.
• Fixed suggestions when pattern is a single quoted string (i.e. for 'foo' in .[field='foo'])
• Fixed suggestions for Pick nodes when query is a complex expression, e.g. a function (#35)
• Fixed suggestions for Block nodes with empty body in strict parse mode
• Fixed processing \0 in strings as a null character for a parity with JavaScript
• Fixed Indentifier node to store an empty string as a name instead of _ for placeholder identifiers in tolerant parse mode. This fixes the problem of restoring a query from an AST after parsing in tolerant mode
• Added Placeholder node type
• Changed Block node to store a Placeholder node instead of null when block's body is empty

1.0.0-beta.6 Dual package, new stat API, suggestions and error precision improvements, and more

• Added support for custom methods as a string (jora query) in jora.setup()
• Added a check for all methods are defined on query compilation step to avoid runtime exceptions
• Allowed g, m, s and u flags in regexp literals
• Improved error message when a methods is not defined, i.e. Method "foo" is not defined instead of m.foo is not a function
• Improved error locations in string literals
• Disallowed a backslash before closing quote or apostrophe in string literals
• Fixed match() method to work well for RegExp with g flag and for strings when matchAll is true
• Fixed sort() method to perform a stable sort for old js-engines and always place undefined values last
• Fixed range in details for bad input errors
• Fixed suggestion support in template literals (#33)
• Fixed suggestions for = and != operators by avoiding unfold array values
• Fixed suggestions for arrays in in, not in, has and has no operators to exclude literal values only
• Removed value suggestions in cases | in <string or number> and <string or number> has |
• Fixed a call stack overflow exception when too many (over ~110k) suggestion values for a range
• BREAKING Reworked stat API:
  • Changed stat() method result value to return values as is, i.e. a Set instance instead of its materialization as an array. Mutations of sets (values and related) should be avoided since they are shared between all stat API methods calls.
  • Changed a signature of suggestion() method to get options as a second argument (optional), with the following options:
    • limit (default: Infinity) – a max number of the values that should be returned for each value type ("property", "value" or "variable")
    • sort (default: false) – a comparator function (should take 2 arguments and return a negative number, 0 or a positive number) for value list sorting, makes sence when limit is used
    • filter (default: function) – a filter function factory (pattern => value => <expr>) to discard values from the result when returns a falsy value (default is equivalent to patttern => value => String(value).toLowerCase().includes(pattern))
  • Changed suggestion() method result to return values grouped by a type:

        suggestion(): Array<{
            type: 'property' | 'value' | 'variable',
            from: number,
            to: number,
            text: string,
            suggestions: Array<string | number>
        }> | null

  • All the changes are targeted to improve performance and memory consumption when a query is performing to a huge datasets (hundreds of thousands of values). As a result a suggestions fetching is boosted up to 30-40 times for such cases.
• Converted to Dual Package, i.e. ESM and CommonJS support
• Changed Node.js support to ^10.12.0 || ^12.20.0 || ^14.13.0 || >=15.0.0
• Changed dist modules:
  • Removed jora.min.js
  • Changed jora.js format from CJS to IIFE and applied minification
  • Added jora.esm.js (minified ESM module)
  • Added source maps jora.js.map & jora.esm.js.map

1.0.0-beta.5 Superset of JSON5 and template literals

• Jora became a superset of JSON5 (see #23)
• Added support for template literals
• Added support for multi-line comments
• Added support for hexadecimal numbers
• Added support for hexadecimal escape sequence in strings, i.e. 'hello\x20world'
• Added support for multiple lines in strings by escaping new line characters
• Added Infinity and NaN literals
• Fixed string literal parsing to be ECMA-262 compliant
• Changed parsing to recognize line terminators according to ECMA-262 (added \r\n, \u2028 and \u2029)
• Allowed a single trailing comma in object and array literals
• Allowed unicode escape sequence in identifier name
• Allowed object literal property names starting with $ when a value is defined

1.0.0-beta.4

• Added setup() API method to create a query function with defined custom methods once
• Allowed definitions in object's literals, i.e. { $a: 42; foo: $a * 2, $a } results in { foo: 84, a: 42 }
• Exposed suggest(source, parseResult) method (as syntax.suggest) to get suggestion ranges based on AST and source
• Exposed tokenize(source, tolerantMode = false) method (as syntax.tokenize)