@dev-blinq/cucumber_client 1.0.1431-dev → 1.0.1431-stage

package/bin/assets/scripts/dom_attr.js

@@ -1,372 +1,372 @@
-
 class DOM_Attr {
-    /**
-     * Finds attributes that are unique to the target element
-     * @param {Element} target - Target element
-     * @param {Element[]} similarElements - Array of similar elements to compare against
-     * @returns {Object} - Object with unique attribute names as keys and their values
-     */
-    findUniqueAttributes(target, similarElements) {
-        if (!target || !Array.isArray(similarElements)) return {};
-
-        const targetAttrs = getElementAttributes(target);
-        const uniqueAttrs = {};
-
-        // Check each attribute of the target
-        for (const [attrName, attrValue] of Object.entries(targetAttrs)) {
-            let isUnique = true;
-
-            // Check if any similar element has the same attribute with the same value
-            for (const element of similarElements) {
-                if (element === target) continue; // Skip self
-
-                const elementAttrs = getElementAttributes(element);
-                if (elementAttrs[attrName] === attrValue) {
-                    isUnique = false;
-                    break;
-                }
-            }
-
-            if (isUnique) {
-                uniqueAttrs[attrName] = attrValue;
-            }
+  /**
+   * Finds attributes that are unique to the target element
+   * @param {Element} target - Target element
+   * @param {Element[]} similarElements - Array of similar elements to compare against
+   * @returns {Object} - Object with unique attribute names as keys and their values
+   */
+  findUniqueAttributes(target, similarElements) {
+    if (!target || !Array.isArray(similarElements)) return {};
+
+    const targetAttrs = getElementAttributes(target);
+    const uniqueAttrs = {};
+
+    // Check each attribute of the target
+    for (const [attrName, attrValue] of Object.entries(targetAttrs)) {
+      let isUnique = true;
+
+      // Check if any similar element has the same attribute with the same value
+      for (const element of similarElements) {
+        if (element === target) continue; // Skip self
+
+        const elementAttrs = getElementAttributes(element);
+        if (elementAttrs[attrName] === attrValue) {
+          isUnique = false;
+          break;
         }
+      }
 
-        return uniqueAttrs;
+      if (isUnique) {
+        uniqueAttrs[attrName] = attrValue;
+      }
     }
 
-    /**
- * Finds attributes that exist on target but not on similar elements
- * @param {Element} target - Target element
- * @param {Element[]} similarElements - Array of similar elements to compare against
- * @returns {Object} - Object with attribute names that only target has
- */
-    findExclusiveAttributes(target, similarElements) {
-        if (!target || !Array.isArray(similarElements)) return {};
-
-        const targetAttrs = getElementAttributes(target);
-        const exclusiveAttrs = {};
-
-        // Check each attribute of the target
-        for (const [attrName, attrValue] of Object.entries(targetAttrs)) {
-            let hasAttribute = false;
-
-            // Check if any similar element has this attribute (regardless of value)
-            for (const element of similarElements) {
-                if (element === target) continue; // Skip self
-
-                if (element.hasAttribute(attrName)) {
-                    hasAttribute = true;
-                    break;
-                }
-            }
-
-            if (!hasAttribute) {
-                exclusiveAttrs[attrName] = attrValue;
-            }
-        }
+    return uniqueAttrs;
+  }
 
-        return exclusiveAttrs;
-    }
-    /**
-     * Finds classnames that are unique to the target element
-     * @param {Element} target - Target element
-     * @param {Element[]} similarElements - Array of similar elements to compare against
-     * @returns {Set<string>} - Set of unique classnames
-     */
-    findUniqueClassNames(target, similarElements) {
-        if (!target || !Array.isArray(similarElements)) return new Set();
-
-        const targetClasses = getElementClassNames(target);
-        const uniqueClasses = new Set();
-
-        // Check each class of the target
-        for (const className of targetClasses) {
-            let isUnique = true;
-
-            // Check if any similar element has the same class
-            for (const element of similarElements) {
-                if (element === target) continue; // Skip self
-
-                const elementClasses = getElementClassNames(element);
-                if (elementClasses.has(className)) {
-                    isUnique = false;
-                    break;
-                }
-            }
-
-            if (isUnique) {
-                uniqueClasses.add(className);
-            }
-        }
+  /**
+   * Finds attributes that exist on target but not on similar elements
+   * @param {Element} target - Target element
+   * @param {Element[]} similarElements - Array of similar elements to compare against
+   * @returns {Object} - Object with attribute names that only target has
+   */
+  findExclusiveAttributes(target, similarElements) {
+    if (!target || !Array.isArray(similarElements)) return {};
 
-        return uniqueClasses;
-    }
+    const targetAttrs = getElementAttributes(target);
+    const exclusiveAttrs = {};
 
-    /**
-     * Finds attributes with different values between target and similar elements
-     * @param {Element} target - Target element
-     * @param {Element[]} similarElements - Array of similar elements to compare against
-     * @returns {Object} - Object with attribute names as keys and comparison info as values
-     */
-    findDifferentValueAttributes(target, similarElements) {
-        if (!target || !Array.isArray(similarElements)) return {};
-
-        const targetAttrs = getElementAttributes(target);
-        const differentAttrs = {};
-
-        // Get all attributes from all elements
-        const allAttributes = new Set(Object.keys(targetAttrs));
-        similarElements.forEach(element => {
-            if (element !== target) {
-                const attrs = getElementAttributes(element);
-                Object.keys(attrs).forEach(attr => allAttributes.add(attr));
-            }
-        });
+    // Check each attribute of the target
+    for (const [attrName, attrValue] of Object.entries(targetAttrs)) {
+      let hasAttribute = false;
 
-        // Check each attribute
-        for (const attrName of allAttributes) {
-            const targetValue = targetAttrs[attrName];
-            const otherValues = [];
-
-            similarElements.forEach(element => {
-                if (element !== target) {
-                    const attrs = getElementAttributes(element);
-                    const value = attrs[attrName];
-                    if (value !== undefined && value !== targetValue) {
-                        otherValues.push(value);
-                    }
-                }
-            });
-
-            if (otherValues.length > 0) {
-                differentAttrs[attrName] = {
-                    targetValue: targetValue || null,
-                    otherValues: [...new Set(otherValues)] // Remove duplicates
-                };
-            }
+      // Check if any similar element has this attribute (regardless of value)
+      for (const element of similarElements) {
+        if (element === target) continue; // Skip self
+
+        if (element.hasAttribute(attrName)) {
+          hasAttribute = true;
+          break;
         }
+      }
 
-        return differentAttrs;
+      if (!hasAttribute) {
+        exclusiveAttrs[attrName] = attrValue;
+      }
     }
 
-    /**
- * Main function: Finds all differentiating attributes and classnames
- * @param {Element} target - Target element to find differentiators for
- * @param {Element[]} similarElements - Array of similar elements to compare against
- * @param {Object} options - Options for the comparison
- * @param {boolean} options.includeComputedStyles - Whether to include computed style differences
- * @param {string[]} options.styleProperties - Array of CSS properties to check if includeComputedStyles is true
- * @param {boolean} options.ignoreDataAttributes - Whether to ignore data-* attributes
- * @param {boolean} options.ignoreAriaAttributes - Whether to ignore aria-* attributes
- * @param {string[]} options.ignoreAttributes - Array of attribute names to ignore
- * @param {boolean} options.caseSensitiveClasses - Whether class comparison should be case sensitive
- * @returns {Object} - Comprehensive differentiating information
- */
-    findDifferentiatingAttributes(target, similarElements, options = {}) {
-        const {
-            includeComputedStyles = false,
-            styleProperties = ['color', 'background-color', 'font-size', 'display', 'position'],
-            ignoreDataAttributes = false,
-            ignoreAriaAttributes = false,
-            ignoreAttributes = [],
-            caseSensitiveClasses = true
-        } = options;
-
-        // Validate inputs
-        if (!target) {
-            throw new Error('Target element is required');
+    return exclusiveAttrs;
+  }
+  /**
+   * Finds classnames that are unique to the target element
+   * @param {Element} target - Target element
+   * @param {Element[]} similarElements - Array of similar elements to compare against
+   * @returns {Set<string>} - Set of unique classnames
+   */
+  findUniqueClassNames(target, similarElements) {
+    if (!target || !Array.isArray(similarElements)) return new Set();
+
+    const targetClasses = getElementClassNames(target);
+    const uniqueClasses = new Set();
+
+    // Check each class of the target
+    for (const className of targetClasses) {
+      let isUnique = true;
+
+      // Check if any similar element has the same class
+      for (const element of similarElements) {
+        if (element === target) continue; // Skip self
+
+        const elementClasses = getElementClassNames(element);
+        if (elementClasses.has(className)) {
+          isUnique = false;
+          break;
         }
+      }
 
-        if (!Array.isArray(similarElements)) {
-            throw new Error('similarElements must be an array');
-        }
+      if (isUnique) {
+        uniqueClasses.add(className);
+      }
+    }
 
-        // Filter out the target from similar elements if it exists
-        const filteredSimilarElements = similarElements.filter(el => el !== target);
-
-        if (filteredSimilarElements.length === 0) {
-            return {
-                uniqueAttributes: getElementAttributes(target),
-                exclusiveAttributes: getElementAttributes(target),
-                uniqueClassNames: getElementClassNames(target),
-                differentValueAttributes: {},
-                computedStyleDifferences: {},
-                summary: {
-                    hasUniqueAttributes: Object.keys(getElementAttributes(target)).length > 0,
-                    hasUniqueClasses: getElementClassNames(target).size > 0,
-                    totalDifferences: Object.keys(getElementAttributes(target)).length + getElementClassNames(target).size
-                }
-            };
+    return uniqueClasses;
+  }
+
+  /**
+   * Finds attributes with different values between target and similar elements
+   * @param {Element} target - Target element
+   * @param {Element[]} similarElements - Array of similar elements to compare against
+   * @returns {Object} - Object with attribute names as keys and comparison info as values
+   */
+  findDifferentValueAttributes(target, similarElements) {
+    if (!target || !Array.isArray(similarElements)) return {};
+
+    const targetAttrs = getElementAttributes(target);
+    const differentAttrs = {};
+
+    // Get all attributes from all elements
+    const allAttributes = new Set(Object.keys(targetAttrs));
+    similarElements.forEach((element) => {
+      if (element !== target) {
+        const attrs = getElementAttributes(element);
+        Object.keys(attrs).forEach((attr) => allAttributes.add(attr));
+      }
+    });
+
+    // Check each attribute
+    for (const attrName of allAttributes) {
+      const targetValue = targetAttrs[attrName];
+      const otherValues = [];
+
+      similarElements.forEach((element) => {
+        if (element !== target) {
+          const attrs = getElementAttributes(element);
+          const value = attrs[attrName];
+          if (value !== undefined && value !== targetValue) {
+            otherValues.push(value);
+          }
         }
+      });
 
-        // Helper function to filter attributes based on options
-        const shouldIgnoreAttribute = (attrName) => {
-            if (ignoreAttributes.includes(attrName)) return true;
-            if (ignoreDataAttributes && attrName.startsWith('data-')) return true;
-            if (ignoreAriaAttributes && attrName.startsWith('aria-')) return true;
-            return false;
-        };
-
-        // Filter attributes for target and similar elements
-        const filterAttributes = (attrs) => {
-            const filtered = {};
-            for (const [name, value] of Object.entries(attrs)) {
-                if (!shouldIgnoreAttribute(name)) {
-                    filtered[name] = value;
-                }
-            }
-            return filtered;
+      if (otherValues.length > 0) {
+        differentAttrs[attrName] = {
+          targetValue: targetValue || null,
+          otherValues: [...new Set(otherValues)], // Remove duplicates
         };
+      }
+    }
 
-        // Get filtered attributes
-        const targetAttrs = filterAttributes(getElementAttributes(target));
+    return differentAttrs;
+  }
+
+  /**
+   * Main function: Finds all differentiating attributes and classnames
+   * @param {Element} target - Target element to find differentiators for
+   * @param {Element[]} similarElements - Array of similar elements to compare against
+   * @param {Object} options - Options for the comparison
+   * @param {boolean} options.includeComputedStyles - Whether to include computed style differences
+   * @param {string[]} options.styleProperties - Array of CSS properties to check if includeComputedStyles is true
+   * @param {boolean} options.ignoreDataAttributes - Whether to ignore data-* attributes
+   * @param {boolean} options.ignoreAriaAttributes - Whether to ignore aria-* attributes
+   * @param {string[]} options.ignoreAttributes - Array of attribute names to ignore
+   * @param {boolean} options.caseSensitiveClasses - Whether class comparison should be case sensitive
+   * @returns {Object} - Comprehensive differentiating information
+   */
+  findDifferentiatingAttributes(target, similarElements, options = {}) {
+    const {
+      includeComputedStyles = false,
+      styleProperties = ["color", "background-color", "font-size", "display", "position"],
+      ignoreDataAttributes = false,
+      ignoreAriaAttributes = false,
+      ignoreAttributes = [],
+      caseSensitiveClasses = true,
+    } = options;
+
+    // Validate inputs
+    if (!target) {
+      throw new Error("Target element is required");
+    }
 
-        // Temporarily override attribute getting to use filtered attributes
-        const originalTarget = { ...target };
-        const originalGetElementAttributes = getElementAttributes;
+    if (!Array.isArray(similarElements)) {
+      throw new Error("similarElements must be an array");
+    }
 
-        const getFilteredAttributes = (element) => {
-            return filterAttributes(originalGetElementAttributes(element));
-        };
+    // Filter out the target from similar elements if it exists
+    const filteredSimilarElements = similarElements.filter((el) => el !== target);
+
+    if (filteredSimilarElements.length === 0) {
+      return {
+        uniqueAttributes: getElementAttributes(target),
+        exclusiveAttributes: getElementAttributes(target),
+        uniqueClassNames: getElementClassNames(target),
+        differentValueAttributes: {},
+        computedStyleDifferences: {},
+        summary: {
+          hasUniqueAttributes: Object.keys(getElementAttributes(target)).length > 0,
+          hasUniqueClasses: getElementClassNames(target).size > 0,
+          totalDifferences: Object.keys(getElementAttributes(target)).length + getElementClassNames(target).size,
+        },
+      };
+    }
 
-        // Find unique attributes (same name and value combination is unique)
-        const uniqueAttributes = {};
-        for (const [attrName, attrValue] of Object.entries(targetAttrs)) {
-            let isUnique = true;
-
-            for (const element of filteredSimilarElements) {
-                const elementAttrs = getFilteredAttributes(element);
-                if (elementAttrs[attrName] === attrValue) {
-                    isUnique = false;
-                    break;
-                }
-            }
-
-            if (isUnique) {
-                uniqueAttributes[attrName] = attrValue;
-            }
+    // Helper function to filter attributes based on options
+    const shouldIgnoreAttribute = (attrName) => {
+      if (ignoreAttributes.includes(attrName)) return true;
+      if (ignoreDataAttributes && attrName.startsWith("data-")) return true;
+      if (ignoreAriaAttributes && attrName.startsWith("aria-")) return true;
+      return false;
+    };
+
+    // Filter attributes for target and similar elements
+    const filterAttributes = (attrs) => {
+      const filtered = {};
+      for (const [name, value] of Object.entries(attrs)) {
+        if (!shouldIgnoreAttribute(name)) {
+          filtered[name] = value;
         }
+      }
+      return filtered;
+    };
+
+    // Get filtered attributes
+    const targetAttrs = filterAttributes(getElementAttributes(target));
+
+    // Temporarily override attribute getting to use filtered attributes
+    const originalTarget = { ...target };
+    const originalGetElementAttributes = getElementAttributes;
+
+    const getFilteredAttributes = (element) => {
+      return filterAttributes(originalGetElementAttributes(element));
+    };
+
+    // Find unique attributes (same name and value combination is unique)
+    const uniqueAttributes = {};
+    for (const [attrName, attrValue] of Object.entries(targetAttrs)) {
+      let isUnique = true;
+
+      for (const element of filteredSimilarElements) {
+        const elementAttrs = getFilteredAttributes(element);
+        if (elementAttrs[attrName] === attrValue) {
+          isUnique = false;
+          break;
+        }
+      }
+
+      if (isUnique) {
+        uniqueAttributes[attrName] = attrValue;
+      }
+    }
+
+    // Find exclusive attributes (target has, others don't)
+    const exclusiveAttributes = {};
+    for (const [attrName, attrValue] of Object.entries(targetAttrs)) {
+      let hasAttribute = false;
 
-        // Find exclusive attributes (target has, others don't)
-        const exclusiveAttributes = {};
-        for (const [attrName, attrValue] of Object.entries(targetAttrs)) {
-            let hasAttribute = false;
-
-            for (const element of filteredSimilarElements) {
-                if (element.hasAttribute(attrName) && !shouldIgnoreAttribute(attrName)) {
-                    hasAttribute = true;
-                    break;
-                }
-            }
-
-            if (!hasAttribute) {
-                exclusiveAttributes[attrName] = attrValue;
-            }
+      for (const element of filteredSimilarElements) {
+        if (element.hasAttribute(attrName) && !shouldIgnoreAttribute(attrName)) {
+          hasAttribute = true;
+          break;
         }
+      }
 
-        // Find unique classnames
-        const targetClasses = getElementClassNames(target);
-        const uniqueClassNames = new Set();
+      if (!hasAttribute) {
+        exclusiveAttributes[attrName] = attrValue;
+      }
+    }
 
-        for (const className of targetClasses) {
-            let isUnique = true;
+    // Find unique classnames
+    const targetClasses = getElementClassNames(target);
+    const uniqueClassNames = new Set();
 
-            for (const element of filteredSimilarElements) {
-                const elementClasses = getElementClassNames(element);
-                const hasClass = caseSensitiveClasses
-                    ? elementClasses.has(className)
-                    : Array.from(elementClasses).some(cls => cls.toLowerCase() === className.toLowerCase());
+    for (const className of targetClasses) {
+      let isUnique = true;
 
-                if (hasClass) {
-                    isUnique = false;
-                    break;
-                }
-            }
+      for (const element of filteredSimilarElements) {
+        const elementClasses = getElementClassNames(element);
+        const hasClass = caseSensitiveClasses
+          ? elementClasses.has(className)
+          : Array.from(elementClasses).some((cls) => cls.toLowerCase() === className.toLowerCase());
 
-            if (isUnique) {
-                uniqueClassNames.add(className);
-            }
+        if (hasClass) {
+          isUnique = false;
+          break;
         }
+      }
 
-        // Find different value attributes
-        const differentValueAttributes = {};
-        const allAttributes = new Set(Object.keys(targetAttrs));
+      if (isUnique) {
+        uniqueClassNames.add(className);
+      }
+    }
 
-        filteredSimilarElements.forEach(element => {
-            const attrs = getFilteredAttributes(element);
-            Object.keys(attrs).forEach(attr => allAttributes.add(attr));
-        });
+    // Find different value attributes
+    const differentValueAttributes = {};
+    const allAttributes = new Set(Object.keys(targetAttrs));
 
-        for (const attrName of allAttributes) {
-            const targetValue = targetAttrs[attrName];
-            const otherValues = [];
-
-            filteredSimilarElements.forEach(element => {
-                const attrs = getFilteredAttributes(element);
-                const value = attrs[attrName];
-                if (value !== undefined && value !== targetValue) {
-                    otherValues.push(value);
-                }
-            });
-
-            if (otherValues.length > 0) {
-                differentValueAttributes[attrName] = {
-                    targetValue: targetValue || null,
-                    otherValues: [...new Set(otherValues)]
-                };
-            }
-        }
+    filteredSimilarElements.forEach((element) => {
+      const attrs = getFilteredAttributes(element);
+      Object.keys(attrs).forEach((attr) => allAttributes.add(attr));
+    });
 
-        // Computed style differences
-        let computedStyleDifferences = {};
-        if (includeComputedStyles) {
-            const targetStyles = getComputedStyles(target, styleProperties);
-
-            for (const property of styleProperties) {
-                const targetValue = targetStyles[property];
-                const otherValues = [];
-
-                filteredSimilarElements.forEach(element => {
-                    const elementStyles = getComputedStyles(element, [property]);
-                    const value = elementStyles[property];
-                    if (value && value !== targetValue) {
-                        otherValues.push(value);
-                    }
-                });
-
-                if (otherValues.length > 0) {
-                    computedStyleDifferences[property] = {
-                        targetValue,
-                        otherValues: [...new Set(otherValues)]
-                    };
-                }
-            }
+    for (const attrName of allAttributes) {
+      const targetValue = targetAttrs[attrName];
+      const otherValues = [];
+
+      filteredSimilarElements.forEach((element) => {
+        const attrs = getFilteredAttributes(element);
+        const value = attrs[attrName];
+        if (value !== undefined && value !== targetValue) {
+          otherValues.push(value);
         }
+      });
 
-        // Generate summary
-        const summary = {
-            hasUniqueAttributes: Object.keys(uniqueAttributes).length > 0,
-            hasExclusiveAttributes: Object.keys(exclusiveAttributes).length > 0,
-            hasUniqueClasses: uniqueClassNames.size > 0,
-            hasDifferentValues: Object.keys(differentValueAttributes).length > 0,
-            hasStyleDifferences: Object.keys(computedStyleDifferences).length > 0,
-            totalDifferences: Object.keys(uniqueAttributes).length +
-                uniqueClassNames.size +
-                Object.keys(differentValueAttributes).length +
-                Object.keys(computedStyleDifferences).length,
-            comparedAgainst: filteredSimilarElements.length
+      if (otherValues.length > 0) {
+        differentValueAttributes[attrName] = {
+          targetValue: targetValue || null,
+          otherValues: [...new Set(otherValues)],
         };
+      }
+    }
 
-        return {
-            uniqueAttributes,
-            exclusiveAttributes,
-            uniqueClassNames,
-            differentValueAttributes,
-            computedStyleDifferences,
-            summary
-        };
+    // Computed style differences
+    let computedStyleDifferences = {};
+    if (includeComputedStyles) {
+      const targetStyles = getComputedStyles(target, styleProperties);
+
+      for (const property of styleProperties) {
+        const targetValue = targetStyles[property];
+        const otherValues = [];
+
+        filteredSimilarElements.forEach((element) => {
+          const elementStyles = getComputedStyles(element, [property]);
+          const value = elementStyles[property];
+          if (value && value !== targetValue) {
+            otherValues.push(value);
+          }
+        });
+
+        if (otherValues.length > 0) {
+          computedStyleDifferences[property] = {
+            targetValue,
+            otherValues: [...new Set(otherValues)],
+          };
+        }
+      }
     }
+
+    // Generate summary
+    const summary = {
+      hasUniqueAttributes: Object.keys(uniqueAttributes).length > 0,
+      hasExclusiveAttributes: Object.keys(exclusiveAttributes).length > 0,
+      hasUniqueClasses: uniqueClassNames.size > 0,
+      hasDifferentValues: Object.keys(differentValueAttributes).length > 0,
+      hasStyleDifferences: Object.keys(computedStyleDifferences).length > 0,
+      totalDifferences:
+        Object.keys(uniqueAttributes).length +
+        uniqueClassNames.size +
+        Object.keys(differentValueAttributes).length +
+        Object.keys(computedStyleDifferences).length,
+      comparedAgainst: filteredSimilarElements.length,
+    };
+
+    return {
+      uniqueAttributes,
+      exclusiveAttributes,
+      uniqueClassNames,
+      differentValueAttributes,
+      computedStyleDifferences,
+      summary,
+    };
+  }
 }
 
-export default DOM_Attr;
+export default DOM_Attr;