@availity/yup 4.1.0 → 5.0.0

package/dist/index.mjs

@@ -0,0 +1,325 @@
+// src/index.ts
+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;
+    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);
+      });
+    });
+  }
+  _typeCheck(value) {
+    return value.isValid() || value._i === "";
+  }
+  getValidDate(value) {
+    return moment(value, [this.format, ...formats], true);
+  }
+  min(min, message) {
+    const minDate = this.getValidDate(min);
+    return this.test({
+      message: message || `Date must be ${minDate.format(this.format)} or later.`,
+      name: "min",
+      exclusive: true,
+      params: { min },
+      test(value) {
+        if (!min || !minDate.isValid()) {
+          return true;
+        }
+        return value === null || minDate.isSameOrBefore(value);
+      }
+    });
+  }
+  max(max, message) {
+    const maxDate = this.getValidDate(max);
+    return this.test({
+      message: message || `Date must be ${maxDate.format(this.format)} or earlier.`,
+      name: "max",
+      exclusive: true,
+      params: { max },
+      test(value) {
+        if (!max || !maxDate.isValid()) {
+          return true;
+        }
+        return value === null || maxDate.isSameOrAfter(value);
+      }
+    });
+  }
+  isRequired(isRequired2 = true, msg) {
+    return this.test({
+      name: "isRequired",
+      exclusive: true,
+      message: msg || "This field is required.",
+      test(value) {
+        if (!isRequired2) {
+          return true;
+        }
+        return value !== void 0;
+      }
+    });
+  }
+  between(min, max, msg, inclusivity = "()") {
+    const minDate = this.getValidDate(min);
+    const maxDate = this.getValidDate(max);
+    return this.test({
+      name: "between",
+      exclusive: true,
+      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()) {
+          return true;
+        }
+        return value.isBetween(minDate, maxDate, void 0, inclusivity);
+      }
+    });
+  }
+};
+var avDate = (opts) => new AvDateSchema(opts);
+
+// src/dateRange.ts
+import { MixedSchema as MixedSchema2, ValidationError } from "yup";
+import moment2 from "moment";
+import get from "lodash/get";
+import merge from "lodash/merge";
+var defaultOptions = {
+  startKey: "startDate",
+  endKey: "endDate",
+  format: "MM/DD/YYYY"
+};
+var formats2 = ["YYYY-MM-DD", "MMDDYYYY", "YYYYMMDD"];
+var DateRangeSchema = class extends MixedSchema2 {
+  constructor(options) {
+    super({
+      type: "dateRange"
+    });
+    const { startKey, endKey, format } = merge({}, defaultOptions, options);
+    this.startKey = startKey;
+    this.endKey = endKey;
+    this.format = format;
+    this.withMutation((schema) => {
+      schema.transform(function mutate(value) {
+        const start = get(value, startKey);
+        const end = get(value, endKey);
+        return {
+          startDate: start ? schema.getValidDate(start) : start,
+          endDate: end ? schema.getValidDate(end) : end,
+          supportedFormats: [schema.format, ...formats2]
+        };
+      });
+    });
+  }
+  getValidDate(value) {
+    return moment2(value, [this.format, ...formats2], true);
+  }
+  distance({
+    min: { value: minValue, units: minUnits = "day", errorMessage: minErrorMessage } = { value: 0 },
+    max: { value: maxValue, units: maxUnits = "day", errorMessage: maxErrorMessage } = { value: 0 }
+  } = {}) {
+    return this.test({
+      name: "distance",
+      exclusive: true,
+      test({ endDate, startDate } = {}) {
+        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);
+        }
+        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 true;
+      }
+    });
+  }
+  min(min, message) {
+    return this.test({
+      message: message || (({ min: min2 }) => `Date Range must start on or after ${min2}`),
+      name: "min",
+      exclusive: true,
+      params: { min },
+      test({ startDate, supportedFormats } = {}) {
+        if (!startDate || !min)
+          return true;
+        const minDate = moment2(min, supportedFormats, true);
+        return minDate.isValid() && minDate.isSameOrBefore(startDate);
+      }
+    });
+  }
+  max(max, message) {
+    return this.test({
+      message: message || (({ max: max2 }) => `Date Range must end on or before ${max2}`),
+      name: "max",
+      exclusive: true,
+      params: { max },
+      test({ endDate, supportedFormats } = {}) {
+        if (!endDate || !max)
+          return true;
+        const maxDate = moment2(max, supportedFormats, true);
+        return maxDate.isValid() && maxDate.isSameOrAfter(endDate);
+      }
+    });
+  }
+  between(min, max, message) {
+    return this.test({
+      message: message || (({ min: min2, max: max2 }) => `Date Range must be between ${min2} and ${max2}`),
+      name: "between",
+      exclusive: true,
+      params: { min, max },
+      test({ startDate, endDate, supportedFormats } = {}) {
+        if (!startDate || !endDate || !min || !max)
+          return true;
+        const minDate = moment2(min, supportedFormats, true);
+        const maxDate = moment2(max, supportedFormats, true);
+        return maxDate.isValid() && minDate.isValid() && maxDate.isSameOrAfter(endDate) && minDate.isSameOrBefore(startDate);
+      }
+    });
+  }
+  isRequired(isRequired2 = true, msg) {
+    return this.test({
+      name: "isRequired",
+      exclusive: true,
+      message: msg || "This field is required.",
+      test({ startDate, endDate } = {}) {
+        return !isRequired2 || !!(startDate && endDate);
+      }
+    });
+  }
+  typeError({ message }) {
+    return this.test({
+      name: "typeError",
+      exclusive: true,
+      test({ startDate, endDate } = {}) {
+        const errors = [];
+        if ((!startDate || !endDate) && (startDate || endDate)) {
+          errors.push(message || "Start and End Date are required.");
+        }
+        if (startDate && endDate && !startDate.isSameOrBefore(endDate)) {
+          errors.push("Start date must come before end date.");
+        }
+        if (startDate && !startDate.isValid()) {
+          errors.push("Start Date is invalid.");
+        }
+        if (endDate && !endDate.isValid()) {
+          errors.push("End Date is invalid.");
+        }
+        return errors.length > 0 ? new ValidationError(errors, { startDate, endDate }, this.path) : true;
+      }
+    });
+  }
+  _typeCheck(range = {}) {
+    const { startDate, endDate } = range;
+    return !!startDate && !!endDate && startDate.isValid() && endDate.isValid();
+  }
+};
+var dateRange = (opts) => new DateRangeSchema(opts);
+
+// src/isRequired.ts
+function isRequired(isRequired2 = true, msg) {
+  return this.test({
+    name: "isRequired",
+    exclusive: true,
+    message: msg || "This field is required.",
+    test(value) {
+      if (isRequired2) {
+        if (this.schema.type === "array") {
+          return Array.isArray(value) ? value.length > 0 : value !== void 0;
+        }
+        if (this.schema.type === "string") {
+          return value !== void 0 && value !== "";
+        }
+        return value !== void 0;
+      }
+      return true;
+    }
+  });
+}
+var isRequired_default = isRequired;
+
+// src/npi.ts
+var INTEGER_REGEX = /^\d*$/;
+function npi(msg) {
+  return this.test({
+    name: "npi",
+    exclusive: true,
+    message: msg || "This field is invalid.",
+    test(value) {
+      if (!value)
+        return true;
+      value += "";
+      if (!INTEGER_REGEX.test(value) || value.length !== 10) {
+        return false;
+      }
+      const firstDigit = value.charAt(0);
+      if (["1", "2", "3", "4"].indexOf(firstDigit) < 0) {
+        return false;
+      }
+      const digit = Number.parseInt(value.charAt(9), 10);
+      value = value.substring(0, 9);
+      value = `80840${value}`;
+      let alternate = true;
+      let total = 0;
+      for (let i = value.length; i > 0; i--) {
+        let next = Number.parseInt(value.charAt(i - 1), 10);
+        if (alternate) {
+          next *= 2;
+          if (next > 9) {
+            next = next % 10 + 1;
+          }
+        }
+        total += next;
+        alternate = !alternate;
+      }
+      const roundUp = Math.ceil(total / 10) * 10;
+      const calculatedCheck = roundUp - total;
+      return calculatedCheck === digit;
+    }
+  });
+}
+var npi_default = npi;
+
+// src/phone.ts
+var NANP_REGEXP = /^(\+?1[\s.-]?)?\(?[2-9]\d{2}[\s).-]?\s?[2-9]\d{2}[\s.-]?\d{4}$/;
+function phone(msg) {
+  return this.test({
+    name: "phone",
+    exclusive: true,
+    message: msg || "This field is invalid",
+    test(value) {
+      if (!value)
+        return true;
+      return NANP_REGEXP.test(value);
+    }
+  });
+}
+var phone_default = phone;
+
+// src/index.ts
+addMethod(array, "isRequired", isRequired_default);
+addMethod(number, "isRequired", isRequired_default);
+addMethod(object, "isRequired", isRequired_default);
+addMethod(string, "isRequired", isRequired_default);
+addMethod(number, "npi", npi_default);
+addMethod(string, "npi", npi_default);
+addMethod(number, "phone", phone_default);
+addMethod(string, "phone", phone_default);
+export {
+  avDate,
+  dateRange
+};

package/jest.config.js

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

package/package.json

@@ -1,31 +1,48 @@
 {
   "name": "@availity/yup",
-  "version": "4.1.0",
-  "description": "Additional Methods for Yup validation library",
-  "main": "lib/index.js",
-  "module": "src/index.js",
-  "types": "types/index.d.ts",
+  "version": "5.0.0",
+  "description": "Additional methods for yup validation library",
   "keywords": [
     "yup",
-    "availity"
+    "availity",
+    "validation"
   ],
-  "author": "Kyle Gray <kyle.gray@availity.com>",
+  "homepage": "https://availity.github.io/sdk-js/resources/yup",
+  "bugs": {
+    "url": "https://github.com/Availity/sdk-js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Availity/sdk-js.git",
+    "directory": "packages/yup"
+  },
   "license": "MIT",
-  "publishConfig": {
-    "access": "public"
+  "author": "Kyle Gray <kyle.gray@availity.com>",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "clean": "rm -rf node_modules && rm -rf dist",
+    "bundlesize": "bundlesize",
+    "publish": "yarn npm publish --tolerate-republish --access public"
   },
   "dependencies": {
-    "@babel/runtime": "^7.10.2",
-    "core-js": "^3.12.1",
-    "lodash": "^4.17.21"
+    "lodash": "^4.17.21",
+    "yup": "^0.32.0"
   },
   "devDependencies": {
     "moment": "^2.24.0",
-    "yup": "^0.32.9"
+    "tsup": "^5.10.1",
+    "typescript": "^4.5.3"
   },
   "peerDependencies": {
-    "moment": "^2.24.0",
-    "yup": "^0.32.9"
+    "moment": "^2.24.0"
   },
-  "gitHead": "3b66243750e10849b5fbd109d65f935c99f10abf"
-}
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/project.json

@@ -0,0 +1,23 @@
+{
+  "root": "packages/yup",
+  "projectType": "library",
+  "targets": {
+    "test": {
+      "executor": "@nrwl/jest:jest",
+      "outputs": ["coverage/yup"],
+      "options": {
+        "jestConfig": "packages/yup/jest.config.js",
+        "passWithNoTests": true
+      }
+    },
+    "version": {
+      "executor": "@jscutlery/semver:version",
+      "options": {
+        "preset": "angular",
+        "commitMessageFormat": "chore(${projectName}): release version ${version} [skip ci]",
+        "tagPrefix": "@availity/${projectName}@",
+        "baseBranch": "master"
+      }
+    }
+  }
+}

package/src/{date.js → date.ts}

@@ -1,20 +1,18 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 import { MixedSchema } from 'yup';
-import moment from 'moment';
-
-const defaultOpts = {
-  format: 'MM/DD/YYYY',
-};
+import moment, { Moment } from 'moment';
 
 const formats = ['YYYY-MM-DD', 'MMDDYYYY', 'YYYYMMDD', 'MM-DD-YYYY'];
 
-export default class AvDateSchema extends MixedSchema {
-  constructor({ format = 'MM/DD/YYYY' } = defaultOpts) {
+export default class AvDateSchema extends MixedSchema<Moment> {
+  format: string;
+
+  constructor({ format = 'MM/DD/YYYY' }: Options = {}) {
     super({
       type: 'avDate',
     });
 
     this.format = format;
-    this.getValidDate = this.getValidDate.bind(this);
 
     this.withMutation((schema) => {
       if (!schema.tests.some((test) => test?.OPTIONS?.name === 'typeError')) {
@@ -26,7 +24,7 @@ export default class AvDateSchema extends MixedSchema {
     });
   }
 
-  _typeCheck(value) {
+  _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
@@ -34,11 +32,11 @@ export default class AvDateSchema extends MixedSchema {
     return value.isValid() || value._i === '';
   }
 
-  getValidDate(value) {
+  getValidDate(value: string | Date | Moment) {
     return moment(value, [this.format, ...formats], true);
   }
 
-  min(min, message) {
+  min(min: string, message?: string) {
     const minDate = this.getValidDate(min);
 
     return this.test({
@@ -50,12 +48,12 @@ export default class AvDateSchema extends MixedSchema {
         if (!min || !minDate.isValid()) {
           return true;
         }
-        return value === null || minDate.isSameOrBefore(value, 'MM/DD/YYYY');
+        return value === null || minDate.isSameOrBefore(value);
       },
     });
   }
 
-  max(max, message) {
+  max(max: string, message?: string) {
     const maxDate = this.getValidDate(max);
 
     return this.test({
@@ -72,7 +70,7 @@ export default class AvDateSchema extends MixedSchema {
     });
   }
 
-  isRequired(isRequired = true, msg) {
+  isRequired(isRequired = true, msg?: string) {
     return this.test({
       name: 'isRequired',
       exclusive: true,
@@ -87,9 +85,8 @@ export default class AvDateSchema extends MixedSchema {
     });
   }
 
-  between(min, max, msg, 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
@@ -108,3 +105,8 @@ export default class AvDateSchema extends MixedSchema {
     });
   }
 }
+
+export type Inclusivity = '()' | '[)' | '(]' | '[]';
+type Options = { format?: string };
+
+export const avDate = (opts?: Options): AvDateSchema => new AvDateSchema(opts);