@applitools/eyes-cypress 3.28.0 → 3.28.1

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

package/src/browser/socket.js

@@ -1,144 +1,143 @@
 /* global WebSocket */
-const uuid = require('uuid');
+const uuid = require('uuid')
 
 class Socket {
   constructor() {
-    this._socket = null;
-    this._listeners = new Map();
-    this._queue = new Set();
+    this._socket = null
+    this._listeners = new Map()
+    this._queue = new Set()
   }
 
   attach(ws) {
-    if (!ws) return;
+    if (!ws) return
 
-    if (ws.readyState === WebSocket.CONNECTING) ws.addEventListener('open', () => this.attach(ws));
+    if (ws.readyState === WebSocket.CONNECTING) ws.addEventListener('open', () => this.attach(ws))
     else if (ws.readyState === WebSocket.OPEN) {
-      this._socket = ws;
-      this._queue.forEach(command => command());
-      this._queue.clear();
+      this._socket = ws
+      this._queue.forEach(command => command())
+      this._queue.clear()
 
       this._socket.addEventListener('message', message => {
-        const {name, key, payload} = this.deserialize(message);
-        const fns = this._listeners.get(name);
-        if (fns) fns.forEach(fn => fn(payload, key));
+        const {name, key, payload} = this.deserialize(message)
+        const fns = this._listeners.get(name)
+        if (fns) fns.forEach(fn => fn(payload, key))
         if (key) {
-          const fns = this._listeners.get(`${name}/${key}`);
-          if (fns) fns.forEach(fn => fn(payload, key));
+          const fns = this._listeners.get(`${name}/${key}`)
+          if (fns) fns.forEach(fn => fn(payload, key))
         }
-      });
+      })
       this._socket.addEventListener('close', () => {
-        const fns = this._listeners.get('close');
-        if (fns) fns.forEach(fn => fn());
-      });
+        const fns = this._listeners.get('close')
+        if (fns) fns.forEach(fn => fn())
+      })
     }
   }
 
   on(type, fn) {
-    const name = typeof type === 'string' ? type : `${type.name}/${type.key}`;
-    let fns = this._listeners.get(name);
+    const name = typeof type === 'string' ? type : `${type.name}/${type.key}`
+    let fns = this._listeners.get(name)
     if (!fns) {
-      fns = new Set();
-      this._listeners.set(name, fns);
+      fns = new Set()
+      this._listeners.set(name, fns)
     }
-    fns.add(fn);
-    return () => this.off(name, fn);
+    fns.add(fn)
+    return () => this.off(name, fn)
   }
 
   connect(url) {
-    const ws = new WebSocket(url);
-    this.attach(ws);
+    const ws = new WebSocket(url)
+    this.attach(ws)
   }
 
   disconnect() {
-    if (!this._socket) return;
-    this._socket.terminate();
-    this._socket = null;
+    if (!this._socket) return
+    this._socket.terminate()
+    this._socket = null
   }
 
   request(name, payload) {
     return new Promise((resolve, reject) => {
       try {
-        const key = uuid.v4();
-        this.emit({name, key}, payload);
+        const key = uuid.v4()
+        this.emit({name, key}, payload)
         this.once({name, key}, response => {
-          if (response.error) return reject(response.error);
-          return resolve(response.result);
-        });
+          if (response.error) return reject(response.error)
+          return resolve(response.result)
+        })
       } catch (ex) {
-        console.log(ex);
-        throw ex;
+        console.log(ex)
+        throw ex
       }
-    });
+    })
   }
 
   command(name, fn) {
     this.on(name, async (payload, key) => {
       try {
-        const result = await fn(payload);
-        this.emit({name, key}, {result});
+        const result = await fn(payload)
+        this.emit({name, key}, {result})
       } catch (error) {
-        console.log(error);
-        this.emit({name, key}, {error});
+        console.log(error)
+        this.emit({name, key}, {error})
       }
-    });
+    })
   }
 
   subscribe(name, publisher, fn) {
-    const subscription = uuid.v4();
-    this.emit(name, {publisher, subscription});
-    const off = this.on({name, key: subscription}, fn);
-    return () => (this.emit({name, key: subscription}), off());
+    const subscription = uuid.v4()
+    this.emit(name, {publisher, subscription})
+    const off = this.on({name, key: subscription}, fn)
+    return () => (this.emit({name, key: subscription}), off())
   }
 
   once(type, fn) {
-    const off = this.on(type, (...args) => (fn(...args), this.off()));
-    return off;
+    const off = this.on(type, (...args) => (fn(...args), this.off()))
+    return off
   }
 
   off(name, fn) {
-    if (!fn) return this._listeners.delete(name);
-    const fns = this._listeners.get(name);
-    if (!fns) return false;
-    const existed = fns.delete(fn);
-    if (!fns.size) this._listeners.delete(name);
-    return existed;
+    if (!fn) return this._listeners.delete(name)
+    const fns = this._listeners.get(name)
+    if (!fns) return false
+    const existed = fns.delete(fn)
+    if (!fns.size) this._listeners.delete(name)
+    return existed
   }
 
   emit(type, payload) {
     try {
-      const command = () => this._socket.send(this.serialize(type, payload));
-      if (this._socket) command();
-      else this._queue.add(command);
-      return () => this._queue.delete(command);
+      const command = () => this._socket.send(this.serialize(type, payload))
+      if (this._socket) command()
+      else this._queue.add(command)
+      return () => this._queue.delete(command)
     } catch (ex) {
-      console.log(ex);
-      throw ex;
+      console.log(ex)
+      throw ex
     }
   }
 
   ref() {
-    const command = () => this._socket._socket.ref();
-    if (this._socket) command();
-    else this._queue.add(command);
-    return () => this._queue.delete(command);
+    const command = () => this._socket._socket.ref()
+    if (this._socket) command()
+    else this._queue.add(command)
+    return () => this._queue.delete(command)
   }
 
   unref() {
-    const command = () => this._socket._socket.unref();
-    if (this._socket) command();
-    else this._queue.add(command);
-    return () => this._queue.delete(command);
+    const command = () => this._socket._socket.unref()
+    if (this._socket) command()
+    else this._queue.add(command)
+    return () => this._queue.delete(command)
   }
 
   serialize(type, payload) {
-    const message =
-      typeof type === 'string' ? {name: type, payload} : {name: type.name, key: type.key, payload};
-    return JSON.stringify(message);
+    const message = typeof type === 'string' ? {name: type, payload} : {name: type.name, key: type.key, payload}
+    return JSON.stringify(message)
   }
 
   deserialize(message) {
-    return JSON.parse(message.data);
+    return JSON.parse(message.data)
   }
 }
 
-module.exports = Socket;
+module.exports = Socket

package/src/browser/socketCommands.js

@@ -1,83 +1,72 @@
-/* global Node */
-const spec = require('../../dist/browser/spec-driver');
+const spec = require('../../dist/browser/spec-driver')
 
 function socketCommands(socket, refer) {
   socket.command('Driver.executeScript', ({context, script, arg = []}) => {
-    const res = spec.executeScript(refer.deref(context), script, derefArgs(arg));
-    return res ? refer.ref(res) : res;
-  });
+    const res = spec.executeScript(refer.deref(context), script, derefArgs(arg))
+    return res ? refer.ref(res) : res
+  })
 
   socket.command('Driver.mainContext', () => {
-    return refer.ref(spec.mainContext()), {type: 'context'};
-  });
+    return refer.ref(spec.mainContext()), {type: 'context'}
+  })
 
   socket.command('Driver.parentContext', ({context}) => {
-    return refer.ref(spec.parentContext(refer.deref(context)));
-  });
+    return refer.ref(spec.parentContext(refer.deref(context)))
+  })
 
   socket.command('Driver.childContext', ({context, element}) => {
-    return refer.ref(spec.childContext(refer.deref(context), refer.deref(element)));
-  });
+    return refer.ref(spec.childContext(refer.deref(context), refer.deref(element)))
+  })
 
   socket.command('Driver.getViewportSize', () => {
-    return spec.getViewportSize();
-  });
+    return spec.getViewportSize()
+  })
   socket.command('Driver.setViewportSize', vs => {
-    spec.setViewportSize(vs);
-  });
+    spec.setViewportSize(vs)
+  })
   socket.command('Driver.findElement', ({context, selector, parent}) => {
-    const element = spec.findElement(
-      refer.deref(context),
-      spec.transformSelector(selector),
-      refer.deref(parent),
-    );
-    return element === null ? element : refer.ref(element, context);
-  });
+    const element = spec.findElement(refer.deref(context), spec.transformSelector(selector), refer.deref(parent))
+    return element === null ? element : refer.ref(element, context)
+  })
   socket.command('Driver.findElements', ({context, selector, parent}) => {
-    const elements = spec.findElements(
-      refer.deref(context),
-      spec.transformSelector(selector),
-      refer.deref(parent),
-    );
-    return Array.prototype.map.call(elements, element =>
-      element === null ? element : refer.ref(element, context),
-    );
-  });
+    const elements = spec.findElements(refer.deref(context), spec.transformSelector(selector), refer.deref(parent))
+    return Array.prototype.map.call(elements, element => (element === null ? element : refer.ref(element, context)))
+  })
 
   socket.command('Driver.getUrl', ({driver}) => {
-    return spec.getUrl(refer.deref(driver));
-  });
+    return spec.getUrl(refer.deref(driver))
+  })
 
   socket.command('Driver.getTitle', ({driver}) => {
-    return spec.getTitle(refer.deref(driver));
-  });
+    return spec.getTitle(refer.deref(driver))
+  })
 
   socket.command('Driver.getCookies', async () => {
-    return await spec.getCookies();
-  });
+    return await spec.getCookies()
+  })
 
   // utils
 
   function derefArgs(arg) {
-    const derefArg = [];
+    const derefArg = []
     if (Array.isArray(arg)) {
       for (const argument of arg) {
         if (Array.isArray(argument)) {
-          derefArg.push(derefArgs(argument));
+          derefArg.push(derefArgs(argument))
         } else {
-          derefArg.push(refer.deref(argument));
+          derefArg.push(refer.deref(argument))
         }
       }
-      return derefArg;
+      return derefArg
     } else if (typeof arg === 'object') {
       for (const [key, value] of Object.entries(arg)) {
-        derefArg[key] = refer.deref(value);
+        derefArg[key] = refer.deref(value)
       }
-      return derefArg;
+      return derefArg
     } else {
-      return arg;
+      return arg
     }
   }
 }
 
-module.exports = {socketCommands};
+module.exports = {socketCommands}

package/src/plugin/concurrencyMsg.js

@@ -1,8 +1,8 @@
-'use strict';
-const chalk = require('chalk');
+'use strict'
+const chalk = require('chalk')
 const MSG = `
 Important notice: Your Applitools visual tests are currently running with a testConcurrency value of 5.
 This means that only up to 5 visual tests can run in parallel, and therefore the execution might be slower.
 If your Applitools license supports a higher concurrency level, learn how to configure it here: https://www.npmjs.com/package/@applitools/eyes-cypress#concurrency.
-Need a higher concurrency in your account? Email us @ sdr@applitools.com with your required concurrency level.`;
-module.exports = {concurrencyMsg: chalk.yellow(MSG), msgText: MSG};
+Need a higher concurrency in your account? Email us @ sdr@applitools.com with your required concurrency level.`
+module.exports = {concurrencyMsg: chalk.yellow(MSG), msgText: MSG}