@linzjs/step-ag-grid 23.0.1 → 25.0.0

package/src/utils/__tests__/vitestUtil.ts

@@ -0,0 +1,295 @@
+import { act, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { isEqual } from 'lodash-es';
+import { expect } from 'vitest';
+
+import { findQuick, getAllQuick, getMatcher, getQuick, IQueryQuick, queryQuick } from './testQuick';
+
+let user = userEvent;
+/**
+ * allow external userEvent to be used
+ * @param customisedUserEvent
+ */
+export const setUpUserEvent = (customisedUserEvent: any) => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  user = customisedUserEvent;
+};
+
+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(() => {
+    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;
+  await act(async () => {
+    row = await findQuick<HTMLDivElement>(
+      { tagName: `.ag-center-cols-container div[row-index='${rowIndex}']:not(:empty)` },
+      within,
+    );
+    let combineChildren = [...Array.from(row.children)];
+
+    const leftCols = queryQuick<HTMLDivElement>(
+      { tagName: `.ag-pinned-left-cols-container div[row-index='${rowIndex}']` },
+      within,
+    );
+    if (leftCols) {
+      combineChildren = [...Array.from(leftCols.children), ...combineChildren];
+    }
+
+    const rightCols = queryQuick<HTMLDivElement>(
+      { tagName: `.ag-pinned-right-cols-container div[row-index='${rowIndex}']` },
+      within,
+    );
+    if (rightCols) {
+      combineChildren = [...Array.from(rightCols.children), ...combineChildren];
+    }
+
+    row.replaceChildren(...combineChildren);
+  });
+  return row;
+};
+
+export const findRow = async (rowId: number | string, within?: HTMLElement): Promise<HTMLDivElement> => {
+  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;
+  await act(async () => {
+    row = await findQuick<HTMLDivElement>(
+      { tagName: `.ag-center-cols-container div[row-id='${rowId}']:not(:empty)` },
+      within,
+    );
+    let combineChildren = [...Array.from(row.children)];
+
+    const leftCols = queryQuick<HTMLDivElement>(
+      { tagName: `.ag-pinned-left-cols-container div[row-id='${rowId}']` },
+      within,
+    );
+    if (leftCols) {
+      combineChildren = [...Array.from(leftCols.children), ...combineChildren];
+    }
+
+    const rightCols = queryQuick<HTMLDivElement>(
+      { tagName: `.ag-pinned-right-cols-container div[row-id='${rowId}']` },
+      within,
+    );
+    if (rightCols) {
+      combineChildren = [...Array.from(rightCols.children), ...combineChildren];
+    }
+
+    row.replaceChildren(...combineChildren);
+  });
+  return row;
+};
+
+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',
+  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);
+    await user.click(cell);
+    await waitFor(async () => {
+      const row = await findRow(rowId, within);
+      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);
+
+export const deselectRow = async (rowId: string | number, within?: HTMLElement): Promise<void> =>
+  _selectRow('deselect', rowId, within);
+
+export const findCell = async (rowId: number | string, colId: string, within?: HTMLElement): Promise<HTMLElement> => {
+  const row = await findRow(rowId, within);
+  return await findQuick({ tagName: `[col-id='${colId}']` }, row);
+};
+
+export const findCellContains = async (
+  rowId: number | string,
+  colId: string,
+  text: string | RegExp,
+  within?: HTMLElement,
+) => {
+  return await waitFor(
+    async () => {
+      const row = await findRow(rowId, within);
+      return getQuick({ tagName: `[col-id='${colId}']`, text }, row);
+    },
+    { timeout: 10000 },
+  );
+};
+
+export const selectCell = async (rowId: string | number, colId: string, within?: HTMLElement): Promise<void> => {
+  const cell = await findCell(rowId, colId, within);
+  await user.click(cell);
+};
+
+export const editCell = async (rowId: number | string, colId: string, within?: HTMLElement): Promise<void> => {
+  await waitFor(
+    async () => {
+      const cell = await findCell(rowId, colId, within);
+      await user.dblClick(cell);
+      await waitFor(findOpenPopover, { timeout: 1000 });
+    },
+    { timeout: 10000 },
+  );
+};
+
+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');
+};
+
+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 matcher = getMatcher(menuOptionText);
+  const result = els.find(matcher);
+  return result ?? null;
+};
+
+export const findMenuOption = async (menuOptionText: string | RegExp): Promise<HTMLElement> => {
+  return await waitFor(
+    async () => {
+      const menuOption = await queryMenuOption(menuOptionText);
+      if (menuOption == null) {
+        throw Error(`Unable to find menu option ${menuOptionText}`);
+      }
+      return menuOption;
+    },
+    { timeout: 5000 },
+  );
+};
+
+export const validateMenuOptions = async (
+  rowId: number | string,
+  colId: string,
+  expectedMenuOptions: Array<string>,
+): Promise<boolean> => {
+  await editCell(rowId, colId);
+  const openMenu = await findOpenPopover();
+  const actualOptions = (await within(openMenu).findAllByRole('menuitem')).map((menuItem) => menuItem.textContent);
+  return isEqual(actualOptions, expectedMenuOptions);
+};
+
+export const clickMenuOption = async (menuOptionText: string | RegExp): Promise<void> => {
+  const menuOption = await findMenuOption(menuOptionText);
+  await user.click(menuOption);
+};
+
+export const openAndClickMenuOption = async (
+  rowId: number | string,
+  colId: string,
+  menuOptionText: string | RegExp,
+  within?: HTMLElement,
+): Promise<void> => {
+  await editCell(rowId, colId, within);
+  await clickMenuOption(menuOptionText);
+};
+
+export const openAndFindMenuOption = async (
+  rowId: number | string,
+  colId: string,
+  menuOptionText: string | RegExp,
+  within?: HTMLElement,
+): Promise<HTMLElement> => {
+  await editCell(rowId, colId, within);
+  return await findMenuOption(menuOptionText);
+};
+
+export const getMultiSelectOptions = async () => {
+  const openMenu = await findOpenPopover();
+  return getAllQuick<HTMLInputElement>({ role: 'menuitem', child: { tagName: 'input,textarea' } }, openMenu).map(
+    (input) => {
+      return {
+        v: input.value,
+        c: input.checked ?? true,
+      };
+    },
+  );
+};
+
+export const findMultiSelectOption = async (value: string): Promise<HTMLElement> => {
+  const openMenu = await findOpenPopover();
+  return getQuick({ role: 'menuitem', child: { tagName: `input[value='${value}']` } }, openMenu);
+};
+
+export const clickMultiSelectOption = async (value: string): Promise<void> => {
+  const menuItem = await findMultiSelectOption(value);
+  menuItem.parentElement && (await user.click(menuItem.parentElement));
+};
+
+const typeInput = async (value: string, filter: IQueryQuick): Promise<void> => {
+  const openMenu = await findOpenPopover();
+  const input = await findQuick(filter, openMenu);
+  await user.clear(input);
+  //'typing' an empty string will cause a console error, and it's also unnecessary after the previous clear call
+  if (value.length > 0) {
+    await user.type(input, value);
+  }
+};
+
+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);
+  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');
+  await typeInput(value, { child: { tagName: `input[id='${inputId}'], textarea[id='${inputId}']` } });
+};
+
+export const typeInputByPlaceholder = async (value: string, placeholder: string): Promise<void> =>
+  typeInput(value, {
+    child: { tagName: `input[placeholder='${placeholder}'], textarea[placeholder='${placeholder}']` },
+  });
+
+export const typeOtherInput = async (value: string): Promise<void> =>
+  typeInput(value, { classes: '.subComponent', child: { tagName: "input[type='text']" } });
+
+export const typeOtherTextArea = async (value: string): Promise<void> =>
+  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);
+
+export const clickActionButton = async (text: string, container?: HTMLElement): Promise<void> => {
+  const button = await findActionButton(text, container);
+  await user.click(button);
+};
+
+export const waitForGridReady = async (props?: { grid?: HTMLElement; timeout?: number }) =>
+  waitFor(() => expect(getAllQuick({ classes: '.Grid-ready' }, props?.grid)).toBeDefined(), {
+    timeout: props?.timeout ?? 5000,
+  });
+
+export const waitForGridRows = async (props?: { grid?: HTMLElement; timeout?: number }) =>
+  waitFor(() => expect(getAllQuick({ classes: '.ag-row' }, props?.grid).length > 0).toBe(true), {
+    timeout: props?.timeout ?? 5000,
+  });

package/src/utils/bearing.test.ts

@@ -1,55 +1,57 @@
+import { describe, expect, test, vi } from 'vitest';
+
 import {
   bearingCorrectionRangeValidator,
   bearingRangeValidator,
   bearingStringValidator,
   convertDDToDMS,
-} from "./bearing";
+} from './bearing';
 
-describe("bearing", () => {
-  test("convertDDToDMS converts decimal-ish degrees to DMS", () => {
-    expect(convertDDToDMS(-0.001, false)).toBe("-0° 00' 10\"");
-    expect(convertDDToDMS(-10.001, false)).toBe("-10° 00' 10\"");
-    expect(convertDDToDMS(-370.001, false)).toBe("-10° 00' 10\"");
+describe('bearing', () => {
+  test('convertDDToDMS converts decimal-ish degrees to DMS', () => {
+    expect(convertDDToDMS(-0.001, false)).toBe('-0° 00\' 10"');
+    expect(convertDDToDMS(-10.001, false)).toBe('-10° 00\' 10"');
+    expect(convertDDToDMS(-370.001, false)).toBe('-10° 00\' 10"');
     expect(convertDDToDMS(359.595999, false, 2)).toBe("0° 00'");
-    expect(convertDDToDMS(359.595999, false, 4)).toBe("0° 00' 00\"");
-    expect(convertDDToDMS(359.595999, false, 5)).toBe("0° 00' 00.0\"");
-    expect(convertDDToDMS(369.696999, false)).toBe("10° 10' 10\"");
-    expect(convertDDToDMS(369.696999, false, 4)).toBe("10° 10' 10\"");
+    expect(convertDDToDMS(359.595999, false, 4)).toBe('0° 00\' 00"');
+    expect(convertDDToDMS(359.595999, false, 5)).toBe('0° 00\' 00.0"');
+    expect(convertDDToDMS(369.696999, false)).toBe('10° 10\' 10"');
+    expect(convertDDToDMS(369.696999, false, 4)).toBe('10° 10\' 10"');
     expect(convertDDToDMS(221.555999, false, 2)).toBe("221° 56'");
-    expect(convertDDToDMS(221.555999, false, 5)).toBe("221° 56' 00.0\"");
-    expect(convertDDToDMS(5, true, 5)).toBe("+5° 00' 00.0\"");
-    expect(convertDDToDMS(5.0, true, 5)).toBe("+5° 00' 00.0\"");
-    expect(convertDDToDMS(5.00001, true, 5)).toBe("+5° 00' 00.1\"");
-    expect(convertDDToDMS(5.1, true, 5)).toBe("+5° 10' 00.0\"");
-    expect(convertDDToDMS(5.12345)).toBe("+5° 12' 34.5\"");
-    expect(convertDDToDMS(5.12345, false)).toBe("5° 12' 34.5\"");
-    expect(convertDDToDMS(5.12345, false, 2)).toBe("5° 12' 34.5\"");
-    expect(convertDDToDMS(300, true, 5)).toBe("+300° 00' 00.0\"");
-    expect(convertDDToDMS(300.0, true, 5)).toBe("+300° 00' 00.0\"");
-    expect(convertDDToDMS(300.00001)).toBe("+300° 00' 00.1\"");
-    expect(convertDDToDMS(300.1, true, 5)).toBe("+300° 10' 00.0\"");
-    expect(convertDDToDMS(300.12345)).toBe("+300° 12' 34.5\"");
-    expect(convertDDToDMS(300.12345, false)).toBe("300° 12' 34.5\"");
+    expect(convertDDToDMS(221.555999, false, 5)).toBe('221° 56\' 00.0"');
+    expect(convertDDToDMS(5, true, 5)).toBe('+5° 00\' 00.0"');
+    expect(convertDDToDMS(5.0, true, 5)).toBe('+5° 00\' 00.0"');
+    expect(convertDDToDMS(5.00001, true, 5)).toBe('+5° 00\' 00.1"');
+    expect(convertDDToDMS(5.1, true, 5)).toBe('+5° 10\' 00.0"');
+    expect(convertDDToDMS(5.12345)).toBe('+5° 12\' 34.5"');
+    expect(convertDDToDMS(5.12345, false)).toBe('5° 12\' 34.5"');
+    expect(convertDDToDMS(5.12345, false, 2)).toBe('5° 12\' 34.5"');
+    expect(convertDDToDMS(300, true, 5)).toBe('+300° 00\' 00.0"');
+    expect(convertDDToDMS(300.0, true, 5)).toBe('+300° 00\' 00.0"');
+    expect(convertDDToDMS(300.00001)).toBe('+300° 00\' 00.1"');
+    expect(convertDDToDMS(300.1, true, 5)).toBe('+300° 10\' 00.0"');
+    expect(convertDDToDMS(300.12345)).toBe('+300° 12\' 34.5"');
+    expect(convertDDToDMS(300.12345, false)).toBe('300° 12\' 34.5"');
     expect(convertDDToDMS(300, false, 2)).toBe("300° 00'");
     expect(convertDDToDMS(300.1, false, 2)).toBe("300° 10'");
     expect(convertDDToDMS(0, false, 2)).toBe("0° 00'");
     expect(convertDDToDMS(0.0, false)).toBe("0° 00'");
-    expect(convertDDToDMS(0.0, false, 4)).toBe("0° 00' 00\"");
-    expect(convertDDToDMS(0.0, false, 5)).toBe("0° 00' 00.0\"");
+    expect(convertDDToDMS(0.0, false, 4)).toBe('0° 00\' 00"');
+    expect(convertDDToDMS(0.0, false, 5)).toBe('0° 00\' 00.0"');
   });
 
-  test("bearingStringValidator", () => {
+  test('bearingStringValidator', () => {
     const tests: [string, string | null][] = [
-      ["", null],
-      ["1", null],
-      ["1.2345", null],
-      ["-1.2345", null],
-      ["360.2345", null],
-      ["-360.2345", null],
-      ["1.2e6", "Bearing must be a number in D.MMSSS format"],
-      ["0.60000", "Bearing must be a number in D.MMSSS format"],
-      ["0.00600", "Bearing must be a number in D.MMSSS format"],
-      ["0.123456", "Bearing has a maximum of 5 decimal places"],
+      ['', null],
+      ['1', null],
+      ['1.2345', null],
+      ['-1.2345', null],
+      ['360.2345', null],
+      ['-360.2345', null],
+      ['1.2e6', 'Bearing must be a number in D.MMSSS format'],
+      ['0.60000', 'Bearing must be a number in D.MMSSS format'],
+      ['0.00600', 'Bearing must be a number in D.MMSSS format'],
+      ['0.123456', 'Bearing has a maximum of 5 decimal places'],
     ];
 
     tests.forEach((test, i) => {
@@ -57,22 +59,22 @@ describe("bearing", () => {
     });
 
     // calls custom invalid
-    const fn = jest.fn();
-    bearingStringValidator("1.2", fn);
+    const fn = vi.fn();
+    bearingStringValidator('1.2', fn);
     expect(fn).toHaveBeenCalledWith(1.2);
   });
 
-  test("bearingRangeValidator", () => {
+  test('bearingRangeValidator', () => {
     expect(bearingRangeValidator(0)).toBeNull();
     expect(bearingRangeValidator(359.595999)).toBeNull();
-    expect(bearingRangeValidator(-0.00001)).toBe("Bearing must not be negative");
-    expect(bearingRangeValidator(360)).toBe("Bearing must be less than 360 degrees");
+    expect(bearingRangeValidator(-0.00001)).toBe('Bearing must not be negative');
+    expect(bearingRangeValidator(360)).toBe('Bearing must be less than 360 degrees');
   });
 
-  test("bearingCorrectionRangeValidator", () => {
+  test('bearingCorrectionRangeValidator', () => {
     expect(bearingCorrectionRangeValidator(-179.59999)).toBeNull();
     expect(bearingCorrectionRangeValidator(359.59999)).toBeNull();
-    expect(bearingCorrectionRangeValidator(-180)).toBe("Bearing correction must be greater then -180 degrees");
-    expect(bearingCorrectionRangeValidator(360)).toBe("Bearing correction must be less than 360 degrees");
+    expect(bearingCorrectionRangeValidator(-180)).toBe('Bearing correction must be greater then -180 degrees');
+    expect(bearingCorrectionRangeValidator(360)).toBe('Bearing correction must be less than 360 degrees');
   });
 });

package/src/utils/bearing.ts

@@ -1,7 +1,7 @@
 export const bearingValueFormatter = (value: any): string => {
-  const safeValue = typeof value == "string" ? parseFloat(value) : value;
+  const safeValue = typeof value === 'string' ? parseFloat(value) : value;
   if (safeValue == null) {
-    return "–";
+    return '–';
   }
   return convertDDToDMS(safeValue, false);
 };
@@ -9,16 +9,16 @@ export const bearingValueFormatter = (value: any): string => {
 export const bearingCorrectionValueFormatter = (value: any): string => {
   const safeValue = value;
   if (safeValue == null) {
-    return "–";
+    return '–';
   }
-  if (typeof safeValue === "string") {
+  if (typeof safeValue === 'string') {
     return convertDDToDMS(bearingNumberParser(safeValue), true, 4);
   }
   return convertDDToDMS(safeValue, true, 4);
 };
 
 export const bearingNumberParser = (value: string): number | null => {
-  if (value === "") return null;
+  if (value === '') return null;
   return parseFloat(value);
 };
 
@@ -28,12 +28,12 @@ export const bearingStringValidator = (
   customInvalid?: (value: number | null) => string | null,
 ): string | null => {
   value = value.trim();
-  if (value === "") return null;
+  if (value === '') return null;
   const match = value.match(validMaskForDmsBearing);
-  if (!match) return "Bearing must be a number in D.MMSSS format";
+  if (!match) return 'Bearing must be a number in D.MMSSS format';
   const decimalPart = match[4];
   if (decimalPart != null && decimalPart.length > 5) {
-    return "Bearing has a maximum of 5 decimal places";
+    return 'Bearing has a maximum of 5 decimal places';
   }
 
   const bearing = parseFloat(value);
@@ -53,10 +53,10 @@ export const bearingStringValidator = (
  * @returns Degrees Minutes Seconds
  */
 export const convertDDToDMS = (dd: number | null, showPositiveSymbol = true, trailingZeroDp: 2 | 4 | 5 = 2): string => {
-  if (dd == null) return "–";
+  if (dd == null) return '–';
 
   // toFixed rounds parts up greater than 60, which has to be corrected below
-  const [bearingWholeString, bearingDecimalString] = dd.toFixed(5).split(".");
+  const [bearingWholeString, bearingDecimalString] = dd.toFixed(5).split('.');
 
   let bearingWhole = Math.abs(parseInt(bearingWholeString));
   let minNumeric = parseInt(bearingDecimalString?.substring(0, 2));
@@ -75,12 +75,12 @@ export const convertDDToDMS = (dd: number | null, showPositiveSymbol = true, tra
     bearingWhole -= 360;
   }
 
-  const minString = minNumeric.toString().padStart(2, "0");
-  const secString = secNumeric.toString().padStart(2, "0");
+  const minString = minNumeric.toString().padStart(2, '0');
+  const secString = secNumeric.toString().padStart(2, '0');
   const deciSecString = bearingDecimalString?.substring(4, 5);
 
-  let dmsString = `${showPositiveSymbol && dd > 0 ? "+" : ""}${dd < 0 ? "-" : ""}${bearingWhole}°`;
-  if (trailingZeroDp === 5 || deciSecString != "0") {
+  let dmsString = `${showPositiveSymbol && dd > 0 ? '+' : ''}${dd < 0 ? '-' : ''}${bearingWhole}°`;
+  if (trailingZeroDp === 5 || deciSecString != '0') {
     dmsString += `\xa0${minString}'\xa0${secString}.${deciSecString}"`; // "\xa0" is here for non-breaking space
   } else if (trailingZeroDp === 4 || secNumeric != 0) {
     dmsString += `\xa0${minString}'\xa0${secString}"`;
@@ -91,15 +91,15 @@ export const convertDDToDMS = (dd: number | null, showPositiveSymbol = true, tra
 };
 
 export const bearingRangeValidator = (value: number | null) => {
-  if (value === null) return "Bearing is required";
-  if (value >= 360) return "Bearing must be less than 360 degrees";
-  if (value < 0) return "Bearing must not be negative";
+  if (value === null) return 'Bearing is required';
+  if (value >= 360) return 'Bearing must be less than 360 degrees';
+  if (value < 0) return 'Bearing must not be negative';
   return null;
 };
 
 export const bearingCorrectionRangeValidator = (value: number | null) => {
-  if (value === null) return "Bearing correction is required";
-  if (value >= 360) return "Bearing correction must be less than 360 degrees";
-  if (value <= -180) return "Bearing correction must be greater then -180 degrees";
+  if (value === null) return 'Bearing correction is required';
+  if (value >= 360) return 'Bearing correction must be less than 360 degrees';
+  if (value <= -180) return 'Bearing correction must be greater then -180 degrees';
   return null;
 };

package/src/utils/deferredPromise.ts

@@ -1,4 +1,4 @@
-import { useEffect, useRef } from "react";
+import { useEffect, useRef } from 'react';
 
 export const useDeferredPromise = <T>() => {
   const promiseResolve = useRef<((value: T | PromiseLike<T>) => void) | undefined>();

package/src/utils/textMatcher.test.ts

@@ -1,5 +1,6 @@
-import { textMatch } from "./textMatcher";
+import { describe, expect, test } from 'vitest';
 
+import { textMatch } from './textMatcher';
 /**
  * "L" => L*
  * "=L" => L
@@ -11,18 +12,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) ||