@percy/config 1.0.0 → 1.0.3

package/dist/defaults.js

@@ -0,0 +1,38 @@
+import { merge } from './utils/index.js';
+import { getSchema } from './validate.js';
+const {
+  isArray
+} = Array;
+const {
+  assign,
+  entries
+} = 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
+    return getDefaultsFromSchema(getSchema((schema === null || schema === void 0 ? void 0 : schema.$ref) ?? '/config'));
+  } else if (schema.default != null) {
+    // return the default for this schema
+    return schema.default;
+  } else if (schema.type === 'object' && schema.properties) {
+    // 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);
+  } else {
+    return undefined;
+  }
+}
+
+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

@@ -0,0 +1,9 @@
+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
+
+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

@@ -0,0 +1,100 @@
+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']
+}); // 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. Will automatically convert older config
+// versions to the latest version while printing a warning.
+
+export function load({
+  path,
+  overrides = {},
+  reload = 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];
+  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 = 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) {
+          log.warn(`Ignoring config file - unsupported version "${version}"`);
+        } else {
+          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 {
+        log[infoDebug]('Config file not found');
+        if (bail) return;
+      }
+    } catch (error) {
+      log[errorDebug](error);
+      if (bail) return;
+    }
+  } // 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
+
+
+  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

@@ -0,0 +1,238 @@
+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.
+
+const ajv = new AJV({
+  strict: false,
+  verbose: true,
+  allErrors: true,
+  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: {
+      version: {
+        type: 'integer',
+        default: 2
+      }
+    }
+  };
+} // 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);
+  }
+
+  let config = getSchema('/config');
+  ajv.removeSchema('/config');
+
+  for (let [key, schema] of entries(schemas)) {
+    let $id = `/config/${key}`;
+    if (ajv.getSchema($id)) ajv.removeSchema($id);
+    assign(config.properties, {
+      [key]: {
+        $ref: $id
+      }
+    });
+    ajv.addSchema(schema, $id);
+  }
+
+  return ajv.addSchema(config, '/config');
+} // 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.
+
+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.
+
+
+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,
+        keyword,
+        message,
+        params
+      } = error;
+      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 = 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 (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
+
+
+      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
+
+
+      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,6 +1,6 @@
 {
   "name": "@percy/config",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -14,8 +14,9 @@
     "node": ">=14"
   },
   "files": [
-    "./dist",
-    "./types/index.d.ts"
+    "dist",
+    "types/index.d.ts",
+    "tests/helpers.js"
   ],
   "main": "./dist/index.js",
   "types": "./types/index.d.ts",
@@ -33,7 +34,7 @@
     "test:types": "tsd"
   },
   "dependencies": {
-    "@percy/logger": "1.0.0",
+    "@percy/logger": "1.0.3",
     "ajv": "^8.6.2",
     "cosmiconfig": "^7.0.0",
     "yaml": "^1.10.0"
@@ -41,5 +42,5 @@
   "devDependencies": {
     "json-schema-typed": "^7.0.3"
   },
-  "gitHead": "6df509421a60144e4f9f5d59dc57a5675372a0b2"
+  "gitHead": "a259d5cff0933711bced21a979c577e70765d318"
 }

package/types/index.d.ts

@@ -0,0 +1,33 @@
+import { JSONSchema } from 'json-schema-typed';
+
+interface Pojo { [x: string]: any; }
+export interface PercyConfigObject extends Pojo { version: number; }
+
+declare namespace PercyConfig {
+  function load(options?: {
+    path?: undefined | string | false,
+    overrides?: Pojo,
+    reload?: boolean,
+    bail?: boolean
+  }): PercyConfigObject;
+
+  function validate(
+    config: PercyConfigObject,
+    options?: { scrub?: boolean }
+  ): boolean;
+
+  function addSchema(schemas: {
+    [x: string]: JSONSchema
+  }): void;
+
+  function getDefaults(
+    overrides?: Pojo
+  ): PercyConfigObject;
+
+  function stringify(
+    format: 'yaml' | 'json' | 'js',
+    config?: PercyConfigObject
+  ): string;
+}
+
+export default PercyConfig