@borgar/fx 4.12.0 → 5.0.0

package/lib/translate-toA1.spec.js

@@ -1,214 +0,0 @@
-import { test, Test } from 'tape';
-import { translateToA1 } from './translate.js';
-import { tokenize } from './lexer.js';
-import { addTokenMeta } from './addTokenMeta.js';
-import { ERROR, FUNCTION, FX_PREFIX, OPERATOR, REF_RANGE, REF_BEAM, REF_STRUCT } from './constants.js';
-
-Test.prototype.isR2A = function isTokens (expr, anchor, result, opts) {
-  this.is(translateToA1(expr, anchor, opts), result, expr);
-};
-
-test('translate absolute cells from RC to A1', t => {
-  t.isR2A('=R1C1', 'B2', '=$A$1');
-  t.isR2A('=R2C1', 'B2', '=$A$2');
-  t.isR2A('=R3C1', 'B2', '=$A$3');
-  t.isR2A('=R1C2', 'B2', '=$B$1');
-  t.isR2A('=R2C2', 'B2', '=$B$2');
-  t.isR2A('=R3C2', 'B2', '=$B$3');
-  t.isR2A('=R1C3', 'B2', '=$C$1');
-  t.isR2A('=R2C3', 'B2', '=$C$2');
-  t.isR2A('=R3C3', 'B2', '=$C$3');
-  // absolute cells, anchor has no real effect
-  t.isR2A('=R1C1', 'Z19', '=$A$1');
-  t.isR2A('=R2C1', 'Z19', '=$A$2');
-  t.isR2A('=R3C1', 'Z19', '=$A$3');
-  t.isR2A('=R1C2', 'Z19', '=$B$1');
-  t.isR2A('=R2C2', 'Z19', '=$B$2');
-  t.isR2A('=R3C2', 'Z19', '=$B$3');
-  t.isR2A('=R1C3', 'Z19', '=$C$1');
-  t.isR2A('=R2C3', 'Z19', '=$C$2');
-  t.isR2A('=R3C3', 'Z19', '=$C$3');
-  t.end();
-});
-
-test('translate relative cells from RC to A1', t => {
-  t.isR2A('=R[-1]C[-1]', 'B2', '=A1');
-  t.isR2A('=RC[-1]', 'B2', '=A2');
-  t.isR2A('=R[1]C[-1]', 'B2', '=A3');
-  t.isR2A('=R[-1]C', 'B2', '=B1');
-  t.isR2A('=RC', 'B2', '=B2');
-  t.isR2A('=R[1]C', 'B2', '=B3');
-  t.isR2A('=R[-1]C[1]', 'B2', '=C1');
-  t.isR2A('=RC[1]', 'B2', '=C2');
-  t.isR2A('=R[1]C[1]', 'B2', '=C3');
-  // relative cells move with anchor
-  t.isR2A('=R[-1]C[-1]', 'I12', '=H11');
-  t.isR2A('=RC[-1]', 'I12', '=H12');
-  t.isR2A('=R[1]C[-1]', 'I12', '=H13');
-  t.isR2A('=R[-1]C', 'I12', '=I11');
-  t.isR2A('=RC', 'I12', '=I12');
-  t.isR2A('=R[1]C', 'I12', '=I13');
-  t.isR2A('=R[-1]C[1]', 'I12', '=J11');
-  t.isR2A('=RC[1]', 'I12', '=J12');
-  t.isR2A('=R[1]C[1]', 'I12', '=J13');
-  // relative cells, but with [0] notation
-  t.isR2A('=R[0]C[-1]', 'B2', '=A2');
-  t.isR2A('=R[-1]C[0]', 'B2', '=B1');
-  t.isR2A('=R[0]C[0]', 'B2', '=B2');
-  t.isR2A('=R[1]C[0]', 'B2', '=B3');
-  t.isR2A('=R[0]C[1]', 'B2', '=C2');
-  t.end();
-});
-
-test('translate rows from RC to A1', t => {
-  t.isR2A('=R', 'B2', '=2:2');
-  t.isR2A('=R[0]', 'B2', '=2:2');
-  t.isR2A('=R', 'B13', '=13:13');
-  t.isR2A('=R:R', 'B2', '=2:2');
-  t.isR2A('=R2:R2', 'B2', '=$2:$2');
-  t.isR2A('=R:R2', 'B2', '=2:$2');
-  t.isR2A('=R[1]:R[-1]', 'Z10', '=9:11');
-  t.end();
-});
-
-test('translate cols from RC to A1', t => {
-  t.isR2A('=C', 'B2', '=B:B');
-  t.isR2A('=C[0]', 'B2', '=B:B');
-  t.isR2A('=C', 'Z2', '=Z:Z');
-  t.isR2A('=C:C', 'B2', '=B:B');
-  t.isR2A('=C2:C2', 'B2', '=$B:$B');
-  t.isR2A('=C:C2', 'B2', '=B:$B');
-  t.isR2A('=C[1]:C[-1]', 'M10', '=L:N');
-  t.end();
-});
-
-test('translate partials from RC to A1', t => {
-  t.isR2A('=R[-5]C[-2]:C[-2]', 'C6', '=A1:A');
-  t.isR2A('=R[-5]C[-3]:R[-5]', 'D6', '=A1:1');
-  t.isR2A('=R[-6]C1:C1', 'C7', '=$A1:$A');
-  t.isR2A('=C1:R[-6]C1', 'D7', '=$A1:$A');
-  t.isR2A('=R[-6]C1:R[-6]', 'C7', '=$A1:1');
-  t.isR2A('=R[-6]:R[-6]C1', 'C7', '=$A1:1');
-  t.isR2A('=R1C[-2]:C[-2]', 'C6', '=A$1:A');
-  t.isR2A('=C[-2]:R1C[-2]', 'C6', '=A$1:A');
-  t.isR2A('=R1C[-3]:R1', 'D6', '=A$1:$1');
-  t.isR2A('=R1C[-3]:R1', 'D6', '=A$1:$1');
-  t.isR2A('=R1C1:C1', 'D6', '=$A$1:$A');
-  t.isR2A('=C1:R1C1', 'D6', '=$A$1:$A');
-  t.isR2A('=R1C1:R1', 'D6', '=$A$1:$1');
-  t.isR2A('=R1:R1C1', 'D6', '=$A$1:$1');
-  t.end();
-});
-
-test('translate bounds coords from RC to A1', t => {
-  t.isR2A('=C[-1]', 'A1', '=XFD:XFD');
-  t.isR2A('=C[-2]', 'A1', '=XFC:XFC');
-  t.isR2A('=RC[16383]', 'B1', '=A1');
-  t.isR2A('=RC[16383]', 'C1', '=B1');
-  t.isR2A('=R[-1]', 'A1', '=1048576:1048576');
-  t.isR2A('=R[-2]', 'A1', '=1048575:1048575');
-  t.isR2A('=R[1048575]C', 'A2', '=A1');
-  t.isR2A('=R[1048575]C', 'A3', '=A2');
-
-  t.isR2A('=R1:R1048576', 'A1', '=$1:$1048576');
-  t.isR2A('=C1:C16384', 'A1', '=$A:$XFD');
-  t.isR2A('=R1C1:R1048576C16384', 'A1', '=$A$1:$XFD$1048576');
-
-  const f1 = '=R[-1]C[-1]';
-  t.is(translateToA1(f1, 'A1', { wrapEdges: false }), '=#REF!', f1);
-
-  const tokens = addTokenMeta(tokenize('SUM(Sheet1!R[-1]C[-1])', { r1c1: true, withLocation: true }));
-  t.deepEqual(translateToA1(tokens, 'A1', { wrapEdges: false }), [
-    { type: FUNCTION, value: 'SUM', loc: [ 0, 3 ], index: 0, depth: 0 },
-    { type: OPERATOR, value: '(', loc: [ 3, 4 ], index: 1, depth: 1, groupId: 'fxg1' },
-    { type: ERROR, value: '#REF!', loc: [ 4, 9 ], index: 2, depth: 1 },
-    { type: OPERATOR, value: ')', loc: [ 9, 10 ], index: 3, depth: 1, groupId: 'fxg1' }
-  ], 'tokens with meta');
-
-  const f2 = '=Sheet4!R[-2]C[-2]:R[-1]C[-1]';
-  t.is(translateToA1(f2, 'B2', { wrapEdges: false }), '=#REF!', f2);
-
-  const f3 = '=Sheet4!R[-2]C[-2]:R[-1]C[-1]';
-  t.is(translateToA1(f3, 'B2', { wrapEdges: false, mergeRefs: false }), '=Sheet4!#REF!:A1', f3);
-
-  t.end();
-});
-
-test('translate mixed rel/abs coords from RC to A1', t => {
-  t.isR2A('=R1C[0]', 'B2', '=B$1');
-  t.isR2A('=R[4]C4', 'B4', '=$D8');
-  t.isR2A('=R[4]:R10', 'B4', '=8:$10');
-  t.isR2A('=C10:C[10]', 'B4', '=$J:L');
-  t.isR2A('=R1C1:R2C2', 'D4', '=$A$1:$B$2');
-  t.isR2A('=R[-1]C[-1]:R[2]C[2]', 'D4', '=C3:F6');
-  t.end();
-});
-
-test('translate involved formula from RC to A1', t => {
-  t.isR2A('=SUM(IF(RC[1],R2C5,R3C5),Sheet1!R2*Sheet2!C[-2])', 'D10',
-    '=SUM(IF(E10,$E$2,$E$3),Sheet1!$2:$2*Sheet2!B:B)');
-  t.end();
-});
-
-test('translate works with merged ranges', t => {
-  // This tests that:
-  // - Translate works with ranges that have context attached
-  // - If input is a tokenlist, output is also a tokenlist
-  // - If tokens have ranges, those ranges are adjusted to new token lengths
-  // - Properties added by addTokenMeta are preserved
-  const expr = '=SUM(IF(RC[1],R2C5,R3C5),Sheet1!R2*Sheet2!C[-2])';
-  const tokens = addTokenMeta(tokenize(expr, { withLocation: true, r1c1: true }));
-  const expected = [
-    { type: FX_PREFIX, value: '=', loc: [ 0, 1 ], index: 0, depth: 0 },
-    { type: FUNCTION, value: 'SUM', loc: [ 1, 4 ], index: 1, depth: 0 },
-    { type: OPERATOR, value: '(', loc: [ 4, 5 ], index: 2, depth: 1, groupId: 'fxg3' },
-    { type: FUNCTION, value: 'IF', loc: [ 5, 7 ], index: 3, depth: 1 },
-    { type: OPERATOR, value: '(', loc: [ 7, 8 ], index: 4, depth: 2, groupId: 'fxg1' },
-    { type: REF_RANGE, value: 'E10', loc: [ 8, 11 ], index: 5, depth: 2 },
-    { type: OPERATOR, value: ',', loc: [ 11, 12 ], index: 6, depth: 2 },
-    { type: REF_RANGE, value: '$E$2', loc: [ 12, 16 ], index: 7, depth: 2 },
-    { type: OPERATOR, value: ',', loc: [ 16, 17 ], index: 8, depth: 2 },
-    { type: REF_RANGE, value: '$E$3', loc: [ 17, 21 ], index: 9, depth: 2 },
-    { type: OPERATOR, value: ')', loc: [ 21, 22 ], index: 10, depth: 2, groupId: 'fxg1' },
-    { type: OPERATOR, value: ',', loc: [ 22, 23 ], index: 11, depth: 1 },
-    { type: REF_BEAM, value: 'Sheet1!$2:$2', loc: [ 23, 35 ], index: 12, depth: 1, groupId: 'fxg2' },
-    { type: OPERATOR, value: '*', loc: [ 35, 36 ], index: 13, depth: 1 },
-    { type: REF_BEAM, value: 'Sheet2!B:B', loc: [ 36, 46 ], index: 14, depth: 1 },
-    { type: OPERATOR, value: ')', loc: [ 46, 47 ], index: 15, depth: 1, groupId: 'fxg3' }
-  ];
-  t.deepEqual(translateToA1(tokens, 'D10'), expected, expr);
-  t.end();
-});
-
-test('translate works with xlsx mode references', t => {
-  const testExpr = (expr, anchor, expected) => {
-    const opts = { mergeRefs: true, xlsx: true, r1c1: true };
-    t.deepEqual(translateToA1(tokenize(expr, opts), anchor, opts), expected, expr);
-  };
-  testExpr("'[My Fancy Workbook.xlsx]'!R1C", 'B2', [
-    { type: REF_RANGE, value: "'[My Fancy Workbook.xlsx]'!B$1" }
-  ]);
-  testExpr('[Workbook.xlsx]!R1C', 'B2', [
-    { type: REF_RANGE, value: '[Workbook.xlsx]!B$1' }
-  ]);
-  testExpr('[Workbook.xlsx]Sheet1!R1C', 'B2', [
-    { type: REF_RANGE, value: '[Workbook.xlsx]Sheet1!B$1' }
-  ]);
-  testExpr('[Workbook.xlsx]!table[#data]', 'B2', [
-    { type: REF_STRUCT, value: '[Workbook.xlsx]!table[#data]' }
-  ]);
-  t.end();
-});
-
-test('translate works with trimmed ranges', t => {
-  const testExpr = (expr, anchor, expected) => {
-    const opts = { mergeRefs: true, xlsx: true, r1c1: true };
-    t.deepEqual(translateToA1(tokenize(expr, opts), anchor, opts), expected, expr);
-  };
-  testExpr('Sheet!R[-1]C[-1].:.RC*Sheet2!C[50].:.C[700]', 'B2', [
-    { type: 'range', value: 'Sheet!A1.:.B2' },
-    { type: 'operator', value: '*' },
-    { type: 'range_beam', value: 'Sheet2!AZ.:.ZZ' }
-  ]);
-  t.end();
-});

package/lib/translate-toRC.spec.js

@@ -1,197 +0,0 @@
-import { test, Test } from 'tape';
-import { translateToR1C1 } from './translate.js';
-import { tokenize } from './lexer.js';
-import { addTokenMeta } from './addTokenMeta.js';
-import { FUNCTION, FX_PREFIX, OPERATOR, REF_RANGE, REF_BEAM, REF_STRUCT } from './constants.js';
-
-Test.prototype.isA2R = function isTokens (expr, anchor, result) {
-  this.is(translateToR1C1(expr, anchor), result, expr);
-};
-
-test('translate absolute cells from A1 to RC', t => {
-  t.isA2R('=$A$1', 'B2', '=R1C1');
-  t.isA2R('=$A$2', 'B2', '=R2C1');
-  t.isA2R('=$A$3', 'B2', '=R3C1');
-  t.isA2R('=$B$1', 'B2', '=R1C2');
-  t.isA2R('=$B$2', 'B2', '=R2C2');
-  t.isA2R('=$B$3', 'B2', '=R3C2');
-  t.isA2R('=$C$1', 'B2', '=R1C3');
-  t.isA2R('=$C$2', 'B2', '=R2C3');
-  t.isA2R('=$C$3', 'B2', '=R3C3');
-  // absolute cells, anchor has no real effect
-  t.isA2R('=$A$1', 'Z19', '=R1C1');
-  t.isA2R('=$A$2', 'Z19', '=R2C1');
-  t.isA2R('=$A$3', 'Z19', '=R3C1');
-  t.isA2R('=$B$1', 'Z19', '=R1C2');
-  t.isA2R('=$B$2', 'Z19', '=R2C2');
-  t.isA2R('=$B$3', 'Z19', '=R3C2');
-  t.isA2R('=$C$1', 'Z19', '=R1C3');
-  t.isA2R('=$C$2', 'Z19', '=R2C3');
-  t.isA2R('=$C$3', 'Z19', '=R3C3');
-  t.end();
-});
-
-test('translate relative cells from A1 to RC', t => {
-  t.isA2R('=A1', 'B2', '=R[-1]C[-1]');
-  t.isA2R('=A2', 'B2', '=RC[-1]');
-  t.isA2R('=A3', 'B2', '=R[1]C[-1]');
-  t.isA2R('=B1', 'B2', '=R[-1]C');
-  t.isA2R('=B2', 'B2', '=RC');
-  t.isA2R('=B3', 'B2', '=R[1]C');
-  t.isA2R('=C1', 'B2', '=R[-1]C[1]');
-  t.isA2R('=C2', 'B2', '=RC[1]');
-  t.isA2R('=C3', 'B2', '=R[1]C[1]');
-  // relative cells, but with [0] notation
-  t.isA2R('=H11', 'I12', '=R[-1]C[-1]');
-  t.isA2R('=H12', 'I12', '=RC[-1]');
-  t.isA2R('=H13', 'I12', '=R[1]C[-1]');
-  t.isA2R('=I11', 'I12', '=R[-1]C');
-  t.isA2R('=I12', 'I12', '=RC');
-  t.isA2R('=I13', 'I12', '=R[1]C');
-  t.isA2R('=J11', 'I12', '=R[-1]C[1]');
-  t.isA2R('=J12', 'I12', '=RC[1]');
-  t.isA2R('=J13', 'I12', '=R[1]C[1]');
-  t.end();
-});
-
-test('translate rows from A1 to RC', t => {
-  t.isA2R('=2:2', 'B1', '=R[1]');
-  t.isA2R('=2:2', 'B2', '=R');
-  t.isA2R('=2:2', 'B3', '=R[-1]');
-  t.isA2R('=13:13', 'B13', '=R');
-  t.isA2R('=$2:$2', 'B2', '=R2');
-  t.isA2R('=2:$2', 'B2', '=R:R2');
-  t.isA2R('=11:9', 'Z10', '=R[-1]:R[1]');
-  t.end();
-});
-
-test('translate cols from A1 to RC', t => {
-  t.isA2R('=B:B', 'A2', '=C[1]');
-  t.isA2R('=B:B', 'B2', '=C');
-  t.isA2R('=B:B', 'C2', '=C[-1]');
-  t.isA2R('=Z:Z', 'Z2', '=C');
-  t.isA2R('=B:B', 'B2', '=C');
-  t.isA2R('=$B:$B', 'B2', '=C2');
-  t.isA2R('=B:$B', 'B2', '=C:C2');
-  t.isA2R('=N:L', 'M10', '=C[-1]:C[1]');
-  t.end();
-});
-
-test('translate partials from A1 to RC', t => {
-  t.isA2R('=A1:A', 'C6', '=R[-5]C[-2]:C[-2]');
-  t.isA2R('=A1:1', 'D6', '=R[-5]C[-3]:R[-5]');
-  t.isA2R('=$A1:$A', 'C7', '=R[-6]C1:C1');
-  t.isA2R('=$A:$A1', 'D7', '=R[-6]C1:C1');
-  t.isA2R('=$A1:1', 'C7', '=R[-6]C1:R[-6]');
-  t.isA2R('=1:$A1', 'C7', '=R[-6]C1:R[-6]');
-  t.isA2R('=A$1:A', 'C6', '=R1C[-2]:C[-2]');
-  t.isA2R('=A:A$1', 'C6', '=R1C[-2]:C[-2]');
-  t.isA2R('=A$1:$1', 'D6', '=R1C[-3]:R1');
-  t.isA2R('=$1:A$1', 'D6', '=R1C[-3]:R1');
-  t.isA2R('=$A$1:$A', 'D6', '=R1C1:C1');
-  t.isA2R('=$A:$A$1', 'D6', '=R1C1:C1');
-  t.isA2R('=$A$1:$1', 'D6', '=R1C1:R1');
-  t.isA2R('=$1:$A$1', 'D6', '=R1C1:R1');
-  t.end();
-});
-
-test('translate boundary coords from A1 to RC', t => {
-  t.isA2R('=XFD:XFD', 'A1', '=C[16383]');
-  t.isA2R('=A1', 'B1', '=RC[-1]');
-  t.isA2R('=B1', 'C1', '=RC[-1]');
-  t.isA2R('=1048576:1048576', 'A1', '=R[1048575]');
-  t.isA2R('=$1:$1048576', 'A1', '=R1:R1048576');
-  t.isA2R('=$A:$XFD', 'A1', '=C1:C16384');
-  t.isA2R('=$A$1:$XFD$1048576', 'A1', '=R1C1:R1048576C16384');
-  t.isA2R('=A1', 'A2', '=R[-1]C');
-  t.isA2R('=A2', 'A3', '=R[-1]C');
-  t.end();
-});
-
-test('translate mixed rel/abs coords from A1 to RC', t => {
-  t.isA2R('=B$1', 'B2', '=R1C');
-  t.isA2R('=$D8', 'B4', '=R[4]C4');
-  t.isA2R('=8:$10', 'B4', '=R[4]:R10');
-  t.isA2R('=$J:L', 'B4', '=C10:C[10]');
-  t.isA2R('=$A$1:$B$2', 'D4', '=R1C1:R2C2');
-  t.isA2R('=C3:F6', 'D4', '=R[-1]C[-1]:R[2]C[2]');
-  t.end();
-});
-
-test('translate involved cases from A1 to RC', t => {
-  t.isA2R('=SUM(IF(E10,$E$2,$E$3),Sheet1!$2:$2*Sheet2!B:B)', 'D10',
-    '=SUM(IF(RC[1],R2C5,R3C5),Sheet1!R2*Sheet2!C[-2])');
-
-  // make sure we don't get confused by structured, or named refs
-  t.isA2R('=A1+Table1[#Data]', 'D10', '=R[-9]C[-3]+Table1[#Data]');
-  t.isA2R('=A1+foobar', 'D10', '=R[-9]C[-3]+foobar');
-
-  // This [123]Sheet!A1 variant of the syntax is used internally in xlsx files
-  t.isA2R('=[2]Sheet1!A1', 'D10', '=[2]Sheet1!R[-9]C[-3]');
-
-  t.end();
-});
-
-test('translate works with merged ranges', t => {
-  // This tests that:
-  // - Translate works with ranges that have context attached
-  // - If input is a tokenlist, output is also a tokenlist
-  // - If tokens have ranges, those ranges are adjusted to new token lengths
-  // - Properties added by addTokenMeta are preserved
-  const expr = '=SUM(IF(E10,$E$2,$E$3),Sheet1!$2:$2*Sheet2!B:B)';
-  const tokens = addTokenMeta(tokenize(expr, { withLocation: true }));
-  const expected = [
-    { type: FX_PREFIX, value: '=', loc: [ 0, 1 ], index: 0, depth: 0 },
-    { type: FUNCTION, value: 'SUM', loc: [ 1, 4 ], index: 1, depth: 0 },
-    { type: OPERATOR, value: '(', loc: [ 4, 5 ], index: 2, depth: 1, groupId: 'fxg7' },
-    { type: FUNCTION, value: 'IF', loc: [ 5, 7 ], index: 3, depth: 1 },
-    { type: OPERATOR, value: '(', loc: [ 7, 8 ], index: 4, depth: 2, groupId: 'fxg4' },
-    { type: REF_RANGE, value: 'RC[1]', loc: [ 8, 13 ], index: 5, depth: 2, groupId: 'fxg1' },
-    { type: OPERATOR, value: ',', loc: [ 13, 14 ], index: 6, depth: 2 },
-    { type: REF_RANGE, value: 'R2C5', loc: [ 14, 18 ], index: 7, depth: 2, groupId: 'fxg2' },
-    { type: OPERATOR, value: ',', loc: [ 18, 19 ], index: 8, depth: 2 },
-    { type: REF_RANGE, value: 'R3C5', loc: [ 19, 23 ], index: 9, depth: 2, groupId: 'fxg3' },
-    { type: OPERATOR, value: ')', loc: [ 23, 24 ], index: 10, depth: 2, groupId: 'fxg4' },
-    { type: OPERATOR, value: ',', loc: [ 24, 25 ], index: 11, depth: 1 },
-    { type: REF_BEAM, value: 'Sheet1!R2', loc: [ 25, 34 ], index: 12, depth: 1, groupId: 'fxg5' },
-    { type: OPERATOR, value: '*', loc: [ 34, 35 ], index: 13, depth: 1 },
-    { type: REF_BEAM, value: 'Sheet2!C[-2]', loc: [ 35, 47 ], index: 14, depth: 1, groupId: 'fxg6' },
-    { type: OPERATOR, value: ')', loc: [ 47, 48 ], index: 15, depth: 1, groupId: 'fxg7' }
-  ];
-  t.deepEqual(translateToR1C1(tokens, 'D10'), expected, expr);
-  t.end();
-});
-
-test('translate works with xlsx mode', t => {
-  const testExpr = (expr, anchor, expected) => {
-    const opts = { mergeRefs: true, xlsx: true, r1c1: false };
-    const tokens = tokenize(expr, opts);
-    t.deepEqual(translateToR1C1(tokens, anchor, opts), expected, expr);
-  };
-  testExpr("'[My Fancy Workbook.xlsx]'!B$1", 'B2', [
-    { type: REF_RANGE, value: "'[My Fancy Workbook.xlsx]'!R1C" }
-  ]);
-  testExpr('[Workbook.xlsx]!B$1', 'B2', [
-    { type: REF_RANGE, value: '[Workbook.xlsx]!R1C' }
-  ]);
-  testExpr('[Workbook.xlsx]Sheet1!B$1', 'B2', [
-    { type: REF_RANGE, value: '[Workbook.xlsx]Sheet1!R1C' }
-  ]);
-  testExpr('[Workbook.xlsx]!table[#data]', 'B2', [
-    { type: REF_STRUCT, value: '[Workbook.xlsx]!table[#data]' }
-  ]);
-  t.end();
-});
-
-test('translate works with trimmed ranges', t => {
-  const testExpr = (expr, anchor, expected) => {
-    const opts = { mergeRefs: true, xlsx: true, r1c1: false };
-    t.deepEqual(translateToR1C1(tokenize(expr, opts), anchor, opts), expected, expr);
-  };
-  testExpr('Sheet!A1.:.B2*Sheet2!AZ.:.ZZ', 'B2', [
-    { type: 'range', value: 'Sheet!R[-1]C[-1].:.RC' },
-    { type: 'operator', value: '*' },
-    { type: 'range_beam', value: 'Sheet2!C[50].:.C[700]' }
-  ]);
-  t.end();
-});

package/lib/translate.js

@@ -1,239 +0,0 @@
-import { MAX_ROWS, MAX_COLS, ERROR } from './constants.js';
-import { fromA1, parseA1Ref, stringifyA1Ref } from './a1.js';
-import { parseR1C1Ref, stringifyR1C1Ref } from './rc.js';
-import { tokenize } from './lexer.js';
-import { isRange } from './isType.js';
-
-const calc = (abs, vX, aX) => {
-  if (vX == null) {
-    return null;
-  }
-  return abs ? vX : vX - aX;
-};
-
-const settings = {
-  withLocation: false,
-  mergeRefs: false,
-  allowTernary: true,
-  r1c1: false
-};
-
-/**
- * Translates ranges in a formula or list of tokens from absolute A1 syntax to
- * relative R1C1 syntax.
- *
- * Returns the same formula with the ranges translated. If an array of tokens
- * was supplied, then the same array is returned.
- *
- * ```js
- * translateToR1C1("=SUM(E10,$E$2,Sheet!$E$3)", "D10");
- * // => "=SUM(RC[1],R2C5,Sheet!R3C5)");
- * ```
- *
- * @param {(string | Array<Token>)} formula A string (an Excel formula) or a token list that should be adjusted.
- * @param {string} anchorCell A simple string reference to an A1 cell ID (`AF123` or`$C$5`).
- * @param {object} [options={}] The 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)
- * @param {boolean} [options.allowTernary=true]  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.
- * @returns {(string | Array<Token>)} A formula string or token list (depending on which was input)
- */
-export function translateToR1C1 (formula, anchorCell, { xlsx = false, allowTernary = true } = {}) {
-  const { top, left } = fromA1(anchorCell);
-  const isString = typeof formula === 'string';
-
-  const tokens = isString
-    ? tokenize(formula, { ...settings, xlsx, allowTernary })
-    : formula;
-
-  let offsetSkew = 0;
-  const refOpts = { xlsx, allowTernary };
-  tokens.forEach(token => {
-    if (isRange(token)) {
-      const tokenValue = token.value;
-      const ref = parseA1Ref(tokenValue, refOpts);
-      const d = ref.range;
-      const range = {};
-      range.r0 = calc(d.$top, d.top, top);
-      range.r1 = calc(d.$bottom, d.bottom, top);
-      range.c0 = calc(d.$left, d.left, left);
-      range.c1 = calc(d.$right, d.right, left);
-      range.$r0 = d.$top;
-      range.$r1 = d.$bottom;
-      range.$c0 = d.$left;
-      range.$c1 = d.$right;
-      if (d.trim) {
-        range.trim = d.trim;
-      }
-      ref.range = range;
-      token.value = stringifyR1C1Ref(ref, refOpts);
-      // if token includes offsets, those offsets are now likely wrong!
-      if (token.loc) {
-        token.loc[0] += offsetSkew;
-        offsetSkew += token.value.length - tokenValue.length;
-        token.loc[1] += offsetSkew;
-      }
-    }
-    else if (offsetSkew && token.loc) {
-      token.loc[0] += offsetSkew;
-      token.loc[1] += offsetSkew;
-    }
-  });
-
-  return isString
-    ? tokens.map(d => d.value).join('')
-    : tokens;
-}
-
-function toFixed (val, abs, base, max, wrapEdges = true) {
-  let v = val;
-  if (v != null && !abs) {
-    v = base + val;
-    // Excel "wraps around" when value goes out of lower bounds.
-    // It's a bit quirky on entry as Excel _really wants_ to re-rewite the
-    // references but the behaviour is consistent with INDIRECT:
-    // ... In A1: RC[-1] => R1C[16383].
-    if (v < 0) {
-      if (!wrapEdges) {
-        return NaN;
-      }
-      v = max + v + 1;
-    }
-    // ... In B1: =RC[16383] => =RC[-1]
-    if (v > max) {
-      if (!wrapEdges) {
-        return NaN;
-      }
-      v -= max + 1;
-    }
-  }
-  return v;
-}
-
-const defaultOptions = {
-  wrapEdges: true,
-  mergeRefs: true,
-  allowTernary: true,
-  xlsx: false
-};
-
-/**
- * Translates ranges in a formula or list of tokens from relative R1C1 syntax to
- * absolute A1 syntax.
- *
- * Returns the same formula with the ranges translated. If an array of tokens
- * was supplied, then the same array is returned.
- *
- * ```js
- * translateToA1("=SUM(RC[1],R2C5,Sheet!R3C5)", "D10");
- * // => "=SUM(E10,$E$2,Sheet!$E$3)");
- * ```
- *
- * If an input range is -1,-1 relative rows/columns and the anchor is A1, the
- * resulting range will (by default) wrap around to the bottom of the sheet
- * resulting in the range XFD1048576. This may not be what you want so may set
- * `wrapEdges` to false which will instead turn the range into a `#REF!` error.
- *
- * ```js
- * translateToA1("=R[-1]C[-1]", "A1");
- * // => "=XFD1048576");
- *
- * translateToA1("=R[-1]C[-1]", "A1", { wrapEdges: false });
- * // => "=#REF!");
- * ```
- *
- * Note that if you are passing in a list of tokens that was not created using
- * `mergeRefs` and you disable edge wrapping (or you simply set both options
- * to false), you can end up with a formula such as `=#REF!:B2` or
- * `=Sheet3!#REF!:F3`. These are valid formulas in the Excel formula language
- * and Excel will accept them, but they are not supported in Google Sheets.
- *
- * @param {(string | Array<Token>)} formula A string (an Excel formula) or a token list that should be adjusted.
- * @param {string} anchorCell A simple string reference to an A1 cell ID (`AF123` or`$C$5`).
- * @param {object} [options={}] The options
- * @param {boolean} [options.wrapEdges=true]  Wrap out-of-bounds ranges around sheet edges rather than turning them to #REF! errors
- * @param {boolean} [options.mergeRefs=true]   Should ranges be treated as whole references (`Sheet1!A1:B2`) or as separate tokens for each part: (`Sheet1`,`!`,`A1`,`:`,`B2`).
- * @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)
- * @param {boolean} [options.allowTernary=true]  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.
- * @returns {(string | Array<Token>)} A formula string or token list (depending on which was input)
- */
-export function translateToA1 (formula, anchorCell, options = defaultOptions) {
-  const anchor = fromA1(anchorCell);
-  const isString = typeof formula === 'string';
-  const opts = { ...defaultOptions, ...options };
-
-  const tokens = isString
-    ? tokenize(formula, {
-      withLocation: false,
-      mergeRefs: opts.mergeRefs,
-      xlsx: opts.xlsx,
-      allowTernary: opts.allowTernary,
-      r1c1: true
-    })
-    : formula;
-
-  let offsetSkew = 0;
-  const refOpts = { xlsx: opts.xlsx, allowTernary: opts.allowTernary };
-  tokens.forEach(token => {
-    if (isRange(token)) {
-      const tokenValue = token.value;
-      const ref = parseR1C1Ref(tokenValue, refOpts);
-      const d = ref.range;
-      const range = {};
-      const r0 = toFixed(d.r0, d.$r0, anchor.top, MAX_ROWS, opts.wrapEdges);
-      const r1 = toFixed(d.r1, d.$r1, anchor.top, MAX_ROWS, opts.wrapEdges);
-      if (r0 > r1) {
-        range.top = r1;
-        range.$top = d.$r1;
-        range.bottom = r0;
-        range.$bottom = d.$r0;
-      }
-      else {
-        range.top = r0;
-        range.$top = d.$r0;
-        range.bottom = r1;
-        range.$bottom = d.$r1;
-      }
-      const c0 = toFixed(d.c0, d.$c0, anchor.left, MAX_COLS, opts.wrapEdges);
-      const c1 = toFixed(d.c1, d.$c1, anchor.left, MAX_COLS, opts.wrapEdges);
-      if (c0 > c1) {
-        range.left = c1;
-        range.$left = d.$c1;
-        range.right = c0;
-        range.$right = d.$c0;
-      }
-      else {
-        range.left = c0;
-        range.$left = d.$c0;
-        range.right = c1;
-        range.$right = d.$c1;
-      }
-      if (d.trim) {
-        range.trim = d.trim;
-      }
-      if (isNaN(r0) || isNaN(r1) || isNaN(c0) || isNaN(c1)) {
-        // convert to ref error
-        token.type = ERROR;
-        token.value = '#REF!';
-        delete token.groupId;
-      }
-      else {
-        ref.range = range;
-        token.value = stringifyA1Ref(ref, refOpts);
-      }
-      // if token includes offsets, those offsets are now likely wrong!
-      if (token.loc) {
-        token.loc[0] += offsetSkew;
-        offsetSkew += token.value.length - tokenValue.length;
-        token.loc[1] += offsetSkew;
-      }
-    }
-    else if (offsetSkew && token.loc) {
-      token.loc[0] += offsetSkew;
-      token.loc[1] += offsetSkew;
-    }
-  });
-
-  return isString
-    ? tokens.map(d => d.value).join('')
-    : tokens;
-}

package/lib/translate.spec.js

@@ -1,21 +0,0 @@
-import { test, Test } from 'tape';
-import { translateToR1C1, translateToA1 } from './translate.js';
-
-Test.prototype.okayRoundTrip = function roundTrip (expr, anchor, options) {
-  const rc = translateToR1C1(expr, anchor, options);
-  const a1 = translateToA1(rc, anchor, options);
-  this.is(a1, expr, 'Round trip: ' + expr);
-};
-
-test('translate absolute cells from A1 to RC', t => {
-  t.okayRoundTrip('=Sheet1!$1:$1048576', 'A1');
-  t.okayRoundTrip('=D$1:$BJ$1048576', 'A1');
-  t.okayRoundTrip('=VLOOKUP(C7,Röðun,4,0)', 'A1');
-  t.okayRoundTrip('=COUNTIF(B$1442:B$1048576,$G1442)', 'A1');
-  t.okayRoundTrip('=IF(p2m<=D5,10,0)*scene_spend', 'A1');
-  t.okayRoundTrip('=(kwh_used_daily*kwhbtu*co2btu)/1000000', 'A1');
-  t.okayRoundTrip('=NOPLATT1+g1_+ROIC1+WACC+G1+g1_+G130+ROIC2+WACC+g2_+WACC+N', 'A1');
-  // FIXME: translate needs to be be able to specify allowTernary=false
-  t.okayRoundTrip('=foo:C3:D4', 'A1', { allowTernary: false });
-  t.end();
-});