@percy/config 1.0.0-beta.7 → 1.0.0-beta.73

package/README.md

@@ -1,13 +1,14 @@
-## @percy/config
+# @percy/config
 
 Handles loading and adding options to Percy configuration files. Uses
 [cosmiconfig](https://github.com/davidtheclark/cosmiconfig) to load configuration files and [JSON
 schema](https://json-schema.org/) with [AJV](https://github.com/epoberezkin/ajv) to validate those
 configuration files.
 
-## Usage
+- [Loading config files](#loading-config-files)
+- [Extending config options](#extending-config-options)
 
-### Loading config files
+## Loading config files
 
 The `.load()` method will load and validate a configuation file, optionally merging it with any
 provided `overrides`. If no `path` is provided, will search for the first supported config found
@@ -18,14 +19,17 @@ from the current directory up to the home directoy. Configuration files are cach
 import PercyConfig from '@percy/config'
 
 // loading is done synchronously
-const config = PercyConfig.load({
-  path,            // config file path or directory path containing a config file
-  overrides = {},  // configuration option overrides
-  reload = false,  // reload file and update cache
-  bail = false     // return undefined on validation warnings
-})
+const config = PercyConfig.load(options)
 ```
 
+#### Options
+
+- `path` — Config file path or directory containing a config file
+- `overrides` — Config option overrides
+- `reload` — Do not use cached config (**default** `false`)
+- `bail` — Return undefined when failing validation (**default** `false`)
+- `print` — Print info and error logs (**default** `false`)
+
 #### Supported files
 
 - `"percy"` entry in `package.json`
@@ -34,7 +38,7 @@ const config = PercyConfig.load({
 - `.percy.yaml` or `.percy.yml` YAML file
 - `.percy.js` or `percy.config.js` file that exports an object
 
-### Extending config options
+## Extending config options
 
 The `.addSchema()` function will add a sub-schema to the Percy configuration file which will be
 parsed and validated when `PercyConfig.load()` is called. See [JSON
@@ -43,5 +47,7 @@ schema](https://json-schema.org/) for possible schema options.
 ```js
 import PercyConfig from '@percy/config'
 
-PercyConfig.addSchema({ propertyName: JSONSchema })
+PercyConfig.addSchema({
+  propertyName: JSONSchema
+})
 ```

package/dist/defaults.js

@@ -3,46 +3,50 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = getDefaults;
+exports.default = void 0;
+exports.getDefaults = getDefaults;
 
-var _deepmerge = _interopRequireDefault(require("deepmerge"));
+var _utils = require("./utils");
 
 var _validate = require("./validate");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+const {
+  isArray
+} = Array;
 const {
   assign,
-  entries,
-  freeze
+  entries
 } = Object; // Recursively walks a schema and collects defaults. When no schema is provided,
-// the default config schema is used. Returned defaults are frozen.
+// the default config schema is used.
 
-function getDefaultFromSchema(schema) {
+function getDefaultsFromSchema(schema) {
   if (!schema || typeof schema.$ref === 'string') {
     var _schema$$ref;
 
     // get the schema from ajv
-    return getDefaultFromSchema((0, _validate.getSchema)((_schema$$ref = schema === null || schema === void 0 ? void 0 : schema.$ref) !== null && _schema$$ref !== void 0 ? _schema$$ref : 'config'));
+    return getDefaultsFromSchema((0, _validate.getSchema)((_schema$$ref = schema === null || schema === void 0 ? void 0 : schema.$ref) !== null && _schema$$ref !== void 0 ? _schema$$ref : '/config'));
   } else if (schema.default != null) {
-    // return the frozen default for this schema
-    return freeze(schema.default);
+    // return the default for this schema
+    return schema.default;
   } else if (schema.type === 'object' && schema.properties) {
-    // return a frozen object of default properties
-    return freeze(entries(schema.properties).reduce((acc, [prop, schema]) => {
-      let def = getDefaultFromSchema(schema);
+    // return an object of default properties
+    return entries(schema.properties).reduce((acc, [prop, schema]) => {
+      let def = getDefaultsFromSchema(schema);
       return def != null ? assign(acc || {}, {
         [prop]: def
       }) : acc;
-    }, undefined));
+    }, undefined);
   } else {
     return undefined;
   }
 }
 
 function getDefaults(overrides = {}) {
-  return _deepmerge.default.all([getDefaultFromSchema(), overrides], {
-    // overwrite default arrays, do not merge
-    arrayMerge: (_, arr) => arr
+  return (0, _utils.merge)([getDefaultsFromSchema(), overrides], (path, prev, next) => {
+    // override default array instead of merging
+    return isArray(next) && [path, next];
   });
-}
+}
+
+var _default = getDefaults;
+exports.default = _default;

package/dist/index.js

@@ -3,31 +3,118 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "addMigration", {
+  enumerable: true,
+  get: function () {
+    return _migrate.addMigration;
+  }
+});
+Object.defineProperty(exports, "addSchema", {
+  enumerable: true,
+  get: function () {
+    return _validate.addSchema;
+  }
+});
+Object.defineProperty(exports, "cache", {
+  enumerable: true,
+  get: function () {
+    return _load.cache;
+  }
+});
+Object.defineProperty(exports, "clearMigrations", {
+  enumerable: true,
+  get: function () {
+    return _migrate.clearMigrations;
+  }
+});
 exports.default = void 0;
+Object.defineProperty(exports, "explorer", {
+  enumerable: true,
+  get: function () {
+    return _load.explorer;
+  }
+});
+Object.defineProperty(exports, "getDefaults", {
+  enumerable: true,
+  get: function () {
+    return _defaults.default;
+  }
+});
+Object.defineProperty(exports, "load", {
+  enumerable: true,
+  get: function () {
+    return _load.default;
+  }
+});
+Object.defineProperty(exports, "migrate", {
+  enumerable: true,
+  get: function () {
+    return _migrate.default;
+  }
+});
+Object.defineProperty(exports, "normalize", {
+  enumerable: true,
+  get: function () {
+    return _normalize.default;
+  }
+});
+Object.defineProperty(exports, "resetSchema", {
+  enumerable: true,
+  get: function () {
+    return _validate.resetSchema;
+  }
+});
+Object.defineProperty(exports, "search", {
+  enumerable: true,
+  get: function () {
+    return _load.search;
+  }
+});
+Object.defineProperty(exports, "stringify", {
+  enumerable: true,
+  get: function () {
+    return _stringify.default;
+  }
+});
+Object.defineProperty(exports, "validate", {
+  enumerable: true,
+  get: function () {
+    return _validate.default;
+  }
+});
 
 var _load = _interopRequireWildcard(require("./load"));
 
 var _validate = _interopRequireWildcard(require("./validate"));
 
+var _migrate = _interopRequireWildcard(require("./migrate"));
+
 var _defaults = _interopRequireDefault(require("./defaults"));
 
+var _normalize = _interopRequireDefault(require("./normalize"));
+
 var _stringify = _interopRequireDefault(require("./stringify"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-// Export a single object that can be imported as PercyConfig
+// mirror the namespace as the default export
 var _default = {
   load: _load.default,
+  search: _load.search,
   cache: _load.cache,
   explorer: _load.explorer,
   validate: _validate.default,
   addSchema: _validate.addSchema,
   resetSchema: _validate.resetSchema,
+  migrate: _migrate.default,
+  addMigration: _migrate.addMigration,
+  clearMigrations: _migrate.clearMigrations,
   getDefaults: _defaults.default,
+  normalize: _normalize.default,
   stringify: _stringify.default
 };
 exports.default = _default;

package/dist/load.js

@@ -3,27 +3,28 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = load;
-exports.explorer = exports.cache = void 0;
+exports.explorer = exports.default = exports.cache = void 0;
+exports.load = load;
+exports.search = search;
 
 var _path = require("path");
 
-var _cosmiconfig = require("cosmiconfig");
-
-var _pathType = require("path-type");
+var _fs = require("fs");
 
-var _deepmerge = _interopRequireDefault(require("deepmerge"));
+var _cosmiconfig = require("cosmiconfig");
 
 var _logger = _interopRequireDefault(require("@percy/logger"));
 
 var _defaults = _interopRequireDefault(require("./defaults"));
 
-var _normalize = _interopRequireDefault(require("./normalize"));
+var _migrate = _interopRequireDefault(require("./migrate"));
 
-var _validate = _interopRequireDefault(require("./validate"));
+var _normalize = _interopRequireDefault(require("./normalize"));
 
 var _stringify = require("./stringify");
 
+var _validate = _interopRequireDefault(require("./validate"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 // Loaded configuration file cache
@@ -33,60 +34,94 @@ exports.cache = cache;
 const explorer = (0, _cosmiconfig.cosmiconfigSync)('percy', {
   cache: false,
   searchPlaces: ['package.json', '.percyrc', '.percy.json', '.percy.yaml', '.percy.yml', '.percy.js', 'percy.config.js']
-}); // Finds and loads a config file using cosmiconfig, merges it with optional
+}); // Searches within a provided directory, or loads the provided config path
+
+exports.explorer = explorer;
+
+function search(path) {
+  try {
+    let result = path && !(0, _fs.statSync)(path).isDirectory() ? explorer.load(path) : explorer.search(path);
+    return result || {};
+  } catch (error) {
+    if (error.code === 'ENOENT') return {};else throw error;
+  }
+} // 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
 // updated. Validation errors are logged as warnings and the config is returned
 // unless `bail` is true. Supports kebab-case and camelCase config options and
-// always returns camelCase options. Currently only supports version 2 config
-// files; missing versions or other versions are discarded.
+// always returns camelCase options. Will automatically convert older config
+// versions to the latest version while printing a warning.
 
-exports.explorer = explorer;
 
 function load({
   path,
   overrides = {},
   reload = false,
-  bail = false
+  bail = false,
+  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]; // load config or reload cached config
+  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 = (0, _logger.default)('config'); // load config or reload cached config
 
   if (path !== false && (!config || reload)) {
     try {
-      let result = !path || (0, _pathType.isDirectorySync)(path) ? explorer.search(path) : explorer.load(path);
+      let result = search(path);
 
-      if (result && result.config) {
-        _logger.default.debug(`Found config file: ${(0, _path.relative)('', result.filepath)}`);
+      if (result !== null && result !== void 0 && result.config) {
+        log[infoDebug](`Found config file: ${(0, _path.relative)('', result.filepath)}`);
+        let version = parseInt(result.config.version, 10);
 
-        if (result.config.version !== 2) {
-          _logger.default.warn('Ignoring config file - ' + (!result.config.version ? 'missing version' : 'unsupported version'));
+        if (Number.isNaN(version)) {
+          log.warn('Ignoring config file - missing or invalid version');
+        } else if (version > 2) {
+          log.warn(`Ignoring config file - unsupported version "${version}"`);
         } else {
-          // normalize to remove empty values and convert snake-case to camelCase
-          config = (0, _normalize.default)(result.config);
+          if (version < 2) {
+            log.warn('Found older config file version, please run ' + '`percy config:migrate` to update to the latest version');
+          }
+
+          config = (0, _migrate.default)(result.config);
           cache.set(path, config);
         }
       } else {
-        _logger.default.debug('Config file not found');
+        log[infoDebug]('Config file not found');
+        if (bail) return;
       }
     } catch (error) {
-      _logger.default.debug('Failed to load or parse config file');
-
-      _logger.default.debug(error.toString());
+      log[errorDebug](error);
+      if (bail) return;
     }
-  } // merge found config with overrides and validate
+  } // normalize and merge with overrides then validate
+
 
+  config = (0, _normalize.default)(config, {
+    overrides,
+    schema: '/config'
+  });
+  let errors = config && (0, _validate.default)(config);
 
-  config = (0, _deepmerge.default)(config || {}, overrides);
-  if (!(0, _validate.default)(config, {
-    scrub: true
-  }) && bail) return; // normalize again to remove empty values from overrides and validation scrubbing
+  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${(0, _stringify.inspect)(config)}`);
+  } // merge with defaults
 
-  config = (0, _normalize.default)(config);
-  if (config) _logger.default.debug(`Using config:\n${(0, _stringify.inspect)(config)}`); // merge with defaults
 
   return (0, _defaults.default)(config);
-}
+}
+
+var _default = load;
+exports.default = _default;

package/dist/migrate.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addMigration = addMigration;
+exports.clearMigrations = clearMigrations;
+exports.default = void 0;
+exports.migrate = migrate;
+
+var _logger = _interopRequireDefault(require("@percy/logger"));
+
+var _normalize2 = _interopRequireDefault(require("./normalize"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Global set of registered migrations
+const migrations = new Map(); // Register a migration function for the main config schema by default
+
+function addMigration(migration, schema = '/config') {
+  if (Array.isArray(migration)) {
+    // accept schema as the first item in a tuple
+    if (typeof migration[0] === 'string') [schema, ...migration] = migration;
+    return migration.map(m => addMigration(m, schema));
+  }
+
+  if (!migrations.has(schema)) migrations.set(schema, []);
+  migrations.get(schema).unshift(migration);
+  return migration;
+} // Clear all migration functions
+
+
+function clearMigrations() {
+  migrations.clear();
+  addMigration(defaultMigration);
+} // The default config migration
+
+
+addMigration(defaultMigration);
+
+function defaultMigration(config, {
+  set
+}) {
+  if (config.version !== 2) set('version', 2);
+} // Migrate util for deprecated options
+
+
+function deprecate(config, log, path, options) {
+  if ((0, _utils.get)(config, path) == null) return;
+  let {
+    type,
+    until: ver,
+    map: to,
+    alt,
+    warn
+  } = options;
+  let name = (0, _utils.joinPropertyPath)(path);
+  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 ? (0, _utils.map)(config, path, to) : config;
+} // Calls each registered migration function with a normalize provided config
+// and util functions for working with the config object
+
+
+function migrate(config, schema = '/config') {
+  var _normalize;
+
+  config = (_normalize = (0, _normalize2.default)(config, {
+    schema
+  })) !== null && _normalize !== void 0 ? _normalize : {};
+
+  if (migrations.has(schema)) {
+    let log = (0, _logger.default)('config');
+    let util = {
+      deprecate: deprecate.bind(null, config, log),
+      set: _utils.set.bind(null, config),
+      map: _utils.map.bind(null, config),
+      del: _utils.del.bind(null, config),
+      log
+    };
+
+    for (let migration of migrations.get(schema)) {
+      migration(config, util);
+    } // normalize again to adjust for migrations
+
+
+    config = (0, _normalize2.default)(config, {
+      schema
+    });
+  }
+
+  return config;
+}
+
+var _default = migrate;
+exports.default = _default;

package/dist/normalize.js

@@ -3,35 +3,53 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = normalize;
-
-// recursively reduces config objects and arrays to remove undefined and empty
-// values and rename kebab-case properties to camelCase.
-function normalize(subject) {
-  if (typeof subject === 'object') {
-    let isArray = Array.isArray(subject);
-    return Object.entries(subject).reduce((result, [key, value]) => {
-      value = normalize(value);
-
-      if (typeof value !== 'undefined') {
-        return isArray ? (result || []).concat(value) : Object.assign(result || {}, {
-          [camelize(key)]: value
-        });
-      } else {
-        return result;
-      }
-    }, undefined);
-  } else {
-    return subject;
-  }
-} // Edge case camelizations
-
-
-const CAMELIZE_MAP = {
-  css: 'CSS',
-  javascript: 'JavaScript'
-}; // Converts a kebab-cased string to camelCase.
-
-function camelize(s) {
-  return s.replace(/-([^-]+)/g, (_, w) => CAMELIZE_MAP[w] || w[0].toUpperCase() + w.slice(1));
-}
+exports.camelcase = camelcase;
+exports.default = void 0;
+exports.kebabcase = kebabcase;
+exports.normalize = normalize;
+
+var _validate = require("./validate");
+
+var _utils = require("./utils");
+
+// Edge case camelizations
+const CAMELCASE_MAP = new Map([['css', 'CSS'], ['javascript', 'JavaScript']]); // Converts kebab-cased and snake_cased strings to camelCase.
+
+const KEBAB_SNAKE_REG = /[-_]([^-_]+)/g;
+
+function camelcase(str) {
+  if (typeof str !== 'string') return str;
+  return str.replace(KEBAB_SNAKE_REG, (match, word) => CAMELCASE_MAP.get(word) || word[0].toUpperCase() + word.slice(1));
+} // Coverts camelCased and snake_cased strings to kebab-case.
+
+
+const CAMEL_SNAKE_REG = /([a-z])([A-Z]+)|_([^_]+)/g;
+
+function kebabcase(str) {
+  if (typeof str !== 'string') return str;
+  return Array.from(CAMELCASE_MAP).reduce((str, [word, camel]) => str.replace(camel, `-${word}`), str).replace(CAMEL_SNAKE_REG, (match, p, n, w) => `${p || ''}-${(n || w).toLowerCase()}`);
+} // 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.
+
+
+function normalize(object, options) {
+  let keycase = options !== null && options !== void 0 && options.kebab ? kebabcase : camelcase;
+  return (0, _utils.merge)([object, options === null || options === void 0 ? void 0 : options.overrides], path => {
+    var _schemas$shift;
+
+    let schemas = (0, _validate.getSchema)(options === null || options === void 0 ? void 0 : options.schema, path.map(camelcase));
+    let skip = ((_schemas$shift = schemas.shift()) === null || _schemas$shift === void 0 ? void 0 : _schemas$shift.normalize) === false;
+    path = path.map((k, i) => {
+      var _schemas$i;
+
+      if (skip) return k;
+      skip || (skip = ((_schemas$i = schemas[i]) === null || _schemas$i === void 0 ? void 0 : _schemas$i.normalize) === false);
+      return keycase(k);
+    });
+    return [path];
+  });
+}
+
+var _default = normalize;
+exports.default = _default;

package/dist/stringify.js

@@ -3,8 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.default = void 0;
 exports.inspect = inspect;
-exports.default = stringify;
+exports.stringify = stringify;
 
 var _util = _interopRequireDefault(require("util"));
 
@@ -31,12 +32,15 @@ function stringify(format, config = (0, _defaults.default)()) {
       return _yaml.default.stringify(config);
 
     case 'json':
-      return JSON.stringify(config, null, 2);
+      return JSON.stringify(config, null, 2) + '\n';
 
     case 'js':
-      return `module.exports = ${inspect(config)}`;
+      return `module.exports = ${inspect(config)}\n`;
 
     default:
       throw new Error(`Unsupported format: ${format}`);
   }
-}
+}
+
+var _default = stringify;
+exports.default = _default;

package/dist/utils.js

@@ -0,0 +1,190 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.del = del;
+exports.filterEmpty = filterEmpty;
+exports.get = get;
+exports.isArrayKey = isArrayKey;
+exports.joinPropertyPath = joinPropertyPath;
+exports.map = map;
+exports.merge = merge;
+exports.parsePropertyPath = parsePropertyPath;
+exports.set = set;
+const {
+  isArray
+} = Array;
+const {
+  isInteger
+} = Number;
+const {
+  entries
+} = Object; // Creates an empty object or array
+
+function create(array) {
+  return array ? [] : {};
+} // 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
+
+
+const ARRAY_PATH_KEY_REG = /^(\[\d+]|0|[1-9]\d*)$/;
+
+function isArrayKey(key) {
+  return isInteger(key) || ARRAY_PATH_KEY_REG.test(key);
+} // Split a property path string by dot or array notation
+
+
+function parsePropertyPath(path) {
+  return isArray(path) ? path : path.split('.').reduce((full, part) => {
+    return full.concat(part.split('[').reduce((f, p) => {
+      if (p.endsWith(']')) p = p.slice(0, -1);
+      return f.concat(isArrayKey(p) ? parseInt(p, 10) : p);
+    }, []));
+  }, []);
+} // Join an array of path parts into a single path string
+
+
+function joinPropertyPath(path) {
+  if (typeof path === 'string') return path;
+  let joined = path.map(k => isArrayKey(k) ? `[${k}]` : `.${k}`).join('');
+  if (joined.startsWith('.')) return joined.substr(1);
+  return joined;
+} // Gets a value in the object at the path
+
+
+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
+
+
+function set(object, path, value) {
+  return parsePropertyPath(path).reduce((target, key, index, path) => {
+    if (index < path.length - 1) {
+      var _target$key;
+
+      (_target$key = target[key]) !== null && _target$key !== void 0 ? _target$key : target[key] = create(isArrayKey(path[index + 1]));
+      return target[key];
+    } else {
+      target[key] = value;
+      return object;
+    }
+  }, object);
+} // Deletes properties from an object at the paths
+
+
+function del(object, ...paths) {
+  return paths.reduce((object, path) => {
+    return parsePropertyPath(path).reduce((target, key, index, path) => {
+      if (index < path.length - 1) {
+        return target === null || target === void 0 ? void 0 : target[key];
+      } else {
+        target === null || target === void 0 ? true : delete target[key];
+        return object;
+      }
+    }, object);
+  }, object);
+} // Maps a value from one path to another, deleting the first path
+
+
+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
+
+
+function walk(object, fn, path = []) {
+  if (path.length && fn([...path], object) === false) return;
+
+  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]);
+    }
+  }
+} // 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.
+
+
+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 [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
+
+
+      if (next !== null && (isArray(ctx) || isInteger(key))) {
+        var _ctx$length, _ctx2;
+
+        path.splice(-1, 1, (_ctx$length = (_ctx2 = ctx) === null || _ctx2 === void 0 ? void 0 : _ctx2.length) !== null && _ctx$length !== void 0 ? _ctx$length : 0);
+      } // delete prev values
+
+
+      if (next === null || next == null && value === null) {
+        del(target, path);
+      } // set the next or default value if there is one
+
+
+      if (next != null || next !== null && value != null && !hasKeys(value)) {
+        var _target;
+
+        set((_target = target) !== null && _target !== void 0 ? _target : target = create(isSourceArray), path, next !== null && next !== void 0 ? next : value);
+      } // do not recurse mapped objects
+
+
+      return next === undefined;
+    });
+    return target;
+  }, undefined);
+} // Recursively mutate and filter empty values from arrays and objects
+
+
+function filterEmpty(subject) {
+  if (typeof subject === 'object') {
+    if (isArray(subject)) {
+      for (let i = 0; i < subject.length; i++) {
+        if (!filterEmpty(subject[i])) {
+          subject.splice(i--, 1);
+        }
+      }
+
+      return subject.length > 0;
+    } else {
+      for (let k in subject) {
+        if (!filterEmpty(subject[k])) {
+          delete subject[k];
+        }
+      }
+
+      return entries(subject).length > 0;
+    }
+  } else {
+    return subject != null;
+  }
+}

package/dist/validate.js

@@ -3,32 +3,77 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getSchema = getSchema;
 exports.addSchema = addSchema;
+exports.default = void 0;
+exports.getSchema = getSchema;
 exports.resetSchema = resetSchema;
-exports.default = validate;
+exports.validate = validate;
 
 var _ajv = _interopRequireDefault(require("ajv"));
 
-var _logger = _interopRequireDefault(require("@percy/logger"));
+var _utils = require("./utils");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+const {
+  isArray
+} = Array;
 const {
   assign,
   entries
-} = Object; // Ajv manages and validates schemas.
+} = Object; // AJV manages and validates schemas.
 
 const ajv = new _ajv.default({
+  strict: false,
   verbose: true,
   allErrors: true,
-  schemas: {
-    config: getDefaultSchema()
-  }
+  schemas: [getDefaultSchema()],
+  keywords: [{
+    // custom instanceof schema validation
+    keyword: 'instanceof',
+    metaSchema: {
+      enum: ['Function', 'RegExp']
+    },
+    error: {
+      message: cxt => _ajv.default.str`must be an instanceof ${cxt.schemaCode}`,
+      params: cxt => _ajv.default._`{ instanceof: ${cxt.schemaCode} }`
+    },
+    code: cxt => cxt.fail(_ajv.default._`!(${cxt.data} instanceof ${_ajv.default._([cxt.schema])})`)
+  }, {
+    // disallowed validation based on required
+    keyword: 'disallowed',
+    metaSchema: {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    },
+    error: {
+      message: 'disallowed property',
+      params: cxt => _ajv.default._`{ disallowedProperty: ${cxt.params.disallowedProperty} }`
+    },
+    code: cxt => {
+      let {
+        data,
+        gen,
+        schema
+      } = cxt;
+
+      for (let prop of schema) {
+        gen.if(_ajv.default._`${data}.${_ajv.default._([prop])} !== undefined`, () => {
+          cxt.setParams({
+            disallowedProperty: _ajv.default._`${prop}`
+          }, true);
+          cxt.error();
+        });
+      }
+    }
+  }]
 }); // Returns a new default schema.
 
 function getDefaultSchema() {
   return {
+    $id: '/config',
     type: 'object',
     additionalProperties: false,
     properties: {
@@ -38,84 +83,174 @@ function getDefaultSchema() {
       }
     }
   };
-} // Gets the schema object from the AJV schema.
+} // 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).
+
 
+function getSchema(name, path, root) {
+  var _ajv$getSchema, _schema, _schema2, _schema3, _schema4;
+
+  // 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 = schema) !== null && _schema !== void 0 && _schema.$ref) {
+    let [name, ref = ''] = schema.$ref.split('#');
+    schema = (0, _utils.get)(getSchema(name || root), ref.split('/').slice(1));
+  }
 
-function getSchema(name) {
-  return ajv.getSchema(name).schema;
-} // 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 (!path) return schema; // destructure the path and set the default root schema for future refs
+
+  let [key, ...rest] = path = (0, _utils.parsePropertyPath)(path);
+  root || (root = schema); // if the desired schema is one of many, we need to find one that best matches
+
+  let many = isArray(schema) ? schema : (_schema2 = schema) === null || _schema2 === void 0 ? void 0 : _schema2[['anyOf', 'oneOf', 'allOf'].find(p => schema[p])];
+
+  if (many) {
+    let isLooseMatch = s => (s === null || s === void 0 ? void 0 : s.type) === 'object' && s.additionalProperties !== false; // the best possible match will match most of the path or loosely match
+
+
+    return many.map(p => getSchema(p, path, root)).sort((a, b) => b.length - a.length || (isLooseMatch(a[0]) ? -1 : 1))[0];
+  } else if ((0, _utils.isArrayKey)(key) && ((_schema3 = schema) === null || _schema3 === void 0 ? void 0 : _schema3.type) === 'array') {
+    // find the remaining paths in the items schema
+    return [schema].concat(getSchema(schema.items, rest, root));
+  } else if (path.length && ((_schema4 = schema) === null || _schema4 === void 0 ? void 0 : _schema4.type) === 'object') {
+    var _schema$properties;
+
+    // find the remaining paths nested in the property schema
+    return [schema].concat(getSchema((_schema$properties = schema.properties) === null || _schema$properties === void 0 ? void 0 : _schema$properties[key], rest, root));
+  } else if (!path.length && schema) {
+    // end of path matching
+    return [schema];
+  } else {
+    // no match
+    return [];
+  }
+} // 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.
 
 
 function addSchema(schemas) {
-  let config = getSchema('config');
-  ajv.removeSchema('config');
+  if (isArray(schemas)) {
+    return schemas.map(addSchema);
+  }
+
+  if (schemas.$id) {
+    let {
+      $id
+    } = schemas;
+    if (ajv.getSchema($id)) ajv.removeSchema($id);
+    return ajv.addSchema(schemas);
+  }
+
+  let config = getSchema('/config');
+  ajv.removeSchema('/config');
 
-  for (let [$id, schema] of entries(schemas)) {
+  for (let [key, schema] of entries(schemas)) {
+    let $id = `/config/${key}`;
     if (ajv.getSchema($id)) ajv.removeSchema($id);
     assign(config.properties, {
-      [$id]: {
+      [key]: {
         $ref: $id
       }
     });
     ajv.addSchema(schema, $id);
   }
 
-  ajv.addSchema(config, 'config');
+  return ajv.addSchema(config, '/config');
 } // Resets the schema by removing all schemas and inserting a new default schema.
 
 
 function resetSchema() {
   ajv.removeSchema();
-  ajv.addSchema(getDefaultSchema(), 'config');
-} // Validates config data according to the config schema and logs warnings to the
-// console. Optionallly scrubs invalid values from the provided config. Returns
-// true when the validation success, false otherwise.
+  ajv.addSchema(getDefaultSchema(), '/config');
+} // 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
+
 
+const HIDE_NESTED_KEYWORDS = ['oneOf', 'anyOf', 'allOf', 'not'];
 
-function validate(config, {
-  scrub
-} = {}) {
-  let result = ajv.validate('config', config);
+function shouldHideError({
+  parentSchema,
+  keyword,
+  schemaPath
+}) {
+  var _parentSchema$errors;
 
-  if (!result) {
-    _logger.default.warn('Invalid config:');
+  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.
+
+
+function validate(data, key = '/config') {
+  if (!ajv.validate(key, data)) {
+    let errors = new Map();
 
     for (let error of ajv.errors) {
+      var _parentSchema$errors2;
+
+      if (shouldHideError(error)) continue;
       let {
-        dataPath,
+        instancePath,
+        parentSchema,
         keyword,
-        params,
         message,
-        data
+        params
       } = error;
-      let pre = dataPath ? `'${dataPath.substr(1)}' ` : '';
+      let path = instancePath ? instancePath.substr(1).split('/') : []; // generate a custom error message
 
-      if (keyword === 'required') {
-        message = `is missing required property '${params.missingProperty}'`;
-      } else if (keyword === 'additionalProperties') {
-        pre = pre ? `${pre}has ` : '';
-        message = `unknown property '${params.additionalProperty}'`;
-        if (scrub) delete data[params.additionalProperty];
+      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;
       } else if (keyword === 'type') {
-        let dataType = Array.isArray(data) ? 'array' : typeof data;
-        message = `should be ${a(params.type)}, received ${a(dataType)}`;
+        let dataType = error.data === null ? 'null' : isArray(error.data) ? 'array' : typeof error.data;
+        message = `must be ${a(params.type)}, received ${a(dataType)}`;
+      } else if (keyword === 'required') {
+        message = 'missing required property';
+      } else if (keyword === 'additionalProperties') {
+        message = 'unknown property';
+      } // fix paths
 
-        if (scrub) {
-          let [key, ...path] = dataPath.substr(1).split('.').reverse();
-          delete path.reduceRight((d, k) => d[k], config)[key];
-        }
-      }
 
-      _logger.default.warn(`- ${pre}${message}`);
-    }
-  }
+      if (params.missingProperty) {
+        path.push(params.missingProperty);
+      } else if (params.additionalProperty) {
+        path.push(params.additionalProperty);
+      } else if (params.disallowedProperty) {
+        path.push(params.disallowedProperty);
+      } // fix invalid data
 
-  return result;
-} // Adds "a" or "an" to a word for readability.
 
+      if (keyword === 'minimum') {
+        (0, _utils.set)(data, path, Math.max(error.data, error.schema));
+      } else if (keyword === 'maximum') {
+        (0, _utils.set)(data, path, Math.min(error.data, error.schema));
+      } else if (keyword === 'required') {
+        (0, _utils.del)(data, path.slice(0, -1));
+      } else {
+        (0, _utils.del)(data, path);
+      } // joined for error messages
 
-function a(word) {
-  return `${'aeiou'.includes(word[0]) ? 'an' : 'a'} ${word}`;
-}
+
+      path = (0, _utils.joinPropertyPath)(path); // map one error per path
+
+      errors.set(path, {
+        path,
+        message
+      });
+    } // filter empty values as a result of scrubbing
+
+
+    (0, _utils.filterEmpty)(data); // return an array of errors
+
+    return Array.from(errors.values());
+  }
+}
+
+var _default = validate;
+exports.default = _default;

package/package.json

@@ -1,36 +1,39 @@
 {
   "name": "@percy/config",
-  "version": "1.0.0-beta.7",
+  "version": "1.0.0-beta.73",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/percy/cli",
+    "directory": "packages/config"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "main": "dist/index.js",
   "types": "types/index.d.ts",
   "files": [
     "dist",
     "types/index.d.ts"
   ],
+  "engines": {
+    "node": ">=12"
+  },
   "scripts": {
-    "build": "babel --root-mode upward src --out-dir dist",
+    "build": "node ../../scripts/build",
     "lint": "eslint --ignore-path ../../.gitignore .",
-    "test": "cross-env NODE_ENV=test mocha",
-    "test:coverage": "nyc yarn test",
+    "test": "node ../../scripts/test",
+    "test:coverage": "yarn test --coverage",
     "test:types": "tsd"
   },
-  "publishConfig": {
-    "access": "public"
-  },
-  "mocha": {
-    "require": "../../scripts/babel-register"
-  },
   "dependencies": {
-    "@percy/logger": "^1.0.0-beta.7",
-    "ajv": "^6.12.0",
+    "@percy/logger": "1.0.0-beta.73",
+    "ajv": "^8.6.2",
     "cosmiconfig": "^7.0.0",
-    "deepmerge": "^4.2.2",
-    "path-type": "^4.0.0",
-    "yaml": "^1.8.0"
+    "yaml": "^1.10.0"
   },
   "devDependencies": {
     "json-schema-typed": "^7.0.3"
   },
-  "gitHead": "5be796ec8f17958e93ada0b634899b945c9b0d60"
+  "gitHead": "aa8160e02bea3e04ab1d3605762f89fbe79605d4"
 }