Extract transformCoordToPoint, getCellValue and getCellRangeValue to utils and test

Fix formatting

Fix lint warnings

Author: iddan

src/Spreadsheet.test.tsx

@@ -3,7 +3,7 @@
  */
 
 import React from "react";
-import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { fireEvent, render, screen } from "@testing-library/react";
 import Spreadsheet, { Props } from "./Spreadsheet";
 import * as Matrix from "./matrix";
 import * as Types from "./types";

src/Spreadsheet.tsx

@@ -34,9 +34,11 @@ import {
   range,
   readTextFromClipboard,
   writeTextToClipboard,
-  getComputedValue,
   getSelectedCSV,
   calculateSpreadsheetSize,
+  transformCoordToPoint,
+  getCellRangeValue,
+  getCellValue,
 } from "./util";
 import "./Spreadsheet.css";
 
@@ -388,40 +390,27 @@ const Spreadsheet = <CellType extends Types.CellBase>(
     formulaParser.on("callCellValue", (cellCoord, done) => {
       let value;
       try {
-        const point = {
-          row: cellCoord.row.index,
-          column: cellCoord.column.index,
-        };
-        const cell = Matrix.get(point, store.getState().data);
-        value = getComputedValue<CellType, CellType["value"]>({
-          cell,
-          formulaParser: formulaParser,
-        });
+        const point = transformCoordToPoint(cellCoord);
+        const data = store.getState().data;
+        value = getCellValue(formulaParser, data, point);
       } catch (error) {
         console.error(error);
       } finally {
         done(value);
       }
     });
     formulaParser.on("callRangeValue", (startCellCoord, endCellCoord, done) => {
-      const startPoint = {
-        row: startCellCoord.row.index,
-        column: startCellCoord.column.index,
-      };
-      const endPoint = {
-        row: endCellCoord.row.index,
-        column: endCellCoord.column.index,
-      };
-      const values = Matrix.toArray(
-        Matrix.slice(startPoint, endPoint, store.getState().data),
-        (cell) =>
-          getComputedValue<CellType, CellType["value"]>({
-            cell,
-            formulaParser: formulaParser,
-          })
-      );
-
-      done(values);
+      const startPoint = transformCoordToPoint(startCellCoord);
+      const endPoint = transformCoordToPoint(endCellCoord);
+      const data = store.getState().data;
+      let values;
+      try {
+        values = getCellRangeValue(formulaParser, data, startPoint, endPoint);
+      } catch (error) {
+        console.error(error);
+      } finally {
+        done(values);
+      }
     });
   }, [formulaParser, store, handleCut, handleCopy, handlePaste]);
 

src/util.test.ts

@@ -28,6 +28,9 @@ import {
   readTextFromClipboard,
   normalizeSelected,
   getCopiedRange,
+  transformCoordToPoint,
+  getCellValue,
+  getCellRangeValue,
 } from "./util";
 
 const EXAMPLE_INPUT_VALUE = "EXAMPLE_INPUT_VALUE";
@@ -468,3 +471,31 @@ describe("getCopiedRange()", () => {
     expect(getCopiedRange(copied, hasPasted)).toEqual(expected);
   });
 });
+
+describe("transformCoordToPoint()", () => {
+  test("transforms coord to point", () => {
+    expect(
+      transformCoordToPoint({
+        row: { index: Point.ORIGIN.row },
+        column: { index: Point.ORIGIN.column },
+      })
+    ).toEqual(Point.ORIGIN);
+  });
+});
+
+describe("getCellValue()", () => {
+  expect(getCellValue(MOCK_FORMULA_PARSER, EXAMPLE_DATA, Point.ORIGIN)).toEqual(
+    null
+  );
+});
+
+describe("getCellRangeValue()", () => {
+  expect(
+    getCellRangeValue(
+      MOCK_FORMULA_PARSER,
+      EXAMPLE_DATA,
+      Point.ORIGIN,
+      Point.ORIGIN
+    )
+  ).toEqual([null]);
+});

src/util.ts

@@ -218,3 +218,44 @@ export function getCopiedRange(
   const set: PointSet.PointSet = PointMap.map(() => true, copied);
   return PointSet.toRange(set);
 }
+
+/** Tranform given hot-formula-parser coord to Point.Point */
+export function transformCoordToPoint(coord: {
+  row: { index: number };
+  column: { index: number };
+}): Point.Point {
+  return { row: coord.row.index, column: coord.column.index };
+}
+
+/**
+ * Get cell value for given point from given spreadsheet data with evaluated
+ * cells using given formulaParser
+ */
+export function getCellValue<CellType extends Types.CellBase>(
+  formulaParser: hotFormulaParser.Parser,
+  data: Matrix.Matrix<CellType>,
+  point: Point.Point
+): FormulaParseResult | CellType["value"] | null {
+  return getComputedValue({
+    cell: Matrix.get(point, data),
+    formulaParser,
+  });
+}
+
+/**
+ * Get cell range value for given start and end points from given spreadsheet
+ * data with evaluated cells using given formulaParser
+ */
+export function getCellRangeValue<CellType extends Types.CellBase>(
+  formulaParser: hotFormulaParser.Parser,
+  data: Matrix.Matrix<CellType>,
+  start: Point.Point,
+  end: Point.Point
+): Array<FormulaParseResult | CellType["value"] | null> {
+  return Matrix.toArray(Matrix.slice(start, end, data), (cell) =>
+    getComputedValue({
+      cell,
+      formulaParser,
+    })
+  );
+}