@availity/yup 4.1.0 → 5.0.0

package/.eslintrc.yml

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

package/CHANGELOG.md

@@ -1,7 +1,34 @@
-# Change Log
+# Changelog
+
+This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
+
+# [5.0.0](https://github.com/Availity/sdk-js/compare/@availity/yup@4.2.0...@availity/yup@5.0.0) (2022-04-28)
+
+
+* build!: switch from lerna to nx and compile to esm with tsup ([c586085](https://github.com/Availity/sdk-js/commit/c5860856ca96b743a0653d335ea00f0889132f7f))
+
+
+### BREAKING CHANGES
+
+* Drop Internet Explorer support
+
+
+
+# 4.2.0 (2021-12-21)
+
+
+### Bug Fixes
+
+* **yup:** conditional logic fix ([3679957](https://github.com/Availity/sdk-js/commit/36799574f86674e1a41228c10bfba8d303958e02))
+
+
+### Features
+
+* **yup:** convert to ts and fix undefined class property ([f5a3a4f](https://github.com/Availity/sdk-js/commit/f5a3a4f944a0ae281e0eaabf3b6a38659a2acc71))
+
+
+
 
-All notable changes to this project will be documented in this file.
-See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
 # 4.1.0 (2021-11-18)
 

package/README.md

@@ -1,8 +1,10 @@
-# yup
+# @availity/yup
 
-> Method extensions for the [yup](https://github.com/jquense/yup)
+> Method extensions for [yup](https://github.com/jquense/yup)
 
 [![Version](https://img.shields.io/npm/v/@availity/yup.svg?style=for-the-badge)](https://www.npmjs.com/package/@availity/yup)
+[![NPM Downloads](https://img.shields.io/npm/dt/@availity/yup.svg?style=for-the-badge)](https://www.npmjs.com/package/@availity/yup)
+[![Dependecy Status](https://img.shields.io/librariesio/release/npm/@availity/yup?style=for-the-badge)](https://github.com/Availity/sdk-js/blob/master/packages/yup/package.json)
 
 ## Install
 
@@ -18,4 +20,8 @@ npm install @availity/yup yup
 yarn add @availity/yup yup
 ```
 
-## [Documentation](https://availity.github.io/sdk-js/resources/yup)
+> You will need to also install [moment](https://www.npmjs.com/package/moment) if you plan on using the `date` or `dateRange` schemas
+
+## Documentation
+
+Check out more documentation at [availity.github.io](https://availity.github.io/sdk-js/resources/yup)

package/dist/index.d.ts

@@ -0,0 +1,88 @@
+import { Maybe, AnyObject, Optionals } from 'yup/lib/types';
+import BaseSchema, { AnySchema } from 'yup/lib/schema';
+import { TypeOf, Asserts } from 'yup/lib/util/types';
+import { ObjectShape, TypeOfShape, AssertsShape } from 'yup/lib/object';
+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;
+    min(min: string, message?: string): this;
+    max(max: string, message?: string): this;
+    isRequired(isRequired?: boolean, msg?: string): this;
+    between(min: string, max: string, msg?: string, inclusivity?: Inclusivity): this;
+}
+declare type Inclusivity = '()' | '[)' | '(]' | '[]';
+declare type Options$1 = {
+    format?: string;
+};
+declare const avDate: (opts?: Options$1 | undefined) => AvDateSchema;
+
+declare class DateRangeSchema extends MixedSchema<DateRange> {
+    startKey: string;
+    endKey: string;
+    format: string;
+    constructor(options?: Options);
+    getValidDate(value: string | Date | Moment): moment.Moment;
+    distance({ min: { value: minValue, units: minUnits, errorMessage: minErrorMessage }, max: { value: maxValue, units: maxUnits, errorMessage: maxErrorMessage }, }?: DistanceOptions): this;
+    min(min: string, message?: string): this;
+    max(max: string, message?: string): this;
+    between(min: string, max: string, message?: string): this;
+    isRequired(isRequired?: boolean, msg?: string): this;
+    typeError({ message }: {
+        message: string;
+    }): this;
+    _typeCheck(range?: {
+        startDate?: Moment;
+        endDate?: Moment;
+    }): range is DateRange;
+}
+declare type Options = {
+    startKey?: string;
+    endKey?: string;
+    format?: string;
+};
+declare type DateRange = {
+    startDate?: Moment;
+    endDate?: Moment;
+    supportedFormats?: string[];
+};
+declare type DistanceValue = {
+    value: number;
+    units?: unitOfTime.DurationConstructor;
+    errorMessage?: string;
+};
+declare type DistanceOptions = {
+    min?: DistanceValue;
+    max?: DistanceValue;
+};
+declare const dateRange: (opts?: Options | undefined) => DateRangeSchema;
+
+declare module 'yup' {
+    interface StringSchema<TType extends Maybe<string> = string | undefined, TContext extends AnyObject = AnyObject, TOut extends TType = TType> extends BaseSchema<TType, TContext, TOut> {
+        isRequired(required?: boolean, errorMessage?: string): StringSchema<TType, TContext>;
+        npi(errorMessage?: string): StringSchema<TType, TContext>;
+        phone(errorMessage?: string): StringSchema<TType, TContext>;
+    }
+    interface NumberSchema<TType extends Maybe<number> = number | undefined, TContext extends AnyObject = AnyObject, TOut extends TType = TType> extends BaseSchema<TType, TContext, TOut> {
+        isRequired(required?: boolean, errorMessage?: string): NumberSchema<TType, TContext, TOut>;
+        npi(errorMessage?: string): NumberSchema<TType, TContext, TOut>;
+        phone(errorMessage?: string): NumberSchema<TType, TContext, TOut>;
+    }
+    interface ArraySchema<T extends AnySchema | Lazy<any, any>, C extends AnyObject = AnyObject, TIn extends Maybe<TypeOf<T>[]> = TypeOf<T>[] | undefined, TOut extends Maybe<Asserts<T>[]> = Asserts<T>[] | Optionals<TIn>> extends BaseSchema<TIn, C, TOut> {
+        isRequired(required?: boolean, errorMessage?: string): ArraySchema<T, C, TIn, TOut>;
+    }
+    interface ObjectSchema<TShape extends ObjectShape, TContext extends AnyObject = AnyObject, TIn extends Maybe<TypeOfShape<TShape>> = TypeOfShape<TShape>, TOut extends Maybe<AssertsShape<TShape>> = AssertsShape<TShape> | Optionals<TIn>> extends BaseSchema<TIn, TContext, TOut> {
+        isRequired(required?: boolean, errorMessage?: string): ObjectSchema<TShape, TContext, TIn, TOut>;
+    }
+}
+
+export { avDate, dateRange };

package/dist/index.js

@@ -0,0 +1,353 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  avDate: () => avDate,
+  dateRange: () => dateRange
+});
+module.exports = __toCommonJS(src_exports);
+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;
+    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 (0, import_moment.default)(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
+var import_yup2 = require("yup");
+var import_moment2 = __toESM(require("moment"));
+var import_get = __toESM(require("lodash/get"));
+var import_merge = __toESM(require("lodash/merge"));
+var defaultOptions = {
+  startKey: "startDate",
+  endKey: "endDate",
+  format: "MM/DD/YYYY"
+};
+var formats2 = ["YYYY-MM-DD", "MMDDYYYY", "YYYYMMDD"];
+var DateRangeSchema = class extends import_yup2.MixedSchema {
+  constructor(options) {
+    super({
+      type: "dateRange"
+    });
+    const { startKey, endKey, format } = (0, import_merge.default)({}, defaultOptions, options);
+    this.startKey = startKey;
+    this.endKey = endKey;
+    this.format = format;
+    this.withMutation((schema) => {
+      schema.transform(function mutate(value) {
+        const start = (0, import_get.default)(value, startKey);
+        const end = (0, import_get.default)(value, endKey);
+        return {
+          startDate: start ? schema.getValidDate(start) : start,
+          endDate: end ? schema.getValidDate(end) : end,
+          supportedFormats: [schema.format, ...formats2]
+        };
+      });
+    });
+  }
+  getValidDate(value) {
+    return (0, import_moment2.default)(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 import_yup2.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 import_yup2.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 = (0, import_moment2.default)(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 = (0, import_moment2.default)(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 = (0, import_moment2.default)(min, supportedFormats, true);
+        const maxDate = (0, import_moment2.default)(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 import_yup2.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
+(0, import_yup3.addMethod)(import_yup3.array, "isRequired", isRequired_default);
+(0, import_yup3.addMethod)(import_yup3.number, "isRequired", isRequired_default);
+(0, import_yup3.addMethod)(import_yup3.object, "isRequired", isRequired_default);
+(0, import_yup3.addMethod)(import_yup3.string, "isRequired", isRequired_default);
+(0, import_yup3.addMethod)(import_yup3.number, "npi", npi_default);
+(0, import_yup3.addMethod)(import_yup3.string, "npi", npi_default);
+(0, import_yup3.addMethod)(import_yup3.number, "phone", phone_default);
+(0, import_yup3.addMethod)(import_yup3.string, "phone", phone_default);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  avDate,
+  dateRange
+});