improve customLocatorStrategies playwright helper

Author: kobenguyent

lib/helper/Playwright.js

@@ -44,6 +44,36 @@ if (typeof global.__playwrightSelectorsRegistered === 'undefined') {
   global.__playwrightSelectorsRegistered = false
 }
 
+/**
+ * Creates a Playwright selector engine factory for a custom locator strategy.
+ * @param {string} name - Strategy name for error messages
+ * @param {Function} func - The locator function (selector, root) => Element|Element[]
+ * @returns {Function} Selector engine factory
+ */
+function createCustomSelectorEngine(name, func) {
+  return () => ({
+    create: () => null,
+    query(root, selector) {
+      if (!root) return null
+      try {
+        const result = func(selector, root)
+        return Array.isArray(result) ? result[0] : result
+      } catch (e) {
+        return null
+      }
+    },
+    queryAll(root, selector) {
+      if (!root) return []
+      try {
+        const result = func(selector, root)
+        return Array.isArray(result) ? result : result ? [result] : []
+      } catch (e) {
+        return []
+      }
+    },
+  })
+}
+
 const popupStore = new Popup()
 const consoleLogStore = new Console()
 const availableBrowsers = ['chromium', 'webkit', 'firefox', 'electron']
@@ -358,23 +388,13 @@ class Playwright extends Helper {
 
     // Filter out invalid customLocatorStrategies (empty arrays, objects without functions)
     // This can happen in worker threads where config is serialized/deserialized
-    let validCustomLocators = null
-    if (typeof config.customLocatorStrategies === 'object' && config.customLocatorStrategies !== null) {
-      // Check if it's an empty array or object with no function properties
-      const entries = Object.entries(config.customLocatorStrategies)
-      const hasFunctions = entries.some(([_, value]) => typeof value === 'function')
-      if (hasFunctions) {
-        validCustomLocators = config.customLocatorStrategies
-      }
-    }
-
-    this.customLocatorStrategies = validCustomLocators
+    this.customLocatorStrategies = this._parseCustomLocatorStrategies(config.customLocatorStrategies)
     this._customLocatorsRegistered = false
 
     // Add custom locator strategies to global registry for early registration
     if (this.customLocatorStrategies) {
-      for (const [strategyName, strategyFunction] of Object.entries(this.customLocatorStrategies)) {
-        globalCustomLocatorStrategies.set(strategyName, strategyFunction)
+      for (const [name, func] of Object.entries(this.customLocatorStrategies)) {
+        globalCustomLocatorStrategies.set(name, func)
       }
     }
 
@@ -565,54 +585,23 @@ class Playwright extends Helper {
       }
 
       // Register all custom locator strategies from the global registry
-      for (const [strategyName, strategyFunction] of globalCustomLocatorStrategies.entries()) {
-        if (!registeredCustomLocatorStrategies.has(strategyName)) {
-          try {
-            // Create a selector engine factory function exactly like createValueEngine pattern
-            // Capture variables in closure to avoid reference issues
-            const createCustomEngine = ((name, func) => {
-              return () => {
-                return {
-                  create() {
-                    return null
-                  },
-                  query(root, selector) {
-                    try {
-                      if (!root) return null
-                      const result = func(selector, root)
-                      return Array.isArray(result) ? result[0] : result
-                    } catch (error) {
-                      console.warn(`Error in custom locator "${name}":`, error)
-                      return null
-                    }
-                  },
-                  queryAll(root, selector) {
-                    try {
-                      if (!root) return []
-                      const result = func(selector, root)
-                      return Array.isArray(result) ? result : result ? [result] : []
-                    } catch (error) {
-                      console.warn(`Error in custom locator "${name}":`, error)
-                      return []
-                    }
-                  },
-                }
-              }
-            })(strategyName, strategyFunction)
+      await this._registerGlobalCustomLocators()
+    } catch (e) {
+      console.warn(e)
+    }
+  }
 
-            await playwright.selectors.register(strategyName, createCustomEngine)
-            registeredCustomLocatorStrategies.add(strategyName)
-          } catch (error) {
-            if (!error.message.includes('already registered')) {
-              console.warn(`Failed to register custom locator strategy '${strategyName}':`, error)
-            } else {
-              console.log(`Custom locator strategy '${strategyName}' already registered`)
-            }
-          }
+  async _registerGlobalCustomLocators() {
+    for (const [name, func] of globalCustomLocatorStrategies.entries()) {
+      if (registeredCustomLocatorStrategies.has(name)) continue
+      try {
+        await playwright.selectors.register(name, createCustomSelectorEngine(name, func))
+        registeredCustomLocatorStrategies.add(name)
+      } catch (e) {
+        if (!e.message.includes('already registered')) {
+          this.debugSection('Custom Locator', `Failed to register '${name}': ${e.message}`)
         }
       }
-    } catch (e) {
-      console.warn(e)
     }
   }
 
@@ -1277,28 +1266,31 @@ class Playwright extends Helper {
     return this.browser
   }
 
+  _hasCustomLocatorStrategies() {
+    return !!(this.customLocatorStrategies && Object.keys(this.customLocatorStrategies).length > 0)
+  }
+
+  _parseCustomLocatorStrategies(strategies) {
+    if (typeof strategies !== 'object' || strategies === null) return null
+    const hasValidFunctions = Object.values(strategies).some(v => typeof v === 'function')
+    return hasValidFunctions ? strategies : null
+  }
+
   _lookupCustomLocator(customStrategy) {
-    if (typeof this.customLocatorStrategies !== 'object' || this.customLocatorStrategies === null) {
-      return null
-    }
+    if (!this._hasCustomLocatorStrategies()) return null
     const strategy = this.customLocatorStrategies[customStrategy]
     return typeof strategy === 'function' ? strategy : null
   }
 
   _isCustomLocator(locator) {
     const locatorObj = new Locator(locator)
-    if (locatorObj.isCustom()) {
-      const customLocator = this._lookupCustomLocator(locatorObj.type)
-      if (customLocator) {
-        return true
-      }
-      throw new Error('Please define "customLocatorStrategies" as an Object and the Locator Strategy as a "function".')
-    }
-    return false
+    if (!locatorObj.isCustom()) return false
+    if (this._lookupCustomLocator(locatorObj.type)) return true
+    throw new Error('Please define "customLocatorStrategies" as an Object and the Locator Strategy as a "function".')
   }
 
   _isCustomLocatorStrategyDefined() {
-    return !!(this.customLocatorStrategies && Object.keys(this.customLocatorStrategies).length > 0)
+    return this._hasCustomLocatorStrategies()
   }
 
   /**
@@ -1321,49 +1313,16 @@ class Playwright extends Helper {
   }
 
   async _registerCustomLocatorStrategies() {
-    if (!this.customLocatorStrategies) return
-
-    for (const [strategyName, strategyFunction] of Object.entries(this.customLocatorStrategies)) {
-      if (!registeredCustomLocatorStrategies.has(strategyName)) {
-        try {
-          const createCustomEngine = ((name, func) => {
-            return () => {
-              return {
-                create(root, target) {
-                  return null
-                },
-                query(root, selector) {
-                  try {
-                    if (!root) return null
-                    const result = func(selector, root)
-                    return Array.isArray(result) ? result[0] : result
-                  } catch (error) {
-                    console.warn(`Error in custom locator "${name}":`, error)
-                    return null
-                  }
-                },
-                queryAll(root, selector) {
-                  try {
-                    if (!root) return []
-                    const result = func(selector, root)
-                    return Array.isArray(result) ? result : result ? [result] : []
-                  } catch (error) {
-                    console.warn(`Error in custom locator "${name}":`, error)
-                    return []
-                  }
-                },
-              }
-            }
-          })(strategyName, strategyFunction)
+    if (!this._hasCustomLocatorStrategies()) return
 
-          await playwright.selectors.register(strategyName, createCustomEngine)
-          registeredCustomLocatorStrategies.add(strategyName)
-        } catch (error) {
-          if (!error.message.includes('already registered')) {
-            console.warn(`Failed to register custom locator strategy '${strategyName}':`, error)
-          } else {
-            console.log(`Custom locator strategy '${strategyName}' already registered`)
-          }
+    for (const [name, func] of Object.entries(this.customLocatorStrategies)) {
+      if (registeredCustomLocatorStrategies.has(name)) continue
+      try {
+        await playwright.selectors.register(name, createCustomSelectorEngine(name, func))
+        registeredCustomLocatorStrategies.add(name)
+      } catch (e) {
+        if (!e.message.includes('already registered')) {
+          this.debugSection('Custom Locator', `Failed to register '${name}': ${e.message}`)
         }
       }
     }