@coxy/react-validator 1.3.3 → 2.0.1

package/src/validator-wrapper.test.tsx

@@ -0,0 +1,138 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { createRef } from 'react'
+import { render } from '@testing-library/react'
+
+import { ValidatorWrapper } from './validator-wrapper'
+import { ValidatorField } from './validator-field'
+import { rules } from './rules'
+
+it('render without child', () => {
+  expect(() => shallow(<ValidatorWrapper />)).toThrowError()
+})
+
+it('check wrapper validator', () => {
+  const validator = createRef<ValidatorWrapper>()
+  render((
+    <ValidatorWrapper ref={validator}>
+      <ValidatorField rules={[]} />
+      <ValidatorField rules={[]} />
+      <ValidatorField rules={[]} />
+      <ValidatorField rules={[]} />
+      <ValidatorField rules={[]} />
+      <ValidatorField rules={[]} />
+    </ValidatorWrapper>
+  ))
+
+  expect(typeof validator.current).toBe('object')
+  expect(typeof validator.current.validate).toBe('function')
+})
+
+it('check getField validator', () => {
+  const validator = createRef<ValidatorWrapper>()
+  render((
+    <ValidatorWrapper ref={validator}>
+      <ValidatorField rules={[]} id="test" />
+      <ValidatorField rules={[]} id="test-fields" />
+    </ValidatorWrapper>
+  ))
+  expect(typeof validator.current.getField).toBe('function')
+  const field = validator.current.getField('test')
+
+  expect(typeof field.validate).toBe('function')
+  const fieldValidate = field.validate()
+
+  expect(fieldValidate.isValid).toBe(true)
+  expect(fieldValidate.message).toBe('')
+})
+
+it('check getField undefined field', () => {
+  const validator = createRef<ValidatorWrapper>()
+  render((
+    <ValidatorWrapper ref={validator}>
+      <ValidatorField rules={[]} id="test-empty-field" />
+    </ValidatorWrapper>
+  ))
+
+  const field = validator.current.getField('8')
+  expect(field).toBe(null)
+})
+
+it('check stopAtFirstError validator', () => {
+  const validator = createRef<ValidatorWrapper>()
+  render((
+    <ValidatorWrapper ref={validator} stopAtFirstError>
+      <ValidatorField rules={[]} value="test" />
+      <ValidatorField rules={rules.email} value="test" />
+      <ValidatorField rules={rules.password} value="" />
+    </ValidatorWrapper>
+  ))
+  const fieldValidate = validator.current.validate()
+  expect(fieldValidate.isValid).toBe(false)
+  expect(fieldValidate.message).toBe('Email is invalid')
+  expect(fieldValidate.errors.length).toBe(1)
+})
+
+it('check unregisterField, registerField', () => {
+  const validator = createRef<ValidatorWrapper>()
+  render((
+    <ValidatorWrapper ref={validator}>
+      <ValidatorField rules={[]} id="test-register-field" />
+    </ValidatorWrapper>
+  ))
+
+  expect(typeof validator.current.registerField).toBe('function')
+  expect(typeof validator.current.unregisterField).toBe('function')
+})
+
+it('check filed in field', () => {
+  const validator = createRef<ValidatorWrapper>()
+  render(
+    <ValidatorWrapper ref={validator}>
+      <ValidatorField rules={[]}>
+        <ValidatorField rules={[]} id="check-validate-field-1" />
+        <ValidatorField rules={[]} id="check-validate-field-2" />
+      </ValidatorField>
+    </ValidatorWrapper>
+  )
+
+  expect(typeof validator.current).toBe('object')
+  expect(typeof validator.current.validate).toBe('function')
+  const result = validator.current.validate()
+  expect(result.isValid).toBe(true)
+})
+
+it('check wrapper in wrapper', () => {
+  const validatorOut = createRef<ValidatorWrapper>()
+  const validatorIn = createRef<ValidatorWrapper>()
+  render((
+    <ValidatorWrapper ref={validatorOut}>
+      <ValidatorField rules={rules.email} value="" />
+      <ValidatorWrapper ref={validatorIn}>
+        <ValidatorField rules={rules.password} value="successpasswword" />
+      </ValidatorWrapper>
+    </ValidatorWrapper>
+  ))
+  expect(validatorIn.current.validate().isValid).toBe(true)
+  expect(validatorOut.current.validate().isValid).toBe(false)
+})
+
+it('check two validators', () => {
+  const validatorSuccess = createRef<ValidatorWrapper>()
+  const validatorFailed = createRef<ValidatorWrapper>()
+  render((
+    <>
+      <ValidatorWrapper ref={validatorSuccess}>
+        <ValidatorField rules={rules.password} value="successpasswword" />
+      </ValidatorWrapper>
+      <ValidatorWrapper ref={validatorFailed}>
+        <ValidatorField rules={rules.email} value="" />
+      </ValidatorWrapper>
+    </>
+  ))
+
+  expect(validatorFailed.current.validate().isValid).toBe(false)
+  expect(validatorSuccess.current.validate().isValid).toBe(true)
+})

package/src/validator-wrapper.tsx

@@ -0,0 +1,58 @@
+/* eslint react/sort-comp: [0], camelcase: [0] */
+import { Component, ReactNode, RefObject } from 'react'
+
+import { Context } from './context'
+import { Validator } from './validator'
+
+interface ComponentProps {
+  children?: ReactNode
+  stopAtFirstError?: boolean
+  ref?: RefObject<any>
+}
+
+export class ValidatorWrapper extends Component<ComponentProps> {
+  fields = [];
+
+  constructor (props, ctx) {
+    super(props, ctx)
+    this.registerField = this.registerField.bind(this)
+    this.unregisterField = this.unregisterField.bind(this)
+  }
+
+  componentWillUnmount () {
+    this.fields = []
+  }
+
+  registerField (field) {
+    if (field && !this.fields.includes(field)) {
+      this.fields.push(field)
+    }
+  }
+
+  unregisterField (field) {
+    const index = this.fields.indexOf(field)
+    if (index > -1) this.fields.splice(index, 1)
+  }
+
+  getField (id) {
+    return this.fields.find((field) => field.props.id === id) || null
+  }
+
+  validate () {
+    const validator = new Validator({ stopAtFirstError: this.props.stopAtFirstError })
+    this.fields.forEach((comp) => {
+      validator.addField(comp.props)
+    })
+    return validator.validate()
+  }
+
+  render () {
+    return (
+      <Context.Provider
+        value={{ registerField: this.registerField, unregisterField: this.unregisterField }}
+      >
+        {this.props.children}
+      </Context.Provider>
+    )
+  }
+}

package/src/validator.test.tsx

@@ -0,0 +1,30 @@
+import { rules } from './rules'
+import { Validator } from './validator'
+
+it('check normal create validator', () => {
+  const validator = new Validator()
+  expect(typeof validator).toBe('object')
+  expect(typeof validator.validate).toBe('function')
+})
+
+it('check normal add and remove fields', () => {
+  const validator = new Validator({ stopAtFirstError: true })
+  const fieldPassword = validator.addField({
+    rules: rules.password,
+    value: '',
+    id: 'for-remove'
+  })
+
+  expect(typeof fieldPassword).toBe('object')
+
+  const fieldSearchPassword = validator.getField('for-remove')
+
+  expect(typeof fieldSearchPassword).toBe('object')
+  expect(typeof fieldSearchPassword.validate).toBe('function')
+  expect(fieldPassword.id === fieldSearchPassword.id).toBe(true)
+
+  let newFieldSearchPassword = validator.getField('for-remove')
+  validator.removeField(newFieldSearchPassword)
+  newFieldSearchPassword = validator.getField('for-remove')
+  expect(newFieldSearchPassword === null).toBe(true)
+})

package/src/validator.ts

@@ -0,0 +1,105 @@
+import { Validity, Value } from './validator-field'
+import { ValidatorRules } from './rules'
+
+export interface FieldParams {
+  value: Value
+  rules: ValidatorRules,
+  required?: boolean
+  id?: string | number
+}
+
+export class Field {
+  private rules: ValidatorRules;
+  private required: boolean;
+  private value: Value;
+  public id: string | number;
+  constructor ({
+    rules,
+    required,
+    value,
+    id
+  }: FieldParams) {
+    this.rules = rules
+    this.required = required
+    this.value = value
+    this.id = id
+  }
+
+  validate (): Validity {
+    let isValid = true
+    let message = ''
+    const {
+      rules,
+      value,
+      required,
+      id
+    } = this
+
+    const isEmptyValue = !value && parseFloat(value) !== 0
+
+    if (!rules.length || (isEmptyValue && required === false)) {
+      return { isValid, message, id }
+    }
+    rules.forEach((instance) => {
+      if (isValid) {
+        isValid = instance.rule(value)
+        if (!isValid) {
+          if (typeof instance.message === 'function') {
+            message = instance.message(value)
+          } else {
+            message = instance.message
+          }
+        }
+      }
+    })
+    return { isValid, message, id }
+  }
+}
+
+export interface ValidatorParams {
+  stopAtFirstError: boolean
+}
+
+export class Validator {
+  private fields: Field[];
+  private params: ValidatorParams;
+
+  constructor (params?: ValidatorParams) {
+    this.params = params || null
+    this.fields = []
+  }
+
+  addField (params: FieldParams): Field {
+    const field = new Field(params)
+    this.fields.push(field)
+    return field
+  }
+
+  removeField (field: Field): void {
+    const index = this.fields.indexOf(field)
+    if (index > -1) this.fields.splice(index, 1)
+  }
+
+  getField (id: Field['id']): Field {
+    return this.fields.find((field) => field.id === id) || null
+  }
+
+  validate (): Validity {
+    let prevResult
+    const statuses = this.fields.map((field) => {
+      if (this.params?.stopAtFirstError && prevResult && prevResult.isValid === false) {
+        return null
+      }
+      prevResult = field.validate()
+      return prevResult
+    })
+
+    const errors = statuses.filter((inst) => inst && inst.isValid === false)
+
+    if (errors.length) {
+      const { isValid, message } = errors[0]
+      return { isValid, message, errors }
+    }
+    return { isValid: true, message: '' }
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "src/**/*.test.tsx",
+    "src/**/*.test.ts"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,39 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "declaration": true,
+    "module": "CommonJS",
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "es2017",
+    "sourceMap": false,
+    "composite": true,
+    "incremental": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": false,
+    "resolveJsonModule": true,
+    "outDir": "./dist",
+    "rootDir": "src",
+    "baseUrl": "./src",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "isolatedModules": true,
+    "moduleResolution": "node",
+    "jsx": "preserve"
+  },
+  "include": [
+    "src",
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

package/.babelrc.js

@@ -1,14 +0,0 @@
-module.exports = {
-  "presets": [
-    "@babel/preset-env",
-    "@babel/preset-react"
-  ],
-  "plugins": [
-    "@babel/proposal-class-properties"
-  ],
-  "env": {
-    "production": {
-      "plugins": ["transform-react-remove-prop-types"]
-    }
-  }
-}

package/build/index.js

@@ -1 +0,0 @@
-module.exports=(()=>{"use strict";var e={942:(e,t,r)=>{r.r(t),r.d(t,{Validator:()=>p,ValidatorField:()=>x,default:()=>A,rules:()=>V});const n=require("react");var i=r.n(n);const o=require("prop-types");var u=r.n(o);const s=i().createContext("@coxy/Validator");function l(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function a(e,t){for(var r=0;r<t.length;r++){var n=t[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}}function c(e,t,r){return t&&a(e.prototype,t),r&&a(e,r),e}var f=function(){function e(t){var r=t.rules,n=t.required,i=t.value,o=t.id;l(this,e),this.rules=r,this.required=n,this.value=i,this.id=o}return c(e,[{key:"validate",value:function(){var e=!0,t="",r=this.rules,n=this.value,i=this.required,o=this.id,u=!n&&0!==parseFloat(n);return!r.length||u&&!1===i||r.forEach((function(r){e&&((e=r.rule(n))||"function"==typeof(t=r.message)&&(t=t(n)))})),{isValid:e,message:t,id:o}}}]),e}(),p=function(){function e(t){l(this,e),this.params=t||{},this.fields=[]}return c(e,[{key:"addField",value:function(e){var t=new f(e);return this.fields.push(t),t}},{key:"removeField",value:function(e){var t=this.fields.indexOf(e);t>-1&&this.fields.splice(t,1)}},{key:"getField",value:function(e){return this.fields.find((function(t){return t.id===e}))||null}},{key:"validate",value:function(){var e,t=this,r=this.fields.map((function(r){return t.params.stopAtFirstError&&e&&!1===e.isValid?null:e=r.validate()})).filter((function(e){return e&&!1===e.isValid}));if(r.length){var n=r[0];return{isValid:n.isValid,message:n.message,errors:r}}return{isValid:!0,message:""}}}]),e}();function d(e){return(d="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function y(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function h(e,t){for(var r=0;r<t.length;r++){var n=t[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}}function v(e,t){return(v=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function b(e,t){return!t||"object"!==d(t)&&"function"!=typeof t?g(e):t}function g(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}function m(e){return(m=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}function O(e,t,r){return t in e?Object.defineProperty(e,t,{value:r,enumerable:!0,configurable:!0,writable:!0}):e[t]=r,e}var F=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&v(e,t)}(l,e);var t,r,n,o,u=(n=l,o=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],(function(){}))),!0}catch(e){return!1}}(),function(){var e,t=m(n);if(o){var r=m(this).constructor;e=Reflect.construct(t,arguments,r)}else e=t.apply(this,arguments);return b(this,e)});function l(){var e;y(this,l);for(var t=arguments.length,r=new Array(t),n=0;n<t;n++)r[n]=arguments[n];return O(g(e=u.call.apply(u,[this].concat(r))),"fields",[]),e.registerField=e.registerField.bind(g(e)),e.unregisterField=e.unregisterField.bind(g(e)),e}return t=l,(r=[{key:"componentWillUnmount",value:function(){this.fields=[]}},{key:"registerField",value:function(e){e&&!this.fields.includes(e)&&this.fields.push(e)}},{key:"unregisterField",value:function(e){var t=this.fields.indexOf(e);t>-1&&this.fields.splice(t,1)}},{key:"getField",value:function(e){return this.fields.find((function(t){return t.props.id===e}))||null}},{key:"validate",value:function(){var e=new p({stopAtFirstError:this.props.stopAtFirstError});return this.fields.forEach((function(t){e.addField(t.props)})),e.validate()}},{key:"render",value:function(){return i().createElement(s.Provider,{value:{registerField:this.registerField,unregisterField:this.unregisterField}},this.props.children)}}])&&h(t.prototype,r),l}(n.Component);F.propTypes={children:u().node.isRequired,stopAtFirstError:u().bool},F.defaultProps={stopAtFirstError:!1};const w=F;function P(){return(P=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var r=arguments[t];for(var n in r)Object.prototype.hasOwnProperty.call(r,n)&&(e[n]=r[n])}return e}).apply(this,arguments)}function j(e){return(j="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function S(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function E(e,t){for(var r=0;r<t.length;r++){var n=t[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}}function _(e,t){return(_=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function k(e,t){return!t||"object"!==j(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}function q(e){return(q=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}var R=function(e){!function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&_(e,t)}(u,e);var t,r,n,i,o=(n=u,i=function(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],(function(){}))),!0}catch(e){return!1}}(),function(){var e,t=q(n);if(i){var r=q(this).constructor;e=Reflect.construct(t,arguments,r)}else e=t.apply(this,arguments);return k(this,e)});function u(){return S(this,u),o.apply(this,arguments)}return t=u,(r=[{key:"componentWillUnmount",value:function(){this.props.unregisterField(this)}},{key:"componentDidMount",value:function(){this.props.registerField(this)}},{key:"validate",value:function(){return new f({rules:this.props.rules,required:this.props.required,value:this.props.value,id:this.props.id}).validate()}},{key:"render",value:function(){var e=this.props,t=e.children,r=e.value,n=this.validate();return"function"==typeof t?t(n,r):t}}])&&E(t.prototype,r),u}(n.Component);function x(e){return i().createElement(s.Consumer,null,(function(t){return i().createElement(R,P({},e,{registerField:t.registerField,unregisterField:t.unregisterField}))}))}R.propTypes={registerField:u().func.isRequired,unregisterField:u().func.isRequired,children:u().oneOfType([u().node,u().func]),rules:u().arrayOf(u().shape({message:u().oneOfType([u().string,u().func]),rule:u().func})),id:u().string,required:u().bool,value:u().any},R.defaultProps={rules:[],children:null,required:!0,value:void 0,id:""};var T=/^(([^<>()\[\]\\.,;:\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,}))$/;const V={notEmpty:[{rule:function(e){return""!==e&&e.length>0},message:"Value is required"}],bool:[{rule:function(e){return!!e},message:"Value is required"}],password:[{rule:function(e){return e.length>0},message:"Password field cannot be empty"},{rule:function(e){return e.length>5},message:"Password field can not be less than 6 characters"}],email:[{rule:function(e){return!!e&&""!==e&&0!==e.length},message:"Email is required"},{rule:function(e){return T.test(String(e).toLowerCase())},message:"Email is invalid"}],min:function(e){return[{rule:function(t){return parseFloat(t)>e},message:"The value must be greater than ".concat(e)}]},max:function(e){return[{rule:function(t){return parseFloat(t)<e},message:"The value must be smaller ".concat(e)}]},length:function(e,t){return[{rule:function(t){return String(t).length>=e},message:"No less than ".concat(e," symbols")},{rule:function(e){return void 0===t||String(e).length<=t},message:"No more than ".concat(t," symbols")}]}},A=w}},t={};function r(n){if(t[n])return t[n].exports;var i=t[n]={exports:{}};return e[n](i,i.exports,r),i.exports}return r.n=e=>{var t=e&&e.__esModule?()=>e.default:()=>e;return r.d(t,{a:t}),t},r.d=(e,t)=>{for(var n in t)r.o(t,n)&&!r.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:t[n]})},r.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),r.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r(942)})();

package/jest.config.js

@@ -1,5 +0,0 @@
-module.exports = {
-  collectCoverage: true,
-  coverageDirectory: './coverage/',
-  displayName: '@coxy',
-};

package/src/context.js

@@ -1,3 +0,0 @@
-import React from 'react';
-
-export default React.createContext('@coxy/Validator');

package/src/context.test.js

@@ -1,9 +0,0 @@
-/* eslint-env jest */
-
-import context from './context';
-
-it('renders with or without a name', () => {
-  expect(typeof context).toBe('object');
-  expect(typeof context.Consumer).toBe('object');
-  expect(typeof context.Provider).toBe('object');
-});

package/src/index.js

@@ -1,13 +0,0 @@
-import ValidatorWrapper from './validator-wrapper';
-import ValidatorField from './validator-field';
-import useValidator from './use-validator';
-import Validator from './validator';
-import rules from './rules';
-
-export default ValidatorWrapper;
-export {
-  ValidatorField,
-  useValidator,
-  Validator,
-  rules,
-};

package/src/index.test.js

@@ -1,9 +0,0 @@
-/* eslint-env jest */
-
-import ValidatorWrapper, { ValidatorField, rules } from './index';
-
-it('renders with or without a name', () => {
-  expect(typeof ValidatorWrapper).toBe('function');
-  expect(typeof ValidatorField).toBe('function');
-  expect(typeof rules).toBe('object');
-});

package/src/rules.test.js

@@ -1,130 +0,0 @@
-/* eslint-env jest */
-
-import rules from './rules';
-
-it('check rule email', () => {
-  expect(rules.email.length).toBe(2);
-
-  let result = null;
-  // email.length > 0
-  result = rules.email[0].rule('test');
-  expect(result).toBe(true);
-
-  // email check regexp
-  result = rules.email[1].rule('test');
-  expect(result).toBe(false);
-
-  // email check regexp
-  result = rules.email[1].rule('test@gmail.com');
-  expect(result).toBe(true);
-});
-
-it('check rule password', () => {
-  expect(rules.password.length).toBe(2);
-
-  let result = null;
-  // password.length > 0
-  result = rules.password[0].rule('test');
-  expect(result).toBe(true);
-
-  // password.length > 5
-  result = rules.password[1].rule('test');
-  expect(result).toBe(false);
-});
-
-it('check rule bool', () => {
-  expect(rules.bool.length).toBe(1);
-
-  let result = null;
-  result = rules.bool[0].rule(true);
-  expect(result).toBe(true);
-});
-
-it('check rule notEmpty', () => {
-  expect(rules.notEmpty.length).toBe(1);
-
-  let result = null;
-  result = rules.notEmpty[0].rule('');
-  expect(result).toBe(false);
-
-  result = rules.notEmpty[0].rule('test');
-  expect(result).toBe(true);
-});
-
-it('check rule min', () => {
-  expect(rules.min(1).length).toBe(1);
-  expect(typeof rules.min).toBe('function');
-
-  let result = null;
-  result = rules.min(10)[0].rule('');
-  expect(result).toBe(false);
-
-  result = rules.min(9)[0].rule('testtesttest');
-  expect(result).toBe(false);
-
-  result = rules.min(9)[0].rule('11');
-  expect(result).toBe(true);
-
-  result = rules.min(9)[0].rule(10);
-  expect(result).toBe(true);
-
-  result = rules.min(9)[0].rule('8');
-  expect(result).toBe(false);
-
-  result = rules.min(9)[0].rule(7);
-  expect(result).toBe(false);
-
-  result = rules.min(-1)[0].rule('');
-  expect(result).toBe(false);
-});
-
-it('check rule max', () => {
-  let result = null;
-  result = rules.max(10)[0].rule('');
-  expect(result).toBe(false);
-
-  result = rules.max(9)[0].rule('testtesttest');
-  expect(result).toBe(false);
-
-  result = rules.max(9)[0].rule('11');
-  expect(result).toBe(false);
-
-  result = rules.max(9)[0].rule(10);
-  expect(result).toBe(false);
-
-  result = rules.max(9)[0].rule('5');
-  expect(result).toBe(true);
-
-  result = rules.max(9)[0].rule(5);
-  expect(result).toBe(true);
-
-  result = rules.max(-1)[0].rule('');
-  expect(result).toBe(false);
-});
-
-it('check rule length', () => {
-  let result = null;
-  result = rules.length(1)[0].rule('');
-  expect(result).toBe(false);
-
-  result = rules.length(1)[0].rule('1');
-  expect(result).toBe(true);
-
-  result = rules.length(1, 10)[0].rule('testtesttest');
-  expect(result).toBe(true);
-
-  result = rules.length(1, 10)[1].rule('testtesttest');
-  expect(result).toBe(false);
-
-  result = rules.length(1, 10)[0].rule('lol');
-  expect(result).toBe(true);
-
-  result = rules.length(1, 10)[1].rule('lol');
-  expect(result).toBe(true);
-
-  result = rules.length(1)[1].rule('test undefined 2 param');
-  expect(result).toBe(true);
-
-  result = rules.length(10)[0].rule('tes');
-  expect(result).toBe(false);
-});

package/src/use-validator.js

@@ -1,8 +0,0 @@
-import Validator from './validator';
-
-export default function useValidate(value, rules) {
-  const validator = new Validator();
-  validator.addField({ value, rules });
-  const { isValid, ...validateObject } = validator.validate();
-  return [isValid, validateObject];
-}

package/src/use-validator.test.js

@@ -1,52 +0,0 @@
-/* eslint-env jest */
-/* eslint react/jsx-filename-extension: [0] */
-
-import React from 'react';
-import { render, unmountComponentAtNode } from 'react-dom';
-import { act } from 'react-dom/test-utils';
-
-import rules from './rules';
-import useValidate from './use-validator';
-
-let container = null;
-beforeEach(() => {
-  container = document.createElement('div');
-  document.body.appendChild(container);
-});
-
-afterEach(() => {
-  unmountComponentAtNode(container);
-  container.remove();
-  container = null;
-});
-
-jest.useFakeTimers();
-
-it('check state change and hide field', () => {
-  function Comp() {
-    const [value, setValue] = React.useState(false);
-    const [isValid] = useValidate(value, rules.bool);
-    console.log(isValid);
-
-    React.useEffect(() => {
-      setTimeout(() => {
-        act(() => {
-          setValue(true);
-        });
-      }, 100);
-    }, []);
-
-    return (
-      <div>{isValid ? 'true' : 'false'}</div>
-    );
-  }
-  act(() => {
-    render(<Comp />, container);
-  });
-
-  expect(container.textContent).toBe('false');
-
-  jest.runAllTimers();
-
-  expect(container.textContent).toBe('true');
-});