@applitools/eyes-cypress 3.28.0 → 3.28.2

package/src/browser/eyesCheckMapping.js

@@ -1,9 +1,9 @@
 /* global Node */
 function eyesCheckMapValues({args, refer}) {
   if (typeof args === `string`) {
-    args = {tag: args};
+    args = {tag: args}
   }
-  const config = args; // just did it for having less git changes at this moment
+  const config = args // just did it for having less git changes at this moment
   const mappedValues = [
     'tag',
     'scriptHooks',
@@ -16,10 +16,10 @@ function eyesCheckMapValues({args, refer}) {
     'region',
     'selector',
     'element',
-  ];
+  ]
 
-  let regionSettings = {};
-  let shadowDomSettings = {};
+  let regionSettings = {}
+  let shadowDomSettings = {}
   const checkSettings = {
     name: config.tag,
     hooks: config.scriptHooks,
@@ -29,7 +29,7 @@ function eyesCheckMapValues({args, refer}) {
     layoutRegions: convertPaddedRegion(config.layout),
     contentRegions: convertPaddedRegion(config.content),
     accessibilityRegions: convertAccessabilityRegions(config.accessibility),
-  };
+  }
 
   if (config.target === 'region') {
     if (!Array.isArray(config.selector)) {
@@ -37,12 +37,12 @@ function eyesCheckMapValues({args, refer}) {
         if (isHTMLElement(config.element)) {
           regionSettings = {
             region: Object.assign(refer.ref(config.element), {type: 'element'}),
-          };
+          }
         } else {
           // JQuery element
           regionSettings = {
             region: Object.assign(refer.ref(config.element[0]), {type: 'element'}),
-          };
+          }
         }
       } else if (
         config.region &&
@@ -58,114 +58,121 @@ function eyesCheckMapValues({args, refer}) {
             width: config.region.width,
             height: config.region.height,
           },
-        };
+        }
       } else if (!config.hasOwnProperty('selector')) {
         regionSettings = {
           region: config.region,
-        };
+        }
       } else {
         regionSettings = {
           region: config.selector,
-        };
+        }
       }
     } else {
-      const selectors = config.selector;
+      const selectors = config.selector
       for (let i = selectors.length - 1; i > -1; i--) {
         if (i === selectors.length - 1) {
-          shadowDomSettings['shadow'] = selectors[i].selector;
+          shadowDomSettings['shadow'] = selectors[i].selector
         } else {
-          const prevSettings = Object.assign({}, shadowDomSettings);
-          shadowDomSettings['selector'] = selectors[i].selector;
+          const prevSettings = Object.assign({}, shadowDomSettings)
+          shadowDomSettings['selector'] = selectors[i].selector
           if (!prevSettings.hasOwnProperty('selector')) {
-            shadowDomSettings['shadow'] = prevSettings.shadow;
+            shadowDomSettings['shadow'] = prevSettings.shadow
           } else {
-            shadowDomSettings['shadow'] = prevSettings;
+            shadowDomSettings['shadow'] = prevSettings
           }
         }
       }
-      regionSettings = {region: shadowDomSettings};
+      regionSettings = {region: shadowDomSettings}
     }
   }
 
   for (const val of mappedValues) {
     if (config.hasOwnProperty(val)) {
-      delete config[val];
+      delete config[val]
     }
   }
 
-  return Object.assign({}, checkSettings, regionSettings, config);
+  return Object.assign({}, checkSettings, regionSettings, config)
 
   // #region helper functions
 
   function convertPaddedRegion(regions) {
-    if (!regions) return;
-    if (!Array.isArray(regions)) regions = [regions];
-    let resRegions = [];
+    if (!regions) return
+    if (!Array.isArray(regions)) regions = [regions]
+    let resRegions = []
     for (const region of regions) {
       if (region.element || isHTMLElement(region) || region.jquery) {
         if (region.padding || region.regionId) {
-          let currRefElements = refElements(region.element);
+          let currRefElements = refElements(region.element)
           for (const refElement of currRefElements) {
-            let curr = {region: refElement};
+            let curr = {region: refElement}
             if (region.padding) {
-              curr.padding = region.padding;
+              curr.padding = region.padding
             }
             if (region.regionId) {
-              curr.regionId = region.regionId;
+              curr.regionId = region.regionId
             }
-            resRegions.push(curr);
+            resRegions.push(curr)
           }
         } else {
-          resRegions = [...resRegions, ...refElements(region)];
+          resRegions = [...resRegions, ...refElements(region)]
         }
       } else {
         if (region.selector && !region.type) {
-          region.region = region.selector;
-          delete region.selector;
+          region.region = region.selector
+          delete region.selector
         }
-        resRegions.push(region);
+        resRegions.push(region)
       }
     }
-    return resRegions;
+    return resRegions
   }
 
   function convertAccessabilityRegions(accessibilityRegions) {
-    if (!accessibilityRegions) return accessibilityRegions;
-    const accessibility = [];
+    if (!accessibilityRegions) return accessibilityRegions
+    if (!Array.isArray(accessibilityRegions)) {
+      accessibilityRegions = [accessibilityRegions]
+    }
+    const accessibility = []
 
     accessibilityRegions.map(region => {
       const accessabilityRegion = {
         type: region.accessibilityType,
-      };
+      }
       if (region.hasOwnProperty('selector')) {
-        accessabilityRegion.region = region.selector;
-        accessibility.push(accessabilityRegion);
+        accessabilityRegion.region = region.selector
+        accessibility.push(accessabilityRegion)
       } else if (region.hasOwnProperty('element')) {
-        const elements = refElements(region.element);
+        const elements = refElements(region.element)
+        delete region['element']
         for (const element of elements) {
-          accessibility.push(Object.assign({}, accessabilityRegion, {region: element}));
+          accessibility.push(Object.assign({}, region, accessabilityRegion, {region: element}))
         }
       } else if (region.hasOwnProperty('region')) {
-        region.type = region.region.accessibilityType;
-        delete region.region.accessibilityType;
-        accessibility.push(region);
+        region.type = region.region.accessibilityType
+        delete region.region.accessibilityType
+        accessibility.push(region)
       } else {
         accessabilityRegion.region = {
           y: region.top,
           x: region.left,
           width: region.width,
           height: region.height,
-        };
-        accessibility.push(accessabilityRegion);
+        }
+        accessibility.push(accessabilityRegion)
       }
-    });
+    })
 
-    return accessibility;
+    return accessibility
   }
 
   function convertFloatingRegion(floatingRegions) {
-    if (!floatingRegions) return floatingRegions;
-    const floating = [];
+    if (!floatingRegions) return floatingRegions
+    if (!Array.isArray(floatingRegions)) {
+      floatingRegions = [floatingRegions]
+    }
+    const floating = []
 
     for (const region of floatingRegions) {
       const floatingRegion = {
@@ -173,49 +180,48 @@ function eyesCheckMapValues({args, refer}) {
         maxLeftOffset: region.maxLeftOffset || 0,
         maxUpOffset: region.maxUpOffset || 0,
         maxRightOffset: region.maxRightOffset || 0,
-      };
+      }
       if (region.hasOwnProperty('selector')) {
-        floatingRegion.region = region.selector;
-        floating.push(floatingRegion);
+        floatingRegion.region = region.selector
+        floating.push(floatingRegion)
       } else if (region.hasOwnProperty('element')) {
-        const elements = refElements(region.element);
+        const elements = refElements(region.element)
+        delete region['element']
         for (const element of elements) {
-          floating.push(Object.assign({}, floatingRegion, {region: element}));
+          floating.push(Object.assign({}, region, floatingRegion, {region: element}))
         }
       } else if (region.hasOwnProperty('region')) {
-        floating.push(region);
+        floating.push(region)
       } else {
         floatingRegion.region = {
           y: region.top,
           x: region.left,
           width: region.width,
           height: region.height,
-        };
-        floating.push(floatingRegion);
+        }
+        floating.push(floatingRegion)
       }
     }
-    return floating;
+    return floating
   }
 
   function refElements(regions) {
-    if (!regions) return regions;
-    if (!Array.isArray(regions)) regions = [regions];
-    const elements = [];
+    if (!regions) return regions
+    if (!Array.isArray(regions)) regions = [regions]
+    const elements = []
     for (const region of regions) {
       if (isHTMLElement(region)) {
-        elements.push(Object.assign(refer.ref(region), {type: 'element'}));
+        elements.push(Object.assign(refer.ref(region), {type: 'element'}))
       } else if (region.jquery) {
-        region.each(function() {
+        region.each(function () {
           // there's a small chance that `this` is not an HTML element. So we just verify it.
-          elements.push(
-            isHTMLElement(this) ? Object.assign(refer.ref(this), {type: 'element'}) : this,
-          );
-        });
+          elements.push(isHTMLElement(this) ? Object.assign(refer.ref(this), {type: 'element'}) : this)
+        })
       } else {
-        elements.push(region);
+        elements.push(region)
       }
     }
-    return elements;
+    return elements
   }
 
   // #endregion
@@ -224,7 +230,7 @@ function eyesCheckMapValues({args, refer}) {
 function isHTMLElement(element) {
   // Avoiding instanceof here since the element might come from an iframe, and `instanceof HTMLElement` would fail.
   // This check looks naive, but if anyone passes something like {nodeType: 1} as a region, then I'm fine with them crashing :)
-  return element.nodeType && element.nodeType === Node.ELEMENT_NODE;
+  return element.nodeType && element.nodeType === Node.ELEMENT_NODE
 }
 
-module.exports = {eyesCheckMapValues};
+module.exports = {eyesCheckMapValues}

package/src/browser/eyesOpenMapping.js

@@ -1,22 +1,22 @@
 const batchPropertiesRetriever = (args, appliConfFile) => {
-  return function(prop, nestedProp) {
-    nestedProp = nestedProp || prop;
+  return function (prop, nestedProp) {
+    nestedProp = nestedProp || prop
     if (args.hasOwnProperty(prop)) {
-      return args[prop];
+      return args[prop]
     } else if (args.batch && args.batch.hasOwnProperty(nestedProp)) {
-      return args.batch[nestedProp];
+      return args.batch[nestedProp]
     } else if (appliConfFile.hasOwnProperty(prop)) {
-      return appliConfFile[prop];
+      return appliConfFile[prop]
     } else if (appliConfFile.batch && appliConfFile.batch.hasOwnProperty(nestedProp)) {
-      return appliConfFile.batch[nestedProp];
+      return appliConfFile.batch[nestedProp]
     }
-    return undefined;
-  };
-};
+    return undefined
+  }
+}
 function eyesOpenMapValues({args, appliConfFile, testName, shouldUseBrowserHooks}) {
-  let browsersInfo = args.browser || appliConfFile.browser;
-  let accessibilitySettings = args.accessibilityValidation || appliConfFile.accessibilityValidation;
-  const batchProperties = batchPropertiesRetriever(args, appliConfFile);
+  let browsersInfo = args.browser || appliConfFile.browser
+  let accessibilitySettings = args.accessibilityValidation || appliConfFile.accessibilityValidation
+  const batchProperties = batchPropertiesRetriever(args, appliConfFile)
   const batch = {
     id: batchProperties('batchId', 'id'),
     name: batchProperties('batchName', 'name'),
@@ -25,10 +25,10 @@ function eyesOpenMapValues({args, appliConfFile, testName, shouldUseBrowserHooks
     properties:
       (args.batch ? args.batch.properties : undefined) ||
       (appliConfFile.batch ? appliConfFile.batch.properties : undefined),
-  };
+  }
   for (let prop in batch) {
     if (typeof batch[prop] === 'undefined') {
-      delete batch[prop];
+      delete batch[prop]
     }
   }
 
@@ -43,15 +43,15 @@ function eyesOpenMapValues({args, appliConfFile, testName, shouldUseBrowserHooks
     'batchName',
     'batchId',
     'batchSequenceName',
-  ];
+  ]
 
   if (browsersInfo) {
     if (Array.isArray(browsersInfo)) {
       for (const [index, value] of browsersInfo.entries()) {
-        browsersInfo[index] = fillDefaultBrowserName(value);
+        browsersInfo[index] = fillDefaultBrowserName(value)
       }
     } else {
-      browsersInfo = [fillDefaultBrowserName(browsersInfo)];
+      browsersInfo = [fillDefaultBrowserName(browsersInfo)]
     }
   }
 
@@ -62,15 +62,15 @@ function eyesOpenMapValues({args, appliConfFile, testName, shouldUseBrowserHooks
     useDom: args.useDom || appliConfFile.useDom,
     enablePatterns: args.enablePatterns || appliConfFile.enablePatterns,
     ignoreDisplacements: args.ignoreDisplacements || appliConfFile.ignoreDisplacements,
-  };
+  }
 
-  const appliConfFileCopy = {...appliConfFile};
+  const appliConfFileCopy = {...appliConfFile}
   for (const val of mappedValues) {
     if (args.hasOwnProperty(val)) {
-      delete args[val];
+      delete args[val]
     }
     if (appliConfFileCopy.hasOwnProperty(val)) {
-      delete appliConfFileCopy[val];
+      delete appliConfFileCopy[val]
     }
   }
 
@@ -79,27 +79,23 @@ function eyesOpenMapValues({args, appliConfFile, testName, shouldUseBrowserHooks
     browsersInfo,
     defaultMatchSettings,
     batch,
-  };
+  }
 
-  return Object.assign(
-    {testName, dontCloseBatches: !shouldUseBrowserHooks},
-    appliConfFileCopy,
-    mappedArgs,
-  );
+  return Object.assign({testName, dontCloseBatches: !shouldUseBrowserHooks}, appliConfFileCopy, mappedArgs)
 }
 
 function fillDefaultBrowserName(browser) {
   if (!browser.iosDeviceInfo && !browser.chromeEmulationInfo) {
     if (!browser.name) {
-      browser.name = 'chrome';
+      browser.name = 'chrome'
     }
     if (browser.deviceName) {
-      browser = {chromeEmulationInfo: browser};
+      browser = {chromeEmulationInfo: browser}
     }
-    return browser;
+    return browser
   } else {
-    return browser;
+    return browser
   }
 }
 
-module.exports = {eyesOpenMapValues};
+module.exports = {eyesOpenMapValues}

package/src/browser/makeSend.js

@@ -1,18 +1,13 @@
-'use strict';
+'use strict'
 
 function makeSend(port, fetch) {
-  return function send({
-    command,
-    data,
-    method = 'POST',
-    headers = {'Content-Type': 'application/json'},
-  }) {
+  return function send({command, data, method = 'POST', headers = {'Content-Type': 'application/json'}}) {
     return fetch(`https://localhost:${port}/eyes/${command}`, {
       method,
       body: headers['Content-Type'] === 'application/json' ? JSON.stringify(data) : data,
       headers,
-    });
-  };
+    })
+  }
 }
 
-module.exports = makeSend;
+module.exports = makeSend

package/src/browser/refer.js

@@ -1,70 +1,70 @@
 /* global Node */
 
-const uuid = require('uuid');
-const REF_ID = 'applitools-ref-id';
+const uuid = require('uuid')
+const REF_ID = 'applitools-ref-id'
 
 class Refer {
   constructor() {
-    this.store = new Map();
-    this.relation = new Map();
+    this.store = new Map()
+    this.relation = new Map()
   }
 
   isRef(ref) {
-    return Boolean(ref && ref[REF_ID]);
+    return Boolean(ref && ref[REF_ID])
   }
 
   check(value) {
-    if (!value) return;
+    if (!value) return
     if (value.nodeType === Node.ELEMENT_NODE) {
-      return 'element';
+      return 'element'
     } else if (value.nodeType === Node.DOCUMENT_NODE || value.ownerDocument) {
-      return 'context';
+      return 'context'
     } else if (value.constructor && value.constructor.name === 'Window') {
-      return 'driver';
+      return 'driver'
     }
   }
 
   ref(value, parentRef) {
-    const refType = this.check(value);
+    const refType = this.check(value)
     if (refType) {
-      const ref = uuid.v4();
-      this.store.set(ref, value);
+      const ref = uuid.v4()
+      this.store.set(ref, value)
       if (parentRef) {
-        let childRefs = this.relation.get(parentRef[REF_ID]);
+        let childRefs = this.relation.get(parentRef[REF_ID])
         if (!childRefs) {
-          childRefs = new Set();
-          this.relation.set(parentRef[REF_ID], childRefs);
+          childRefs = new Set()
+          this.relation.set(parentRef[REF_ID], childRefs)
         }
-        childRefs.add({[REF_ID]: ref});
+        childRefs.add({[REF_ID]: ref})
       }
-      return {[REF_ID]: ref, type: refType};
+      return {[REF_ID]: ref, type: refType}
     } else if (Array.isArray(value)) {
-      return value.map(value => this.ref(value, parentRef));
+      return value.map(value => this.ref(value, parentRef))
     } else if (typeof value === 'object' && value !== null) {
       return Object.entries(value).reduce((obj, [key, value]) => {
-        return Object.assign(obj, {[key]: this.ref(value, parentRef)});
-      }, {});
+        return Object.assign(obj, {[key]: this.ref(value, parentRef)})
+      }, {})
     } else {
-      return value;
+      return value
     }
   }
 
   deref(ref) {
     if (this.isRef(ref)) {
-      return this.store.get(ref[REF_ID]);
+      return this.store.get(ref[REF_ID])
     } else {
-      return ref;
+      return ref
     }
   }
 
   destroy(ref) {
-    if (!this.isRef(ref)) return;
-    const childRefs = this.relation.get(ref[REF_ID]);
+    if (!this.isRef(ref)) return
+    const childRefs = this.relation.get(ref[REF_ID])
     if (childRefs) {
-      childRefs.forEach(childRef => this.destroy(childRef));
+      childRefs.forEach(childRef => this.destroy(childRef))
     }
-    this.store.delete(ref[REF_ID]);
+    this.store.delete(ref[REF_ID])
   }
 }
 
-module.exports = Refer;
+module.exports = Refer

package/src/browser/sendRequest.js

@@ -1,4 +1,4 @@
-'use strict';
+'use strict'
 
 function makeSendRequest(send) {
   return function sendRequest(args) {
@@ -6,11 +6,11 @@ function makeSendRequest(send) {
       .then(resp => resp.json())
       .then(body => {
         if (!body.success) {
-          throw new Error(body.error);
+          throw new Error(body.error)
         }
-        return body.result;
-      });
-  };
+        return body.result
+      })
+  }
 }
 
-module.exports = makeSendRequest;
+module.exports = makeSendRequest