[PERF] coordinate: faster xc parsing

This commit improves the parsing of references by removing
regular expressions, string allocations, splits, and concatenations, which
were heavily used in the previous implementation.

Total time spent in `toCartesian` when loading the BE Timesheet dashboard:

before:	84ms
after:	27ms (3x faster!)

Task: 4771804
X-original-commit: 24e0b5a
Part-of: #6429
Signed-off-by: Adrien Minne (adrm) <adrm@odoo.com>
Signed-off-by: Lucas Lefèvre (lul) <lul@odoo.com>

Author: LucasLefevre

src/helpers/coordinates.ts

@@ -3,6 +3,7 @@
 //------------------------------------------------------------------------------
 
 import { HeaderIndex, Position, RangePart } from "../types";
+import { TokenizingChars } from "./misc";
 
 /**
  * Convert a (col) number to the corresponding letter.
@@ -28,13 +29,17 @@ export function lettersToNumber(letters: string): number {
   let result = 0;
   const l = letters.length;
   for (let i = 0; i < l; i++) {
-    const charCode = letters.charCodeAt(i);
-    const colIndex = charCode >= 65 && charCode <= 90 ? charCode - 64 : charCode - 96;
+    const colIndex = charToNumber(letters[i]);
     result = result * 26 + colIndex;
   }
   return result - 1;
 }
 
+function charToNumber(char: string) {
+  const charCode = char.charCodeAt(0);
+  return charCode >= 65 && charCode <= 90 ? charCode - 64 : charCode - 96;
+}
+
 function isCharALetter(char: string) {
   return (char >= "A" && char <= "Z") || (char >= "a" && char <= "z");
 }
@@ -43,6 +48,40 @@ function isCharADigit(char: string) {
   return char >= "0" && char <= "9";
 }
 
+// we limit the max column to 3 letters and max row to 7 digits for performance reasons
+export const MAX_COL = lettersToNumber("ZZZ");
+export const MAX_ROW = 9999998;
+
+export function consumeSpaces(chars: TokenizingChars) {
+  while (chars.current === " ") {
+    chars.advanceBy(1);
+  }
+}
+
+export function consumeLetters(chars: TokenizingChars): number {
+  if (chars.current === "$") chars.advanceBy(1);
+  if (!chars.current || !isCharALetter(chars.current)) {
+    return -1;
+  }
+  let colCoordinate = 0;
+  while (chars.current && isCharALetter(chars.current)) {
+    colCoordinate = colCoordinate * 26 + charToNumber(chars.shift());
+  }
+  return colCoordinate;
+}
+
+export function consumeDigits(chars: TokenizingChars): number {
+  if (chars.current === "$") chars.advanceBy(1);
+  if (!chars.current || !isCharADigit(chars.current)) {
+    return -1;
+  }
+  let num = 0;
+  while (chars.current && isCharADigit(chars.current)) {
+    num = num * 10 + Number(chars.shift());
+  }
+  return num;
+}
+
 /**
  * Convert a "XC" coordinate to cartesian coordinates.
  *
@@ -53,37 +92,21 @@ function isCharADigit(char: string) {
  * Note: it also accepts lowercase coordinates, but not fixed references
  */
 export function toCartesian(xc: string): Position {
-  xc = xc.trim();
-
-  let letterPart = "";
-  let numberPart = "";
-  let i = 0;
+  const chars = new TokenizingChars(xc);
 
-  // Process letter part
-  if (xc[i] === "$") i++;
-  while (i < xc.length && isCharALetter(xc[i])) {
-    letterPart += xc[i++];
-  }
+  consumeSpaces(chars);
+  const letterPart = consumeLetters(chars);
 
-  if (letterPart.length === 0 || letterPart.length > 3) {
-    // limit to max 3 letters for performance reasons
+  if (letterPart === -1 || !chars.current) {
     throw new Error(`Invalid cell description: ${xc}`);
   }
 
-  // Process number part
-  if (xc[i] === "$") i++;
-  while (i < xc.length && isCharADigit(xc[i])) {
-    numberPart += xc[i++];
-  }
-
-  if (i !== xc.length || numberPart.length === 0 || numberPart.length > 7) {
-    // limit to max 7 numbers for performance reasons
-    throw new Error(`Invalid cell description: ${xc}`);
-  }
+  const num = consumeDigits(chars);
+  consumeSpaces(chars);
 
-  const col = lettersToNumber(letterPart);
-  const row = Number(numberPart) - 1;
-  if (isNaN(row)) {
+  const col = letterPart - 1;
+  const row = num - 1;
+  if (!chars.isOver() || col > MAX_COL || row > MAX_ROW) {
     throw new Error(`Invalid cell description: ${xc}`);
   }
   return { col, row };

tests/helpers/coordinates_helpers.test.ts

@@ -17,13 +17,15 @@ describe("numberToLetter", () => {
 describe("toCartesian", () => {
   test("basic functionality", () => {
     expect(toCartesian("A1")).toEqual(toPosition(0, 0));
+    expect(toCartesian("A01")).toEqual(toPosition(0, 0));
     expect(toCartesian("B1")).toEqual(toPosition(1, 0));
     expect(toCartesian("C5")).toEqual(toPosition(2, 4));
     expect(toCartesian("AA55")).toEqual(toPosition(26, 54));
     expect(toCartesian("c5")).toEqual(toPosition(2, 4));
     expect(toCartesian(" C5 ")).toEqual(toPosition(2, 4));
     expect(toCartesian("AAA1")).toEqual(toPosition(702, 0));
-    expect(toCartesian("A999999")).toEqual(toPosition(0, 999998));
+    expect(toCartesian("ZZZ1")).toEqual(toPosition(18277, 0));
+    expect(toCartesian("A9999999")).toEqual(toPosition(0, 9999998));
   });
 
   test("invalid ranges", () => {
@@ -35,6 +37,7 @@ describe("toCartesian", () => {
     expect(() => toCartesian("")).toThrow("Invalid cell description: ");
     expect(() => toCartesian(" ")).toThrow("Invalid cell description: ");
     expect(() => toCartesian("AAAA1")).toThrow("Invalid cell description: AAAA1");
+    expect(() => toCartesian("ZZZA1")).toThrow("Invalid cell description: ZZZA1");
     expect(() => toCartesian("A10000000")).toThrow("Invalid cell description: A10000000");
   });
 });