@borgar/fx 4.11.2 → 4.12.0

package/docs/API.md

@@ -383,6 +383,7 @@ The AST Abstract Syntax Tree's format is documented in [AST_format.md](./AST_for
 | [options]                   | `object`                   | `{}`    | Options                                                                                                                                             |
 | [options].allowNamed        | `boolean`                  | `true`  | Enable parsing names as well as ranges.                                                                                                             |
 | [options].allowTernary      | `boolean`                  | `false` | Enables the recognition of ternary ranges in the style of `A1:A` or `A1:1`. These are supported by Google Sheets but not Excel. See: References.md. |
+| [options].looseRefCalls     | `boolean`                  | `false` | Permits any function call where otherwise only functions that return references would be permitted.                                                 |
 | [options].negativeNumbers   | `boolean`                  | `true`  | Merges unary minuses with their immediately following number tokens (`-`,`1`) => `-1` (alternatively these will be unary operations in the tree).   |
 | [options].permitArrayCalls  | `boolean`                  | `false` | Function calls are allowed as elements of arrays. This is a feature in Google Sheets while Excel does not allow it.                                 |
 | [options].permitArrayRanges | `boolean`                  | `false` | Ranges are allowed as elements of arrays. This is a feature in Google Sheets while Excel does not allow it.                                         |

package/lib/parseSRange.js

@@ -1,4 +1,4 @@
-const re_SRcolumnB = /^\[('['#@[\]]|[^'#@[\]])+\]/i;
+const re_SRcolumnB = /^\[('['#@[\]]|[^'#@[\]])*\]/i;
 const re_SRcolumnN = /^([^#@[\]:]+)/i;
 
 const keyTerms = {
@@ -68,7 +68,9 @@ export function parseSRange (raw) {
     // [column]
     else if ((m1 = matchColumn(s, false))) {
       pos += m1[0].length;
-      columns.push(m1[1]);
+      if (m1[1]) {
+        columns.push(m1[1]);
+      }
     }
     // use the "normal" method
     // [[#keyword]]

package/lib/parseStructRef.spec.js

@@ -24,12 +24,16 @@ Test.prototype.isSREqual = function isSREqual (expr, expect, opts) {
   this.deepEqual(parseStructRef(expr, opts), expect, expr);
 };
 
-test('parse structured references', t => {
+test.only('parse structured references', t => {
   t.isSREqual('table[col]', {
     table: 'table',
     columns: [ 'col' ]
   });
 
+  t.isSREqual('table[]', {
+    table: 'table'
+  });
+
   t.isSREqual('[#All]', {
     sections: [ 'all' ]
   });

package/lib/parser.js

@@ -63,8 +63,16 @@ const refFunctions = [
   'XLOOKUP'
 ];
 
+const symbolTable = {};
+let currentNode;
+let tokens;
+let tokenIndex;
+let permitArrayRanges = false;
+let permitArrayCalls = false;
+let looseRefCalls = false;
+
 const isReferenceFunctionName = fnName => {
-  return refFunctions.includes(fnName.toUpperCase());
+  return looseRefCalls || refFunctions.includes(fnName.toUpperCase());
 };
 
 const isReferenceToken = (token, allowOperators = false) => {
@@ -98,13 +106,6 @@ const isReferenceNode = node => {
   );
 };
 
-const symbolTable = {};
-let currentNode;
-let tokens;
-let tokenIndex;
-let permitArrayRanges = false;
-let permitArrayCalls = false;
-
 function halt (message, atIndex = null) {
   const err = new Error(message);
   err.source = tokens.map(d => d.value).join('');
@@ -688,6 +689,7 @@ prefix('{', function () {
  * @param {boolean} [options.negativeNumbers=true]  Merges unary minuses with their immediately following number tokens (`-`,`1`) => `-1` (alternatively these will be unary operations in the tree).
  * @param {boolean} [options.permitArrayRanges=false]  Ranges are allowed as elements of arrays. This is a feature in Google Sheets while Excel does not allow it.
  * @param {boolean} [options.permitArrayCalls=false]  Function calls are allowed as elements of arrays. This is a feature in Google Sheets while Excel does not allow it.
+ * @param {boolean} [options.looseRefCalls=false]  Permits any function call where otherwise only functions that return references would be permitted.
  * @param {boolean} [options.r1c1=false]  Ranges are expected to be in the R1C1 style format rather than the more popular A1 style.
  * @param {boolean} [options.withLocation=false]  Nodes will include source position offsets to the tokens: `{ loc: [ start, end ] }`
  * @param {boolean} [options.xlsx=false]  Switches to the `[1]Sheet1!A1` or `[1]!name` prefix syntax form for external workbooks. See: [Prefixes.md](./Prefixes.md)
@@ -711,6 +713,8 @@ export function parse (formula, options) {
   permitArrayRanges = options?.permitArrayRanges;
   // allow calls in arrays "literals"?
   permitArrayCalls = options?.permitArrayCalls;
+  // allow any function call in range operations?
+  looseRefCalls = options?.looseRefCalls;
   // set index to start
   tokenIndex = 0;
   // discard redundant whitespace and = prefix

package/lib/parser.spec.js

@@ -1194,3 +1194,15 @@ test('parser whitespace handling', t => {
   });
   t.end();
 });
+
+test('looseRefCalls: true relaxes ref function restrictions', t => {
+  t.isInvalidExpr('A1:TESTFN()');
+  t.isParsed('A1:TESTFN()', {
+    type: 'BinaryExpression', operator: ':',
+    arguments: [
+      { type: 'ReferenceIdentifier', value: 'A1', kind: 'range' },
+      { type: 'CallExpression', callee: { type: 'Identifier', name: 'TESTFN' }, arguments: [] }
+    ]
+  }, { looseRefCalls: true });
+  t.end();
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgar/fx",
-  "version": "4.11.2",
+  "version": "4.12.0",
   "description": "Utilities for working with Excel formulas",
   "main": "dist/fx.js",
   "types": "dist/fx.d.ts",