@percy/client 1.12.0 → 1.14.0

package/dist/client.js

@@ -2,39 +2,38 @@ import fs from 'fs';
 import PercyEnv from '@percy/env';
 import { git } from '@percy/env/utils';
 import logger from '@percy/logger';
-import { pool, request, sha256hash, base64encode, getPackageJSON } from './utils.js'; // Default client API URL can be set with an env var for API development
+import { pool, request, sha256hash, base64encode, getPackageJSON } from './utils.js';
 
+// Default client API URL can be set with an env var for API development
 const {
   PERCY_CLIENT_API_URL = 'https://percy.io/api/v1'
 } = process.env;
-const pkg = getPackageJSON(import.meta.url); // Validate ID arguments
+const pkg = getPackageJSON(import.meta.url);
 
+// Validate ID arguments
 function validateId(type, id) {
   if (!id) throw new Error(`Missing ${type} ID`);
-
   if (!(typeof id === 'string' || typeof id === 'number')) {
     throw new Error(`Invalid ${type} ID`);
   }
-} // Validate project path arguments
-
+}
 
+// Validate project path arguments
 function validateProjectPath(path) {
   if (!path) throw new Error('Missing project path');
-
   if (!/^[^/]+?\/.+/.test(path)) {
     throw new Error(`Invalid project path. Expected "org/project" but received "${path}"`);
   }
-} // PercyClient is used to communicate with the Percy API to create and finalize
+}
+
+// PercyClient is used to communicate with the Percy API to create and finalize
 // builds and snapshot. Uses @percy/env to collect environment information used
 // during build creation.
-
-
 export class PercyClient {
   log = logger('client');
   env = new PercyEnv(process.env);
   clientInfo = new Set();
   environmentInfo = new Set();
-
   constructor({
     // read or write token, defaults to PERCY_TOKEN environment variable
     token,
@@ -50,55 +49,55 @@ export class PercyClient {
     });
     this.addClientInfo(clientInfo);
     this.addEnvironmentInfo(environmentInfo);
-  } // Adds additional unique client info.
-
+  }
 
+  // Adds additional unique client info.
   addClientInfo(info) {
     for (let i of [].concat(info)) {
       if (i) this.clientInfo.add(i);
     }
-  } // Adds additional unique environment info.
-
+  }
 
+  // Adds additional unique environment info.
   addEnvironmentInfo(info) {
     for (let i of [].concat(info)) {
       if (i) this.environmentInfo.add(i);
     }
-  } // Stringifies client and environment info.
-
+  }
 
+  // Stringifies client and environment info.
   userAgent() {
     let client = new Set([`Percy/${/\w+$/.exec(this.apiUrl)}`].concat(`${pkg.name}/${pkg.version}`, ...this.clientInfo).filter(Boolean));
     let environment = new Set([...this.environmentInfo].concat(`node/${process.version}`, this.env.info).filter(Boolean));
     return `${[...client].join(' ')} (${[...environment].join('; ')})`;
-  } // Checks for a Percy token and returns it.
-
+  }
 
+  // Checks for a Percy token and returns it.
   getToken() {
     let token = this.token || this.env.token;
     if (!token) throw new Error('Missing Percy token');
     return token;
-  } // Returns common headers used for each request with additional
+  }
+
+  // Returns common headers used for each request with additional
   // headers. Throws an error when the token is missing, which is a required
   // authorization header.
-
-
   headers(headers) {
     return Object.assign({
       Authorization: `Token token=${this.getToken()}`,
       'User-Agent': this.userAgent()
     }, headers);
-  } // Performs a GET request for an API endpoint with appropriate headers.
-
+  }
 
+  // Performs a GET request for an API endpoint with appropriate headers.
   get(path) {
     return request(`${this.apiUrl}/${path}`, {
       headers: this.headers(),
       method: 'GET'
     });
-  } // Performs a POST request to a JSON API endpoint with appropriate headers.
-
+  }
 
+  // Performs a POST request to a JSON API endpoint with appropriate headers.
   post(path, body = {}) {
     return request(`${this.apiUrl}/${path}`, {
       headers: this.headers({
@@ -107,11 +106,11 @@ export class PercyClient {
       method: 'POST',
       body
     });
-  } // Creates a build with optional build resources. Only one build can be
+  }
+
+  // Creates a build with optional build resources. Only one build can be
   // created at a time per instance so snapshots and build finalization can be
   // done more seemlessly without manually tracking build ids
-
-
   async createBuild({
     resources = []
   } = {}) {
@@ -150,10 +149,10 @@ export class PercyClient {
         }
       }
     });
-  } // Finalizes the active build. When `all` is true, `all-shards=true` is
-  // added as a query param so the API finalizes all other build shards.
-
+  }
 
+  // Finalizes the active build. When `all` is true, `all-shards=true` is
+  // added as a query param so the API finalizes all other build shards.
   async finalizeBuild(buildId, {
     all = false
   } = {}) {
@@ -161,25 +160,25 @@ export class PercyClient {
     let qs = all ? 'all-shards=true' : '';
     this.log.debug(`Finalizing build ${buildId}...`);
     return this.post(`builds/${buildId}/finalize?${qs}`);
-  } // Retrieves build data by id. Requires a read access token.
-
+  }
 
+  // Retrieves build data by id. Requires a read access token.
   async getBuild(buildId) {
     validateId('build', buildId);
     this.log.debug(`Get build ${buildId}`);
     return this.get(`builds/${buildId}`);
-  } // Retrieves project builds optionally filtered. Requires a read access token.
-
+  }
 
+  // Retrieves project builds optionally filtered. Requires a read access token.
   async getBuilds(project, filters = {}) {
     validateProjectPath(project);
     let qs = Object.keys(filters).map(k => Array.isArray(filters[k]) ? filters[k].map(v => `filter[${k}][]=${v}`).join('&') : `filter[${k}]=${filters[k]}`).join('&');
     this.log.debug(`Fetching builds for ${project}`);
     return this.get(`projects/${project}/builds?${qs}`);
-  } // Resolves when the build has finished and is no longer pending or
-  // processing. By default, will time out if no update after 10 minutes.
-
+  }
 
+  // Resolves when the build has finished and is no longer pending or
+  // processing. By default, will time out if no update after 10 minutes.
   waitForBuild({
     build,
     project,
@@ -194,42 +193,44 @@ export class PercyClient {
     } else if (project) {
       validateProjectPath(project);
     }
-
     commit || (commit = this.env.git.sha);
     if (!build && !commit) throw new Error('Missing build commit');
     let sha = commit && (git(`rev-parse ${commit}`) || commit);
-
     let fetchData = async () => {
       var _await$this$getBuilds;
-
       return build ? (await this.getBuild(build)).data : (_await$this$getBuilds = (await this.getBuilds(project, {
         sha
       })).data) === null || _await$this$getBuilds === void 0 ? void 0 : _await$this$getBuilds[0];
     };
+    this.log.debug(`Waiting for build ${build || `${project} (${commit})`}...`);
 
-    this.log.debug(`Waiting for build ${build || `${project} (${commit})`}...`); // recursively poll every second until the build finishes
-
+    // recursively poll every second until the build finishes
     return new Promise((resolve, reject) => async function poll(last, t) {
       try {
         let data = await fetchData();
         let state = data === null || data === void 0 ? void 0 : data.attributes.state;
         let pending = !state || state === 'pending' || state === 'processing';
-        let updated = JSON.stringify(data) !== JSON.stringify(last); // new data received
+        let updated = JSON.stringify(data) !== JSON.stringify(last);
 
+        // new data received
         if (updated) {
-          t = Date.now(); // no new data within the timeout
+          t = Date.now();
+
+          // no new data within the timeout
         } else if (Date.now() - t >= timeout) {
           throw new Error(state == null ? 'Build not found' : 'Timeout exceeded with no updates');
-        } // call progress every update after the first update
-
+        }
 
+        // call progress every update after the first update
         if ((last || pending) && updated) {
           onProgress === null || onProgress === void 0 ? void 0 : onProgress(data);
-        } // not finished, poll again
-
+        }
 
+        // not finished, poll again
         if (pending) {
-          return setTimeout(poll, interval, data, t); // build finished
+          return setTimeout(poll, interval, data, t);
+
+          // build finished
         } else {
           // ensure progress is called at least once
           if (!last) onProgress === null || onProgress === void 0 ? void 0 : onProgress(data);
@@ -241,11 +242,11 @@ export class PercyClient {
         reject(err);
       }
     }(null, Date.now()));
-  } // Uploads a single resource to the active build. If `filepath` is provided,
+  }
+
+  // Uploads a single resource to the active build. If `filepath` is provided,
   // `content` is read from the filesystem. The sha is optional and will be
   // created from `content` if one is not provided.
-
-
   async uploadResource(buildId, {
     url,
     sha,
@@ -264,9 +265,9 @@ export class PercyClient {
         }
       }
     });
-  } // Uploads resources to the active build concurrently, two at a time.
-
+  }
 
+  // Uploads resources to the active build concurrently, two at a time.
   async uploadResources(buildId, resources) {
     validateId('build', buildId);
     this.log.debug(`Uploading resources for ${buildId}...`);
@@ -275,9 +276,9 @@ export class PercyClient {
         yield this.uploadResource(buildId, resource);
       }
     }, this, 2);
-  } // Creates a snapshot for the active build using the provided attributes.
-
+  }
 
+  // Creates a snapshot for the active build using the provided attributes.
   async createSnapshot(buildId, {
     name,
     widths,
@@ -291,18 +292,14 @@ export class PercyClient {
     validateId('build', buildId);
     this.addClientInfo(clientInfo);
     this.addEnvironmentInfo(environmentInfo);
-
     if (!this.clientInfo.size || !this.environmentInfo.size) {
       this.log.warn('Warning: Missing `clientInfo` and/or `environmentInfo` properties');
     }
-
     this.log.debug(`Creating snapshot: ${name}...`);
-
     for (let resource of resources) {
       if (resource.sha || resource.content || !resource.filepath) continue;
       resource.content = await fs.promises.readFile(resource.filepath);
     }
-
     return this.post(`builds/${buildId}/snapshots`, {
       data: {
         type: 'snapshots',
@@ -329,23 +326,21 @@ export class PercyClient {
         }
       }
     });
-  } // Finalizes a snapshot.
-
+  }
 
+  // Finalizes a snapshot.
   async finalizeSnapshot(snapshotId) {
     validateId('snapshot', snapshotId);
     this.log.debug(`Finalizing snapshot ${snapshotId}...`);
     return this.post(`snapshots/${snapshotId}/finalize`);
-  } // Convenience method for creating a snapshot for the active build, uploading
-  // missing resources for the snapshot, and finalizing the snapshot.
-
+  }
 
+  // Convenience method for creating a snapshot for the active build, uploading
+  // missing resources for the snapshot, and finalizing the snapshot.
   async sendSnapshot(buildId, options) {
     var _snapshot$data$relati, _snapshot$data$relati2;
-
     let snapshot = await this.createSnapshot(buildId, options);
     let missing = (_snapshot$data$relati = snapshot.data.relationships) === null || _snapshot$data$relati === void 0 ? void 0 : (_snapshot$data$relati2 = _snapshot$data$relati['missing-resources']) === null || _snapshot$data$relati2 === void 0 ? void 0 : _snapshot$data$relati2.data;
-
     if (missing !== null && missing !== void 0 && missing.length) {
       let resources = options.resources.reduce((acc, r) => Object.assign(acc, {
         [r.sha]: r
@@ -354,11 +349,9 @@ export class PercyClient {
         id
       }) => resources[id]));
     }
-
     await this.finalizeSnapshot(snapshot.data.id);
     return snapshot;
   }
-
   async createComparison(snapshotId, {
     tag,
     tiles = [],
@@ -366,12 +359,10 @@ export class PercyClient {
   } = {}) {
     validateId('snapshot', snapshotId);
     this.log.debug(`Creating comparision: ${tag.name}...`);
-
     for (let tile of tiles) {
       if (tile.sha || tile.content || !tile.filepath) continue;
       tile.content = await fs.promises.readFile(tile.filepath);
     }
-
     return this.post(`snapshots/${snapshotId}/comparisons`, {
       data: {
         type: 'comparisons',
@@ -409,7 +400,6 @@ export class PercyClient {
       }
     });
   }
-
   async uploadComparisonTile(comparisonId, {
     index = 0,
     total = 1,
@@ -429,7 +419,6 @@ export class PercyClient {
       }
     });
   }
-
   async uploadComparisonTiles(comparisonId, tiles) {
     validateId('comparison', comparisonId);
     this.log.debug(`Uploading comparison tiles for ${comparisonId}...`);
@@ -443,13 +432,11 @@ export class PercyClient {
       }
     }, this, 2);
   }
-
   async finalizeComparison(comparisonId) {
     validateId('comparison', comparisonId);
     this.log.debug(`Finalizing comparison ${comparisonId}...`);
     return this.post(`comparisons/${comparisonId}/finalize`);
   }
-
   async sendComparison(buildId, options) {
     let snapshot = await this.createSnapshot(buildId, options);
     let comparison = await this.createComparison(snapshot.data.id, options);
@@ -457,6 +444,5 @@ export class PercyClient {
     await this.finalizeComparison(comparison.data.id);
     return comparison;
   }
-
 }
 export default PercyClient;

package/dist/proxy.js

@@ -4,44 +4,48 @@ import http from 'http';
 import https from 'https';
 import logger from '@percy/logger';
 const CRLF = '\r\n';
-const STATUS_REG = /^HTTP\/1.[01] (\d*)/; // Returns true if the URL hostname matches any patterns
+const STATUS_REG = /^HTTP\/1.[01] (\d*)/;
 
+// Returns true if the URL hostname matches any patterns
 export function hostnameMatches(patterns, url) {
   let subject = new URL(url);
+
   /* istanbul ignore next: only strings are provided internally by the client proxy; core (which
    * borrows this util) sometimes provides an array of patterns or undefined */
-
   patterns = typeof patterns === 'string' ? patterns.split(/[\s,]+/) : [].concat(patterns);
-
   for (let pattern of patterns) {
     if (pattern === '*') return true;
-    if (!pattern) continue; // parse pattern
+    if (!pattern) continue;
 
+    // parse pattern
     let {
       groups: rule
-    } = pattern.match(/^(?<hostname>.+?)(?::(?<port>\d+))?$/); // missing a hostname or ports do not match
+    } = pattern.match(/^(?<hostname>.+?)(?::(?<port>\d+))?$/);
 
+    // missing a hostname or ports do not match
     if (!rule.hostname || rule.port && rule.port !== subject.port) {
       continue;
-    } // wildcards are treated the same as leading dots
-
+    }
 
-    rule.hostname = rule.hostname.replace(/^\*/, ''); // hostnames are equal or end with a wildcard rule
+    // wildcards are treated the same as leading dots
+    rule.hostname = rule.hostname.replace(/^\*/, '');
 
+    // hostnames are equal or end with a wildcard rule
     if (rule.hostname === subject.hostname || rule.hostname.startsWith('.') && subject.hostname.endsWith(rule.hostname)) {
       return true;
     }
   }
-
   return false;
-} // Returns the port number of a URL object. Defaults to port 443 for https
-// protocols or port 80 otherwise.
+}
 
+// Returns the port number of a URL object. Defaults to port 443 for https
+// protocols or port 80 otherwise.
 export function port(options) {
   if (options.port) return options.port;
   return options.protocol === 'https:' ? 443 : 80;
-} // Returns a string representation of a URL-like object
+}
 
+// Returns a string representation of a URL-like object
 export function href(options) {
   let {
     protocol,
@@ -53,72 +57,64 @@ export function href(options) {
   } = options;
   return `${protocol}//${hostname}:${port(options)}` + (path || `${pathname || ''}${search || ''}${hash || ''}`);
 }
-; // Returns the proxy URL for a set of request options
+;
 
+// Returns the proxy URL for a set of request options
 export function getProxy(options) {
   let proxyUrl = options.protocol === 'https:' && (process.env.https_proxy || process.env.HTTPS_PROXY) || process.env.http_proxy || process.env.HTTP_PROXY;
   let shouldProxy = !!proxyUrl && !hostnameMatches(process.env.no_proxy || process.env.NO_PROXY, href(options));
-
   if (shouldProxy) {
     proxyUrl = new URL(proxyUrl);
     let isHttps = proxyUrl.protocol === 'https:';
-
     if (!isHttps && proxyUrl.protocol !== 'http:') {
       throw new Error(`Unsupported proxy protocol: ${proxyUrl.protocol}`);
     }
-
     let proxy = {
       isHttps
     };
     proxy.auth = !!proxyUrl.username && 'Basic ' + (proxyUrl.password ? Buffer.from(`${proxyUrl.username}:${proxyUrl.password}`) : Buffer.from(proxyUrl.username)).toString('base64');
     proxy.host = proxyUrl.hostname;
     proxy.port = port(proxyUrl);
-
     proxy.connect = () => (isHttps ? tls : net).connect({
       rejectUnauthorized: options.rejectUnauthorized,
       host: proxy.host,
       port: proxy.port
     });
-
     return proxy;
   }
-} // Proxified http agent
+}
 
+// Proxified http agent
 export class ProxyHttpAgent extends http.Agent {
   // needed for https proxies
   httpsAgent = new https.Agent({
     keepAlive: true
   });
-
   addRequest(request, options) {
     var _request$outputData;
-
     let proxy = getProxy(options);
     if (!proxy) return super.addRequest(request, options);
-    logger('client:proxy').debug(`Proxying request: ${options.href}`); // modify the request for proxying
+    logger('client:proxy').debug(`Proxying request: ${options.href}`);
 
+    // modify the request for proxying
     request.path = href(options);
-
     if (proxy.auth) {
       request.setHeader('Proxy-Authorization', proxy.auth);
-    } // regenerate headers since we just changed things
-
+    }
 
+    // regenerate headers since we just changed things
     delete request._header;
-
     request._implicitHeader();
-
     if (((_request$outputData = request.outputData) === null || _request$outputData === void 0 ? void 0 : _request$outputData.length) > 0) {
       let first = request.outputData[0].data;
       let endOfHeaders = first.indexOf(CRLF.repeat(2)) + 4;
       request.outputData[0].data = request._header + first.substring(endOfHeaders);
-    } // coerce the connection to the proxy
-
+    }
 
+    // coerce the connection to the proxy
     options.port = proxy.port;
     options.host = proxy.host;
     delete options.path;
-
     if (proxy.isHttps) {
       // use the underlying https agent to complete the connection
       request.agent = this.httpsAgent;
@@ -127,9 +123,9 @@ export class ProxyHttpAgent extends http.Agent {
       return super.addRequest(request, options);
     }
   }
+}
 
-} // Proxified https agent
-
+// Proxified https agent
 export class ProxyHttpsAgent extends https.Agent {
   constructor(options) {
     // default keep-alive
@@ -138,56 +134,47 @@ export class ProxyHttpsAgent extends https.Agent {
       ...options
     });
   }
-
   createConnection(options, callback) {
     let proxy = getProxy(options);
     if (!proxy) return super.createConnection(options, callback);
-    logger('client:proxy').debug(`Proxying request: ${href(options)}`); // generate proxy connect message
+    logger('client:proxy').debug(`Proxying request: ${href(options)}`);
 
+    // generate proxy connect message
     let host = `${options.hostname}:${port(options)}`;
     let connectMessage = [`CONNECT ${host} HTTP/1.1`, `Host: ${host}`];
-
     if (proxy.auth) {
       connectMessage.push(`Proxy-Authorization: ${proxy.auth}`);
     }
-
     connectMessage = connectMessage.join(CRLF);
-    connectMessage += CRLF.repeat(2); // start the proxy connection and setup listeners
+    connectMessage += CRLF.repeat(2);
 
+    // start the proxy connection and setup listeners
     let socket = proxy.connect();
-
     let handleError = err => {
       socket.destroy(err);
       callback(err);
     };
-
     let handleClose = () => handleError(new Error('Connection closed while sending request to upstream proxy'));
-
     let buffer = '';
-
     let handleData = data => {
       var _buffer$match;
-
-      buffer += data.toString(); // haven't received end of headers yet, keep buffering
-
-      if (!buffer.includes(CRLF.repeat(2))) return; // stop listening after end of headers
-
+      buffer += data.toString();
+      // haven't received end of headers yet, keep buffering
+      if (!buffer.includes(CRLF.repeat(2))) return;
+      // stop listening after end of headers
       socket.off('data', handleData);
-
       if (((_buffer$match = buffer.match(STATUS_REG)) === null || _buffer$match === void 0 ? void 0 : _buffer$match[1]) !== '200') {
         return handleError(new Error('Error establishing proxy connection. ' + `Response from server was: ${buffer}`));
       }
-
       options.socket = socket;
-      options.servername = options.hostname; // callback not passed in so not to be added as a listener
-
+      options.servername = options.hostname;
+      // callback not passed in so not to be added as a listener
       callback(null, super.createConnection(options));
-    }; // send and handle the connect message
-
+    };
 
+    // send and handle the connect message
     socket.on('error', handleError).on('close', handleClose).on('data', handleData).write(connectMessage);
   }
-
 }
 export function proxyAgentFor(url, options) {
   let cache = proxyAgentFor.cache || (proxyAgentFor.cache = new Map());
@@ -196,10 +183,8 @@ export function proxyAgentFor(url, options) {
     hostname
   } = new URL(url);
   let cachekey = `${protocol}//${hostname}`;
-
   if (!cache.has(cachekey)) {
     cache.set(cachekey, protocol === 'https:' ? new ProxyHttpsAgent(options) : new ProxyHttpAgent(options));
   }
-
   return cache.get(cachekey);
 }

package/dist/utils.js

@@ -2,16 +2,19 @@ import os from 'os';
 import fs from 'fs';
 import url from 'url';
 import path from 'path';
-import crypto from 'crypto'; // Returns a sha256 hash of a string.
+import crypto from 'crypto';
 
+// Returns a sha256 hash of a string.
 export function sha256hash(content) {
   return crypto.createHash('sha256').update(content, 'utf-8').digest('hex');
-} // Returns a base64 encoding of a string or buffer.
+}
 
+// Returns a base64 encoding of a string or buffer.
 export function base64encode(content) {
   return Buffer.from(content).toString('base64');
-} // Returns the package.json content at the package path.
+}
 
+// Returns the package.json content at the package path.
 export function getPackageJSON(rel) {
   /* istanbul ignore else: sanity check */
   if (rel.startsWith('file:')) rel = url.fileURLToPath(rel);
@@ -19,32 +22,31 @@ export function getPackageJSON(rel) {
   if (fs.existsSync(pkg)) return JSON.parse(fs.readFileSync(pkg));
   let dir = path.dirname(rel);
   /* istanbul ignore else: sanity check */
-
   if (dir !== rel && dir !== os.homedir()) return getPackageJSON(dir);
-} // Creates a concurrent pool of promises created by the given generator.
+}
+
+// Creates a concurrent pool of promises created by the given generator.
 // Resolves when the generator's final promise resolves and rejects when any
 // generated promise rejects.
-
 export function pool(generator, context, concurrency) {
   return new Promise((resolve, reject) => {
     let iterator = generator.call(context);
     let queue = 0;
     let ret = [];
-    let err; // generates concurrent promises
+    let err;
 
+    // generates concurrent promises
     let proceed = () => {
       while (queue < concurrency) {
         let {
           done,
           value: promise
         } = iterator.next();
-
         if (done || err) {
           if (!queue && err) reject(err);
           if (!queue) resolve(ret);
           return;
         }
-
         queue++;
         promise.then(value => {
           queue--;
@@ -56,49 +58,53 @@ export function pool(generator, context, concurrency) {
           proceed();
         });
       }
-    }; // start generating promises
-
+    };
 
+    // start generating promises
     proceed();
   });
-} // Returns a promise that resolves or rejects when the provided function calls
+}
+
+// Returns a promise that resolves or rejects when the provided function calls
 // `resolve` or `reject` respectively. The third function argument, `retry`,
 // will recursively call the function at the specified interval until retries
 // are exhausted, at which point the promise will reject with the last error
 // passed to `retry`.
-
 export function retry(fn, {
   retries = 5,
   interval = 50
 }) {
   return new Promise((resolve, reject) => {
-    let run = () => fn(resolve, reject, retry); // wait an interval to try again or reject with the error
-
+    let run = () => fn(resolve, reject, retry);
 
+    // wait an interval to try again or reject with the error
     let retry = err => {
       if (retries-- > 0) {
         setTimeout(run, interval);
       } else {
         reject(err);
       }
-    }; // start trying
-
+    };
 
+    // start trying
     run();
   });
-} // Used by the request util when retrying specific errors
+}
 
-const RETRY_ERROR_CODES = ['ECONNREFUSED', 'ECONNRESET', 'EPIPE', 'EHOSTUNREACH', 'EAI_AGAIN']; // Proxified request function that resolves with the response body when the request is successful
+// Used by the request util when retrying specific errors
+const RETRY_ERROR_CODES = ['ECONNREFUSED', 'ECONNRESET', 'EPIPE', 'EHOSTUNREACH', 'EAI_AGAIN'];
+
+// Proxified request function that resolves with the response body when the request is successful
 // and rejects when a non-successful response is received. The rejected error contains response data
 // and any received error details. Server 500 errors are retried up to 5 times at 50ms intervals by
 // default, and 404 errors may also be optionally retried. If a callback is provided, it is called
 // with the parsed response body and response details. If the callback returns a value, that value
 // will be returned in the final resolved promise instead of the response body.
-
 export async function request(url, options = {}, callback) {
   // accept `request(url, callback)`
-  if (typeof options === 'function') [options, callback] = [{}, options]; // gather request options
+  if (typeof options === 'function') [options, callback] = [{}, options];
 
+  // gather request options
   let {
     body,
     headers,
@@ -116,24 +122,26 @@ export async function request(url, options = {}, callback) {
     pathname,
     search,
     hash
-  } = new URL(url); // reference the default export so tests can mock it
+  } = new URL(url);
 
+  // reference the default export so tests can mock it
   let {
     default: http
   } = await import(protocol === 'https:' ? 'https' : 'http');
   let {
     proxyAgentFor
-  } = await import('./proxy.js'); // automatically stringify body content
+  } = await import('./proxy.js');
 
+  // automatically stringify body content
   if (body !== undefined && typeof body !== 'string') {
     headers = {
       'Content-Type': 'application/json',
       ...headers
     };
     body = JSON.stringify(body);
-  } // combine request options
-
+  }
 
+  // combine request options
   Object.assign(requestOptions, {
     agent: requestOptions.agent || !noProxy && proxyAgentFor(url) || null,
     path: pathname + search + hash,
@@ -145,33 +153,32 @@ export async function request(url, options = {}, callback) {
   return retry((resolve, reject, retry) => {
     let handleError = error => {
       if (handleError.handled) return;
-      handleError.handled = true; // maybe retry 404s, always retry 500s, or retry specific errors
+      handleError.handled = true;
 
+      // maybe retry 404s, always retry 500s, or retry specific errors
       let shouldRetry = error.response ? retryNotFound && error.response.statusCode === 404 || error.response.statusCode >= 500 && error.response.statusCode < 600 : !!error.code && RETRY_ERROR_CODES.includes(error.code);
       return shouldRetry ? retry(error) : reject(error);
     };
-
     let handleFinished = async (body, res) => {
       let {
         statusCode,
         headers
       } = res;
-      let raw = body.toString('utf-8'); // only return a buffer when requested
+      let raw = body.toString('utf-8');
 
-      if (buffer !== true) body = raw; // attempt to parse the body as json
+      // only return a buffer when requested
+      if (buffer !== true) body = raw;
 
+      // attempt to parse the body as json
       try {
         body = JSON.parse(raw);
       } catch {}
-
       try {
         if (statusCode >= 200 && statusCode < 300) {
           var _callback;
-
           resolve((await ((_callback = callback) === null || _callback === void 0 ? void 0 : _callback(body, res))) ?? body);
         } else {
           var _body, _body$errors, _body$errors$find;
-
           let err = (_body = body) === null || _body === void 0 ? void 0 : (_body$errors = _body.errors) === null || _body$errors === void 0 ? void 0 : (_body$errors$find = _body$errors.find(e => e.detail)) === null || _body$errors$find === void 0 ? void 0 : _body$errors$find.detail;
           throw new Error(err || `${statusCode} ${res.statusMessage || raw}`);
         }
@@ -186,14 +193,12 @@ export async function request(url, options = {}, callback) {
         }));
       }
     };
-
     let handleResponse = res => {
       let chunks = [];
       res.on('data', chunk => chunks.push(chunk));
       res.on('end', () => handleFinished(Buffer.concat(chunks), res));
       res.on('error', handleError);
     };
-
     let req = http.request(requestOptions);
     req.on('response', handleResponse);
     req.on('error', handleError);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/client",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -31,8 +31,8 @@
     "test:coverage": "yarn test --coverage"
   },
   "dependencies": {
-    "@percy/env": "1.12.0",
-    "@percy/logger": "1.12.0"
+    "@percy/env": "1.14.0",
+    "@percy/logger": "1.14.0"
   },
-  "gitHead": "4303b74df91f60e36065141289d2ef2277d1d6fc"
+  "gitHead": "fd72688e449d6dd3eafd346fc07879cb3bb01a4e"
 }