@coxy/react-validator 2.0.6 → 3.0.0

package/README.md

@@ -1,28 +1,30 @@
-### React Validator
- 
+# @Coxy/react-validator
 
-[![MIT License](https://img.shields.io/apm/l/atomic-design-ui.svg?)](https://github.com/dsshard/react-validator/blob/master/LICENSE)
-[![Travis CI](https://travis-ci.org/dsshard/react-validator.svg?branch=master)](https://travis-ci.org/dsshard/react-validator)
-[![CodeCov](https://codecov.io/gh/dsshard/react-validator/branch/master/graph/badge.svg)](https://codecov.io/gh/dsshard/react-validator)
-[![Coverage Status](https://coveralls.io/repos/github/dsshard/react-validator/badge.svg?branch=master)](https://coveralls.io/github/dsshard/react-validator?branch=master)
-[![dependencies Status](https://david-dm.org/dsshard/react-validator/status.svg)](https://david-dm.org/dsshard/react-validator)
-[![Maintainability](https://api.codeclimate.com/v1/badges/a30e71d313f2d8bdd6b1/maintainability)](https://codeclimate.com/github/dsshard/react-validator/maintainability)
-[![BundlePhobia](https://badgen.net/bundlephobia/minzip/@coxy/react-validator)](https://bundlephobia.com/result?p=@coxy/react-validator)
-[![GitHub Release](https://img.shields.io/github/release/dsshard/react-validator.svg?style=flat)]()  
+---
 
+# Simple React Form Validation
 
-Simple React form validation.
+@Coxy/react-validator provides a simple and flexible way to validate forms in React.
 
-Data validation on the **Node JS** side, is also supported.
+> Supports data validation both **in-browser** and **on Node.js**.
 
+> Requires React **\>=16.3**.
 
-Need react **>=16.3**
+---
 
-# Example
+# Installation
 
-See more examples [here](example/example.tsx)
+```bash
+npm install @coxy/react-validator
+# or
+yarn add @coxy/react-validator
+```
+
+---
+
+# Quick Start Example
 
-```jsx
+```tsx
 import React, { useState } from 'react';
 import { ValidatorWrapper, rules, ValidatorField } from '@coxy/react-validator';
 
@@ -34,174 +36,197 @@ const handleSubmit = () => {
     console.log(isValid, message, errors);
     return;
   }
-  // Success
+  alert('Form is valid!');
 };
 
-export default () => {
-  const [email, handleChange] = useState('');
+export default function Example() {
+  const [email, setEmail] = useState('');
 
   return (
     <ValidatorWrapper ref={validator}>
-
       <ValidatorField value={email} rules={rules.email}>
         {({ isValid, message }) => (
           <>
-            <input value={email} onChange={({ target: { value } }) => handleChange(value)} />
-            {!isValid && <div>{message}</div>}
+            <input value={email} onChange={({ target: { value } }) => setEmail(value)} />
+            {!isValid && <div style={{ color: 'red' }}>{message}</div>}
           </>
         )}
       </ValidatorField>
 
-      <ValidatorField value={email} rules={rules.email}>
-        <input value={email} onChange={({ target: { value } }) => handleChange(value)} />
-      </ValidatorField>
-
-      {/* This is also possible :) */}
-      <ValidatorField value={email} rules={rules.email} />
-
       <button onClick={handleSubmit} type="button">
         Submit
       </button>
-
     </ValidatorWrapper>
   );
-};
+}
 ```
 
-See more examples [here](example/example.tsx)
-&nbsp;
-# Rules
+More examples available [here](example/example.tsx).
+
+---
 
-You can create your own rules for validation, with your own error messages
+# Built-in Validation Rules
 
+Create your own rules easily, or use the built-in ones:
 
 ```javascript
 const rules = {
-  email: [{
-    rule: value => value !== '' && value.length > 0,
-    message: 'Value is required',
-  }, {
-    rule: value => value.indexOf('@') > -1,
-    message: '@ is required',
-  }]
-}
+  email: [
+    { rule: value => value.trim() !== '', message: 'Value is required' },
+    { rule: value => value.includes('@'), message: '@ is required' },
+  ],
+  password: [
+    { rule: value => value.length >= 6, message: 'Password must be at least 6 characters' },
+  ],
+  notEmpty: [
+    { rule: value => !!value && value.trim() !== '', message: 'Field cannot be empty' },
+  ],
+  boolean: [
+    { rule: value => typeof value === 'boolean', message: 'Must be a boolean value' },
+  ],
+  min: (min) => ([
+    { rule: value => Number(value) >= min, message: `Must be at least ${min}` },
+  ]),
+  max: (max) => ([
+    { rule: value => Number(value) <= max, message: `Must be at most ${max}` },
+  ]),
+  length: (min, max) => ([
+    { rule: value => value.length >= min, message: `Must be at least ${min} characters` },
+    ...(max ? [{ rule: value => value.length <= max, message: `Must be at most ${max} characters` }] : [])
+  ]),
+};
 ```
 
-This component has a default set of rules that you can use right away:
+| Name        | Type     | Description                                               |
+|-------------|----------|-----------------------------------------------------------|
+| email       | Array    | Validate non-empty email with regex check.                |
+| password    | Array    | Validate non-empty password with min length.              |
+| notEmpty    | Array    | Check if a string is not empty.                           |
+| boolean     | Array    | Ensure a boolean value is present.                        |
+| min(n)      | Function | Validate number is >= `n`.                                |
+| max(n)      | Function | Validate number is <= `n`.                                |
+| length(a,b) | Function | Validate string length is between `a` and `b` (optional). |
 
-| ****name**** | **Type** | **description**                                                         |
-|--------------|----------|-------------------------------------------------------------------------|
-| email        |          | Check email for empty string and regexp                                 |
-| password     |          | Check password for empty string and length                              |
-| notEmpty     |          | Check if the string is not empty                                        |
-| boolean      |          | Will check that the value is present                                    |
-| min          | function | min\(3\) \-> Check the number                                           |
-| max          | function | max\(5\) \-> Check the number                                           |
-| length       | function | length\(3, 5\) \-> Check string length \(second parameter is optional\) |
+---
 
-&nbsp;
+# React API
 
-# Api for React
+## `<ValidatorWrapper />` Props
 
-#### ValidatorWrapper props
+| Name             | Default | Required | Description                                        |
+|------------------|---------|----------|----------------------------------------------------|
+| ref              | null    | No       | React ref or useRef for control.                   |
+| stopAtFirstError | false   | No       | Stop validating after the first error.             |
 
-| **name**         | **default** | **required** | **description**                                        |
-|------------------|-------------|--------------|--------------------------------------------------------|
-| ref              | null        | no           | React\.ref or useRef                                   |
-| stopAtFirstError | false       | no           | The validator will stop checking after the first error |
+## `<ValidatorField />` Props
 
-&nbsp;
-#### ValidatorField props
+| Name     | Default   | Required | Description                           |
+|----------|-----------|----------|---------------------------------------|
+| value    | undefined | Yes      | Value to validate.                    |
+| rules    | []        | Yes      | Validation rules array.               |
+| required | true      | No       | Whether the field is required.        |
+| id       | null      | No       | ID for the field (for manual access). |
 
-| ****name**** | ****default**** | ****required**** | **description**               |
-|--------------|-----------------|------------------|-------------------------------|
-| value        | undefined       | yes              | Value for validation          |
-| rules        | \[\]            | yes              | Array of rules for validation |
-| required     | true            | no               | The field will be required    |
-| id           | null            | no               | ID for get field              |
+## `useValidator`
 
-&nbsp;
-# React api useValidator
+Validate a value directly in your component:
 
-```javascript
+```tsx
+import { useValidator, rules } from '@coxy/react-validator';
 
-const [isValid, { errors }] = useValidator('test value', rules.email)
-console.log(isValid, errors) // false
+const [isValid, { errors }] = useValidator('test@example.com', rules.email);
 
+console.log(isValid); // true or false
+console.log(errors);  // array of error messages
 ```
 
-&nbsp;
-# Api for inline validation
+---
 
-#### Validator constructor parameters
+# Validator Class (Node.js / Manual Usage)
 
-| **name**         | **default** | **required** | **description**                                        |
-|------------------|-------------|--------------|--------------------------------------------------------|
-| stopAtFirstError | false       | no           | The validator will stop checking after the first error |
+Use it server-side or in custom flows.
 
-&nbsp;
-#### Validator.addField()
+## Validator Constructor Options
 
-Adds a field for validation
+| Name             | Default | Required | Description                                          |
+|------------------|---------|----------|------------------------------------------------------|
+| stopAtFirstError | false   | No       | Stop validating after first error across all fields. |
 
-```javascript
-import { Validator } from '@coxy/react-validator';
+## Methods
+
+### `.addField()`
 
+```javascript
 const validator = new Validator({ stopAtFirstError: true });
+
 const field = validator.addField({
-    rules: rules.password,
-    value: '',
+  rules: rules.password,
+  value: '12345',
 });
 ```
-&nbsp;
-#### Validator.getField()
 
-Returns the field by ID
+### `.getField(id)`
 
 ```javascript
-import { Validator } from '@coxy/react-validator';
+const field = validator.getField('password-field');
+console.log(field);
+```
 
-const validator = new Validator({ stopAtFirstError: true });
-const field = validator.addField({
-    rules: rules.password,
-    value: '',
-    id: 'test-field-name'
-});
-console.log(validator.getField('test-field-name')) // Field Class
+### `.removeField(field)`
+
+```javascript
+validator.removeField(field);
 ```
-&nbsp;
-#### Validator.removeField()
 
-Removes a previously added field
+### `.validate()`
+
+```javascript
+const { isValid, message, errors } = validator.validate();
+console.log(isValid, errors);
+```
 
+## Full Server-Side Example
 
 ```javascript
-import { Validator } from '@coxy/react-validator';
+import { Validator, rules } from '@coxy/react-validator';
 
-const validator = new Validator({ stopAtFirstError: true });
-const field = validator.addField({
-    rules: rules.password,
-    value: '',
-    id: 'test-field-name'
+const validator = new Validator();
+
+validator.addField({
+  id: 'email',
+  rules: rules.email,
+  value: 'test@domain.com',
 });
 
-validator.removeField(field);
-console.log(validator.getField('test-field-name')) // null
+validator.addField({
+  id: 'password',
+  rules: rules.password,
+  value: '1234567',
+});
+
+const result = validator.validate();
+
+if (result.isValid) {
+  console.log('Validation passed!');
+} else {
+  console.error('Validation failed:', result.errors);
+}
 ```
 
-&nbsp;
-#### Validator.validate()
+---
 
-Validates all added fields
+# License
 
-```javascript
-import { Validator } from '@coxy/react-validator';
+MIT © [Dsshard](https://github.com/dsshard)
 
-const validator = new Validator({ stopAtFirstError: true });
-const field = validator.addField({
-    rules: rules.password,
-    value: '',
-});
+---
+
+# Notes
+
+- Lightweight, flexible, easy to integrate.
+- Server-side and client-side validation supported.
+- Create custom rules for different scenarios.
+- Easy to add dynamic validation logic.
+
+> **Fun Fact:** Early validation of user inputs in a form can reduce backend server load by up to **40%** compared to server-only validation!
 
-console.log(validator.validate());
-```

package/biome.json

@@ -0,0 +1,32 @@
+{
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 120,
+    "formatWithErrors": false,
+    "ignore": ["**/*.min.js"]
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "single",
+      "semicolons": "asNeeded",
+      "trailingCommas": "all"
+    }
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "json": {
+    "formatter": {
+      "indentStyle": "space",
+      "indentWidth": 2
+    },
+    "linter": {
+      "enabled": true
+    }
+  }
+}

package/dist/index.d.mts

@@ -0,0 +1,116 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode, Component, RefObject } from 'react';
+
+type Value = any;
+type Fn$1 = (validity: Validity, value: Value) => ReactNode;
+interface Props {
+    rules?: ValidatorRules;
+    required?: boolean;
+    value?: Value;
+    id?: string | number;
+    children?: ReactNode | Fn$1;
+    unregisterField: (val: Value) => void;
+    registerField: (val: Value) => void;
+    customErrors: Array<Validity>;
+}
+declare function ValidatorField(props: Omit<Props, 'registerField' | 'unregisterField' | 'customErrors'>): react_jsx_runtime.JSX.Element;
+
+type Fn = (value: Value) => string;
+interface ValidatorRule {
+    rule: (value: Value) => boolean;
+    message: string | Fn;
+}
+interface ErrorMessage {
+    message: string;
+    isValid: boolean;
+}
+interface Validity {
+    message: string;
+    isValid: boolean;
+    errors?: ErrorMessage[];
+    id?: string | number;
+}
+interface FieldParams {
+    value: Value;
+    rules: ValidatorRules;
+    required?: boolean;
+    id?: string | number;
+}
+
+type ValidatorRules = ValidatorRule[];
+declare const rules: {
+    notEmpty: {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+    bool: {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+    password: {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+    email: {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+    min: (min: any) => {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+    max: (max: any) => {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+    length: (min: any, max?: any) => {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+};
+
+declare class Field {
+    private rules;
+    private required;
+    private value;
+    id: string | number;
+    constructor({ rules, required, value, id }: FieldParams);
+    validate(): Validity;
+}
+interface ValidatorParams {
+    stopAtFirstError: boolean;
+}
+declare class Validator {
+    private fields;
+    private params;
+    constructor(params?: ValidatorParams);
+    addField(params: FieldParams): Field;
+    removeField(field: Field): void;
+    getField(id: Field['id']): Field;
+    validate(): Validity;
+}
+
+interface ComponentProps {
+    children?: ReactNode;
+    stopAtFirstError?: boolean;
+    ref?: RefObject<ValidatorWrapper>;
+}
+declare class ValidatorWrapper extends Component<ComponentProps> {
+    fields: any[];
+    state: {
+        customErrors: any[];
+    };
+    constructor(props: any);
+    componentWillUnmount(): void;
+    registerField(field: any): void;
+    unregisterField(field: any): void;
+    getField(id: any): Field | null;
+    setCustomError(customError: Validity): void;
+    clearCustomErrors(): void;
+    validate(): Validity;
+    render(): ReactNode;
+}
+
+declare function useValidator(value: Value, rules: ValidatorRules): [boolean, Pick<Validity, 'message' | 'errors'>];
+
+export { type ErrorMessage, type FieldParams, Validator, ValidatorField, type ValidatorRule, ValidatorWrapper, type Validity, rules, useValidator };

package/dist/index.d.ts

@@ -1,6 +1,116 @@
-export { rules } from './rules';
-export { ValidatorField } from './validator-field';
-export { ValidatorWrapper } from './validator-wrapper';
-export { Validator } from './validator';
-export { useValidator } from './use-validator';
-export * from './types';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode, Component, RefObject } from 'react';
+
+type Value = any;
+type Fn$1 = (validity: Validity, value: Value) => ReactNode;
+interface Props {
+    rules?: ValidatorRules;
+    required?: boolean;
+    value?: Value;
+    id?: string | number;
+    children?: ReactNode | Fn$1;
+    unregisterField: (val: Value) => void;
+    registerField: (val: Value) => void;
+    customErrors: Array<Validity>;
+}
+declare function ValidatorField(props: Omit<Props, 'registerField' | 'unregisterField' | 'customErrors'>): react_jsx_runtime.JSX.Element;
+
+type Fn = (value: Value) => string;
+interface ValidatorRule {
+    rule: (value: Value) => boolean;
+    message: string | Fn;
+}
+interface ErrorMessage {
+    message: string;
+    isValid: boolean;
+}
+interface Validity {
+    message: string;
+    isValid: boolean;
+    errors?: ErrorMessage[];
+    id?: string | number;
+}
+interface FieldParams {
+    value: Value;
+    rules: ValidatorRules;
+    required?: boolean;
+    id?: string | number;
+}
+
+type ValidatorRules = ValidatorRule[];
+declare const rules: {
+    notEmpty: {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+    bool: {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+    password: {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+    email: {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+    min: (min: any) => {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+    max: (max: any) => {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+    length: (min: any, max?: any) => {
+        rule: (value: any) => boolean;
+        message: string;
+    }[];
+};
+
+declare class Field {
+    private rules;
+    private required;
+    private value;
+    id: string | number;
+    constructor({ rules, required, value, id }: FieldParams);
+    validate(): Validity;
+}
+interface ValidatorParams {
+    stopAtFirstError: boolean;
+}
+declare class Validator {
+    private fields;
+    private params;
+    constructor(params?: ValidatorParams);
+    addField(params: FieldParams): Field;
+    removeField(field: Field): void;
+    getField(id: Field['id']): Field;
+    validate(): Validity;
+}
+
+interface ComponentProps {
+    children?: ReactNode;
+    stopAtFirstError?: boolean;
+    ref?: RefObject<ValidatorWrapper>;
+}
+declare class ValidatorWrapper extends Component<ComponentProps> {
+    fields: any[];
+    state: {
+        customErrors: any[];
+    };
+    constructor(props: any);
+    componentWillUnmount(): void;
+    registerField(field: any): void;
+    unregisterField(field: any): void;
+    getField(id: any): Field | null;
+    setCustomError(customError: Validity): void;
+    clearCustomErrors(): void;
+    validate(): Validity;
+    render(): ReactNode;
+}
+
+declare function useValidator(value: Value, rules: ValidatorRules): [boolean, Pick<Validity, 'message' | 'errors'>];
+
+export { type ErrorMessage, type FieldParams, Validator, ValidatorField, type ValidatorRule, ValidatorWrapper, type Validity, rules, useValidator };

package/dist/index.js

@@ -1,28 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useValidator = exports.Validator = exports.ValidatorWrapper = exports.ValidatorField = exports.rules = void 0;
-var rules_1 = require("./rules");
-Object.defineProperty(exports, "rules", { enumerable: true, get: function () { return rules_1.rules; } });
-var validator_field_1 = require("./validator-field");
-Object.defineProperty(exports, "ValidatorField", { enumerable: true, get: function () { return validator_field_1.ValidatorField; } });
-var validator_wrapper_1 = require("./validator-wrapper");
-Object.defineProperty(exports, "ValidatorWrapper", { enumerable: true, get: function () { return validator_wrapper_1.ValidatorWrapper; } });
-var validator_1 = require("./validator");
-Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return validator_1.Validator; } });
-var use_validator_1 = require("./use-validator");
-Object.defineProperty(exports, "useValidator", { enumerable: true, get: function () { return use_validator_1.useValidator; } });
-__exportStar(require("./types"), exports);
+'use strict';var react=require('react'),jsxRuntime=require('react/jsx-runtime');var h=/^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,g={notEmpty:[{rule:t=>t!==""&&t.length>0,message:"Value is required"}],bool:[{rule:t=>!!t,message:"Value is required"}],password:[{rule:t=>t.length>0,message:"Password field cannot be empty"},{rule:t=>t.length>5,message:"Password field can not be less than 6 characters"}],email:[{rule:t=>!!t&&t!==""&&t.length!==0,message:"Email is required"},{rule:t=>h.test(String(t).toLowerCase()),message:"Email is invalid"}],min:t=>[{rule:e=>Number.parseFloat(e)>t,message:`The value must be greater than ${t}`}],max:t=>[{rule:e=>Number.parseFloat(e)<t,message:`The value must be smaller ${t}`}],length:(t,e)=>[{rule:r=>String(r).length>=t,message:`No less than ${t} symbols`},{rule:r=>e!==void 0?String(r).length<=e:true,message:`No more than ${e} symbols`}]};var d=react.createContext(null);var l=class{rules;required;value;id;constructor({rules:e,required:r,value:s,id:i}){this.rules=e,this.required=r,this.value=s,this.id=i;}validate(){let e=true,r="",{rules:s,value:i,required:n,id:m}=this,c=!i&&Number.parseFloat(i)!==0;if(!s.length||c&&n===false)return {isValid:e,message:r,id:m};for(let a of s)e&&(e=a.rule(i),e||(typeof a.message=="function"?r=a.message(i):r=a.message));return {isValid:e,message:r,id:m}}},o=class{fields;params;constructor(e){this.params=e||null,this.fields=[];}addField(e){let r=new l(e);return this.fields.push(r),r}removeField(e){let r=this.fields.indexOf(e);r>-1&&this.fields.splice(r,1);}getField(e){return this.fields.find(r=>r.id===e)||null}validate(){let e,s=this.fields.map(i=>this.params?.stopAtFirstError&&e&&e.isValid===false?null:(e=i.validate(),e)).filter(i=>i&&i.isValid===false);if(s.length){let{isValid:i,message:n}=s[0];return {isValid:i,message:n,errors:s}}return {isValid:true,message:""}}};var u=class extends react.Component{componentWillUnmount(){this.props.unregisterField(this);}componentDidMount(){this.props.registerField(this);}validate(){let e=this.props,r=e.customErrors.find(i=>i.id===e.id);return r||new l({rules:e.rules,required:e.required,value:e.value,id:e.id}).validate()}render(){let{children:e,value:r}=this.props,s=this.validate();return typeof e=="function"?e(s,r):e}};function F(t){return jsxRuntime.jsx(d.Consumer,{children:e=>jsxRuntime.jsx(u,{...t,customErrors:e.customErrors,registerField:e.registerField,unregisterField:e.unregisterField})})}var p=class extends react.Component{fields=[];state={customErrors:[]};constructor(e){super(e),this.registerField=this.registerField.bind(this),this.unregisterField=this.unregisterField.bind(this);}componentWillUnmount(){this.fields=[];}registerField(e){e&&!this.fields.includes(e)&&this.fields.push(e);}unregisterField(e){let r=this.fields.indexOf(e);r>-1&&this.fields.splice(r,1);}getField(e){return this.fields.find(r=>r.props.id===e)||null}setCustomError(e){this.setState({customErrors:[...this.state.customErrors,e]});}clearCustomErrors(){this.setState({customErrors:[]});}validate(){let e=new o({stopAtFirstError:this.props.stopAtFirstError});for(let r of this.fields)e.addField(r.props);return e.validate()}render(){return jsxRuntime.jsx(d.Provider,{value:{customErrors:this.state.customErrors,registerField:this.registerField,unregisterField:this.unregisterField},children:this.props.children})}};function x(t,e){let r=new o;r.addField({value:t,rules:e});let{isValid:s,...i}=r.validate();return [s,i]}exports.Validator=o;exports.ValidatorField=F;exports.ValidatorWrapper=p;exports.rules=g;exports.useValidator=x;//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map