@percy/cli 1.12.0 → 1.14.0

package/dist/commands.js

@@ -3,22 +3,22 @@ import fs from 'fs';
 import url from 'url';
 import path from 'path';
 import Module from 'module';
-import { command, legacyCommand, logger } from '@percy/cli-command'; // Helper to simplify reducing async functions
+import { command, legacyCommand, logger } from '@percy/cli-command';
 
+// Helper to simplify reducing async functions
 async function reduceAsync(iter, reducer, accum = []) {
   for (let i of iter) accum = await reducer(accum, i);
-
   return accum;
-} // Helper to read and reduce files within a directory
-
+}
 
+// Helper to read and reduce files within a directory
 function reduceFiles(dir, reducer) {
   return reduceAsync(fs.readdirSync(dir, {
     withFileTypes: true
   }), reducer);
-} // Returns the paths of potential percy packages found within node_modules
-
+}
 
+// Returns the paths of potential percy packages found within node_modules
 function findModulePackages(dir) {
   try {
     // not given node_modules or a directory that contains node_modules, look up
@@ -27,14 +27,14 @@ function findModulePackages(dir) {
       let next = fs.existsSync(modulesPath) ? modulesPath : path.dirname(dir);
       if (next === dir || next === os.homedir()) return [];
       return findModulePackages(next);
-    } // given node modules, look for percy packages
-
+    }
 
+    // given node modules, look for percy packages
     return reduceFiles(dir, async (roots, file) => {
       let rootPath = path.join(dir, file.name);
-
       if (file.name === '@percy') {
-        return roots.concat(await reduceFiles(rootPath, (dirs, f) => // specifically protect against files to allow linked directories
+        return roots.concat(await reduceFiles(rootPath, (dirs, f) =>
+        // specifically protect against files to allow linked directories
         f.isFile() ? dirs : dirs.concat(path.join(rootPath, f.name)), []));
       } else if (file.name.startsWith('percy-cli-')) {
         return roots.concat(rootPath);
@@ -46,14 +46,14 @@ function findModulePackages(dir) {
     logger('cli:plugins').debug(error);
     return [];
   }
-} // Used by `findPnpPackages` to filter Percy CLI plugins
+}
 
+// Used by `findPnpPackages` to filter Percy CLI plugins
+const PERCY_PKG_REG = /^(@percy\/|percy-cli-)/;
 
-const PERCY_PKG_REG = /^(@percy\/|percy-cli-)/; // Returns the paths of potential percy packages found within yarn's pnp system
-
+// Returns the paths of potential percy packages found within yarn's pnp system
 function findPnpPackages(dir) {
   var _Module$findPnpApi;
-
   let pnpapi = (_Module$findPnpApi = Module.findPnpApi) === null || _Module$findPnpApi === void 0 ? void 0 : _Module$findPnpApi.call(Module, `${dir}/`);
   let pkgLoc = pnpapi === null || pnpapi === void 0 ? void 0 : pnpapi.findPackageLocator(`${dir}/`);
   let pkgInfo = pkgLoc && (pnpapi === null || pnpapi === void 0 ? void 0 : pnpapi.getPackageInformation(pkgLoc));
@@ -64,21 +64,21 @@ function findPnpPackages(dir) {
     let depInfo = pnpapi.getPackageInformation(depLoc);
     return roots.concat(depInfo.packageLocation);
   }, []);
-} // Helper to import and wrap legacy percy commands for reverse compatibility
-
+}
 
+// Helper to import and wrap legacy percy commands for reverse compatibility
 function importLegacyCommands(commandsPath) {
   return reduceFiles(commandsPath, async (cmds, file) => {
     let filepath = path.join(commandsPath, file.name);
     let {
       name
     } = path.parse(file.name);
-
     if (file.isDirectory()) {
       // recursively import nested commands and find the index command
       let commands = await importLegacyCommands(filepath);
-      let index = commands.findIndex(cmd => cmd.name === 'index'); // modify or create an index command to hold nested commands
+      let index = commands.findIndex(cmd => cmd.name === 'index');
 
+      // modify or create an index command to hold nested commands
       index = ~index ? commands.splice(index, 1)[0] : command();
       Object.defineProperty(index, 'name', {
         value: name
@@ -90,71 +90,72 @@ function importLegacyCommands(commandsPath) {
       let exports = Object.values(await import(url.pathToFileURL(filepath).href));
       let cmd = exports.find(e => {
         var _e$prototype;
-
         return typeof (e === null || e === void 0 ? void 0 : (_e$prototype = e.prototype) === null || _e$prototype === void 0 ? void 0 : _e$prototype.run) === 'function';
       });
       return cmd ? cmds.concat(legacyCommand(name, cmd)) : cmds;
     }
   });
-} // Imports and returns compatibile CLI commands from various sources
-
+}
 
+// Imports and returns compatibile CLI commands from various sources
 export async function importCommands() {
-  let root = path.resolve(url.fileURLToPath(import.meta.url), '../..'); // start with a set to get built-in deduplication
-
-  let cmdPkgs = await reduceAsync(new Set([// find included dependencies
-  root, // find potential sibling packages
-  path.join(root, '..'), // find any current project dependencies
+  let root = path.resolve(url.fileURLToPath(import.meta.url), '../..');
+
+  // start with a set to get built-in deduplication
+  let cmdPkgs = await reduceAsync(new Set([
+  // find included dependencies
+  root,
+  // find potential sibling packages
+  path.join(root, '..'),
+  // find any current project dependencies
   process.cwd()]), async (roots, dir) => {
     if (fs.existsSync(path.join(dir, 'package.json'))) roots.push(dir);
     roots.push(...(await findModulePackages(dir)));
     roots.push(...(await findPnpPackages(dir)));
     return roots;
-  }); // reduce found packages to functions which import cli commands
+  });
 
+  // reduce found packages to functions which import cli commands
   let cmdImports = await reduceAsync(cmdPkgs, async (pkgs, pkgPath) => {
     var _pkg$oclif, _pkg$PercyCli;
+    let pkg = JSON.parse(fs.readFileSync(path.join(pkgPath, 'package.json')));
+    // do not include self
+    if (pkg.name === '@percy/cli') return pkgs;
 
-    let pkg = JSON.parse(fs.readFileSync(path.join(pkgPath, 'package.json'))); // do not include self
-
-    if (pkg.name === '@percy/cli') return pkgs; // support legacy oclif percy commands
-
+    // support legacy oclif percy commands
     if (((_pkg$oclif = pkg.oclif) === null || _pkg$oclif === void 0 ? void 0 : _pkg$oclif.bin) === 'percy') {
       pkgs.set(pkg.name, async () => {
         var _pkg$oclif$hooks;
-
         if ((_pkg$oclif$hooks = pkg.oclif.hooks) !== null && _pkg$oclif$hooks !== void 0 && _pkg$oclif$hooks.init) {
           let initPath = path.join(pkgPath, pkg.oclif.hooks.init);
           let init = await import(url.pathToFileURL(initPath).href);
           await init.default();
         }
-
         if (pkg.oclif.commands) {
           let commandsPath = path.join(pkgPath, pkg.oclif.commands);
           return importLegacyCommands(commandsPath);
         }
-
         return [];
       });
-    } // overwrite any found package of the same name
-
+    }
 
+    // overwrite any found package of the same name
     if ((_pkg$PercyCli = pkg['@percy/cli']) !== null && _pkg$PercyCli !== void 0 && _pkg$PercyCli.commands) {
       pkgs.set(pkg.name, () => Promise.all(pkg['@percy/cli'].commands.map(async cmdPath => {
         var _module$default;
-
         let modulePath = path.join(pkgPath, cmdPath);
         let module = await import(url.pathToFileURL(modulePath).href);
         (_module$default = module.default).packageInformation || (_module$default.packageInformation = pkg);
         return module.default;
       })));
     }
-
     return pkgs;
-  }, new Map()); // actually import found commands
+  }, new Map());
 
-  let cmds = await reduceAsync(cmdImports.values(), async (cmds, importCmds) => cmds.concat(await importCmds())); // sort standalone commands before command topics
+  // actually import found commands
+  let cmds = await reduceAsync(cmdImports.values(), async (cmds, importCmds) => cmds.concat(await importCmds()));
 
+  // sort standalone commands before command topics
   return cmds.sort((a, b) => {
     if (a.callback && !b.callback) return -1;
     if (b.callback && !a.callback) return 1;

package/dist/update.js

@@ -3,17 +3,18 @@ import url from 'url';
 import path from 'path';
 import logger from '@percy/logger';
 import { colors } from '@percy/logger/utils';
-import { getPackageJSON } from '@percy/cli-command/utils'; // filepath where the cache will be read and written to
+import { getPackageJSON } from '@percy/cli-command/utils';
 
-const CACHE_FILE = path.resolve(url.fileURLToPath(import.meta.url), '../../.releases'); // max age the cache should be used for (3 days)
+// filepath where the cache will be read and written to
+const CACHE_FILE = path.resolve(url.fileURLToPath(import.meta.url), '../../.releases');
+// max age the cache should be used for (3 days)
+const CACHE_MAX_AGE = 3 * 24 * 60 * 60 * 1000;
 
-const CACHE_MAX_AGE = 3 * 24 * 60 * 60 * 1000; // Safely read from CACHE_FILE and return an object containing `data` mirroring what was previously
+// Safely read from CACHE_FILE and return an object containing `data` mirroring what was previously
 // written using `writeToCache(data)`. An empty object is returned when older than CACHE_MAX_AGE,
 // and an `error` will be present if one was encountered.
-
 function readFromCache() {
   let cached = {};
-
   try {
     if (fs.existsSync(CACHE_FILE)) {
       let {
@@ -27,11 +28,10 @@ function readFromCache() {
     log.debug('Unable to read from cache');
     log.debug(cached.error = error);
   }
-
   return cached;
-} // Safely write data to CACHE_FILE with the current timestamp.
-
+}
 
+// Safely write data to CACHE_FILE with the current timestamp.
 function writeToCache(data) {
   try {
     fs.writeFileSync(CACHE_FILE, JSON.stringify({
@@ -43,30 +43,32 @@ function writeToCache(data) {
     log.debug('Unable to write to cache');
     log.debug(error);
   }
-} // Fetch and return release information for @percy/cli.
-
+}
 
+// Fetch and return release information for @percy/cli.
 async function fetchReleases(pkg) {
   let {
     request
-  } = await import('@percy/client/utils'); // fetch releases from the github api without retries
+  } = await import('@percy/client/utils');
 
+  // fetch releases from the github api without retries
   let api = 'https://api.github.com/repos/percy/cli/releases';
   let data = await request(api, {
     headers: {
       'User-Agent': pkg.name
     },
     retries: 0
-  }); // return relevant information
+  });
 
+  // return relevant information
   return data.map(r => ({
     tag: r.tag_name,
     prerelease: r.prerelease
   }));
-} // Check for updates by comparing latest releases with the current version. The result of the check
-// is cached to speed up subsequent CLI usage.
-
+}
 
+// Check for updates by comparing latest releases with the current version. The result of the check
+// is cached to speed up subsequent CLI usage.
 export async function checkForUpdate() {
   let {
     data: releases,
@@ -74,18 +76,22 @@ export async function checkForUpdate() {
   } = readFromCache();
   let pkg = getPackageJSON(import.meta.url);
   let log = logger('cli:update');
-
+  if (process.env.PERCY_SKIP_UPDATE_CHECK) {
+    log.debug('Skipping update check');
+    return;
+  }
   try {
     // request new release information if needed
     if (!releases) {
       releases = await fetchReleases(pkg);
       if (!cacheError) writeToCache(releases, log);
-    } // check the current package version against released versions
-
+    }
 
+    // check the current package version against released versions
     let versions = releases.map(r => r.tag.substr(1));
-    let age = versions.indexOf(pkg.version); // a new version is available
+    let age = versions.indexOf(pkg.version);
 
+    // a new version is available
     if (age !== 0) {
       log.warn(`\n${age > 0 && age < 10 ? 'A new version of @percy/cli is available!' : 'Heads up! The current version of @percy/cli is more than 10 releases behind!'} ${colors.red(pkg.version)} -> ${colors.green(versions[0])}\n`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/cli",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -30,15 +30,15 @@
     "test:coverage": "yarn test --coverage"
   },
   "dependencies": {
-    "@percy/cli-app": "1.12.0",
-    "@percy/cli-build": "1.12.0",
-    "@percy/cli-command": "1.12.0",
-    "@percy/cli-config": "1.12.0",
-    "@percy/cli-exec": "1.12.0",
-    "@percy/cli-snapshot": "1.12.0",
-    "@percy/cli-upload": "1.12.0",
-    "@percy/client": "1.12.0",
-    "@percy/logger": "1.12.0"
+    "@percy/cli-app": "1.14.0",
+    "@percy/cli-build": "1.14.0",
+    "@percy/cli-command": "1.14.0",
+    "@percy/cli-config": "1.14.0",
+    "@percy/cli-exec": "1.14.0",
+    "@percy/cli-snapshot": "1.14.0",
+    "@percy/cli-upload": "1.14.0",
+    "@percy/client": "1.14.0",
+    "@percy/logger": "1.14.0"
   },
-  "gitHead": "4303b74df91f60e36065141289d2ef2277d1d6fc"
+  "gitHead": "fd72688e449d6dd3eafd346fc07879cb3bb01a4e"
 }