@borgar/fx 4.11.2 → 4.13.0

package/lib/lexers/lexRangeA1.js

@@ -0,0 +1,130 @@
+/* eslint-disable no-mixed-operators */
+import { REF_RANGE, REF_BEAM, REF_TERNARY, MAX_COLS, MAX_ROWS } from '../constants.js';
+import { advRangeOp } from './advRangeOp.js';
+import { canEndRange, canEndPartialRange } from './canEndRange.js';
+
+function advA1Col (str, pos) {
+  // [A-Z]{1,3}
+  const start = pos;
+  if (str.charCodeAt(pos) === 36) { // $
+    pos++;
+  }
+  const stop = pos + 3;
+  let col = 0;
+  do {
+    const c = str.charCodeAt(pos);
+    if (c >= 65 && c <= 90) { // A-Z
+      col = 26 * col + c - 64;
+      pos++;
+    }
+    else if (c >= 97 && c <= 122) { // a-z
+      col = 26 * col + c - 96;
+      pos++;
+    }
+    else {
+      break;
+    }
+  }
+  while (pos < stop && pos < str.length);
+  return (col && col <= MAX_COLS + 1) ? pos - start : 0;
+}
+
+function advA1Row (str, pos) {
+  // [1-9][0-9]{0,6}
+  const start = pos;
+  if (str.charCodeAt(pos) === 36) { // $
+    pos++;
+  }
+  const stop = pos + 7;
+  let row = 0;
+  let c = str.charCodeAt(pos);
+  if (c >= 49 && c <= 57) { // 1-9
+    row = row * 10 + c - 48;
+    pos++;
+    do {
+      c = str.charCodeAt(pos);
+      if (c >= 48 && c <= 57) { // 0-9
+        row = row * 10 + c - 48;
+        pos++;
+      }
+      else {
+        break;
+      }
+    }
+    while (pos < stop && pos < str.length);
+  }
+  return (row && row <= MAX_ROWS + 1) ? pos - start : 0;
+}
+
+export function lexRangeA1 (str, pos, options) {
+  let p = pos;
+  const left = advA1Col(str, p);
+  let right = 0;
+  let bottom = 0;
+  if (left) {
+    // TLBR: could be A1:A1
+    // TL R: could be A1:A (if allowTernary)
+    // TLB : could be A1:1 (if allowTernary)
+    //  LBR: could be A:A1 (if allowTernary)
+    //  L R: could be A:A
+    p += left;
+    const top = advA1Row(str, p);
+    p += top;
+    const op = advRangeOp(str, p);
+    const preOp = p;
+    if (op) {
+      p += op;
+      right = advA1Col(str, p);
+      p += right;
+      bottom = advA1Row(str, p);
+      p += bottom;
+      if (top && bottom && right) {
+        if (canEndRange(str, p) && options.mergeRefs) {
+          return { type: REF_RANGE, value: str.slice(pos, p) };
+        }
+      }
+      else if (!top && !bottom) {
+        if (canEndRange(str, p)) {
+          return { type: REF_BEAM, value: str.slice(pos, p) };
+        }
+      }
+      else if (options.allowTernary && (bottom || right)) {
+        if (canEndPartialRange(str, p)) {
+          return { type: REF_TERNARY, value: str.slice(pos, p) };
+        }
+      }
+    }
+    // LT  : this is A1
+    if (top && canEndRange(str, preOp)) {
+      return { type: REF_RANGE, value: str.slice(pos, preOp) };
+    }
+  }
+  else {
+    // T B : could be 1:1
+    // T BR: could be 1:A1 (if allowTernary)
+    const top = advA1Row(str, p);
+    if (top) {
+      p += top;
+      const op = advRangeOp(str, p);
+      if (op) {
+        p += op;
+        right = advA1Col(str, p);
+        if (right) {
+          p += right;
+        }
+        bottom = advA1Row(str, p);
+        p += bottom;
+        if (right && bottom && options.allowTernary) {
+          if (canEndPartialRange(str, p)) {
+            return { type: REF_TERNARY, value: str.slice(pos, p) };
+          }
+        }
+        if (!right && bottom) {
+          if (canEndRange(str, p)) {
+            return { type: REF_BEAM, value: str.slice(pos, p) };
+          }
+        }
+      }
+    }
+  }
+}

package/lib/lexers/lexRangeR1C1.js

@@ -0,0 +1,142 @@
+/* eslint-disable no-mixed-operators */
+import { REF_RANGE, REF_BEAM, REF_TERNARY, MAX_COLS, MAX_ROWS } from '../constants.js';
+import { advRangeOp } from './advRangeOp.js';
+import { canEndRange } from './canEndRange.js';
+
+const BR_OPEN = 91; // [
+const BR_CLOSE = 93; // ]
+const UC_R = 82;
+const LC_R = 114;
+const UC_C = 67;
+const LC_C = 99;
+const PLUS = 43;
+const MINUS = 45;
+
+// C
+// C\[[+-]?\d+\]
+// C[1-9][0-9]{0,4}
+// R
+// R\[[+-]?\d+\]
+// R[1-9][0-9]{0,6}
+function lexR1C1Part (str, pos, isRow = false) {
+  const start = pos;
+  const c0 = str.charCodeAt(pos);
+  if ((isRow ? c0 === UC_R || c0 === LC_R : c0 === UC_C || c0 === LC_C)) {
+    pos++;
+    let digits = 0;
+    let value = 0;
+    let stop = str.length;
+    const c1 = str.charCodeAt(pos);
+    let c;
+    let sign = 1;
+    const relative = c1 === BR_OPEN;
+    if (relative) {
+      stop = Math.min(stop, pos + (isRow ? 8 : 6));
+      pos++;
+      // allow +-
+      c = str.charCodeAt(pos);
+      if (c === PLUS || c === MINUS) {
+        pos++;
+        stop++;
+        sign = c === MINUS ? -1 : 1;
+      }
+    }
+    else if (c1 < 49 || c1 > 57 || isNaN(c1)) {
+      // char must be 1-9, or part is either just "R" or "C"
+      return 1;
+    }
+
+    do {
+      const c = str.charCodeAt(pos);
+      if (c >= 48 && c <= 57) { // 0-9
+        value = value * 10 + c - 48;
+        digits++;
+        pos++;
+      }
+      else {
+        break;
+      }
+    }
+    while (pos < stop);
+
+    const MAX = isRow ? MAX_ROWS : MAX_COLS;
+    if (relative) {
+      const c = str.charCodeAt(pos);
+      if (c !== BR_CLOSE) {
+        return 0;
+      }
+      // isRow: next char must not be a number!
+      pos++;
+      value *= sign;
+      return (digits && (-MAX <= value) && (value <= MAX))
+        ? pos - start
+        : 0;
+    }
+    // isRow: next char must not be a number!
+    return (digits && value <= (MAX + 1)) ? pos - start : 0;
+  }
+  return 0;
+}
+
+export function lexRangeR1C1 (str, pos, options) {
+  let p = pos;
+  // C1
+  // C1:C1
+  // C1:R1C1  --partial
+  // R1
+  // R1:R1
+  // R1:R1C1  --partial
+  // R1C1
+  // R1C1:C1  --partial
+  // R1C1:R1  --partial
+  const r1 = lexR1C1Part(str, p, true);
+  p += r1;
+  const c1 = lexR1C1Part(str, p);
+  p += c1;
+  if (c1 || r1) {
+    const op = advRangeOp(str, p);
+    const preOp = p;
+    if (op) {
+      p += op;
+      const r2 = lexR1C1Part(str, p, true); // R1
+      p += r2;
+      const c2 = lexR1C1Part(str, p); // C1
+      p += c2;
+
+      // C1:R2C2  --partial
+      // R1:R2C2  --partial
+      // R1C1:C2  --partial
+      // R1C1:R2  --partial
+      if (
+        (r1 && !c1 && r2 && c2) ||
+        (!r1 && c1 && r2 && c2) ||
+        (r1 && c1 && r2 && !c2) ||
+        (r1 && c1 && !r2 && c2)
+      ) {
+        if (options.allowTernary && canEndRange(str, p)) {
+          return { type: REF_TERNARY, value: str.slice(pos, p) };
+        }
+      }
+      // C1:C2 -- beam
+      // R1:R2 -- beam
+      else if (
+        (c1 && c2 && !r1 && !r2) ||
+        (!c1 && !c2 && r1 && r2)
+      ) {
+        if (canEndRange(str, p)) {
+          return { type: REF_BEAM, value: str.slice(pos, p) };
+        }
+      }
+      // Note: we do not capture R1C1:R1C1, mergeRefTokens will join the parts
+    }
+    // R1
+    // C1
+    // R1C1
+    if (canEndRange(str, preOp)) {
+      return {
+        type: (r1 && c1) ? REF_RANGE : REF_BEAM,
+        value: str.slice(pos, preOp)
+      };
+    }
+  }
+}

package/lib/lexers/lexRangeTrim.js

@@ -0,0 +1,25 @@
+import { OPERATOR_TRIM } from '../constants.js';
+
+const PERIOD = 46;
+const COLON = 58;
+
+export function lexRangeTrim (str, pos) {
+  const c0 = str.charCodeAt(pos);
+  if (c0 === PERIOD || c0 === COLON) {
+    const c1 = str.charCodeAt(pos + 1);
+    if (c0 !== c1) {
+      if (c1 === COLON) {
+        return {
+          type: OPERATOR_TRIM,
+          value: str.slice(pos, pos + (str.charCodeAt(pos + 2) === PERIOD ? 3 : 2))
+        };
+      }
+      else if (c1 === PERIOD) {
+        return {
+          type: OPERATOR_TRIM,
+          value: str.slice(pos, pos + 2)
+        };
+      }
+    }
+  }
+}

package/lib/lexers/lexRefOp.js

@@ -0,0 +1,18 @@
+import { OPERATOR } from '../constants.js';
+import { advRangeOp } from './advRangeOp.js';
+
+const EXCL = 33; // !
+
+export function lexRefOp (str, pos, opts) {
+  // in R1C1 mode we only allow [ '!' ]
+  if (str.charCodeAt(pos) === EXCL) {
+    return { type: OPERATOR, value: str[pos] };
+  }
+  if (!opts.r1c1) {
+    // in A1 mode we allow [ '!' ] + [ ':', '.:', ':.', '.:.']
+    const opLen = advRangeOp(str, pos);
+    if (opLen) {
+      return { type: OPERATOR, value: str.slice(pos, pos + opLen) };
+    }
+  }
+}

package/lib/lexers/lexString.js

@@ -0,0 +1,22 @@
+/* eslint-disable no-mixed-operators */
+import { STRING } from '../constants.js';
+
+const QUOT = 34;
+
+export function lexString (str, pos) {
+  const start = pos;
+  if (str.charCodeAt(pos) === QUOT) {
+    pos++;
+    while (pos < str.length) {
+      const c = str.charCodeAt(pos);
+      if (c === QUOT) {
+        pos++;
+        if (str.charCodeAt(pos) !== QUOT) {
+          return { type: STRING, value: str.slice(start, pos) };
+        }
+      }
+      pos++;
+    }
+    return { type: STRING, value: str.slice(start, pos), unterminated: true };
+  }
+}

package/lib/lexers/lexStructured.js

@@ -0,0 +1,25 @@
+/* eslint-disable no-mixed-operators */
+import { parseSRange } from '../parseSRange.js';
+import { REF_STRUCT } from '../constants.js';
+import { isWS } from './lexWhitespace.js';
+
+const EXCL = 33; // !
+
+export function lexStructured (str, pos) {
+  const structData = parseSRange(str, pos);
+  if (structData && structData.length) {
+    // we have a match for a valid SR
+    let i = structData.length;
+    // skip tailing whitespace
+    while (isWS(str.charCodeAt(pos + i))) {
+      i++;
+    }
+    // and ensure that it isn't followed by a !
+    if (str.charCodeAt(pos + i) !== EXCL) {
+      return {
+        type: REF_STRUCT,
+        value: structData.token
+      };
+    }
+  }
+}

package/lib/lexers/lexWhitespace.js

@@ -0,0 +1,30 @@
+import { WHITESPACE } from '../constants.js';
+
+export function isWS (c) {
+  return (
+    c === 0x9 ||
+    c === 0xB ||
+    c === 0xC ||
+    c === 0xD ||
+    c === 0x20 ||
+    c === 0xA0 ||
+    c === 0x1680 ||
+    c === 0x2028 ||
+    c === 0x2029 ||
+    c === 0x202f ||
+    c === 0x205f ||
+    c === 0x3000 ||
+    c === 0xfeff ||
+    (c >= 0x2000 && c <= 0x200a)
+  );
+}
+
+export function lexWhitespace (str, pos) {
+  const start = pos;
+  while (isWS(str.charCodeAt(pos))) {
+    pos++;
+  }
+  if (pos !== start) {
+    return { type: WHITESPACE, value: str.slice(start, pos) };
+  }
+}

package/lib/lexers/sets.js

@@ -0,0 +1,38 @@
+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.js

@@ -50,19 +50,23 @@ validRunsMerge.forEach(run => packList(run.concat().reverse(), refPartsTree));
 // attempt to match a backwards run of tokens from a given point
 // to a path in the tree
 const matcher = (tokens, currNode, anchorIndex, index = 0) => {
-  const token = tokens[anchorIndex - index];
-  if (token) {
-    const key = (token.type === OPERATOR) ? token.value : token.type;
-    if (key in currNode) {
-      return matcher(tokens, currNode[key], anchorIndex, index + 1);
+  let i = index;
+  let node = currNode;
+  const max = tokens.length - index;
+  // keep walking as long as the next backward token matches a child key
+  while (i <= max) {
+    const token = tokens[anchorIndex - i];
+    if (token) {
+      const key = (token.type === OPERATOR) ? token.value : token.type;
+      if (key in node) {
+        node = node[key];
+        i += 1;
+        continue;
+      }
     }
+    // can't advance further; accept only if current node is a terminal
+    return node[END] ? i : 0;
   }
-  if (currNode[END]) {
-    // we may end here so this is a match
-    return index;
-  }
-  // no match
-  return 0;
 };
 
 /**
@@ -81,19 +85,25 @@ export function mergeRefTokens (tokenlist) {
   // that controls what can be joined.
   for (let i = tokenlist.length - 1; i >= 0; i--) {
     let token = tokenlist[i];
-    const valid = matcher(tokenlist, refPartsTree, i);
-    if (valid) {
-      const toMerge = tokenlist.slice(i - valid + 1, i + 1);
-      // use the meta properties from the "first" token (right-most token)
-      token = { ...token };
-      token.value = toMerge.map(d => d.value).join('');
-      // adjust the offsets to include all the text
-      if (token.loc && toMerge[0].loc) {
-        token.loc[0] = toMerge[0].loc[0];
+    const type = token.type;
+    // Quick check if token type could even start a valid run
+    if (type === REF_RANGE || type === REF_BEAM || type === REF_TERNARY ||
+        type === REF_NAMED || type === REF_STRUCT) {
+      const valid = matcher(tokenlist, refPartsTree, i);
+      if (valid > 1) {
+        token = { ...token, value: '' };
+        const start = i - valid + 1;
+        for (let j = start; j <= i; j++) {
+          token.value += tokenlist[j].value;
+        }
+        // adjust the offsets to include all the text
+        if (token.loc && tokenlist[start].loc) {
+          token.loc[0] = tokenlist[start].loc[0];
+        }
+        i -= valid - 1;
       }
-      i -= valid - 1;
     }
-    finalTokens.unshift(token);
+    finalTokens[finalTokens.length] = token;
   }
-  return finalTokens;
+  return finalTokens.reverse();
 }

package/lib/parseRef.js

@@ -9,7 +9,7 @@ import {
   REF_STRUCT,
   OPERATOR
 } from './constants.js';
-import { lexersRefs } from './lexerParts.js';
+import { lexersRefs } from './lexers/sets.js';
 import { getTokens } from './lexer.js';
 
 // Liberally split a context string up into parts.