@percy/webdriver-utils 1.27.0-alpha.0

package/dist/driver.js

@@ -0,0 +1,65 @@
+import utils from '@percy/sdk-utils';
+import Cache from './util/cache.js';
+const {
+  request
+} = utils;
+export default class Driver {
+  constructor(sessionId, executorUrl) {
+    this.sessionId = sessionId;
+    this.executorUrl = executorUrl.includes('@') ? `https://${executorUrl.split('@')[1]}` : executorUrl;
+  }
+  async getCapabilites() {
+    return await Cache.withCache(Cache.caps, this.sessionId, async () => {
+      const baseUrl = `${this.executorUrl}/session/${this.sessionId}`;
+      const caps = JSON.parse((await request(baseUrl)).body);
+      return caps.value;
+    });
+  }
+  async getWindowSize() {
+    const baseUrl = `${this.executorUrl}/session/${this.sessionId}/window/current/size`;
+    const windowSize = JSON.parse((await request(baseUrl)).body);
+    return windowSize;
+  }
+
+  // command => {script: "", args: []}
+  async executeScript(command) {
+    if (!command.constructor === Object || !(Object.keys(command).length === 2 && Object.keys(command).includes('script') && Object.keys(command).includes('args'))) {
+      throw new Error('Please pass command as {script: "", args: []}');
+    }
+    const options = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json;charset=utf-8'
+      },
+      body: JSON.stringify(command)
+    };
+    const baseUrl = `${this.executorUrl}/session/${this.sessionId}/execute/sync`;
+    const response = JSON.parse((await request(baseUrl, options)).body);
+    return response;
+  }
+  async takeScreenshot() {
+    const baseUrl = `${this.executorUrl}/session/${this.sessionId}/screenshot`;
+    const screenShot = JSON.parse((await request(baseUrl)).body);
+    return screenShot.value;
+  }
+  async rect(elementId) {
+    const baseUrl = `${this.executorUrl}/session/${this.sessionId}/element/${elementId}/rect`;
+    const response = JSON.parse((await request(baseUrl)).body);
+    return response.value;
+  }
+  async findElement(using, value) {
+    const options = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json;charset=utf-8'
+      },
+      body: JSON.stringify({
+        using,
+        value
+      })
+    };
+    const baseUrl = `${this.executorUrl}/session/${this.sessionId}/element`;
+    const response = JSON.parse((await request(baseUrl, options)).body);
+    return response.value;
+  }
+}

package/dist/index.js

@@ -0,0 +1,36 @@
+import ProviderResolver from './providers/providerResolver.js';
+import utils from '@percy/sdk-utils';
+import { camelcase } from '@percy/config/utils';
+export default class WebdriverUtils {
+  log = utils.logger('webdriver-utils:main');
+  constructor({
+    sessionId,
+    commandExecutorUrl,
+    capabilities,
+    sessionCapabilites,
+    snapshotName,
+    clientInfo,
+    environmentInfo,
+    options = {}
+  }) {
+    this.sessionId = sessionId;
+    this.commandExecutorUrl = commandExecutorUrl;
+    this.capabilities = capabilities;
+    this.sessionCapabilites = sessionCapabilites;
+    this.snapshotName = snapshotName;
+    const camelCasedOptions = {};
+    Object.keys(options).forEach(key => {
+      let newKey = camelcase(key);
+      camelCasedOptions[newKey] = options[key];
+    });
+    this.options = camelCasedOptions;
+    this.clientInfo = clientInfo;
+    this.environmentInfo = environmentInfo;
+  }
+  async automateScreenshot() {
+    this.log.info('Starting automate screenshot');
+    const automate = ProviderResolver.resolve(this.sessionId, this.commandExecutorUrl, this.capabilities, this.sessionCapabilites, this.clientInfo, this.environmentInfo, this.options);
+    await automate.createDriver();
+    return await automate.screenshot(this.snapshotName, this.options);
+  }
+}

package/dist/metadata/desktopMetaData.js

@@ -0,0 +1,56 @@
+export default class DesktopMetaData {
+  constructor(driver, opts) {
+    this.driver = driver;
+    this.capabilities = opts;
+  }
+  browserName() {
+    return this.capabilities.browserName.toLowerCase();
+  }
+  browserVersion() {
+    return this.capabilities.browserVersion.split('.')[0];
+  }
+  osName() {
+    let osName = this.capabilities.os;
+    if (osName) return osName.toLowerCase();
+    osName = this.capabilities.platform;
+    return osName;
+  }
+
+  // showing major version
+  osVersion() {
+    return this.capabilities.osVersion.toLowerCase();
+  }
+
+  // combination of browserName + browserVersion + osVersion + osName
+  deviceName() {
+    return this.browserName() + '_' + this.browserVersion() + '_' + this.osVersion() + '_' + this.osName();
+  }
+  orientation() {
+    return 'landscape';
+  }
+  async windowSize() {
+    const dpr = await this.devicePixelRatio();
+    const data = await this.driver.getWindowSize();
+    const width = parseInt(data.value.width * dpr),
+      height = parseInt(data.value.height * dpr);
+    return {
+      width,
+      height
+    };
+  }
+  async screenResolution() {
+    const data = await this.driver.executeScript({
+      script: 'return [window.screen.width.toString(), window.screen.height.toString()];',
+      args: []
+    });
+    const screenInfo = data.value;
+    return `${screenInfo[0]} x ${screenInfo[1]}`;
+  }
+  async devicePixelRatio() {
+    const devicePixelRatio = await this.driver.executeScript({
+      script: 'return window.devicePixelRatio;',
+      args: []
+    });
+    return devicePixelRatio.value;
+  }
+}

package/dist/metadata/metaDataResolver.js

@@ -0,0 +1,13 @@
+import DesktopMetaData from './desktopMetaData.js';
+import MobileMetaData from './mobileMetaData.js';
+export default class MetaDataResolver {
+  static resolve(driver, capabilities, opts) {
+    if (!driver) throw new Error('Please pass a Driver object');
+    const platform = opts.platformName || opts.platform;
+    if (['ios', 'android'].includes(platform.toLowerCase())) {
+      return new MobileMetaData(driver, capabilities);
+    } else {
+      return new DesktopMetaData(driver, capabilities);
+    }
+  }
+}

package/dist/metadata/mobileMetaData.js

@@ -0,0 +1,50 @@
+export default class MobileMetaData {
+  constructor(driver, opts) {
+    this.driver = driver;
+    this.capabilities = opts;
+  }
+  browserName() {
+    return this.capabilities.browserName.toLowerCase();
+  }
+  browserVersion() {
+    var _this$capabilities$br;
+    const bsVersion = (_this$capabilities$br = this.capabilities.browserVersion) === null || _this$capabilities$br === void 0 ? void 0 : _this$capabilities$br.split('.');
+    if ((bsVersion === null || bsVersion === void 0 ? void 0 : bsVersion.length) > 0) {
+      return bsVersion[0];
+    }
+    return this.capabilities.version.split('.')[0];
+  }
+  osName() {
+    let osName = this.capabilities.os.toLowerCase();
+    if (osName === 'mac' && this.browserName() === 'iphone') {
+      osName = 'ios';
+    }
+    return osName;
+  }
+  osVersion() {
+    return this.capabilities.osVersion.split('.')[0];
+  }
+  deviceName() {
+    return this.capabilities.deviceName.split('-')[0];
+  }
+  orientation() {
+    return this.capabilities.orientation;
+  }
+  async windowSize() {
+    const dpr = await this.devicePixelRatio();
+    const data = await this.driver.getWindowSize();
+    const width = parseInt(data.value.width * dpr),
+      height = parseInt(data.value.height * dpr);
+    return {
+      width,
+      height
+    };
+  }
+  async devicePixelRatio() {
+    const devicePixelRatio = await this.driver.executeScript({
+      script: 'return window.devicePixelRatio;',
+      args: []
+    });
+    return devicePixelRatio.value;
+  }
+}

package/dist/providers/automateProvider.js

@@ -0,0 +1,133 @@
+import utils from '@percy/sdk-utils';
+import GenericProvider from './genericProvider.js';
+import Cache from '../util/cache.js';
+import Tile from '../util/tile.js';
+const log = utils.logger('webdriver-utils:automateProvider');
+const {
+  TimeIt
+} = utils;
+export default class AutomateProvider extends GenericProvider {
+  constructor(sessionId, commandExecutorUrl, capabilities, sessionCapabilites, clientInfo, environmentInfo, options) {
+    super(sessionId, commandExecutorUrl, capabilities, sessionCapabilites, clientInfo, environmentInfo, options);
+    this._markedPercy = false;
+  }
+  static supports(commandExecutorUrl) {
+    return commandExecutorUrl.includes(process.env.AA_DOMAIN || 'browserstack');
+  }
+  async screenshot(name, {
+    ignoreRegionXpaths = [],
+    ignoreRegionSelectors = [],
+    ignoreRegionElements = [],
+    customIgnoreRegions = []
+  }) {
+    let response = null;
+    let error;
+    try {
+      let result = await this.percyScreenshotBegin(name);
+      this.setDebugUrl(result);
+      response = await super.screenshot(name, {
+        ignoreRegionXpaths,
+        ignoreRegionSelectors,
+        ignoreRegionElements,
+        customIgnoreRegions
+      });
+    } catch (e) {
+      error = e;
+      throw e;
+    } finally {
+      var _response, _response$body;
+      await this.percyScreenshotEnd(name, (_response = response) === null || _response === void 0 ? void 0 : (_response$body = _response.body) === null || _response$body === void 0 ? void 0 : _response$body.link, `${error}`);
+    }
+    return response;
+  }
+  async percyScreenshotBegin(name) {
+    return await TimeIt.run('percyScreenshotBegin', async () => {
+      try {
+        let result = await this.browserstackExecutor('percyScreenshot', {
+          name,
+          percyBuildId: process.env.PERCY_BUILD_ID,
+          percyBuildUrl: process.env.PERCY_BUILD_URL,
+          state: 'begin'
+        });
+        this._markedPercy = result.success;
+        return result;
+      } catch (e) {
+        log.debug(`[${name}] Could not mark Automate session as percy`);
+        log.error(`[${name}] error: ${e.toString()}`);
+        return null;
+      }
+    });
+  }
+  async percyScreenshotEnd(name, percyScreenshotUrl, statusMessage = null) {
+    return await TimeIt.run('percyScreenshotEnd', async () => {
+      try {
+        await this.browserstackExecutor('percyScreenshot', {
+          name,
+          percyScreenshotUrl,
+          status: percyScreenshotUrl ? 'success' : 'failure',
+          statusMessage,
+          state: 'end'
+        });
+      } catch (e) {
+        log.debug(`[${name}] Could not mark Automate session as percy`);
+      }
+    });
+  }
+  async getTiles(fullscreen) {
+    if (!this.driver) throw new Error('Driver is null, please initialize driver with createDriver().');
+    const response = await TimeIt.run('percyScreenshot:screenshot', async () => {
+      return await this.browserstackExecutor('percyScreenshot', {
+        state: 'screenshot',
+        percyBuildId: process.env.PERCY_BUILD_ID,
+        screenshotType: 'singlepage',
+        scaleFactor: await this.driver.executeScript({
+          script: 'return window.devicePixelRatio;',
+          args: []
+        }),
+        options: this.options
+      });
+    });
+    const responseValue = JSON.parse(response.value);
+    if (!responseValue.success) {
+      throw new Error('Failed to get screenshots from Automate.' + ' Check dashboard for error.');
+    }
+    const tiles = [];
+    const tileResponse = JSON.parse(responseValue.result);
+    for (let tileData of tileResponse.sha) {
+      tiles.push(new Tile({
+        statusBarHeight: 0,
+        navBarHeight: 0,
+        headerHeight: 0,
+        footerHeight: 0,
+        fullscreen,
+        sha: tileData.split('-')[0] // drop build id
+      }));
+    }
+
+    return {
+      tiles: tiles,
+      domInfoSha: tileResponse.dom_sha
+    };
+  }
+  async browserstackExecutor(action, args) {
+    if (!this.driver) throw new Error('Driver is null, please initialize driver with createDriver().');
+    let options = args ? {
+      action,
+      arguments: args
+    } : {
+      action
+    };
+    let res = await this.driver.executeScript({
+      script: `browserstack_executor: ${JSON.stringify(options)}`,
+      args: []
+    });
+    return res;
+  }
+  async setDebugUrl() {
+    if (!this.driver) throw new Error('Driver is null, please initialize driver with createDriver().');
+    this.debugUrl = await Cache.withCache(Cache.bstackSessionDetails, this.driver.sessionId, async () => {
+      const sessionDetails = await this.browserstackExecutor('getSessionDetails');
+      return JSON.parse(sessionDetails.value).browser_url;
+    });
+  }
+}

package/dist/providers/genericProvider.js

@@ -0,0 +1,223 @@
+import utils from '@percy/sdk-utils';
+import MetaDataResolver from '../metadata/metaDataResolver.js';
+import Tile from '../util/tile.js';
+import Driver from '../driver.js';
+const log = utils.logger('webdriver-utils:genericProvider');
+export default class GenericProvider {
+  clientInfo = new Set();
+  environmentInfo = new Set();
+  options = {};
+  constructor(sessionId, commandExecutorUrl, capabilities, sessionCapabilites, clientInfo, environmentInfo, options) {
+    this.sessionId = sessionId;
+    this.commandExecutorUrl = commandExecutorUrl;
+    this.capabilities = capabilities;
+    this.sessionCapabilites = sessionCapabilites;
+    this.addClientInfo(clientInfo);
+    this.addEnvironmentInfo(environmentInfo);
+    this.options = options;
+    this.driver = null;
+    this.metaData = null;
+    this.debugUrl = null;
+  }
+  async createDriver() {
+    this.driver = new Driver(this.sessionId, this.commandExecutorUrl);
+    const caps = await this.driver.getCapabilites();
+    this.metaData = await MetaDataResolver.resolve(this.driver, caps, this.capabilities);
+  }
+  static supports(_commandExecutorUrl) {
+    return true;
+  }
+  addClientInfo(info) {
+    for (let i of [].concat(info)) {
+      if (i) this.clientInfo.add(i);
+    }
+  }
+  addEnvironmentInfo(info) {
+    for (let i of [].concat(info)) {
+      if (i) this.environmentInfo.add(i);
+    }
+  }
+  async addPercyCSS(userCSS) {
+    const createStyleElement = `const e = document.createElement('style');
+      e.setAttribute('data-percy-specific-css', true);
+      e.innerHTML = '${userCSS}';
+      document.body.appendChild(e);`;
+    await this.driver.executeScript({
+      script: createStyleElement,
+      args: []
+    });
+  }
+  async removePercyCSS() {
+    const removeStyleElement = `const n = document.querySelector('[data-percy-specific-css]');
+      n.remove();`;
+    await this.driver.executeScript({
+      script: removeStyleElement,
+      args: []
+    });
+  }
+  async screenshot(name, {
+    ignoreRegionXpaths = [],
+    ignoreRegionSelectors = [],
+    ignoreRegionElements = [],
+    customIgnoreRegions = []
+  }) {
+    let fullscreen = false;
+    const percyCSS = this.options.percyCSS || '';
+    await this.addPercyCSS(percyCSS);
+    const tag = await this.getTag();
+    const tiles = await this.getTiles(fullscreen);
+    const ignoreRegions = await this.findIgnoredRegions(ignoreRegionXpaths, ignoreRegionSelectors, ignoreRegionElements, customIgnoreRegions);
+    await this.setDebugUrl();
+    await this.removePercyCSS();
+    log.debug(`${name} : Tag ${JSON.stringify(tag)}`);
+    log.debug(`${name} : Tiles ${JSON.stringify(tiles)}`);
+    log.debug(`${name} : Debug url ${this.debugUrl}`);
+    return {
+      name,
+      tag,
+      tiles: tiles.tiles,
+      // TODO: Fetch this one for bs automate, check appium sdk
+      externalDebugUrl: this.debugUrl,
+      ignoredElementsData: ignoreRegions,
+      environmentInfo: [...this.environmentInfo].join('; '),
+      clientInfo: [...this.clientInfo].join(' '),
+      domInfoSha: tiles.domInfoSha
+    };
+  }
+
+  // TODO: get dom sha for non-automate
+  async getDomContent() {
+    // execute script and return dom content
+    return 'dummyValue';
+  }
+  async getTiles(fullscreen) {
+    if (!this.driver) throw new Error('Driver is null, please initialize driver with createDriver().');
+    const base64content = await this.driver.takeScreenshot();
+    return {
+      tiles: [new Tile({
+        content: base64content,
+        // TODO: Need to add method to fetch these attr
+        statusBarHeight: 0,
+        navBarHeight: 0,
+        headerHeight: 0,
+        footerHeight: 0,
+        fullscreen
+      })],
+      // TODO: Add Generic support sha for contextual diff
+      domInfoSha: await this.getDomContent()
+    };
+  }
+  async getTag() {
+    if (!this.driver) throw new Error('Driver is null, please initialize driver with createDriver().');
+    const {
+      width,
+      height
+    } = await this.metaData.windowSize();
+    const resolution = await this.metaData.screenResolution();
+    const orientation = this.metaData.orientation();
+    return {
+      name: this.metaData.deviceName(),
+      osName: this.metaData.osName(),
+      osVersion: this.metaData.osVersion(),
+      width,
+      height,
+      orientation: orientation,
+      browserName: this.metaData.browserName(),
+      browserVersion: this.metaData.browserVersion(),
+      resolution: resolution
+    };
+  }
+
+  // TODO: Add Debugging Url
+  async setDebugUrl() {
+    this.debugUrl = 'https://localhost/v1';
+  }
+  async findIgnoredRegions(ignoreRegionXpaths, ignoreRegionSelectors, ignoreRegionElements, customIgnoreRegions) {
+    const ignoreElementXpaths = await this.getIgnoreRegionsBy('xpath', ignoreRegionXpaths);
+    const ignoreElementSelectors = await this.getIgnoreRegionsBy('css selector', ignoreRegionSelectors);
+    const ignoreElements = await this.getIgnoreRegionsByElement(ignoreRegionElements);
+    const ignoreElementCustom = await this.getCustomIgnoreRegions(customIgnoreRegions);
+    return {
+      ignoreElementsData: [...ignoreElementXpaths, ...ignoreElementSelectors, ...ignoreElements, ...ignoreElementCustom]
+    };
+  }
+  async ignoreElementObject(selector, elementId) {
+    const scaleFactor = parseInt(await this.metaData.devicePixelRatio());
+    const rect = await this.driver.rect(elementId);
+    const location = {
+      x: rect.x,
+      y: rect.y
+    };
+    const size = {
+      height: rect.height,
+      width: rect.width
+    };
+    const coOrdinates = {
+      top: Math.floor(location.y * scaleFactor),
+      bottom: Math.ceil((location.y + size.height) * scaleFactor),
+      left: Math.floor(location.x * scaleFactor),
+      right: Math.ceil((location.x + size.width) * scaleFactor)
+    };
+    const jsonObject = {
+      selector,
+      coOrdinates
+    };
+    return jsonObject;
+  }
+  async getIgnoreRegionsBy(findBy, elements) {
+    const ignoredElementsArray = [];
+    for (const idx in elements) {
+      try {
+        const element = await this.driver.findElement(findBy, elements[idx]);
+        const selector = `${findBy}: ${elements[idx]}`;
+        const ignoredRegion = await this.ignoreElementObject(selector, element[Object.keys(element)[0]]);
+        ignoredElementsArray.push(ignoredRegion);
+      } catch (e) {
+        log.warn(`Selenium Element with ${findBy}: ${elements[idx]} not found. Ignoring this ${findBy}.`);
+        log.error(e.toString());
+      }
+    }
+    return ignoredElementsArray;
+  }
+  async getIgnoreRegionsByElement(elements) {
+    const ignoredElementsArray = [];
+    for (let index = 0; index < elements.length; index++) {
+      try {
+        const selector = `element: ${index}`;
+        const ignoredRegion = await this.ignoreElementObject(selector, elements[index]);
+        ignoredElementsArray.push(ignoredRegion);
+      } catch (e) {
+        log.warn(`Correct Web Element not passed at index ${index}.`);
+        log.debug(e.toString());
+      }
+    }
+    return ignoredElementsArray;
+  }
+  async getCustomIgnoreRegions(customLocations) {
+    const ignoredElementsArray = [];
+    const {
+      width,
+      height
+    } = await this.metaData.windowSize();
+    for (let index = 0; index < customLocations.length; index++) {
+      const customLocation = customLocations[index];
+      const invalid = customLocation.top >= height || customLocation.bottom > height || customLocation.left >= width || customLocation.right > width;
+      if (!invalid) {
+        const selector = `custom ignore region ${index}`;
+        const ignoredRegion = {
+          selector,
+          coOrdinates: {
+            top: customLocation.top,
+            bottom: customLocation.bottom,
+            left: customLocation.left,
+            right: customLocation.right
+          }
+        };
+        ignoredElementsArray.push(ignoredRegion);
+      } else {
+        log.warn(`Values passed in custom ignored region at index: ${index} is not valid`);
+      }
+    }
+    return ignoredElementsArray;
+  }
+}

package/dist/providers/providerResolver.js

@@ -0,0 +1,9 @@
+import GenericProvider from './genericProvider.js';
+import AutomateProvider from './automateProvider.js';
+export default class ProviderResolver {
+  static resolve(sessionId, commandExecutorUrl, capabilities, sessionCapabilities, clientInfo, environmentInfo, options) {
+    // We can safely do [0] because GenericProvider is catch all
+    const Klass = [AutomateProvider, GenericProvider].filter(x => x.supports(commandExecutorUrl))[0];
+    return new Klass(sessionId, commandExecutorUrl, capabilities, sessionCapabilities, clientInfo, environmentInfo, options);
+  }
+}

package/dist/util/cache.js

@@ -0,0 +1,62 @@
+import utils from '@percy/sdk-utils';
+const {
+  Undefined
+} = utils;
+export default class Cache {
+  static cache = {};
+
+  // Common stores, const, dont modify outside
+  static caps = 'caps';
+  static bstackSessionDetails = 'bstackSessionDetails';
+  static systemBars = 'systemBars';
+
+  // maintainance
+  static lastTime = Date.now();
+  static timeout = 5 * 60 * 1000;
+  static async withCache(store, key, func, cacheExceptions = false) {
+    this.maintain();
+    if (Undefined(this.cache[store])) this.cache[store] = {};
+    store = this.cache[store];
+    if (store[key]) {
+      if (store[key].success) {
+        return store[key].val;
+      } else {
+        throw store[key].val;
+      }
+    }
+    const obj = {
+      success: false,
+      val: null,
+      time: Date.now()
+    };
+    try {
+      obj.val = await func();
+      obj.success = true;
+    } catch (e) {
+      obj.val = e;
+    }
+
+    // We seem to have correct coverage for both flows but nyc is marking it as missing
+    // branch coverage anyway
+    /* istanbul ignore next */
+    if (obj.success || cacheExceptions) {
+      store[key] = obj;
+    }
+    if (!obj.success) throw obj.val;
+    return obj.val;
+  }
+  static maintain() {
+    if (this.lastTime + this.timeout > Date.now()) return;
+    for (const [, store] of Object.entries(this.cache)) {
+      for (const [key, item] of Object.entries(store)) {
+        if (item.time + this.timeout < Date.now()) {
+          delete store[key];
+        }
+      }
+    }
+    this.lastTime = Date.now();
+  }
+  static reset() {
+    this.cache = {};
+  }
+}

package/dist/util/tile.js

@@ -0,0 +1,19 @@
+export default class Tile {
+  constructor({
+    content,
+    statusBarHeight,
+    navBarHeight,
+    headerHeight,
+    footerHeight,
+    fullscreen,
+    sha
+  }) {
+    this.content = content;
+    this.statusBarHeight = statusBarHeight;
+    this.navBarHeight = navBarHeight;
+    this.headerHeight = headerHeight;
+    this.footerHeight = footerHeight;
+    this.fullscreen = fullscreen;
+    this.sha = sha;
+  }
+}

package/dist/util/timing.js

@@ -0,0 +1,47 @@
+import validations from './validations.js';
+const {
+  Undefined
+} = validations;
+export default class TimeIt {
+  static data = {};
+  static enabled = process.env.PERCY_METRICS === 'true';
+  static async run(store, func) {
+    if (!this.enabled) return await func();
+    const t1 = Date.now();
+    try {
+      return await func();
+    } finally {
+      if (Undefined(this.data[store])) this.data[store] = [];
+      this.data[store].push(Date.now() - t1);
+    }
+  }
+  static min(store) {
+    return Math.min(...this.data[store]);
+  }
+  static max(store) {
+    return Math.max(...this.data[store]);
+  }
+  static avg(store) {
+    const vals = this.data[store];
+    return vals.reduce((a, b) => a + b, 0) / vals.length;
+  }
+  static summary({
+    includeVals
+  } = {}) {
+    const agg = {};
+    for (const key of Object.keys(this.data)) {
+      agg[key] = {
+        min: this.min(key),
+        max: this.max(key),
+        avg: this.avg(key),
+        count: this.data[key].length
+      };
+      if (includeVals) agg[key].vals = this.data[key];
+    }
+    return agg;
+  }
+  static reset() {
+    this.data = {};
+  }
+}
+;

package/dist/util/validations.js

@@ -0,0 +1,7 @@
+function Undefined(obj) {
+  return obj === undefined;
+}
+export { Undefined };
+
+// export the namespace by default
+export * as default from './validations.js';

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@percy/webdriver-utils",
+  "version": "1.27.0-alpha.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/percy/cli",
+    "directory": "packages/webdriver-utils"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "node ../../scripts/build",
+    "lint": "eslint --ignore-path ../../.gitignore .",
+    "test": "node ../../scripts/test",
+    "test:coverage": "yarn test --coverage"
+  },
+  "dependencies": {
+    "@percy/config": "1.27.0-alpha.0",
+    "@percy/sdk-utils": "1.27.0-alpha.0"
+  },
+  "gitHead": "16f2c87641d844c6af6c3e198f6aff1c08ee0ec1"
+}