react-mui-form-validator 1.5.1 → 1.5.3

package/lib/index.d.ts

@@ -3,165 +3,164 @@ import React__default from 'react';
 import { TextFieldVariants, FilledTextFieldProps, StandardTextFieldProps, OutlinedTextFieldProps } from '@mui/material';
 import { MuiTelInputInfo } from 'mui-tel-input';
 
-interface required {
-    validator: "required";
-}
-interface matchRegexp {
-    validator: "matchRegexp";
-    regexp: RegExp | string;
-}
-interface isEmail {
-    validator: "isEmail";
-}
-interface isEmpty {
-    validator: "isEmpty";
-}
-interface trim {
-    validator: "trim";
-}
-interface isNumber {
-    validator: "isNumber";
-}
-interface isFloat {
-    validator: "isFloat";
-}
-interface isPositive {
-    validator: "isPositive";
-}
-interface maxNumber {
-    validator: "maxNumber";
-    max: number;
-}
-interface minNumber {
-    validator: "minNumber";
-    min: number;
-}
-interface maxFloat {
-    validator: "maxFloat";
-    max: number;
-}
-interface minFloat {
-    validator: "minFloat";
-    min: number;
-}
-interface isString {
-    validator: "isString";
-}
-interface minStringLength {
-    validator: "minStringLength";
-    min: number;
-}
-interface maxStringLength {
-    validator: "maxStringLength";
-    max: number;
-}
-interface isFile {
-    validator: "isFile";
-}
-interface maxFileSize {
-    validator: "maxFileSize";
-    max: number;
-}
-interface allowedExtensions {
-    validator: "allowedExtensions";
-    fileTypes: string;
-}
+interface required {
+    validator: "required";
+}
+interface matchRegexp {
+    validator: "matchRegexp";
+    regexp: RegExp | string;
+}
+interface isEmail {
+    validator: "isEmail";
+}
+interface isEmpty {
+    validator: "isEmpty";
+}
+interface trim {
+    validator: "trim";
+}
+interface isNumber {
+    validator: "isNumber";
+}
+interface isFloat {
+    validator: "isFloat";
+}
+interface isPositive {
+    validator: "isPositive";
+}
+interface maxNumber {
+    validator: "maxNumber";
+    max: number;
+}
+interface minNumber {
+    validator: "minNumber";
+    min: number;
+}
+interface maxFloat {
+    validator: "maxFloat";
+    max: number;
+}
+interface minFloat {
+    validator: "minFloat";
+    min: number;
+}
+interface isString {
+    validator: "isString";
+}
+interface minStringLength {
+    validator: "minStringLength";
+    min: number;
+}
+interface maxStringLength {
+    validator: "maxStringLength";
+    max: number;
+}
+interface isFile {
+    validator: "isFile";
+}
+interface maxFileSize {
+    validator: "maxFileSize";
+    max: number;
+}
+interface allowedExtensions {
+    validator: "allowedExtensions";
+    fileTypes: string;
+}
 type Validator = required | matchRegexp | isEmail | isEmpty | trim | isNumber | isFloat | isPositive | maxNumber | minNumber | maxFloat | minFloat | isString | minStringLength | maxStringLength | isFile | maxFileSize | allowedExtensions;
 
-type MuiTextFieldProps<Variant extends TextFieldVariants = TextFieldVariants> = Variant extends "filled" ? FilledTextFieldProps : Variant extends "standard" ? StandardTextFieldProps : OutlinedTextFieldProps & ValidatorComponentProps;
-interface ValidatorComponentProps {
-    errorMessages?: string | string[];
-    validators?: Validator[];
-    value: any;
-    validatorListener?: (value: boolean) => void;
-    withRequiredValidator?: boolean;
-    containerProps?: object;
-    onChangeTel?: (value: string, info: MuiTelInputInfo) => void;
-}
-interface ValidatorComponentState {
-    isValid?: boolean;
-    value: any;
-    errorMessages?: string | string[];
-    validators?: Validator[];
-}
-interface ValidatorFormProps {
-    onSubmit: () => void;
-    instantValidate?: boolean;
-    children?: React.ReactNode;
-    onError?: (errors: any[]) => void;
-    debounceTime?: number;
+type MuiTextFieldProps<Variant extends TextFieldVariants = TextFieldVariants> = Variant extends "filled" ? FilledTextFieldProps : Variant extends "standard" ? StandardTextFieldProps : OutlinedTextFieldProps & ValidatorComponentProps;
+interface ValidatorComponentProps {
+    errorMessages?: string | string[];
+    validators?: Validator[];
+    value: any;
+    validatorListener?: (value: boolean) => void;
+    withRequiredValidator?: boolean;
+    containerProps?: object;
+    onChangeTel?: (value: string, info: MuiTelInputInfo) => void;
+}
+interface ValidatorComponentState {
+    isValid?: boolean;
+    value: any;
+    errorMessages?: string | string[];
+    validators?: Validator[];
+}
+interface ValidatorFormProps {
+    children: React.ReactNode;
+    onSubmit: () => void;
+    instantValidate?: boolean;
+    onError?: (errors: any) => void;
+    debounceTime?: number;
 }
 
-declare class ValidatorForm extends React$1.Component<ValidatorFormProps> {
-    static getValidator: (value: any, validator: Validator) => boolean;
-    childs: any[];
-    errors: any[];
-    instantValidate: boolean;
-    debounceTime: number | undefined;
-    getFormHelpers: () => {
-        form: {
-            attachToForm: (component: any) => void;
-            debounceTime: number | undefined;
-            detachFromForm: (component: any) => void;
-            instantValidate: boolean | undefined;
-        };
-    };
-    attachToForm: (component: any) => void;
-    detachFromForm: (component: any) => void;
-    submit: (event: React$1.FormEvent<HTMLFormElement>) => void;
-    walk: (children: any[], dryRun?: boolean) => Promise<boolean>;
-    checkInput: (input: any, dryRun?: boolean) => Promise<boolean>;
-    validate: (input: any, includeRequired: boolean, dryRun?: boolean) => Promise<boolean>;
-    find: (collection: any[], fn: (item: any) => boolean) => any;
-    resetValidations: () => void;
-    isFormValid: (dryRun?: boolean) => Promise<boolean>;
-    render(): React$1.JSX.Element;
+declare class ValidatorForm extends React$1.Component<ValidatorFormProps> {
+    static getValidator: (validator: Validator, value: any, includeRequired: boolean) => boolean;
+    getFormHelpers: () => {
+        form: {
+            attachToForm: (component: any) => void;
+            detachFromForm: (component: any) => void;
+            instantValidate: boolean;
+            debounceTime: number;
+        };
+    };
+    instantValidate: boolean;
+    childs: any[];
+    errors: any[];
+    debounceTime: number;
+    attachToForm: (component: any) => void;
+    detachFromForm: (component: any) => void;
+    submit: (event: React$1.FormEvent<HTMLFormElement>) => void;
+    walk: (children: any[], dryRun?: boolean) => Promise<boolean>;
+    checkInput: (input: any, dryRun?: boolean) => Promise<boolean>;
+    validate: (input: any, includeRequired: boolean, dryRun?: boolean) => Promise<boolean>;
+    find: (collection: any[], fn: (item: any) => boolean) => any;
+    resetValidations: () => void;
+    isFormValid: (dryRun?: boolean) => Promise<boolean>;
+    render(): React$1.JSX.Element;
 }
 
-declare class ValidatorComponent extends React$1.Component<MuiTextFieldProps & ValidatorComponentProps, ValidatorComponentState> {
-    renderValidatorComponent(): React$1.ReactNode;
-    form: any;
-    debounceTime: any;
-    validateDebounced: {
-        (value: any, includeRequired?: boolean | undefined, dryRun?: boolean | undefined): void;
-        cancel: () => void;
-    } | any;
-    constructor(props: MuiTextFieldProps & ValidatorComponentProps);
-    getSnapshotBeforeUpdate(nextProps: Readonly<MuiTextFieldProps & ValidatorComponentProps>, prevState: Readonly<ValidatorComponentState>): {
-        value: any;
-        validators: Validator[];
-        errorMessages: string | string[];
-    } | {
-        value: any;
-        validators?: undefined;
-        errorMessages?: undefined;
-    };
-    instantValidate: boolean;
-    invalid: number[];
-    componentDidMount(): void;
-    configure: () => void;
-    shouldComponentUpdate(nextProps: MuiTextFieldProps, nextState: ValidatorComponentState): boolean;
-    componentDidUpdate(prevProps: MuiTextFieldProps, prevState: ValidatorComponentState): void;
-    componentWillUnmount(): void;
-    getErrorMessage: () => string | boolean | string[];
-    validate: (value: any, dryRun?: boolean) => Promise<boolean>;
-    isValid: () => boolean;
-    makeInvalid: () => void;
-    makeValid: () => void;
-    renderComponent: (form: ValidatorForm) => React$1.ReactNode;
-    render(): React$1.JSX.Element;
+declare class ValidatorComponent extends React$1.Component<MuiTextFieldProps & ValidatorComponentProps, ValidatorComponentState> {
+    [x: string]: any;
+    getSnapshotBeforeUpdate(nextProps: ValidatorComponentProps, prevState: ValidatorComponentState): {
+        value: any;
+        validators: Validator[];
+        errorMessages: string | string[];
+    } | {
+        value: any;
+        validators?: undefined;
+        errorMessages?: undefined;
+    };
+    state: {
+        isValid: boolean;
+        value: any;
+        errorMessages: string | string[] | undefined;
+        validators: Validator[] | undefined;
+    };
+    componentDidMount(): void;
+    shouldComponentUpdate(nextProps: ValidatorComponentProps, nextState: ValidatorComponentState): boolean;
+    componentDidUpdate(prevProps: ValidatorComponentProps, prevState: ValidatorComponentState): void;
+    componentWillUnmount(): void;
+    getErrorMessage: () => string | boolean | string[];
+    instantValidate: boolean;
+    invalid: number[];
+    configure: () => void;
+    validate: (value: any, includeRequired?: boolean, dryRun?: boolean) => Promise<boolean>;
+    isValid: () => boolean;
+    makeInvalid: () => void;
+    makeValid: () => void;
+    renderComponent: (form: ValidatorForm) => React$1.ReactNode;
+    render(): React$1.JSX.Element;
 }
 
-declare class MuiSelect extends ValidatorComponent {
-    renderValidatorComponent(): React$1.JSX.Element;
+declare class MuiSelect extends ValidatorComponent {
+    renderValidatorComponent(): React$1.JSX.Element;
 }
 
-declare class MuiTextField extends ValidatorComponent {
-    renderValidatorComponent(): React__default.JSX.Element;
+declare class MuiTextField extends ValidatorComponent {
+    renderValidatorComponent(): React__default.JSX.Element;
 }
 
-declare class MuiTelInputDefault extends ValidatorComponent {
-    renderValidatorComponent(): React__default.JSX.Element;
+declare class MuiTelInputDefault extends ValidatorComponent {
+    renderValidatorComponent(): React__default.JSX.Element;
 }
 
 export { ValidatorComponent as MuiComponent, ValidatorForm as MuiForm, MuiTelInputDefault as MuiPhoneNumber, MuiSelect, MuiTextField, Validator as MuiValidator };

package/lib/index.js

@@ -17372,66 +17372,88 @@ var validations = {
   maxFileSize: (value, max) => isEmpty6(value) || validations.isFile(value) && value.size <= parseInt(max.toString(), 10),
   allowedExtensions: (value, fileTypes) => isEmpty6(value) || validations.isFile(value) && fileTypes.split(",").indexOf(value.type) !== -1
 };
-var ValidationRules_default = validations;
 
 // src/core/validator/ValidatorForm.tsx
 var FormContext = React61.createContext("form");
 var ValidatorForm = class extends React61.Component {
-  static getValidator = (value, validator2) => {
+  static getValidator = (validator2, value, includeRequired) => {
     let valid = validator2;
-    switch (valid.validator) {
-      case "required":
-        return ValidationRules_default.isEmpty(value);
-      case "isEmail":
-        return ValidationRules_default.isEmail(value);
-      case "isEmpty":
-        return ValidationRules_default.isEmpty(value);
-      case "allowedExtensions":
-        return ValidationRules_default.allowedExtensions(value, valid.fileTypes);
-      case "isFile":
-        return ValidationRules_default.isFile(value);
-      case "isFloat":
-        return ValidationRules_default.isFloat(value);
-      case "isNumber":
-        return ValidationRules_default.isNumber(value);
-      case "isPositive":
-        return ValidationRules_default.isPositive(value);
-      case "isString":
-        return ValidationRules_default.isString(value);
-      case "matchRegexp":
-        return ValidationRules_default.matchRegexp(value, valid.regexp);
-      case "maxFileSize":
-        return ValidationRules_default.maxFileSize(value, valid.max);
-      case "maxFloat":
-        return ValidationRules_default.maxFloat(value, valid.max);
-      case "maxNumber":
-        return ValidationRules_default.maxNumber(value, valid.max);
-      case "maxStringLength":
-        return ValidationRules_default.maxStringLength(value, valid.max);
-      case "minFloat":
-        return ValidationRules_default.minFloat(value, valid.min);
-      case "minNumber":
-        return ValidationRules_default.minNumber(value, valid.min);
-      case "minStringLength":
-        return ValidationRules_default.minStringLength(value, valid.min);
-      case "trim":
-        return ValidationRules_default.trim(value);
-      default:
-        return true;
+    let result = true;
+    if (valid.validator !== "required" || includeRequired) {
+      switch (valid.validator) {
+        case "required":
+          result = validations.required(value);
+          break;
+        case "isEmail":
+          result = validations.isEmail(value);
+          break;
+        case "isEmpty":
+          result = validations.isEmpty(value);
+          break;
+        case "allowedExtensions":
+          result = validations.allowedExtensions(value, valid.fileTypes);
+          break;
+        case "isFile":
+          result = validations.isFile(value);
+          break;
+        case "isFloat":
+          result = validations.isFloat(value);
+          break;
+        case "isNumber":
+          result = validations.isNumber(value);
+          break;
+        case "isPositive":
+          result = validations.isPositive(value);
+          break;
+        case "isString":
+          result = validations.isString(value);
+          break;
+        case "matchRegexp":
+          result = validations.matchRegexp(value, valid.regexp);
+          break;
+        case "maxFileSize":
+          result = validations.maxFileSize(value, valid.max);
+          break;
+        case "maxFloat":
+          result = validations.maxFloat(value, valid.max);
+          break;
+        case "maxNumber":
+          result = validations.maxNumber(value, valid.max);
+          break;
+        case "maxStringLength":
+          result = validations.maxStringLength(value, valid.max);
+          break;
+        case "minFloat":
+          result = validations.minFloat(value, valid.min);
+          break;
+        case "minNumber":
+          result = validations.minNumber(value, valid.min);
+          break;
+        case "minStringLength":
+          result = validations.minStringLength(value, valid.min);
+          break;
+        case "trim":
+          result = validations.trim(value);
+          break;
+        default:
+          result = true;
+          break;
+      }
     }
+    return result;
   };
-  childs = [];
-  errors = [];
-  instantValidate = this.props.instantValidate !== void 0 ? this.props.instantValidate : true;
-  debounceTime = this.props.debounceTime;
   getFormHelpers = () => ({
     form: {
       attachToForm: this.attachToForm,
-      debounceTime: this.props.debounceTime,
       detachFromForm: this.detachFromForm,
-      instantValidate: this.props.instantValidate
+      instantValidate: this.instantValidate,
+      debounceTime: this.debounceTime
     }
   });
+  instantValidate = this.props.instantValidate !== void 0 ? this.props.instantValidate : true;
+  childs = [];
+  errors = [];
+  debounceTime = this.props.debounceTime !== void 0 ? this.props.debounceTime : 0;
   attachToForm = (component) => {
     if (this.childs.indexOf(component) === -1) {
       this.childs.push(component);
@@ -17451,7 +17473,9 @@ var ValidatorForm = class extends React61.Component {
     this.errors = [];
     this.walk(this.childs).then((result) => {
       if (this.errors.length) {
-        this.props.onError(this.errors);
+        if (this.props.onError != void 0) {
+          this.props.onError(this.errors);
+        }
       }
       if (result) {
         this.props.onSubmit();
@@ -17561,21 +17585,6 @@ var debounce2 = (func, wait, immediate) => {
 
 // src/core/validator/ValidatorComponent.tsx
 var ValidatorComponent = class extends React62.Component {
-  renderValidatorComponent() {
-    throw new Error("Method not implemented.");
-  }
-  form;
-  debounceTime;
-  validateDebounced;
-  constructor(props) {
-    super(props);
-    this.state = {
-      isValid: true,
-      value: this.props.value,
-      errorMessages: this.props.errorMessages,
-      validators: this.props.validators
-    };
-  }
   getSnapshotBeforeUpdate(nextProps, prevState) {
     if (nextProps.validators && nextProps.errorMessages && (prevState.validators !== nextProps.validators || prevState.errorMessages !== nextProps.errorMessages)) {
       return {
@@ -17588,17 +17597,15 @@ var ValidatorComponent = class extends React62.Component {
       value: nextProps.value
     };
   }
-  instantValidate = true;
-  invalid = [];
+  state = {
+    isValid: true,
+    value: this.props.value,
+    errorMessages: this.props.errorMessages,
+    validators: this.props.validators
+  };
   componentDidMount() {
     this.configure();
   }
-  configure = () => {
-    this.form.attachToForm(this);
-    this.instantValidate = this.form.instantValidate;
-    this.debounceTime = this.form.debounceTime;
-    this.validateDebounced = debounce2(this.validate, this.debounceTime);
-  };
   shouldComponentUpdate(nextProps, nextState) {
     return this.state !== nextState || this.props !== nextProps;
   }
@@ -17617,41 +17624,57 @@ var ValidatorComponent = class extends React62.Component {
   getErrorMessage = () => {
     const { errorMessages } = this.state;
     const type = typeof errorMessages;
-    if (type === "string") {
-      return errorMessages;
-    } else if (type === "object") {
-      if (this.invalid.length > 0) {
-        return errorMessages[this.invalid[0]];
+    if (errorMessages) {
+      if (type === "string") {
+        return errorMessages;
+      } else if (type === "object") {
+        if (this.invalid.length > 0) {
+          return errorMessages[this.invalid[0]];
+        }
       }
     }
     return true;
   };
-  validate = async (value, dryRun = false) => {
-    const validations2 = Promise.all(
-      this.state.validators.map(
-        (validator2) => ValidatorForm_default.getValidator(value, validator2)
-      )
-    );
-    const results = await validations2;
-    this.invalid = [];
-    let valid = true;
-    results.forEach((result, key) => {
-      if (!result) {
-        valid = false;
-        this.invalid.push(key);
-      }
-    });
-    if (!dryRun) {
-      this.setState({ isValid: valid }, () => {
-        if (this.props.validatorListener)
-          this.props.validatorListener(
-            this.state.isValid === void 0 ? false : this.state.isValid
-          );
+  instantValidate = true;
+  invalid = [];
+  configure = () => {
+    this.form.attachToForm(this);
+    this.instantValidate = this.form.instantValidate;
+    this.debounceTime = this.form.debounceTime;
+    this.validateDebounced = debounce2(this.validate, this.debounceTime);
+  };
+  validate = async (value, includeRequired = false, dryRun = false) => {
+    if (this.state.validators) {
+      const validations2 = Promise.all(
+        this.state.validators.map(
+          (validator2) => ValidatorForm_default.getValidator(validator2, value, includeRequired)
+        )
+      );
+      return validations2.then((results) => {
+        this.invalid = [];
+        let valid = true;
+        results.forEach((result, key) => {
+          if (!result) {
+            valid = false;
+            this.invalid.push(key);
+          }
+        });
+        if (!dryRun) {
+          this.setState({ isValid: valid }, () => {
+            if (this.props.validatorListener != void 0) {
+              this.props.validatorListener(
+                this.state.isValid === void 0 ? true : this.state.isValid
+              );
+            }
+          });
+        }
+        return valid;
       });
+    } else {
+      return true;
     }
-    return valid;
   };
-  isValid = () => this.state.isValid === void 0 ? false : this.state.isValid;
+  isValid = () => this.state.isValid === void 0 ? true : this.state.isValid;
   makeInvalid = () => {
     this.setState({ isValid: false });
   };

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "react-mui-form-validator",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "Validator for forms designed with material-ui components.",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "scripts": {
     "prod": "rimraf ./lib && tsup src/index.ts --dts --outDir=lib",
+    "start": "react-scripts start",
     "test": "jest",
     "test:watch": "jest --watch"
   },
@@ -39,12 +38,26 @@
   },
   "devDependencies": {
     "@mui/material": "^5.14.16",
-    "@types/react": "^18.2.33",
+    "@types/node": "^20.8.10",
+    "@types/react": "^18.2.34",
     "@types/react-dom": "^18.2.14",
     "@types/react-lifecycles-compat": "^3.0.3",
     "mui-tel-input": "4.0.1",
     "rimraf": "^5.0.5",
     "tsup": "^7.2.0",
-    "typescript": "^5.2.2"
+    "react-scripts": "5.0.1",
+    "typescript": "^4.9.5"
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
   }
 }

package/tsconfig.json

@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "baseUrl": ".",
     "module": "ESNext",
     "target": "ESNext",
 
@@ -13,7 +14,7 @@
     "allowSyntheticDefaultImports": true,
     "noFallthroughCasesInSwitch": true,
 
-    "outDir": "lib",
+    //"outDir": "lib",
     "declaration": true,
     "moduleResolution": "node",
     "resolveJsonModule": true,