@afixt/test-utils 1.0.1 → 1.1.0

package/src/index.js

@@ -5,60 +5,103 @@
  */
 
 // Array utilities
-export * from './arrayUtils.js';
+const arrayUtils = require('./arrayUtils.js');
 
 // DOM utilities
-export * from './domUtils.js';
+const domUtils = require('./domUtils.js');
 
 // Accessibility name computation
-export * from './getAccessibleName.js';
-export * from './getAccessibleText.js';
-export * from './hasAccessibleName.js';
+const getAccessibleName = require('./getAccessibleName.js');
+const getAccessibleText = require('./getAccessibleText.js');
+const hasAccessibleName = require('./hasAccessibleName.js');
 
 // ARIA utilities
-export * from './getAriaAttributesByElement.js';
-export * from './hasValidAriaAttributes.js';
-export * from './hasValidAriaRole.js';
-export * from './isAriaAttributesValid.js';
-export * from './interactiveRoles.js';
+const getAriaAttributesByElement = require('./getAriaAttributesByElement.js');
+const hasValidAriaAttributes = require('./hasValidAriaAttributes.js');
+const hasValidAriaRole = require('./hasValidAriaRole.js');
+const isAriaAttributesValid = require('./isAriaAttributesValid.js');
+const interactiveRoles = require('./interactiveRoles.js');
 
 // CSS utilities
-export * from './getCSSGeneratedContent.js';
-export * from './getGeneratedContent.js';
-export * from './getStyleObject.js';
-export * from './hasCSSGeneratedContent.js';
+const getCSSGeneratedContent = require('./getCSSGeneratedContent.js');
+const getGeneratedContent = require('./getGeneratedContent.js');
+const getStyleObject = require('./getStyleObject.js');
+const hasCSSGeneratedContent = require('./hasCSSGeneratedContent.js');
 
 // Table utilities
-export * from './isComplexTable.js';
-export * from './isDataTable.js';
+const isComplexTable = require('./isComplexTable.js');
+const isDataTable = require('./isDataTable.js');
 
 // Visibility and positioning
-export * from './isHidden.js';
-export * from './isOffScreen.js';
-export * from './isVisible.js';
-export * from './hasHiddenParent.js';
+const isHidden = require('./isHidden.js');
+const isOffScreen = require('./isOffScreen.js');
+const isVisible = require('./isVisible.js');
+const hasHiddenParent = require('./hasHiddenParent.js');
 
 // Element relationships
-export * from './hasParent.js';
-export * from './hasAttribute.js';
+const hasParent = require('./hasParent.js');
+const hasAttribute = require('./hasAttribute.js');
 
 // Focus management
-export * from './getFocusableElements.js';
-export * from './isFocusable.js';
+const getFocusableElements = require('./getFocusableElements.js');
+const isFocusable = require('./isFocusable.js');
 
 // Role computation
-export * from './getComputedRole.js';
+const getComputedRole = require('./getComputedRole.js');
 
 // Image utilities
-export * from './getImageText.js';
+const getImageText = require('./getImageText.js');
 
 // Testing utilities
-export * from './testContrast.js';
-export * from './testLang.js';
-export * from './testOrder.js';
+const testContrast = require('./testContrast.js');
+const testLang = require('./testLang.js');
+const testOrder = require('./testOrder.js');
 
 // URL utilities
-export * from './isValidUrl.js';
+const isValidUrl = require('./isValidUrl.js');
 
 // String utilities
-export * from './stringUtils.js';
+const stringUtils = require('./stringUtils.js');
+
+// Query cache utilities
+const queryCache = require('./queryCache.js');
+
+// List event listeners
+const listEventListeners = require('./listEventListeners.js');
+
+// Export all utilities
+module.exports = {
+    ...arrayUtils,
+    ...domUtils,
+    ...getAccessibleName,
+    ...getAccessibleText,
+    ...hasAccessibleName,
+    ...getAriaAttributesByElement,
+    ...hasValidAriaAttributes,
+    ...hasValidAriaRole,
+    ...isAriaAttributesValid,
+    ...interactiveRoles,
+    ...getCSSGeneratedContent,
+    ...getGeneratedContent,
+    ...getStyleObject,
+    ...hasCSSGeneratedContent,
+    ...isComplexTable,
+    ...isDataTable,
+    ...isHidden,
+    ...isOffScreen,
+    ...isVisible,
+    ...hasHiddenParent,
+    ...hasParent,
+    ...hasAttribute,
+    ...getFocusableElements,
+    ...isFocusable,
+    ...getComputedRole,
+    ...getImageText,
+    ...testContrast,
+    ...testLang,
+    ...testOrder,
+    ...isValidUrl,
+    ...stringUtils,
+    ...queryCache,
+    ...listEventListeners
+};

package/src/interactiveRoles.js

@@ -17,4 +17,4 @@ const interactiveRoles = [
     "tree",
 ];
 
-export default interactiveRoles;
+module.exports = interactiveRoles;

package/src/isAriaAttributesValid.js

@@ -65,10 +65,14 @@ const validAriaAttributes = new Set([
  * @param {string} attributeName - The name of the ARIA attribute to check (e.g., 'aria-label')
  * @returns {boolean} True if the attribute is a valid ARIA attribute, false otherwise
  */
-export function isAriaAttributeValid(attributeName) {
+function isAriaAttributeValid(attributeName) {
     if (!attributeName || typeof attributeName !== 'string') {
         return false;
     }
     
     return validAriaAttributes.has(attributeName.toLowerCase());
-}
+}
+
+module.exports = {
+    isAriaAttributeValid
+};

package/src/isComplexTable.js

@@ -5,7 +5,7 @@
  * @param {HTMLElement} el - The table element to check.
  * @returns {boolean} True if the table has more than one row in the header, otherwise false.
  */
-export function checkMultiRowsInHeader(el) {
+function checkMultiRowsInHeader(el) {
     return el.querySelectorAll("thead tr").length > 1;
 }
 
@@ -17,7 +17,7 @@ export function checkMultiRowsInHeader(el) {
  * @returns {boolean} - Returns true if there are more than one row
  * with at least one cell having a colspan attribute, otherwise false.
  */
-export function checkMultiRowsWithColspan(el) {
+function checkMultiRowsWithColspan(el) {
     let rowsWithColspanCount = 0;
     el.querySelectorAll("tr").forEach((row) => {
         if (row.querySelectorAll("td[colspan]").length >= 1) {
@@ -37,7 +37,7 @@ export function checkMultiRowsWithColspan(el) {
  * @returns {boolean} - Returns `true` if the table has inconsistent
  * row or column spans, otherwise `false`.
  */
-export function checkInconsistent(el) {
+function checkInconsistent(el) {
     let result = false;
     let clone = el.cloneNode(true);
 
@@ -94,7 +94,7 @@ export function checkInconsistent(el) {
  * @param {HTMLElement} el - The table element to check.
  * @returns {boolean} - Returns true if the table is complex, otherwise false.
  */
-export function isComplexTable(el) {
+function isComplexTable(el) {
     if (!el) return true;
     let clone = el.cloneNode(true);
 
@@ -107,3 +107,10 @@ export function isComplexTable(el) {
 
     return multiRowsInHeader || inconsistent || multiRowsWithColspan;
 }
+
+module.exports = {
+    checkMultiRowsInHeader,
+    checkMultiRowsWithColspan,
+    checkInconsistent,
+    isComplexTable
+};

package/src/isDataTable.js

@@ -1,5 +1,5 @@
 // Import using object destructuring for better compatibility with tests
-import { arrayCount } from './arrayUtils.js';
+const { arrayCount } = require('./arrayUtils.js');
 
 /**
  * Returns the number of rows in the given table element.
@@ -98,8 +98,6 @@ function cellColorDiffs(table, maxColors, maxDiffs) {
     return false;
 }
 
-// Export the utility functions
-export { rowCount, cellCount, countBordersPct, colCount, cellColorDiffs };
 
 /**
  * Determines if a given table element is a data table based on various heuristics and options.
@@ -235,5 +233,12 @@ function isDataTable(table, options = {}) {
     return true;
 }
 
-// Export the main function
-export { isDataTable };
+// Export the main function and utility functions
+module.exports = {
+    isDataTable,
+    rowCount,
+    cellCount,
+    countBordersPct,
+    colCount,
+    cellColorDiffs
+};

package/src/isFocusable.js

@@ -3,7 +3,7 @@
  * @param {Element} element - The HTML element to check.
  * @returns {boolean} - Returns true if the element is focusable, otherwise false.
  */
-export function isFocusable(element) {
+function isFocusable(element) {
     if (!element) return false;
 
     const nodeName = element.nodeName.toLowerCase();
@@ -32,3 +32,7 @@ export function isFocusable(element) {
     // This is some other page element that is not normally focusable
     return false;
 }
+
+module.exports = {
+    isFocusable
+};

package/src/isHidden.js

@@ -14,4 +14,4 @@ const isHidden = (element) => {
     );
 };
 
-export default isHidden;
+module.exports = isHidden;

package/src/isOffScreen.js

@@ -3,7 +3,7 @@
  * @param {Element} element - The element to check.
  * @returns {boolean} - True if the element is off-screen, otherwise false.
  */
-export function isOffScreen(element) {
+function isOffScreen(element) {
     if (!element) return false;
 
     const rect = element.getBoundingClientRect();
@@ -14,3 +14,7 @@ export function isOffScreen(element) {
         rect.top > window.innerHeight
     );
 }
+
+module.exports = {
+    isOffScreen
+};

package/src/isValidUrl.js

@@ -3,7 +3,7 @@
  * @param {string} str - The string to validate.
  * @returns {boolean} - Returns true if the string is a valid URL, otherwise false.
  */
-export function isValidUrl(str) {
+function isValidUrl(str) {
     try {
         new URL(str);
         return true;
@@ -11,3 +11,7 @@ export function isValidUrl(str) {
         return false;
     }
 }
+
+module.exports = {
+    isValidUrl
+};

package/src/isVisible.js

@@ -4,7 +4,7 @@
  * @param {boolean} strict - Option to be more strict about visibility of aria-hidden="true" in addition to CSS display: none.
  * @returns {boolean}
  */
-export function isVisible(element, strict = false) {
+function isVisible(element, strict = false) {
     if (!element) return false;
 
     const id = element.id;
@@ -60,3 +60,7 @@ export function isVisible(element, strict = false) {
 
     return visible;
 }
+
+module.exports = {
+    isVisible
+};

package/src/listEventListeners.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const eventListenersMap = new WeakMap();
+
+const originalAddEventListener = EventTarget.prototype.addEventListener;
+const originalRemoveEventListener = EventTarget.prototype.removeEventListener;
+
+// Override addEventListener to track event listeners
+EventTarget.prototype.addEventListener = function (type, listener, options) {
+    if (!eventListenersMap.has(this)) {
+        eventListenersMap.set(this, {});
+    }
+    const listeners = eventListenersMap.get(this);
+
+    if (!listeners[type]) {
+        listeners[type] = [];
+    }
+    listeners[type].push({ listener, options });
+
+    return originalAddEventListener.call(this, type, listener, options);
+};
+
+// Override removeEventListener to remove from tracking
+EventTarget.prototype.removeEventListener = function (type, listener, options) {
+    if (eventListenersMap.has(this)) {
+        const listeners = eventListenersMap.get(this);
+        if (listeners[type]) {
+            listeners[type] = listeners[type].filter((l) => l.listener !== listener);
+        }
+    }
+    return originalRemoveEventListener.call(this, type, listener, options);
+};
+
+// Function to get XPath of an element
+const getXPath = (element) => {
+    if (element.id) {
+        return `//*[@id="${element.id}"]`;
+    }
+    let path = '';
+    while (element && element.nodeType === Node.ELEMENT_NODE) {
+        let index = 0;
+        let sibling = element;
+        while (sibling) {
+            if (sibling.nodeName === element.nodeName) {
+                index++;
+            }
+            sibling = sibling.previousElementSibling;
+        }
+        path = `/${element.nodeName.toLowerCase()}[${index}]` + path;
+        element = element.parentNode;
+    }
+    return path;
+};
+
+// Function to get all event listeners on an element
+const getEventListeners = (element) => {
+    return eventListenersMap.get(element) || {};
+};
+
+/**
+ * List all event listeners for an element and its children
+ * @param {Element} rootElement - The root element to start listing from (defaults to document)
+ * @returns {Array} Array of event listener objects with element, xpath, and event properties
+ */
+const listEventListeners = (rootElement = document) => {
+    const eventListeners = [];
+
+    /**
+     * Process an element to extract its event listeners
+     * @param {Element} el - The element to process
+     */
+    function processElement(el) {
+        const listeners = getEventListeners(el);
+        if (Object.keys(listeners).length > 0) {
+            Object.keys(listeners).forEach((eventName) => {
+                eventListeners.push({
+                    element: el.tagName.toLowerCase(),
+                    xpath: getXPath(el),
+                    event: eventName
+                });
+            });
+        }
+    }
+
+    // Process root element
+    processElement(rootElement);
+
+    // Process child elements
+    rootElement.querySelectorAll('*').forEach(processElement);
+
+    return eventListeners;
+};
+
+// Export functions
+module.exports = { listEventListeners, getEventListeners };