@percy/core 1.12.0 → 1.14.0

package/dist/server.js

@@ -1,38 +1,28 @@
 function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
-
 function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
-
 function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
-
 function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
-
 function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
-
 function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
-
 function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
-
 function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
-
 function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
-
 import fs from 'fs';
 import path from 'path';
 import http from 'http';
 import mime from 'mime-types';
 import disposition from 'content-disposition';
-import { pathToRegexp, match as pathToMatch, compile as makeToPath } from 'path-to-regexp'; // custom incoming message adds a `url` and `body` properties containing the parsed URL and message
-// buffer respectively; both available after the 'end' event is emitted
+import { pathToRegexp, match as pathToMatch, compile as makeToPath } from 'path-to-regexp';
 
+// custom incoming message adds a `url` and `body` properties containing the parsed URL and message
+// buffer respectively; both available after the 'end' event is emitted
 export class IncomingMessage extends http.IncomingMessage {
   constructor(socket) {
     let buffer = [];
     super(socket).on('data', d => buffer.push(d)).on('end', () => {
       var _this$headers$content;
-
       this.url = new URL(this.url, `http://${this.headers.host}`);
       if (buffer.length) this.body = Buffer.concat(buffer);
-
       if (this.body && (_this$headers$content = this.headers['content-type']) !== null && _this$headers$content !== void 0 && _this$headers$content.includes('json')) {
         try {
           this.body = JSON.parse(this.body);
@@ -40,9 +30,9 @@ export class IncomingMessage extends http.IncomingMessage {
       }
     });
   }
+}
 
-} // custom server response adds additional convenience methods
-
+// custom server response adds additional convenience methods
 export class ServerResponse extends http.ServerResponse {
   // responds with a status, headers, and body; the second argument can be an content-type string,
   // or a headers object, with content-length being automatically set when a `body` is provided
@@ -51,41 +41,39 @@ export class ServerResponse extends http.ServerResponse {
       this.setHeader('Content-Type', headers);
       headers = null;
     }
-
     if (body != null && !this.hasHeader('Content-Length')) {
       this.setHeader('Content-Length', Buffer.byteLength(body));
     }
-
     return this.writeHead(status, headers).end(body);
-  } // responds with a status and content with a plain/text content-type
-
+  }
 
+  // responds with a status and content with a plain/text content-type
   text(status, content) {
     if (arguments.length < 2) [status, content] = [200, status];
     return this.send(status, 'text/plain', content.toString());
-  } // responds with a status and stringified `data` with a json content-type
-
+  }
 
+  // responds with a status and stringified `data` with a json content-type
   json(status, data) {
     if (arguments.length < 2) [status, data] = [200, status];
     return this.send(status, 'application/json', JSON.stringify(data));
-  } // responds with a status and streams a file with appropriate headers
-
+  }
 
+  // responds with a status and streams a file with appropriate headers
   file(status, filepath) {
     if (arguments.length < 2) [status, filepath] = [200, status];
     filepath = path.resolve(filepath);
     let {
       size
     } = fs.lstatSync(filepath);
-    let range = parseByteRange(this.req.headers.range, size); // support simple range requests
+    let range = parseByteRange(this.req.headers.range, size);
 
+    // support simple range requests
     if (this.req.headers.range) {
       let byteRange = range ? `${range.start}-${range.end}` : '*';
       this.setHeader('Content-Range', `bytes ${byteRange}/${size}`);
       if (!range) return this.send(416);
     }
-
     this.writeHead(range ? 206 : status, {
       'Accept-Ranges': 'bytes',
       'Content-Type': mime.contentType(path.extname(filepath)),
@@ -97,31 +85,25 @@ export class ServerResponse extends http.ServerResponse {
     fs.createReadStream(filepath, range).pipe(this);
     return this;
   }
+}
 
-} // custom server error with a status and default reason
-
+// custom server error with a status and default reason
 export class ServerError extends Error {
   static throw(status, reason) {
     throw new this(status, reason);
   }
-
   constructor(status = 500, reason) {
     super(reason || http.STATUS_CODES[status]);
     this.status = status;
   }
+}
 
-} // custom server class handles routing requests and provides alternate methods and properties
-
+// custom server class handles routing requests and provides alternate methods and properties
 var _sockets = /*#__PURE__*/new WeakMap();
-
 var _defaultPort = /*#__PURE__*/new WeakMap();
-
 var _routes = /*#__PURE__*/new WeakMap();
-
 var _route = /*#__PURE__*/new WeakSet();
-
 var _handleRequest = /*#__PURE__*/new WeakSet();
-
 export class Server extends http.Server {
   constructor({
     port
@@ -130,28 +112,22 @@ export class Server extends http.Server {
       IncomingMessage,
       ServerResponse
     });
-
     _classPrivateMethodInitSpec(this, _handleRequest);
-
     _classPrivateMethodInitSpec(this, _route);
-
     _classPrivateFieldInitSpec(this, _sockets, {
       writable: true,
       value: new Set()
     });
-
     _classPrivateFieldInitSpec(this, _defaultPort, {
       writable: true,
       value: void 0
     });
-
     _classPrivateFieldInitSpec(this, _routes, {
       writable: true,
       value: [{
         priority: -1,
         handle: (req, res, next) => {
           res.setHeader('Access-Control-Allow-Origin', '*');
-
           if (req.method === 'OPTIONS') {
             let allowHeaders = req.headers['access-control-request-headers'] || '*';
             let allowMethods = [...new Set(_classPrivateFieldGet(this, _routes).flatMap(route => (!route.match || route.match(req.url.pathname)) && route.methods || []))].join(', ');
@@ -168,55 +144,50 @@ export class Server extends http.Server {
         handle: req => ServerError.throw(404)
       }]
     });
+    _classPrivateFieldSet(this, _defaultPort, port);
 
-    _classPrivateFieldSet(this, _defaultPort, port); // handle requests on end
-
-
+    // handle requests on end
     this.on('request', (req, res) => {
       req.on('end', () => _classPrivateMethodGet(this, _handleRequest, _handleRequest2).call(this, req, res));
-    }); // track open connections to terminate when the server closes
-
+    });
+    // track open connections to terminate when the server closes
     this.on('connection', socket => {
       let handleClose = () => _classPrivateFieldGet(this, _sockets).delete(socket);
-
       _classPrivateFieldGet(this, _sockets).add(socket.on('close', handleClose));
     });
-  } // return the listening port or any default port
-
+  }
 
+  // return the listening port or any default port
   get port() {
     var _super$address;
-
     return ((_super$address = super.address()) === null || _super$address === void 0 ? void 0 : _super$address.port) ?? _classPrivateFieldGet(this, _defaultPort);
-  } // return a string representation of the server address
-
+  }
 
+  // return a string representation of the server address
   address() {
     let port = this.port;
     let host = 'http://localhost';
     return port ? `${host}:${port}` : host;
-  } // return a promise that resolves when the server is listening
-
+  }
 
+  // return a promise that resolves when the server is listening
   listen(port = _classPrivateFieldGet(this, _defaultPort)) {
     return new Promise((resolve, reject) => {
       let handle = err => off() && err ? reject(err) : resolve(this);
-
       let off = () => this.off('error', handle).off('listening', handle);
-
       super.listen(port, handle).once('error', handle);
     });
-  } // return a promise that resolves when the server closes
-
+  }
 
+  // return a promise that resolves when the server closes
   close() {
     return new Promise(resolve => {
       _classPrivateFieldGet(this, _sockets).forEach(socket => socket.destroy());
-
       super.close(resolve);
     });
-  } // initial routes include cors and 404 handling
+  }
 
+  // initial routes include cors and 404 handling
 
   // set request routing and handling for pathnames and methods
   route(method, pathname, handle) {
@@ -229,12 +200,11 @@ export class Server extends http.Server {
       match: pathname && pathToMatch(pathname),
       handle
     });
-  } // install a route that serves requested files from the provided directory
-
+  }
 
+  // install a route that serves requested files from the provided directory
   serve(pathname, directory, options) {
     var _options;
-
     if (typeof directory !== 'string') [options, directory] = [directory];
     if (!directory) [pathname, directory] = ['/', pathname];
     let root = path.resolve(directory);
@@ -258,7 +228,6 @@ export class Server extends http.Server {
       handle: async (req, res, next) => {
         try {
           var _options2;
-
           let pathname = rewritePath(req.url.pathname);
           let file = await getFile(root, pathname, (_options2 = options) === null || _options2 === void 0 ? void 0 : _options2.cleanUrls);
           if (!(file !== null && file !== void 0 && file.stats.isFile())) return await next();
@@ -270,28 +239,24 @@ export class Server extends http.Server {
         }
       }
     });
-  } // route and respond to requests; handling errors if necessary
-
+  }
 
-} // create a url rewriter from provided rewrite rules
+  // route and respond to requests; handling errors if necessary
+}
 
+// create a url rewriter from provided rewrite rules
 function _route2(route) {
   let i = _classPrivateFieldGet(this, _routes).findIndex(r => r.priority >= route.priority);
-
   _classPrivateFieldGet(this, _routes).splice(i, 0, route);
-
   return this;
 }
-
 async function _handleRequest2(req, res) {
   // support node < 15.7.0
   res.req ?? (res.req = req);
-
   try {
     // invoke routes like middleware
     await async function cont(routes, i = 0) {
       let next = () => cont(routes, i + 1);
-
       let {
         methods,
         match,
@@ -304,12 +269,12 @@ async function _handleRequest2(req, res) {
     }(_classPrivateFieldGet(this, _routes));
   } catch (error) {
     var _req$headers$accept, _req$headers$content;
-
     let {
       status = 500,
       message
-    } = error; // fallback error handling
+    } = error;
 
+    // fallback error handling
     if ((_req$headers$accept = req.headers.accept) !== null && _req$headers$accept !== void 0 && _req$headers$accept.includes('json') || (_req$headers$content = req.headers['content-type']) !== null && _req$headers$content !== void 0 && _req$headers$content.includes('json')) {
       res.json(status, {
         error: message
@@ -319,10 +284,8 @@ async function _handleRequest2(req, res) {
     }
   }
 }
-
 function createRewriter(rewrites = [], cb) {
   let normalize = p => path.posix.normalize(path.posix.join('/', p));
-
   if (!Array.isArray(rewrites)) rewrites = Object.entries(rewrites);
   let rewrite = [{
     // resolve and normalize the path before rewriting
@@ -337,23 +300,23 @@ function createRewriter(rewrites = [], cb) {
     };
   })).reduceRight((next, rule) => pathname => {
     var _rule$match;
-
     // compose all rewrites into a single function
     let result = ((_rule$match = rule.match) === null || _rule$match === void 0 ? void 0 : _rule$match.call(rule, pathname)) ?? pathname;
     if (result) pathname = rule.apply(result);
     return next(pathname);
-  }, p => p); // allow additional pathname processing around the rewriter
+  }, p => p);
 
+  // allow additional pathname processing around the rewriter
   return p => cb(p, rewrite);
-} // returns true if the pathname is inside the root pathname
-
+}
 
+// returns true if the pathname is inside the root pathname
 function isPathInside(root, pathname) {
   let abs = path.resolve(path.join(root, pathname));
   return !abs.lastIndexOf(root, 0) && (abs[root.length] === path.sep || !abs[root.length]);
-} // get the absolute path and stats of a possible file
-
+}
 
+// get the absolute path and stats of a possible file
 async function getFile(root, pathname, cleanUrls) {
   for (let filename of [pathname].concat(cleanUrls ? path.join(pathname, 'index.html') : [], cleanUrls && pathname.length > 2 ? pathname.replace(/\/?$/, '.html') : [])) {
     let filepath = path.resolve(path.join(root, filename));
@@ -363,11 +326,10 @@ async function getFile(root, pathname, cleanUrls) {
       stats
     };
   }
-} // returns the start and end of a byte range or undefined if unable to parse
-
+}
 
+// returns the start and end of a byte range or undefined if unable to parse
 const RANGE_REGEXP = /^bytes=(\d*)?-(\d*)?(?:\b|$)/;
-
 function parseByteRange(range, size) {
   let [, start, end = size] = (range === null || range === void 0 ? void 0 : range.match(RANGE_REGEXP)) ?? [0, 0, 0];
   start = Math.max(parseInt(start, 10), 0);
@@ -377,9 +339,9 @@ function parseByteRange(range, size) {
     start,
     end
   };
-} // shorthand function for creating a new server with specific options
-
+}
 
+// shorthand function for creating a new server with specific options
 export function createServer(options = {}) {
   let {
     serve,
@@ -391,8 +353,9 @@ export function createServer(options = {}) {
     port
   });
   return serve ? server.serve(baseUrl, serve, opts) : server;
-} // include some exports as static properties
+}
 
+// include some exports as static properties
 Server.Error = ServerError;
 Server.createRewriter = createRewriter;
 Server.createServer = createServer;

package/dist/session.js

@@ -4,13 +4,11 @@ export class Session extends EventEmitter {
   #callbacks = new Map();
   log = logger('core:session');
   children = new Map();
-
   constructor(browser, {
     params,
     sessionId: parentId
   }) {
     var _this$parent;
-
     super();
     this.browser = browser;
     this.sessionId = params.sessionId;
@@ -21,7 +19,6 @@ export class Session extends EventEmitter {
     (_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.children.set(this.sessionId, this);
     this.on('Inspector.targetCrashed', this._handleTargetCrashed);
   }
-
   async close() {
     if (!this.browser || this.closing) return;
     this.closing = true;
@@ -29,20 +26,20 @@ export class Session extends EventEmitter {
       targetId: this.targetId
     }).catch(this._handleClosedError);
   }
-
   async send(method, params) {
     /* istanbul ignore next: race condition paranoia */
     if (this.closedReason) {
       throw new Error(`Protocol error (${method}): ${this.closedReason}`);
-    } // send a raw message to the browser so we can provide a sessionId
-
+    }
 
+    // send a raw message to the browser so we can provide a sessionId
     let id = await this.browser.send({
       sessionId: this.sessionId,
       method,
       params
-    }); // will resolve or reject when a matching response is received
+    });
 
+    // will resolve or reject when a matching response is received
     return new Promise((resolve, reject) => {
       this.#callbacks.set(id, {
         error: new Error(),
@@ -52,14 +49,13 @@ export class Session extends EventEmitter {
       });
     });
   }
-
   _handleMessage(data) {
     if (data.id && this.#callbacks.has(data.id)) {
       // resolve or reject a pending promise created with #send()
       let callback = this.#callbacks.get(data.id);
       this.#callbacks.delete(data.id);
-      /* istanbul ignore next: races with browser._handleMessage() */
 
+      /* istanbul ignore next: races with browser._handleMessage() */
       if (data.error) {
         callback.reject(Object.assign(callback.error, {
           message: `Protocol error (${callback.method}): ${data.error.message}` + ('data' in data.error ? `: ${data.error.data}` : '')
@@ -72,29 +68,26 @@ export class Session extends EventEmitter {
       this.emit(data.method, data.params);
     }
   }
-
   _handleClose() {
     var _this$parent2;
+    this.closedReason || (this.closedReason = 'Session closed.');
 
-    this.closedReason || (this.closedReason = 'Session closed.'); // reject any pending callbacks
-
+    // reject any pending callbacks
     for (let callback of this.#callbacks.values()) {
       callback.reject(Object.assign(callback.error, {
         message: `Protocol error (${callback.method}): ${this.closedReason}`
       }));
     }
-
     this.#callbacks.clear();
     (_this$parent2 = this.parent) === null || _this$parent2 === void 0 ? void 0 : _this$parent2.children.delete(this.sessionId);
     this.browser = null;
   }
-
   _handleTargetCrashed = () => {
     this.closedReason = 'Session crashed!';
     this.close();
   };
-  /* istanbul ignore next: encountered during closing races */
 
+  /* istanbul ignore next: encountered during closing races */
   _handleClosedError = error => {
     if (!(error.message ?? error).endsWith(this.closedReason)) {
       this.log.debug(error, this.meta);