@availity/yup 4.1.0 → 4.1.1-alpha.2

package/lib/dateRange.js

@@ -13,8 +13,6 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
-var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
-
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 
 var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
@@ -29,11 +27,11 @@ var _merge2 = _interopRequireDefault(require("lodash/merge"));
 
 var defaultOptions = {
   startKey: 'startDate',
-  endKey: 'endDate',
-  format: 'MM/DD/YYYY'
+  endKey: 'endDate'
 };
 var defaultValue = {};
-var formats = ['YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD'];
+var displayFormat = 'MM/DD/YYYY';
+var formats = [displayFormat, 'YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD'];
 
 var DateRangeSchema = /*#__PURE__*/function (_MixedSchema) {
   (0, _inherits2["default"])(DateRangeSchema, _MixedSchema);
@@ -50,13 +48,10 @@ var DateRangeSchema = /*#__PURE__*/function (_MixedSchema) {
 
     var _merge = (0, _merge2["default"])({}, defaultOptions, options),
         startKey = _merge.startKey,
-        endKey = _merge.endKey,
-        format = _merge.format;
+        endKey = _merge.endKey;
 
     _this.startKey = startKey;
-    _this.endKey = endKey;
-    _this.format = format;
-    _this.getValidDate = _this.getValidDate.bind((0, _assertThisInitialized2["default"])(_this));
+    _this.endKey = endKey; // this.format = format;
 
     _this.withMutation(function (schema) {
       schema.transform(function mutate(value) {
@@ -86,7 +81,7 @@ var DateRangeSchema = /*#__PURE__*/function (_MixedSchema) {
   (0, _createClass2["default"])(DateRangeSchema, [{
     key: "getValidDate",
     value: function getValidDate(value) {
-      return (0, _moment["default"])(value, [this.format].concat(formats), true);
+      return (0, _moment["default"])(value, formats, true);
     }
   }, {
     key: "distance",
@@ -136,10 +131,10 @@ var DateRangeSchema = /*#__PURE__*/function (_MixedSchema) {
   }, {
     key: "min",
     value: function min(_min, message) {
-      var format = this.format;
+      // it works for date, but not daterange. maybe that can tell us more about what is going on
       var minDate = this.getValidDate(_min);
       return this.test({
-        message: message || "Date Range must start on or after ".concat(minDate.format(format)),
+        message: message || "Date Range must start on or after ".concat(minDate.format(displayFormat)),
         name: 'min',
         exclusive: true,
         params: {
@@ -149,21 +144,17 @@ var DateRangeSchema = /*#__PURE__*/function (_MixedSchema) {
           var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
               startDate = _ref3.startDate;
 
-          if (!startDate || !_min) {
-            return true;
-          }
-
-          return minDate.isValid() && minDate.isSameOrBefore(startDate);
+          // is minDate valid and is it before the given date
+          return !startDate || !_min ? true : minDate.isValid() && minDate.isSameOrBefore(startDate);
         }
       });
     }
   }, {
     key: "max",
     value: function max(_max, message) {
-      var format = this.format;
       var maxDate = this.getValidDate(_max);
       return this.test({
-        message: message || "Date Range must end on or before ".concat(maxDate.format(format)),
+        message: message || "Date Range must end on or before ".concat(maxDate.format(displayFormat)),
         name: 'max',
         exclusive: true,
         params: {
@@ -173,19 +164,18 @@ var DateRangeSchema = /*#__PURE__*/function (_MixedSchema) {
           var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultValue,
               endDate = _ref4.endDate;
 
-          if (!endDate || !_max) return true;
-          return maxDate.isValid() && maxDate.isSameOrAfter(endDate);
+          // is maxDate valid and is it after the given date
+          return !endDate || !_max ? true : maxDate.isValid() && maxDate.isSameOrAfter(endDate);
         }
       });
     }
   }, {
     key: "between",
     value: function between(min, max, message) {
-      var format = this.format;
       var minDate = this.getValidDate(min);
       var maxDate = this.getValidDate(max);
       return this.test({
-        message: message || "Date Range must be between ".concat(minDate.format(format), " and ").concat(maxDate.format(format)),
+        message: message || "Date Range must be between ".concat(minDate.format(displayFormat), " and ").concat(maxDate.format(displayFormat)),
         name: 'between',
         exclusive: true,
         params: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@availity/yup",
-  "version": "4.1.0",
+  "version": "4.1.1-alpha.2+3679957",
   "description": "Additional Methods for Yup validation library",
   "main": "lib/index.js",
   "module": "src/index.js",
@@ -27,5 +27,5 @@
     "moment": "^2.24.0",
     "yup": "^0.32.9"
   },
-  "gitHead": "3b66243750e10849b5fbd109d65f935c99f10abf"
+  "gitHead": "36799574f86674e1a41228c10bfba8d303958e02"
 }

package/src/dateRange.js

@@ -6,12 +6,13 @@ import merge from 'lodash/merge';
 const defaultOptions = {
   startKey: 'startDate',
   endKey: 'endDate',
-  format: 'MM/DD/YYYY',
 };
 
 const defaultValue = {};
 
-const formats = ['YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD'];
+const displayFormat = 'MM/DD/YYYY';
+
+const formats = [displayFormat, 'YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD'];
 
 export default class DateRangeSchema extends MixedSchema {
   constructor(options) {
@@ -19,12 +20,11 @@ export default class DateRangeSchema extends MixedSchema {
       type: 'dateRange',
     });
 
-    const { startKey, endKey, format } = merge({}, defaultOptions, options);
+    const { startKey, endKey } = merge({}, defaultOptions, options);
 
     this.startKey = startKey;
     this.endKey = endKey;
-    this.format = format;
-    this.getValidDate = this.getValidDate.bind(this);
+    // this.format = format;
 
     this.withMutation((schema) => {
       schema.transform(function mutate(value) {
@@ -46,7 +46,7 @@ export default class DateRangeSchema extends MixedSchema {
   }
 
   getValidDate(value) {
-    return moment(value, [this.format, ...formats], true);
+    return moment(value, formats, true);
   }
 
   distance({
@@ -85,48 +85,43 @@ export default class DateRangeSchema extends MixedSchema {
   }
 
   min(min, message) {
-    const { format } = this;
-
+    // 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 || `Date Range must start on or after ${minDate.format(format)}`,
+      message: message || `Date Range must start on or after ${minDate.format(displayFormat)}`,
       name: 'min',
       exclusive: true,
       params: { min },
       test({ startDate } = defaultValue) {
-        if (!startDate || !min) {
-          return true;
-        }
-        return minDate.isValid() && minDate.isSameOrBefore(startDate);
+        // is minDate valid and is it before the given date
+        return !startDate || !min ? true : minDate.isValid() && minDate.isSameOrBefore(startDate);
       },
     });
   }
 
   max(max, message) {
-    const { format } = this;
-
     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(displayFormat)}`,
       name: 'max',
       exclusive: true,
       params: { max },
       test({ endDate } = defaultValue) {
-        if (!endDate || !max) return true;
-        return maxDate.isValid() && maxDate.isSameOrAfter(endDate);
+        // is maxDate valid and is it after the given date
+        return !endDate || !max ? true : maxDate.isValid() && maxDate.isSameOrAfter(endDate);
       },
     });
   }
 
   between(min, max, message) {
-    const { format } = this;
-
     const minDate = this.getValidDate(min);
     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(displayFormat)} and ${maxDate.format(displayFormat)}`,
       name: 'between',
       exclusive: true,
       params: { min, max },

package/types/date.d.ts

@@ -1,21 +1,19 @@
-import * as yup from 'yup';
+import { MixedSchema } from 'yup';
 
-declare module 'yup' {
-  interface DateOpts {
-    format?: string | 'MM/DD/YYYY';
-  }
-
-  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>;
-    isRequired(required?: boolean, errorMessage?: string): AvDateSchema<T>;
-  }
+interface DateOpts {
+  format?: string | 'MM/DD/YYYY';
+}
 
-  export interface AvDateSchemaConstructor {
-    (opts: DateOpts): AvDateSchema;
-    new (opts: DateOpts): AvDateSchema;
-  }
+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>;
+  isRequired(required?: boolean, errorMessage?: string): AvDateSchema<T>;
+}
 
-  export const avDate: AvDateSchemaConstructor;
+export interface AvDateSchemaConstructor {
+  (opts?: DateOpts): AvDateSchema;
+  new (opts?: DateOpts): AvDateSchema;
 }
+
+export const avDate: AvDateSchemaConstructor;

package/types/dateRange.d.ts

@@ -1,40 +1,38 @@
-import * as yup from 'yup';
+import { MixedSchema } from 'yup';
 
-declare module 'yup' {
-  type DateRangeObject = {
-    [startDate: any]: string;
-    [endDate: any]: string;
-  };
+type DateRangeObject = {
+  startDate: string;
+  endDate: string;
+};
 
-  interface DateRangeOpts {
-    startKey?: string | 'startDate';
-    endKey?: string | 'endKey';
-    format?: string | 'MM/DD/YYYY';
-  }
-
-  type DistanceValue = {
-    value: number;
-    units?: string;
-    errorMessage?: string;
-  };
+interface DateRangeOpts {
+  startKey?: string | 'startDate';
+  endKey?: string | 'endKey';
+  format?: string | 'MM/DD/YYYY';
+}
 
-  type DistanceOpts = {
-    min?: DistanceValue;
-    max?: DistanceValue;
-  };
+type DistanceValue = {
+  value: number;
+  units?: string;
+  errorMessage?: string;
+};
 
-  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>;
-    isRequired(required?: boolean, errorMessage?: string): DateRangeSchema<T>;
-    distance(distanceOpts: DistanceOpts): DateRangeSchema<T>;
-  }
+type DistanceOpts = {
+  min?: DistanceValue;
+  max?: DistanceValue;
+};
 
-  export interface DateRangeSchemaConstructor {
-    (opts: DateRangeOpts): DateRangeSchema;
-    new (opts: DateRangeOpts): DateRangeSchema;
-  }
+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>;
+  isRequired(required?: boolean, errorMessage?: string): DateRangeSchema<T>;
+  distance(distanceOpts: DistanceOpts): DateRangeSchema<T>;
+}
 
-  export const dateRange: DateRangeSchemaConstructor;
+export interface DateRangeSchemaConstructor {
+  (opts?: DateRangeOpts): DateRangeSchema;
+  new (opts?: DateRangeOpts): DateRangeSchema;
 }
+
+export const dateRange: DateRangeSchemaConstructor;

package/types/index.d.ts

@@ -1,25 +1,28 @@
 import * as yup from 'yup';
-import './dateRange.d.ts';
-import './date.d.ts';
+
+import { dateRange } from './dateRange';
+import { avDate } from './date';
+
+export { avDate, dateRange };
 
 declare module 'yup' {
-  interface StringSchema<T extends string | null | undefined = string> extends Schema<T> {
+  interface StringSchema<T extends string | null | undefined = string> extends yup.StringSchema<T> {
     isRequired(required?: boolean, errorMessage?: string): StringSchema<T>;
     npi(errorMessage?: string): StringSchema<T>;
     phone(errorMessage?: string): StringSchema<T>;
   }
 
-  interface ArraySchema<T> extends BasicArraySchema<T[]> {
+  interface ArraySchema<T> extends yup.ArraySchema<T[]> {
     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 yup.NumberSchema<T> {
     isRequired(required?: boolean, errorMessage?: string): NumberSchema<T>;
     npi(errorMessage?: string): NumberSchema<T>;
     phone(errorMessage?: string): NumberSchema<T>;
   }
 
-  interface ObjectSchema<T> extends Schema<T> {
-    isRequired(required?: boolean, errorMessage?: string): ObjectSchema<T>;
+  interface ObjectSchema<TShape extends Record<string, any>> extends yup.ObjectSchema<TShape> {
+    isRequired(required?: boolean, errorMessage?: string): ObjectSchema<TShape>;
   }
 }