@percy/config 1.0.0-beta.8 → 1.0.1

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

@@ -1,48 +1,38 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = getDefaults;
-
-var _deepmerge = _interopRequireDefault(require("deepmerge"));
-
-var _validate = require("./validate");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+import { merge } from './utils/index.js';
+import { getSchema } from './validate.js';
+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(getSchema((schema === null || schema === void 0 ? 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
+export function getDefaults(overrides = {}) {
+  return merge([getDefaultsFromSchema(), overrides], (path, prev, next) => {
+    // override default array instead of merging
+    return isArray(next) && [path, next];
   });
-}
+}
+export default getDefaults;

package/dist/index.js

@@ -1,33 +1,9 @@
-"use strict";
+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
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
+export { load, search, validate, addSchema, migrate, addMigration, getDefaults, merge, normalize, stringify }; // export the namespace by default
 
-var _load = _interopRequireWildcard(require("./load"));
-
-var _validate = _interopRequireWildcard(require("./validate"));
-
-var _defaults = _interopRequireDefault(require("./defaults"));
-
-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 _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; }
-
-// Export a single object that can be imported as PercyConfig
-var _default = {
-  load: _load.default,
-  cache: _load.cache,
-  explorer: _load.explorer,
-  validate: _validate.default,
-  addSchema: _validate.addSchema,
-  resetSchema: _validate.resetSchema,
-  getDefaults: _defaults.default,
-  stringify: _stringify.default
-};
-exports.default = _default;
+export * as default from './index.js';

package/dist/load.js

@@ -1,92 +1,100 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = load;
-exports.explorer = exports.cache = void 0;
-
-var _path = require("path");
-
-var _cosmiconfig = require("cosmiconfig");
-
-var _pathType = require("path-type");
-
-var _deepmerge = _interopRequireDefault(require("deepmerge"));
-
-var _logger = _interopRequireDefault(require("@percy/logger"));
-
-var _defaults = _interopRequireDefault(require("./defaults"));
-
-var _normalize = _interopRequireDefault(require("./normalize"));
-
-var _validate = _interopRequireDefault(require("./validate"));
-
-var _stringify = require("./stringify");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-// Loaded configuration file cache
-const cache = new Map(); // The cosmiconfig explorer used to load config files
-
-exports.cache = cache;
-const explorer = (0, _cosmiconfig.cosmiconfigSync)('percy', {
+import fs from 'fs';
+import { relative } from 'path';
+import { cosmiconfigSync } from 'cosmiconfig';
+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
+
+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.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
+
+export function search(path) {
+  try {
+    let result = path && !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({
+export 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 = logger('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: ${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 = migrate(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 = 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;
+  }
 
-  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 (path !== false && config) {
+    log[infoDebug](`Using config:\n${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);
-}
+  return getDefaults(config);
+}
+export default load;

package/dist/migrate.js

@@ -0,0 +1,77 @@
+import logger from '@percy/logger';
+import { get, set, del, map, joinPropertyPath, normalize } from './utils/index.js'; // 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
+
+export 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 (get(config, path) == null) return;
+  let {
+    type,
+    until: ver,
+    map: mapto,
+    alt,
+    warn
+  } = options;
+  let name = joinPropertyPath(path);
+  let to = joinPropertyPath(mapto);
+  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
+
+
+export function migrate(config, schema = '/config') {
+  config = normalize(config, {
+    schema
+  }) ?? {};
+
+  if (migrations.has(schema)) {
+    let log = logger('config');
+    let util = {
+      deprecate: deprecate.bind(null, config, log),
+      set: set.bind(null, config),
+      map: map.bind(null, config),
+      del: del.bind(null, config),
+      log
+    };
+
+    for (let migration of migrations.get(schema)) {
+      migration(config, util);
+    } // normalize again to adjust for migrations
+
+
+    config = normalize(config, {
+      schema
+    });
+  }
+
+  return config;
+}
+export default migrate;

package/dist/utils/index.js

@@ -0,0 +1,3 @@
+export * from './merge.js';
+export * from './normalize.js';
+export * from './stringify.js';

package/dist/utils/merge.js

@@ -0,0 +1,169 @@
+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*)$/;
+export function isArrayKey(key) {
+  return isInteger(key) || ARRAY_PATH_KEY_REG.test(key);
+} // 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) => {
+      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
+
+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
+
+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
+
+export function set(object, path, value) {
+  return parsePropertyPath(path).reduce((target, key, index, path) => {
+    if (index < path.length - 1) {
+      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
+
+export 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
+
+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
+
+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]);
+    }
+  }
+} // Recursively mutate and filter empty values from arrays and objects
+
+
+export 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;
+  }
+} // 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 [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 _ctx2;
+
+        path.splice(-1, 1, ((_ctx2 = ctx) === null || _ctx2 === void 0 ? void 0 : _ctx2.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)) {
+        set(target ?? (target = create(isSourceArray)), path, next ?? value);
+      } // do not recurse mapped objects
+
+
+      return next === undefined;
+    });
+    return target;
+  }, undefined);
+}
+export default merge;

package/dist/utils/normalize.js

@@ -0,0 +1,42 @@
+import merge from './merge.js';
+import { getSchema } from '../validate.js'; // 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;
+export 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;
+export 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.
+
+export function normalize(object, options) {
+  var _options, _options2;
+
+  if (typeof options === 'string') options = {
+    schema: options
+  };
+  let keycase = (_options = options) !== null && _options !== void 0 && _options.kebab ? kebabcase : camelcase;
+  return merge([object, (_options2 = options) === null || _options2 === void 0 ? void 0 : _options2.overrides], path => {
+    var _options3, _schemas$shift;
+
+    let schemas = getSchema((_options3 = options) === null || _options3 === void 0 ? void 0 : _options3.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];
+  });
+}
+export default normalize;

package/dist/utils/stringify.js

@@ -0,0 +1,29 @@
+import util from 'util';
+import YAML from 'yaml';
+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.
+
+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}`);
+  }
+}
+export default stringify;

package/dist/validate.js

@@ -1,34 +1,64 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getSchema = getSchema;
-exports.addSchema = addSchema;
-exports.resetSchema = resetSchema;
-exports.default = validate;
-
-var _ajv = _interopRequireDefault(require("ajv"));
-
-var _logger = _interopRequireDefault(require("@percy/logger"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+import AJV from 'ajv/dist/2019.js';
+import { set, del, filterEmpty, parsePropertyPath, joinPropertyPath, isArrayKey } from './utils/index.js';
+const {
+  isArray
+} = Array;
 const {
   assign,
   entries
-} = Object; // Ajv manages and validates schemas.
+} = Object; // AJV manages and validates schemas.
 
-const ajv = new _ajv.default({
+const ajv = new AJV({
+  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.str`must be an instanceof ${cxt.schemaCode}`,
+      params: cxt => AJV._`{ instanceof: ${cxt.schemaCode} }`
+    },
+    code: cxt => cxt.fail(AJV._`!(${cxt.data} instanceof ${AJV._([cxt.schema])})`)
+  }, {
+    // disallowed validation based on required
+    keyword: 'disallowed',
+    metaSchema: {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    },
+    error: {
+      message: 'disallowed property',
+      params: cxt => AJV._`{ disallowedProperty: ${cxt.params.disallowedProperty} }`
+    },
+    code: cxt => {
+      let {
+        data,
+        gen,
+        schema
+      } = cxt;
+
+      for (let prop of schema) {
+        gen.if(AJV._`${data}.${AJV._([prop])} !== undefined`, () => {
+          cxt.setParams({
+            disallowedProperty: AJV._`${prop}`
+          }, true);
+          cxt.error();
+        });
+      }
+    }
+  }]
 }); // Returns a new default schema.
 
 function getDefaultSchema() {
   return {
+    $id: '/config',
     type: 'object',
     additionalProperties: false,
     properties: {
@@ -38,84 +68,171 @@ function getDefaultSchema() {
       }
     }
   };
-} // Gets the schema object from the AJV schema.
-
-
-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.
+} // 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
+
+  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
+      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)) {
+    // find the remaining paths in the items schema
+    return [schema].concat(getSchema(schema.items, rest, root));
+  } else if ((schema === null || schema === void 0 ? void 0 : schema.type) === 'object' && path.length && (_schema$properties = schema.properties) !== null && _schema$properties !== void 0 && _schema$properties[key]) {
+    // find the remaining paths nested in the property schema
+    return [schema].concat(getSchema(schema.properties[key], rest, root));
+  } else if (schema !== null && schema !== void 0 && schema.$ref && (path.length || Object.keys(schema).length === 1)) {
+    // follow references
+    let $ref = schema.$ref.startsWith('#') ? `${root.$id}${schema.$ref}` : schema.$ref;
+    return getSchema($ref, path, root);
+  } else if (schema && (!path.length || schema.type === 'object' && schema.additionalProperties !== false)) {
+    // 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.
+
+export function addSchema(schemas) {
+  if (isArray(schemas)) {
+    return schemas.map(addSchema);
+  }
 
+  if (schemas.$id) {
+    let {
+      $id
+    } = schemas;
+    if (ajv.getSchema($id)) ajv.removeSchema($id);
+    return ajv.addSchema(schemas);
+  }
 
-function addSchema(schemas) {
-  let config = getSchema('config');
-  ajv.removeSchema('config');
+  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() {
+export 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 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}`)) || getSchema(key, path)[path.length] !== parentSchema);
+} // Validates data according to the associated schema and returns a list of errors, if any.
 
-function validate(config, {
-  scrub
-} = {}) {
-  let result = ajv.validate('config', config);
 
-  if (!result) {
-    _logger.default.warn('Invalid config:');
+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 {
-        dataPath,
+        instancePath,
+        parentSchema,
         keyword,
-        params,
         message,
-        data
+        params
       } = error;
-      let pre = dataPath ? `'${dataPath.substr(1)}' ` : '';
-
-      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];
+      let path = instancePath ? instancePath.substr(1).split('/') : [];
+      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;
       } 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' || keyword === 'unevaluatedProperties') {
+        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.unevaluatedProperty) {
+        path.push(params.unevaluatedProperty);
+      } 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') {
+        set(data, path, Math.max(error.data, error.schema));
+      } else if (keyword === 'maximum') {
+        set(data, path, Math.min(error.data, error.schema));
+      } else if (keyword === 'required') {
+        del(data, path.slice(0, -1));
+      } else {
+        del(data, path);
+      } // joined for error messages
 
-function a(word) {
-  return `${'aeiou'.includes(word[0]) ? 'an' : 'a'} ${word}`;
-}
+
+      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
+
+    return Array.from(errors.values());
+  }
+}
+export default validate;

package/package.json

@@ -1,36 +1,45 @@
 {
   "name": "@percy/config",
-  "version": "1.0.0-beta.8",
+  "version": "1.0.1",
   "license": "MIT",
-  "main": "dist/index.js",
-  "types": "types/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/percy/cli",
+    "directory": "packages/config"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=14"
+  },
   "files": [
     "dist",
     "types/index.d.ts"
   ],
+  "main": "./dist/index.js",
+  "types": "./types/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./utils": "./dist/utils/index.js",
+    "./test/helpers": "./test/helpers.js"
+  },
   "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.8",
-    "ajv": "^6.12.0",
+    "@percy/logger": "1.0.1",
+    "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": "6015850e7c20c130d625fcb327b10d7513b35707"
+  "gitHead": "38917e6027299d6cd86008e2ccd005d90bbf89c0"
 }

package/dist/normalize.js

@@ -1,37 +0,0 @@
-"use strict";
-
-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));
-}

package/dist/stringify.js

@@ -1,42 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.inspect = inspect;
-exports.default = stringify;
-
-var _util = _interopRequireDefault(require("util"));
-
-var _yaml = _interopRequireDefault(require("yaml"));
-
-var _defaults = _interopRequireDefault(require("./defaults"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-// Provides native util.inspect with common options for printing configs.
-function inspect(config) {
-  return _util.default.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.
-
-
-function stringify(format, config = (0, _defaults.default)()) {
-  switch (format) {
-    case 'yml':
-    case 'yaml':
-      return _yaml.default.stringify(config);
-
-    case 'json':
-      return JSON.stringify(config, null, 2);
-
-    case 'js':
-      return `module.exports = ${inspect(config)}`;
-
-    default:
-      throw new Error(`Unsupported format: ${format}`);
-  }
-}