@linzjs/step-ag-grid 23.0.1 → 24.0.0

package/src/utils/testQuick.ts

@@ -5,9 +5,9 @@
  * @param container Optional container
  * @return HTMLElement array
  */
-import { IconName } from "@linzjs/lui/dist/components/LuiIcon/LuiIcon";
+import { IconName } from '@linzjs/lui/dist/components/LuiIcon/LuiIcon';
 
-import { wait } from "./util";
+import { wait } from './util';
 
 const queryAllBySelector = <T extends HTMLElement>(selector: string, container: HTMLElement = document.body): T[] =>
   Array.from(container.querySelectorAll<T>(selector));
@@ -17,7 +17,8 @@ const queryAllBySelector = <T extends HTMLElement>(selector: string, container:
  */
 export interface IQueryQuick {
   testId?: string;
-  tagName?: "button" | "span" | "div" | "input" | "textarea" | any;
+  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+  tagName?: 'button' | 'span' | 'div' | 'input' | 'textarea' | any;
   text?: string | RegExp;
   icon?: IconName;
   ariaLabel?: string;
@@ -26,11 +27,11 @@ export interface IQueryQuick {
   child?: IQueryQuick;
 }
 
-const escapeSelectorParam = (param: string): string => param.replace(/["\\]/g, "\\$&");
+const escapeSelectorParam = (param: string): string => param.replace(/["\\]/g, '\\$&');
 
 export const getMatcher = (matcherText: string | RegExp) => {
   const textMatcher =
-    typeof matcherText === "string"
+    typeof matcherText === 'string'
       ? (text?: string) => text != null && text.toLowerCase() === matcherText.toLowerCase()
       : (text?: string) => text != null && matcherText.test(text);
   return (e: HTMLElement) => textMatcher(e.innerHTML?.trim()) || textMatcher(e.innerText?.trim());
@@ -46,7 +47,7 @@ const quickSelector = <T extends HTMLElement>(
   props: IQueryQuick,
   container?: HTMLElement,
 ): { selector: string; els: T[] } => {
-  let selector = "";
+  let selector = '';
   let lastIQueryQuick = props;
   for (let loop: IQueryQuick | undefined = props; loop; loop = loop.child) {
     lastIQueryQuick = loop;
@@ -56,11 +57,11 @@ const quickSelector = <T extends HTMLElement>(
     loop.testId && (selector += `[data-testid="${escapeSelectorParam(loop.testId)}"]`);
     loop.icon && (selector += `[data-icon='${loop.icon}']`);
     loop.classes && (selector += loop.classes);
-    selector += " ";
+    selector += ' ';
   }
 
-  if (selector.trim() == "") {
-    throw "get/query/findQuick needs at least one defined parameter";
+  if (selector.trim() == '') {
+    throw 'get/query/findQuick needs at least one defined parameter';
   }
 
   let els = queryAllBySelector<T>(selector, container);
@@ -73,10 +74,10 @@ const quickSelector = <T extends HTMLElement>(
   return {
     selector: [
       selector,
-      typeof lastIQueryQuick.text == "string" ? JSON.stringify(lastIQueryQuick.text) : lastIQueryQuick.text,
+      typeof lastIQueryQuick.text === 'string' ? JSON.stringify(lastIQueryQuick.text) : lastIQueryQuick.text,
     ]
       .filter((r) => r)
-      .join(" "),
+      .join(' '),
     els,
   };
 };
@@ -91,9 +92,9 @@ const quickSelector = <T extends HTMLElement>(
 export const queryQuick = <T extends HTMLElement>(filter: IQueryQuick, container?: HTMLElement): T | null => {
   const { els, selector } = quickSelector<T>(filter, container);
   if (els.length > 1) {
-    throw `Found multiple(${els.length}) elements by selector ${selector}\n${els.map(
-      (el, index) => `${index}: ${el.parentElement?.innerHTML}\n\n`,
-    )}`;
+    throw `Found multiple(${els.length}) elements by selector ${selector}\n${els
+      .map((el, index) => `${index}: ${el.parentElement?.innerHTML}\n\n`)
+      .join()}`;
   }
   return els[0] ?? null;
 };

package/src/utils/testUtil.ts

@@ -1,8 +1,8 @@
-import { act, waitFor, within } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import { isEqual } from "lodash-es";
+import { act, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { isEqual } from 'lodash-es';
 
-import { IQueryQuick, findQuick, getAllQuick, getMatcher, getQuick, queryQuick } from "./testQuick";
+import { findQuick, getAllQuick, getMatcher, getQuick, IQueryQuick, queryQuick } from './testQuick';
 
 let user = userEvent;
 /**
@@ -10,16 +10,17 @@ let user = userEvent;
  * @param customisedUserEvent
  */
 export const setUpUserEvent = (customisedUserEvent: any) => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
   user = customisedUserEvent;
 };
 
-export const countRows = async (within?: HTMLElement): Promise<number> => {
+export const countRows = (within?: HTMLElement): number => {
   return getAllQuick({ tagName: `div[row-id]:not(:empty)` }, within).length;
 };
 
 export const findRowByIndex = async (rowIndex: number | string, within?: HTMLElement): Promise<HTMLDivElement> => {
-  await waitFor(async () => {
-    expect(getAllQuick({ classes: ".ag-row" }).length > 0).toBe(true);
+  await waitFor(() => {
+    expect(getAllQuick({ classes: '.ag-row' }).length > 0).toBe(true);
   });
   //if this is not wrapped in an act console errors are logged during testing
   let row!: HTMLDivElement;
@@ -28,7 +29,6 @@ export const findRowByIndex = async (rowIndex: number | string, within?: HTMLEle
       { tagName: `.ag-center-cols-container div[row-index='${rowIndex}']:not(:empty)` },
       within,
     );
-    // @ts-ignore
     let combineChildren = [...Array.from(row.children)];
 
     const leftCols = queryQuick<HTMLDivElement>(
@@ -36,7 +36,6 @@ export const findRowByIndex = async (rowIndex: number | string, within?: HTMLEle
       within,
     );
     if (leftCols) {
-      // @ts-ignore
       combineChildren = [...Array.from(leftCols.children), ...combineChildren];
     }
 
@@ -45,7 +44,6 @@ export const findRowByIndex = async (rowIndex: number | string, within?: HTMLEle
       within,
     );
     if (rightCols) {
-      // @ts-ignore
       combineChildren = [...Array.from(rightCols.children), ...combineChildren];
     }
 
@@ -55,8 +53,8 @@ export const findRowByIndex = async (rowIndex: number | string, within?: HTMLEle
 };
 
 export const findRow = async (rowId: number | string, within?: HTMLElement): Promise<HTMLDivElement> => {
-  await waitFor(async () => {
-    expect(getAllQuick({ classes: ".ag-row" }).length > 0).toBe(true);
+  await waitFor(() => {
+    expect(getAllQuick({ classes: '.ag-row' }).length > 0).toBe(true);
   });
   //if this is not wrapped in an act console errors are logged during testing
   let row!: HTMLDivElement;
@@ -65,7 +63,6 @@ export const findRow = async (rowId: number | string, within?: HTMLElement): Pro
       { tagName: `.ag-center-cols-container div[row-id='${rowId}']:not(:empty)` },
       within,
     );
-    // @ts-ignore
     let combineChildren = [...Array.from(row.children)];
 
     const leftCols = queryQuick<HTMLDivElement>(
@@ -73,7 +70,6 @@ export const findRow = async (rowId: number | string, within?: HTMLElement): Pro
       within,
     );
     if (leftCols) {
-      // @ts-ignore
       combineChildren = [...Array.from(leftCols.children), ...combineChildren];
     }
 
@@ -82,7 +78,6 @@ export const findRow = async (rowId: number | string, within?: HTMLElement): Pro
       within,
     );
     if (rightCols) {
-      // @ts-ignore
       combineChildren = [...Array.from(rightCols.children), ...combineChildren];
     }
 
@@ -91,33 +86,33 @@ export const findRow = async (rowId: number | string, within?: HTMLElement): Pro
   return row;
 };
 
-export const queryRow = async (rowId: number | string, within?: HTMLElement): Promise<HTMLDivElement | null> => {
+export const queryRow = (rowId: number | string, within?: HTMLElement): HTMLDivElement | null => {
   return queryQuick<HTMLDivElement>({ tagName: `div[row-id='${rowId}']:not(:empty)` }, within);
 };
 
 const _selectRow = async (
-  select: "select" | "deselect" | "toggle",
+  select: 'select' | 'deselect' | 'toggle',
   rowId: string | number,
   within?: HTMLElement,
 ): Promise<void> => {
   const row = await findRow(rowId, within);
-  const isSelected = row.className.includes("ag-row-selected");
-  if (select === "toggle" || (select === "select" && !isSelected) || (select === "deselect" && isSelected)) {
-    const cell = await findCell(rowId, "selection", within);
+  const isSelected = row.className.includes('ag-row-selected');
+  if (select === 'toggle' || (select === 'select' && !isSelected) || (select === 'deselect' && isSelected)) {
+    const cell = await findCell(rowId, 'selection', within);
     await user.click(cell);
     await waitFor(async () => {
       const row = await findRow(rowId, within);
-      const nowSelected = row.className.includes("ag-row-selected");
+      const nowSelected = row.className.includes('ag-row-selected');
       if (nowSelected === isSelected) throw `Row ${rowId} won't select`;
     });
   }
 };
 
 export const selectRow = async (rowId: string | number, within?: HTMLElement): Promise<void> =>
-  _selectRow("select", rowId, within);
+  _selectRow('select', rowId, within);
 
 export const deselectRow = async (rowId: string | number, within?: HTMLElement): Promise<void> =>
-  _selectRow("deselect", rowId, within);
+  _selectRow('deselect', rowId, within);
 
 export const findCell = async (rowId: number | string, colId: string, within?: HTMLElement): Promise<HTMLElement> => {
   const row = await findRow(rowId, within);
@@ -157,14 +152,14 @@ export const editCell = async (rowId: number | string, colId: string, within?: H
 
 export const isCellReadOnly = async (rowId: number | string, colId: string, within?: HTMLElement): Promise<boolean> => {
   const cell = await findCell(rowId, colId, within);
-  return cell.className.includes("GridCell-readonly");
+  return cell.className.includes('GridCell-readonly');
 };
 
-export const findOpenPopover = () => findQuick({ classes: ".szh-menu--state-open" });
+export const findOpenPopover = () => findQuick({ classes: '.szh-menu--state-open' });
 
 export const queryMenuOption = async (menuOptionText: string | RegExp): Promise<HTMLElement | null> => {
   const openMenu = await findOpenPopover();
-  const els = await within(openMenu).findAllByRole("menuitem");
+  const els = await within(openMenu).findAllByRole('menuitem');
   const matcher = getMatcher(menuOptionText);
   const result = els.find(matcher);
   return result ?? null;
@@ -190,7 +185,7 @@ export const validateMenuOptions = async (
 ): Promise<boolean> => {
   await editCell(rowId, colId);
   const openMenu = await findOpenPopover();
-  const actualOptions = (await within(openMenu).findAllByRole("menuitem")).map((menuItem) => menuItem.textContent);
+  const actualOptions = (await within(openMenu).findAllByRole('menuitem')).map((menuItem) => menuItem.textContent);
   return isEqual(actualOptions, expectedMenuOptions);
 };
 
@@ -221,7 +216,7 @@ export const openAndFindMenuOption = async (
 
 export const getMultiSelectOptions = async () => {
   const openMenu = await findOpenPopover();
-  return getAllQuick<HTMLInputElement>({ role: "menuitem", child: { tagName: "input,textarea" } }, openMenu).map(
+  return getAllQuick<HTMLInputElement>({ role: 'menuitem', child: { tagName: 'input,textarea' } }, openMenu).map(
     (input) => {
       return {
         v: input.value,
@@ -233,7 +228,7 @@ export const getMultiSelectOptions = async () => {
 
 export const findMultiSelectOption = async (value: string): Promise<HTMLElement> => {
   const openMenu = await findOpenPopover();
-  return getQuick({ role: "menuitem", child: { tagName: `input[value='${value}']` } }, openMenu);
+  return getQuick({ role: 'menuitem', child: { tagName: `input[value='${value}']` } }, openMenu);
 };
 
 export const clickMultiSelectOption = async (value: string): Promise<void> => {
@@ -255,14 +250,14 @@ export const typeOnlyInput = async (value: string): Promise<void> =>
   typeInput(value, { child: { tagName: "input[type='text'], textarea" } });
 
 export const typeInputByLabel = async (value: string, labelText: string): Promise<void> => {
-  const labels = getAllQuick({ child: { tagName: "label" } }).filter((l) => l.textContent === labelText);
+  const labels = getAllQuick({ child: { tagName: 'label' } }).filter((l) => l.textContent === labelText);
   if (labels.length === 0) {
     throw Error(`Label not found for text: ${labelText}`);
   }
   if (labels.length > 1) {
     throw Error(`Multiple labels found for text: ${labelText}`);
   }
-  const inputId = labels[0].getAttribute("for");
+  const inputId = labels[0].getAttribute('for');
   await typeInput(value, { child: { tagName: `input[id='${inputId}'], textarea[id='${inputId}']` } });
 };
 
@@ -272,16 +267,16 @@ export const typeInputByPlaceholder = async (value: string, placeholder: string)
   });
 
 export const typeOtherInput = async (value: string): Promise<void> =>
-  typeInput(value, { classes: ".subComponent", child: { tagName: "input[type='text']" } });
+  typeInput(value, { classes: '.subComponent', child: { tagName: "input[type='text']" } });
 
 export const typeOtherTextArea = async (value: string): Promise<void> =>
-  typeInput(value, { classes: ".subComponent", child: { tagName: "textarea" } });
+  typeInput(value, { classes: '.subComponent', child: { tagName: 'textarea' } });
 
 export const closeMenu = () => user.click(document.body);
 export const closePopover = () => user.click(document.body);
 
 export const findActionButton = (text: string, container?: HTMLElement): Promise<HTMLElement> =>
-  findQuick({ tagName: "button", child: { classes: ".ActionButton-minimalAreaDisplay", text: text } }, container);
+  findQuick({ tagName: 'button', child: { classes: '.ActionButton-minimalAreaDisplay', text: text } }, container);
 
 export const clickActionButton = async (text: string, container?: HTMLElement): Promise<void> => {
   const button = await findActionButton(text, container);
@@ -289,11 +284,11 @@ export const clickActionButton = async (text: string, container?: HTMLElement):
 };
 
 export const waitForGridReady = async (props?: { grid?: HTMLElement; timeout?: number }) =>
-  waitFor(() => expect(getAllQuick({ classes: ".Grid-ready" }, props?.grid)).toBeInTheDocument(), {
+  waitFor(() => expect(getAllQuick({ classes: '.Grid-ready' }, props?.grid)).toBeInTheDocument(), {
     timeout: props?.timeout ?? 5000,
   });
 
 export const waitForGridRows = async (props?: { grid?: HTMLElement; timeout?: number }) =>
-  waitFor(async () => expect(getAllQuick({ classes: ".ag-row" }, props?.grid).length > 0).toBe(true), {
+  waitFor(() => expect(getAllQuick({ classes: '.ag-row' }, props?.grid).length > 0).toBe(true), {
     timeout: props?.timeout ?? 5000,
   });

package/src/utils/textMatcher.test.ts

@@ -1,4 +1,4 @@
-import { textMatch } from "./textMatcher";
+import { textMatch } from './textMatcher';
 
 /**
  * "L" => L*
@@ -11,18 +11,18 @@ import { textMatch } from "./textMatcher";
  * "=!A" => all values must not match exactly A
  * Returns true if there's a text match.
  */
-describe("textMatch", () => {
-  test("textMatch", () => {
+describe('textMatch', () => {
+  test('textMatch', () => {
     const validate = [
       {
-        value: "",
-        matched: [""],
-        unmatched: ["a", "a*", "*a*"],
+        value: '',
+        matched: [''],
+        unmatched: ['a', 'a*', '*a*'],
       },
       {
-        value: "two words",
-        matched: ["", "*wo", "*or*", "tw", "two", "tw wo", "tw, rr", "=!tw"],
-        unmatched: ["ds", "o", "=tw", "tw rr", "!two", "!tw*"],
+        value: 'two words',
+        matched: ['', '*wo', '*or*', 'tw', 'two', 'tw wo', 'tw, rr', '=!tw'],
+        unmatched: ['ds', 'o', '=tw', 'tw rr', '!two', '!tw*'],
       },
     ];
 

package/src/utils/textMatcher.ts

@@ -1,5 +1,5 @@
-import { isEmpty, partition } from "lodash-es";
-import { isMatch } from "matcher";
+import { isEmpty, partition } from 'lodash-es';
+import { isMatch } from 'matcher';
 
 /**
  * Text matching with wildcards and multiple matchers.
@@ -17,22 +17,22 @@ export const textMatch = (text: string | undefined | null, filter: string): bool
   if (text == null) return true;
 
   const superFilters = filter
-    .split(",")
+    .split(',')
     .map((sf) => sf.trim())
     .filter((sf) => sf)
     .map((r) =>
       r
         .split(/\s+/)
-        .map((f) => (f.startsWith("=") ? f.slice(1) : f + "*"))
-        .join(" "),
+        .map((f) => (f.startsWith('=') ? f.slice(1) : f + '*'))
+        .join(' '),
     );
-  const [negativeFilters, positiveFilters] = partition(superFilters, (superFilters) => superFilters.startsWith("!"));
+  const [negativeFilters, positiveFilters] = partition(superFilters, (superFilters) => superFilters.startsWith('!'));
 
-  const values = text.replaceAll(",", " ").trim().split(/\s+/);
+  const values = text.replaceAll(',', ' ').trim().split(/\s+/);
   return (
     (isEmpty(positiveFilters) || // Not filtered
       positiveFilters.some((superFilter) => {
-        const subFilters = superFilter.split(/\s+/).map((s) => s.replaceAll(/([!?])/g, "\\$1"));
+        const subFilters = superFilter.split(/\s+/).map((s) => s.replaceAll(/([!?])/g, '\\$1'));
         return subFilters.every((subFilter) => values.some((value) => isMatch(value, subFilter)));
       })) &&
     (isEmpty(negativeFilters) ||

package/src/utils/textValidator.test.ts

@@ -1,89 +1,89 @@
-import { GridBaseRow } from "../components/Grid";
-import { TextInputValidator, TextInputValidatorProps } from "./textValidator";
+import { GridBaseRow } from '../components/Grid';
+import { TextInputValidator, TextInputValidatorProps } from './textValidator';
 
-describe("TextInputValidator", () => {
-  test("number format", () => {
+describe('TextInputValidator', () => {
+  test('number format', () => {
     const validate = [
       {
         numberFormat: {},
         tests: [
-          ["x", "Must be a valid number"],
-          ["1.2e6", "Must be a valid number"],
-          ["", null],
-          ["1", null],
-          ["1.2", null],
-          [".2", null],
-          ["-1.2", null],
-          ["-.2", null],
-          ["-.2", null],
+          ['x', 'Must be a valid number'],
+          ['1.2e6', 'Must be a valid number'],
+          ['', null],
+          ['1', null],
+          ['1.2', null],
+          ['.2', null],
+          ['-1.2', null],
+          ['-.2', null],
+          ['-.2', null],
         ],
       },
       {
         numberFormat: { geMin: 0, leMax: 10 },
         tests: [
-          ["x", "Must be a valid number"],
-          ["", null],
-          ["1", null],
-          ["0", null],
-          ["-1", "Must not be less than 0"],
-          ["10", null],
-          ["10.1", "Must not be greater than 10"],
+          ['x', 'Must be a valid number'],
+          ['', null],
+          ['1', null],
+          ['0', null],
+          ['-1', 'Must not be less than 0'],
+          ['10', null],
+          ['10.1', 'Must not be greater than 10'],
         ],
       },
       {
         numberFormat: { gtMin: 0, ltMax: 10 },
         tests: [
-          ["x", "Must be a valid number"],
-          ["", null],
-          ["1", null],
-          ["0", "Must be greater than 0"],
-          ["10", "Must be less than 10"],
+          ['x', 'Must be a valid number'],
+          ['', null],
+          ['1', null],
+          ['0', 'Must be greater than 0'],
+          ['10', 'Must be less than 10'],
         ],
       },
       {
         numberFormat: { precision: 3 },
         tests: [
-          ["x", "Must be a valid number"],
-          ["", null],
-          ["1.22", null],
-          ["0.122", null],
-          ["1.123", "Must have no more than 3 digits precision"],
-          ["0.1234", "Must have no more than 3 digits precision"],
+          ['x', 'Must be a valid number'],
+          ['', null],
+          ['1.22', null],
+          ['0.122', null],
+          ['1.123', 'Must have no more than 3 digits precision'],
+          ['0.1234', 'Must have no more than 3 digits precision'],
         ],
       },
       {
         numberFormat: { scale: 2 },
         tests: [
-          ["x", "Must be a valid number"],
-          ["", null],
-          ["1.22", null],
-          ["0.122", "Must have no more than 2 decimal places"],
-          ["1.123", "Must have no more than 2 decimal places"],
+          ['x', 'Must be a valid number'],
+          ['', null],
+          ['1.22', null],
+          ['0.122', 'Must have no more than 2 decimal places'],
+          ['1.123', 'Must have no more than 2 decimal places'],
         ],
       },
       {
         numberFormat: { scale: 0 },
         tests: [
-          ["1", null],
-          ["1.1", "Must be a whole number"],
+          ['1', null],
+          ['1.1', 'Must be a whole number'],
         ],
       },
       {
         numberFormat: { notZero: true },
         tests: [
-          ["1", null],
-          ["0", "Must not be 0"],
+          ['1', null],
+          ['0', 'Must not be 0'],
         ],
       },
       {
         required: true,
         tests: [
-          ["xx", null],
-          ["", "Must not be empty"],
-          ["\t", "Must not be empty"],
-          ["\n", "Must not be empty"],
-          ["\r", "Must not be empty"],
-          [" ", "Must not be empty"],
+          ['xx', null],
+          ['', 'Must not be empty'],
+          ['\t', 'Must not be empty'],
+          ['\n', 'Must not be empty'],
+          ['\r', 'Must not be empty'],
+          [' ', 'Must not be empty'],
         ],
       },
     ] as (TextInputValidatorProps<GridBaseRow> & { tests: [string, string | undefined][] })[];
@@ -98,21 +98,21 @@ describe("TextInputValidator", () => {
     });
   });
 
-  test("validator is called", () => {
+  test('validator is called', () => {
     const fn = jest.fn();
-    TextInputValidator({ invalid: fn }, "", { id: 0 }, {});
+    TextInputValidator({ invalid: fn }, '', { id: 0 }, {});
     expect(fn).toHaveBeenCalled();
   });
 
-  test("maxLength", () => {
-    expect(TextInputValidator({ maxLength: 2 }, "", { id: 0 }, {})).toBeNull();
-    expect(TextInputValidator({ maxLength: 2 }, "aa", { id: 0 }, {})).toBeNull();
-    expect(TextInputValidator({ maxLength: 2 }, "aaa", { id: 0 }, {})).toBe("Must be no longer than 2 characters");
+  test('maxLength', () => {
+    expect(TextInputValidator({ maxLength: 2 }, '', { id: 0 }, {})).toBeNull();
+    expect(TextInputValidator({ maxLength: 2 }, 'aa', { id: 0 }, {})).toBeNull();
+    expect(TextInputValidator({ maxLength: 2 }, 'aaa', { id: 0 }, {})).toBe('Must be no longer than 2 characters');
   });
 
-  test("maxBytes", () => {
-    expect(TextInputValidator({ maxBytes: 2 }, "", { id: 0 }, {})).toBeNull();
-    expect(TextInputValidator({ maxBytes: 2 }, "aa", { id: 0 }, {})).toBeNull();
-    expect(TextInputValidator({ maxBytes: 2 }, "a–", { id: 0 }, {})).toBe("Must be no longer than 2 bytes");
+  test('maxBytes', () => {
+    expect(TextInputValidator({ maxBytes: 2 }, '', { id: 0 }, {})).toBeNull();
+    expect(TextInputValidator({ maxBytes: 2 }, 'aa', { id: 0 }, {})).toBeNull();
+    expect(TextInputValidator({ maxBytes: 2 }, 'a–', { id: 0 }, {})).toBe('Must be no longer than 2 bytes');
   });
 });

package/src/utils/textValidator.ts

@@ -1,7 +1,7 @@
-import { ReactElement } from "react";
+import { ReactElement } from 'react';
 
-import { GridBaseRow } from "../components/Grid";
-import { isFloat, stringByteLengthIsInvalid } from "./util";
+import { GridBaseRow } from '../components/Grid';
+import { isFloat, stringByteLengthIsInvalid } from './util';
 
 export interface TextInputValidatorProps<TData extends GridBaseRow> {
   required?: boolean;
@@ -28,11 +28,11 @@ export const TextInputValidator = <TData extends GridBaseRow>(
   if (value == null) return null;
 
   // This can happen because subcomponent is invoked without type safety
-  if (typeof value !== "string") {
-    return "Value is not a string";
+  if (typeof value !== 'string') {
+    return 'Value is not a string';
   }
-  if (props.required && value.trim() == "") {
-    return "Must not be empty";
+  if (props.required && value.trim() == '') {
+    return 'Must not be empty';
   }
   if (props.maxLength && value.length > props.maxLength) {
     return `Must be no longer than ${props.maxLength} characters`;
@@ -42,10 +42,10 @@ export const TextInputValidator = <TData extends GridBaseRow>(
   }
   const nf = props.numberFormat;
   if (nf) {
-    if (value != "" && !isFloat(value)) {
+    if (value != '' && !isFloat(value)) {
       return `Must be a valid number`;
     }
-    if (value != "") {
+    if (value != '') {
       const number = parseFloat(value);
       if (nf.notZero && number === 0) {
         return `Must not be 0`;
@@ -63,13 +63,13 @@ export const TextInputValidator = <TData extends GridBaseRow>(
         return `Must not be greater than ${nf.leMax.toLocaleString()}`;
       }
 
-      if (nf.precision != null && value != "") {
+      if (nf.precision != null && value != '') {
         if (parseFloat(number.toPrecision(nf.precision)) != number) {
           return `Must have no more than ${nf.precision} digits precision`;
         }
       }
 
-      if (nf.scale != null && value != "") {
+      if (nf.scale != null && value != '') {
         if (parseFloat(number.toFixed(nf.scale)) != number) {
           return nf.scale == 0 ? `Must be a whole number` : `Must have no more than ${nf.scale} decimal places`;
         }