@percy/sdk-utils 1.0.0 → 1.0.3

package/dist/percy-enabled.js

@@ -0,0 +1,55 @@
+import logger from '@percy/logger';
+import percy from './percy-info.js';
+import request from './request.js'; // Create a socket to connect to a remote logger
+
+async function connectRemoteLogger() {
+  await logger.remote(async () => {
+    let url = percy.address.replace('http', 'ws');
+
+    if (process.env.__PERCY_BROWSERIFIED__) {
+      return new window.WebSocket(url);
+    } else {
+      /* eslint-disable-next-line import/no-extraneous-dependencies */
+      let {
+        default: WebSocket
+      } = await import('ws');
+      let ws = new WebSocket(url); // allow node to exit with an active connection
+
+      return ws.once('open', () => ws._socket.unref());
+    }
+  });
+} // Check if Percy is enabled using the healthcheck endpoint
+
+
+export async function isPercyEnabled() {
+  if (percy.enabled == null) {
+    let log = logger('utils');
+    let error;
+
+    try {
+      let response = await request('/percy/healthcheck');
+      percy.version = response.headers['x-percy-core-version'];
+      percy.config = response.body.config;
+      percy.enabled = true;
+    } catch (e) {
+      percy.enabled = false;
+      error = e;
+    }
+
+    if (percy.enabled && percy.version.major !== 1) {
+      log.info('Unsupported Percy CLI version, disabling snapshots');
+      log.debug(`Found version: ${percy.version}`);
+      percy.enabled = false;
+    } else if (!percy.enabled) {
+      log.info('Percy is not running, disabling snapshots');
+      log.debug(error);
+    }
+
+    if (percy.enabled) {
+      await connectRemoteLogger();
+    }
+  }
+
+  return percy.enabled;
+}
+export default isPercyEnabled;

package/dist/percy-idle.js

@@ -0,0 +1,10 @@
+import request from './request.js';
+const RETRY_ERROR_CODES = ['ECONNRESET', 'ETIMEDOUT'];
+export async function waitForPercyIdle() {
+  try {
+    return !!(await request('/percy/idle'));
+  } catch (e) {
+    return RETRY_ERROR_CODES.includes(e.code) && waitForPercyIdle();
+  }
+}
+export default waitForPercyIdle;

package/dist/percy-info.js

@@ -0,0 +1,59 @@
+// helper to create a version object from a string
+function toVersion(str) {
+  str || (str = '0.0.0');
+  return str.split(/\.|-/).reduce((version, part, i) => {
+    let v = parseInt(part, 10);
+    version[i] = isNaN(v) ? part : v;
+    return version;
+  }, {
+    get major() {
+      return this[0] || 0;
+    },
+
+    get minor() {
+      return this[1] || 0;
+    },
+
+    get patch() {
+      return this[2] || 0;
+    },
+
+    get prerelease() {
+      return this[3];
+    },
+
+    get build() {
+      return this[4];
+    },
+
+    toString() {
+      return str;
+    }
+
+  });
+} // private version cache
+
+
+let version = toVersion(); // contains local percy info
+
+const info = {
+  // get or set the CLI API address via the environment
+  get address() {
+    return process.env.PERCY_SERVER_ADDRESS || 'http://localhost:5338';
+  },
+
+  set address(addr) {
+    return process.env.PERCY_SERVER_ADDRESS = addr;
+  },
+
+  // version information
+  get version() {
+    return version;
+  },
+
+  set version(v) {
+    return version = toVersion(v);
+  }
+
+};
+export default info;

package/dist/post-snapshot.js

@@ -0,0 +1,17 @@
+import percy from './percy-info.js';
+import request from './request.js'; // Post snapshot data to the snapshot endpoint. If the snapshot endpoint responds with a closed
+// error message, signal that Percy has been disabled.
+
+export async function postSnapshot(options, params) {
+  let query = params ? `?${new URLSearchParams(params)}` : '';
+  await request.post(`/percy/snapshot${query}`, options).catch(err => {
+    var _err$response, _err$response$body, _err$response$body$bu;
+
+    if ((_err$response = err.response) !== null && _err$response !== void 0 && (_err$response$body = _err$response.body) !== null && _err$response$body !== void 0 && (_err$response$body$bu = _err$response$body.build) !== null && _err$response$body$bu !== void 0 && _err$response$body$bu.error) {
+      percy.enabled = false;
+    } else {
+      throw err;
+    }
+  });
+}
+export default postSnapshot;

package/dist/request.js

@@ -0,0 +1,65 @@
+import percy from './percy-info.js'; // Helper to send a request to the local CLI API
+
+export async function request(path, options = {}) {
+  let response = await request.fetch(`${percy.address}${path}`, options); // maybe parse response body as json
+
+  if (typeof response.body === 'string' && response.headers['content-type'] === 'application/json') {
+    try {
+      response.body = JSON.parse(response.body);
+    } catch (e) {}
+  } // throw an error if status is not ok
+
+
+  if (!(response.status >= 200 && response.status < 300)) {
+    throw Object.assign(new Error(), {
+      message: response.body.error || `${response.status} ${response.statusText}`,
+      response
+    });
+  }
+
+  return response;
+}
+
+request.post = function post(url, json) {
+  return request(url, {
+    method: 'POST',
+    body: JSON.stringify(json)
+  });
+}; // environment specific implementation
+
+
+if (process.env.__PERCY_BROWSERIFIED__) {
+  // use window.fetch in browsers
+  const winFetch = window.fetch;
+
+  request.fetch = async function fetch(url, options) {
+    let response = await winFetch(url, options);
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+      body: await response.text()
+    };
+  };
+} else {
+  // use http.request in node
+  request.fetch = async function fetch(url, options) {
+    let {
+      default: http
+    } = await import('http');
+    return new Promise((resolve, reject) => {
+      http.request(url, options).on('response', response => {
+        let body = '';
+        response.on('data', chunk => body += chunk.toString());
+        response.on('end', () => resolve({
+          status: response.statusCode,
+          statusText: response.statusMessage,
+          headers: response.headers,
+          body
+        }));
+      }).on('error', reject).end(options.body);
+    });
+  };
+}
+
+export default request;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/sdk-utils",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -14,10 +14,10 @@
     "node": ">=14"
   },
   "files": [
-    "./dist",
-    "./test/server.js",
-    "./test/client.js",
-    "./test/helpers.js"
+    "dist",
+    "test/server.js",
+    "test/client.js",
+    "test/helpers.js"
   ],
   "main": "./dist/index.js",
   "browser": "./dist/bundle.js",
@@ -58,7 +58,7 @@
     }
   },
   "dependencies": {
-    "@percy/logger": "1.0.0"
+    "@percy/logger": "1.0.3"
   },
-  "gitHead": "6df509421a60144e4f9f5d59dc57a5675372a0b2"
+  "gitHead": "a259d5cff0933711bced21a979c577e70765d318"
 }

package/test/client.js

@@ -0,0 +1,278 @@
+(function() {
+  this["null"] = this["null"] || {};
+  this.PercySDKUtils.TestHelpers = (function (logger, utils) {
+    'use strict';
+
+    const process = (typeof globalThis !== "undefined" && globalThis.process) || {};
+    process.env = process.env || {};
+    process.env.__PERCY_BROWSERIFIED__ = true;
+
+    globalThis.process = globalThis.process || process;
+
+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+    var logger__default = /*#__PURE__*/_interopDefaultLegacy(logger);
+    var utils__default = /*#__PURE__*/_interopDefaultLegacy(utils);
+
+    const {
+      assign,
+      entries
+    } = Object; // matches ansi escape sequences
+
+    const ANSI_REG = new RegExp('[\\u001B\\u009B][[\\]()#;?]*((?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)' + '|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))', 'g'); // color names by ansi escape code
+
+    const ANSI_COLORS = {
+      '91m': 'red',
+      '32m': 'green',
+      '93m': 'yellow',
+      '34m': 'blue',
+      '95m': 'magenta',
+      '90m': 'grey'
+    }; // colorize each line of a string using an ansi escape sequence
+
+    const LINE_REG = /^.*$/gm;
+
+    function colorize(code, str) {
+      return str.replace(LINE_REG, line => `\u001b[${code}${line}\u001b[39m`);
+    } // map ansi colors to bound colorize functions
+
+
+    entries(ANSI_COLORS).reduce((colors, _ref) => {
+      let [code, name] = _ref;
+      return assign(colors, {
+        [name]: colorize.bind(null, code)
+      });
+    }, {});
+
+    const ELAPSED_REG = /\s\S*?\(\d+ms\)\S*/;
+    const NEWLINE_REG = /\r\n/g;
+    const LASTLINE_REG = /\n$/;
+
+    function sanitizeLog(str) {
+      let {
+        ansi,
+        elapsed
+      } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      // normalize line endings
+      str = str.replace(NEWLINE_REG, '\n'); // strip ansi colors
+
+      if (!ansi) str = str.replace(ANSI_REG, ''); // strip elapsed time
+
+      if (!elapsed) str = str.replace(ELAPSED_REG, ''); // strip trailing line endings
+
+      return str.replace(LASTLINE_REG, '');
+    }
+
+    function spy(object, method, func) {
+      if (object[method].restore) object[method].restore();
+      let spy = Object.assign(function spy() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        spy.calls.push(args);
+        if (func) return func.apply(this, args);
+      }, {
+        restore: () => object[method] = spy.originalValue,
+        reset: () => (spy.calls.length = 0) || spy,
+        originalValue: object[method],
+        calls: []
+      });
+      object[method] = spy;
+      return spy;
+    }
+
+    const {
+      Logger,
+      loglevel
+    } = logger__default["default"];
+    const helpers$1 = {
+      stdout: [],
+      stderr: [],
+      loglevel,
+
+      async mock() {
+        let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        helpers$1.reset();
+
+        if (process.env.__PERCY_BROWSERIFIED__) {
+          spy(Logger.prototype, 'write', function (lvl, msg) {
+            let stdio = lvl === 'info' ? 'stdout' : 'stderr';
+            helpers$1[stdio].push(sanitizeLog(msg, options));
+            return this.write.originalValue.call(this, lvl, msg);
+          });
+          spy(console, 'log');
+          spy(console, 'warn');
+          spy(console, 'error');
+        } else {
+          let {
+            Writable
+          } = await import('stream');
+
+          for (let stdio of ['stdout', 'stderr']) {
+            Logger[stdio] = Object.assign(new Writable(), {
+              columns: options.isTTY ? 100 : null,
+              isTTY: options.isTTY,
+
+              cursorTo() {},
+
+              clearLine() {},
+
+              _write(chunk, encoding, callback) {
+                helpers$1[stdio].push(sanitizeLog(chunk.toString(), options));
+                callback();
+              }
+
+            });
+          }
+        }
+      },
+
+      reset(soft) {
+        if (soft) loglevel('info');else delete Logger.instance;
+        helpers$1.stdout.length = 0;
+        helpers$1.stderr.length = 0;
+
+        if (console.log.reset) {
+          console.log.reset();
+          console.warn.reset();
+          console.error.reset();
+        }
+      },
+
+      dump() {
+        let msgs = Array.from(Logger.instance && Logger.instance.messages || []);
+        if (!msgs.length) return;
+
+        let log = m => process.env.__PERCY_BROWSERIFIED__ ? console.log.and ? console.log.and.originalFn(m) : console.log(m) : process.stderr.write(`${m}\n`);
+
+        logger__default["default"].loglevel('debug');
+        log(logger__default["default"].format('testing', 'warn', '--- DUMPING LOGS ---'));
+        msgs.reduce((last, _ref) => {
+          let {
+            debug,
+            level,
+            message,
+            timestamp
+          } = _ref;
+          log(logger__default["default"].format(debug, level, message, timestamp - last));
+          return timestamp;
+        }, msgs[0].timestamp);
+      }
+
+    };
+
+    const helpers = {
+      logger: helpers$1,
+
+      async setup() {
+        utils__default["default"].percy.version = '';
+        delete utils__default["default"].percy.config;
+        delete utils__default["default"].percy.enabled;
+        delete utils__default["default"].percy.domScript;
+        delete process.env.PERCY_SERVER_ADDRESS;
+        await helpers.call('server.mock');
+        await helpers$1.mock();
+      },
+
+      teardown: () => helpers.call('server.close'),
+      getRequests: () => helpers.call('server.requests'),
+      testReply: (path, reply) => helpers.call('server.reply', path, reply),
+      testFailure: function () {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        return helpers.call('server.test.failure', ...args);
+      },
+      testError: path => helpers.call('server.test.error', path),
+      testSerialize: fn => !fn ? helpers.call('server.test.serialize') // get
+      : helpers.call('server.test.serialize', fn),
+      // set
+      mockSite: () => helpers.call('site.mock'),
+      closeSite: () => helpers.call('site.close')
+    };
+
+    if (process.env.__PERCY_BROWSERIFIED__) {
+      helpers.call = async function call(event) {
+        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+          args[_key2 - 1] = arguments[_key2];
+        }
+
+        let {
+          socket,
+          pending = {}
+        } = helpers.call;
+
+        if (!socket) {
+          socket = new window.WebSocket('ws://localhost:5339');
+          await new Promise((resolve, reject) => {
+            let done = event => {
+              clearTimeout(timeoutid);
+              socket.onopen = socket.onerror = null;
+
+              if (event && (event.error || event.type === 'error')) {
+                reject(event.error || new Error('Test client connection failed'));
+              } else resolve(socket);
+            };
+
+            let timeoutid = setTimeout(done, 1000, {
+              error: new Error('Test client connection timed out')
+            });
+            socket.onopen = socket.onerror = done;
+          });
+
+          socket.onmessage = _ref => {
+            let {
+              data
+            } = _ref;
+            let {
+              id,
+              resolve,
+              reject
+            } = JSON.parse(data);
+            if (!pending[id]) return;
+            if (resolve) pending[id].resolve(resolve.result);
+            if (reject) pending[id].reject(reject.error);
+          };
+
+          Object.assign(helpers.call, {
+            socket,
+            pending
+          });
+        }
+
+        let id = helpers.call.uid = (helpers.call.uid || 0) + 1;
+        args = args.map(a => typeof a === 'function' ? a.toString() : a);
+        socket.send(JSON.stringify({
+          id,
+          event,
+          args
+        }));
+        return (pending[id] = {}).promise = new Promise((resolve, reject) => {
+          Object.assign(pending[id], {
+            resolve,
+            reject
+          });
+        });
+      };
+    } else {
+      helpers.call = async function call() {
+        let {
+          context
+        } = await import('./server.js');
+        helpers.context = helpers.context || (await context());
+        return helpers.context.call(...arguments);
+      };
+    }
+
+    return helpers;
+
+  })(PercySDKUtils.logger, PercySDKUtils);
+}).call(window);
+
+if (typeof define === "function" && define.amd) {
+  define([], () => window.PercySDKUtils.TestHelpers);
+} else if (typeof module === "object" && module.exports) {
+  module.exports = window.PercySDKUtils.TestHelpers;
+}

package/test/helpers.js

@@ -0,0 +1,80 @@
+import logger from '@percy/logger/test/helpers';
+import utils from '@percy/sdk-utils';
+
+export const helpers = {
+  logger,
+
+  async setup() {
+    utils.percy.version = '';
+    delete utils.percy.config;
+    delete utils.percy.enabled;
+    delete utils.percy.domScript;
+    delete process.env.PERCY_SERVER_ADDRESS;
+    await helpers.call('server.mock');
+    await logger.mock();
+  },
+
+  teardown: () => helpers.call('server.close'),
+  getRequests: () => helpers.call('server.requests'),
+  testReply: (path, reply) => helpers.call('server.reply', path, reply),
+  testFailure: (...args) => helpers.call('server.test.failure', ...args),
+  testError: path => helpers.call('server.test.error', path),
+  testSerialize: fn => !fn
+    ? helpers.call('server.test.serialize') // get
+    : helpers.call('server.test.serialize', fn), // set
+  mockSite: () => helpers.call('site.mock'),
+  closeSite: () => helpers.call('site.close')
+};
+
+if (process.env.__PERCY_BROWSERIFIED__) {
+  helpers.call = async function call(event, ...args) {
+    let { socket, pending = {} } = helpers.call;
+
+    if (!socket) {
+      socket = new window.WebSocket('ws://localhost:5339');
+
+      await new Promise((resolve, reject) => {
+        let done = event => {
+          clearTimeout(timeoutid);
+          socket.onopen = socket.onerror = null;
+          if (event && (event.error || event.type === 'error')) {
+            reject(event.error || new Error('Test client connection failed'));
+          } else resolve(socket);
+        };
+
+        let timeoutid = setTimeout(done, 1000, {
+          error: new Error('Test client connection timed out')
+        });
+
+        socket.onopen = socket.onerror = done;
+      });
+
+      socket.onmessage = ({ data }) => {
+        let { id, resolve, reject } = JSON.parse(data);
+        if (!pending[id]) return;
+        if (resolve) pending[id].resolve(resolve.result);
+        if (reject) pending[id].reject(reject.error);
+      };
+
+      Object.assign(helpers.call, { socket, pending });
+    }
+
+    let id = helpers.call.uid = (helpers.call.uid || 0) + 1;
+    args = args.map(a => typeof a === 'function' ? a.toString() : a);
+    socket.send(JSON.stringify({ id, event, args }));
+
+    return ((pending[id] = {}).promise = (
+      new Promise((resolve, reject) => {
+        Object.assign(pending[id], { resolve, reject });
+      })
+    ));
+  };
+} else {
+  helpers.call = async function call() {
+    let { context } = await import('./server.js');
+    helpers.context = (helpers.context || await context());
+    return helpers.context.call(...arguments);
+  };
+}
+
+export default helpers;