@linzjs/step-ag-grid 15.1.0 → 15.1.2

package/dist/src/utils/testQuick.d.ts

@@ -53,7 +53,7 @@ export declare const getAllQuick: <T extends HTMLElement>(filter: IQueryQuick, c
  */
 export declare const getQuick: (filter: IQueryQuick, container?: HTMLElement) => HTMLElement;
 /**
- * Find by filter.  Waits up to 4 seconds to find filter.
+ * Find by filter.  Waits up to 5 seconds to find filter.
  *
  * @param filter Filter
  * @param container Optional container to look in

package/dist/src/utils/testUtil.d.ts

@@ -1,3 +1,8 @@
+/**
+ * allow external userEvent to be used
+ * @param customisedUserEvent
+ */
+export declare const setUpUserEvent: (customisedUserEvent: any) => void;
 export declare const countRows: (within?: HTMLElement) => Promise<number>;
 export declare const findRow: (rowId: number | string, within?: HTMLElement) => Promise<HTMLDivElement>;
 export declare const queryRow: (rowId: number | string, within?: HTMLElement) => Promise<HTMLDivElement | null>;

package/dist/step-ag-grid.cjs.js

@@ -28392,14 +28392,14 @@ const getQuick = (filter, container) => {
     return el;
 };
 /**
- * Find by filter.  Waits up to 4 seconds to find filter.
+ * Find by filter.  Waits up to 5 seconds to find filter.
  *
  * @param filter Filter
  * @param container Optional container to look in
  * @return HTMLElement.  Throws exception if not found.
  */
 const findQuick = async (filter, container) => {
-    const endTime = Date.now() + 4000;
+    const endTime = Date.now() + 5000;
     while (Date.now() < endTime) {
         const el = queryQuick(filter, container);
         if (el)
@@ -28409,46 +28409,42 @@ const findQuick = async (filter, container) => {
     throw Error(`findQuick not found, selector: ${quickSelector(filter).selector}`);
 };
 
+let user = userEvent;
+/**
+ * allow external userEvent to be used
+ * @param customisedUserEvent
+ */
+const setUpUserEvent = (customisedUserEvent) => {
+    user = customisedUserEvent;
+};
 const countRows = async (within) => {
     return getAllQuick({ tagName: `div[row-id]:not(:empty)` }, within).length;
 };
 const findRow = async (rowId, within) => {
-    //if this is not wrapped in an act console errors are logged during testing
-    let row;
-    await act(async () => {
-        row = await findQuick({ tagName: `div[row-id='${rowId}']:not(:empty)` }, within);
-    });
-    return row;
+    return await findQuick({ tagName: `div[row-id='${rowId}']:not(:empty)` }, within);
 };
 const queryRow = async (rowId, within) => {
     return queryQuick({ tagName: `div[row-id='${rowId}']:not(:empty)` }, within);
 };
 const _selectRow = async (select, rowId, within) => {
-    await act(async () => {
-        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 userEvent.click(cell);
-            await waitForWrapper$1(async () => {
-                const row = await findRow(rowId, within);
-                const nowSelected = row.className.includes("ag-row-selected");
-                if (nowSelected == isSelected)
-                    throw `Row ${rowId} won't select`;
-            });
-        }
-    });
+    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 waitForWrapper$1(async () => {
+            const row = await findRow(rowId, within);
+            const nowSelected = row.className.includes("ag-row-selected");
+            if (nowSelected === isSelected)
+                throw `Row ${rowId} won't select`;
+        });
+    }
 };
 const selectRow = async (rowId, within) => _selectRow("select", rowId, within);
 const deselectRow = async (rowId, within) => _selectRow("deselect", rowId, within);
 const findCell = async (rowId, colId, within) => {
-    //if this is not wrapped in an act console errors are logged during testing
-    let cell;
-    await act(async () => {
-        const row = await findRow(rowId, within);
-        cell = await findQuick({ tagName: `[col-id='${colId}']` }, row);
-    });
-    return cell;
+    const row = await findRow(rowId, within);
+    return await findQuick({ tagName: `[col-id='${colId}']` }, row);
 };
 const findCellContains = async (rowId, colId, text, within) => {
     return await waitForWrapper$1(async () => {
@@ -28457,16 +28453,12 @@ const findCellContains = async (rowId, colId, text, within) => {
     }, { timeout: 10000 });
 };
 const selectCell = async (rowId, colId, within) => {
-    await act(async () => {
-        const cell = await findCell(rowId, colId, within);
-        await userEvent.click(cell);
-    });
+    const cell = await findCell(rowId, colId, within);
+    await user.click(cell);
 };
 const editCell = async (rowId, colId, within) => {
-    await act(async () => {
-        const cell = await findCell(rowId, colId, within);
-        await userEvent.dblClick(cell);
-    });
+    const cell = await findCell(rowId, colId, within);
+    await user.dblClick(cell);
     await waitForWrapper$1(findOpenPopover);
 };
 const isCellReadOnly = async (rowId, colId, within) => {
@@ -28497,10 +28489,8 @@ const validateMenuOptions = async (rowId, colId, expectedMenuOptions) => {
     return lodashEs.isEqual(actualOptions, expectedMenuOptions);
 };
 const clickMenuOption = async (menuOptionText) => {
-    await act(async () => {
-        const menuOption = await findMenuOption(menuOptionText);
-        await userEvent.click(menuOption);
-    });
+    const menuOption = await findMenuOption(menuOptionText);
+    await user.click(menuOption);
 };
 const openAndClickMenuOption = async (rowId, colId, menuOptionText, within) => {
     await editCell(rowId, colId, within);
@@ -28525,21 +28515,21 @@ const findMultiSelectOption = async (value) => {
 };
 const clickMultiSelectOption = async (value) => {
     const menuItem = await findMultiSelectOption(value);
-    menuItem.parentElement && (await userEvent.click(menuItem.parentElement));
+    menuItem.parentElement && (await user.click(menuItem.parentElement));
 };
-const typeInput = async (value, filter) => act(async () => {
+const typeInput = async (value, filter) => {
     const openMenu = await findOpenPopover();
     const input = await findQuick(filter, openMenu);
-    await userEvent.clear(input);
+    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 userEvent.type(input, value);
+        await user.type(input, value);
     }
-});
+};
 const typeOnlyInput = async (value) => typeInput(value, { child: { tagName: "input[type='text'], textarea" } });
 const typeInputByLabel = async (value, labelText) => {
-    const labels = getAllQuick({ child: { tagName: "label" } }).filter((l) => l.textContent == labelText);
-    if (labels.length == 0) {
+    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) {
@@ -28553,14 +28543,12 @@ const typeInputByPlaceholder = async (value, placeholder) => typeInput(value, {
 });
 const typeOtherInput = async (value) => typeInput(value, { classes: ".subComponent", child: { tagName: "input[type='text']" } });
 const typeOtherTextArea = async (value) => typeInput(value, { classes: ".subComponent", child: { tagName: "textarea" } });
-const closeMenu = () => userEvent.click(document.body);
-const closePopover = () => userEvent.click(document.body);
+const closeMenu = () => user.click(document.body);
+const closePopover = () => user.click(document.body);
 const findActionButton = (text, container) => findQuick({ tagName: "button", child: { classes: ".ActionButton-minimalAreaDisplay", text: text } }, container);
 const clickActionButton = async (text, container) => {
-    await act(async () => {
-        const button = await findActionButton(text, container);
-        await userEvent.click(button);
-    });
+    const button = await findActionButton(text, container);
+    await user.click(button);
 };
 
 exports.ActionButton = ActionButton;
@@ -28671,6 +28659,7 @@ exports.queryRow = queryRow;
 exports.sanitiseFileName = sanitiseFileName;
 exports.selectCell = selectCell;
 exports.selectRow = selectRow;
+exports.setUpUserEvent = setUpUserEvent;
 exports.stringByteLengthIsInvalid = stringByteLengthIsInvalid;
 exports.suppressCellKeyboardEvents = suppressCellKeyboardEvents;
 exports.typeInputByLabel = typeInputByLabel;