@availity/yup 3.1.1 → 3.2.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.2.0 (2021-10-22)
+
+
+### Features
+
+* **yup:** switch to lodash from merge-options-es5 ([06456c9](https://github.com/Availity/sdk-js/commit/06456c90ac6ef7523c4ed0d2e4dc9af8c4a6dee5))
+
+
+
+
+
 ## [3.1.1](https://github.com/Availity/sdk-js/compare/@availity/yup@3.1.0...@availity/yup@3.1.1) (2021-06-16)
 
 

package/README.md

@@ -9,13 +9,13 @@
 ### NPM
 
 ```bash
-$ npm install @availity/yup yup
+npm install @availity/yup yup
 ```
 
 ### Yarn
 
 ```bash
-$ yarn add @availity/yup yup
+yarn add @availity/yup yup
 ```
 
 ## [Documentation](https://availity.github.io/sdk-js/resources/yup)

package/lib/dateRange.js

@@ -23,11 +23,11 @@ var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/creat
 
 var _moment = _interopRequireDefault(require("moment"));
 
-var _get = _interopRequireDefault(require("lodash/get"));
-
 var _yup = require("yup");
 
-var _mergeOptionsEs = _interopRequireDefault(require("merge-options-es5"));
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _merge2 = _interopRequireDefault(require("lodash/merge"));
 
 var defaultOptions = {
   startKey: 'startDate',
@@ -50,7 +50,7 @@ var DateRangeSchema = /*#__PURE__*/function (_mixed) {
       type: 'dateRange'
     });
 
-    var _merge = (0, _mergeOptionsEs["default"])({}, defaultOptions, options),
+    var _merge = (0, _merge2["default"])({}, defaultOptions, options),
         startKey = _merge.startKey,
         endKey = _merge.endKey,
         format = _merge.format;

package/package.json

@@ -1,37 +1,31 @@
 {
   "name": "@availity/yup",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "Additional Methods for Yup validation library",
   "main": "lib/index.js",
   "module": "src/index.js",
-  "typings": "typings/index.d.ts",
-  "scripts": {
-    "test": "test"
-  },
+  "types": "types/index.d.ts",
   "keywords": [
-    "tus",
-    "resumable",
-    "upload",
+    "yup",
     "availity"
   ],
   "author": "Kyle Gray <kyle.gray@availity.com>",
   "license": "MIT",
-  "peerDependencies": {
-    "moment": "^2.24.0",
-    "yup": "^0.28.1"
-  },
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@babel/runtime": "^7.10.2",
+    "core-js": "^3.12.1",
+    "lodash": "^4.17.21"
+  },
   "devDependencies": {
     "moment": "^2.24.0",
     "yup": "^0.28.1"
   },
-  "dependencies": {
-    "@babel/runtime": "^7.10.2",
-    "core-js": "^3.12.1",
-    "lodash": "^4.17.21",
-    "merge-options-es5": "^1.0.0"
+  "peerDependencies": {
+    "moment": "^2.24.0",
+    "yup": "^0.28.1"
   },
-  "gitHead": "70499b398a0119fa67ce2b70f00bcd1aef00127c"
+  "gitHead": "a247c20c27816eb3e3b68b983d12631a6cadd72b"
 }

package/src/date.js

@@ -42,8 +42,7 @@ export default class AvDateSchema extends mixed {
     const minDate = this.getValidDate(min);
 
     return this.test({
-      message:
-        message || `Date must be ${minDate.format(this.format)} or later.`,
+      message: message || `Date must be ${minDate.format(this.format)} or later.`,
       name: 'min',
       exclusive: true,
       params: { min },
@@ -60,8 +59,7 @@ export default class AvDateSchema extends mixed {
     const maxDate = this.getValidDate(max);
 
     return this.test({
-      message:
-        message || `Date must be ${maxDate.format(this.format)} or earlier.`,
+      message: message || `Date must be ${maxDate.format(this.format)} or earlier.`,
       name: 'max',
       exclusive: true,
       params: { max },
@@ -99,19 +97,9 @@ export default class AvDateSchema extends mixed {
       name: 'between',
       exclusive: true, // Validation errors don't stack
       // NOTE: Intentional use of single quotes - yup will handle the string interpolation
-      message:
-        msg ||
-        `Date must be between ${minDate.format(
-          this.format
-        )} and ${maxDate.format(this.format)}.`,
+      message: msg || `Date must be between ${minDate.format(this.format)} and ${maxDate.format(this.format)}.`,
       test(value) {
-        if (
-          !value ||
-          !min ||
-          !max ||
-          !minDate.isValid() ||
-          !maxDate.isValid()
-        ) {
+        if (!value || !min || !max || !minDate.isValid() || !maxDate.isValid()) {
           return true;
         }
 

package/src/dateRange.js

@@ -1,7 +1,7 @@
 import moment from 'moment';
-import get from 'lodash/get';
 import { mixed, ValidationError } from 'yup';
-import merge from 'merge-options-es5';
+import get from 'lodash/get';
+import merge from 'lodash/merge';
 
 const defaultOptions = {
   startKey: 'startDate',
@@ -64,16 +64,8 @@ export default class DateRangeSchema extends mixed {
   }
 
   distance({
-    min: {
-      value: minValue,
-      units: minUnits = 'day',
-      errorMessage: minErrorMessage,
-    } = {},
-    max: {
-      value: maxValue,
-      units: maxUnits = 'day',
-      errorMessage: maxErrorMessage,
-    } = {},
+    min: { value: minValue, units: minUnits = 'day', errorMessage: minErrorMessage } = {},
+    max: { value: maxValue, units: maxUnits = 'day', errorMessage: maxErrorMessage } = {},
   } = defaultValue) {
     return this.test({
       name: 'distance',
@@ -82,28 +74,24 @@ export default class DateRangeSchema extends mixed {
         if ((!minValue && !maxValue) || !startDate || !endDate) return true;
 
         if (maxValue && endDate.isAfter(startDate.add(maxValue, maxUnits), 'day')) {
-            return new ValidationError(
-              maxErrorMessage ||
-                `The end date must be within ${maxValue} ${maxUnits}${
-                  maxValue > 1 ? 's' : ''
-                } of the start date`,
-              {
-                startDate,
-                endDate,
-              },
-              this.path
-            );
-          }
+          return new ValidationError(
+            maxErrorMessage ||
+              `The end date must be within ${maxValue} ${maxUnits}${maxValue > 1 ? 's' : ''} of the start date`,
+            {
+              startDate,
+              endDate,
+            },
+            this.path
+          );
+        }
         if (minValue && endDate.isBefore(startDate.add(minValue, minUnits), 'day')) {
-            return new ValidationError(
-              minErrorMessage ||
-                `The end date must be greater than ${minValue} ${minUnits}${
-                  minValue > 1 ? 's' : ''
-                } of the start date`,
-              { startDate, endDate },
-              this.path
-            );
-          }
+          return new ValidationError(
+            minErrorMessage ||
+              `The end date must be greater than ${minValue} ${minUnits}${minValue > 1 ? 's' : ''} of the start date`,
+            { startDate, endDate },
+            this.path
+          );
+        }
 
         return true;
       },
@@ -115,9 +103,7 @@ export default class DateRangeSchema extends mixed {
 
     const minDate = this.getValidDate(min);
     return this.test({
-      message:
-        message ||
-        `Date Range must start on or after ${minDate.format(format)}`,
+      message: message || `Date Range must start on or after ${minDate.format(format)}`,
       name: 'min',
       exclusive: true,
       params: { min },
@@ -136,8 +122,7 @@ export default class DateRangeSchema extends mixed {
     const maxDate = this.getValidDate(max);
 
     return this.test({
-      message:
-        message || `Date Range must end on or before ${maxDate.format(format)}`,
+      message: message || `Date Range must end on or before ${maxDate.format(format)}`,
       name: 'max',
       exclusive: true,
       params: { max },
@@ -155,21 +140,14 @@ export default class DateRangeSchema extends mixed {
     const maxDate = this.getValidDate(max);
 
     return this.test({
-      message:
-        message ||
-        `Date Range must be between ${minDate.format(
-          format
-        )} and ${maxDate.format(format)}`,
+      message: message || `Date Range must be between ${minDate.format(format)} and ${maxDate.format(format)}`,
       name: 'between',
       exclusive: true,
       params: { min, max },
       test({ startDate, endDate } = defaultValue) {
         if (!startDate || !endDate || !min || !max) return true;
         return (
-          maxDate.isValid() &&
-          minDate.isValid() &&
-          maxDate.isSameOrAfter(endDate) &&
-          minDate.isSameOrBefore(startDate)
+          maxDate.isValid() && minDate.isValid() && maxDate.isSameOrAfter(endDate) && minDate.isSameOrBefore(startDate)
         );
       },
     });
@@ -205,9 +183,7 @@ export default class DateRangeSchema extends mixed {
           errors.push('End Date is invalid.');
         }
 
-        return errors.length > 0
-          ? new ValidationError(errors, { startDate, endDate }, this.path)
-          : true;
+        return errors.length > 0 ? new ValidationError(errors, { startDate, endDate }, this.path) : true;
       },
     });
   }

package/src/index.js

@@ -5,8 +5,8 @@ import phone from './phone';
 import AvDate from './date';
 import DateRange from './dateRange';
 
-export const avDate = opts => new AvDate(opts);
-export const dateRange = opts => new DateRange(opts);
+export const avDate = (opts) => new AvDate(opts);
+export const dateRange = (opts) => new DateRange(opts);
 
 addMethod(string, 'isRequired', isRequired);
 addMethod(number, 'isRequired', isRequired);

package/src/phone.js

@@ -1,5 +1,4 @@
-const NANP_REGEXP =
-  /^(\+?1[\s.-]?)?\(?[2-9]\d{2}[\s).-]?\s?[2-9]\d{2}[\s.-]?\d{4}$/;
+const NANP_REGEXP = /^(\+?1[\s.-]?)?\(?[2-9]\d{2}[\s).-]?\s?[2-9]\d{2}[\s.-]?\d{4}$/;
 
 function phone(msg) {
   return this.test({

package/{typings → types}/date.d.ts

@@ -5,15 +5,10 @@ declare module 'yup' {
     format?: string | 'MM/DD/YYYY';
   }
 
-  interface AvDateSchema<T extends string | null | undefined = string>
-    extends MixedSchema<T> {
+  interface AvDateSchema<T extends string | null | undefined = string> extends MixedSchema<T> {
     min(date: string, errorMessage?: string): DateRangeSchema<T>;
     max(date: string, errorMessage?: string): DateRangeSchema<T>;
-    between(
-      minDate: string,
-      maxDate: string,
-      errorMessage?: string
-    ): AvDateSchema<T>;
+    between(minDate: string, maxDate: string, errorMessage?: string): AvDateSchema<T>;
     isRequired(required?: boolean, errorMessage?: string): AvDateSchema<T>;
   }
 

package/{typings → types}/dateRange.d.ts

@@ -23,18 +23,12 @@ declare module 'yup' {
     max?: DistanceValue;
   };
 
-  interface DateRangeSchema<
-    T extends DateRangeObject | null | undefined = DateRangeObject
-  > extends MixedSchema<T> {
+  interface DateRangeSchema<T extends DateRangeObject | null | undefined = DateRangeObject> extends MixedSchema<T> {
     min(date: string, errorMessage?: string): DateRangeSchema<T>;
     max(date: string, errorMessage?: string): DateRangeSchema<T>;
-    between(
-      minDate: string,
-      maxDate: string,
-      errorMessage?: string
-    ): DateRangeSchema<T>;
+    between(minDate: string, maxDate: string, errorMessage?: string): DateRangeSchema<T>;
     isRequired(required?: boolean, errorMessage?: string): DateRangeSchema<T>;
-    distance(distanceOpts: DistanceOpts);
+    distance(distanceOpts: DistanceOpts): DateRangeSchema<T>;
   }
 
   export interface DateRangeSchemaConstructor {

package/{typings → types}/index.d.ts

@@ -3,8 +3,7 @@ import './dateRange.d.ts';
 import './date.d.ts';
 
 declare module 'yup' {
-  interface StringSchema<T extends string | null | undefined = string>
-    extends Schema<T> {
+  interface StringSchema<T extends string | null | undefined = string> extends Schema<T> {
     isRequired(required?: boolean, errorMessage?: string): StringSchema<T>;
     npi(errorMessage?: string): StringSchema<T>;
     phone(errorMessage?: string): StringSchema<T>;
@@ -14,8 +13,7 @@ declare module 'yup' {
     isRequired(required?: boolean, errorMessage?: string): ArraySchema<T>;
   }
 
-  interface NumberSchema<T extends number | null | undefined = number>
-    extends Schema<T> {
+  interface NumberSchema<T extends number | null | undefined = number> extends Schema<T> {
     isRequired(required?: boolean, errorMessage?: string): NumberSchema<T>;
     npi(errorMessage?: string): NumberSchema<T>;
     phone(errorMessage?: string): NumberSchema<T>;

package/tests/date.test.js

@@ -1,172 +0,0 @@
-import { avDate } from '../src';
-
-const INVALID = 'Date is invalid.';
-
-const defaults = {};
-
-const validate = async (
-  date,
-  { format, min, max, message, inclusivity, customErrorMessage } = defaults
-) => {
-  let schema = avDate({
-    format,
-  });
-
-  if (min && !max) {
-    schema = schema.min(min, message);
-  }
-
-  if (max && !min) {
-    schema = schema.max(max, message);
-  }
-
-  if (min && max) {
-    schema = inclusivity
-      ? schema.between(min, max, message, inclusivity)
-      : schema.between(min, max, message);
-  }
-
-  if (customErrorMessage) {
-    schema = schema.typeError(customErrorMessage);
-  }
-
-  return schema.validate(date);
-};
-
-describe('Date', () => {
-  test('valid', async () => {
-    await expect(validate('12/12/2012')).resolves.toBeTruthy();
-    await expect(validate('12-12-2012')).resolves.toBeTruthy();
-    await expect(
-      validate('2012/12/12', { format: 'YYYY/MM/DD' })
-    ).resolves.toBeTruthy();
-    await expect(
-      validate('20121212', { format: 'YYYYMMDD' })
-    ).resolves.toBeTruthy();
-  });
-
-  test('invalid', async () => {
-    await expect(validate('2012')).rejects.toThrow(INVALID);
-    await expect(validate('12-2012')).rejects.toThrow(INVALID);
-    await expect(validate('12-2012-12')).rejects.toThrow(INVALID);
-    await expect(validate('invalid-date')).rejects.toThrow(INVALID);
-    await expect(validate('01/01/20011')).rejects.toThrow(INVALID);
-
-    // Allow user to clear date field without showing typeError
-    await expect(validate('')).resolves.toBeTruthy();
-
-    // With custom message
-    await expect(
-      validate('invalid-date', { customErrorMessage: 'custom error message' })
-    ).rejects.toThrow('custom error message');
-  });
-
-  test('min date', async () => {
-    await expect(
-      validate('12/12/2012', {
-        min: '12/11/2012',
-      })
-    ).resolves.toBeTruthy();
-
-    await expect(
-      validate('12/12/2012', {
-        min: '12/12/2012',
-      })
-    ).resolves.toBeTruthy();
-
-    await expect(
-      validate('12/10/2012', {
-        min: '12/11/2012',
-      })
-    ).rejects.toThrow(`Date must be 12/11/2012 or later.`);
-
-    await expect(
-      validate('2012/12/12', {
-        min: '2012/12/11',
-        format: 'YYYY/MM/DD',
-      })
-    ).resolves.toBeTruthy();
-
-    await expect(
-      validate('2012/12/10', {
-        min: '2012/12/11',
-        format: 'YYYY/MM/DD',
-      })
-    ).rejects.toThrow();
-  });
-
-  test('max date', async () => {
-    await expect(
-      validate('12/11/2012', {
-        max: '12/12/2012',
-      })
-    ).resolves.toBeTruthy();
-
-    await expect(
-      validate('12/12/2012', {
-        max: '12/12/2012',
-      })
-    ).resolves.toBeTruthy();
-
-    await expect(
-      validate('12/12/2012', {
-        max: '12/11/2012',
-      })
-    ).rejects.toThrow(`Date must be 12/11/2012 or earlier.`);
-
-    await expect(
-      validate('2012/12/11', {
-        max: '2012/12/11',
-        format: 'YYYY/MM/DD',
-      })
-    ).resolves.toBeTruthy();
-
-    await expect(
-      validate('2012/12/12', {
-        max: '2012/12/11',
-        format: 'YYYY/MM/DD',
-      })
-    ).rejects.toThrow();
-  });
-
-  test('between', async () => {
-    await expect(
-      validate('12/11/2012', {
-        max: '12/12/2012',
-        min: '12/10/2012',
-      })
-    ).resolves.toBeTruthy();
-
-    await expect(
-      validate('12/12/2012', {
-        min: '12/12/2012',
-        max: '12/13/2012',
-      })
-    ).rejects.toThrow(`Date must be between 12/12/2012 and 12/13/2012.`);
-
-    await expect(
-      validate('2012/12/11', {
-        max: '2012/12/13',
-        min: '2012/12/10',
-        format: 'YYYY/MM/DD',
-      })
-    ).resolves.toBeTruthy();
-
-    await expect(
-      validate('2012/12/13', {
-        min: '2012/12/11',
-        max: '2012/12/12',
-        format: 'YYYY/MM/DD',
-      })
-    ).rejects.toThrow();
-
-    await expect(
-      validate('2012/12/12', {
-        max: '2012/12/12',
-        min: '2012/12/10',
-        format: 'YYYY/MM/DD',
-        inclusivity: '(]',
-      })
-    ).resolves.toBeTruthy();
-  });
-});

package/tests/dateRange.test.js

@@ -1,97 +0,0 @@
-import { dateRange } from '../src';
-
-describe('DateRange', () => {
-  test('start comes before end', async () => {
-    const schema = dateRange();
-
-    await expect(
-      schema.validate({
-        startDate: '12/14/2012',
-        endDate: '12/13/2012',
-      })
-    ).rejects.toThrow('Start date must come before end date.');
-  });
-
-  test('Invalid Dates', async () => {
-    const schema = dateRange();
-
-    await expect(
-      schema.validate({
-        startDate: '',
-        endDate: '12/14/2012',
-      })
-    ).rejects.toThrow('Start and End Date are required.');
-  });
-
-  test('defines min', async () => {
-    const schema = dateRange().min('12/12/2012');
-
-    const valid = await schema.isValid({
-      startDate: '12/13/2012',
-      endDate: '12/14/2012',
-    });
-
-    expect(valid).toBe(true);
-  });
-
-  test('errors on invalid', async () => {
-    const schema = dateRange().min('12/12/2012');
-
-    const valid = await schema.isValid({
-      startDate: '12/11/2012',
-      endDate: '12/13/2012',
-    });
-
-    expect(valid).toBe(false);
-  });
-});
-
-describe('date', () => {
-  test('should validate', async () => {
-    const schema = dateRange().between('12/10/2012', '12/13/2012');
-
-    const valid = await schema.isValid({
-      startDate: '12/11/2012',
-      endDate: '12/12/2012',
-    });
-
-    expect(valid).toBe(true);
-  });
-
-  test('should work with custom value keys', async () => {
-    const schema = dateRange({
-      startKey: 'helloDate',
-      endKey: 'worldDate',
-    }).between('12/10/2012', '12/13/2012');
-
-    const valid = await schema.isValid({
-      helloDate: '12/11/2012',
-      worldDate: '12/12/2012',
-    });
-
-    expect(valid).toBe(true);
-  });
-
-  test('should validate distance', async () => {
-    const schema = dateRange().distance({
-      min: {
-        value: 5,
-        units: 'day',
-      },
-    });
-
-    let valid = await schema.isValid({
-      startDate: '12/11/2012',
-      endDate: '12/13/2012',
-    });
-
-    expect(valid).toBe(false);
-
-    valid = await schema.isValid({
-      startDate: '12/11/2012',
-      endDate: '12/18/2012',
-    });
-
-    expect(valid).toBe(true);
-  });
-});

package/tests/isRequired.test.js

@@ -1,52 +0,0 @@
-import { array, number, string } from 'yup';
-import '../src';
-
-describe('isRequired', () => {
-  test('should return error on empty input', async () => {
-    const schema = string().isRequired();
-
-    const valid = await schema.isValid('');
-
-    expect(valid).toBe(false);
-  });
-
-  test('should return error on no number', async () => {
-    const schema = number().isRequired();
-
-    const valid = await schema.isValid(null);
-
-    expect(valid).toBe(false);
-  });
-
-  test('should return error on empty array', async () => {
-    const schema = array().isRequired();
-
-    const valid = await schema.isValid([]);
-
-    expect(valid).toBe(false);
-  });
-
-  test('should accept null input', async () => {
-    const schema = string()
-      .isRequired(true)
-      .nullable();
-
-    const valid = await schema.isValid(null);
-
-    expect(valid).toBe(true);
-  });
-
-  test('should accept input', async () => {
-    const schema = string().isRequired(true);
-
-    const valid = await schema.isValid('Test');
-
-    expect(valid).toBe(true);
-  });
-
-  test('should render custom error message', async () => {
-    const schema = string().isRequired(true, 'Test Error Message');
-
-    await expect(schema.validate()).rejects.toThrow('Test Error Message');
-  });
-});

package/tests/npi.test.js

@@ -1,77 +0,0 @@
-import { number, string } from 'yup';
-import '../src';
-
-describe('npi', () => {
-  test('should be valid for empty input', async () => {
-    const schema = string().npi();
-
-    const valid = await schema.isValid('');
-
-    expect(valid).toBe(true);
-  });
-
-  test('should be valid for no number', async () => {
-    const schema = number().npi();
-
-    const valid = await schema.isValid();
-
-    expect(valid).toBe(true);
-  });
-
-  test('should accept null input', async () => {
-    const schema = string()
-      .npi()
-      .nullable();
-
-    const valid = await schema.isValid(null);
-
-    expect(valid).toBe(true);
-  });
-
-  test('should be invalid for invalid input', async () => {
-    const schema = string().npi();
-
-    const valid = await schema.isValid('1234');
-
-    expect(valid).toBe(false);
-  });
-
-  test('should be invalid if NPI contains non-digits', async () => {
-    const schema = number().npi();
-    const valid = await schema.isValid('i2eh56789o');
-    expect(valid).toBe(false);
-  });
-
-  test('should be invalid if NPI is not 10 digits in length', async () => {
-    const schema = number().npi();
-    let valid = await schema.isValid('123456789');
-    expect(valid).toBe(false);
-
-    valid = await schema.isValid('12345678901');
-    expect(valid).toBe(false);
-  });
-
-  test('should be invalid if NPI does not start with a 1, 2, 3, or 4', async () => {
-    const schema = number().npi();
-    const valid = await schema.isValid('5678901234');
-    expect(valid).toBe(false);
-  });
-
-  test('should be invalid if NPI checksum does not match check digit', async () => {
-    const schema = number().npi();
-    const valid = await schema.isValid('1234567890');
-    expect(valid).toBe(false);
-  });
-
-  test('should be valid if NPI is valid', async () => {
-    const schema = number().npi();
-    const valid = await schema.isValid('1234567893');
-    expect(valid).toBe(true);
-  });
-
-  test('should render custom error message', async () => {
-    const schema = number().npi('Test Error Message');
-
-    await expect(schema.validate('123')).rejects.toThrow('Test Error Message');
-  });
-});

package/tests/phone.test.js

@@ -1,62 +0,0 @@
-import { number, string } from 'yup';
-import '../src';
-
-describe('phone', () => {
-  test('should accept empty string', async () => {
-    const schema = string().phone();
-    const valid = await schema.isValid('');
-    expect(valid).toBe(true);
-  });
-
-  test('should accept no number', async () => {
-    const schema = number().phone();
-    const valid = await schema.isValid();
-    expect(valid).toBe(true);
-  });
-
-  test('should accept null input', async () => {
-    const schema = string()
-      .phone()
-      .nullable();
-    const valid = await schema.isValid();
-    expect(valid).toBe(true);
-  });
-
-  test('should not accept less than 10 digits', async () => {
-    const schema = number().phone();
-    const valid = await schema.isValid('123456789');
-    expect(valid).toBe(false);
-  });
-
-  test('should accept country code of "+1" and variations', async () => {
-    const schema = string().phone();
-    expect(await schema.isValid('+14444444444')).toBe(true);
-    expect(await schema.isValid('14444444444')).toBe(true);
-    expect(await schema.isValid('+1 4444444444')).toBe(true);
-    expect(await schema.isValid('1 4444444444')).toBe(true);
-  });
-
-  test('must be 10 digits without country code', async () => {
-    const schema = number().phone();
-    expect(await schema.isValid('4444444444')).toBe(true);
-    expect(await schema.isValid('444 444 4444')).toBe(true);
-    expect(await schema.isValid('44444444445')).toBe(false);
-  });
-
-  test('can be formatted', async () => {
-    const schema = string().phone();
-    expect(await schema.isValid('(444) 444-4444')).toBe(true);
-    expect(await schema.isValid('+1 (444) 444-4444')).toBe(true);
-    expect(await schema.isValid('444-444-4444')).toBe(true);
-    expect(await schema.isValid('+1 444-444-4444')).toBe(true);
-    expect(await schema.isValid('444.444.4444')).toBe(true);
-    expect(await schema.isValid('(444) 444 4444')).toBe(true);
-  });
-
-  test('should display custom error message', async () => {
-    const schema = number().phone('Custom Error Message');
-    await expect(schema.validate('123321')).rejects.toThrow(
-      'Custom Error Message'
-    );
-  });
-});