@percy/config 1.0.3 → 1.0.6

package/dist/utils/merge.js

@@ -86,15 +86,17 @@ export function map(object, from, to, transform = v => v) {
   }, object)));
 } // Steps through an object's properties calling the function with the path and value of each
 
-function walk(object, fn, path = []) {
+function walk(object, fn, path = [], visited = new Set()) {
   if (path.length && fn([...path], object) === false) return;
+  if (visited.has(object)) return;
+  visited.add(object);
 
   if (object != null && typeof object === 'object') {
     let isArrayObject = isArray(object);
 
     for (let [key, value] of entries(object)) {
       if (isArrayObject) key = parseInt(key, 10);
-      walk(value, fn, [...path, key]);
+      walk(value, fn, [...path, key], new Set(visited));
     }
   }
 } // Recursively mutate and filter empty values from arrays and objects

package/dist/utils/normalize.js

@@ -24,11 +24,16 @@ export function normalize(object, 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;
+  return merge([object, (_options2 = options) === null || _options2 === void 0 ? void 0 : _options2.overrides], (path, value) => {
+    var _options3, _schemas$shift, _options4, _options4$skip;
 
     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;
+    let skip = ((_schemas$shift = schemas.shift()) === null || _schemas$shift === void 0 ? void 0 : _schemas$shift.normalize) === false || ((_options4 = options) === null || _options4 === void 0 ? void 0 : (_options4$skip = _options4.skip) === null || _options4$skip === void 0 ? void 0 : _options4$skip.call(_options4, path, value)); // skip normalizing paths of class instances
+
+    if (!skip && typeof value === 'object' && value !== null && value !== void 0 && value.constructor) {
+      skip = Object.getPrototypeOf(value) !== Object.prototype;
+    }
+
     path = path.map((k, i) => {
       var _schemas$i;
 

package/dist/validate.js

@@ -165,7 +165,7 @@ function shouldHideError(key, path, error) {
     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);
+  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.
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/config",
-  "version": "1.0.3",
+  "version": "1.0.6",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -16,7 +16,7 @@
   "files": [
     "dist",
     "types/index.d.ts",
-    "tests/helpers.js"
+    "test/helpers.js"
   ],
   "main": "./dist/index.js",
   "types": "./types/index.d.ts",
@@ -34,7 +34,7 @@
     "test:types": "tsd"
   },
   "dependencies": {
-    "@percy/logger": "1.0.3",
+    "@percy/logger": "1.0.6",
     "ajv": "^8.6.2",
     "cosmiconfig": "^7.0.0",
     "yaml": "^1.10.0"
@@ -42,5 +42,5 @@
   "devDependencies": {
     "json-schema-typed": "^7.0.3"
   },
-  "gitHead": "a259d5cff0933711bced21a979c577e70765d318"
+  "gitHead": "f883f713ac513635245301622392870ba4018706"
 }

package/test/helpers.js

@@ -0,0 +1,118 @@
+import fs from 'fs';
+import os from 'os';
+import url from 'url';
+import path from 'path';
+import Module from 'module';
+
+// Reset various global @percy/config internals for testing
+export async function resetPercyConfig(all) {
+  // aliased to src during tests
+  let { clearMigrations } = await import('../dist/migrate.js');
+  let { resetSchema } = await import('../dist/validate.js');
+  let { cache } = await import('../dist/load.js');
+  if (all) clearMigrations();
+  if (all) resetSchema();
+  cache.clear();
+}
+
+// When mocking fs, these classes should not be spied on
+const FS_CLASSES = [
+  'Stats', 'Dirent',
+  'StatWatcher', 'FSWatcher',
+  'ReadStream', 'WriteStream'
+];
+
+// Used to bypass mocking internal package files
+const INTERNAL_FILE_REG = new RegExp(
+  '(/|\\\\)(packages)\\1((?:(?!\\1).)+?)\\1' +
+    '(src|dist|test|package\\.json)(\\1|$)'
+);
+
+// Mock and spy on fs methods using an in-memory filesystem
+export async function mockfs({
+  // set `true` to allow mocking files within `node_modules` (may cause dynamic import issues)
+  $modules = false,
+  // list of filepaths or function matchers to allow direct access to the real filesystem
+  $bypass = [],
+  // initial flat map of files and/or directories to create
+  ...initial
+} = {}) {
+  let memfs = await import('memfs');
+  let vol = new memfs.Volume();
+
+  // automatically cleanup mock imports
+  global.__MOCK_IMPORTS__?.clear();
+
+  // when .js files are created, also mock the module for importing
+  spyOn(vol, 'writeFileSync').and.callFake((...args) => {
+    if (args[0].endsWith('.js')) mockFileModule(...args);
+    return vol.writeFileSync.and.originalFn.apply(vol, args);
+  });
+
+  // initial volume contents include the cwd and tmpdir
+  vol.fromJSON({
+    [process.cwd()]: null,
+    [os.tmpdir()]: null,
+    ...initial
+  });
+
+  let bypass = [
+    // bypass babel config for runtime registration
+    path.resolve(url.fileURLToPath(import.meta.url), '../../../../babel.config.cjs'),
+    // bypass descriptors that don't exist in the current volume
+    p => typeof p === 'number' && !vol.fds[p],
+    // bypass node_modules by default to avoid dynamic import issues
+    p => !$modules && p.includes?.('node_modules'),
+    // bypass internal package files to avoid dynamic import issues
+    p => p.match?.(INTERNAL_FILE_REG) && !vol.existsSync(p),
+    // additional bypass matches
+    ...$bypass
+  ];
+
+  // spies on fs methods and calls in-memory methods unless bypassed
+  let installFakes = (og, fake) => {
+    for (let k in og) {
+      if (k in fake && typeof og[k] === 'function' && !FS_CLASSES.includes(k)) {
+        spyOn(og, k).and.callFake((...args) => bypass.some(p => (
+          typeof p === 'function' ? p(...args) : (p === args[0])
+        )) ? og[k].and.originalFn(...args) : fake[k](...args));
+      }
+    }
+  };
+
+  // mock and install fs methods using the in-memory filesystem
+  let mock = memfs.createFsFromVolume(vol);
+  installFakes(fs.promises, mock.promises);
+  installFakes(fs, mock);
+
+  // allow tests access to the in-memory filesystem
+  fs.$bypass = bypass;
+  fs.$vol = vol;
+  return vol;
+}
+
+// Mock module loading to avoid node using internal C++ fs bindings
+function mockFileModule(filepath, content = '') {
+  if (!jasmine.isSpy(Module._load)) {
+    spyOn(Module, '_load').and.callThrough();
+    spyOn(Module, '_resolveFilename').and.callThrough();
+  }
+
+  let mod = new Module();
+  let fp = mod.filename = path.resolve(filepath);
+  let any = { asymmetricMatch: () => true };
+
+  let matchFilepath = {
+    asymmetricMatch: f => path.resolve(f) === fp ||
+      fp.endsWith(path.join('node_modules', f))
+  };
+
+  Module._resolveFilename.withArgs(matchFilepath, any).and.returnValue(fp);
+  Module._load.withArgs(matchFilepath, any, any).and.callFake(() => {
+    mod.loaded = mod.loaded || (mod._compile(content, fp), true);
+    return mod.exports;
+  });
+}
+
+// export fs for convenience
+export { fs };