@borgar/fx 4.1.0 → 4.3.0

package/lib/parseRef.js

@@ -12,13 +12,61 @@ import {
 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) {
-  const m = /(?:\[(.+?)\])?([^[\]]+?)$/.exec(contextString);
-  if (m) {
-    const [ , a, b ] = m;
-    const context = [ a, b ].filter(Boolean);
-    return { context };
+  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, "'");
@@ -30,9 +78,14 @@ 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 => {
-  if (t && t.type === CONTEXT) { return splitContext(t.value); }
-  if (t && t.type === CONTEXT_QUOTE) { return splitContext(unquote(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 };
 
@@ -62,15 +115,24 @@ export function parseRef (ref, opts) {
     allowTernary: false,
     allowNamed: true,
     r1c1: false,
+    xlsx: false,
     ...opts
   };
   const tokens = getTokens(ref, lexersRefs, options);
-  const refData = {
-    context: [],
-    r0: '',
-    r1: '',
-    name: ''
-  };
+  const refData = options.xlsx
+    ? {
+      workbookName: '',
+      sheetName: '',
+      r0: '',
+      r1: '',
+      name: ''
+    }
+    : {
+      context: [],
+      r0: '',
+      r1: '',
+      name: ''
+    };
   // discard the "="-prefix if it is there
   if (tokens.length && tokens[0].type === FX_PREFIX) {
     tokens.shift();
@@ -80,7 +142,7 @@ export function parseRef (ref, opts) {
     const data = { ...refData };
     if (runs[i].length === tokens.length) {
       const valid = runs[i].every((parse, j) => {
-        const d = parse(tokens[j]);
+        const d = parse(tokens[j], options);
         Object.assign(data, d);
         return d;
       });

package/lib/parseRef.spec.js

@@ -0,0 +1,60 @@
+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/parser.js

@@ -475,7 +475,7 @@ prefix('{', function () {
  * because it does not recognize reference context tokens.
  *
  * The AST Abstract Syntax Tree's format is documented in
- * [AST_format.md][./AST_format.md]
+ * [AST_format.md](./AST_format.md)
  *
  * @see nodeTypes
  * @param {(string | Array<Object>)} formula An Excel formula string (an Excel expression) or an array of tokens.
@@ -486,7 +486,8 @@ prefix('{', function () {
  * @param {boolean} [options.permitArrayRanges=false]  Ranges are allowed as elements of arrays. This is a feature in Google Sheets while Excel does not allow it.
  * @param {boolean} [options.permitArrayCalls=false]  Function calls are allowed as elements of arrays. This is a feature in Google Sheets while Excel does not allow it.
  * @param {boolean} [options.r1c1=false]  Ranges are expected to be in the R1C1 style format rather than the more popular A1 style.
- * @param {boolean} [options.withLocation=true]  Nodes will include source position offsets to the tokens: `{ loc: [ start, end ] }`
+ * @param {boolean} [options.withLocation=false]  Nodes will include source position offsets to the tokens: `{ loc: [ start, end ] }`
+ * @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)
  * @return {Object} An AST of nodes
  */
 export function parse (source, options) {

package/lib/parser.spec.js

@@ -828,3 +828,14 @@ test('does not tolerate unterminated tokens', t => {
     { permitArrayCalls: true });
   t.end();
 });
+
+test('parser can permit xlsx mode references', t => {
+  t.isInvalidExpr('=SUM([Workbook.xlsx]!A1+[Workbook.xlsx]!Table1[#Data])');
+  t.isParsed('=SUM([Workbook.xlsx]!A1+[Workbook.xlsx]!Table1[#Data])',
+    { type: 'CallExpression', callee: { type: 'Identifier', name: 'SUM' }, arguments: [
+      { type: 'BinaryExpression', operator: '+', arguments: [
+        { type: 'ReferenceIdentifier', value: '[Workbook.xlsx]!A1' },
+        { type: 'ReferenceIdentifier', value: '[Workbook.xlsx]!Table1[#Data]' } ] } ] },
+    { xlsx: true });
+  t.end();
+});

package/lib/rc.js

@@ -8,7 +8,7 @@
 */
 import { MAX_ROWS, MAX_COLS } from './constants.js';
 import { parseRef } from './parseRef.js';
-import { stringifyPrefix } from './stringifyPrefix.js';
+import { stringifyPrefix, stringifyPrefixAlt } from './stringifyPrefix.js';
 
 const clamp = (min, val, max) => Math.min(Math.max(val, min), max);
 
@@ -268,10 +268,11 @@ export function fromR1C1 (ref) {
  * @param {Object} [options={}]  Options
  * @param {boolean} [options.allowNamed=true]  Enable parsing names as well as ranges.
  * @param {boolean} [options.allowTernary=false]  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.
+ * @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)
  * @return {(Object|null)} An object representing a valid reference or null if it is invalid.
  */
-export function parseR1C1Ref (refString, { allowNamed = true, allowTernary = false } = {}) {
-  const d = parseRef(refString, { allowNamed, allowTernary, r1c1: true });
+export function parseR1C1Ref (refString, { allowNamed = true, allowTernary = false, xlsx = false } = {}) {
+  const d = parseRef(refString, { allowNamed, allowTernary, xlsx, r1c1: true });
   if (d && (d.r0 || d.name)) {
     const range = d.r1
       ? fromR1C1(d.r0 + ':' + d.r1)
@@ -310,10 +311,15 @@ export function parseR1C1Ref (refString, { allowNamed = true, allowTernary = fal
  * ```
  *
  * @param {Object} refObject A reference object
+ * @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)
  * @return {Object} The reference in R1C1-style string format
  */
-export function stringifyR1C1Ref (refObject) {
-  return stringifyPrefix(refObject) + (
+export function stringifyR1C1Ref (refObject, { xlsx = false } = {}) {
+  const prefix = xlsx
+    ? stringifyPrefixAlt(refObject)
+    : stringifyPrefix(refObject);
+  return prefix + (
     refObject.name ? refObject.name : toR1C1(refObject.range)
   );
 }

package/lib/rc.spec.js

@@ -3,24 +3,32 @@ import { test, Test } from 'tape';
 import { MAX_COLS, MAX_ROWS } from './constants.js';
 import { parseR1C1Ref, stringifyR1C1Ref, toR1C1 } from './rc.js';
 
-Test.prototype.isRCEqual = function isTokens (expr, result, opts) {
-  if (result) {
-    result = {
-      context: [],
-      name: '',
-      range: null,
-      ...result
-    };
-    if (result.range && typeof result.range === 'object') {
+Test.prototype.isRCEqual = function isTokens (expr, expect, opts) {
+  if (expect) {
+    expect = (opts?.xlsx)
+      ? {
+        workbookName: '',
+        sheetName: '',
+        name: '',
+        range: null,
+        ...expect
+      }
+      : {
+        context: [],
+        name: '',
+        range: null,
+        ...expect
+      };
+    if (expect.range && typeof expect.range === 'object') {
       // mix in some defaults so we don't have to write things out in full
-      result.range = {
+      expect.range = {
         r0: null, c0: null, r1: null, c1: null,
         $r0: false, $c0: false, $r1: false, $c1: false,
-        ...result.range
+        ...expect.range
       };
     }
   }
-  this.deepEqual(parseR1C1Ref(expr, opts), result, expr);
+  this.deepEqual(parseR1C1Ref(expr, opts), expect, expr);
 };
 
 Test.prototype.isR1C1Rendered = function isTokens (range, expect, d) {
@@ -151,6 +159,108 @@ test('parse joined R1C1 references', t => {
   t.end();
 });
 
+test('parse R1C1 ranges in XLSX mode', t => {
+  const opts = { xlsx: true };
+  const rcRange = { r0: 0, c0: 0, r1: 0, c1: 0 };
+  t.isRCEqual('[1]!RC', {
+    workbookName: '1',
+    sheetName: '',
+    range: rcRange
+  }, opts);
+
+  t.isRCEqual('[Workbook.xlsx]!RC', {
+    workbookName: 'Workbook.xlsx',
+    sheetName: '',
+    range: rcRange
+  }, opts);
+
+  t.isRCEqual('[1]Sheet1!RC', {
+    workbookName: '1',
+    sheetName: 'Sheet1',
+    range: rcRange
+  }, opts);
+
+  t.isRCEqual('[Workbook.xlsx]Sheet1!RC', {
+    workbookName: 'Workbook.xlsx',
+    sheetName: 'Sheet1',
+    range: rcRange
+  }, opts);
+
+  t.isRCEqual('[4]!name', {
+    workbookName: '4',
+    sheetName: '',
+    name: 'name'
+  }, opts);
+
+  t.isRCEqual('[Workbook.xlsx]!name', {
+    workbookName: 'Workbook.xlsx',
+    sheetName: '',
+    name: 'name'
+  }, opts);
+
+  t.isRCEqual('[16]Sheet1!name', {
+    workbookName: '16',
+    sheetName: 'Sheet1',
+    name: 'name'
+  }, opts);
+
+  t.isRCEqual('[Workbook.xlsx]Sheet1!name', {
+    workbookName: 'Workbook.xlsx',
+    sheetName: 'Sheet1',
+    name: 'name'
+  }, opts);
+
+  t.isRCEqual("='[1]'!RC", {
+    workbookName: '1',
+    sheetName: '',
+    range: rcRange
+  }, opts);
+
+  t.isRCEqual("='[Workbook.xlsx]'!RC", {
+    workbookName: 'Workbook.xlsx',
+    sheetName: '',
+    range: rcRange
+  }, opts);
+
+  t.isRCEqual("'[1]Sheet1'!RC", {
+    workbookName: '1',
+    sheetName: 'Sheet1',
+    range: rcRange
+  }, opts);
+
+  t.isRCEqual("'[Workbook.xlsx]Sheet1'!RC", {
+    workbookName: 'Workbook.xlsx',
+    sheetName: 'Sheet1',
+    range: rcRange
+  }, opts);
+
+  t.isRCEqual("'[4]'!name", {
+    workbookName: '4',
+    sheetName: '',
+    name: 'name'
+  }, opts);
+
+  t.isRCEqual("'[Workbook.xlsx]'!name", {
+    workbookName: 'Workbook.xlsx',
+    sheetName: '',
+    name: 'name'
+  }, opts);
+
+  t.isRCEqual("'[16]Sheet1'!name", {
+    workbookName: '16',
+    sheetName: 'Sheet1',
+    name: 'name'
+  }, opts);
+
+  t.isRCEqual("'[Workbook.xlsx]Sheet1'!name", {
+    workbookName: 'Workbook.xlsx',
+    sheetName: 'Sheet1',
+    name: 'name'
+  }, opts);
+
+  t.end();
+});
+
 test('R1C1 serialization', t => {
   // ray
   t.isR1C1Rendered({ r0: 0, c0: 0, r1: 0, c1: MAX_COLS }, 'R');
@@ -229,3 +339,26 @@ test('stringifyR1C1Ref', t => {
   testRef({ context: [ 'My File.xlsx' ], name: 'foo' }, "'My File.xlsx'!foo");
   t.end();
 });
+
+test('stringifyR1C1Ref in XLSX mode', t => {
+  const rangeA1 = { r0: 2, c0: 4, r1: 2, c1: 4 };
+  const testRef = (ref, expect) => t.is(stringifyR1C1Ref(ref, { xlsx: true }), expect, expect);
+  testRef({ range: rangeA1 }, 'R[2]C[4]');
+  testRef({ sheetName: 'Sheet1', range: rangeA1 }, 'Sheet1!R[2]C[4]');
+  testRef({ sheetName: 'Sheet 1', range: rangeA1 }, "'Sheet 1'!R[2]C[4]");
+  testRef({ workbookName: 'MyFile.xlsx', sheetName: 'Sheet1', range: rangeA1 }, '[MyFile.xlsx]Sheet1!R[2]C[4]');
+  testRef({ workbookName: 'My File.xlsx', sheetName: 'Sheet1', range: rangeA1 }, "'[My File.xlsx]Sheet1'!R[2]C[4]");
+  testRef({ workbookName: 'MyFile.xlsx', range: rangeA1 }, '[MyFile.xlsx]!R[2]C[4]');
+  testRef({ workbookName: 'My File.xlsx', range: rangeA1 }, "'[My File.xlsx]'!R[2]C[4]");
+  testRef({ name: 'foo' }, 'foo');
+  testRef({ sheetName: 'Sheet1', name: 'foo' }, 'Sheet1!foo');
+  testRef({ sheetName: 'Sheet 1', name: 'foo' }, "'Sheet 1'!foo");
+  testRef({ workbookName: 'MyFile.xlsx', sheetName: 'Sheet1', name: 'foo' }, '[MyFile.xlsx]Sheet1!foo');
+  testRef({ workbookName: 'My File.xlsx', sheetName: 'Sheet1', name: 'foo' }, "'[My File.xlsx]Sheet1'!foo");
+  testRef({ workbookName: 'MyFile.xlsx', name: 'foo' }, '[MyFile.xlsx]!foo');
+  testRef({ workbookName: 'My File.xlsx', name: 'foo' }, "'[My File.xlsx]'!foo");
+  // ignore .context
+  testRef({ context: [ 'MyFile.xlsx', 'Sheet1' ], range: rangeA1 }, 'R[2]C[4]');
+  testRef({ context: [ 'MyFile.xlsx', 'Sheet1' ], name: 'foo' }, 'foo');
+  t.end();
+});

package/lib/sr.js

@@ -1,5 +1,5 @@
 import { parseRef } from './parseRef.js';
-import { stringifyPrefix } from './stringifyPrefix.js';
+import { stringifyPrefix, stringifyPrefixAlt } from './stringifyPrefix.js';
 
 const re_SRcolumnB = /^\[('['#@[\]]|[^'#@[\]])+\]/i;
 const re_SRcolumnN = /^([^#@[\]:]+)/i;
@@ -186,19 +186,28 @@ export function parseSRange (raw) {
  * @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)
  * @return {(Object|null)} An object representing a valid reference or null if it is invalid.
  */
-export function parseStructRef (ref, opts = {}) {
+export function parseStructRef (ref, opts = { xlsx: false }) {
   const r = parseRef(ref, opts);
   if (r && r.struct) {
     const structData = parseSRange(r.struct);
     if (structData && structData.length === r.struct.length) {
-      return {
-        context: r.context,
-        table: r.name,
-        columns: structData.columns,
-        sections: structData.sections
-      };
+      return opts.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;
@@ -230,10 +239,15 @@ function toSentenceCase (str) {
  * ```
  *
  * @param {Object} refObject A structured reference object
+ * @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)
  * @return {Object} The structured reference in string format
  */
-export function stringifyStructRef (ref) {
-  let s = stringifyPrefix(ref);
+export function stringifyStructRef (ref, { xlsx = false } = {}) {
+  let s = xlsx
+    ? stringifyPrefixAlt(ref)
+    : stringifyPrefix(ref);
+
   if (ref.table) {
     s += ref.table;
   }

package/lib/sr.spec.js

@@ -4,13 +4,22 @@ import { parseStructRef, stringifyStructRef } from './sr.js';
 
 Test.prototype.isSREqual = function isSREqual (expr, expect, opts) {
   if (expect) {
-    expect = {
-      context: [],
-      table: '',
-      columns: [],
-      sections: [],
-      ...expect
-    };
+    expect = opts?.xlsx
+      ? {
+        workbookName: '',
+        sheetName: '',
+        table: '',
+        columns: [],
+        sections: [],
+        ...expect
+      }
+      : {
+        context: [],
+        table: '',
+        columns: [],
+        sections: [],
+        ...expect
+      };
   }
   this.deepEqual(parseStructRef(expr, opts), expect, expr);
 };
@@ -67,6 +76,18 @@ test('parse structured references', t => {
     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.end();
 });
 
@@ -177,3 +198,68 @@ test('serialize structured references', t => {
   t.end();
 });
 
+test('structured references parse and serialize 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.is(
+    stringifyStructRef({
+      context: [ 'Lorem', 'Ipsum' ],
+      columns: [ 'foo' ]
+    }, { xlsx: true }),
+    '[foo]',
+    'context prop is ignored in xlsx mode'
+  );
+  t.is(
+    stringifyStructRef({
+      workbookName: 'Lorem',
+      sheetName: 'Ipsum',
+      columns: [ 'foo' ]
+    }, { xlsx: false }),
+    '[foo]',
+    'workbookName+sheetName props are ignored in default mode'
+  );
+  t.is(
+    stringifyStructRef({
+      workbookName: 'Lorem',
+      sheetName: 'Ipsum',
+      columns: [ 'foo' ]
+    }, { xlsx: true }),
+    '[Lorem]Ipsum![foo]',
+    'workbookName+sheetName props are rendered correctly'
+  );
+  t.is(
+    stringifyStructRef({
+      workbookName: 'Lorem',
+      columns: [ 'foo' ]
+    }, { xlsx: true }),
+    '[Lorem]![foo]',
+    'workbookName prop is rendered correctly'
+  );
+  t.is(
+    stringifyStructRef({
+      sheetName: 'Ipsum',
+      columns: [ 'foo' ]
+    }, { xlsx: true }),
+    'Ipsum![foo]',
+    'sheetName prop is rendered correctly'
+  );
+  t.end();
+});
+

package/lib/stringifyPrefix.js

@@ -19,3 +19,21 @@ export function stringifyPrefix (ref) {
   }
   return pre ? pre + '!' : pre;
 }
+
+export function stringifyPrefixAlt (ref) {
+  let pre = '';
+  let quote = 0;
+  const { workbookName, sheetName } = ref;
+  if (workbookName) {
+    pre += '[' + workbookName + ']';
+    quote += reBannedChars.test(workbookName);
+  }
+  if (sheetName) {
+    pre += sheetName;
+    quote += reBannedChars.test(sheetName);
+  }
+  if (quote) {
+    pre = "'" + pre.replace(/'/g, "''") + "'";
+  }
+  return pre ? pre + '!' : pre;
+}

package/lib/translate-toA1.spec.js

@@ -2,10 +2,10 @@ 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 } from './constants.js';
+import { ERROR, FUNCTION, FX_PREFIX, OPERATOR, REF_RANGE, REF_BEAM, REF_STRUCT } from './constants.js';
 
-Test.prototype.isR2A = function isTokens (expr, anchor, result) {
-  this.is(translateToA1(expr, anchor), result, expr);
+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 => {
@@ -175,3 +175,23 @@ test('translate works with merged ranges', t => {
   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();
+});