@borgar/fx 2.1.1 → 3.0.0

package/lib/rc.js

@@ -1,12 +1,14 @@
 /*
-  RC notation works differently from A1 in that we can't merge static references joined by `:`.
-  Merging can only work between references that are relative/absolute on the same axes, so:
-  R1C1:R2C2 will work, R[1]C1:R[2]C2 will also work, but R[1]C[1]:R2C2 cannot be represented
-  simply by a rectangle as without knowing the cell context.
+** RC notation works differently from A1 in that we can't merge static
+** references joined by `:`. Merging can only work between references
+** that are relative/absolute on the same axes, so:
+** - R1C1:R2C2 will work,
+** - R[1]C1:R[2]C2 will also work, but
+** - R[1]C[1]:R2C2 doesn't have a direct rectangle represention without context.
 */
-
-import { MAX_ROWS, MAX_COLS, tokenHandlersRefsRC } from './constants.js';
+import { MAX_ROWS, MAX_COLS } from './constants.js';
 import { parseRef } from './parseRef.js';
+import { stringifyPrefix } from './stringifyPrefix.js';
 
 function toCoord (value, isAbs) {
   if (isAbs) {
@@ -17,23 +19,37 @@ function toCoord (value, isAbs) {
 
 export function toRC (range) {
   const { r0, c0, r1, c1, $c0, $c1, $r0, $r1 } = range;
+  const nullR0 = r0 == null;
+  const nullR1 = r1 == null;
+  const nullC0 = c0 == null;
+  const nullC1 = c1 == null;
   // C:C
-  if (r0 === 0 && r1 === MAX_ROWS) {
+  if ((r0 === 0 && r1 >= MAX_ROWS) || (nullR0 && nullR1)) {
     const a = toCoord(c0, $c0);
     const b = toCoord(c1, $c1);
     return 'C' + (a === b ? a : a + ':C' + b);
   }
   // R:R
-  if (c0 === 0 && c1 === MAX_COLS) {
+  if ((c0 === 0 && c1 >= MAX_COLS) || (nullC0 && nullC1)) {
     const a = toCoord(r0, $r0);
     const b = toCoord(r1, $r1);
     return 'R' + (a === b ? a : a + ':R' + b);
   }
-  // RC:RC
   const s_r0 = toCoord(r0, $r0);
   const s_r1 = toCoord(r1, $r1);
   const s_c0 = toCoord(c0, $c0);
   const s_c1 = toCoord(c1, $c1);
+  // RC:R, RC:C
+  if (nullR0 || nullR1 || nullC0 || nullC1) {
+    return (
+      (nullR0 ? '' : 'R' + s_r0) +
+      (nullC0 ? '' : 'C' + s_c0) +
+      ':' +
+      (nullR1 ? '' : 'R' + s_r1) +
+      (nullC1 ? '' : 'C' + s_c1)
+    );
+  }
+  // RC:RC
   if (s_r0 !== s_r1 || s_c0 !== s_c1) {
     return 'R' + s_r0 + 'C' + s_c0 + ':R' + s_r1 + 'C' + s_c1;
   }
@@ -42,85 +58,167 @@ export function toRC (range) {
 }
 
 function parseRCPart (ref) {
-  let r0 = 0;
-  let c0 = 0;
-  let r1 = MAX_ROWS;
-  let c1 = MAX_COLS;
-  let $r0 = false;
-  let $c0 = false;
-  let $r1 = false;
-  let $c1 = false;
+  let r0 = null;
+  let c0 = null;
+  let $r0 = null;
+  let $c0 = null;
   // R part
   const rm = /^R(?:\[([+-]?\d+)\]|(\d+))?/.exec(ref);
   if (rm) {
     if (rm[1]) {
       r0 = parseInt(rm[1], 10);
+      $r0 = false;
     }
     else if (rm[2]) {
       r0 = parseInt(rm[2], 10) - 1;
       $r0 = true;
     }
-    r1 = r0;
-    $r1 = $r0;
+    else {
+      r0 = 0;
+      $r0 = false;
+    }
     ref = ref.slice(rm[0].length);
   }
-  else {
-    // r0 = 0, r1 = MAX_ROWS
-    $r0 = true;
-    $r1 = true;
-  }
   // C part
   const cm = /^C(?:\[([+-]?\d+)\]|(\d+))?/.exec(ref);
   if (cm) {
     if (cm[1]) {
       c0 = parseInt(cm[1], 10);
+      $c0 = false;
     }
     else if (cm[2]) {
       c0 = parseInt(cm[2], 10) - 1;
       $c0 = true;
     }
-    c1 = c0;
-    $c1 = $c0;
+    else {
+      c0 = 0;
+      $c0 = false;
+    }
     ref = ref.slice(cm[0].length);
   }
-  else {
-    // c0 = 0, c1 = MAX_COLS
-    $c0 = true;
-    $c1 = true;
-  }
   // must have at least one part (and nothing more)
   if ((!rm && !cm) || ref.length) {
     return null;
   }
-  return { r0, c0, r1, c1, $r0, $c0, $r1, $c1 };
+  return [ r0, c0, $r0, $c0 ];
 }
 
 export function fromRC (ref) {
+  let final = null;
   const [ part1, part2 ] = ref.split(':', 2);
   const range = parseRCPart(part1);
-  if (!range) {
-    return null;
-  }
-  if (range && part2) {
-    const extendTo = parseRCPart(part2);
-    if (extendTo) {
-      // Note: R[-1]C[-1]:R1C1 is only meaningful once we have an anchor
-      range.r1 = extendTo.r1;
-      range.c1 = extendTo.c1;
-      range.$r1 = extendTo.$r1;
-      range.$c1 = extendTo.$c1;
+  if (range) {
+    const [ r0, c0, $r0, $c0 ] = range;
+    if (part2) {
+      const extendTo = parseRCPart(part2);
+      if (extendTo) {
+        final = {};
+        const [ r1, c1, $r1, $c1 ] = extendTo;
+        // rows
+        if (r0 != null && r1 != null) {
+          final.r0 = $r0 === $r1 ? Math.min(r0, r1) : r0;
+          final.$r0 = $r0;
+          final.r1 = $r0 === $r1 ? Math.max(r0, r1) : r1;
+          final.$r1 = $r1;
+        }
+        else if (r0 != null && r1 == null) {
+          // partial RC:C
+          final.r0 = r0;
+          final.$r0 = $r0;
+          final.r1 = null;
+          final.$r1 = $r0;
+        }
+        else if (r0 == null && r1 != null) {
+          // partial C:RC
+          final.r0 = r1;
+          final.$r0 = $r1;
+          final.r1 = null;
+          final.$r1 = $r1;
+        }
+        else if (r0 == null && r1 == null) {
+          // C:C
+          final.r0 = null;
+          final.$r0 = false;
+          final.r1 = null;
+          final.$r1 = false;
+        }
+        // columns
+        if (c0 != null && c1 != null) {
+          final.c0 = $c0 === $c1 ? Math.min(c0, c1) : c0;
+          final.$c0 = $c0;
+          final.c1 = $c0 === $c1 ? Math.max(c0, c1) : c1;
+          final.$c1 = $c1;
+        }
+        else if (c0 != null && c1 == null) {
+          final.c0 = c0;
+          final.$c0 = $c0;
+          final.c1 = null;
+          final.$c1 = $c0;
+        }
+        else if (c0 == null && c1 != null) {
+          final.c0 = c1;
+          final.$c0 = $c1;
+          final.c1 = null;
+          final.$c1 = $c1;
+        }
+        else if (c0 == null && c1 == null) {
+          final.c0 = null;
+          final.$c0 = false;
+          final.c1 = null;
+          final.$c1 = false;
+        }
+      }
+      else {
+        return null;
+      }
+    }
+    // range only - no second part
+    else if (r0 != null && c0 == null) {
+      return {
+        r0: r0,
+        c0: null,
+        r1: r0,
+        c1: null,
+        $r0: $r0,
+        $c0: false,
+        $r1: $r0,
+        $c1: false
+      };
+    }
+    else if (r0 == null && c0 != null) {
+      return {
+        r0: null,
+        c0: c0,
+        r1: null,
+        c1: c0,
+        $r0: false,
+        $c0: $c0,
+        $r1: false,
+        $c1: $c0
+      };
     }
     else {
-      return null;
+      return {
+        r0: r0 || 0,
+        c0: c0 || 0,
+        r1: r0 || 0,
+        c1: c0 || 0,
+        $r0: $r0 || false,
+        $c0: $c0 || false,
+        $r1: $r0 || false,
+        $c1: $c0 || false
+      };
     }
   }
-  return range;
+  return final;
 }
 
-export function parseRCRef (ref, allow_named = true) {
-  const d = parseRef(ref, allow_named, tokenHandlersRefsRC);
+export function parseRCRef (ref, { allowNamed = true, allowTernary = false } = {}) {
+  const d = parseRef(ref, { allowNamed, allowTernary, r1c1: true });
   if (d && (d.r0 || d.name)) {
-    const range = d.r1 ? fromRC(d.r0 + ':' + d.r1) : fromRC(d.r0);
+    const range = d.r1
+      ? fromRC(d.r0 + ':' + d.r1)
+      : fromRC(d.r0);
     if (d.name || range) {
       d.range = range;
       delete d.r0;
@@ -134,8 +232,15 @@ export function parseRCRef (ref, allow_named = true) {
   return null;
 }
 
+export function stringifyRCRef (ref) {
+  return stringifyPrefix(ref) + (
+    ref.name ? ref.name : toRC(ref.range)
+  );
+}
+
 export default {
   to: toRC,
   from: fromRC,
-  parse: parseRCRef
+  parse: parseRCRef,
+  stringify: stringifyRCRef
 };

package/lib/rc.spec.js

@@ -0,0 +1,220 @@
+/* eslint-disable object-property-newline, object-curly-newline */
+import { test, Test } from 'tape';
+import { MAX_COLS, MAX_ROWS } from './constants.js';
+import { parseRCRef, stringifyRCRef, toRC } 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') {
+      // mix in some defaults so we don't have to write things out in full
+      result.range = {
+        r0: null, c0: null, r1: null, c1: null,
+        $r0: false, $c0: false, $r1: false, $c1: false,
+        ...result.range
+      };
+    }
+  }
+  this.deepEqual(parseRCRef(expr, opts), result, expr);
+};
+
+Test.prototype.isR1C1Rendered = function isTokens (range, expect, d) {
+  this.is(toRC(range, d), expect, expect);
+};
+
+test('parse single R1C1 references', t => {
+  // current row
+  t.isRCEqual('R', { range: { r0: 0, r1: 0 } });
+  t.isRCEqual('R[0]', { range: { r0: 0, r1: 0 } });
+  // row N (equivalent to 1:1)
+  t.isRCEqual('R0', { name: 'R0' });
+  t.isRCEqual('R1', { range: { r0: 0, r1: 0, $r0: true, $r1: true } });
+  t.isRCEqual('R10', { range: { r0: 9, r1: 9, $r0: true, $r1: true } });
+  // row following current
+  t.isRCEqual('R[1]', { range: { r0: 1, r1: 1 } });
+  // row preceding current
+  t.isRCEqual('R[-1]', { range: { r0: -1, r1: -1 } });
+
+  // current column
+  t.isRCEqual('C', { range: { c0: 0, c1: 0 } });
+  t.isRCEqual('C[0]', { range: { c0: 0, c1: 0 } });
+  // column N (equivalent to A:A)
+  t.isRCEqual('C0', { name: 'C0' });
+  t.isRCEqual('C1', { range: { c0: 0, c1: 0, $c0: true, $c1: true } });
+  t.isRCEqual('C10', { range: { c0: 9, c1: 9, $c0: true, $c1: true } });
+  // column following current
+  t.isRCEqual('C[1]', { range: { c0: 1, c1: 1 } });
+  // column preceding current
+  t.isRCEqual('C[-1]', { range: { c0: -1, c1: -1 } });
+  // current cell
+  t.isRCEqual('RC', { range: { r0: 0, c0: 0, r1: 0, c1: 0 } });
+  t.isRCEqual('R0C0', { name: 'R0C0' });
+  // fixed cell
+  t.isRCEqual('R1C1', { range: { r0: 0, c0: 0, r1: 0, c1: 0, $c0: true, $c1: true, $r0: true, $r1: true } });
+  t.isRCEqual('R10C8', { range: { r0: 9, c0: 7, r1: 9, c1: 7, $c0: true, $c1: true, $r0: true, $r1: true } });
+  t.isRCEqual('R-10C-8', null);
+
+  // relative parts
+  t.isRCEqual('R[2]C', { range: { r0: 2, c0: 0, r1: 2, c1: 0 } });
+  t.isRCEqual('R[-2]C', { range: { r0: -2, c0: 0, r1: -2, c1: 0 } });
+  t.isRCEqual('RC[3]', { range: { r0: 0, c0: 3, r1: 0, c1: 3 } });
+  t.isRCEqual('RC[-3]', { range: { r0: 0, c0: -3, r1: 0, c1: -3 } });
+  t.isRCEqual('R[2]C[4]', { range: { r0: 2, c0: 4, r1: 2, c1: 4 } });
+  t.isRCEqual('R[-2]C[-4]', { range: { r0: -2, c0: -4, r1: -2, c1: -4 } });
+  // mixed fixed and relative
+  t.isRCEqual('R[9]C9', { range: { r0: 9, c0: 8, r1: 9, c1: 8, $c0: true, $c1: true } });
+  t.isRCEqual('R9C[9]', { range: { r0: 8, c0: 9, r1: 8, c1: 9, $r0: true, $r1: true } });
+
+  // out of bounds
+  t.isRCEqual('R1048577', { name: 'R1048577' });
+  t.isRCEqual('R[1048576]', null);
+  t.isRCEqual('C16385', { name: 'C16385' });
+  t.isRCEqual('C[16384]', null);
+
+  t.end();
+});
+
+test('R1C1 partial ranges', t => {
+  const opts = { allowTernary: true };
+  // partials are not allowed by defult
+  t.isRCEqual('R[-5]C[-2]:C[-2]', null);
+  t.isRCEqual('R1:R1C1', null);
+  // beam type partials A1:A @ C6
+  t.isRCEqual('R[-5]C[-2]:C[-2]', { range: { r0: -5, c0: -2, c1: -2 } }, opts);
+  t.isRCEqual('C[-2]:R[-5]C[-2]', { range: { r0: -5, c0: -2, c1: -2 } }, opts);
+  t.isRCEqual('R[-5]C[-3]:R[-5]', { range: { r0: -5, c0: -3, r1: -5 } }, opts);
+  t.isRCEqual('R[-5]:R[-5]C[-3]', { range: { r0: -5, c0: -3, r1: -5 } }, opts);
+  t.isRCEqual('R[-6]C1:C1', { range: { r0: -6, c0: 0, c1: 0, $c0: true, $c1: true } }, opts);
+  t.isRCEqual('C1:R[-6]C1', { range: { r0: -6, c0: 0, c1: 0, $c0: true, $c1: true } }, opts);
+  t.isRCEqual('R[-6]C1:R[-6]', { range: { r0: -6, c0: 0, r1: -6, $c0: true, $c1: true } }, opts);
+  t.isRCEqual('R[-6]:R[-6]C1', { range: { r0: -6, c0: 0, r1: -6, $c0: true, $c1: true } }, opts);
+  t.isRCEqual('R1C[-2]:C[-2]', { range: { r0: 0, c0: -2, c1: -2, $r0: true, $c0: false, $r1: true, $c1: false } }, opts);
+  t.isRCEqual('C[-2]:R1C[-2]', { range: { r0: 0, c0: -2, c1: -2, $r0: true, $c0: false, $r1: true, $c1: false } }, opts);
+  t.isRCEqual('R1C[-3]:R1', { range: { r0: 0, c0: -3, r1: 0, $r0: true, $c0: false, $r1: true, $c1: false } }, opts);
+  t.isRCEqual('R1:R1C[-3]', { range: { r0: 0, c0: -3, r1: 0, $r0: true, $c0: false, $r1: true, $c1: false } }, opts);
+  t.isRCEqual('R1C1:C1', { range: { r0: 0, c0: 0, c1: 0, $r0: true, $c0: true, $r1: true, $c1: true } }, opts);
+  t.isRCEqual('C1:R1C1', { range: { r0: 0, c0: 0, c1: 0, $r0: true, $c0: true, $r1: true, $c1: true } }, opts);
+  t.isRCEqual('R1C1:R1', { range: { r0: 0, c0: 0, r1: 0, $r0: true, $c0: true, $r1: true, $c1: true } }, opts);
+  t.isRCEqual('R1:R1C1', { range: { r0: 0, c0: 0, r1: 0, $r0: true, $c0: true, $r1: true, $c1: true } }, opts);
+  // range type partials P1:10 @ F6
+  t.isRCEqual('R[-5]C[10]:R[4]', { range: { r0: -5, c0: 10, r1: 4 } }, opts);
+  t.isRCEqual('R[4]:R[-5]C[10]', { range: { r0: -5, c0: 10, r1: 4 } }, opts);
+  t.isRCEqual('R[-6]C16:R[3]', { range: { r0: -6, c0: 15, r1: 3, $c0: true, $c1: true } }, opts);
+  t.isRCEqual('R[3]:R[-6]C16', { range: { r0: -6, c0: 15, r1: 3, $c0: true, $c1: true } }, opts);
+  t.isRCEqual('R1C[10]:R10', { range: { r0: 0, c0: 10, r1: 9, $r0: true, $c0: false, $r1: true, $c1: false } }, opts);
+  t.isRCEqual('R10:R1C[10]', { range: { r0: 0, c0: 10, r1: 9, $r0: true, $c0: false, $r1: true, $c1: false } }, opts);
+  t.isRCEqual('R1C16:R10', { range: { r0: 0, c0: 15, r1: 9, $r0: true, $c0: true, $r1: true, $c1: true } }, opts);
+  t.isRCEqual('R10:R1C16', { range: { r0: 0, c0: 15, r1: 9, $r0: true, $c0: true, $r1: true, $c1: true } }, opts);
+  t.end();
+});
+
+test('parse joined R1C1 references', t => {
+  // all "mirrored" refs are equivalent of the non mirrored counterparts...
+  t.isRCEqual('R:R', { range: { r0: 0, r1: 0 } });
+  t.isRCEqual('R[0]:R[0]', { range: { r0: 0, r1: 0 } });
+  t.isRCEqual('R1:R1', { range: { r0: 0, r1: 0, $r0: true, $r1: true } });
+  t.isRCEqual('R10:R10', { range: { r0: 9, r1: 9, $r0: true, $r1: true } });
+  t.isRCEqual('R[1]:R[1]', { range: { r0: 1, r1: 1 } });
+  t.isRCEqual('R[-1]:R[-1]', { range: { r0: -1, r1: -1 } });
+
+  t.isRCEqual('C:C', { range: { c0: 0, c1: 0 } });
+  t.isRCEqual('C[0]:C[0]', { range: { c0: 0, c1: 0 } });
+  t.isRCEqual('C1:C1', { range: { c0: 0, c1: 0, $c0: true, $c1: true } });
+  t.isRCEqual('C10:C10', { range: { c0: 9, c1: 9, $c0: true, $c1: true } });
+  t.isRCEqual('C[1]:C[1]', { range: { c0: 1, c1: 1 } });
+  t.isRCEqual('C[-1]:C[-1]', { range: { c0: -1, c1: -1 } });
+
+  t.isRCEqual('R0:R0', null);
+  t.isRCEqual('C0:C0', null);
+  t.isRCEqual('R[9]C9:R[9]C9', { range: { r0: 9, c0: 8, r1: 9, c1: 8, $c0: true, $c1: true } });
+  t.isRCEqual('R9C[9]:R9C[9]', { range: { r0: 8, c0: 9, r1: 8, c1: 9, $r0: true, $r1: true } });
+  t.isRCEqual('R[1]C[1]:R1C1', { range: { r0: 1, c0: 1, r1: 0, c1: 0, $c1: true, $r1: true } });
+  t.isRCEqual('R[1]C[1]:R1C1', { range: { r0: 1, c0: 1, r1: 0, c1: 0, $c1: true, $r1: true } });
+  t.isRCEqual('R1C1:R2C2', { range: { r0: 0, c0: 0, r1: 1, c1: 1, $c0: true, $c1: true, $r0: true, $r1: true } });
+  t.isRCEqual('R2C2:R1C1', { range: { r0: 0, c0: 0, r1: 1, c1: 1, $c0: true, $c1: true, $r0: true, $r1: true } });
+  // single thing
+  t.isRCEqual('C1:C3', { range: { c0: 0, c1: 2, $c0: true, $c1: true } });
+  t.isRCEqual('R[1]:R3', { range: { r0: 1, r1: 2, $r1: true } });
+  t.isRCEqual('R[1]C1:R1C[-1]', { range: { r0: 1, c0: 0, r1: 0, c1: -1, $c0: true, $r1: true, $c1: false } });
+  // many things
+  t.isRCEqual('R:C', null);
+  t.isRCEqual('R:RC', null);
+  t.isRCEqual('RC:R', null);
+  t.isRCEqual('RC:C', null);
+  t.isRCEqual('C:R', null);
+  t.isRCEqual('C:RC', null);
+  t.end();
+});
+
+test('R1C1 serialization', t => {
+  // ray
+  t.isR1C1Rendered({ r0: 0, c0: 0, r1: 0, c1: MAX_COLS }, 'R');
+  t.isR1C1Rendered({ r0: 0, r1: 0 }, 'R');
+  t.isR1C1Rendered({ r0: 0, c0: 0, r1: 0, c1: MAX_COLS, $r0: true, $r1: true }, 'R1');
+  t.isR1C1Rendered({ r0: 0, r1: 0, $r0: true, $r1: true }, 'R1');
+  t.isR1C1Rendered({ r0: 1, c0: 0, r1: 1, c1: MAX_COLS }, 'R[1]');
+  t.isR1C1Rendered({ r0: 1, r1: 1 }, 'R[1]');
+  // ray
+  t.isR1C1Rendered({ r0: 0, c0: 0, r1: MAX_ROWS, c1: 0 }, 'C');
+  t.isR1C1Rendered({ c0: 0, c1: 0 }, 'C');
+  t.isR1C1Rendered({ r0: 0, c0: 0, r1: MAX_ROWS, c1: 0, $c0: true, $c1: true }, 'C1');
+  t.isR1C1Rendered({ c0: 0, c1: 0, $c0: true, $c1: true }, 'C1');
+  t.isR1C1Rendered({ r0: 0, c0: 1, r1: MAX_ROWS, c1: 1 }, 'C[1]');
+  t.isR1C1Rendered({ c0: 1, c1: 1 }, 'C[1]');
+  // rect
+  t.isR1C1Rendered({ r0: 0, c0: 0, r1: 0, c1: 0 }, 'RC');
+  t.isR1C1Rendered({ r0: 0, c0: 0, r1: 0, c1: 0, $c0: true, $c1: true, $r0: true, $r1: true }, 'R1C1');
+  t.isR1C1Rendered({ r0: 9, c0: 7, r1: 9, c1: 7, $c0: true, $c1: true, $r0: true, $r1: true }, 'R10C8');
+  t.isR1C1Rendered({ r0: 2, c0: 0, r1: 2, c1: 0 }, 'R[2]C');
+  t.isR1C1Rendered({ r0: -2, c0: 0, r1: -2, c1: 0 }, 'R[-2]C');
+  t.isR1C1Rendered({ r0: 0, c0: 3, r1: 0, c1: 3 }, 'RC[3]');
+  t.isR1C1Rendered({ r0: 0, c0: -3, r1: 0, c1: -3 }, 'RC[-3]');
+  t.isR1C1Rendered({ r0: 2, c0: 4, r1: 2, c1: 4 }, 'R[2]C[4]');
+  t.isR1C1Rendered({ r0: -2, c0: -4, r1: -2, c1: -4 }, 'R[-2]C[-4]');
+  t.isR1C1Rendered({ r0: 9, c0: 8, r1: 9, c1: 8, $c0: true, $c1: true }, 'R[9]C9');
+  t.isR1C1Rendered({ r0: 8, c0: 9, r1: 8, c1: 9, $r0: true, $r1: true }, 'R9C[9]');
+  t.isR1C1Rendered({ r0: 1, c0: 1, r1: 0, c1: 0, $c1: true, $r1: true }, 'R[1]C[1]:R1C1');
+  t.isR1C1Rendered({ r0: 0, c0: 0, r1: 1, c1: 1, $c0: true, $c1: true, $r0: true, $r1: true }, 'R1C1:R2C2');
+  t.isR1C1Rendered({ c0: 0, c1: 2, $c0: true, $c1: true }, 'C1:C3');
+  t.isR1C1Rendered({ r0: 1, r1: 2, $r1: true }, 'R[1]:R3');
+  t.isR1C1Rendered({ r0: 1, c0: 0, r1: 0, c1: -1, $c0: true, $r1: true }, 'R[1]C1:R1C[-1]');
+  // partial
+  t.isR1C1Rendered({ r0: -5, c0: -2, c1: -2 }, 'R[-5]C[-2]:C[-2]');
+  t.isR1C1Rendered({ r0: -5, c0: -3, r1: -5 }, 'R[-5]C[-3]:R[-5]');
+  t.isR1C1Rendered({ r0: -6, c0: 0, c1: 0, $c0: true, $c1: true }, 'R[-6]C1:C1');
+  t.isR1C1Rendered({ r0: -6, c0: 0, r1: -6, $c0: true, $c1: true }, 'R[-6]C1:R[-6]');
+  t.isR1C1Rendered({ r0: 0, c0: -2, c1: -2, $r0: true, $r1: true }, 'R1C[-2]:C[-2]');
+  t.isR1C1Rendered({ r0: 0, c0: -3, r1: 0, $r0: true, $r1: true }, 'R1C[-3]:R1');
+  t.isR1C1Rendered({ r0: 0, c0: 0, c1: 0, $r0: true, $c0: true, $r1: true, $c1: true }, 'R1C1:C1');
+  t.isR1C1Rendered({ r0: 0, c0: 0, r1: 0, $r0: true, $c0: true, $r1: true, $c1: true }, 'R1C1:R1');
+  t.isR1C1Rendered({ r0: -5, c0: 10, r1: 4 }, 'R[-5]C[10]:R[4]');
+  t.isR1C1Rendered({ r0: -6, c0: 15, r1: 3, $c0: true, $c1: true }, 'R[-6]C16:R[3]');
+  t.isR1C1Rendered({ r0: 0, c0: 10, r1: 9, $r0: true, $r1: true }, 'R1C[10]:R10');
+  t.isR1C1Rendered({ r0: 0, c0: 15, r1: 9, $r0: true, $c0: true, $r1: true, $c1: true }, 'R1C16:R10');
+  t.end();
+});
+
+test('stringifyRCRef', t => {
+  const rangeA1 = { r0: 2, c0: 4, r1: 2, c1: 4 };
+  const testRef = (ref, expect) => t.is(stringifyRCRef(ref), expect, expect);
+  testRef({ range: rangeA1 }, 'R[2]C[4]');
+  testRef({ context: [ 'Sheet1' ], range: rangeA1 }, 'Sheet1!R[2]C[4]');
+  testRef({ context: [ 'Sheet 1' ], range: rangeA1 }, "'Sheet 1'!R[2]C[4]");
+  testRef({ context: [ 'MyFile.xlsx', 'Sheet1' ], range: rangeA1 }, '[MyFile.xlsx]Sheet1!R[2]C[4]');
+  testRef({ context: [ 'My File.xlsx', 'Sheet1' ], range: rangeA1 }, "'[My File.xlsx]Sheet1'!R[2]C[4]");
+  testRef({ context: [ 'MyFile.xlsx' ], range: rangeA1 }, 'MyFile.xlsx!R[2]C[4]');
+  testRef({ context: [ 'My File.xlsx' ], range: rangeA1 }, "'My File.xlsx'!R[2]C[4]");
+  testRef({ name: 'foo' }, 'foo');
+  testRef({ context: [ 'Sheet1' ], name: 'foo' }, 'Sheet1!foo');
+  testRef({ context: [ 'Sheet 1' ], name: 'foo' }, "'Sheet 1'!foo");
+  testRef({ context: [ 'MyFile.xlsx', 'Sheet1' ], name: 'foo' }, '[MyFile.xlsx]Sheet1!foo');
+  testRef({ context: [ 'My File.xlsx', 'Sheet1' ], name: 'foo' }, "'[My File.xlsx]Sheet1'!foo");
+  testRef({ context: [ 'MyFile.xlsx' ], name: 'foo' }, 'MyFile.xlsx!foo');
+  testRef({ context: [ 'My File.xlsx' ], name: 'foo' }, "'My File.xlsx'!foo");
+  t.end();
+});

package/lib/stringifyPrefix.js

@@ -0,0 +1,21 @@
+const reBannedChars = /[^0-9A-Za-z._¡¤§¨ª\u00ad¯-\uffff]/;
+
+export function stringifyPrefix (ref) {
+  let pre = '';
+  let quote = 0;
+  let nth = 0;
+  const context = ref.context || [];
+  for (let i = context.length; i > -1; i--) {
+    const scope = context[i];
+    if (scope) {
+      const part = (nth % 2) ? '[' + scope + ']' : scope;
+      pre = part + pre;
+      quote += reBannedChars.test(scope);
+      nth++;
+    }
+  }
+  if (quote) {
+    pre = "'" + pre.replace(/'/g, "''") + "'";
+  }
+  return pre ? pre + '!' : pre;
+}

package/lib/{translate-toA1-test.js → translate-toA1.spec.js}

@@ -1,8 +1,8 @@
 import { test, Test } from 'tape';
 import { translateToA1 } from './translate.js';
 
-Test.prototype.isR2A = function isTokens (expr, anchor, result) {
-  this.is(translateToA1(expr, anchor), result, expr);
+Test.prototype.isR2A = function isTokens (expr, anchor, result, debug) {
+  this.is(translateToA1(expr, anchor, debug), result, expr);
 };
 
 test('translate absolute cells from RC to A1', t => {
@@ -79,6 +79,24 @@ test('translate cols from RC to A1', t => {
   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 out of bounds coords from RC to A1', t => {
   t.isR2A('=C[-1]', 'A1', '=XFD:XFD');
   t.isR2A('=C[-2]', 'A1', '=XFC:XFC');

package/lib/{translate-toRC-test.js → translate-toRC.spec.js}

@@ -74,6 +74,24 @@ test('translate cols from A1 to RC', t => {
   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 out of boundary coords from A1 to RC', t => {
   t.isA2R('=XFD:XFD', 'A1', '=C[16383]');
   t.isA2R('=A1', 'B1', '=RC[-1]');
@@ -99,4 +117,3 @@ test('translate involved formula from A1 to RC', t => {
     '=SUM(IF(RC[1],R2C5,R3C5),Sheet1!R2*Sheet2!C[-2])');
   t.end();
 });
-