@percy/config 1.12.0 → 1.13.0

package/dist/defaults.js

@@ -6,9 +6,10 @@ const {
 const {
   assign,
   entries
-} = Object; // Recursively walks a schema and collects defaults. When no schema is provided,
-// the default config schema is used.
+} = Object;
 
+// Recursively walks a schema and collects defaults. When no schema is provided,
+// the default config schema is used.
 function getDefaultsFromSchema(schema) {
   if (!schema || typeof schema.$ref === 'string') {
     // get the schema from ajv
@@ -28,7 +29,6 @@ function getDefaultsFromSchema(schema) {
     return undefined;
   }
 }
-
 export function getDefaults(overrides = {}) {
   return merge([getDefaultsFromSchema(), overrides], (path, prev, next) => {
     // override default array instead of merging

package/dist/index.js

@@ -2,8 +2,10 @@ import load, { search } from './load.js';
 import validate, { addSchema } from './validate.js';
 import migrate, { addMigration } from './migrate.js';
 import { merge, normalize, stringify } from './utils/index.js';
-import getDefaults from './defaults.js'; // public config API
+import getDefaults from './defaults.js';
 
-export { load, search, validate, addSchema, migrate, addMigration, getDefaults, merge, normalize, stringify }; // export the namespace by default
+// public config API
+export { load, search, validate, addSchema, migrate, addMigration, getDefaults, merge, normalize, stringify };
 
+// export the namespace by default
 export * as default from './index.js';

package/dist/load.js

@@ -5,15 +5,18 @@ import logger from '@percy/logger';
 import migrate from './migrate.js';
 import validate from './validate.js';
 import getDefaults from './defaults.js';
-import { inspect, normalize } from './utils/index.js'; // Loaded configuration file cache
+import { inspect, normalize } from './utils/index.js';
 
-export const cache = new Map(); // The cosmiconfig explorer used to load config files
+// Loaded configuration file cache
+export const cache = new Map();
 
+// The cosmiconfig explorer used to load config files
 export const explorer = cosmiconfigSync('percy', {
   cache: false,
   searchPlaces: ['package.json', '.percyrc', '.percy.json', '.percy.yaml', '.percy.yml', '.percy.js', '.percy.cjs', 'percy.config.js', 'percy.config.cjs']
-}); // Searches within a provided directory, or loads the provided config path
+});
 
+// Searches within a provided directory, or loads the provided config path
 export function search(path) {
   try {
     let result = path && !fs.statSync(path).isDirectory() ? explorer.load(path) : explorer.search(path);
@@ -21,7 +24,9 @@ export function search(path) {
   } catch (error) {
     if (error.code === 'ENOENT') return {};else throw error;
   }
-} // Finds and loads a config file using cosmiconfig, merges it with optional
+}
+
+// Finds and loads a config file using cosmiconfig, merges it with optional
 // inputs, validates the combined config according to the schema, and returns
 // the combined config. Loaded config files are cached and reused on next load,
 // unless `reload` is true in which the file will be reloaded and the cache
@@ -29,7 +34,6 @@ export function search(path) {
 // unless `bail` is true. Supports kebab-case and camelCase config options and
 // always returns camelCase options. Will automatically convert older config
 // versions to the latest version while printing a warning.
-
 export function load({
   path,
   overrides = {},
@@ -38,21 +42,19 @@ export function load({
   print = false
 } = {}) {
   var _Array$from;
-
   // load cached config; when no path is specified, get the last config cached
   let config = path ? cache.get(path) : (_Array$from = Array.from(cache)[cache.size - 1]) === null || _Array$from === void 0 ? void 0 : _Array$from[1];
   let infoDebug = print ? 'info' : 'debug';
   let errorDebug = print ? 'error' : 'debug';
-  let log = logger('config'); // load config or reload cached config
+  let log = logger('config');
 
+  // load config or reload cached config
   if (path !== false && (!config || reload)) {
     try {
       let result = search(path);
-
       if (result !== null && result !== void 0 && result.config) {
         log[infoDebug](`Found config file: ${relative('', result.filepath)}`);
         let version = parseInt(result.config.version, 10);
-
         if (Number.isNaN(version)) {
           log.warn('Ignoring config file - missing or invalid version');
         } else if (version > 2) {
@@ -61,7 +63,6 @@ export function load({
           if (version < 2) {
             log.warn('Found older config file version, please run ' + '`percy config:migrate` to update to the latest version');
           }
-
           config = migrate(result.config);
           cache.set(path, config);
         }
@@ -73,28 +74,24 @@ export function load({
       log[errorDebug](error);
       if (bail) return;
     }
-  } // normalize and merge with overrides then validate
-
+  }
 
+  // normalize and merge with overrides then validate
   config = normalize(config, {
     overrides,
     schema: '/config'
   });
   let errors = config && validate(config);
-
   if (errors) {
     log.warn('Invalid config:');
-
     for (let e of errors) log.warn(`- ${e.path}: ${e.message}`);
-
     if (bail) return;
   }
-
   if (path !== false && config) {
     log[infoDebug](`Using config:\n${inspect(config)}`);
-  } // merge with defaults
-
+  }
 
+  // merge with defaults
   return getDefaults(config);
 }
 export default load;

package/dist/migrate.js

@@ -1,34 +1,36 @@
 import logger from '@percy/logger';
-import { get, set, del, map, joinPropertyPath, normalize } from './utils/index.js'; // Global set of registered migrations
+import { get, set, del, map, joinPropertyPath, normalize } from './utils/index.js';
 
-const migrations = new Map(); // Register a migration function for the main config schema by default
+// Global set of registered migrations
+const migrations = new Map();
 
+// Register a migration function for the main config schema by default
 export function addMigration(migration, schema = '/config') {
   if (Array.isArray(migration)) {
     return migration.map(m => addMigration(m, schema));
   } else if (typeof migration !== 'function') {
     return Object.entries(migration).map(([s, m]) => addMigration(m, s));
   }
-
   if (!migrations.has(schema)) migrations.set(schema, []);
   migrations.get(schema).unshift(migration);
   return migration;
-} // Clear all migration functions
+}
 
+// Clear all migration functions
 export function clearMigrations() {
   migrations.clear();
   addMigration(defaultMigration);
-} // The default config migration
+}
 
+// The default config migration
 addMigration(defaultMigration);
-
 function defaultMigration(config, {
   set
 }) {
   if (config.version !== 2) set('version', 2);
-} // Migrate util for deprecated options
-
+}
 
+// Migrate util for deprecated options
 function deprecate(config, log, path, options) {
   if (get(config, path) == null) return;
   let {
@@ -43,15 +45,14 @@ function deprecate(config, log, path, options) {
   let message = 'The ' + [type ? `${type} option \`${name}\`` : `\`${name}\` option`, `will be removed in ${ver || 'a future release'}.`, to ? `Use \`${to}\` instead.` : alt || ''].join(' ').trim();
   if (warn) log.warn(`Warning: ${message}`);else log.deprecated(message);
   return to ? map(config, path, to) : config;
-} // Calls each registered migration function with a normalize provided config
-// and util functions for working with the config object
-
+}
 
+// Calls each registered migration function with a normalize provided config
+// and util functions for working with the config object
 export function migrate(config, schema = '/config') {
   config = normalize(config, {
     schema
   }) ?? {};
-
   if (migrations.has(schema)) {
     let log = logger('config');
     let util = {
@@ -61,17 +62,15 @@ export function migrate(config, schema = '/config') {
       del: del.bind(null, config),
       log
     };
-
     for (let migration of migrations.get(schema)) {
       migration(config, util);
-    } // normalize again to adjust for migrations
-
+    }
 
+    // normalize again to adjust for migrations
     config = normalize(config, {
       schema
     });
   }
-
   return config;
 }
 export default migrate;

package/dist/utils/merge.js

@@ -6,23 +6,25 @@ const {
 } = Number;
 const {
   entries
-} = Object; // Creates an empty object or array
+} = Object;
 
+// Creates an empty object or array
 function create(array) {
   return array ? [] : {};
-} // Returns true or false if a subject has iterable keys or not
-
+}
 
+// Returns true or false if a subject has iterable keys or not
 function hasKeys(subj) {
   return isArray(subj) || Object.getPrototypeOf(subj) === Object.prototype;
-} // Returns true if the provided key looks like an array key
-
+}
 
+// Returns true if the provided key looks like an array key
 const ARRAY_PATH_KEY_REG = /^(\[\d+]|0|[1-9]\d*)$/;
 export function isArrayKey(key) {
   return isInteger(key) || ARRAY_PATH_KEY_REG.test(key);
-} // Split a property path string by dot or array notation
+}
 
+// Split a property path string by dot or array notation
 export function parsePropertyPath(path) {
   return isArray(path) ? path : path.split('.').reduce((full, part) => {
     return full.concat(part.split('[').reduce((f, p) => {
@@ -30,25 +32,25 @@ export function parsePropertyPath(path) {
       return f.concat(isArrayKey(p) ? parseInt(p, 10) : p || []);
     }, []));
   }, []);
-} // Join an array of path parts into a single path string
+}
 
+// Join an array of path parts into a single path string
 export function joinPropertyPath(path) {
   path = !Array.isArray(path) ? path : path.filter(Boolean).map(k => isArrayKey(k) ? `[${k}]` : `.${k}`).join('');
-
   while ((_path = path) !== null && _path !== void 0 && _path.startsWith('.')) {
     var _path;
-
     path = path.substr(1);
   }
-
   return path;
-} // Gets a value in the object at the path
+}
 
+// Gets a value in the object at the path
 export function get(object, path, find) {
   return parsePropertyPath(path).reduce((target, key) => target === null || target === void 0 ? void 0 : target[key], object);
-} // Sets a value to the object at the path creating any necessary nested
-// objects or arrays along the way
+}
 
+// Sets a value to the object at the path creating any necessary nested
+// objects or arrays along the way
 export function set(object, path, value) {
   return parsePropertyPath(path).reduce((target, key, index, path) => {
     if (index < path.length - 1) {
@@ -59,8 +61,9 @@ export function set(object, path, value) {
       return object;
     }
   }, object);
-} // Deletes properties from an object at the paths
+}
 
+// Deletes properties from an object at the paths
 export function del(object, ...paths) {
   return paths.reduce((object, path) => {
     return parsePropertyPath(path).reduce((target, key, index, path) => {
@@ -72,36 +75,34 @@ export function del(object, ...paths) {
       }
     }, object);
   }, object);
-} // Maps a value from one path to another, deleting the first path
+}
 
+// Maps a value from one path to another, deleting the first path
 export function map(object, from, to, transform = v => v) {
   return set(object, to, transform(parsePropertyPath(from).reduce((target, key, index, path) => {
     let value = target === null || target === void 0 ? void 0 : target[key];
-
     if (index === path.length - 1) {
       target === null || target === void 0 ? true : delete target[key];
     }
-
     return value;
   }, object)));
-} // Steps through an object's properties calling the function with the path and value of each
+}
 
+// Steps through an object's properties calling the function with the path and value of each
 function walk(object, fn, path = [], visited = new Set()) {
   if (path.length && fn([...path], object) === false) return;
   if (visited.has(object)) return;
   visited.add(object);
-
   if (object != null && typeof object === 'object') {
     let isArrayObject = isArray(object);
-
     for (let [key, value] of entries(object)) {
       if (isArrayObject) key = parseInt(key, 10);
       walk(value, fn, [...path, key], new Set(visited));
     }
   }
-} // Recursively mutate and filter empty values from arrays and objects
-
+}
 
+// Recursively mutate and filter empty values from arrays and objects
 export function filterEmpty(subject) {
   if (typeof subject === 'object') {
     if (isArray(subject)) {
@@ -110,7 +111,6 @@ export function filterEmpty(subject) {
           subject.splice(i--, 1);
         }
       }
-
       return subject.length > 0;
     } else {
       for (let k in subject) {
@@ -118,51 +118,51 @@ export function filterEmpty(subject) {
           delete subject[k];
         }
       }
-
       return entries(subject).length > 0;
     }
   } else {
     return subject != null;
   }
-} // Merges source values and returns a new merged value. The map function will be called with a
+}
+
+// Merges source values and returns a new merged value. The map function will be called with a
 // property's path, previous value, and next value; it should return an array containing any
 // replacement path and value; when a replacement value not defined, values will be merged.
-
 export function merge(sources, map) {
   return sources.reduce((target, source, i) => {
     let isSourceArray = isArray(source);
     walk(source, (path, value) => {
       var _ctx;
-
       let ctx = get(target, path.slice(0, -1));
       let key = path[path.length - 1];
-      let prev = (_ctx = ctx) === null || _ctx === void 0 ? void 0 : _ctx[key]; // maybe map the property path and/or value
+      let prev = (_ctx = ctx) === null || _ctx === void 0 ? void 0 : _ctx[key];
 
-      let [mapped, next] = (map === null || map === void 0 ? void 0 : map(path, prev, value)) || []; // update the context and path if changed
+      // maybe map the property path and/or value
+      let [mapped, next] = (map === null || map === void 0 ? void 0 : map(path, prev, value)) || [];
 
+      // update the context and path if changed
       if (mapped !== null && mapped !== void 0 && mapped.some((m, i) => m !== path[i])) {
         ctx = get(target, mapped.slice(0, -1));
         path = [...mapped];
-      } // adjust path to concat array values when necessary
-
+      }
 
+      // adjust path to concat array values when necessary
       if (next !== null && (isArray(ctx) || isInteger(key))) {
         var _ctx2;
-
         path.splice(-1, 1, ((_ctx2 = ctx) === null || _ctx2 === void 0 ? void 0 : _ctx2.length) ?? 0);
-      } // delete prev values
-
+      }
 
+      // delete prev values
       if (next === null || next == null && value === null) {
         del(target, path);
-      } // set the next or default value if there is one
-
+      }
 
+      // set the next or default value if there is one
       if (next != null || next !== null && value != null && !hasKeys(value)) {
         set(target ?? (target = create(isSourceArray)), path, next ?? value);
-      } // do not recurse mapped objects
-
+      }
 
+      // do not recurse mapped objects
       return next === undefined;
     });
     return target;

package/dist/utils/normalize.js

@@ -1,53 +1,55 @@
 import merge from './merge.js';
-import { getSchema } from '../validate.js'; // Edge case camelizations
+import { getSchema } from '../validate.js';
 
-const CAMELCASE_MAP = new Map([['css', 'CSS'], ['javascript', 'JavaScript']]); // Regular expression that matches words from boundaries or consecutive casing
+// Edge case camelizations
+const CAMELCASE_MAP = new Map([['css', 'CSS'], ['javascript', 'JavaScript']]);
 
-const WORD_REG = /[a-z]{2,}|[A-Z]{2,}|[0-9]{2,}|[^-_\s]+?(?=[A-Z0-9-_\s]|$)/g; // Converts kebab-cased and snake_cased strings to camelCase.
+// Regular expression that matches words from boundaries or consecutive casing
+const WORD_REG = /[a-z]{2,}|[A-Z]{2,}|[0-9]{2,}|[^-_\s]+?(?=[A-Z0-9-_\s]|$)/g;
 
+// Converts kebab-cased and snake_cased strings to camelCase.
 export function camelcase(str) {
   if (typeof str !== 'string') return str;
   return str.match(WORD_REG).reduce((s, w, i) => s + (i ? CAMELCASE_MAP.get(w.toLowerCase()) || w[0].toUpperCase() + w.slice(1).toLowerCase() : w.toLowerCase()), '');
-} // Coverts camelCased and snake_cased strings to kebab-case.
+}
 
+// Coverts camelCased and snake_cased strings to kebab-case.
 export function kebabcase(str) {
   if (typeof str !== 'string') return str;
   return Array.from(CAMELCASE_MAP).reduce((str, [word, camel]) => str.replace(camel, `-${word}`), str).match(WORD_REG).join('-').toLowerCase();
-} // Coverts kebab-case and camelCased strings to snake_case.
+}
 
+// Coverts kebab-case and camelCased strings to snake_case.
 export function snakecase(str) {
   if (typeof str !== 'string') return str;
   return Array.from(CAMELCASE_MAP).reduce((str, [word, camel]) => str.replace(camel, `_${word}`), str).match(WORD_REG).join('_').toLowerCase();
-} // Removes undefined empty values and renames kebab-case properties to camelCase. Optionally
+}
+
+// Removes undefined empty values and renames kebab-case properties to camelCase. Optionally
 // allows deep merging with options.overrides, converting keys to kebab-case with options.kebab,
 // and normalizing against a schema with options.schema.
-
 export function normalize(object, options) {
   var _options, _options2, _options3;
-
   if (typeof options === 'string') options = {
     schema: options
   };
   let keycase = (_options = options) !== null && _options !== void 0 && _options.kebab ? kebabcase : (_options2 = options) !== null && _options2 !== void 0 && _options2.snake ? snakecase : camelcase;
   return merge([object, (_options3 = options) === null || _options3 === void 0 ? void 0 : _options3.overrides], (path, value) => {
     var _options4, _schemas$shift;
-
     let schemas = getSchema((_options4 = options) === null || _options4 === void 0 ? void 0 : _options4.schema, path.map(camelcase));
     let skip = ((_schemas$shift = schemas.shift()) === null || _schemas$shift === void 0 ? void 0 : _schemas$shift.normalize) === false;
-    let mapped = []; // skip normalizing paths of class instances
+    let mapped = [];
 
+    // skip normalizing paths of class instances
     if (!skip && typeof value === 'object' && value !== null && value !== void 0 && value.constructor) {
       skip = Object.getPrototypeOf(value) !== Object.prototype;
     }
-
     for (let [i, k] of path.entries()) {
-      var _options5, _options5$skip, _schemas$i;
-
-      skip || (skip = (_options5 = options) === null || _options5 === void 0 ? void 0 : (_options5$skip = _options5.skip) === null || _options5$skip === void 0 ? void 0 : _options5$skip.call(_options5, mapped.concat(k)));
+      var _options5, _options5$skip, _options6, _schemas$i;
+      skip || (skip = (_options5 = options) === null || _options5 === void 0 ? void 0 : (_options5$skip = (_options6 = _options5).skip) === null || _options5$skip === void 0 ? void 0 : _options5$skip.call(_options6, mapped.concat(k)));
       mapped.push(skip ? k : keycase(k));
       skip || (skip = ((_schemas$i = schemas[i]) === null || _schemas$i === void 0 ? void 0 : _schemas$i.normalize) === false);
     }
-
     return [mapped];
   });
 }

package/dist/utils/stringify.js

@@ -1,27 +1,26 @@
 import util from 'util';
 import YAML from 'yaml';
-import getDefaults from '../defaults.js'; // Provides native util.inspect with common options for printing configs.
+import getDefaults from '../defaults.js';
 
+// Provides native util.inspect with common options for printing configs.
 export function inspect(config) {
   return util.inspect(config, {
     depth: null,
     compact: false
   });
-} // Converts a config to a yaml, json, or js string. When no config is provided,
-// falls back to schema defaults.
+}
 
+// Converts a config to a yaml, json, or js string. When no config is provided,
+// falls back to schema defaults.
 export function stringify(format, config = getDefaults()) {
   switch (format) {
     case 'yml':
     case 'yaml':
       return YAML.stringify(config);
-
     case 'json':
       return JSON.stringify(config, null, 2) + '\n';
-
     case 'js':
       return `module.exports = ${inspect(config)}\n`;
-
     default:
       throw new Error(`Unsupported format: ${format}`);
   }

package/dist/validate.js

@@ -6,8 +6,9 @@ const {
 const {
   assign,
   entries
-} = Object; // AJV manages and validates schemas.
+} = Object;
 
+// AJV manages and validates schemas.
 const ajv = new AJV({
   strict: false,
   verbose: true,
@@ -43,7 +44,6 @@ const ajv = new AJV({
         gen,
         schema
       } = cxt;
-
       for (let prop of schema) {
         gen.if(AJV._`${data}.${AJV._([prop])} !== undefined`, () => {
           cxt.setParams({
@@ -54,8 +54,9 @@ const ajv = new AJV({
       }
     }
   }]
-}); // Returns a new default schema.
+});
 
+// Returns a new default schema.
 function getDefaultSchema() {
   return {
     $id: '/config',
@@ -68,28 +69,28 @@ function getDefaultSchema() {
       }
     }
   };
-} // Gets the schema object from the AJV schema. If a path is provided, an array of schemas is
-// returned, with each index representing the schema of each part of the path (index zero is root).
-
+}
 
+// Gets the schema object from the AJV schema. If a path is provided, an array of schemas is
+// returned, with each index representing the schema of each part of the path (index zero is root).
 export function getSchema(name, path, root) {
   var _ajv$getSchema, _ref, _schema$properties;
-
   // get the root schema if necessary, resolve it, and return it when there is no path
   let schema = typeof name === 'string' ? (_ajv$getSchema = ajv.getSchema(name)) === null || _ajv$getSchema === void 0 ? void 0 : _ajv$getSchema.schema : name;
   if (!schema || !path) return schema ?? [];
-  root ?? (root = schema); // parse and work with one key at a time
+  root ?? (root = schema);
 
-  let [key, ...rest] = path = parsePropertyPath(path); // if the desired schema is one of many, we need to find the best match
+  // parse and work with one key at a time
+  let [key, ...rest] = path = parsePropertyPath(path);
 
+  // if the desired schema is one of many, we need to find the best match
   let many = (_ref = isArray(schema) ? schema : schema === null || schema === void 0 ? void 0 : schema[['anyOf', 'oneOf', 'allOf'].find(p => schema[p])]) === null || _ref === void 0 ? void 0 : _ref.map(p => getSchema(p, path, root)).sort((a, b) => {
     var _a$;
-
-    return (// the best possible match will match most of the path or loosely match
+    return (
+      // the best possible match will match most of the path or loosely match
       b.length - a.length || (((_a$ = a[0]) === null || _a$ === void 0 ? void 0 : _a$.type) === 'object' && (a[0].additionalProperties !== false || a[0].unevaluatedProperties !== false) ? -1 : 1)
     );
   })[0];
-
   if (many !== null && many !== void 0 && many.length) {
     return many;
   } else if ((schema === null || schema === void 0 ? void 0 : schema.type) === 'array' && isArrayKey(key)) {
@@ -109,16 +110,16 @@ export function getSchema(name, path, root) {
     // no match
     return [];
   }
-} // Adds schemas to the config schema's properties. The config schema is removed, modified, and
+}
+
+// Adds schemas to the config schema's properties. The config schema is removed, modified, and
 // replaced after the new schemas are added to clear any compiled caches. Existing schemas are
 // removed and replaced as well. If a schema has an existing $id, the schema will not be added
 // as config schema properties.
-
 export function addSchema(schemas) {
   if (isArray(schemas)) {
     return schemas.map(addSchema);
   }
-
   if (schemas.$id) {
     let {
       $id
@@ -126,10 +127,8 @@ export function addSchema(schemas) {
     if (ajv.getSchema($id)) ajv.removeSchema($id);
     return ajv.addSchema(schemas);
   }
-
   let config = getSchema('/config');
   ajv.removeSchema('/config');
-
   for (let [key, schema] of entries(schemas)) {
     if (key === '$config') {
       assign(config, typeof schema === 'function' ? schema(config) : schema);
@@ -144,42 +143,39 @@ export function addSchema(schemas) {
       ajv.addSchema(schema, $id);
     }
   }
-
   return ajv.addSchema(config, '/config');
-} // Resets the schema by removing all schemas and inserting a new default schema.
+}
 
+// Resets the schema by removing all schemas and inserting a new default schema.
 export function resetSchema() {
   ajv.removeSchema();
   ajv.addSchema(getDefaultSchema(), '/config');
-} // Adds "a" or "an" to a word for readability.
+}
 
+// Adds "a" or "an" to a word for readability.
 function a(word) {
   if (word === 'undefined' || word === 'null') return word;
   return `${'aeiou'.includes(word[0]) ? 'an' : 'a'} ${word}`;
-} // Default errors anywhere within these keywords can be confusing
-
+}
 
+// Default errors anywhere within these keywords can be confusing
 const HIDE_NESTED_KEYWORDS = ['oneOf', 'anyOf', 'allOf', 'if', 'then', 'else', 'not'];
-
 function shouldHideError(key, path, error) {
   var _parentSchema$errors;
-
   let {
     parentSchema,
     keyword,
     schemaPath
   } = error;
   return !(parentSchema.error || (_parentSchema$errors = parentSchema.errors) !== null && _parentSchema$errors !== void 0 && _parentSchema$errors[keyword]) && HIDE_NESTED_KEYWORDS.some(k => schemaPath.includes(`/${k}`));
-} // Validates data according to the associated schema and returns a list of errors, if any.
-
+}
 
+// Validates data according to the associated schema and returns a list of errors, if any.
 export function validate(data, key = '/config') {
   if (!ajv.validate(key, data)) {
     let errors = new Map();
-
     for (let error of ajv.errors) {
       var _parentSchema$errors2;
-
       let {
         instancePath,
         parentSchema,
@@ -188,8 +184,9 @@ export function validate(data, key = '/config') {
         params
       } = error;
       let path = instancePath ? instancePath.substr(1).split('/') : [];
-      if (shouldHideError(key, path, error)) continue; // generate a custom error message
+      if (shouldHideError(key, path, error)) continue;
 
+      // generate a custom error message
       if (parentSchema.error || (_parentSchema$errors2 = parentSchema.errors) !== null && _parentSchema$errors2 !== void 0 && _parentSchema$errors2[keyword]) {
         let custom = parentSchema.error || parentSchema.errors[keyword];
         message = typeof custom === 'function' ? custom(error) : custom;
@@ -200,9 +197,9 @@ export function validate(data, key = '/config') {
         message = 'missing required property';
       } else if (keyword === 'additionalProperties' || keyword === 'unevaluatedProperties') {
         message = 'unknown property';
-      } // fix paths
-
+      }
 
+      // fix paths
       if (params.missingProperty) {
         path.push(params.missingProperty);
       } else if (params.additionalProperty) {
@@ -211,9 +208,9 @@ export function validate(data, key = '/config') {
         path.push(params.unevaluatedProperty);
       } else if (params.disallowedProperty) {
         path.push(params.disallowedProperty);
-      } // fix invalid data
-
+      }
 
+      // fix invalid data
       if (keyword === 'minimum') {
         set(data, path, Math.max(error.data, error.schema));
       } else if (keyword === 'maximum') {
@@ -222,20 +219,22 @@ export function validate(data, key = '/config') {
         del(data, path.slice(0, -1));
       } else if (!params.passingSchemas) {
         del(data, path);
-      } // joined for error messages
-
+      }
 
-      path = joinPropertyPath(path); // map one error per path
+      // joined for error messages
+      path = joinPropertyPath(path);
 
+      // map one error per path
       errors.set(path, {
         path,
         message
       });
-    } // filter empty values as a result of scrubbing
-
+    }
 
-    filterEmpty(data); // return an array of errors
+    // filter empty values as a result of scrubbing
+    filterEmpty(data);
 
+    // return an array of errors
     return Array.from(errors.values());
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/config",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -34,7 +34,7 @@
     "test:types": "tsd"
   },
   "dependencies": {
-    "@percy/logger": "1.12.0",
+    "@percy/logger": "1.13.0",
     "ajv": "^8.6.2",
     "cosmiconfig": "^7.0.0",
     "yaml": "^2.0.0"
@@ -42,5 +42,5 @@
   "devDependencies": {
     "json-schema-typed": "^7.0.3"
   },
-  "gitHead": "4303b74df91f60e36065141289d2ef2277d1d6fc"
+  "gitHead": "d2e812d14aa446fa580ffa75144a6280627b5a27"
 }