patch(vest): general cleanups

packages/shared/src/cache.ts

@@ -29,23 +29,21 @@ export default function createCache(maxSize = 1): {
 
   // invalidate an item in the cache by its dependencies
   cache.invalidate = (deps: any[]): void => {
-    const index = cacheStorage.findIndex(
-      ([cachedDeps]) =>
-        lengthEquals(deps, cachedDeps.length) &&
-        deps.every((dep, i) => dep === cachedDeps[i])
-    );
+    const index = findIndex(deps);
     if (index > -1) cacheStorage.splice(index, 1);
   };
 
   // Retrieves an item from the cache.
   cache.get = (deps: unknown[]): [unknown[], any] | null =>
-    cacheStorage[
-      cacheStorage.findIndex(
-        ([cachedDeps]) =>
-          lengthEquals(deps, cachedDeps.length) &&
-          deps.every((dep, i) => dep === cachedDeps[i])
-      )
-    ] || null;
+    cacheStorage[findIndex(deps)] || null;
 
   return cache;
+
+  function findIndex(deps: unknown[]): number {
+    return cacheStorage.findIndex(
+      ([cachedDeps]) =>
+        lengthEquals(deps, cachedDeps.length) &&
+        deps.every((dep, i) => dep === cachedDeps[i])
+    );
+  }
 }

packages/shared/src/nestedArray.ts

@@ -7,9 +7,9 @@ import last from 'last';
 
 export type NestedArray<T> = Array<NestedArray<T> | T>;
 
-// This is sort of a map/filter in one function.
-// Normally, behaves like a nested-array map
-// Returning `null` will drop the element from the array
+// This is kind of a map/filter in one function.
+// Normally, behaves like a nested-array map,
+// but returning `null` will drop the element from the array
 export function transform<T>(
   array: NestedArray<T>,
   cb: (value: T) => NestedArray<T> | T | null

packages/vest/src/core/isolate/isolates/__tests__/__snapshots__/each.test.ts.snap

@@ -1,3 +1,3 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`each When callback is not a function should throw 1`] = `"callback must be a function"`;
+exports[`each When callback is not a function should throw 1`] = `"each callback must be a function"`;

packages/vest/src/core/isolate/isolates/each.ts

@@ -22,7 +22,7 @@ export default function each<T>(
   callback: (arg: T, index: number) => void
 ): void {
   if (!isFunction(callback)) {
-    throwError('callback must be a function');
+    throwError('each callback must be a function');
   }
 
   isolate({ type: IsolateTypes.EACH }, () => {

packages/vest/src/core/suite/produce/Severity.ts

@@ -0,0 +1,4 @@
+export enum Severity {
+  WARNINGS = 'warnings',
+  ERRORS = 'errors',
+}

packages/vest/src/core/suite/produce/__tests__/nonMatchingSeverityProfile.test.ts

@@ -1,6 +1,6 @@
-import nonMatchingSeverityProfile from 'nonMatchingSeverityProfile';
-
+import { Severity } from 'Severity';
 import VestTest from 'VestTest';
+import nonMatchingSeverityProfile from 'nonMatchingSeverityProfile';
 
 describe('nonMatchingSeverityProfile', () => {
   let testObject: VestTest;
@@ -12,13 +12,17 @@ describe('nonMatchingSeverityProfile', () => {
     describe('When both are warning', () => {
       it('should return false', () => {
         testObject.warn();
-        expect(nonMatchingSeverityProfile('warnings', testObject)).toBe(false);
+        expect(nonMatchingSeverityProfile(Severity.WARNINGS, testObject)).toBe(
+          false
+        );
       });
     });
 
     describe('When both are not warning', () => {
       it('should return false', () => {
-        expect(nonMatchingSeverityProfile('errors', testObject)).toBe(false);
+        expect(nonMatchingSeverityProfile(Severity.ERRORS, testObject)).toBe(
+          false
+        );
       });
     });
   });
@@ -27,13 +31,17 @@ describe('nonMatchingSeverityProfile', () => {
     describe('When test is warning', () => {
       it('should return true', () => {
         testObject.warn();
-        expect(nonMatchingSeverityProfile('errors', testObject)).toBe(true);
+        expect(nonMatchingSeverityProfile(Severity.ERRORS, testObject)).toBe(
+          true
+        );
       });
     });
 
     describe('When severity is warning', () => {
       it('should return true', () => {
-        expect(nonMatchingSeverityProfile('warnings', testObject)).toBe(true);
+        expect(nonMatchingSeverityProfile(Severity.WARNINGS, testObject)).toBe(
+          true
+        );
       });
     });
   });

packages/vest/src/core/suite/produce/genTestsSummary.ts

@@ -1,20 +1,19 @@
+import assign from 'assign';
+
+import { Severity } from 'Severity';
 import VestTest from 'VestTest';
 import { useTestsFlat } from 'stateHooks';
-import type { TSeverity } from 'vestTypes';
 
 /**
  * Reads the testObjects list and gets full validation result from it.
  */
 export default function genTestsSummary(): TTestSummary {
   const testObjects = useTestsFlat();
 
-  const summary: TTestSummary = {
-    errorCount: 0,
+  const summary: TTestSummary = assign(baseStats(), {
     groups: {},
-    testCount: 0,
     tests: {},
-    warnCount: 0,
-  };
+  });
 
   appendSummary(testObjects);
 
@@ -56,11 +55,7 @@ function genTestObject(
 ): TSingleTestSummary {
   const { fieldName, message } = testObject;
 
-  summaryKey[fieldName] = summaryKey[fieldName] || {
-    errorCount: 0,
-    warnCount: 0,
-    testCount: 0,
-  };
+  summaryKey[fieldName] = summaryKey[fieldName] || baseStats();
 
   const testKey = summaryKey[fieldName];
 
@@ -69,22 +64,31 @@ function genTestObject(
   summaryKey[fieldName].testCount++;
 
   // Adds to severity group
-  function addTo(countKey: 'warnCount' | 'errorCount', group: TSeverity) {
+  function addTo(severity: Severity) {
+    const countKey = severity === Severity.ERRORS ? 'errorCount' : 'warnCount';
     testKey[countKey]++;
     if (message) {
-      testKey[group] = (testKey[group] || []).concat(message);
+      testKey[severity] = (testKey[severity] || []).concat(message);
     }
   }
 
   if (testObject.isFailing()) {
-    addTo('errorCount', 'errors');
+    addTo(Severity.ERRORS);
   } else if (testObject.isWarning()) {
-    addTo('warnCount', 'warnings');
+    addTo(Severity.WARNINGS);
   }
 
   return testKey;
 }
 
+function baseStats() {
+  return {
+    errorCount: 0,
+    warnCount: 0,
+    testCount: 0,
+  };
+}
+
 type TTestSummary = {
   groups: Record<string, TTestGroup>;
   tests: TTestGroup;

packages/vest/src/core/suite/produce/getFailures/__tests__/collectFailureMessages.test.ts

@@ -1,18 +1,19 @@
+import { Severity } from 'Severity';
 import VestTest from 'VestTest';
 import collectFailureMessages from 'collectFailureMessages';
 
 describe('collectFailureMessages', () => {
   let testObjects: VestTest[] = [];
 
   it('Should return an object containing just the requested field', () => {
-    const result = collectFailureMessages('errors', testObjects, {
+    const result = collectFailureMessages(Severity.ERRORS, testObjects, {
       fieldName: 'field_1',
     });
     expect(Object.keys(result)).toEqual(['field_1']);
   });
 
   test('Result has an array of matching error messages', () => {
-    const result = collectFailureMessages('errors', testObjects, {
+    const result = collectFailureMessages(Severity.ERRORS, testObjects, {
       fieldName: 'field_1',
     });
     expect(result.field_1).toEqual([
@@ -22,7 +23,7 @@ describe('collectFailureMessages', () => {
   });
 
   it('Should return filtered messages by the selected group', () => {
-    const result = collectFailureMessages('errors', testObjects, {
+    const result = collectFailureMessages(Severity.ERRORS, testObjects, {
       group: 'group1',
     });
 
@@ -31,7 +32,7 @@ describe('collectFailureMessages', () => {
 
   it('Should return an empty object when no options and no failures', () => {
     expect(
-      collectFailureMessages('errors', [
+      collectFailureMessages(Severity.ERRORS, [
         new VestTest('field_1', jest.fn(), { message: 'error_message' }),
       ])
     ).toEqual({});
@@ -40,15 +41,14 @@ describe('collectFailureMessages', () => {
   it('Should return an object with an empty array when selected field has no errors', () => {
     expect(
       collectFailureMessages(
-        'errors',
+        Severity.ERRORS,
         [new VestTest('field_1', jest.fn(), { message: 'error_message' })],
         { fieldName: 'field_1' }
       )
     ).toEqual({ field_1: [] });
   });
 
-  // @ts-expect-error - it can't properly infer the severity
-  ['errors', 'warnings'].forEach((severity: 'errors' | 'warnings') => {
+  [Severity.ERRORS, Severity.WARNINGS].forEach((severity: Severity) => {
     describe('Snapshot tests. severity: ' + severity, () => {
       describe('When no options passed', () => {
         it('should match snapshot', () => {

packages/vest/src/core/suite/produce/getFailures/collectFailureMessages.ts

@@ -1,10 +1,10 @@
+import { Severity } from 'Severity';
 import VestTest from 'VestTest';
 import { nonMatchingFieldName } from 'matchingFieldName';
 import nonMatchingSeverityProfile from 'nonMatchingSeverityProfile';
-import type { TSeverity } from 'vestTypes';
 
 export default function collectFailureMessages(
-  severity: TSeverity,
+  severity: Severity,
   testObjects: VestTest[],
   options: { group?: string; fieldName?: string } = {}
 ): Record<string, string[]> {
@@ -38,7 +38,7 @@ function noGroupMatch(
 
 function noMatch(
   testObject: VestTest,
-  severity: TSeverity,
+  severity: Severity,
   group: void | string,
   fieldName: void | string
 ): boolean {

packages/vest/src/core/suite/produce/getFailures/getFailures.ts

@@ -1,28 +1,28 @@
+import { Severity } from 'Severity';
 import collectFailureMessages from 'collectFailureMessages';
 import getFailuresArrayOrObject from 'getFailuresArrayOrObject';
 import { useTestsFlat } from 'stateHooks';
-import type { TSeverity } from 'vestTypes';
 
 export function getErrors(): Record<string, string[]>;
 export function getErrors(fieldName?: string): string[];
 export function getErrors(
   fieldName?: string
 ): string[] | Record<string, string[]> {
-  return getFailures('errors', fieldName);
+  return getFailures(Severity.ERRORS, fieldName);
 }
 
 export function getWarnings(): Record<string, string[]>;
 export function getWarnings(fieldName?: string): string[];
 export function getWarnings(
   fieldName?: string
 ): string[] | Record<string, string[]> {
-  return getFailures('warnings', fieldName);
+  return getFailures(Severity.WARNINGS, fieldName);
 }
 
 /**
  * @returns suite or field's errors or warnings.
  */
-function getFailures(severityKey: TSeverity, fieldName?: string) {
+function getFailures(severityKey: Severity, fieldName?: string) {
   const testObjects = useTestsFlat();
   const failureMessages = collectFailureMessages(severityKey, testObjects, {
     fieldName,

packages/vest/src/core/suite/produce/getFailures/getFailuresByGroup.ts

@@ -1,9 +1,9 @@
 import throwError from 'throwError';
 
+import { Severity } from 'Severity';
 import collectFailureMessages from 'collectFailureMessages';
 import getFailuresArrayOrObject from 'getFailuresArrayOrObject';
 import { useTestsFlat } from 'stateHooks';
-import type { TSeverity } from 'vestTypes';
 
 export function getErrorsByGroup(groupName: string): Record<string, string[]>;
 export function getErrorsByGroup(
@@ -14,7 +14,7 @@ export function getErrorsByGroup(
   groupName: string,
   fieldName?: string
 ): string[] | Record<string, string[]> {
-  const errors = getByGroup('errors', groupName, fieldName);
+  const errors = getByGroup(Severity.ERRORS, groupName, fieldName);
 
   return getFailuresArrayOrObject(errors, fieldName);
 }
@@ -28,7 +28,7 @@ export function getWarningsByGroup(
   groupName: string,
   fieldName?: string
 ): string[] | Record<string, string[]> {
-  const warnings = getByGroup('warnings', groupName, fieldName);
+  const warnings = getByGroup(Severity.WARNINGS, groupName, fieldName);
 
   return getFailuresArrayOrObject(warnings, fieldName);
 }
@@ -37,7 +37,7 @@ export function getWarningsByGroup(
  * Gets failure messages by group.
  */
 function getByGroup(
-  severityKey: TSeverity,
+  severityKey: Severity,
   group: string,
   fieldName?: string
 ): Record<string, string[]> {