@availity/yup 5.0.0 → 5.1.1

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [5.1.1](https://github.com/Availity/sdk-js/compare/@availity/yup@5.1.0...@availity/yup@5.1.1) (2022-05-24)
+
+
+
+# [5.1.0](https://github.com/Availity/sdk-js/compare/@availity/yup@5.0.1...@availity/yup@5.1.0) (2022-05-20)
+
+
+### Features
+
+* **yup:** update how accepted formats are handled for dates ([91006e5](https://github.com/Availity/sdk-js/commit/91006e564766e2bb66cdabc24dd2cdd69bc8b150))
+
+
+
+## [5.0.1](https://github.com/Availity/sdk-js/compare/@availity/yup@5.0.0...@availity/yup@5.0.1) (2022-04-28)
+
+
+### Bug Fixes
+
+* add browser field for output ([0ce7170](https://github.com/Availity/sdk-js/commit/0ce717075a82675b8707e4db0cc07cd4af370f3d))
+
+
+
 # [5.0.0](https://github.com/Availity/sdk-js/compare/@availity/yup@4.2.0...@availity/yup@5.0.0) (2022-04-28)
 
 

package/dist/index.d.ts

@@ -6,36 +6,64 @@ import Lazy from 'yup/lib/Lazy';
 import { MixedSchema } from 'yup';
 import moment, { Moment, unitOfTime } from 'moment';
 
-declare class AvDateSchema extends MixedSchema<Moment> {
-    format: string;
-    constructor({ format }?: Options$1);
-    _typeCheck(value: Moment & {
-        _i: string;
-    }): value is Moment & {
-        _i: string;
-    };
-    getValidDate(value: string | Date | Moment): moment.Moment;
+declare class MomentDateSchema extends MixedSchema<Moment> {
+    _validFormats: string[];
+    constructor({ format, typeError }?: Options$1);
+    _typeCheck(value: unknown): value is Moment;
+    /**
+     * Validate if the date is on or after a specified min
+     */
     min(min: string, message?: string): this;
+    /**
+     * Validate if the date is on or before a specified max
+     */
     max(max: string, message?: string): this;
-    isRequired(isRequired?: boolean, msg?: string): this;
-    between(min: string, max: string, msg?: string, inclusivity?: Inclusivity): this;
+    /**
+     * Validate if the date is between a specified min or max
+     *
+     * For Inlcusivity: `[]` === include & `()` === exclude
+     */
+    between(min: string, max: string, message?: string, inclusivity?: Inclusivity): this;
+    /**
+     * Set if the field is required and add a custom message
+     */
+    isRequired(isRequired?: boolean, message?: string): this;
 }
 declare type Inclusivity = '()' | '[)' | '(]' | '[]';
 declare type Options$1 = {
-    format?: string;
+    format?: string | string[];
+    typeError?: string;
 };
-declare const avDate: (opts?: Options$1 | undefined) => AvDateSchema;
+declare const avDate: (options?: Options$1 | undefined) => MomentDateSchema;
 
 declare class DateRangeSchema extends MixedSchema<DateRange> {
     startKey: string;
     endKey: string;
     format: string;
     constructor(options?: Options);
+    /**
+     * Convert the string to a moment object
+     */
     getValidDate(value: string | Date | Moment): moment.Moment;
+    /**
+     * Validate based on min and max distance between dates
+     */
     distance({ min: { value: minValue, units: minUnits, errorMessage: minErrorMessage }, max: { value: maxValue, units: maxUnits, errorMessage: maxErrorMessage }, }?: DistanceOptions): this;
+    /**
+     * Validate start date is after given min
+     */
     min(min: string, message?: string): this;
+    /**
+     * Validate end date is before given max
+     */
     max(max: string, message?: string): this;
+    /**
+     * Validate dates are between the set min and max
+     */
     between(min: string, max: string, message?: string): this;
+    /**
+     * Set the field to be required or not
+     */
     isRequired(isRequired?: boolean, msg?: string): this;
     typeError({ message }: {
         message: string;

package/dist/index.js

@@ -31,91 +31,82 @@ var import_yup3 = require("yup");
 // src/date.ts
 var import_yup = require("yup");
 var import_moment = __toESM(require("moment"));
-var formats = ["YYYY-MM-DD", "MMDDYYYY", "YYYYMMDD", "MM-DD-YYYY"];
-var AvDateSchema = class extends import_yup.MixedSchema {
-  constructor({ format = "MM/DD/YYYY" } = {}) {
-    super({
-      type: "avDate"
-    });
-    this.format = format;
+var defaultFormats = ["YYYY-MM-DD", "YYYYMMDD", "MMDDYYYY", "MM-DD-YYYY", "MM/DD/YYYY"];
+var MomentDateSchema = class extends import_yup.MixedSchema {
+  constructor({ format = [], typeError = "The date entered is in an invalid format." } = {}) {
+    super({ type: "avDate" });
+    const formats2 = Array.isArray(format) ? format : [format];
+    this._validFormats = [...defaultFormats, ...formats2];
     this.withMutation((schema) => {
-      if (!schema.tests.some((test) => {
-        var _a;
-        return ((_a = test == null ? void 0 : test.OPTIONS) == null ? void 0 : _a.name) === "typeError";
-      })) {
-        super.typeError("Date is invalid.");
-      }
-      schema.transform(function mutate(value) {
-        return schema.getValidDate(value);
+      schema.typeError(typeError);
+      schema.transform(function transform(value, originalValue) {
+        if (value && this.isType(value)) {
+          return value;
+        }
+        return (0, import_moment.default)(originalValue, schema._validFormats, true);
       });
     });
   }
   _typeCheck(value) {
-    return value.isValid() || value._i === "";
-  }
-  getValidDate(value) {
-    return (0, import_moment.default)(value, [this.format, ...formats], true);
+    return import_moment.default.isMoment(value) && (value.isValid() || value._i === "");
   }
   min(min, message) {
-    const minDate = this.getValidDate(min);
     return this.test({
-      message: message || `Date must be ${minDate.format(this.format)} or later.`,
+      message: ({ min: minDate }) => message || `Date must be ${minDate} or later.`,
       name: "min",
       exclusive: true,
       params: { min },
       test(value) {
-        if (!min || !minDate.isValid()) {
+        if (!min || !value || !value.isValid()) {
           return true;
         }
-        return value === null || minDate.isSameOrBefore(value);
+        return value.isSameOrAfter(min);
       }
     });
   }
   max(max, message) {
-    const maxDate = this.getValidDate(max);
     return this.test({
-      message: message || `Date must be ${maxDate.format(this.format)} or earlier.`,
+      message: ({ max: maxDate }) => message || `Date must be ${maxDate} or earlier.`,
       name: "max",
       exclusive: true,
       params: { max },
       test(value) {
-        if (!max || !maxDate.isValid()) {
+        if (!max || !value || !value.isValid()) {
           return true;
         }
-        return value === null || maxDate.isSameOrAfter(value);
+        return value.isSameOrBefore(max);
       }
     });
   }
-  isRequired(isRequired2 = true, msg) {
+  between(min, max, message, inclusivity = "()") {
     return this.test({
-      name: "isRequired",
+      name: "between",
       exclusive: true,
-      message: msg || "This field is required.",
+      message: ({ min: minDate, max: maxDate }) => message || `Date must be between ${minDate} and ${maxDate}.`,
+      params: { min, max },
       test(value) {
-        if (!isRequired2) {
+        if (!value || !value.isValid() || !min || !max) {
           return true;
         }
-        return value !== void 0;
+        return value.isBetween(min, max, void 0, inclusivity);
       }
     });
   }
-  between(min, max, msg, inclusivity = "()") {
-    const minDate = this.getValidDate(min);
-    const maxDate = this.getValidDate(max);
+  isRequired(isRequired2 = true, message) {
     return this.test({
-      name: "between",
+      name: "isRequired",
       exclusive: true,
-      message: msg || `Date must be between ${minDate.format(this.format)} and ${maxDate.format(this.format)}.`,
+      message: message || "This field is required.",
       test(value) {
-        if (!value || !min || !max || !minDate.isValid() || !maxDate.isValid()) {
+        if (!isRequired2) {
           return true;
         }
-        return value.isBetween(minDate, maxDate, void 0, inclusivity);
+        return value ? !!value._i : false;
       }
     });
   }
 };
-var avDate = (opts) => new AvDateSchema(opts);
+var avDate = (options) => new MomentDateSchema(options);
 
 // src/dateRange.ts
 var import_yup2 = require("yup");
@@ -127,7 +118,7 @@ var defaultOptions = {
   endKey: "endDate",
   format: "MM/DD/YYYY"
 };
-var formats2 = ["YYYY-MM-DD", "MMDDYYYY", "YYYYMMDD"];
+var formats = ["YYYY-MM-DD", "YYYYMMDD", "MMDDYYYY", "MM-DD-YYYY", "MM/DD/YYYY"];
 var DateRangeSchema = class extends import_yup2.MixedSchema {
   constructor(options) {
     super({
@@ -144,13 +135,13 @@ var DateRangeSchema = class extends import_yup2.MixedSchema {
         return {
           startDate: start ? schema.getValidDate(start) : start,
           endDate: end ? schema.getValidDate(end) : end,
-          supportedFormats: [schema.format, ...formats2]
+          supportedFormats: [schema.format, ...formats]
         };
       });
     });
   }
   getValidDate(value) {
-    return (0, import_moment2.default)(value, [this.format, ...formats2], true);
+    return (0, import_moment2.default)(value, [this.format, ...formats], true);
   }
   distance({
     min: { value: minValue, units: minUnits = "day", errorMessage: minErrorMessage } = { value: 0 },

package/dist/index.mjs

@@ -4,91 +4,82 @@ import { addMethod, array, number, object, string } from "yup";
 // src/date.ts
 import { MixedSchema } from "yup";
 import moment from "moment";
-var formats = ["YYYY-MM-DD", "MMDDYYYY", "YYYYMMDD", "MM-DD-YYYY"];
-var AvDateSchema = class extends MixedSchema {
-  constructor({ format = "MM/DD/YYYY" } = {}) {
-    super({
-      type: "avDate"
-    });
-    this.format = format;
+var defaultFormats = ["YYYY-MM-DD", "YYYYMMDD", "MMDDYYYY", "MM-DD-YYYY", "MM/DD/YYYY"];
+var MomentDateSchema = class extends MixedSchema {
+  constructor({ format = [], typeError = "The date entered is in an invalid format." } = {}) {
+    super({ type: "avDate" });
+    const formats2 = Array.isArray(format) ? format : [format];
+    this._validFormats = [...defaultFormats, ...formats2];
     this.withMutation((schema) => {
-      if (!schema.tests.some((test) => {
-        var _a;
-        return ((_a = test == null ? void 0 : test.OPTIONS) == null ? void 0 : _a.name) === "typeError";
-      })) {
-        super.typeError("Date is invalid.");
-      }
-      schema.transform(function mutate(value) {
-        return schema.getValidDate(value);
+      schema.typeError(typeError);
+      schema.transform(function transform(value, originalValue) {
+        if (value && this.isType(value)) {
+          return value;
+        }
+        return moment(originalValue, schema._validFormats, true);
       });
     });
   }
   _typeCheck(value) {
-    return value.isValid() || value._i === "";
-  }
-  getValidDate(value) {
-    return moment(value, [this.format, ...formats], true);
+    return moment.isMoment(value) && (value.isValid() || value._i === "");
   }
   min(min, message) {
-    const minDate = this.getValidDate(min);
     return this.test({
-      message: message || `Date must be ${minDate.format(this.format)} or later.`,
+      message: ({ min: minDate }) => message || `Date must be ${minDate} or later.`,
       name: "min",
       exclusive: true,
       params: { min },
       test(value) {
-        if (!min || !minDate.isValid()) {
+        if (!min || !value || !value.isValid()) {
           return true;
         }
-        return value === null || minDate.isSameOrBefore(value);
+        return value.isSameOrAfter(min);
       }
     });
   }
   max(max, message) {
-    const maxDate = this.getValidDate(max);
     return this.test({
-      message: message || `Date must be ${maxDate.format(this.format)} or earlier.`,
+      message: ({ max: maxDate }) => message || `Date must be ${maxDate} or earlier.`,
       name: "max",
       exclusive: true,
       params: { max },
       test(value) {
-        if (!max || !maxDate.isValid()) {
+        if (!max || !value || !value.isValid()) {
           return true;
         }
-        return value === null || maxDate.isSameOrAfter(value);
+        return value.isSameOrBefore(max);
       }
     });
   }
-  isRequired(isRequired2 = true, msg) {
+  between(min, max, message, inclusivity = "()") {
     return this.test({
-      name: "isRequired",
+      name: "between",
       exclusive: true,
-      message: msg || "This field is required.",
+      message: ({ min: minDate, max: maxDate }) => message || `Date must be between ${minDate} and ${maxDate}.`,
+      params: { min, max },
       test(value) {
-        if (!isRequired2) {
+        if (!value || !value.isValid() || !min || !max) {
           return true;
         }
-        return value !== void 0;
+        return value.isBetween(min, max, void 0, inclusivity);
       }
     });
   }
-  between(min, max, msg, inclusivity = "()") {
-    const minDate = this.getValidDate(min);
-    const maxDate = this.getValidDate(max);
+  isRequired(isRequired2 = true, message) {
     return this.test({
-      name: "between",
+      name: "isRequired",
       exclusive: true,
-      message: msg || `Date must be between ${minDate.format(this.format)} and ${maxDate.format(this.format)}.`,
+      message: message || "This field is required.",
       test(value) {
-        if (!value || !min || !max || !minDate.isValid() || !maxDate.isValid()) {
+        if (!isRequired2) {
           return true;
         }
-        return value.isBetween(minDate, maxDate, void 0, inclusivity);
+        return value ? !!value._i : false;
       }
     });
   }
 };
-var avDate = (opts) => new AvDateSchema(opts);
+var avDate = (options) => new MomentDateSchema(options);
 
 // src/dateRange.ts
 import { MixedSchema as MixedSchema2, ValidationError } from "yup";
@@ -100,7 +91,7 @@ var defaultOptions = {
   endKey: "endDate",
   format: "MM/DD/YYYY"
 };
-var formats2 = ["YYYY-MM-DD", "MMDDYYYY", "YYYYMMDD"];
+var formats = ["YYYY-MM-DD", "YYYYMMDD", "MMDDYYYY", "MM-DD-YYYY", "MM/DD/YYYY"];
 var DateRangeSchema = class extends MixedSchema2 {
   constructor(options) {
     super({
@@ -117,13 +108,13 @@ var DateRangeSchema = class extends MixedSchema2 {
         return {
           startDate: start ? schema.getValidDate(start) : start,
           endDate: end ? schema.getValidDate(end) : end,
-          supportedFormats: [schema.format, ...formats2]
+          supportedFormats: [schema.format, ...formats]
         };
       });
     });
   }
   getValidDate(value) {
-    return moment2(value, [this.format, ...formats2], true);
+    return moment2(value, [this.format, ...formats], true);
   }
   distance({
     min: { value: minValue, units: minUnits = "day", errorMessage: minErrorMessage } = { value: 0 },

package/jest.config.js

@@ -1,11 +1,7 @@
+const global = require('../../jest.config');
+
 module.exports = {
+  ...global,
   displayName: 'yup',
-  preset: '../../jest.preset.js',
-  globals: {
-    'ts-jest': {
-      tsconfig: '<rootDir>/tsconfig.spec.json',
-    },
-  },
   coverageDirectory: '../../coverage/yup',
-  coverageReporters: ['json'],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@availity/yup",
-  "version": "5.0.0",
+  "version": "5.1.1",
   "description": "Additional methods for yup validation library",
   "keywords": [
     "yup",
@@ -18,6 +18,7 @@
   },
   "license": "MIT",
   "author": "Kyle Gray <kyle.gray@availity.com>",
+  "browser": "./dist/index.js",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -36,8 +37,8 @@
   },
   "devDependencies": {
     "moment": "^2.24.0",
-    "tsup": "^5.10.1",
-    "typescript": "^4.5.3"
+    "tsup": "^5.12.8",
+    "typescript": "^4.6.4"
   },
   "peerDependencies": {
     "moment": "^2.24.0"

package/project.json

@@ -18,6 +18,22 @@
         "tagPrefix": "@availity/${projectName}@",
         "baseBranch": "master"
       }
+    },
+    "lint": {
+      "executor": "@nrwl/linter:eslint",
+      "options": {
+        "eslintConfig": ".eslintrc.yaml",
+        "lintFilePatterns": ["packages/yup/**/*.{js,ts}"],
+        "silent": false,
+        "fix": false,
+        "cache": true,
+        "cacheLocation": "./node_modules/.cache/yup/.eslintcache",
+        "maxWarnings": -1,
+        "quiet": false,
+        "noEslintrc": false,
+        "hasTypeAwareRules": true,
+        "cacheStrategy": "metadata"
+      }
     }
   }
 }

package/src/date.ts

@@ -1,112 +1,120 @@
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 import { MixedSchema } from 'yup';
-import moment, { Moment } from 'moment';
+import moment from 'moment';
+import type { Moment } from 'moment';
 
-const formats = ['YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD', 'MM-DD-YYYY'];
+const defaultFormats = ['YYYY-MM-DD', 'YYYYMMDD', 'MMDDYYYY', 'MM-DD-YYYY', 'MM/DD/YYYY'];
 
-export default class AvDateSchema extends MixedSchema<Moment> {
-  format: string;
+export default class MomentDateSchema extends MixedSchema<Moment> {
+  _validFormats: string[];
 
-  constructor({ format = 'MM/DD/YYYY' }: Options = {}) {
-    super({
-      type: 'avDate',
-    });
+  constructor({ format = [], typeError = 'The date entered is in an invalid format.' }: Options = {}) {
+    super({ type: 'avDate' });
 
-    this.format = format;
+    const formats = Array.isArray(format) ? format : [format];
+    this._validFormats = [...defaultFormats, ...formats];
 
     this.withMutation((schema) => {
-      if (!schema.tests.some((test) => test?.OPTIONS?.name === 'typeError')) {
-        super.typeError('Date is invalid.');
-      }
-      schema.transform(function mutate(value) {
-        return schema.getValidDate(value);
+      // Set error message for when _typeCheck fails
+      schema.typeError(typeError);
+
+      // Transform value into a moment object
+      schema.transform(function transform(value, originalValue) {
+        if (value && this.isType(value)) {
+          return value;
+        }
+        return moment(originalValue, schema._validFormats, true);
       });
     });
   }
 
-  _typeCheck(value: Moment & { _i: string }): value is Moment & { _i: string } {
-    // 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: string | Date | Moment) {
-    return moment(value, [this.format, ...formats], true);
+  // Check if the date is a valid moment object or an empty string
+  _typeCheck(value: unknown): value is Moment {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return moment.isMoment(value) && (value.isValid() || value._i === '');
   }
 
+  /**
+   * Validate if the date is on or after a specified min
+   */
   min(min: string, message?: string) {
-    const minDate = this.getValidDate(min);
-
     return this.test({
-      message: message || `Date must be ${minDate.format(this.format)} or later.`,
+      message: ({ min: minDate }) => message || `Date must be ${minDate} or later.`,
       name: 'min',
       exclusive: true,
       params: { min },
       test(value) {
-        if (!min || !minDate.isValid()) {
+        // First check if min is defined and we have a valid date
+        if (!min || !value || !value.isValid()) {
           return true;
         }
-        return value === null || minDate.isSameOrBefore(value);
+        return value.isSameOrAfter(min);
       },
     });
   }
 
+  /**
+   * Validate if the date is on or before a specified max
+   */
   max(max: string, message?: string) {
-    const maxDate = this.getValidDate(max);
-
     return this.test({
-      message: message || `Date must be ${maxDate.format(this.format)} or earlier.`,
+      message: ({ max: maxDate }) => message || `Date must be ${maxDate} or earlier.`,
       name: 'max',
       exclusive: true,
       params: { max },
       test(value) {
-        if (!max || !maxDate.isValid()) {
+        // First check if max is defined and we have a valid date
+        if (!max || !value || !value.isValid()) {
           return true;
         }
-        return value === null || maxDate.isSameOrAfter(value);
+        return value.isSameOrBefore(max);
       },
     });
   }
 
-  isRequired(isRequired = true, msg?: string) {
+  /**
+   * Validate if the date is between a specified min or max
+   *
+   * For Inlcusivity: `[]` === include & `()` === exclude
+   */
+  between(min: string, max: string, message?: string, inclusivity: Inclusivity = '()') {
     return this.test({
-      name: 'isRequired',
+      name: 'between',
       exclusive: true,
-      message: msg || 'This field is required.',
+      message: ({ min: minDate, max: maxDate }) => message || `Date must be between ${minDate} and ${maxDate}.`,
+      params: { min, max },
       test(value) {
-        if (!isRequired) {
+        // First check if min and max are defined and we have a valid date
+        if (!value || !value.isValid() || !min || !max) {
           return true;
         }
 
-        return value !== undefined;
+        return value.isBetween(min, max, undefined, inclusivity);
       },
     });
   }
 
-  between(min: string, max: string, msg?: string, inclusivity: Inclusivity = '()') {
-    const minDate = this.getValidDate(min);
-    const maxDate = this.getValidDate(max);
-
-    // Can't use arrow function because we rely on 'this' referencing yup's internals
+  /**
+   * Set if the field is required and add a custom message
+   */
+  isRequired(isRequired = true, message?: string) {
     return this.test({
-      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)}.`,
+      name: 'isRequired',
+      exclusive: true,
+      message: message || 'This field is required.',
       test(value) {
-        if (!value || !min || !max || !minDate.isValid() || !maxDate.isValid()) {
+        if (!isRequired) {
           return true;
         }
-
-        return value.isBetween(minDate, maxDate, undefined, inclusivity);
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return value ? !!value._i : false;
       },
     });
   }
 }
 
 export type Inclusivity = '()' | '[)' | '(]' | '[]';
-type Options = { format?: string };
+type Options = { format?: string | string[]; typeError?: string };
 
-export const avDate = (opts?: Options): AvDateSchema => new AvDateSchema(opts);
+export const avDate = (options?: Options) => new MomentDateSchema(options);

package/src/dateRange.ts

@@ -1,6 +1,6 @@
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 import { MixedSchema, ValidationError } from 'yup';
-import moment, { Moment, unitOfTime } from 'moment';
+import moment, { unitOfTime } from 'moment';
+import type { Moment } from 'moment';
 import get from 'lodash/get';
 import merge from 'lodash/merge';
 
@@ -10,7 +10,7 @@ const defaultOptions = {
   format: 'MM/DD/YYYY',
 };
 
-const formats = ['YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD'];
+const formats = ['YYYY-MM-DD', 'YYYYMMDD', 'MMDDYYYY', 'MM-DD-YYYY', 'MM/DD/YYYY'];
 
 export default class DateRangeSchema extends MixedSchema<DateRange> {
   startKey: string;
@@ -45,11 +45,16 @@ export default class DateRangeSchema extends MixedSchema<DateRange> {
     });
   }
 
-  // Convert the string to a moment object
+  /**
+   * Convert the string to a moment object
+   */
   getValidDate(value: string | Date | Moment) {
     return moment(value, [this.format, ...formats], true);
   }
 
+  /**
+   * Validate based on min and max distance between dates
+   */
   distance({
     min: { value: minValue, units: minUnits = 'day', errorMessage: minErrorMessage } = { value: 0 },
     max: { value: maxValue, units: maxUnits = 'day', errorMessage: maxErrorMessage } = { value: 0 },
@@ -89,20 +94,20 @@ export default class DateRangeSchema extends MixedSchema<DateRange> {
     });
   }
 
+  /**
+   * Validate start date is after given min
+   */
   min(min: string, message?: string) {
-    // it works for date, but not daterange. maybe that can tell us more about what is going on
-    // const minDate = this.getValidDate(min);
-
     return this.test({
       message: message || (({ min }: { min: string }) => `Date Range must start on or after ${min}`),
       name: 'min',
       exclusive: true,
       params: { min },
       test({ startDate, supportedFormats } = {}) {
-        // return true when no startDate or min set
+        // Only validate if startDate and min are defined
         if (!startDate || !min) return true;
 
-        // otherwise check if min is correct format and is after given startDate
+        // Otherwise check if min is correct format and is after given startDate
         const minDate = moment(min, supportedFormats, true);
 
         return minDate.isValid() && minDate.isSameOrBefore(startDate);
@@ -110,6 +115,9 @@ export default class DateRangeSchema extends MixedSchema<DateRange> {
     });
   }
 
+  /**
+   * Validate end date is before given max
+   */
   max(max: string, message?: string) {
     // const maxDate = this.getValidDate(max);
 
@@ -130,6 +138,9 @@ export default class DateRangeSchema extends MixedSchema<DateRange> {
     });
   }
 
+  /**
+   * Validate dates are between the set min and max
+   */
   between(min: string, max: string, message?: string) {
     // const minDate = this.getValidDate(min);
     // const maxDate = this.getValidDate(max);
@@ -153,6 +164,9 @@ export default class DateRangeSchema extends MixedSchema<DateRange> {
     });
   }
 
+  /**
+   * Set the field to be required or not
+   */
   isRequired(isRequired = true, msg?: string) {
     return this.test({
       name: 'isRequired',
@@ -206,7 +220,6 @@ type Options = { startKey?: string; endKey?: string; format?: string };
 type DateRange = { startDate?: Moment; endDate?: Moment; supportedFormats?: string[] };
 type DistanceValue = {
   value: number;
-  // unitOfTime namespace is provided by moment library
   units?: unitOfTime.DurationConstructor;
   errorMessage?: string;
 };

package/.eslintrc.yml

@@ -1,2 +0,0 @@
-extends: ../../.eslintrc.yml
-ignorePatterns: ['!**/*', 'node_modules/', 'lib/', 'dist/']