@availity/yup 3.0.10 → 3.2.0

package/CHANGELOG.md

@@ -3,6 +3,48 @@
 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)
+
+
+### Bug Fixes
+
+* **yup:** refactor typeError, use _typeCheck ([24cea5e](https://github.com/Availity/sdk-js/commit/24cea5e2140d72ecec169dfde9fd94eb18956e66))
+
+
+
+
+
+# [3.1.0](https://github.com/Availity/sdk-js/compare/@availity/yup@3.0.11...@availity/yup@3.1.0) (2021-06-11)
+
+
+### Features
+
+* **yup:** support inclusivity option ([94b1283](https://github.com/Availity/sdk-js/commit/94b1283c29e00f0db49ea58ae62d1cf16beef678))
+* **yup:** unit test for inclusivity ([25bf64b](https://github.com/Availity/sdk-js/commit/25bf64bd1fbd9b03ff609d8b8614ce40b7a4f4be))
+
+
+
+
+
+## 3.0.11 (2021-05-25)
+
+**Note:** Version bump only for package @availity/yup
+
+
+
+
+
 ## [3.0.10](https://github.com/Availity/sdk-js/compare/@availity/yup@3.0.9...@availity/yup@3.0.10) (2021-05-17)
 
 **Note:** Version bump only for package @availity/yup

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/date.js

@@ -7,6 +7,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 
+require("core-js/modules/es.function.name.js");
+
 require("core-js/modules/es.array.concat.js");
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
@@ -19,6 +21,10 @@ var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits
 
 var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
 
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
 var _yup = require("yup");
 
 var _moment = _interopRequireDefault(require("moment"));
@@ -34,7 +40,7 @@ var AvDateSchema = /*#__PURE__*/function (_mixed) {
   var _super = (0, _createSuper2["default"])(AvDateSchema);
 
   function AvDateSchema() {
-    var _this;
+    var _thisSuper, _this;
 
     var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultOpts,
         _ref$format = _ref.format,
@@ -48,6 +54,14 @@ var AvDateSchema = /*#__PURE__*/function (_mixed) {
     _this.getValidDate = _this.getValidDate.bind((0, _assertThisInitialized2["default"])(_this));
 
     _this.withMutation(function () {
+      if (!_this.tests.some(function (test) {
+        var _test$OPTIONS;
+
+        return (test === null || test === void 0 ? void 0 : (_test$OPTIONS = test.OPTIONS) === null || _test$OPTIONS === void 0 ? void 0 : _test$OPTIONS.name) === 'typeError';
+      })) {
+        (0, _get2["default"])((_thisSuper = (0, _assertThisInitialized2["default"])(_this), (0, _getPrototypeOf2["default"])(AvDateSchema.prototype)), "typeError", _thisSuper).call(_thisSuper, 'Date is invalid.');
+      }
+
       _this.transform(function mutate(value) {
         return this.getValidDate(value);
       });
@@ -57,36 +71,13 @@ var AvDateSchema = /*#__PURE__*/function (_mixed) {
   }
 
   (0, _createClass2["default"])(AvDateSchema, [{
-    key: "typeError",
-    value: function typeError() {
-      return this.test({
-        message: 'Date is invalid.',
-        name: 'typeError',
-        test: function test(value) {
-          if (value !== undefined) {
-            if (!this.schema.isType(value)) {
-              // Values that do not pass the previous .isType() check are expected to be a moment object
-              // because this.getValidDate(value) will have run. So as long as the passed in value
-              // is defined, moment._i will contain a string value to validate.
-              // If user enters a date and then removes it, should not show a typeError
-              // Note: this does not prevent other tests, like isRequired, from showing messages
-              // If user has touched a required field, error message should still show
-              return value._i === '';
-            } // When this.schema.isType(value) returns true
-            // we are avDate type with appropriate format
-
-
-            return true;
-          }
-
-          return true;
-        }
-      });
-    }
-  }, {
     key: "_typeCheck",
     value: function _typeCheck(value) {
-      return value.isValid();
+      // So as long as the passed in value is defined, moment._i will contain a string value to validate.
+      // If user enters a date and then removes it, should not show a typeError
+      // Note: this does not prevent other tests, like isRequired, from showing messages
+      // If user has touched a required field, required error message should still show
+      return value.isValid() || value._i === '';
     }
   }, {
     key: "getValidDate",
@@ -155,6 +146,7 @@ var AvDateSchema = /*#__PURE__*/function (_mixed) {
   }, {
     key: "between",
     value: function between(min, max, msg) {
+      var inclusivity = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '()';
       var minDate = this.getValidDate(min);
       var maxDate = this.getValidDate(max); // Can't use arrow function because we rely on 'this' referencing yup's internals
 
@@ -169,7 +161,7 @@ var AvDateSchema = /*#__PURE__*/function (_mixed) {
             return true;
           }
 
-          return value.isBetween(minDate, maxDate);
+          return value.isBetween(minDate, maxDate, undefined, inclusivity);
         }
       });
     }

package/lib/dateRange.js

@@ -23,11 +23,11 @@ var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/creat
 
 var _moment = _interopRequireDefault(require("moment"));
 
-var _lodash = _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;
@@ -62,8 +62,8 @@ var DateRangeSchema = /*#__PURE__*/function (_mixed) {
 
     _this.withMutation(function () {
       _this.transform(function mutate(value) {
-        var start = (0, _lodash["default"])(value, startKey);
-        var end = (0, _lodash["default"])(value, endKey);
+        var start = (0, _get["default"])(value, startKey);
+        var end = (0, _get["default"])(value, endKey);
         var startDate;
         var endDate;
 

package/package.json

@@ -1,37 +1,31 @@
 {
   "name": "@availity/yup",
-  "version": "3.0.10",
+  "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.get": "^4.4.2",
-    "merge-options-es5": "^1.0.0"
+  "peerDependencies": {
+    "moment": "^2.24.0",
+    "yup": "^0.28.1"
   },
-  "gitHead": "4e1d7493ccf0ba9e776476efc86088f4324618cd"
+  "gitHead": "a247c20c27816eb3e3b68b983d12631a6cadd72b"
 }

package/src/date.js

@@ -17,39 +17,21 @@ export default class AvDateSchema extends mixed {
     this.getValidDate = this.getValidDate.bind(this);
 
     this.withMutation(() => {
+      if (!this.tests.some((test) => test?.OPTIONS?.name === 'typeError')) {
+        super.typeError('Date is invalid.');
+      }
       this.transform(function mutate(value) {
         return this.getValidDate(value);
       });
     });
   }
 
-  typeError() {
-    return this.test({
-      message: 'Date is invalid.',
-      name: 'typeError',
-      test(value) {
-        if (value !== undefined) {
-          if (!this.schema.isType(value)) {
-            // Values that do not pass the previous .isType() check are expected to be a moment object
-            // because this.getValidDate(value) will have run. So as long as the passed in value
-            // is defined, moment._i will contain a string value to validate.
-            // If user enters a date and then removes it, should not show a typeError
-            // Note: this does not prevent other tests, like isRequired, from showing messages
-            // If user has touched a required field, error message should still show
-            return value._i === '';
-          }
-
-          // When this.schema.isType(value) returns true
-          // we are avDate type with appropriate format
-          return true;
-        }
-        return true;
-      },
-    });
-  }
-
   _typeCheck(value) {
-    return value.isValid();
+    // So as long as the passed in value is defined, moment._i will contain a string value to validate.
+    // If user enters a date and then removes it, should not show a typeError
+    // Note: this does not prevent other tests, like isRequired, from showing messages
+    // If user has touched a required field, required error message should still show
+    return value.isValid() || value._i === '';
   }
 
   getValidDate(value) {
@@ -60,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 },
@@ -78,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 },
@@ -107,7 +87,7 @@ export default class AvDateSchema extends mixed {
     });
   }
 
-  between(min, max, msg) {
+  between(min, max, msg, inclusivity = '()') {
     const minDate = this.getValidDate(min);
 
     const maxDate = this.getValidDate(max);
@@ -117,23 +97,13 @@ 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;
         }
 
-        return value.isBetween(minDate, maxDate);
+        return value.isBetween(minDate, maxDate, undefined, inclusivity);
       },
     });
   }

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,149 +0,0 @@
-import { avDate } from '../src';
-
-const INVALID = 'Date is invalid.';
-
-const defaults = {};
-
-const validate = async (date, { format, min, max, message } = 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 = schema.between(min, max, message);
-  }
-
-  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();
-  });
-
-  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();
-  });
-});

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'
-    );
-  });
-});