@borgar/fx 4.13.0 → 5.0.0

package/lib/lexers/lexRange.js

@@ -1,8 +0,0 @@
-import { lexRangeA1 } from './lexRangeA1.js';
-import { lexRangeR1C1 } from './lexRangeR1C1.js';
-
-export function lexRange (str, pos, options) {
-  return options.r1c1
-    ? lexRangeR1C1(str, pos, options)
-    : lexRangeA1(str, pos, options);
-}

package/lib/lexers/sets.js

@@ -1,38 +0,0 @@
-import { lexError } from './lexError.js';
-import { lexRangeTrim } from './lexRangeTrim.js';
-import { lexOperator } from './lexOperator.js';
-import { lexFunction } from './lexFunction.js';
-import { lexBoolean } from './lexBoolean.js';
-import { lexNewLine } from './lexNewLine.js';
-import { lexWhitespace } from './lexWhitespace.js';
-import { lexString } from './lexString.js';
-import { lexContext } from './lexContext.js';
-import { lexRange } from './lexRange.js';
-import { lexStructured } from './lexStructured.js';
-import { lexNumber } from './lexNumber.js';
-import { lexNamed } from './lexNamed.js';
-import { lexRefOp } from './lexRefOp.js';
-
-export const lexers = [
-  lexError,
-  lexRangeTrim,
-  lexOperator,
-  lexFunction,
-  lexBoolean,
-  lexNewLine,
-  lexWhitespace,
-  lexString,
-  lexContext,
-  lexRange,
-  lexStructured,
-  lexNumber,
-  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 './lexers/sets.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();
-});

package/lib/parseStructRef.js

@@ -1,48 +0,0 @@
-import { parseRef } from './parseRef.js';
-import { parseSRange } from './parseSRange.js';
-
-/**
- * Parse a structured reference string into an object representing it.
- *
- * ```js
- * parseStructRef('workbook.xlsx!tableName[[#Data],[Column1]:[Column2]]');
- * // => {
- * //   context: [ 'workbook.xlsx' ],
- * //   sections: [ 'data' ],
- * //   columns: [ 'my column', '@foo' ],
- * //   table: 'tableName',
- * // }
- * ```
- *
- * For A:A or A1:A style ranges, `null` will be used for any dimensions that the
- * syntax does not specify:
- *
- * @tutorial References.md
- * @param {string} ref  A structured reference string
- * @param {object} [options={}]  Options
- * @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)
- * @returns {(ReferenceStruct|null)} An object representing a valid reference or null if it is invalid.
- */
-export function parseStructRef (ref, options = { xlsx: false }) {
-  const r = parseRef(ref, options);
-  if (r && r.struct) {
-    const structData = parseSRange(r.struct);
-    if (structData && structData.length === r.struct.length) {
-      return options.xlsx
-        ? {
-          workbookName: r.workbookName,
-          sheetName: r.sheetName,
-          table: r.name,
-          columns: structData.columns,
-          sections: structData.sections
-        }
-        : {
-          context: r.context,
-          table: r.name,
-          columns: structData.columns,
-          sections: structData.sections
-        };
-    }
-  }
-  return null;
-}

package/lib/parseStructRef.spec.js

@@ -1,164 +0,0 @@
-/* eslint-disable object-property-newline, object-curly-newline */
-import { test, Test } from 'tape';
-import { parseStructRef } from './parseStructRef.js';
-
-Test.prototype.isSREqual = function isSREqual (expr, expect, opts) {
-  if (expect) {
-    expect = opts?.xlsx
-      ? {
-        workbookName: '',
-        sheetName: '',
-        table: '',
-        columns: [],
-        sections: [],
-        ...expect
-      }
-      : {
-        context: [],
-        table: '',
-        columns: [],
-        sections: [],
-        ...expect
-      };
-  }
-  this.deepEqual(parseStructRef(expr, opts), expect, expr);
-};
-
-test('parse structured references', t => {
-  t.isSREqual('table[col]', {
-    table: 'table',
-    columns: [ 'col' ]
-  });
-
-  t.isSREqual('table[]', {
-    table: 'table'
-  });
-
-  t.isSREqual('[#All]', {
-    sections: [ 'all' ]
-  });
-
-  t.isSREqual('[column name]', {
-    columns: [ 'column name' ]
-  });
-
-  t.isSREqual('[column name]!foo', null);
-  t.isSREqual('[foo]bar', null);
-
-  t.isSREqual('[[my column]]', {
-    columns: [ 'my column' ]
-  });
-
-  t.isSREqual('[[my column]:otherColumn]', {
-    columns: [ 'my column', 'otherColumn' ]
-  });
-
-  t.isSREqual('[ [my column]:otherColumn ]', {
-    columns: [ 'my column', 'otherColumn ' ]
-  });
-
-  t.isSREqual('[ [my column]: otherColumn ]', {
-    columns: [ 'my column', ' otherColumn ' ]
-  });
-
-  t.isSREqual('[ @[ my column ]: otherColumn ]', {
-    columns: [ ' my column ', ' otherColumn ' ],
-    sections: [ 'this row' ]
-  });
-
-  t.isSREqual('[[#Data], [my column]:otherColumn]', {
-    columns: [ 'my column', 'otherColumn' ],
-    sections: [ 'data' ]
-  });
-
-  t.isSREqual('[ [#Data], [my column]:[\'@foo] ]', {
-    columns: [ 'my column', '@foo' ],
-    sections: [ 'data' ]
-  });
-
-  t.isSREqual('workbook.xlsx!tableName[ [#Data], [my column]:[\'@foo] ]', {
-    columns: [ 'my column', '@foo' ],
-    sections: [ 'data' ],
-    table: 'tableName',
-    context: [ 'workbook.xlsx' ]
-  });
-
-  t.isSREqual('[[#Data],[#data],[#Data],[#Data],[#Totals],[#Totals],[#Totals],foo]', {
-    columns: [ 'foo' ],
-    sections: [ 'data', 'totals' ]
-  });
-
-  t.isSREqual("'Sheet'!Table[Column]", {
-    columns: [ 'Column' ],
-    table: 'Table',
-    context: [ 'Sheet' ]
-  });
-
-  t.isSREqual("Sheet1!Table1[foo '[bar']]", {
-    columns: [ 'foo [bar]' ],
-    table: 'Table1',
-    context: [ 'Sheet1' ]
-  });
-
-  t.isSREqual('[myworkbook.xlsx]Sheet1!TMP8w0habhr[#All]', {
-    columns: [],
-    table: 'TMP8w0habhr',
-    context: [ 'myworkbook.xlsx', 'Sheet1' ],
-    sections: [ 'all' ]
-  });
-
-  t.end();
-});
-
-test('structured references parse in xlsx mode', t => {
-  t.isSREqual('[Workbook.xlsx]!Table[#Data]', {
-    workbookName: 'Workbook.xlsx',
-    table: 'Table',
-    sections: [ 'data' ]
-  }, { xlsx: true });
-
-  t.isSREqual('[Workbook.xlsx]Sheet1!Table[#Data]', {
-    workbookName: 'Workbook.xlsx',
-    sheetName: 'Sheet1',
-    table: 'Table',
-    sections: [ 'data' ]
-  }, { xlsx: true });
-
-  t.isSREqual('Sheet1!Table[#Data]', {
-    sheetName: 'Sheet1',
-    table: 'Table',
-    sections: [ 'data' ]
-  }, { xlsx: true });
-
-  t.end();
-});
-
-test('longform prase (in xlsx mode)', t => {
-  // thisRow should have no effect when parsing
-  t.isSREqual('Table2[[#This Row],[col1]]', {
-    table: 'Table2',
-    columns: [ 'col1' ],
-    sections: [ 'this row' ]
-  }, { xlsx: true, thisRow: true });
-
-  t.isSREqual('Table2[[#This Row],[col1]]', {
-    table: 'Table2',
-    columns: [ 'col1' ],
-    sections: [ 'this row' ]
-  }, { xlsx: true, thisRow: false });
-
-  t.isSREqual('Table2[[#This Row],[col1]]', {
-    table: 'Table2',
-    columns: [ 'col1' ],
-    sections: [ 'this row' ]
-  }, { xlsx: false, thisRow: true });
-
-  t.isSREqual('Table2[[#This Row],[col1]]', {
-    table: 'Table2',
-    columns: [ 'col1' ],
-    sections: [ 'this row' ]
-  }, { xlsx: false, thisRow: false });
-
-  t.end();
-});
-