@borgar/fx 3.1.0 → 4.0.0-rc.2

package/lib/lexerParts.js

@@ -9,14 +9,16 @@ import {
   STRING,
   CONTEXT,
   CONTEXT_QUOTE,
-  RANGE,
-  RANGE_BEAM,
-  RANGE_NAMED,
-  RANGE_TERNARY,
+  REF_RANGE,
+  REF_BEAM,
+  REF_NAMED,
+  REF_TERNARY,
+  REF_STRUCT,
   MAX_COLS,
   MAX_ROWS
 } from './constants.js';
 import { fromCol } from './a1.js';
+import { parseSRange } from './sr.js';
 
 const re_ERROR = /^#(NAME\?|FIELD!|CALC!|VALUE!|REF!|DIV\/0!|NULL!|NUM!|N\/A|GETTING_DATA\b|SPILL!|UNKNOWN!|FIELD\b|CALC\b|SYNTAX\?|ERROR!|CONNECT!|BLOCKED!|EXTERNAL!)/i;
 const re_OPERATOR = /^(<=|>=|<>|[-+/*^%&<>=]|[{},;]|[()]|@|:|!|#)/;
@@ -50,7 +52,7 @@ const re_RCPARTIAL = new RegExp(`^(${rPart}${cPart}(:${cPart}|:${rPart})(?![[\\d
 // eslint-disable-next-line
 // const re_NAMED = /^[a-zA-Z\\_¡¤§¨ª\u00ad¯\u00b0-\uffff][a-zA-Z0-9\\_.?¡¤§¨ª\u00ad¯\u00b0-\uffff]{0,254}/i;
 // I've simplified to allowing everything above U+00A1:
-const re_NAMED = /^[a-zA-Z\\_\u00a1-\uffff][a-zA-Z0-9\\_.?\u00a1-\uffff]{0,254}/i;
+const re_NAMED = /^(?![CR]\b)[a-zA-Z\\_\u00a1-\uffff][a-zA-Z0-9\\_.?\u00a1-\uffff]{0,254}/i;
 
 function makeHandler (type, re) {
   return str => {
@@ -61,6 +63,26 @@ function makeHandler (type, re) {
   };
 }
 
+function lexStructured (str) {
+  const structData = parseSRange(str);
+  if (structData) {
+    // we have a match for a valid SR
+    let i = structData.length;
+    // skip tailing whitespace
+    while (str[i] === ' ') {
+      i++;
+    }
+    // and ensure that it isn't followed by a !
+    if (str[i] !== '!') {
+      return {
+        type: REF_STRUCT,
+        value: structData.token
+      };
+    }
+  }
+  return null;
+}
+
 const reRCNums = /([RC])(\[?)(-?\d+)/gi;
 const reA1Nums = /(\d+|[a-zA-Z]+)/gi;
 function lexRange (str, options) {
@@ -68,13 +90,13 @@ function lexRange (str, options) {
   if (options.r1c1) {
     // RC notation
     if (options.allowTernary && (m = re_RCPARTIAL.exec(str))) {
-      t = { type: RANGE_TERNARY, value: m[0] };
+      t = { type: REF_TERNARY, value: m[0] };
     }
     else if ((m = re_RCRANGE.exec(str))) {
-      t = { type: RANGE, value: m[0] };
+      t = { type: REF_RANGE, value: m[0] };
     }
     else if ((m = re_RCROW.exec(str)) || (m = re_RCCOL.exec(str))) {
-      t = { type: RANGE_BEAM, value: m[0] };
+      t = { type: REF_BEAM, value: m[0] };
     }
     if (t) {
       reRCNums.lastIndex = 0;
@@ -91,13 +113,13 @@ function lexRange (str, options) {
   else {
     // A1 notation
     if (options.allowTernary && (m = re_A1PARTIAL.exec(str))) {
-      t = { type: RANGE_TERNARY, value: m[0] };
+      t = { type: REF_TERNARY, value: m[0] };
     }
     else if ((m = re_A1COL.exec(str)) || (m = re_A1ROW.exec(str))) {
-      t = { type: RANGE_BEAM, value: m[0] };
+      t = { type: REF_BEAM, value: m[0] };
     }
     else if ((m = re_A1RANGE.exec(str))) {
-      t = { type: RANGE, value: m[0] };
+      t = { type: REF_RANGE, value: m[0] };
     }
     if (t) {
       reA1Nums.lastIndex = 0;
@@ -117,7 +139,7 @@ function lexRange (str, options) {
 }
 
 function lexRefOp (s, opts) {
-  // in RC mode we only allow !
+  // in R1C1 mode we only allow !
   if (opts.r1c1) {
     return (s[0] === '!')
       ? { type: OPERATOR, value: s[0] }
@@ -140,8 +162,9 @@ export const lexers = [
   makeHandler(CONTEXT_QUOTE, re_CONTEXT_QUOTE),
   makeHandler(CONTEXT, re_CONTEXT),
   lexRange,
+  lexStructured,
   makeHandler(NUMBER, re_NUMBER),
-  makeHandler(RANGE_NAMED, re_NAMED)
+  makeHandler(REF_NAMED, re_NAMED)
 ];
 
 export const lexersRefs = [
@@ -149,5 +172,6 @@ export const lexersRefs = [
   makeHandler(CONTEXT_QUOTE, re_CONTEXT_QUOTE),
   makeHandler(CONTEXT, re_CONTEXT),
   lexRange,
-  makeHandler(RANGE_NAMED, re_NAMED)
+  lexStructured,
+  makeHandler(REF_NAMED, re_NAMED)
 ];

package/lib/mergeRefTokens.js

@@ -1,23 +1,27 @@
-import { CONTEXT, CONTEXT_QUOTE, RANGE, RANGE_NAMED, RANGE_BEAM, RANGE_TERNARY, OPERATOR } from './constants.js';
+import { CONTEXT, CONTEXT_QUOTE, REF_RANGE, REF_NAMED, REF_BEAM, REF_TERNARY, OPERATOR, REF_STRUCT } from './constants.js';
 
 const END = '$';
 
 const validRunsMerge = [
-  [ RANGE, ':', RANGE ],
-  [ RANGE ],
-  [ RANGE_BEAM ],
-  [ RANGE_TERNARY ],
-  [ CONTEXT, '!', RANGE, ':', RANGE ],
-  [ CONTEXT, '!', RANGE ],
-  [ CONTEXT, '!', RANGE_BEAM ],
-  [ CONTEXT, '!', RANGE_TERNARY ],
-  [ CONTEXT_QUOTE, '!', RANGE, ':', RANGE ],
-  [ CONTEXT_QUOTE, '!', RANGE ],
-  [ CONTEXT_QUOTE, '!', RANGE_BEAM ],
-  [ CONTEXT_QUOTE, '!', RANGE_TERNARY ],
-  [ RANGE_NAMED ],
-  [ CONTEXT, '!', RANGE_NAMED ],
-  [ CONTEXT_QUOTE, '!', RANGE_NAMED ]
+  [ REF_RANGE, ':', REF_RANGE ],
+  [ REF_RANGE ],
+  [ REF_BEAM ],
+  [ REF_TERNARY ],
+  [ CONTEXT, '!', REF_RANGE, ':', REF_RANGE ],
+  [ CONTEXT, '!', REF_RANGE ],
+  [ CONTEXT, '!', REF_BEAM ],
+  [ CONTEXT, '!', REF_TERNARY ],
+  [ CONTEXT_QUOTE, '!', REF_RANGE, ':', REF_RANGE ],
+  [ CONTEXT_QUOTE, '!', REF_RANGE ],
+  [ CONTEXT_QUOTE, '!', REF_BEAM ],
+  [ CONTEXT_QUOTE, '!', REF_TERNARY ],
+  [ REF_NAMED ],
+  [ CONTEXT, '!', REF_NAMED ],
+  [ CONTEXT_QUOTE, '!', REF_NAMED ],
+  [ REF_STRUCT ],
+  [ REF_NAMED, REF_STRUCT ],
+  [ CONTEXT, '!', REF_NAMED, REF_STRUCT ],
+  [ CONTEXT_QUOTE, '!', REF_NAMED, REF_STRUCT ]
 ];
 
 // valid token runs are converted to a tree structure
@@ -52,22 +56,31 @@ const matcher = (tokens, currNode, anchorIndex, index = 0) => {
   return 0;
 };
 
-// merge reference tokens as possible in a list of tokens
-export function mergeRefTokens (tokens) {
+/**
+ * Merges context with reference tokens as possible in a list of tokens.
+ *
+ * When given a tokenlist, this function returns a new list with ranges returned
+ * as whole references (`Sheet1!A1:B2`) rather than separate tokens for each
+ * part: (`Sheet1`,`!`,`A1`,`:`,`B2`).
+ *
+ * @param {Array<Object>} tokenlist An array of tokens (from `tokenize()`)
+ * @return {Array} A new list of tokens with range parts merged.
+ */
+export function mergeRefTokens (tokenlist) {
   const finalTokens = [];
   // this seeks backwards because it's really the range part
   // that controls what can be joined.
-  for (let i = tokens.length - 1; i >= 0; i--) {
-    let token = tokens[i];
-    const valid = matcher(tokens, refPartsTree, i);
+  for (let i = tokenlist.length - 1; i >= 0; i--) {
+    let token = tokenlist[i];
+    const valid = matcher(tokenlist, refPartsTree, i);
     if (valid) {
-      const toMerge = tokens.slice(i - valid + 1, i + 1);
+      const toMerge = tokenlist.slice(i - valid + 1, i + 1);
       // use the meta properties from the "first" token (right-most token)
       token = { ...token };
       token.value = toMerge.map(d => d.value).join('');
-      // adjust the range to include all the text
-      if (token.range && toMerge[0].range) {
-        token.range[0] = toMerge[0].range[0];
+      // adjust the offsets to include all the text
+      if (token.loc && toMerge[0].loc) {
+        token.loc[0] = toMerge[0].loc[0];
       }
       i -= valid - 1;
     }

package/lib/mergeRefTokens.spec.js

@@ -1,23 +1,23 @@
-import { CONTEXT, FUNCTION, FX_PREFIX, OPERATOR, RANGE, RANGE_BEAM, RANGE_NAMED, RANGE_TERNARY, UNKNOWN } from './constants.js';
+import { CONTEXT, FUNCTION, FX_PREFIX, OPERATOR, REF_RANGE, REF_BEAM, REF_NAMED, REF_TERNARY, UNKNOWN } from './constants.js';
 import { test } from 'tape';
 import { mergeRefTokens } from './mergeRefTokens.js';
 import { tokenize } from './lexer.js';
 
 test('mergeRefTokens basics', t => {
-  const list = tokenize('=SUM([Wb1]Sheet1!A1:B2)', { mergeRanges: false, emitRanges: true });
+  const list = tokenize('=SUM([Wb1]Sheet1!A1:B2)', { mergeRefs: false, withLocation: true });
 
   t.deepEqual(list, [
-    { type: FX_PREFIX, value: '=', range: [ 0, 1 ] },
-    { type: FUNCTION, value: 'SUM', range: [ 1, 4 ] },
-    { type: OPERATOR, value: '(', range: [ 4, 5 ] },
+    { type: FX_PREFIX, value: '=', loc: [ 0, 1 ] },
+    { type: FUNCTION, value: 'SUM', loc: [ 1, 4 ] },
+    { type: OPERATOR, value: '(', loc: [ 4, 5 ] },
 
-    { type: CONTEXT, value: '[Wb1]Sheet1', range: [ 5, 16 ] },
-    { type: OPERATOR, value: '!', range: [ 16, 17 ] },
-    { type: RANGE, value: 'A1', range: [ 17, 19 ] },
-    { type: OPERATOR, value: ':', range: [ 19, 20 ] },
-    { type: RANGE, value: 'B2', range: [ 20, 22 ] },
+    { type: CONTEXT, value: '[Wb1]Sheet1', loc: [ 5, 16 ] },
+    { type: OPERATOR, value: '!', loc: [ 16, 17 ] },
+    { type: REF_RANGE, value: 'A1', loc: [ 17, 19 ] },
+    { type: OPERATOR, value: ':', loc: [ 19, 20 ] },
+    { type: REF_RANGE, value: 'B2', loc: [ 20, 22 ] },
 
-    { type: OPERATOR, value: ')', range: [ 22, 23 ] }
+    { type: OPERATOR, value: ')', loc: [ 22, 23 ] }
   ]);
 
   // set IDs on all tokens about to be joined
@@ -29,89 +29,89 @@ test('mergeRefTokens basics', t => {
 
   const mergedList = mergeRefTokens(list);
   t.deepEqual(mergedList, [
-    { type: FX_PREFIX, value: '=', range: [ 0, 1 ] },
-    { type: FUNCTION, value: 'SUM', range: [ 1, 4 ] },
-    { type: OPERATOR, value: '(', range: [ 4, 5 ] },
-    { type: RANGE,
+    { type: FX_PREFIX, value: '=', loc: [ 0, 1 ] },
+    { type: FUNCTION, value: 'SUM', loc: [ 1, 4 ] },
+    { type: OPERATOR, value: '(', loc: [ 4, 5 ] },
+    { type: REF_RANGE,
       id: 'id5', // token has the id of the first one
       value: '[Wb1]Sheet1!A1:B2',
-      range: [ 5, 22 ] },
-    { type: OPERATOR, value: ')', range: [ 22, 23 ] }
+      loc: [ 5, 22 ] },
+    { type: OPERATOR, value: ')', loc: [ 22, 23 ] }
   ]);
 
   t.end();
 });
 
 test('mergeRefTokens cases', t => {
-  const opts = { mergeRanges: true, allowTernary: true };
+  const opts = { mergeRefs: true, allowTernary: true };
   t.deepEqual(tokenize('A1', opts), [
-    { type: RANGE, value: 'A1' }
+    { type: REF_RANGE, value: 'A1' }
   ]);
   t.deepEqual(tokenize('A1:A1', opts), [
-    { type: RANGE, value: 'A1:A1' }
+    { type: REF_RANGE, value: 'A1:A1' }
   ]);
   t.deepEqual(tokenize('A:A', opts), [
-    { type: RANGE_BEAM, value: 'A:A' }
+    { type: REF_BEAM, value: 'A:A' }
   ]);
   t.deepEqual(tokenize('A1:A', opts), [
-    { type: RANGE_TERNARY, value: 'A1:A' }
+    { type: REF_TERNARY, value: 'A1:A' }
   ]);
 
   t.deepEqual(tokenize('\'Sheet1\'!A1', opts), [
-    { type: RANGE, value: '\'Sheet1\'!A1' }
+    { type: REF_RANGE, value: '\'Sheet1\'!A1' }
   ]);
   t.deepEqual(tokenize('\'Sheet1\'!A:A', opts), [
-    { type: RANGE_BEAM, value: '\'Sheet1\'!A:A' }
+    { type: REF_BEAM, value: '\'Sheet1\'!A:A' }
   ]);
   t.deepEqual(tokenize('\'Sheet1\'!A1:A', opts), [
-    { type: RANGE_TERNARY, value: '\'Sheet1\'!A1:A' }
+    { type: REF_TERNARY, value: '\'Sheet1\'!A1:A' }
   ]);
   t.deepEqual(tokenize('\'Sheet1\'!A1:A', opts), [
-    { type: RANGE_TERNARY, value: '\'Sheet1\'!A1:A' }
+    { type: REF_TERNARY, value: '\'Sheet1\'!A1:A' }
   ]);
 
   t.deepEqual(tokenize('Sheet1!A1', opts), [
-    { type: RANGE, value: 'Sheet1!A1' }
+    { type: REF_RANGE, value: 'Sheet1!A1' }
   ]);
   t.deepEqual(tokenize('Sheet1!A:A', opts), [
-    { type: RANGE_BEAM, value: 'Sheet1!A:A' }
+    { type: REF_BEAM, value: 'Sheet1!A:A' }
   ]);
   t.deepEqual(tokenize('Sheet1!A1:A', opts), [
-    { type: RANGE_TERNARY, value: 'Sheet1!A1:A' }
+    { type: REF_TERNARY, value: 'Sheet1!A1:A' }
   ]);
   t.deepEqual(tokenize('Sheet1!A1:A', opts), [
-    { type: RANGE_TERNARY, value: 'Sheet1!A1:A' }
+    { type: REF_TERNARY, value: 'Sheet1!A1:A' }
   ]);
 
   t.deepEqual(tokenize('[WB]Sheet1!A1', opts), [
-    { type: RANGE, value: '[WB]Sheet1!A1' }
+    { type: REF_RANGE, value: '[WB]Sheet1!A1' }
   ]);
   t.deepEqual(tokenize('[WB]Sheet1!A:A', opts), [
-    { type: RANGE_BEAM, value: '[WB]Sheet1!A:A' }
+    { type: REF_BEAM, value: '[WB]Sheet1!A:A' }
   ]);
   t.deepEqual(tokenize('[WB]Sheet1!A1:A', opts), [
-    { type: RANGE_TERNARY, value: '[WB]Sheet1!A1:A' }
+    { type: REF_TERNARY, value: '[WB]Sheet1!A1:A' }
   ]);
   t.deepEqual(tokenize('[WB]Sheet1!A1:A', opts), [
-    { type: RANGE_TERNARY, value: '[WB]Sheet1!A1:A' }
+    { type: REF_TERNARY, value: '[WB]Sheet1!A1:A' }
   ]);
 
   t.deepEqual(tokenize('foo', opts), [
-    { type: RANGE_NAMED, value: 'foo' }
+    { type: REF_NAMED, value: 'foo' }
   ]);
   t.deepEqual(tokenize('\'quoted\'!foo', opts), [
-    { type: RANGE_NAMED, value: '\'quoted\'!foo' }
+    { type: REF_NAMED, value: '\'quoted\'!foo' }
   ]);
   t.deepEqual(tokenize('Sheet1!foo', opts), [
-    { type: RANGE_NAMED, value: 'Sheet1!foo' }
+    { type: REF_NAMED, value: 'Sheet1!foo' }
   ]);
   t.deepEqual(tokenize('[path]!foo', opts), [
     { type: UNKNOWN, value: '[path]' },
     { type: OPERATOR, value: '!' },
-    { type: RANGE_NAMED, value: 'foo' }
+    { type: REF_NAMED, value: 'foo' }
   ]);
   t.deepEqual(tokenize('[path]prefix!foo', opts), [
-    { type: RANGE_NAMED, value: '[path]prefix!foo' }
+    { type: REF_NAMED, value: '[path]prefix!foo' }
   ]);
 
   t.end();

package/lib/parseRef.js

@@ -2,10 +2,11 @@ import {
   FX_PREFIX,
   CONTEXT,
   CONTEXT_QUOTE,
-  RANGE,
-  RANGE_TERNARY,
-  RANGE_NAMED,
-  RANGE_BEAM,
+  REF_RANGE,
+  REF_TERNARY,
+  REF_NAMED,
+  REF_BEAM,
+  REF_STRUCT,
   OPERATOR
 } from './constants.js';
 import { lexersRefs } from './lexerParts.js';
@@ -23,16 +24,17 @@ function splitContext (contextString) {
 const unquote = d => d.slice(1, -1).replace(/''/g, "'");
 
 const pRangeOp = t => t && t.value === ':' && {};
-const pRange = t => t && t.type === RANGE && { r0: t.value };
-const pPartial = t => t && t.type === RANGE_TERNARY && { r0: t.value };
-const pRange2 = t => t && t.type === RANGE && { r1: t.value };
+const pRange = t => t && t.type === REF_RANGE && { r0: t.value };
+const pPartial = t => t && t.type === REF_TERNARY && { r0: t.value };
+const pRange2 = t => t && t.type === REF_RANGE && { r1: t.value };
 const pBang = t => t && t.type === OPERATOR && t.value === '!' && {};
-const pBeam = t => t && t.type === RANGE_BEAM && { r0: t.value };
+const pBeam = t => t && t.type === REF_BEAM && { r0: t.value };
+const pStrucured = t => t && t.type === REF_STRUCT && { struct: t.value };
 const pContext = t => {
   if (t && t.type === CONTEXT) { return splitContext(t.value); }
   if (t && t.type === CONTEXT_QUOTE) { return splitContext(unquote(t.value)); }
 };
-const pNamed = t => t && t.type === RANGE_NAMED && { name: t.value };
+const pNamed = t => t && t.type === REF_NAMED && { name: t.value };
 
 const validRuns = [
   [ pPartial ],
@@ -47,13 +49,16 @@ const validRuns = [
 
 const validRunsNamed = validRuns.concat([
   [ pNamed ],
-  [ pContext, pBang, pNamed ]
+  [ pContext, pBang, pNamed ],
+  [ pStrucured ],
+  [ pNamed, pStrucured ],
+  [ pContext, pBang, pNamed, pStrucured ]
 ]);
 
 export function parseRef (ref, opts) {
   const options = {
-    emitRanges: false,
-    mergeRanges: false,
+    withLocation: false,
+    mergeRefs: false,
     allowTernary: false,
     allowNamed: true,
     r1c1: false,