@borgar/fx 4.12.0 → 5.0.0

package/lib/lexerParts.js

@@ -1,228 +0,0 @@
-import {
-  OPERATOR,
-  BOOLEAN,
-  ERROR,
-  NUMBER,
-  FUNCTION,
-  NEWLINE,
-  WHITESPACE,
-  STRING,
-  CONTEXT,
-  CONTEXT_QUOTE,
-  REF_RANGE,
-  REF_BEAM,
-  REF_NAMED,
-  REF_TERNARY,
-  REF_STRUCT,
-  MAX_COLS,
-  MAX_ROWS,
-  OPERATOR_TRIM
-} from './constants.js';
-import { fromCol } from './fromCol.js';
-import { parseSRange } from './parseSRange.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 = /^(<=|>=|<>|[-+/*^%&<>=]|[{},;]|[()]|@|:|!|#)/;
-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 re_RANGE_TRIM = /^(\.:\.|\.:|:\.)/;
-
-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 rangeOp = '\\.?:\\.?';
-const nextNotChar = '(?![a-z0-9_\\u00a1-\\uffff])';
-const re_A1COL = new RegExp(`^${colPart}${rangeOp}${colPart}${nextNotChar}`, 'i');
-const re_A1ROW = new RegExp(`^${rowPart}${rangeOp}${rowPart}${nextNotChar}`, 'i');
-const re_A1RANGE = new RegExp(`^${rngPart}${nextNotChar}`, 'i');
-const re_A1PARTIAL = new RegExp(`^((${colPart}|${rowPart})${rangeOp}${rngPart}|${rngPart}${rangeOp}(${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}(${rangeOp}${cPart})?${nextNotChar}`, 'i');
-const re_RCROW = new RegExp(`^${rPart}(${rangeOp}${rPart})?${nextNotChar}`, 'i');
-const re_RCRANGE = new RegExp(`^(?:(?=[RC])${rPart}${cPart})${nextNotChar}`, 'i');
-const re_RCPARTIAL = new RegExp(`^(${rPart}${cPart}(${rangeOp}${cPart}|${rangeOp}${rPart})(?![[\\d])|(${rPart}|${cPart})(${rangeOp}${rPart}${cPart}))${nextNotChar}`, '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] };
-    }
-  };
-}
-
-function lexNamed (str) {
-  const m = re_NAMED.exec(str);
-  if (m) {
-    const lc = m[0].toLowerCase();
-    // names starting with \ must be at least 3 char long
-    if (lc[0] === '\\' && m[0].length < 3) {
-      return null;
-    }
-    // single characters R and C are forbidden as names
-    if (lc === 'r' || lc === 'c') {
-      return null;
-    }
-    return { type: REF_NAMED, value: m[0] };
-  }
-}
-
-const re_QUOTED_VALUE = /^'(?:[^[\]]+?)?(?:\[(.+?)\])?(?:[^[\]]+?)'$/;
-const re_QUOTED_VALUE_XLSX = /^'\[(.+?)\]'$/;
-function lexContext (str, options) {
-  const mq = re_CONTEXT_QUOTE.exec(str);
-  if (mq) {
-    const value = mq[0];
-    const isValid = options.xlsx
-      ? re_QUOTED_VALUE_XLSX.test(value) || re_QUOTED_VALUE.test(value)
-      : re_QUOTED_VALUE.test(value);
-    if (isValid) {
-      return { type: CONTEXT_QUOTE, value: value };
-    }
-  }
-  // xlsx xml uses a variant of the syntax that has external references in
-  // bracets. Any of: [1]Sheet1!A1, '[1]Sheet one'!A1, [1]!named
-  // We're only concerned with the non quoted version here as the quoted version
-  // doesn't currently examine what is in the quotes.
-  const m = re_CONTEXT.exec(str);
-  if (m) {
-    const [ , a, b ] = m;
-    const valid = (
-      ((a && b) || b) || // "[a]b!" or "b!" forms
-      (a && !b && options.xlsx) // "[a]" form (allowed in xlsx mode)
-    );
-    if (valid) {
-      return { type: CONTEXT, value: m[0] };
-    }
-  }
-}
-
-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) {
-  let m, t;
-  if (options.r1c1) {
-    // RC notation
-    if (options.allowTernary && (m = re_RCPARTIAL.exec(str))) {
-      t = { type: REF_TERNARY, value: m[0] };
-    }
-    else if ((m = re_RCRANGE.exec(str))) {
-      t = { type: REF_RANGE, value: m[0] };
-    }
-    else if ((m = re_RCROW.exec(str)) || (m = re_RCCOL.exec(str))) {
-      t = { type: REF_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] ? 0 : 1);
-        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: REF_TERNARY, value: m[0] };
-    }
-    else if ((m = re_A1COL.exec(str)) || (m = re_A1ROW.exec(str))) {
-      t = { type: REF_BEAM, value: m[0] };
-    }
-    else if ((m = re_A1RANGE.exec(str))) {
-      t = { type: REF_RANGE, value: m[0] };
-    }
-    if (t) {
-      reA1Nums.lastIndex = 0;
-      // XXX: can probably optimize this as we know letters can only be 3 at max
-      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 R1C1 mode we only allow !
-  if (opts.r1c1) {
-    return (s[0] === '!')
-      ? { type: OPERATOR, value: s[0] }
-      : null;
-  }
-  // in A1 mode we allow [ '!', ':', '.:', ':.', '.:.']
-  const m = /^(!|\.?:\.?)/.exec(s);
-  if (m) {
-    return { type: OPERATOR, value: m[1] };
-  }
-  return null;
-}
-
-export const lexers = [
-  makeHandler(ERROR, re_ERROR),
-  makeHandler(OPERATOR_TRIM, re_RANGE_TRIM),
-  makeHandler(OPERATOR, re_OPERATOR),
-  makeHandler(FUNCTION, re_FUNCTION),
-  makeHandler(BOOLEAN, re_BOOLEAN),
-  makeHandler(NEWLINE, re_NEWLINE),
-  makeHandler(WHITESPACE, re_WHITESPACE),
-  makeHandler(STRING, re_STRING),
-  lexContext,
-  lexRange,
-  lexStructured,
-  makeHandler(NUMBER, re_NUMBER),
-  lexNamed
-];
-
-export const lexersRefs = [
-  lexRefOp,
-  lexContext,
-  lexRange,
-  lexStructured,
-  lexNamed
-];

package/lib/mergeRefTokens.spec.js

@@ -1,121 +0,0 @@
-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)', { mergeRefs: false, withLocation: true });
-
-  t.deepEqual(list, [
-    { 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', 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: ')', loc: [ 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: '=', 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',
-      loc: [ 5, 22 ] },
-    { type: OPERATOR, value: ')', loc: [ 22, 23 ] }
-  ]);
-
-  t.end();
-});
-
-test('mergeRefTokens cases', t => {
-  const opts = { mergeRefs: true, allowTernary: true };
-  t.deepEqual(tokenize('A1', opts), [
-    { type: REF_RANGE, value: 'A1' }
-  ]);
-  t.deepEqual(tokenize('A1:A1', opts), [
-    { type: REF_RANGE, value: 'A1:A1' }
-  ]);
-  t.deepEqual(tokenize('A:A', opts), [
-    { type: REF_BEAM, value: 'A:A' }
-  ]);
-  t.deepEqual(tokenize('A1:A', opts), [
-    { type: REF_TERNARY, value: 'A1:A' }
-  ]);
-
-  t.deepEqual(tokenize('\'Sheet1\'!A1', opts), [
-    { type: REF_RANGE, value: '\'Sheet1\'!A1' }
-  ]);
-  t.deepEqual(tokenize('\'Sheet1\'!A:A', opts), [
-    { type: REF_BEAM, value: '\'Sheet1\'!A:A' }
-  ]);
-  t.deepEqual(tokenize('\'Sheet1\'!A1:A', opts), [
-    { type: REF_TERNARY, value: '\'Sheet1\'!A1:A' }
-  ]);
-  t.deepEqual(tokenize('\'Sheet1\'!A1:A', opts), [
-    { type: REF_TERNARY, value: '\'Sheet1\'!A1:A' }
-  ]);
-
-  t.deepEqual(tokenize('Sheet1!A1', opts), [
-    { type: REF_RANGE, value: 'Sheet1!A1' }
-  ]);
-  t.deepEqual(tokenize('Sheet1!A:A', opts), [
-    { type: REF_BEAM, value: 'Sheet1!A:A' }
-  ]);
-  t.deepEqual(tokenize('Sheet1!A1:A', opts), [
-    { type: REF_TERNARY, value: 'Sheet1!A1:A' }
-  ]);
-  t.deepEqual(tokenize('Sheet1!A1:A', opts), [
-    { type: REF_TERNARY, value: 'Sheet1!A1:A' }
-  ]);
-
-  t.deepEqual(tokenize('[WB]Sheet1!A1', opts), [
-    { type: REF_RANGE, value: '[WB]Sheet1!A1' }
-  ]);
-  t.deepEqual(tokenize('[WB]Sheet1!A:A', opts), [
-    { type: REF_BEAM, value: '[WB]Sheet1!A:A' }
-  ]);
-  t.deepEqual(tokenize('[WB]Sheet1!A1:A', opts), [
-    { type: REF_TERNARY, value: '[WB]Sheet1!A1:A' }
-  ]);
-  t.deepEqual(tokenize('[WB]Sheet1!A1:A', opts), [
-    { type: REF_TERNARY, value: '[WB]Sheet1!A1:A' }
-  ]);
-  t.deepEqual(tokenize('[WB]Sheet1!A1.:.C3', opts), [
-    { type: REF_RANGE, value: '[WB]Sheet1!A1.:.C3' }
-  ]);
-
-  t.deepEqual(tokenize('foo', opts), [
-    { type: REF_NAMED, value: 'foo' }
-  ]);
-  t.deepEqual(tokenize('\'quoted\'!foo', opts), [
-    { type: REF_NAMED, value: '\'quoted\'!foo' }
-  ]);
-  t.deepEqual(tokenize('Sheet1!foo', opts), [
-    { type: REF_NAMED, value: 'Sheet1!foo' }
-  ]);
-  t.deepEqual(tokenize('[path]!foo', opts), [
-    { type: UNKNOWN, value: '[path]' },
-    { type: OPERATOR, value: '!' },
-    { type: REF_NAMED, value: 'foo' }
-  ]);
-  t.deepEqual(tokenize('[path]prefix!foo', opts), [
-    { type: REF_NAMED, value: '[path]prefix!foo' }
-  ]);
-
-  t.end();
-});

package/lib/package.json

@@ -1 +0,0 @@
-{ "type": "module" }

package/lib/parseRef.js

@@ -1,157 +0,0 @@
-import {
-  FX_PREFIX,
-  CONTEXT,
-  CONTEXT_QUOTE,
-  REF_RANGE,
-  REF_TERNARY,
-  REF_NAMED,
-  REF_BEAM,
-  REF_STRUCT,
-  OPERATOR
-} from './constants.js';
-import { lexersRefs } from './lexerParts.js';
-import { getTokens } from './lexer.js';
-
-// Liberally split a context string up into parts.
-// Permits any combination of braced and unbraced items.
-export function splitPrefix (str, stringsOnly = false) {
-  let inBrace = false;
-  let currStr = '';
-  const parts = [];
-  const flush = () => {
-    if (currStr) {
-      parts.push(
-        stringsOnly
-          ? currStr
-          : { value: currStr, braced: inBrace }
-      );
-    }
-    currStr = '';
-  };
-  for (let i = 0; i < str.length; i++) {
-    const char = str[i];
-    if (char === '[') {
-      flush();
-      inBrace = true;
-    }
-    else if (char === ']') {
-      flush();
-      inBrace = false;
-    }
-    else {
-      currStr += char;
-    }
-  }
-  flush();
-  return parts;
-}
-
-function splitContext (contextString) {
-  return { context: splitPrefix(contextString, true) };
-}
-
-function splitContextXlsx (contextString) {
-  const context = {};
-  const ctx = splitPrefix(contextString);
-  if (ctx.length > 1) {
-    context.workbookName = ctx[ctx.length - 2].value;
-    context.sheetName = ctx[ctx.length - 1].value;
-  }
-  else if (ctx.length === 1) {
-    const item = ctx[0];
-    if (item.braced) {
-      context.workbookName = item.value;
-    }
-    else {
-      context.sheetName = item.value;
-    }
-  }
-  return context;
-}
-
-const unquote = d => d.slice(1, -1).replace(/''/g, "'");
-
-const pRangeOp = t => t && (t.value === ':' || t.value === '.:' || t.value === ':.' || t.value === '.:.') && { operator: 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 === REF_BEAM && { r0: t.value };
-const pStrucured = t => t && t.type === REF_STRUCT && { struct: t.value };
-const pContext = (t, opts) => {
-  const splitter = opts.xlsx ? splitContextXlsx : splitContext;
-  if (t && t.type === CONTEXT) {
-    return splitter(t.value);
-  }
-  if (t && t.type === CONTEXT_QUOTE) {
-    return splitter(unquote(t.value));
-  }
-};
-const pNamed = t => t && t.type === REF_NAMED && { name: t.value };
-
-const validRuns = [
-  [ pPartial ],
-  [ pRange, pRangeOp, pRange2 ],
-  [ pRange ],
-  [ pBeam ],
-  [ pContext, pBang, pPartial ],
-  [ pContext, pBang, pRange, pRangeOp, pRange2 ],
-  [ pContext, pBang, pRange ],
-  [ pContext, pBang, pBeam ]
-];
-
-const validRunsNamed = validRuns.concat([
-  [ pNamed ],
-  [ pContext, pBang, pNamed ],
-  [ pStrucured ],
-  [ pNamed, pStrucured ],
-  [ pContext, pBang, pNamed, pStrucured ]
-]);
-
-export function parseRef (ref, opts) {
-  const options = {
-    withLocation: false,
-    mergeRefs: false,
-    allowTernary: false,
-    allowNamed: true,
-    r1c1: false,
-    xlsx: false,
-    ...opts
-  };
-  const tokens = getTokens(ref, lexersRefs, options);
-  const refData = options.xlsx
-    ? {
-      workbookName: '',
-      sheetName: '',
-      r0: '',
-      r1: '',
-      name: '',
-      operator: ''
-    }
-    : {
-      context: [],
-      r0: '',
-      r1: '',
-      name: '',
-      operator: ''
-    };
-  // discard the "="-prefix if it is there
-  if (tokens.length && tokens[0].type === FX_PREFIX) {
-    tokens.shift();
-  }
-  const runs = options.allowNamed ? validRunsNamed : validRuns;
-  for (let i = 0; i < runs.length; i++) {
-    const data = { ...refData };
-    if (runs[i].length === tokens.length) {
-      const valid = runs[i].every((parse, j) => {
-        const d = parse(tokens[j], options);
-        Object.assign(data, d);
-        return d;
-      });
-      if (valid) {
-        return data;
-      }
-    }
-  }
-  return null;
-}

package/lib/parseRef.spec.js

@@ -1,71 +0,0 @@
-import { test } from 'tape';
-import { splitPrefix } from './parseRef.js';
-
-test('splitPrefix', t => {
-  const testStr = (str, opt, expected) => {
-    t.deepEqual(splitPrefix(str, opt), expected, str);
-  };
-
-  testStr('[foo][bar][baz]', true, [ 'foo', 'bar', 'baz' ]);
-  testStr('foo[bar][baz]', true, [ 'foo', 'bar', 'baz' ]);
-  testStr('[foo]bar[baz]', true, [ 'foo', 'bar', 'baz' ]);
-  testStr('[foo][bar]baz', true, [ 'foo', 'bar', 'baz' ]);
-  testStr('foo[bar]baz', true, [ 'foo', 'bar', 'baz' ]);
-  testStr('[foo]bar[baz]', true, [ 'foo', 'bar', 'baz' ]);
-  testStr('[foo]bar', true, [ 'foo', 'bar' ]);
-  testStr('foo[bar]', true, [ 'foo', 'bar' ]);
-  testStr('[foo][bar]', true, [ 'foo', 'bar' ]);
-  testStr('[foo]', true, [ 'foo' ]);
-  testStr('foo', true, [ 'foo' ]);
-
-  testStr('[foo][bar][baz]', false, [
-    { value: 'foo', braced: true },
-    { value: 'bar', braced: true },
-    { value: 'baz', braced: true }
-  ]);
-  testStr('foo[bar][baz]', false, [
-    { value: 'foo', braced: false },
-    { value: 'bar', braced: true },
-    { value: 'baz', braced: true }
-  ]);
-  testStr('[foo]bar[baz]', false, [
-    { value: 'foo', braced: true },
-    { value: 'bar', braced: false },
-    { value: 'baz', braced: true }
-  ]);
-  testStr('[foo][bar]baz', false, [
-    { value: 'foo', braced: true },
-    { value: 'bar', braced: true },
-    { value: 'baz', braced: false }
-  ]);
-  testStr('foo[bar]baz', false, [
-    { value: 'foo', braced: false },
-    { value: 'bar', braced: true },
-    { value: 'baz', braced: false }
-  ]);
-  testStr('[foo]bar[baz]', false, [
-    { value: 'foo', braced: true },
-    { value: 'bar', braced: false },
-    { value: 'baz', braced: true }
-  ]);
-  testStr('[foo]bar', false, [
-    { value: 'foo', braced: true },
-    { value: 'bar', braced: false }
-  ]);
-  testStr('foo[bar]', false, [
-    { value: 'foo', braced: false },
-    { value: 'bar', braced: true }
-  ]);
-  testStr('[foo][bar]', false, [
-    { value: 'foo', braced: true },
-    { value: 'bar', braced: true }
-  ]);
-  testStr('[foo]', false, [
-    { value: 'foo', braced: true }
-  ]);
-  testStr('foo', false, [
-    { value: 'foo', braced: false }
-  ]);
-
-  t.end();
-});