@percy/core 1.0.0-beta.73 → 1.0.0-beta.76

package/dist/api.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPercyServer = createPercyServer;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _logger = _interopRequireDefault(require("@percy/logger"));
+
+var _server = _interopRequireDefault(require("./server"));
+
+var _package = _interopRequireDefault(require("../package.json"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function createPercyServer(percy, port) {
+  return new _server.default({
+    port
+  }) // facilitate logger websocket connections
+  .websocket(ws => _logger.default.connect(ws)) // general middleware
+  .route((req, res, next) => {
+    // treat all request bodies as json
+    if (req.body) try {
+      req.body = JSON.parse(req.body);
+    } catch {} // add version header
+
+    res.setHeader('Access-Control-Expose-Headers', '*, X-Percy-Core-Version');
+    res.setHeader('X-Percy-Core-Version', _package.default.version); // return json errors
+
+    return next().catch(e => {
+      var _e$status;
+
+      return res.json((_e$status = e.status) !== null && _e$status !== void 0 ? _e$status : 500, {
+        error: e.message,
+        success: false
+      });
+    });
+  }) // healthcheck returns basic information
+  .route('get', '/percy/healthcheck', (req, res) => res.json(200, {
+    loglevel: percy.loglevel(),
+    config: percy.config,
+    build: percy.build,
+    success: true
+  })) // get or set config options
+  .route(['get', 'post'], '/percy/config', async (req, res) => res.json(200, {
+    config: req.body ? await percy.setConfig(req.body) : percy.config,
+    success: true
+  })) // responds once idle (may take a long time)
+  .route('get', '/percy/idle', async (req, res) => res.json(200, {
+    success: await percy.idle().then(() => true)
+  })) // convenient @percy/dom bundle
+  .route('get', '/percy/dom.js', (req, res) => {
+    return res.file(200, require.resolve('@percy/dom'));
+  }) // legacy agent wrapper for @percy/dom
+  .route('get', '/percy-agent.js', async (req, res) => {
+    (0, _logger.default)('core:server').deprecated(['It looks like you’re using @percy/cli with an older SDK.', 'Please upgrade to the latest version to fix this warning.', 'See these docs for more info: https:docs.percy.io/docs/migrating-to-percy-cli'].join(' '));
+    let content = await _fs.default.promises.readFile(require.resolve('@percy/dom'), 'utf-8');
+    let wrapper = '(window.PercyAgent = class { snapshot(n, o) { return PercyDOM.serialize(o); } });';
+    return res.send(200, 'applicaton/javascript', content.concat(wrapper));
+  }) // post one or more snapshots
+  .route('post', '/percy/snapshot', async (req, res) => {
+    let snapshot = percy.snapshot(req.body);
+    if (!req.url.searchParams.has('async')) await snapshot;
+    return res.json(200, {
+      success: true
+    });
+  }) // stops percy at the end of the current event loop
+  .route('/percy/stop', (req, res) => {
+    setImmediate(() => percy.stop());
+    return res.json(200, {
+      success: true
+    });
+  });
+}

package/dist/percy.js

@@ -17,7 +17,7 @@ var _queue = _interopRequireDefault(require("./queue"));
 
 var _browser = _interopRequireDefault(require("./browser"));
 
-var _server = _interopRequireDefault(require("./server"));
+var _api = require("./api");
 
 var _snapshot = require("./snapshot");
 
@@ -139,7 +139,7 @@ class Percy {
         } // start the server after everything else is ready
 
 
-        yield (_this$server = this.server) === null || _this$server === void 0 ? void 0 : _this$server.listen(this.port); // mark instance as started
+        yield (_this$server = this.server) === null || _this$server === void 0 ? void 0 : _this$server.listen(); // mark instance as started
 
         this.log.info('Percy has started!');
         this.readyState = 1;
@@ -275,8 +275,7 @@ class Percy {
     });
 
     if (server) {
-      this.server = (0, _server.default)(this);
-      this.port = port;
+      this.server = (0, _api.createPercyServer)(this, port);
     }
   } // Shortcut for controlling the global logger's log level.
 
@@ -287,7 +286,9 @@ class Percy {
 
 
   address() {
-    return `http://localhost:${this.port}`;
+    var _this$server4;
+
+    return (_this$server4 = this.server) === null || _this$server4 === void 0 ? void 0 : _this$server4.address();
   } // Set client & environment info, and override loaded config options
 
 
@@ -403,7 +404,7 @@ class Percy {
       } catch (error) {
         var _error$response, _failed$detail;
 
-        let failed = ((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.status) === 422 && error.response.body.errors.find(e => {
+        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';

package/dist/server.js

@@ -3,193 +3,469 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createPercyServer = createPercyServer;
-exports.createServer = createServer;
-exports.default = void 0;
+exports.default = exports.ServerResponse = exports.ServerError = exports.Server = exports.IncomingMessage = void 0;
 
 var _fs = _interopRequireDefault(require("fs"));
 
+var _path = _interopRequireDefault(require("path"));
+
 var _http = _interopRequireDefault(require("http"));
 
-var _ws = require("ws");
+var _ws = _interopRequireDefault(require("ws"));
+
+var _mimeTypes = _interopRequireDefault(require("mime-types"));
 
-var _logger = _interopRequireDefault(require("@percy/logger"));
+var _contentDisposition = _interopRequireDefault(require("content-disposition"));
 
-var _package = _interopRequireDefault(require("../package.json"));
+var _pathToRegexp = require("path-to-regexp");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-async function getReply({
-  version,
-  routes
-}, request, response) {
-  var _headers$ContentType, _body$length, _body;
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
 
-  let [url] = request.url.split('?');
-  let route = routes[url] || routes.default;
-  let reply; // cors preflight
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
 
-  if (request.method === 'OPTIONS') {
-    reply = [204, {}];
-    reply[1]['Access-Control-Allow-Methods'] = 'GET,POST,OPTIONS';
-    reply[1]['Access-Control-Request-Headers'] = 'Vary';
-    let allowed = request.headers['access-control-request-headers'];
-    if (allowed !== null && allowed !== void 0 && allowed.length) reply[1]['Access-Control-Allow-Headers'] = allowed;
-  } else {
-    reply = await Promise.resolve().then(() => {
-      var _routes$middleware;
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
 
-      return (_routes$middleware = routes.middleware) === null || _routes$middleware === void 0 ? void 0 : _routes$middleware.call(routes, request, response);
-    }).then(() => route === null || route === void 0 ? void 0 : route(request, response)).catch(routes.catch);
-  } // response was handled
+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; }
 
-  if (response.headersSent) return []; // default 404 when reply is not an array
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 
-  let [status, headers, body] = Array.isArray(reply) ? reply : [404, {}]; // support content-type header shortcut
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
 
-  if (typeof headers === 'string') headers = {
-    'Content-Type': headers
-  }; // auto stringify json
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
 
-  if ((_headers$ContentType = headers['Content-Type']) !== null && _headers$ContentType !== void 0 && _headers$ContentType.includes('json')) body = JSON.stringify(body); // add additional headers
+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; } }
 
-  headers['Content-Length'] = (_body$length = (_body = body) === null || _body === void 0 ? void 0 : _body.length) !== null && _body$length !== void 0 ? _body$length : 0; // cors headers
+// 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
+class IncomingMessage extends _http.default.IncomingMessage {
+  constructor(socket) {
+    let buffer = [];
+    super(socket).on('data', d => buffer.push(d)).on('end', () => {
+      var _this$headers$content;
 
-  headers['Access-Control-Expose-Headers'] = 'X-Percy-Core-Version';
-  headers['Access-Control-Allow-Origin'] = '*'; // version header
+      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);
+        } catch {}
+      }
+    });
+  }
+
+} // custom server response adds additional convenience methods
 
-  headers['X-Percy-Core-Version'] = version;
-  return [status, headers, body];
-}
 
-function createServer(routes) {
-  let context = {
-    version: _package.default.version,
+exports.IncomingMessage = IncomingMessage;
 
-    get listening() {
-      return context.server.listening;
+class ServerResponse extends _http.default.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
+  send(status, headers, body) {
+    if (typeof headers === 'string') {
+      this.setHeader('Content-Type', headers);
+      headers = null;
     }
 
-  }; // create a simple server to route request responses
+    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
+
+
+  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
+
+
+  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
 
-  context.routes = routes;
-  context.server = _http.default.createServer((request, response) => {
-    request.params = new URLSearchParams(request.url.split('?')[1]);
-    request.on('data', chunk => {
-      request.body = (request.body || '') + chunk;
+
+  file(status, filepath) {
+    if (arguments.length < 2) [status, filepath] = [200, status];
+    filepath = _path.default.resolve(filepath);
+
+    let {
+      size
+    } = _fs.default.lstatSync(filepath);
+
+    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': _mimeTypes.default.contentType(_path.default.extname(filepath)),
+      'Content-Length': range ? range.end - range.start + 1 : size,
+      'Content-Disposition': (0, _contentDisposition.default)(filepath, {
+        type: 'inline'
+      })
     });
-    request.on('end', async () => {
-      try {
-        request.body = JSON.parse(request.body);
-      } catch (e) {}
 
-      let [status, headers, body] = await getReply(context, request, response);
-      if (!response.headersSent) response.writeHead(status, headers).end(body);
+    _fs.default.createReadStream(filepath, range).pipe(this);
+
+    return this;
+  }
+
+} // custom server error with a status and default reason
+
+
+exports.ServerResponse = ServerResponse;
+
+class ServerError extends Error {
+  static throw(status, reason) {
+    throw new this(status, reason);
+  }
+
+  constructor(status = 500, reason) {
+    super(reason || _http.default.STATUS_CODES[status]);
+    this.status = status;
+  }
+
+} // custom server class handles routing requests and provides alternate methods and properties
+
+
+exports.ServerError = ServerError;
+
+var _sockets = /*#__PURE__*/new WeakMap();
+
+var _defaultPort = /*#__PURE__*/new WeakMap();
+
+var _up = /*#__PURE__*/new WeakMap();
+
+var _handleUpgrade = /*#__PURE__*/new WeakSet();
+
+var _routes = /*#__PURE__*/new WeakMap();
+
+var _route = /*#__PURE__*/new WeakSet();
+
+var _handleRequest = /*#__PURE__*/new WeakSet();
+
+class Server extends _http.default.Server {
+  constructor({
+    port
+  } = {}) {
+    super({
+      IncomingMessage,
+      ServerResponse
     });
-  }); // track connections
 
-  context.sockets = new Set();
-  context.server.on('connection', s => {
-    context.sockets.add(s.on('close', () => context.sockets.delete(s)));
-  }); // immediately kill connections on close
+    _classPrivateMethodInitSpec(this, _handleRequest);
 
-  context.close = () => new Promise(resolve => {
-    context.sockets.forEach(s => s.destroy());
-    context.server.close(resolve);
-  }); // starts the server
+    _classPrivateMethodInitSpec(this, _route);
 
+    _classPrivateMethodInitSpec(this, _handleUpgrade);
 
-  context.listen = port => new Promise((resolve, reject) => {
-    context.server.on('listening', () => resolve(context));
-    context.server.on('error', reject);
-    context.server.listen(port);
-  }); // add routes programatically
+    _classPrivateFieldInitSpec(this, _sockets, {
+      writable: true,
+      value: new Set()
+    });
 
+    _classPrivateFieldInitSpec(this, _defaultPort, {
+      writable: true,
+      value: void 0
+    });
 
-  context.reply = (url, handler) => {
-    routes[url] = handler;
-    return context;
-  };
+    _classPrivateFieldInitSpec(this, _up, {
+      writable: true,
+      value: []
+    });
+
+    _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(', ');
+            res.setHeader('Access-Control-Allow-Headers', allowHeaders);
+            res.setHeader('Access-Control-Allow-Methods', allowMethods);
+            res.writeHead(204).end();
+          } else {
+            res.setHeader('Access-Control-Expose-Headers', '*');
+            return next();
+          }
+        }
+      }, {
+        priority: 3,
+        handle: req => ServerError.throw(404)
+      }]
+    });
+
+    _classPrivateFieldSet(this, _defaultPort, port); // handle requests on end
+
+
+    this.on('request', (req, res) => {
+      req.on('end', () => _classPrivateMethodGet(this, _handleRequest, _handleRequest2).call(this, req, res));
+    }); // handle websocket upgrades
+
+    this.on('upgrade', (req, sock, head) => {
+      _classPrivateMethodGet(this, _handleUpgrade, _handleUpgrade2).call(this, req, sock, head);
+    }); // track open connections to terminate when the server closes
+
+    this.on('connection', socket => {
+      let handleClose = () => _classPrivateFieldGet(this, _sockets).delete(socket);
 
-  return context;
+      _classPrivateFieldGet(this, _sockets).add(socket.on('close', handleClose));
+    });
+  } // return the listening port or any default port
+
+
+  get port() {
+    var _super$address$port, _super$address;
+
+    return (_super$address$port = (_super$address = super.address()) === null || _super$address === void 0 ? void 0 : _super$address.port) !== null && _super$address$port !== void 0 ? _super$address$port : _classPrivateFieldGet(this, _defaultPort);
+  } // 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
+
+
+  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
+
+
+  close() {
+    return new Promise(resolve => {
+      _classPrivateFieldGet(this, _sockets).forEach(socket => socket.destroy());
+
+      super.close(resolve);
+    });
+  } // handle websocket upgrades
+
+
+  websocket(pathname, handle) {
+    if (!handle) [pathname, handle] = [null, pathname];
+
+    _classPrivateFieldGet(this, _up).push({
+      match: pathname && (0, _pathToRegexp.match)(pathname),
+      handle: (req, sock, head) => new Promise(resolve => {
+        let wss = new _ws.default.Server({
+          noServer: true,
+          clientTracking: false
+        });
+        wss.handleUpgrade(req, sock, head, resolve);
+      }).then(ws => handle(ws, req))
+    });
+
+    if (pathname) {
+      _classPrivateFieldGet(this, _up).sort((a, b) => (a.match ? -1 : 1) - (b.match ? -1 : 1));
+    }
+
+    return this;
+  }
+
+  // set request routing and handling for pathnames and methods
+  route(method, pathname, handle) {
+    if (arguments.length === 1) [handle, method] = [method];
+    if (arguments.length === 2) [handle, pathname] = [pathname];
+    if (arguments.length === 2 && !Array.isArray(method) && method[0] === '/') [pathname, method] = [method];
+    return _classPrivateMethodGet(this, _route, _route2).call(this, {
+      priority: !pathname ? 0 : !method ? 1 : 2,
+      methods: method && [].concat(method).map(m => m.toUpperCase()),
+      match: pathname && (0, _pathToRegexp.match)(pathname),
+      handle
+    });
+  } // 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.default.resolve(directory);
+
+    let mountPattern = (0, _pathToRegexp.pathToRegexp)(pathname, null, {
+      end: false
+    });
+    let rewritePath = createRewriter((_options = options) === null || _options === void 0 ? void 0 : _options.rewrites, (pathname, rewrite) => {
+      try {
+        let filepath = decodeURIComponent(pathname.replace(mountPattern, ''));
+        if (!isPathInside(root, filepath)) ServerError.throw();
+        return rewrite(filepath);
+      } catch {
+        throw new ServerError(400);
+      }
+    });
+    return _classPrivateMethodGet(this, _route, _route2).call(this, {
+      priority: 2,
+      methods: ['GET'],
+      match: pathname => mountPattern.test(pathname),
+      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();
+          return res.file(file.path);
+        } catch (err) {
+          let statusPage = _path.default.join(root, `${err.status}.html`);
+
+          if (!_fs.default.existsSync(statusPage)) throw err;
+          return res.file(err.status, statusPage);
+        }
+      }
+    });
+  } // route and respond to requests; handling errors if necessary
+
+
+} // create a url rewriter from provided rewrite rules
+
+
+exports.Server = Server;
+
+function _handleUpgrade2(req, sock, head) {
+  let up = _classPrivateFieldGet(this, _up).find(u => !u.match || u.match(req.url));
+
+  if (up) return up.handle(req, sock, head);
+  sock.write(`HTTP/1.1 400 ${_http.default.STATUS_CODES[400]}\r\n` + 'Connection: close\r\n\r\n');
+  sock.destroy();
+}
+
+function _route2(route) {
+  let i = _classPrivateFieldGet(this, _routes).findIndex(r => r.priority >= route.priority);
+
+  _classPrivateFieldGet(this, _routes).splice(i, 0, route);
+
+  return this;
 }
 
-function createPercyServer(percy) {
-  let log = (0, _logger.default)('core:server');
-  let context = createServer({
-    // healthcheck returns meta info on success
-    '/percy/healthcheck': () => [200, 'application/json', {
-      success: true,
-      config: percy.config,
-      loglevel: percy.loglevel(),
-      build: percy.build
-    }],
-    // remotely get and set percy config options
-    '/percy/config': ({
-      body
-    }) => [200, 'application/json', {
-      config: body ? percy.setConfig(body) : percy.config,
-      success: true
-    }],
-    // responds when idle
-    '/percy/idle': () => percy.idle().then(() => [200, 'application/json', {
-      success: true
-    }]),
-    // serves @percy/dom as a convenience
-    '/percy/dom.js': () => _fs.default.promises.readFile(require.resolve('@percy/dom'), 'utf-8').then(content => [200, 'applicaton/javascript', content]),
-    // serves the new DOM library, wrapped for compatability to `@percy/agent`
-    '/percy-agent.js': () => _fs.default.promises.readFile(require.resolve('@percy/dom'), 'utf-8').then(content => {
-      let wrapper = '(window.PercyAgent = class PercyAgent { snapshot(n, o) { return PercyDOM.serialize(o); } });';
-      log.deprecated('It looks like you’re using @percy/cli with an older SDK. Please upgrade to the latest version' + ' to fix this warning. See these docs for more info: https://docs.percy.io/docs/migrating-to-percy-cli');
-      return [200, 'applicaton/javascript', content.concat(wrapper)];
-    }),
-    // forward snapshot requests
-    '/percy/snapshot': async ({
-      body,
-      params
-    }) => {
-      let snapshot = percy.snapshot(body);
-      if (!params.has('async')) await snapshot;
-      return [200, 'application/json', {
-        success: true
-      }];
-    },
-    // stops the instance async at the end of the event loop
-    '/percy/stop': () => {
-      setImmediate(async () => await percy.stop());
-      return [200, 'application/json', {
-        success: true
-      }];
-    },
-    // other routes 404
-    default: () => [404, 'application/json', {
-      error: 'Not found',
-      success: false
-    }],
-    // generic error handler
-    catch: ({
+async function _handleRequest2(req, res) {
+  var _res$req;
+
+  // support node < 15.7.0
+  (_res$req = res.req) !== null && _res$req !== void 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,
+        handle
+      } = routes[i];
+      let result = !methods || methods.includes(req.method);
+      result && (result = !match || match(req.url.pathname));
+      if (result) req.params = result.params;
+      return result ? handle(req, res, next) : next();
+    }(_classPrivateFieldGet(this, _routes));
+  } catch (error) {
+    var _req$headers$accept, _req$headers$content;
+
+    let {
+      status = 500,
       message
-    }) => [500, 'application/json', {
-      error: message,
-      success: false
-    }]
-  }); // start a websocket server
-
-  context.wss = new _ws.Server({
-    noServer: true
-  }); // manually handle upgrades to avoid wss handling all events
-
-  context.server.on('upgrade', (req, sock, head) => {
-    context.wss.handleUpgrade(req, sock, head, socket => {
-      // allow remote logging connections
-      let disconnect = _logger.default.connect(socket);
-
-      socket.once('close', () => disconnect());
-    });
-  });
-  return context;
+    } = 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
+      });
+    } else {
+      res.text(status, message);
+    }
+  }
 }
 
-var _default = createPercyServer;
+function createRewriter(rewrites = [], cb) {
+  let normalize = p => _path.default.posix.normalize(_path.default.posix.join('/', p));
+
+  if (!Array.isArray(rewrites)) rewrites = Object.entries(rewrites);
+  let rewrite = [{
+    // resolve and normalize the path before rewriting
+    apply: p => _path.default.posix.resolve(normalize(p))
+  }].concat(rewrites.map(([src, dest]) => {
+    // compile rewrite rules into functions
+    let match = (0, _pathToRegexp.match)(normalize(src));
+    let toPath = (0, _pathToRegexp.compile)(normalize(dest));
+    return {
+      match,
+      apply: r => toPath(r.params)
+    };
+  })).reduceRight((next, rule) => pathname => {
+    var _rule$match, _rule$match2;
+
+    // compose all rewrites into a single function
+    let result = (_rule$match = (_rule$match2 = rule.match) === null || _rule$match2 === void 0 ? void 0 : _rule$match2.call(rule, pathname)) !== null && _rule$match !== void 0 ? _rule$match : pathname;
+    if (result) pathname = rule.apply(result);
+    return next(pathname);
+  }, p => p); // allow additional pathname processing around the rewriter
+
+  return p => cb(p, rewrite);
+} // returns true if the pathname is inside the root pathname
+
+
+function isPathInside(root, pathname) {
+  let abs = _path.default.resolve(_path.default.join(root, pathname));
+
+  return !abs.lastIndexOf(root, 0) && (abs[root.length] === _path.default.sep || !abs[root.length]);
+} // get the absolute path and stats of a possible file
+
+
+async function getFile(root, pathname, cleanUrls) {
+  for (let filename of [pathname].concat(cleanUrls ? _path.default.join(pathname, 'index.html') : [], cleanUrls && pathname.length > 2 ? pathname.replace(/\/?$/, '.html') : [])) {
+    let filepath = _path.default.resolve(_path.default.join(root, filename));
+
+    let stats = await _fs.default.promises.lstat(filepath).catch(() => {});
+    if (stats !== null && stats !== void 0 && stats.isFile()) return {
+      path: filepath,
+      stats
+    };
+  }
+} // 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) {
+  var _range$match;
+
+  let [, start, end = size] = (_range$match = range === null || range === void 0 ? void 0 : range.match(RANGE_REGEXP)) !== null && _range$match !== void 0 ? _range$match : [0, 0, 0];
+  start = Math.max(parseInt(start, 10), 0);
+  end = Math.min(parseInt(end, 10), size - 1);
+  if (isNaN(start)) [start, end] = [size - end, size - 1];
+  if (start >= 0 && start < end) return {
+    start,
+    end
+  };
+} // include ServerError and createRewriter as static properties
+
+
+Server.Error = ServerError;
+Server.createRewriter = createRewriter;
+var _default = Server;
 exports.default = _default;

package/dist/utils.js

@@ -155,14 +155,16 @@ function waitFor(predicate, options) {
     timeout: options
   } : options || {};
   return generatePromise(async function* check(start, done) {
-    if (timeout && Date.now() - start >= timeout) {
-      throw new Error(`Timeout of ${timeout}ms exceeded.`);
-    } else if (!predicate()) {
-      yield new Promise(r => setTimeout(r, poll));
-      return yield* check(start);
-    } else if (idle && !done) {
-      yield new Promise(r => setTimeout(r, idle));
-      return yield* check(start, true);
+    while (true) {
+      if (timeout && Date.now() - start >= timeout) {
+        throw new Error(`Timeout of ${timeout}ms exceeded.`);
+      } else if (!predicate()) {
+        yield new Promise(r => setTimeout(r, poll, done = false));
+      } else if (idle && !done) {
+        yield new Promise(r => setTimeout(r, idle, done = true));
+      } else {
+        return;
+      }
     }
   }(Date.now()));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/core",
-  "version": "1.0.0-beta.73",
+  "version": "1.0.0-beta.76",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -30,14 +30,17 @@
     "test:types": "tsd"
   },
   "dependencies": {
-    "@percy/client": "1.0.0-beta.73",
-    "@percy/config": "1.0.0-beta.73",
-    "@percy/dom": "1.0.0-beta.73",
-    "@percy/logger": "1.0.0-beta.73",
+    "@percy/client": "1.0.0-beta.76",
+    "@percy/config": "1.0.0-beta.76",
+    "@percy/dom": "1.0.0-beta.76",
+    "@percy/logger": "1.0.0-beta.76",
+    "content-disposition": "^0.5.4",
     "cross-spawn": "^7.0.3",
     "extract-zip": "^2.0.1",
+    "mime-types": "^2.1.34",
+    "path-to-regexp": "^6.2.0",
     "rimraf": "^3.0.2",
     "ws": "^8.0.0"
   },
-  "gitHead": "aa8160e02bea3e04ab1d3605762f89fbe79605d4"
+  "gitHead": "445af68d8e270e2a35fc74e26422ed5d3c91d2ae"
 }

package/test/helpers/server.js

@@ -1,20 +1,33 @@
 // aliased to src for coverage during tests without needing to compile this file
-const { createServer } = require('@percy/core/dist/server');
+const { default: Server } = require('@percy/core/dist/server');
 
-function createTestServer(routes, port = 8000) {
-  let context = createServer(routes);
+function createTestServer({ default: defaultReply, ...replies }, port = 8000) {
+  let server = new Server();
 
-  // handle route errors
-  context.routes.catch = ({ message }) => [500, 'text/plain', message];
-
-  // track requests
-  context.requests = [];
-  context.routes.middleware = ({ url, body }) => {
-    context.requests.push(body ? [url, body] : [url]);
+  // alternate route handling
+  let handleReply = reply => async (req, res) => {
+    let [status, headers, body] = typeof reply === 'function' ? await reply(req) : reply;
+    if (!Buffer.isBuffer(body) && typeof body !== 'string') body = JSON.stringify(body);
+    return res.send(status, headers, body);
   };
 
+  // map replies to alternate route handlers
+  server.reply = (p, reply) => (replies[p] = handleReply(reply));
+  for (let [p, reply] of Object.entries(replies)) server.reply(p, reply);
+  if (defaultReply) defaultReply = handleReply(defaultReply);
+
+  // track requests and route replies
+  server.requests = [];
+  server.route(async (req, res, next) => {
+    let pathname = req.url.pathname;
+    if (req.url.search) pathname += req.url.search;
+    server.requests.push(req.body ? [pathname, req.body] : [pathname]);
+    let reply = replies[req.url.pathname] || defaultReply;
+    return reply ? await reply(req, res) : next();
+  });
+
   // automatically listen
-  return context.listen(port);
+  return server.listen(port);
 };
 
 // support commonjs environments