eyes_selenium 3.15.31 → 3.15.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 356574d05d870fac17ef46d6b3302395121fe41481a551e681eefd488e0b46a8
-  data.tar.gz: b30338318cd5ffff33fd154df57117f15d13e746deaab6f75f24940d17c64a59
+  metadata.gz: 7597ed29687826c8bbe108972397fdb2cc7976eec8cb13ee4dd1a64e04595f79
+  data.tar.gz: f586de41503704289ccef067b8b5fd35242de9d5c6817dff8ed8a67e5d50e008
 SHA512:
-  metadata.gz: 0c6d7dbbcd49b238dfd9224a511b87500acec92216aea0c588338eb965176e9ff1052a8252c115f2480bdbe4cc13a7a11472bb7c4da385ec809ac247bc0446c0
-  data.tar.gz: c035fa43f6a4be3404df1366dc15eac2a0dac2dbb293c2540ac7303317df4a086cd94c63c1f1dd0260fb0d5ba5f31813c3926cc6fc17846e3b6ff1317393e1bf
+  metadata.gz: a4c440899e2df919f89d226f737a18fa4f2bf869e0a217a79eb7a8f1d96977ff8cf53e99260aaa636390b86b5873f00ef4a46352057df7afc9d8d83f4356b144
+  data.tar.gz: 7f2024b0a8e8f6304ff7d9d829f8499c852cc84633953ec579c0ce89df951b6052debfd9c5fe47f9d364da39e5a3932fe23e952b75a31a6c1d14e775c2be72c9

data/lib/applitools/selenium/scripts/process_page_and_poll.rb

@@ -2,7 +2,7 @@ module Applitools
   module Selenium
     module Scripts
       PROCESS_PAGE_AND_POLL = <<'END'
-/* @applitools/dom-snapshot@1.4.6 */
+/* @applitools/dom-snapshot@2.2.1 */
 
 function __processPageAndPoll() {
   var processPageAndPoll = (function () {
@@ -65,14 +65,14 @@ function __processPageAndPoll() {
       .map(srcsetEl =>
         srcsetEl
           .getAttribute('srcset')
-          .split(',')
+          .split(', ')
           .map(str => str.trim().split(/\s+/)[0]),
       )
       .reduce((acc, urls) => acc.concat(urls), []);
 
-    const srcUrls = Array.from(doc.querySelectorAll('img[src],source[src]')).map(srcEl =>
-      srcEl.getAttribute('src'),
-    );
+    const srcUrls = Array.from(
+      doc.querySelectorAll('img[src],source[src],input[type="image"][src]'),
+    ).map(srcEl => srcEl.getAttribute('src'));
 
     const imageUrls = Array.from(doc.querySelectorAll('image,use'))
       .map(hrefEl => hrefEl.getAttribute('href') || hrefEl.getAttribute('xlink:href'))
@@ -100,12 +100,6 @@ function __processPageAndPoll() {
 
   var extractLinks_1 = extractLinks;
 
-  function absolutizeUrl(url, absoluteUrl) {
-    return new URL(url, absoluteUrl).href;
-  }
-
-  var absolutizeUrl_1 = absolutizeUrl;
-
   function uuid() {
     return window.crypto.getRandomValues(new Uint32Array(1))[0];
   }
@@ -114,13 +108,33 @@ function __processPageAndPoll() {
 
   function isInlineFrame(frame) {
     return (
-      frame && frame.contentDocument && !/^https?:$/.test(frame.contentDocument.location.protocol)
+      !/^https?:.+/.test(frame.src) ||
+      (frame.contentDocument &&
+        frame.contentDocument.location &&
+        frame.contentDocument.location.href === 'about:blank')
     );
   }
 
   var isInlineFrame_1 = isInlineFrame;
 
-  function domNodesToCdt(docNode, url) {
+  function isAccessibleFrame(frame) {
+    try {
+      const doc = frame.contentDocument;
+      return !!(doc && doc.defaultView && doc.defaultView.frameElement);
+    } catch (err) {
+      // for CORS frames
+    }
+  }
+
+  var isAccessibleFrame_1 = isAccessibleFrame;
+
+  function absolutizeUrl(url, absoluteUrl) {
+    return new URL(url, absoluteUrl).href;
+  }
+
+  var absolutizeUrl_1 = absolutizeUrl;
+
+  function domNodesToCdt(docNode, baseUrl) {
     const cdt = [{nodeType: Node.DOCUMENT_NODE}];
     const docRoots = [docNode];
     const canvasElements = [];
@@ -143,9 +157,8 @@ function __processPageAndPoll() {
     }
 
     function elementNodeFactory(cdt, elementNode) {
-      let node, manualChildNodeIndexes;
+      let node, manualChildNodeIndexes, dummyUrl;
       const {nodeType} = elementNode;
-      let dummyUrl, frameBase;
 
       if ([Node.ELEMENT_NODE, Node.DOCUMENT_FRAGMENT_NODE].includes(nodeType)) {
         if (elementNode.nodeName !== 'SCRIPT') {
@@ -169,14 +182,17 @@ function __processPageAndPoll() {
           }
 
           if (elementNode.nodeName === 'CANVAS') {
-            dummyUrl = absolutizeUrl_1(`applitools-canvas-${uuid_1()}.png`, url);
+            dummyUrl = absolutizeUrl_1(`applitools-canvas-${uuid_1()}.png`, baseUrl);
             node.attributes.push({name: 'data-applitools-src', value: dummyUrl});
             canvasElements.push({element: elementNode, url: dummyUrl});
           }
 
-          if (elementNode.nodeName === 'IFRAME' && isInlineFrame_1(elementNode)) {
-            frameBase = getFrameBaseUrl(elementNode);
-            dummyUrl = absolutizeUrl_1(`?applitools-iframe=${uuid_1()}`, frameBase || url);
+          if (
+            elementNode.nodeName === 'IFRAME' &&
+            isAccessibleFrame_1(elementNode) &&
+            isInlineFrame_1(elementNode)
+          ) {
+            dummyUrl = absolutizeUrl_1(`?applitools-iframe=${uuid_1()}`, baseUrl);
             node.attributes.push({name: 'data-applitools-src', value: dummyUrl});
             inlineFrames.push({element: elementNode, url: dummyUrl});
           }
@@ -279,16 +295,6 @@ function __processPageAndPoll() {
         nodeName: elementNode.nodeName,
       };
     }
-
-    function getFrameBaseUrl(frameElement) {
-      const href =
-        frameElement.contentDocument.querySelectorAll('base') &&
-        frameElement.contentDocument.querySelectorAll('base')[0] &&
-        frameElement.contentDocument.querySelectorAll('base')[0].href;
-      if (href && !href.includes('about:blank')) {
-        return href;
-      }
-    }
   }
 
   var domNodesToCdt_1 = domNodesToCdt;
@@ -314,9 +320,9 @@ function __processPageAndPoll() {
   var aggregateResourceUrlsAndBlobs_1 = aggregateResourceUrlsAndBlobs;
 
   function makeGetResourceUrlsAndBlobs({processResource, aggregateResourceUrlsAndBlobs}) {
-    return function getResourceUrlsAndBlobs(documents, baseUrl, urls) {
+    return function getResourceUrlsAndBlobs({documents, urls, forceCreateStyle = false}) {
       return Promise.all(
-        urls.map(url => processResource(url, documents, baseUrl, getResourceUrlsAndBlobs)),
+        urls.map(url => processResource({url, documents, getResourceUrlsAndBlobs, forceCreateStyle})),
       ).then(resourceUrlsAndBlobsArr => aggregateResourceUrlsAndBlobs(resourceUrlsAndBlobsArr));
     };
   }
@@ -337,63 +343,48 @@ function __processPageAndPoll() {
 
   var toUnAnchoredUri_1 = toUnAnchoredUri;
 
-  function createTempStylsheet(cssContent) {
-    if (!cssContent) {
-      console.log('[dom-snapshot] error createTempStylsheet called without cssContent');
-      return;
-    }
-    const head = document.head || document.querySelectorAll('head')[0];
-    const style = document.createElement('style');
-    style.type = 'text/css';
-    style.setAttribute('data-desc', 'Applitools tmp variable created by DOM SNAPSHOT');
-    head.appendChild(style);
-
-    // This is required for IE8 and below.
-    if (style.styleSheet) {
-      style.styleSheet.cssText = cssContent;
-    } else {
-      style.appendChild(document.createTextNode(cssContent));
-    }
-    return style.sheet;
-  }
+  var noop = () => {};
 
-  var createTempStyleSheet = createTempStylsheet;
-
-  function makeExtractResourcesFromStyle({extractResourcesFromStyleSheet}) {
-    return function extractResourcesFromStyle(styleSheet, cssContent, doc = document) {
-      let corsFreeStyleSheet;
-      try {
-        styleSheet.cssRules;
-        corsFreeStyleSheet = styleSheet;
-      } catch (e) {
-        console.log(
-          `[dom-snapshot] could not access cssRules for ${styleSheet.href} ${e}\ncreating temp style for access.`,
-        );
-        corsFreeStyleSheet = createTempStyleSheet(cssContent);
-      }
-
-      const result = extractResourcesFromStyleSheet(corsFreeStyleSheet, doc);
-      if (corsFreeStyleSheet !== styleSheet) {
-        corsFreeStyleSheet.ownerNode.parentNode.removeChild(corsFreeStyleSheet.ownerNode);
-      }
-      return result;
-    };
+  function flat(arr) {
+    return arr.reduce((flatArr, item) => flatArr.concat(item), []);
   }
 
-  var extractResourcesFromStyle = makeExtractResourcesFromStyle;
+  var flat_1 = flat;
 
   function makeProcessResource({
     fetchUrl,
     findStyleSheetByUrl,
+    getCorsFreeStyleSheet,
     extractResourcesFromStyleSheet,
     extractResourcesFromSvg,
+    sessionCache,
     cache = {},
+    log = noop,
   }) {
-    const extractResourcesFromStyle$$1 = extractResourcesFromStyle({extractResourcesFromStyleSheet});
-    return function processResource(absoluteUrl, documents, baseUrl, getResourceUrlsAndBlobs) {
-      return cache[absoluteUrl] || (cache[absoluteUrl] = doProcessResource(absoluteUrl));
+    return function processResource({
+      url,
+      documents,
+      getResourceUrlsAndBlobs,
+      forceCreateStyle = false,
+    }) {
+      if (!cache[url]) {
+        if (sessionCache && sessionCache.getItem(url)) {
+          const resourceUrls = getDependencies(url);
+          log('doProcessResource from sessionStorage', url, 'deps:', resourceUrls.slice(1));
+          cache[url] = Promise.resolve({resourceUrls});
+        } else {
+          const now = Date.now();
+          cache[url] = doProcessResource(url).then(result => {
+            log('doProcessResource', `[${Date.now() - now}ms]`, url);
+            return result;
+          });
+        }
+      }
+      return cache[url];
 
       function doProcessResource(url) {
+        log('fetching', url);
+        const now = Date.now();
         return fetchUrl(url)
           .catch(e => {
             if (probablyCORS(e)) {
@@ -404,50 +395,81 @@ function __processPageAndPoll() {
           })
           .then(({url, type, value, probablyCORS}) => {
             if (probablyCORS) {
+              sessionCache && sessionCache.setItem(url, []);
               return {resourceUrls: [url]};
             }
 
-            let resourceUrls;
-            let result = {blobsObj: {[url]: {type, value}}};
+            log('fetched', `[${Date.now() - now}ms]`, url);
+
+            const thisBlob = {[url]: {type, value}};
+            let dependentUrls;
             if (/text\/css/.test(type)) {
-              const styleSheet = findStyleSheetByUrl(url, documents);
-              if (styleSheet) {
-                resourceUrls = extractResourcesFromStyle$$1(styleSheet, value, documents[0]);
+              let styleSheet = findStyleSheetByUrl(url, documents);
+              if (styleSheet || forceCreateStyle) {
+                const {corsFreeStyleSheet, cleanStyleSheet} = getCorsFreeStyleSheet(
+                  value,
+                  styleSheet,
+                );
+                dependentUrls = extractResourcesFromStyleSheet(corsFreeStyleSheet, documents[0]);
+                cleanStyleSheet();
               }
             } else if (/image\/svg/.test(type)) {
               try {
-                resourceUrls = extractResourcesFromSvg(value);
+                dependentUrls = extractResourcesFromSvg(value);
+                forceCreateStyle = !!dependentUrls;
               } catch (e) {
                 console.log('could not parse svg content', e);
               }
             }
 
-            if (resourceUrls) {
-              resourceUrls = resourceUrls
-                .map(toUnAnchoredUri_1)
+            if (dependentUrls) {
+              const absoluteDependentUrls = dependentUrls
                 .map(resourceUrl => absolutizeUrl_1(resourceUrl, url.replace(/^blob:/, '')))
+                .map(toUnAnchoredUri_1)
                 .filter(filterInlineUrl_1);
-              result = getResourceUrlsAndBlobs(documents, baseUrl, resourceUrls).then(
-                ({resourceUrls, blobsObj}) => ({
-                  resourceUrls,
-                  blobsObj: Object.assign(blobsObj, {[url]: {type, value}}),
-                }),
-              );
+
+              sessionCache && sessionCache.setItem(url, absoluteDependentUrls);
+
+              return getResourceUrlsAndBlobs({
+                documents,
+                urls: absoluteDependentUrls,
+                forceCreateStyle,
+              }).then(({resourceUrls, blobsObj}) => ({
+                resourceUrls,
+                blobsObj: Object.assign(blobsObj, thisBlob),
+              }));
+            } else {
+              sessionCache && sessionCache.setItem(url, []);
+              return {blobsObj: thisBlob};
             }
-            return result;
           })
           .catch(err => {
-            console.log('[dom-snapshot] error while fetching', url, err);
+            log('error while fetching', url, err);
+            sessionCache && clearFromSessionStorage();
             return {};
           });
       }
 
       function probablyCORS(err) {
-        const msgCORS =
+        const msg =
           err.message &&
           (err.message.includes('Failed to fetch') || err.message.includes('Network request failed'));
-        const nameCORS = err.name && err.name.includes('TypeError');
-        return msgCORS && nameCORS;
+        const name = err.name && err.name.includes('TypeError');
+        return msg && name;
+      }
+
+      function getDependencies(url) {
+        const dependentUrls = sessionCache.getItem(url);
+        return [url].concat(dependentUrls ? uniq_1(flat_1(dependentUrls.map(getDependencies))) : []);
+      }
+
+      function clearFromSessionStorage() {
+        log('clearing from sessionStorage:', url);
+        sessionCache.keys().forEach(key => {
+          const dependentUrls = sessionCache.getItem(key);
+          sessionCache.setItem(key, dependentUrls.filter(dep => dep !== url));
+        });
+        log('cleared from sessionStorage:', url);
       }
     };
   }
@@ -466,12 +488,6 @@ function __processPageAndPoll() {
 
   var getUrlFromCssText_1 = getUrlFromCssText;
 
-  function flat(arr) {
-    return [].concat(...arr);
-  }
-
-  var flat_1 = flat;
-
   function makeExtractResourcesFromSvg({parser, decoder, extractResourceUrlsFromStyleTags}) {
     return function(svgArrayBuffer) {
       const decooder = decoder || new TextDecoder('utf-8');
@@ -479,16 +495,16 @@ function __processPageAndPoll() {
       const domparser = parser || new DOMParser();
       const doc = domparser.parseFromString(svgStr, 'image/svg+xml');
 
-      const fromImages = Array.from(doc.getElementsByTagName('image'))
-        .concat(Array.from(doc.getElementsByTagName('use')))
-        .map(e => e.getAttribute('href') || e.getAttribute('xlink:href'));
+      const fromHref = Array.from(doc.querySelectorAll('image,use,link[rel="stylesheet"]')).map(
+        e => e.getAttribute('href') || e.getAttribute('xlink:href'),
+      );
       const fromObjects = Array.from(doc.getElementsByTagName('object')).map(e =>
         e.getAttribute('data'),
       );
       const fromStyleTags = extractResourceUrlsFromStyleTags(doc, false);
       const fromStyleAttrs = urlsFromStyleAttrOfDoc(doc);
 
-      return fromImages
+      return fromHref
         .concat(fromObjects)
         .concat(fromStyleTags)
         .concat(fromStyleAttrs)
@@ -538,7 +554,7 @@ function __processPageAndPoll() {
   function makeExtractResourcesFromStyleSheet({styleSheetCache}) {
     return function extractResourcesFromStyleSheet(styleSheet, doc) {
       const win = doc.defaultView || (doc.ownerDocument && doc.ownerDocument.defaultView) || window;
-      return uniq_1(
+      const urls = uniq_1(
         Array.from(styleSheet.cssRules || []).reduce((acc, rule) => {
           if (rule instanceof win.CSSImportRule) {
             styleSheetCache[rule.styleSheet.href] = rule.styleSheet;
@@ -559,6 +575,7 @@ function __processPageAndPoll() {
           return acc;
         }, []),
       );
+      return urls.filter(u => u[0] !== '#');
     };
   }
 
@@ -595,6 +612,52 @@ function __processPageAndPoll() {
 
   var extractResourceUrlsFromStyleTags = makeExtractResourceUrlsFromStyleTags;
 
+  function createTempStylsheet(cssArrayBuffer) {
+    const cssText = new TextDecoder('utf-8').decode(cssArrayBuffer);
+    const head = document.head || document.querySelectorAll('head')[0];
+    const style = document.createElement('style');
+    style.type = 'text/css';
+    style.setAttribute('data-desc', 'Applitools tmp variable created by DOM SNAPSHOT');
+    head.appendChild(style);
+
+    // This is required for IE8 and below.
+    if (style.styleSheet) {
+      style.styleSheet.cssText = cssText;
+    } else {
+      style.appendChild(document.createTextNode(cssText));
+    }
+    return style.sheet;
+  }
+
+  var createTempStyleSheet = createTempStylsheet;
+
+  function getCorsFreeStyleSheet(cssArrayBuffer, styleSheet) {
+    let corsFreeStyleSheet;
+    if (styleSheet) {
+      try {
+        styleSheet.cssRules;
+        corsFreeStyleSheet = styleSheet;
+      } catch (e) {
+        console.log(
+          `[dom-snapshot] could not access cssRules for ${styleSheet.href} ${e}\ncreating temp style for access.`,
+        );
+        corsFreeStyleSheet = createTempStyleSheet(cssArrayBuffer);
+      }
+    } else {
+      corsFreeStyleSheet = createTempStyleSheet(cssArrayBuffer);
+    }
+
+    return {corsFreeStyleSheet, cleanStyleSheet};
+
+    function cleanStyleSheet() {
+      if (corsFreeStyleSheet !== styleSheet) {
+        corsFreeStyleSheet.ownerNode.parentNode.removeChild(corsFreeStyleSheet.ownerNode);
+      }
+    }
+  }
+
+  var getCorsFreeStyleSheet_1 = getCorsFreeStyleSheet;
+
   function base64ToArrayBuffer(base64) {
     var binary_string = window.atob(base64);
     var len = binary_string.length;
@@ -621,34 +684,23 @@ function __processPageAndPoll() {
     const iframes = flat_1(
       documents.map(d => Array.from(d.querySelectorAll('iframe[src]:not([src=""])'))),
     );
-    return iframes
-      .filter(f => isAccessibleFrame(f) && !isInlineFrame_1(f))
-      .map(f => f.contentDocument);
-  }
 
-  function isAccessibleFrame(frame) {
-    try {
-      const doc = frame.contentDocument;
-      return !!(doc && doc.defaultView && doc.defaultView.frameElement);
-    } catch (err) {
-      // for CORS frames
-    }
+    return iframes.filter(f => isAccessibleFrame_1(f) && !isInlineFrame_1(f)).map(f => f.contentDocument);
   }
 
   var extractFrames_1 = extractFrames;
 
   const getBaesUrl = function(doc) {
     const baseUrl = doc.querySelectorAll('base')[0] && doc.querySelectorAll('base')[0].href;
-    if (baseUrl) {
+    if (baseUrl && isUrl(baseUrl)) {
       return baseUrl;
     }
-    const frameElement = doc.defaultView && doc.defaultView.frameElement;
-    if (frameElement) {
-      return frameElement.src || getBaesUrl(frameElement.ownerDocument);
-    }
-    return doc.location.href;
   };
 
+  function isUrl(url) {
+    return url && !/^(about:blank|javascript:void|blob:)/.test(url);
+  }
+
   var getBaseUrl = getBaesUrl;
 
   function toUriEncoding(url) {
@@ -664,7 +716,70 @@ function __processPageAndPoll() {
 
   var toUriEncoding_1 = toUriEncoding;
 
-  function processPage(doc = document) {
+  function makeLog(referenceTime) {
+    return function log() {
+      const args = ['[dom-snapshot]', `[+${Date.now() - referenceTime}ms]`].concat(
+        Array.from(arguments),
+      );
+      console.log.apply(console, args);
+    };
+  }
+
+  var log = makeLog;
+
+  const RESOURCE_STORAGE_KEY = '__process_resource';
+
+  function makeSessionCache({log, sessionStorage}) {
+    let sessionStorageCache;
+    try {
+      sessionStorage = sessionStorage || window.sessionStorage;
+      const sessionStorageCacheStr = sessionStorage.getItem(RESOURCE_STORAGE_KEY);
+      sessionStorageCache = sessionStorageCacheStr ? JSON.parse(sessionStorageCacheStr) : {};
+    } catch (ex) {
+      log('error creating session cache', ex);
+    }
+
+    return {
+      getItem,
+      setItem,
+      keys,
+      persist,
+    };
+
+    function getItem(key) {
+      if (sessionStorageCache) {
+        return sessionStorageCache[key];
+      }
+    }
+
+    function setItem(key, value) {
+      if (sessionStorageCache) {
+        log('saving to in-memory sessionStorage, key:', key, 'value:', value);
+        sessionStorageCache[key] = value;
+      }
+    }
+
+    function keys() {
+      if (sessionStorageCache) {
+        return Object.keys(sessionStorageCache);
+      } else {
+        return [];
+      }
+    }
+
+    function persist() {
+      if (sessionStorageCache) {
+        sessionStorage.setItem(RESOURCE_STORAGE_KEY, JSON.stringify(sessionStorageCache));
+      }
+    }
+  }
+
+  var sessionCache = makeSessionCache;
+
+  function processPage(doc = document, {showLogs, useSessionCache} = {}) {
+    const log$$1 = showLogs ? log(Date.now()) : noop;
+    log$$1('processPage start');
+    const sessionCache$$1 = useSessionCache && sessionCache({log: log$$1});
     const styleSheetCache = {};
     const extractResourcesFromStyleSheet$$1 = extractResourcesFromStyleSheet({styleSheetCache});
     const findStyleSheetByUrl$$1 = findStyleSheetByUrl({styleSheetCache});
@@ -676,9 +791,12 @@ function __processPageAndPoll() {
     const processResource$$1 = processResource({
       fetchUrl: fetchUrl_1,
       findStyleSheetByUrl: findStyleSheetByUrl$$1,
+      getCorsFreeStyleSheet: getCorsFreeStyleSheet_1,
       extractResourcesFromStyleSheet: extractResourcesFromStyleSheet$$1,
       extractResourcesFromSvg,
       absolutizeUrl: absolutizeUrl_1,
+      log: log$$1,
+      sessionCache: sessionCache$$1,
     });
 
     const getResourceUrlsAndBlobs$$1 = getResourceUrlsAndBlobs({
@@ -686,47 +804,63 @@ function __processPageAndPoll() {
       aggregateResourceUrlsAndBlobs: aggregateResourceUrlsAndBlobs_1,
     });
 
-    return doProcessPage(doc);
+    return doProcessPage(doc).then(result => {
+      log$$1('processPage end');
+      return result;
+    });
 
-    function doProcessPage(doc, baesUrl = null) {
-      const url = baesUrl || getBaseUrl(doc);
-      const {cdt, docRoots, canvasElements, inlineFrames} = domNodesToCdt_1(doc, url);
+    function doProcessPage(doc, pageUrl = doc.location.href) {
+      const baseUrl = getBaseUrl(doc) || pageUrl;
+      const {cdt, docRoots, canvasElements, inlineFrames} = domNodesToCdt_1(doc, baseUrl);
 
       const linkUrls = flat_1(docRoots.map(extractLinks_1));
       const styleTagUrls = flat_1(docRoots.map(extractResourceUrlsFromStyleTags$$1));
-      const absolutizeThisUrl = getAbsolutizeByUrl(url);
-      const links = uniq_1(
+      const absolutizeThisUrl = getAbsolutizeByUrl(baseUrl);
+      const urls = uniq_1(
         Array.from(linkUrls)
           .concat(Array.from(styleTagUrls))
           .concat(extractResourceUrlsFromStyleAttrs_1(cdt)),
       )
-        .map(toUnAnchoredUri_1)
         .map(toUriEncoding_1)
         .map(absolutizeThisUrl)
+        .map(toUnAnchoredUri_1)
         .filter(filterInlineUrlsIfExisting);
 
-      const resourceUrlsAndBlobsPromise = getResourceUrlsAndBlobs$$1(docRoots, url, links);
+      const resourceUrlsAndBlobsPromise = getResourceUrlsAndBlobs$$1({documents: docRoots, urls}).then(
+        result => {
+          sessionCache$$1 && sessionCache$$1.persist();
+          return result;
+        },
+      );
       const canvasBlobs = buildCanvasBlobs_1(canvasElements);
-
       const frameDocs = extractFrames_1(docRoots);
-      const processFramesPromise = frameDocs.map(f => doProcessPage(f, null));
+
+      const processFramesPromise = frameDocs.map(f =>
+        doProcessPage(f, f.defaultView.frameElement.src),
+      );
       const processInlineFramesPromise = inlineFrames.map(({element, url}) =>
         doProcessPage(element.contentDocument, url),
       );
 
-      const frameElement = doc.defaultView && doc.defaultView.frameElement;
-      return Promise.all([
-        resourceUrlsAndBlobsPromise,
-        ...processFramesPromise,
-        ...processInlineFramesPromise,
-      ]).then(([{resourceUrls, blobsObj}, ...framesResults]) => ({
-        cdt,
-        url,
-        resourceUrls,
-        blobs: [...blobsObjToArray(blobsObj), ...canvasBlobs],
-        frames: framesResults,
-        srcAttr: frameElement ? frameElement.getAttribute('src') : undefined,
-      }));
+      const srcAttr =
+        doc.defaultView &&
+        doc.defaultView.frameElement &&
+        doc.defaultView.frameElement.getAttribute('src');
+
+      return Promise.all(
+        [resourceUrlsAndBlobsPromise].concat(processFramesPromise).concat(processInlineFramesPromise),
+      ).then(function(resultsWithFrameResults) {
+        const {resourceUrls, blobsObj} = resultsWithFrameResults[0];
+        const framesResults = resultsWithFrameResults.slice(1);
+        return {
+          cdt,
+          url: pageUrl,
+          srcAttr,
+          resourceUrls: resourceUrls.map(url => url.replace(/^blob:/, '')),
+          blobs: blobsObjToArray(blobsObj).concat(canvasBlobs),
+          frames: framesResults,
+        };
+      });
     }
   }
 
@@ -757,8 +891,8 @@ function __processPageAndPoll() {
 
   var processPage_1 = processPage;
 
-  function processPageAndSerialize(doc) {
-    return processPage_1(doc).then(serializeFrame);
+  function processPageAndSerialize() {
+    return processPage_1.apply(this, arguments).then(serializeFrame);
   }
 
   function serializeFrame(frame) {

data/lib/applitools/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: false
 
 module Applitools
-  VERSION = '3.15.31'.freeze
+  VERSION = '3.15.32'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eyes_selenium
 version: !ruby/object:Gem::Version
-  version: 3.15.31
+  version: 3.15.32
 platform: ruby
 authors:
 - Applitools Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-13 00:00:00.000000000 Z
+date: 2019-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eyes_core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.15.31
+        version: 3.15.32
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.15.31
+        version: 3.15.32
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver
   requirement: !ruby/object:Gem::Requirement