@percy/core 1.10.4 → 1.11.0

package/dist/snapshot.js

@@ -2,9 +2,10 @@ import logger from '@percy/logger';
 import PercyConfig from '@percy/config';
 import micromatch from 'micromatch';
 import { configSchema } from './config.js';
-import { request, hostnameMatches, createRootResource, createPercyCSSResource, createLogResource, yieldTo } from './utils.js'; // Throw a better error message for missing or invalid urls
+import Queue from './queue.js';
+import { request, hostnameMatches, yieldTo } from './utils.js'; // Throw a better error message for missing or invalid urls
 
-export function validURL(url, base) {
+function validURL(url, base) {
   if (!url) {
     throw new Error('Missing required URL for snapshot');
   }
@@ -16,10 +17,11 @@ export function validURL(url, base) {
   }
 } // used to deserialize regular expression strings
 
+
 const RE_REGEXP = /^\/(.+)\/(\w+)?$/; // Returns true or false if a snapshot matches the provided include and exclude predicates. A
 // predicate can be an array of predicates, a regular expression, a glob pattern, or a function.
 
-export function snapshotMatches(snapshot, include, exclude) {
+function snapshotMatches(snapshot, include, exclude) {
   var _include, _include2;
 
   // support an options object as the second argument
@@ -62,15 +64,16 @@ export function snapshotMatches(snapshot, include, exclude) {
   return !test(exclude, false) && test(include, true);
 } // Accepts an array of snapshots to filter and map with matching options.
 
-export function mapSnapshotOptions(percy, snapshots, config) {
+
+function mapSnapshotOptions(snapshots, context) {
   if (!(snapshots !== null && snapshots !== void 0 && snapshots.length)) return []; // reduce options into a single function
 
-  let applyOptions = [].concat((config === null || config === void 0 ? void 0 : config.options) || []).reduceRight((next, {
+  let applyOptions = [].concat((context === null || context === void 0 ? void 0 : context.options) || []).reduceRight((next, {
     include,
     exclude,
     ...opts
   }) => snap => next( // assign additional options to included snaphots
-  snapshotMatches(snap, include, exclude) ? Object.assign(snap, opts) : snap), s => getSnapshotConfig(percy, s)); // reduce snapshots with overrides
+  snapshotMatches(snap, include, exclude) ? Object.assign(snap, opts) : snap), snap => getSnapshotOptions(snap, context)); // reduce snapshots with overrides
 
   return snapshots.reduce((acc, snapshot) => {
     var _snapshot;
@@ -80,42 +83,84 @@ export function mapSnapshotOptions(percy, snapshots, config) {
       url: snapshot
     }; // normalize the snapshot url and use it for the default name
 
-    let url = validURL(snapshot.url, config === null || config === void 0 ? void 0 : config.baseUrl);
+    let url = validURL(snapshot.url, context === null || context === void 0 ? void 0 : context.baseUrl);
     (_snapshot = snapshot).name || (_snapshot.name = `${url.pathname}${url.search}${url.hash}`);
     snapshot.url = url.href; // use the snapshot when matching include/exclude
 
-    if (snapshotMatches(snapshot, config)) {
+    if (snapshotMatches(snapshot, context)) {
       acc.push(applyOptions(snapshot));
     }
 
     return acc;
   }, []);
-} // Returns an array of derived snapshot options
+} // Return snapshot options merged with defaults and global config.
 
-export async function* gatherSnapshots(percy, options) {
-  let {
-    baseUrl,
-    snapshots
-  } = options;
-  if ('url' in options) snapshots = [options];
-  if ('sitemap' in options) snapshots = yield getSitemapSnapshots(options); // validate evaluated snapshots
 
-  if (typeof snapshots === 'function') {
-    snapshots = yield* yieldTo(snapshots(baseUrl));
-    snapshots = validateSnapshotOptions({
-      baseUrl,
-      snapshots
-    }).snapshots;
-  } // map snapshots with snapshot options
+function getSnapshotOptions(options, {
+  config,
+  meta
+}) {
+  return PercyConfig.merge([{
+    widths: configSchema.snapshot.properties.widths.default,
+    discovery: {
+      allowedHostnames: [validURL(options.url).hostname]
+    },
+    meta: { ...meta,
+      snapshot: {
+        name: options.name
+      }
+    }
+  }, config.snapshot, {
+    // only specific discovery options are used per-snapshot
+    discovery: {
+      allowedHostnames: config.discovery.allowedHostnames,
+      disallowedHostnames: config.discovery.disallowedHostnames,
+      networkIdleTimeout: config.discovery.networkIdleTimeout,
+      requestHeaders: config.discovery.requestHeaders,
+      authorization: config.discovery.authorization,
+      disableCache: config.discovery.disableCache,
+      userAgent: config.discovery.userAgent
+    }
+  }, options], (path, prev, next) => {
+    var _next, _next2;
+
+    switch (path.map(k => k.toString()).join('.')) {
+      case 'widths':
+        // dedup, sort, and override widths when not empty
+        return [path, !((_next = next) !== null && _next !== void 0 && _next.length) ? prev : [...new Set(next)].sort((a, b) => a - b)];
 
+      case 'percyCSS':
+        // concatenate percy css
+        return [path, [prev, next].filter(Boolean).join('\n')];
 
-  snapshots = mapSnapshotOptions(percy, snapshots, options);
-  if (!snapshots.length) throw new Error('No snapshots found');
-  return snapshots;
+      case 'execute':
+        // shorthand for execute.beforeSnapshot
+        return Array.isArray(next) || typeof next !== 'object' ? [path.concat('beforeSnapshot'), next] : [path];
+
+      case 'discovery.disallowedHostnames':
+        // prevent disallowing the root hostname
+        return [path, !((_next2 = next) !== null && _next2 !== void 0 && _next2.length) ? prev : (prev ?? []).concat(next).filter(h => !hostnameMatches(h, options.url))];
+    } // ensure additional snapshots have complete names
+
+
+    if (path[0] === 'additionalSnapshots' && path.length === 2) {
+      let {
+        prefix = '',
+        suffix = '',
+        ...n
+      } = next;
+      next = {
+        name: `${prefix}${options.name}${suffix}`,
+        ...n
+      };
+      return [path, next];
+    }
+  });
 } // Validates and migrates snapshot options against the correct schema based on provided
 // properties. Eagerly throws an error when missing a URL for any snapshot, and warns about all
 // other invalid options which are also scrubbed from the returned migrated options.
 
+
 export function validateSnapshotOptions(options) {
   var _migrated$baseUrl;
 
@@ -161,7 +206,7 @@ export function validateSnapshotOptions(options) {
 } // Fetches a sitemap and parses it into a list of URLs for taking snapshots. Duplicate URLs,
 // including a trailing slash, are removed from the resulting list.
 
-export async function getSitemapSnapshots(options) {
+async function getSitemapSnapshots(options) {
   return request(options.sitemap, (body, res) => {
     // validate sitemap content-type
     let [contentType] = res.headers['content-type'].split(';');
@@ -178,271 +223,192 @@ export async function getSitemapSnapshots(options) {
       return match === -1 || match === i;
     });
   });
-} // Return snapshot options merged with defaults and global options.
-
-export function getSnapshotConfig(percy, options) {
-  return PercyConfig.merge([{
-    widths: configSchema.snapshot.properties.widths.default,
-    discovery: {
-      allowedHostnames: [validURL(options.url).hostname]
-    },
-    meta: {
-      snapshot: {
-        name: options.name
-      },
-      build: percy.build
-    }
-  }, percy.config.snapshot, {
-    // only specific discovery options are used per-snapshot
-    discovery: {
-      allowedHostnames: percy.config.discovery.allowedHostnames,
-      disallowedHostnames: percy.config.discovery.disallowedHostnames,
-      networkIdleTimeout: percy.config.discovery.networkIdleTimeout,
-      requestHeaders: percy.config.discovery.requestHeaders,
-      authorization: percy.config.discovery.authorization,
-      disableCache: percy.config.discovery.disableCache,
-      userAgent: percy.config.discovery.userAgent
-    }
-  }, options], (path, prev, next) => {
-    var _next, _next2;
-
-    switch (path.map(k => k.toString()).join('.')) {
-      case 'widths':
-        // dedup, sort, and override widths when not empty
-        return [path, !((_next = next) !== null && _next !== void 0 && _next.length) ? prev : Array.from(new Set(next)).sort((a, b) => a - b)];
+} // Returns an array of derived snapshot options
 
-      case 'percyCSS':
-        // concatenate percy css
-        return [path, [prev, next].filter(Boolean).join('\n')];
 
-      case 'execute':
-        // shorthand for execute.beforeSnapshot
-        return Array.isArray(next) || typeof next !== 'object' ? [path.concat('beforeSnapshot'), next] : [path];
+export async function* gatherSnapshots(options, context) {
+  let {
+    baseUrl,
+    snapshots
+  } = options;
+  if ('url' in options) [snapshots, options] = [[options], {}];
+  if ('sitemap' in options) snapshots = yield getSitemapSnapshots(options); // validate evaluated snapshots
 
-      case 'discovery.disallowedHostnames':
-        // prevent disallowing the root hostname
-        return [path, !((_next2 = next) !== null && _next2 !== void 0 && _next2.length) ? prev : (prev ?? []).concat(next).filter(h => !hostnameMatches(h, options.url))];
-    } // ensure additional snapshots have complete names
+  if (typeof snapshots === 'function') {
+    snapshots = yield* yieldTo(snapshots(baseUrl));
+    snapshots = validateSnapshotOptions({
+      baseUrl,
+      snapshots
+    }).snapshots;
+  } // map snapshots with snapshot options
 
 
-    if (path[0] === 'additionalSnapshots' && path.length === 2) {
-      let {
-        prefix = '',
-        suffix = '',
-        ...n
-      } = next;
-      next = {
-        name: `${prefix}${options.name}${suffix}`,
-        ...n
-      };
-      return [path, next];
-    }
+  snapshots = mapSnapshotOptions(snapshots, { ...options,
+    ...context
   });
-} // Returns a complete and valid snapshot config object and logs verbose debug logs detailing various
-// snapshot options. When `showInfo` is true, specific messages will be logged as info logs rather
-// than debug logs.
-
-function debugSnapshotConfig(snapshot, showInfo) {
-  let log = logger('core:snapshot'); // log snapshot info
-
-  log.debug('---------', snapshot.meta);
-  if (showInfo) log.info(`Snapshot found: ${snapshot.name}`, snapshot.meta);else log.debug(`Handling snapshot: ${snapshot.name}`, snapshot.meta); // will log debug info for an object property if its value is defined
-
-  let debugProp = (obj, prop, format = String) => {
-    let val = prop.split('.').reduce((o, k) => o === null || o === void 0 ? void 0 : o[k], obj);
+  if (!snapshots.length) throw new Error('No snapshots found');
+  return snapshots;
+} // Merges snapshots and deduplicates resource arrays. Duplicate log resources are replaced, root
+// resources are deduplicated by widths, and all other resources are deduplicated by their URL.
 
-    if (val != null) {
-      // join formatted array values with a space
-      val = [].concat(val).map(format).join(', ');
-      log.debug(`- ${prop}: ${val}`, snapshot.meta);
+function mergeSnapshotOptions(prev = {}, next) {
+  let {
+    resources: oldResources = [],
+    ...existing
+  } = prev;
+  let {
+    resources: newResources = [],
+    widths = [],
+    width,
+    ...incoming
+  } = next; // prioritize singular widths over mutilple widths
+
+  widths = width ? [width] : widths; // deduplicate resources by associated widths and url
+
+  let resources = oldResources.reduce((all, resource) => {
+    if (resource.log || resource.widths.every(w => widths.includes(w))) return all;
+    if (!resource.root && all.some(r => r.url === resource.url)) return all;
+    resource.widths = resource.widths.filter(w => !widths.includes(w));
+    return all.concat(resource);
+  }, newResources.map(r => ({ ...r,
+    widths
+  }))); // sort resources after merging; roots first by min-width & logs last
+
+  resources.sort((a, b) => {
+    if (a.root && b.root) return Math.min(...b.widths) - Math.min(...a.widths);
+    return a.root || b.log ? -1 : a.log || b.root ? 1 : 0;
+  }); // overwrite resources and ensure unique widths
+
+  return PercyConfig.merge([existing, incoming, {
+    widths,
+    resources
+  }], (path, prev, next) => {
+    if (path[0] === 'resources') return [path, next];
+
+    if (path[0] === 'widths' && prev && next) {
+      return [path, [...new Set([...prev, ...next])]];
     }
-  };
-
-  debugProp(snapshot, 'url');
-  debugProp(snapshot, 'scope');
-  debugProp(snapshot, 'widths', v => `${v}px`);
-  debugProp(snapshot, 'minHeight', v => `${v}px`);
-  debugProp(snapshot, 'enableJavaScript');
-  debugProp(snapshot, 'deviceScaleFactor');
-  debugProp(snapshot, 'waitForTimeout');
-  debugProp(snapshot, 'waitForSelector');
-  debugProp(snapshot, 'execute.afterNavigation');
-  debugProp(snapshot, 'execute.beforeResize');
-  debugProp(snapshot, 'execute.afterResize');
-  debugProp(snapshot, 'execute.beforeSnapshot');
-  debugProp(snapshot, 'discovery.allowedHostnames');
-  debugProp(snapshot, 'discovery.disallowedHostnames');
-  debugProp(snapshot, 'discovery.requestHeaders', JSON.stringify);
-  debugProp(snapshot, 'discovery.authorization', JSON.stringify);
-  debugProp(snapshot, 'discovery.disableCache');
-  debugProp(snapshot, 'discovery.userAgent');
-  debugProp(snapshot, 'clientInfo');
-  debugProp(snapshot, 'environmentInfo');
-  debugProp(snapshot, 'domSnapshot', Boolean);
-
-  for (let added of snapshot.additionalSnapshots || []) {
-    if (showInfo) log.info(`Snapshot found: ${added.name}`, snapshot.meta);else log.debug(`Additional snapshot: ${added.name}`, snapshot.meta);
-    debugProp(added, 'waitForTimeout');
-    debugProp(added, 'waitForSelector');
-    debugProp(added, 'execute');
-  }
-} // Calls the provided callback with additional resources
-
-
-function handleSnapshotResources(snapshot, map, callback) {
-  let resources = [...map.values()]; // sort the root resource first
-
-  let [root] = resources.splice(resources.findIndex(r => r.root), 1);
-  resources.unshift(root); // inject Percy CSS
-
-  if (snapshot.percyCSS) {
-    let css = createPercyCSSResource(root.url, snapshot.percyCSS);
-    resources.push(css); // replace root contents and associated properties
-
-    Object.assign(root, createRootResource(root.url, root.content.replace(/(<\/body>)(?!.*\1)/is, `<link data-percy-specific-css rel="stylesheet" href="${css.pathname}"/>` + '$&')));
-  } // include associated snapshot logs matched by meta information
-
-
-  resources.push(createLogResource(logger.query(log => {
-    var _log$meta$snapshot;
-
-    return ((_log$meta$snapshot = log.meta.snapshot) === null || _log$meta$snapshot === void 0 ? void 0 : _log$meta$snapshot.name) === snapshot.meta.snapshot.name;
-  })));
-  return callback(snapshot, resources);
-} // Wait for a page's asset discovery network to idle
+  });
+} // Creates a snapshots queue that manages a Percy build and uploads snapshots.
 
 
-function waitForDiscoveryNetworkIdle(page, options) {
+export function createSnapshotsQueue(percy) {
   let {
-    allowedHostnames,
-    networkIdleTimeout
-  } = options;
-
-  let filter = r => hostnameMatches(allowedHostnames, r.url);
-
-  return page.network.idle(filter, networkIdleTimeout);
-} // Used to cache resources across core instances
-
-
-const RESOURCE_CACHE_KEY = Symbol('resource-cache'); // Trigger resource requests for a page by iterating over snapshot widths and calling any provided
-// execute options. Additional resize options may be provided to capture resources mobile resources
-
-function* triggerResourceRequests(page, snapshot, options) {
-  // copy widths to prevent mutation later
-  let [initialWidth, ...widths] = snapshot.widths; // set the initial page size
-
-  yield page.resize({
-    width: initialWidth,
-    height: snapshot.minHeight,
-    ...options
-  }); // navigate to the url
-
-  yield page.goto(snapshot.url);
-
-  if (snapshot.execute) {
-    // when any execute options are provided, inject snapshot options
-
-    /* istanbul ignore next: cannot detect coverage of injected code */
-    yield page.eval((_, s) => window.__PERCY__.snapshot = s, snapshot);
-    yield page.evaluate(snapshot.execute.afterNavigation);
-  } // trigger resize events for other widths
-
-
-  for (let width of widths) {
-    var _snapshot$execute, _snapshot$execute2;
-
-    yield page.evaluate((_snapshot$execute = snapshot.execute) === null || _snapshot$execute === void 0 ? void 0 : _snapshot$execute.beforeResize);
-    yield waitForDiscoveryNetworkIdle(page, snapshot.discovery);
-    yield page.resize({
-      width,
-      height: snapshot.minHeight,
-      ...options
-    });
-    yield page.evaluate((_snapshot$execute2 = snapshot.execute) === null || _snapshot$execute2 === void 0 ? void 0 : _snapshot$execute2.afterResize);
-  }
-} // Discovers resources for a snapshot using a browser page to intercept requests. The callback
-// function will be called with the snapshot name (for additional snapshots) and an array of
-// discovered resources. When additional snapshots are provided, the callback will be called once
-// for each snapshot.
-
-
-export async function* discoverSnapshotResources(percy, snapshot, callback) {
-  debugSnapshotConfig(snapshot, percy.dryRun); // when dry-running, invoke the callback for each snapshot and immediately return
-
-  let allSnapshots = [snapshot, ...(snapshot.additionalSnapshots || [])];
-  if (percy.dryRun) return allSnapshots.map(s => callback(s)); // keep a global resource cache across snapshots
-
-  let cache = percy[RESOURCE_CACHE_KEY] || (percy[RESOURCE_CACHE_KEY] = new Map()); // preload the root resource for existing dom snapshots
-
-  let resources = new Map(snapshot.domSnapshot && [createRootResource(snapshot.url, snapshot.domSnapshot)].map(resource => [resource.url, resource])); // when no discovery browser is available, do not attempt to discover other resources
-
-  if (percy.skipDiscovery && !snapshot.domSnapshot) {
-    throw new Error('Cannot capture DOM snapshot when asset discovery is disabled');
-  } else if (percy.skipDiscovery) {
-    return handleSnapshotResources(snapshot, resources, callback);
-  } // open a new browser page
-
-
-  let page = yield percy.browser.page({
-    enableJavaScript: snapshot.enableJavaScript ?? !snapshot.domSnapshot,
-    networkIdleTimeout: snapshot.discovery.networkIdleTimeout,
-    requestHeaders: snapshot.discovery.requestHeaders,
-    authorization: snapshot.discovery.authorization,
-    userAgent: snapshot.discovery.userAgent,
-    meta: snapshot.meta,
-    // enable network inteception
-    intercept: {
-      enableJavaScript: snapshot.enableJavaScript,
-      disableCache: snapshot.discovery.disableCache,
-      allowedHostnames: snapshot.discovery.allowedHostnames,
-      disallowedHostnames: snapshot.discovery.disallowedHostnames,
-      getResource: u => resources.get(u) || cache.get(u),
-      saveResource: r => resources.set(r.url, r) && cache.set(r.url, r)
+    concurrency
+  } = percy.config.discovery;
+  let queue = new Queue();
+  let build;
+  return queue.set({
+    concurrency
+  }) // on start, create a new Percy build
+  .handle('start', async () => {
+    try {
+      build = percy.build = {};
+      let {
+        data
+      } = await percy.client.createBuild();
+      let url = data.attributes['web-url'];
+      let number = data.attributes['build-number'];
+      Object.assign(build, {
+        id: data.id,
+        url,
+        number
+      }); // immediately run the queue if not delayed or deferred
+
+      if (!percy.delayUploads && !percy.deferUploads) queue.run();
+    } catch (err) {
+      // immediately throw the error if not delayed or deferred
+      if (!percy.delayUploads && !percy.deferUploads) throw err;
+      Object.assign(build, {
+        error: 'Failed to create build'
+      });
+      percy.log.error(build.error);
+      percy.log.error(err);
+      queue.close(true);
     }
-  });
+  }) // on end, maybe finalize the build and log about build info
+  .handle('end', async () => {
+    var _build, _build2;
 
-  try {
-    yield* triggerResourceRequests(page, snapshot); // trigger resource requests for any alternate device pixel ratio
-
-    if (snapshot.discovery.devicePixelRatio) {
-      // wait for any existing pending resource requests first
-      yield waitForDiscoveryNetworkIdle(page, snapshot.discovery);
-      yield* triggerResourceRequests(page, snapshot, {
-        deviceScaleFactor: snapshot.discovery.devicePixelRatio,
-        mobile: true
+    if (!percy.readyState) return;
+
+    if ((_build = build) !== null && _build !== void 0 && _build.failed) {
+      percy.log.warn(`Build #${build.number} failed: ${build.url}`, {
+        build
+      });
+    } else if ((_build2 = build) !== null && _build2 !== void 0 && _build2.id) {
+      await percy.client.finalizeBuild(build.id);
+      percy.log.info(`Finalized build #${build.number}: ${build.url}`, {
+        build
+      });
+    } else {
+      percy.log.warn('Build not created', {
+        build
       });
     }
+  }) // snapshots are unique by name alone
+  .handle('find', ({
+    name
+  }, snapshot) => snapshot.name === name) // when pushed, maybe flush old snapshots or possibly merge with existing snapshots
+  .handle('push', (snapshot, existing) => {
+    let {
+      name,
+      meta
+    } = snapshot; // log immediately when not deferred or dry-running
+
+    if (!percy.deferUploads) percy.log.info(`Snapshot taken: ${name}`, meta);
+    if (percy.dryRun) percy.log.info(`Snapshot found: ${name}`, meta); // immediately flush when uploads are delayed but not skipped
+
+    if (percy.delayUploads && !percy.deferUploads) queue.flush(); // overwrite any existing snapshot when not deferred or when resources is a function
+
+    if (!percy.deferUploads || typeof snapshot.resources === 'function') return snapshot; // merge snapshot options when uploads are deferred
+
+    return mergeSnapshotOptions(existing, snapshot);
+  }) // send snapshots to be uploaded to the build
+  .handle('task', async function* ({
+    resources,
+    ...snapshot
+  }) {
+    let {
+      name,
+      meta
+    } = snapshot; // yield to evaluated snapshot resources
+
+    snapshot.resources = typeof resources === 'function' ? yield* yieldTo(resources()) : resources; // upload the snapshot and log when deferred
+
+    let send = 'tag' in snapshot ? 'sendComparison' : 'sendSnapshot';
+    let response = yield percy.client[send](build.id, snapshot);
+    if (percy.deferUploads) percy.log.info(`Snapshot uploaded: ${name}`, meta);
+    return { ...snapshot,
+      response
+    };
+  }) // handle possible build errors returned by the API
+  .handle('error', (snapshot, error) => {
+    var _error$response;
+
+    let result = { ...snapshot,
+      error
+    };
+    let {
+      name,
+      meta
+    } = snapshot;
+    if (error.name === 'QueueClosedError') return result;
+    if (error.name === 'AbortError') return result;
+    let failed = ((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.statusCode) === 422 && error.response.body.errors.find(e => {
+      var _e$source;
+
+      return ((_e$source = e.source) === null || _e$source === void 0 ? void 0 : _e$source.pointer) === '/data/attributes/build';
+    });
 
-    if (snapshot.domSnapshot) {
-      // ensure discovery has finished and handle resources
-      yield waitForDiscoveryNetworkIdle(page, snapshot.discovery);
-      handleSnapshotResources(snapshot, resources, callback);
-    } else {
-      let {
-        enableJavaScript
-      } = snapshot; // capture snapshots sequentially
-
-      for (let snap of allSnapshots) {
-        // will wait for timeouts, selectors, and additional network activity
-        let {
-          url,
-          dom
-        } = yield page.snapshot({
-          enableJavaScript,
-          ...snap
-        });
-        let root = createRootResource(url, dom); // use the normalized root url to prevent duplicates
-
-        resources.set(root.url, root); // shallow merge with root snapshot options
-
-        handleSnapshotResources({ ...snapshot,
-          ...snap
-        }, resources, callback); // remove the previously captured dom snapshot
-
-        resources.delete(root.url);
-      }
+    if (failed) {
+      build.error = error.message = failed.detail;
+      build.failed = true;
+      queue.close(true);
     }
-  } finally {
-    await page.close();
-  }
+
+    percy.log.error(`Encountered an error uploading snapshot: ${name}`, meta);
+    percy.log.error(error, meta);
+    return result;
+  });
 }

package/dist/utils.js

@@ -45,7 +45,10 @@ export function createPercyCSSResource(url, css) {
 } // Creates a log resource object.
 
 export function createLogResource(logs) {
-  return createResource(`/percy.${Date.now()}.log`, JSON.stringify(logs), 'text/plain');
+  let [url, content] = [`/percy.${Date.now()}.log`, JSON.stringify(logs)];
+  return createResource(url, content, 'text/plain', {
+    log: true
+  });
 } // Returns true or false if the provided object is a generator or not
 
 export function isGenerator(subject) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/core",
-  "version": "1.10.4",
+  "version": "1.11.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -39,10 +39,10 @@
     "test:types": "tsd"
   },
   "dependencies": {
-    "@percy/client": "1.10.4",
-    "@percy/config": "1.10.4",
-    "@percy/dom": "1.10.4",
-    "@percy/logger": "1.10.4",
+    "@percy/client": "1.11.0",
+    "@percy/config": "1.11.0",
+    "@percy/dom": "1.11.0",
+    "@percy/logger": "1.11.0",
     "content-disposition": "^0.5.4",
     "cross-spawn": "^7.0.3",
     "extract-zip": "^2.0.1",
@@ -53,5 +53,5 @@
     "rimraf": "^3.0.2",
     "ws": "^8.0.0"
   },
-  "gitHead": "16a9a410bfcb8eab51b86a08cff12d8d35e4747e"
+  "gitHead": "0a5043cd677266390889063924f342af9b347055"
 }