use-state-validate - npm Package Compare versions

Comparing version 2.2.0 to 2.3.0

dist/index.d.ts

 export interface IStateWithValidation<T> {
-    value: T;
+    errorMessages: string[];
     isDirty: boolean;
+    isRequired: boolean;
     isValid: boolean;
-    isRequired: boolean;
-    errorMessages: string[];
+    type?: string;
+    value: T;
 }
+interface ILength {
+    min?: number;
+    max?: number;
+}
+interface IValidationMessages {
+    required?: boolean;
+    type?: string;
+    length?: string;
+    enum?: string;
+    match?: string;
+    match0?: string;
+    match1?: string;
+    match2?: string;
+    match3?: string;
+    match4?: string;
+    match5?: string;
+    match6?: string;
+    match7?: string;
+    match8?: string;
+    match9?: string;
+    fn?: string;
+    fn0?: string;
+    fn1?: string;
+    fn2?: string;
+    fn3?: string;
+    fn4?: string;
+    fn5?: string;
+    fn6?: string;
+    fn7?: string;
+    fn8?: string;
+    fn9?: string;
+    function?: string;
+    function0?: string;
+    function1?: string;
+    function2?: string;
+    function3?: string;
+    function4?: string;
+    function5?: string;
+    function6?: string;
+    function7?: string;
+    function8?: string;
+    function9?: string;
+}
+export interface IValidationRules<T> {
+    message?: IValidationMessages;
+    required?: boolean;
+    type?: string;
+    length?: ILength;
+    enum?: string[];
+    match?: RegExp;
+    match0?: RegExp;
+    match1?: RegExp;
+    match2?: RegExp;
+    match3?: RegExp;
+    match4?: RegExp;
+    match5?: RegExp;
+    match6?: RegExp;
+    match7?: RegExp;
+    match8?: RegExp;
+    match9?: RegExp;
+    fn?: (value: string) => boolean;
+    fn0?: (value: string) => boolean;
+    fn1?: (value: string) => boolean;
+    fn2?: (value: string) => boolean;
+    fn3?: (value: string) => boolean;
+    fn4?: (value: string) => boolean;
+    fn5?: (value: string) => boolean;
+    fn6?: (value: string) => boolean;
+    fn7?: (value: string) => boolean;
+    fn8?: (value: string) => boolean;
+    fn9?: (value: string) => boolean;
+    function?: (value: string) => boolean;
+    function0?: (value: string) => boolean;
+    function1?: (value: string) => boolean;
+    function2?: (value: string) => boolean;
+    function3?: (value: string) => boolean;
+    function4?: (value: string) => boolean;
+    function5?: (value: string) => boolean;
+    function6?: (value: string) => boolean;
+    function7?: (value: string) => boolean;
+    function8?: (value: string) => boolean;
+    function9?: (value: string) => boolean;
+}
 interface IUseStateValidate<T> extends Array<IStateWithValidation<T> | T | ((newValue: T) => void)> {
@@ -13,3 +97,3 @@ 0: IStateWithValidation<T>;
 }
-export declare const useStateValidate: <T>(initial: T, rules: any) => IUseStateValidate<T>;
+declare const useStateValidate: <T>(initial: T, rules: IValidationRules<T>) => IUseStateValidate<T>;
 export default useStateValidate;

dist/index.js

@@ -1,1 +0,1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.useStateValidate=void 0;var tslib_1=require("tslib"),react_1=require("react"),validateRequired=function(e){return 0===e||Boolean(e)},validateType=function(e,t){return typeof e===t},validateLength=function(e,t){return t.min<=e.length&&e.length<=t.max},validateEnum=function(e,t){return-1<t.indexOf(e)},validateFn=function(e,t){return t(e)},validateMatch=function(e,t){return t.test(e)},errorMessage=function(e,t){if(e.message&&e.message[t])return e.message[t];switch(!0){case/^required$/.test(t):return"is required";case/^type$/.test(t):return"is not of type "+e[t];case/^length$/.test(t):return"value must have a length between "+(null==e?void 0:e.length.min)+" and  "+(null==e?void 0:e.length.max);case/^enum$/.test(t):return"value must be either "+e.enum.join(", ").replace(/\,(?=[^,]*$)/," or");case/^match$/.test(t):return"does not match pattern "+e[t];case/^(function|fn)$/.test(t):return"does not pass function "+e[t]}return"is invalid"},validate=function(t,r){return Object.keys(r).map(function(e){switch(!0){case/^required$/.test(e):return validateRequired(t)?"":errorMessage(r,e);case/^(function|fn)[0-9]*$/.test(e):return validateFn(t,r[e])?"":errorMessage(r,e);case/^match[0-9]*$/.test(e):return validateMatch(t,r[e])?"":errorMessage(r,e);case/^type$/.test(e):return validateType(t,r[e])?"":errorMessage(r,e);case/^length$/.test(e):return validateLength(t,r[e])?"":errorMessage(r,e);case/^enum$/.test(e):return validateEnum(t,r[e])?"":errorMessage(r,e)}}).filter(function(e){return Boolean(e)})},deriveValidateWrapper=function(e,t){var r=validate(e,t);return{value:e,isDirty:!1,isRequired:Boolean(t.required),isValid:0===r.length,errorMessages:r}};exports.useStateValidate=function(e,t){var r=tslib_1.__read(react_1.useState(deriveValidateWrapper(e,t)),2),a=r[0],n=r[1],s=a;return[s,function(e){s=tslib_1.__assign(tslib_1.__assign({},deriveValidateWrapper(e,t)),{isDirty:!0}),n(s)},function(){s=tslib_1.__assign(tslib_1.__assign({},s),{isDirty:!1}),n(s)}]},exports.default=exports.useStateValidate;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var tslib_1=require("tslib"),react_1=require("react"),validateRequired=function(e){return 0===e||Boolean(e)},validateType=function(e,t){return typeof e===t},validateLength=function(e,t){return(t.min||0)<=e.length&&e.length<=(t.max||Number.MIN_VALUE)},validateEnum=function(e,t){return-1<t.indexOf(e)},validateFn=function(e,t){return t(e)},validateMatch=function(e,t){return t.test(e)},errorMessage=function(e,t){var r;if(e.message&&e.message[t])return e.message[t];switch(!0){case/^required$/.test(t):return"is required";case/^type$/.test(t):return"is not of type "+e[t];case/^length$/.test(t):return"value must have a length between "+(null===(r=null==e?void 0:e.length)||void 0===r?void 0:r.min)+" and  "+(null===(r=null==e?void 0:e.length)||void 0===r?void 0:r.max);case/^enum$/.test(t):return"value must be either "+(null===(r=e.enum)||void 0===r?void 0:r.join(", ").replace(/\,(?=[^,]*$)/," or"));case/^match$/.test(t):return"does not match pattern "+e[t];case/^(function|fn)$/.test(t):return"does not pass function "+e[t]}return"is invalid"},validate=function(t,r){return Object.keys(r).map(function(e){switch(!0){case/^required$/.test(e):return validateRequired(t)?"":errorMessage(r,e);case/^(function|fn)[0-9]*$/.test(e):return validateFn(t,r[e])?"":errorMessage(r,e);case/^match[0-9]*$/.test(e):return validateMatch(t,r[e])?"":errorMessage(r,e);case/^type$/.test(e):return validateType(t,r[e])?"":errorMessage(r,e);case/^length$/.test(e):return validateLength(t,r[e])?"":errorMessage(r,e);case/^enum$/.test(e):return validateEnum(t,r[e])?"":errorMessage(r,e)}}).filter(function(e){return Boolean(e)})},deriveValidateWrapper=function(e,t){var r=validate(e,t);return{value:e,isDirty:!1,isRequired:Boolean(t.required),isValid:0===r.length,type:t.type,errorMessages:r}},useStateValidate=function(e,t){var r=tslib_1.__read(react_1.useState(deriveValidateWrapper(e,t)),2),e=r[0],a=r[1],n=e;return[n,function(e){n=tslib_1.__assign(tslib_1.__assign({},deriveValidateWrapper(e,t)),{isDirty:!0}),a(n)},function(){n=tslib_1.__assign(tslib_1.__assign({},n),{isDirty:!1}),a(n)}]};exports.default=useStateValidate;

package.json

 {
   "name": "use-state-validate",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Custom hook to account for state and validation off single state value",
@@ -5,0 +5,0 @@ "license": "MIT",

README.md

@@ -199,2 +199,3 @@ # use-state-validate
 ### Changelog
+* v2.3.0 - Exposes IStateValidateRules
 * v2.2.0 - Adds types to rules object
@@ -201,0 +202,0 @@ * v2.1.0 - Adds types to validation wrapper

No alert changes

Improved metrics

Total package byte prevSize

13565

increased by20.59%

Lines of code

98

increased by600%

Number of lines in readme file

209

increased by0.48%

No dependency changes