@borgar/fx 2.1.1 → 3.0.0

package/lib/lexerParts.js

@@ -0,0 +1,153 @@
+import {
+  OPERATOR,
+  BOOLEAN,
+  ERROR,
+  NUMBER,
+  FUNCTION,
+  NEWLINE,
+  WHITESPACE,
+  STRING,
+  CONTEXT,
+  CONTEXT_QUOTE,
+  RANGE,
+  RANGE_BEAM,
+  RANGE_NAMED,
+  RANGE_TERNARY,
+  MAX_COLS,
+  MAX_ROWS
+} from './constants.js';
+import { fromCol } from './a1.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!)/i;
+const re_OPERATOR = /^(<=|>=|<>|[-+/*^%&<>=]|[{},;]|[()]|@|:|!|#)/;
+const re_BOOLEAN = /^(TRUE|FALSE)\b/i;
+const re_FUNCTION = /^[A-Z_]+[A-Z\d_.]*(?=\()/i;
+const re_NEWLINE = /^\n+/;
+const re_WHITESPACE = /^[ \f\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/;
+const re_STRING = /^"(?:""|[^"])*("|$)/;
+const re_NUMBER = /^(?:\d+(\.\d+)?(?:[eE][+-]?\d+)?|\d+)/;
+
+const re_CONTEXT = /^(\[(?:[^\]])+\])?([0-9A-Za-z._¡¤§¨ª\u00ad¯-\uffff]+)(?=!)/;
+const re_CONTEXT_QUOTE = /^'(?:''|[^'])*('|$)(?=!)/;
+
+const rngPart = '\\$?[A-Z]{1,3}\\$?[1-9][0-9]{0,6}';
+const colPart = '\\$?[A-Z]{1,3}';
+const rowPart = '\\$?[1-9][0-9]{0,6}';
+const re_A1COL = new RegExp(`^${colPart}:${colPart}`, 'i');
+const re_A1ROW = new RegExp(`^${rowPart}:${rowPart}`, 'i');
+const re_A1RANGE = new RegExp(`^${rngPart}`, 'i');
+const re_A1PARTIAL = new RegExp(`^((${colPart}|${rowPart}):${rngPart}|${rngPart}:(${colPart}|${rowPart}))(?![\\w($.])`, 'i');
+const rPart = '(?:R(?:\\[[+-]?\\d+\\]|[1-9][0-9]{0,6})?)';
+const cPart = '(?:C(?:\\[[+-]?\\d+\\]|[1-9][0-9]{0,4})?)';
+const re_RCCOL = new RegExp(`^${cPart}(:${cPart})?(?=\\W|$)`, 'i');
+const re_RCROW = new RegExp(`^${rPart}(:${rPart})?(?=\\W|$)`, 'i');
+const re_RCRANGE = new RegExp(`^(?:(?=[RC])${rPart}${cPart})`, 'i');
+const re_RCPARTIAL = new RegExp(`^(${rPart}${cPart}(:${cPart}|:${rPart})(?![[\\d])|(${rPart}|${cPart})(:${rPart}${cPart}))(?=\\W|$)`, 'i');
+
+// The advertized named ranges rules are a bit off from what Excel seems to do:
+// in the "extended range" of chars, it looks like it allows most things above
+// U+00B0 with the range between U+00A0-U+00AF rather random.
+// 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;
+
+function makeHandler (type, re) {
+  return str => {
+    const m = re.exec(str);
+    if (m) {
+      return { type: type, value: m[0] };
+    }
+  };
+}
+
+const reRCNums = /([RC])(\[?)(-?\d+)/gi;
+const reA1Nums = /(\d+|[a-zA-Z]+)/gi;
+function lexRange (str, options) {
+  let m, t;
+  if (options.r1c1) {
+    // RC notation
+    if (options.allowTernary && (m = re_RCPARTIAL.exec(str))) {
+      t = { type: RANGE_TERNARY, value: m[0] };
+    }
+    else if ((m = re_RCRANGE.exec(str))) {
+      t = { type: RANGE, value: m[0] };
+    }
+    else if ((m = re_RCROW.exec(str)) || (m = re_RCCOL.exec(str))) {
+      t = { type: RANGE_BEAM, value: m[0] };
+    }
+    if (t) {
+      reRCNums.lastIndex = 0;
+      while ((m = reRCNums.exec(t.value)) !== null) {
+        const x = (m[1] === 'R' ? MAX_ROWS : MAX_COLS) + (m[2] ? 1 : 0);
+        const val = parseInt(m[3], 10);
+        if (val >= x || val <= -x) {
+          return null;
+        }
+      }
+      return t;
+    }
+  }
+  else {
+    // A1 notation
+    if (options.allowTernary && (m = re_A1PARTIAL.exec(str))) {
+      t = { type: RANGE_TERNARY, value: m[0] };
+    }
+    else if ((m = re_A1COL.exec(str)) || (m = re_A1ROW.exec(str))) {
+      t = { type: RANGE_BEAM, value: m[0] };
+    }
+    else if ((m = re_A1RANGE.exec(str))) {
+      t = { type: RANGE, value: m[0] };
+    }
+    if (t) {
+      reA1Nums.lastIndex = 0;
+      while ((m = reA1Nums.exec(t.value)) !== null) {
+        if (/^\d/.test(m[1])) { // row
+          if ((parseInt(m[1], 10) - 1) > MAX_ROWS) {
+            return null;
+          }
+        }
+        else if (fromCol(m[1]) > MAX_COLS) {
+          return null;
+        }
+      }
+      return t;
+    }
+  }
+}
+
+function lexRefOp (s, opts) {
+  // in RC mode we only allow !
+  if (opts.r1c1) {
+    return (s[0] === '!')
+      ? { type: OPERATOR, value: s[0] }
+      : null;
+  }
+  // in A1 mode we allow ! and :
+  return (s[0] === '!' || s[0] === ':')
+    ? { type: OPERATOR, value: s[0] }
+    : null;
+}
+
+export const lexers = [
+  makeHandler(ERROR, re_ERROR),
+  makeHandler(OPERATOR, re_OPERATOR),
+  makeHandler(BOOLEAN, re_BOOLEAN),
+  makeHandler(FUNCTION, re_FUNCTION),
+  makeHandler(NEWLINE, re_NEWLINE),
+  makeHandler(WHITESPACE, re_WHITESPACE),
+  makeHandler(STRING, re_STRING),
+  makeHandler(CONTEXT_QUOTE, re_CONTEXT_QUOTE),
+  makeHandler(CONTEXT, re_CONTEXT),
+  lexRange,
+  makeHandler(NUMBER, re_NUMBER),
+  makeHandler(RANGE_NAMED, re_NAMED)
+];
+
+export const lexersRefs = [
+  lexRefOp,
+  makeHandler(CONTEXT_QUOTE, re_CONTEXT_QUOTE),
+  makeHandler(CONTEXT, re_CONTEXT),
+  lexRange,
+  makeHandler(RANGE_NAMED, re_NAMED)
+];

package/lib/mergeRefTokens.js

@@ -0,0 +1,77 @@
+import { CONTEXT, CONTEXT_QUOTE, RANGE, RANGE_NAMED, RANGE_BEAM, RANGE_TERNARY, OPERATOR } 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 ]
+];
+
+// valid token runs are converted to a tree structure
+const refPartsTree = {};
+function packList (f, node) {
+  if (f.length) {
+    const key = f[0];
+    node[key] = node[key] || {};
+    packList(f.slice(1), node[key]);
+  }
+  else {
+    node[END] = true;
+  }
+}
+validRunsMerge.forEach(run => packList(run.concat().reverse(), refPartsTree));
+
+// attempt to match a backwards run of tokens from a given point
+// to a path in the tree
+const matcher = (tokens, currNode, anchorIndex, index = 0) => {
+  const token = tokens[anchorIndex - index];
+  if (token) {
+    const key = (token.type === OPERATOR) ? token.value : token.type;
+    if (key in currNode) {
+      return matcher(tokens, currNode[key], anchorIndex, index + 1);
+    }
+  }
+  if (currNode[END]) {
+    // we may end here so this is a match
+    return index;
+  }
+  // no match
+  return 0;
+};
+
+// merge reference tokens as possible in a list of tokens
+export function mergeRefTokens (tokens) {
+  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);
+    if (valid) {
+      const toMerge = tokens.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];
+      }
+      i -= valid - 1;
+    }
+    finalTokens.unshift(token);
+  }
+  return finalTokens;
+}

package/lib/mergeRefTokens.spec.js

@@ -0,0 +1,118 @@
+import { CONTEXT, FUNCTION, FX_PREFIX, OPERATOR, RANGE, RANGE_BEAM, RANGE_NAMED, RANGE_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 });
+
+  t.deepEqual(list, [
+    { type: FX_PREFIX, value: '=', range: [ 0, 1 ] },
+    { type: FUNCTION, value: 'SUM', range: [ 1, 4 ] },
+    { type: OPERATOR, value: '(', range: [ 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: OPERATOR, value: ')', range: [ 22, 23 ] }
+  ]);
+
+  // set IDs on all tokens about to be joined
+  list[3].id = 'id1';
+  list[4].id = 'id2';
+  list[5].id = 'id3';
+  list[6].id = 'id4';
+  list[7].id = 'id5';
+
+  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,
+      id: 'id5', // token has the id of the first one
+      value: '[Wb1]Sheet1!A1:B2',
+      range: [ 5, 22 ] },
+    { type: OPERATOR, value: ')', range: [ 22, 23 ] }
+  ]);
+
+  t.end();
+});
+
+test('mergeRefTokens cases', t => {
+  const opts = { mergeRanges: true, allowTernary: true };
+  t.deepEqual(tokenize('A1', opts), [
+    { type: RANGE, value: 'A1' }
+  ]);
+  t.deepEqual(tokenize('A1:A1', opts), [
+    { type: RANGE, value: 'A1:A1' }
+  ]);
+  t.deepEqual(tokenize('A:A', opts), [
+    { type: RANGE_BEAM, value: 'A:A' }
+  ]);
+  t.deepEqual(tokenize('A1:A', opts), [
+    { type: RANGE_TERNARY, value: 'A1:A' }
+  ]);
+
+  t.deepEqual(tokenize('\'Sheet1\'!A1', opts), [
+    { type: RANGE, value: '\'Sheet1\'!A1' }
+  ]);
+  t.deepEqual(tokenize('\'Sheet1\'!A:A', opts), [
+    { type: RANGE_BEAM, value: '\'Sheet1\'!A:A' }
+  ]);
+  t.deepEqual(tokenize('\'Sheet1\'!A1:A', opts), [
+    { type: RANGE_TERNARY, value: '\'Sheet1\'!A1:A' }
+  ]);
+  t.deepEqual(tokenize('\'Sheet1\'!A1:A', opts), [
+    { type: RANGE_TERNARY, value: '\'Sheet1\'!A1:A' }
+  ]);
+
+  t.deepEqual(tokenize('Sheet1!A1', opts), [
+    { type: RANGE, value: 'Sheet1!A1' }
+  ]);
+  t.deepEqual(tokenize('Sheet1!A:A', opts), [
+    { type: RANGE_BEAM, value: 'Sheet1!A:A' }
+  ]);
+  t.deepEqual(tokenize('Sheet1!A1:A', opts), [
+    { type: RANGE_TERNARY, value: 'Sheet1!A1:A' }
+  ]);
+  t.deepEqual(tokenize('Sheet1!A1:A', opts), [
+    { type: RANGE_TERNARY, value: 'Sheet1!A1:A' }
+  ]);
+
+  t.deepEqual(tokenize('[WB]Sheet1!A1', opts), [
+    { type: RANGE, value: '[WB]Sheet1!A1' }
+  ]);
+  t.deepEqual(tokenize('[WB]Sheet1!A:A', opts), [
+    { type: RANGE_BEAM, value: '[WB]Sheet1!A:A' }
+  ]);
+  t.deepEqual(tokenize('[WB]Sheet1!A1:A', opts), [
+    { type: RANGE_TERNARY, value: '[WB]Sheet1!A1:A' }
+  ]);
+  t.deepEqual(tokenize('[WB]Sheet1!A1:A', opts), [
+    { type: RANGE_TERNARY, value: '[WB]Sheet1!A1:A' }
+  ]);
+
+  t.deepEqual(tokenize('foo', opts), [
+    { type: RANGE_NAMED, value: 'foo' }
+  ]);
+  t.deepEqual(tokenize('\'quoted\'!foo', opts), [
+    { type: RANGE_NAMED, value: '\'quoted\'!foo' }
+  ]);
+  t.deepEqual(tokenize('Sheet1!foo', opts), [
+    { type: RANGE_NAMED, value: 'Sheet1!foo' }
+  ]);
+  t.deepEqual(tokenize('[path]!foo', opts), [
+    { type: UNKNOWN, value: '[path]' },
+    { type: OPERATOR, value: '!' },
+    { type: RANGE_NAMED, value: 'foo' }
+  ]);
+  t.deepEqual(tokenize('[path]prefix!foo', opts), [
+    { type: RANGE_NAMED, value: '[path]prefix!foo' }
+  ]);
+
+  t.end();
+});

package/lib/parseRef.js

@@ -1,63 +1,67 @@
-import { FX_PREFIX, PATH_BRACE, PATH_PREFIX, PATH_QUOTE, RANGE, RANGE_NAMED, RANGE_BEAM } from './constants.js';
+import {
+  FX_PREFIX,
+  CONTEXT,
+  CONTEXT_QUOTE,
+  RANGE,
+  RANGE_TERNARY,
+  RANGE_NAMED,
+  RANGE_BEAM,
+  OPERATOR
+} from './constants.js';
+import { lexersRefs } from './lexerParts.js';
 import { getTokens } from './lexer.js';
 
+function splitContext (contextString) {
+  const m = /(?:\[(.+?)\])?([^[\]]+?)$/.exec(contextString);
+  if (m) {
+    const [ , a, b ] = m;
+    const context = [ a, b ].filter(Boolean);
+    return { context };
+  }
+}
+
 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 pBang = t => t && t.value === '!' && {};
+const pBang = t => t && t.type === OPERATOR && t.value === '!' && {};
 const pBeam = t => t && t.type === RANGE_BEAM && { r0: t.value };
-const pSheet = t => t && t.type === PATH_PREFIX && /^[^:\\/?*[\]]{0,31}$/.test(t.value) && { sheetName: t.value };
-const pFile = t => t && t.type === PATH_BRACE && { workbookName: t.value.slice(1, -1) };
-const pFile2 = t => t && t.type === PATH_PREFIX && { workbookName: t.value };
-const pNamed = t => t && t.type === RANGE_NAMED && { name: t.value };
-
-const pQuoted = t => {
-  if (t && t.type === PATH_QUOTE) {
-    const m = /(?:\[(.+?)\])?([^[\]]+?)$/.exec(unquote(t.value));
-    if (m) {
-      const [ , file, sheet ] = m;
-      if (!sheet || /^[^:\\/?*[\]]{0,31}$/.test(sheet)) {
-        return {
-          workbookName: file || '',
-          sheetName: sheet || ''
-        };
-      }
-    }
-  }
+const pContext = t => {
+  if (t && t.type === CONTEXT) { return splitContext(t.value); }
+  if (t && t.type === CONTEXT_QUOTE) { return splitContext(unquote(t.value)); }
 };
-const pQuoted2 = t => t && t.type === PATH_QUOTE && { workbookName: unquote(t.value) };
+const pNamed = t => t && t.type === RANGE_NAMED && { name: t.value };
 
 const validRuns = [
-  [ pRange ],
+  [ pPartial ],
   [ pRange, pRangeOp, pRange2 ],
+  [ pRange ],
   [ pBeam ],
-  [ pQuoted, pBang, pRange ],
-  [ pQuoted, pBang, pRange, pRangeOp, pRange2 ],
-  [ pQuoted, pBang, pBeam ],
-  [ pSheet, pBang, pRange ],
-  [ pSheet, pBang, pRange, pRangeOp, pRange2 ],
-  [ pSheet, pBang, pBeam ],
-  [ pFile, pSheet, pBang, pRange ],
-  [ pFile, pSheet, pBang, pRange, pRangeOp, pRange2 ],
-  [ pFile, pSheet, pBang, pBeam ]
+  [ pContext, pBang, pPartial ],
+  [ pContext, pBang, pRange, pRangeOp, pRange2 ],
+  [ pContext, pBang, pRange ],
+  [ pContext, pBang, pBeam ]
 ];
 
 const validRunsNamed = validRuns.concat([
   [ pNamed ],
-  [ pFile2, pBang, pNamed ],
-  [ pQuoted2, pBang, pNamed ]
+  [ pContext, pBang, pNamed ]
 ]);
 
-export function parseRef (ref, allow_named = true, tokenHandlers = []) {
-  const tokens = getTokens(ref, tokenHandlers, {
+export function parseRef (ref, opts) {
+  const options = {
     emitRanges: false,
-    mergeRanges: false
-  });
+    mergeRanges: false,
+    allowTernary: false,
+    allowNamed: true,
+    r1c1: false,
+    ...opts
+  };
+  const tokens = getTokens(ref, lexersRefs, options);
   const refData = {
-    sheetName: '',
-    workbookName: '',
+    context: [],
     r0: '',
     r1: '',
     name: ''
@@ -66,7 +70,7 @@ export function parseRef (ref, allow_named = true, tokenHandlers = []) {
   if (tokens.length && tokens[0].type === FX_PREFIX) {
     tokens.shift();
   }
-  const runs = allow_named ? validRunsNamed : validRuns;
+  const runs = options.allowNamed ? validRunsNamed : validRuns;
   for (let i = 0; i < runs.length; i++) {
     const data = { ...refData };
     if (runs[i].length === tokens.length) {