vest 4.0.0-dev-366a8b → 4.0.0-dev-e266d9

package/types/enforce/schema.d.ts

@@ -0,0 +1,151 @@
+type DropFirst<T extends unknown[]> = T extends [
+    unknown,
+    ...infer U
+] ? U : never;
+type TStringable = string | ((...args: any[]) => string);
+type TRuleReturn = boolean | {
+    pass: boolean;
+    message?: TStringable;
+};
+type TRuleDetailedResult = {
+    pass: boolean;
+    message?: string;
+};
+type TArgs = any[];
+type TBaseRules = typeof baseRules;
+type KBaseRules = keyof TBaseRules;
+declare function condition(value: any, callback: (value: any) => TRuleReturn): TRuleReturn;
+declare function endsWith(value: string, arg1: string): boolean;
+declare function equals(value: unknown, arg1: unknown): boolean;
+declare function greaterThan(value: number | string, gt: number | string): boolean;
+declare function greaterThanOrEquals(value: string | number, gte: string | number): boolean;
+declare function inside(value: unknown, arg1: string | unknown[]): boolean;
+// The module is named "isArrayValue" since it
+// is conflicting with a nested npm dependency.
+// We may need to revisit this in the future.
+declare function isArray(value: unknown): value is Array<unknown>;
+declare function isBetween(value: number | string, min: number | string, max: number | string): boolean;
+declare function isBlank(value: unknown): boolean;
+declare function isBoolean(value: unknown): value is boolean;
+declare function isEmpty(value: unknown): boolean;
+declare function isNaN(value: unknown): boolean;
+declare function isNegative(value: number | string): boolean;
+declare function isNull(value: unknown): value is null;
+declare function isNullish(value: any): value is null | undefined;
+declare function isNumber(value: unknown): value is number;
+declare function isNumeric(value: string | number): boolean;
+declare function isStringValue(v: unknown): v is string;
+declare function isTruthy(value: unknown): boolean;
+declare function isUndefined(value?: unknown): boolean;
+declare function lengthEquals(value: string | unknown[], arg1: string | number): boolean;
+declare function lessThan(value: string | number, lt: string | number): boolean;
+declare function lessThanOrEquals(value: string | number, lte: string | number): boolean;
+declare function longerThan(value: string | unknown[], arg1: string | number): boolean;
+declare function longerThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
+declare function matches(value: string, regex: RegExp | string): boolean;
+declare function numberEquals(value: string | number, eq: string | number): boolean;
+declare function shorterThan(value: string | unknown[], arg1: string | number): boolean;
+declare function shorterThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
+declare function startsWith(value: string, arg1: string): boolean;
+declare const baseRules: {
+    condition: typeof condition;
+    doesNotEndWith: (value: string, arg1: string) => boolean;
+    doesNotStartWith: (value: string, arg1: string) => boolean;
+    endsWith: typeof endsWith;
+    equals: typeof equals;
+    greaterThan: typeof greaterThan;
+    greaterThanOrEquals: typeof greaterThanOrEquals;
+    gt: typeof greaterThan;
+    gte: typeof greaterThanOrEquals;
+    inside: typeof inside;
+    isArray: typeof isArray;
+    isBetween: typeof isBetween;
+    isBlank: typeof isBlank;
+    isBoolean: typeof isBoolean;
+    isEmpty: typeof isEmpty;
+    isEven: (value: any) => boolean;
+    isFalsy: (value: unknown) => boolean;
+    isNaN: typeof isNaN;
+    isNegative: typeof isNegative;
+    isNotArray: (value: unknown) => boolean;
+    isNotBetween: (value: string | number, min: string | number, max: string | number) => boolean;
+    isNotBlank: (value: unknown) => boolean;
+    isNotBoolean: (value: unknown) => boolean;
+    isNotEmpty: (value: unknown) => boolean;
+    isNotNaN: (value: unknown) => boolean;
+    isNotNull: (value: unknown) => boolean;
+    isNotNullish: (value: any) => boolean;
+    isNotNumber: (value: unknown) => boolean;
+    isNotNumeric: (value: string | number) => boolean;
+    isNotString: (v: unknown) => boolean;
+    isNotUndefined: (value?: unknown) => boolean;
+    isNull: typeof isNull;
+    isNullish: typeof isNullish;
+    isNumber: typeof isNumber;
+    isNumeric: typeof isNumeric;
+    isOdd: (value: any) => boolean;
+    isPositive: (value: string | number) => boolean;
+    isString: typeof isStringValue;
+    isTruthy: typeof isTruthy;
+    isUndefined: typeof isUndefined;
+    lengthEquals: typeof lengthEquals;
+    lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
+    lessThan: typeof lessThan;
+    lessThanOrEquals: typeof lessThanOrEquals;
+    longerThan: typeof longerThan;
+    longerThanOrEquals: typeof longerThanOrEquals;
+    lt: typeof lessThan;
+    lte: typeof lessThanOrEquals;
+    matches: typeof matches;
+    notEquals: (value: unknown, arg1: unknown) => boolean;
+    notInside: (value: unknown, arg1: string | unknown[]) => boolean;
+    notMatches: (value: string, regex: string | RegExp) => boolean;
+    numberEquals: typeof numberEquals;
+    numberNotEquals: (value: string | number, eq: string | number) => boolean;
+    shorterThan: typeof shorterThan;
+    shorterThanOrEquals: typeof shorterThanOrEquals;
+    startsWith: typeof startsWith;
+};
+type TRules<E = Record<string, unknown>> = n4s.EnforceCustomMatchers<TRules<E> & E> & Record<string, (...args: TArgs) => TRules<E> & E> & {
+    [P in KBaseRules]: (...args: DropFirst<Parameters<TBaseRules[P]>> | TArgs) => TRules<E> & E;
+};
+/* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-interface */
+declare global {
+    namespace n4s {
+        interface IRules<E> extends TRules<E> {
+        }
+    }
+}
+type TLazyRules = n4s.IRules<TLazyRuleMethods>;
+type TLazy = TLazyRules & TLazyRuleMethods & 
+// This is a "catch all" hack to make TS happy while not
+// losing type hints
+Record<string, (...args: any[]) => any>;
+interface IShapeObject extends Record<string, any>, Record<string, TLazyRuleRunners> {
+}
+type TLazyRuleMethods = TLazyRuleRunners & {
+    message: (message: TLazyMessage) => TLazy;
+};
+type TLazyRuleRunners = {
+    test: (value: unknown) => boolean;
+    run: (value: unknown) => TRuleDetailedResult;
+};
+type TLazyMessage = string | ((value: unknown, originalMessage?: TStringable) => string);
+declare function isArrayOf(inputArray: any[], currentRule: TLazy): TRuleDetailedResult;
+declare function loose(inputObject: Record<string, any>, shapeObject: IShapeObject): TRuleDetailedResult;
+declare function optional(value: any, ruleChain: TLazy): TRuleDetailedResult;
+declare function shape(inputObject: Record<string, any>, shapeObject: IShapeObject): TRuleDetailedResult;
+// Help needed improving the typings of this file.
+// Ideally, we'd be able to extend IShapeObject, but that's not possible.
+declare function partial<T extends Record<any, any>>(shapeObject: T): T;
+declare global {
+    namespace n4s {
+        interface EnforceCustomMatchers<R> {
+            isArrayOf: (...args: DropFirst<Parameters<typeof isArrayOf>>) => R;
+            loose: (...args: DropFirst<Parameters<typeof loose>>) => R;
+            shape: (...args: DropFirst<Parameters<typeof shape>>) => R;
+            optional: (...args: DropFirst<Parameters<typeof optional>>) => R;
+        }
+    }
+}
+export { partial };

package/types/vest.d.ts

@@ -1,174 +1,4 @@
-type TEnforceContext = null | {
-    meta: Record<string, any>;
-    value: any;
-    parent: () => TEnforceContext;
-};
-type DropFirst<T extends unknown[]> = T extends [
-    unknown,
-    ...infer U
-] ? U : never;
-type TStringable = string | ((...args: any[]) => string);
-type TRuleReturn = boolean | {
-    pass: boolean;
-    message?: TStringable;
-};
-type TRuleDetailedResult = {
-    pass: boolean;
-    message?: string;
-};
-type TLazyRules = TRules<TLazyRuleMethods>;
-type TLazy = TLazyRules & TLazyRuleMethods;
-type TShapeObject = Record<any, TLazy>;
-type TLazyRuleMethods = TLazyRuleRunners & {
-    message: (message: TLazyMessage) => TLazy;
-};
-type TLazyRuleRunners = {
-    test: (value: unknown) => boolean;
-    run: (value: unknown) => TRuleDetailedResult;
-};
-type TLazyMessage = string | ((value: unknown, originalMessage?: TStringable) => string);
-declare function allOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult;
-declare function anyOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult;
-declare function noneOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult;
-declare function oneOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult;
-declare function optional(value: any, ruleChain: TLazy): TRuleDetailedResult;
-declare function compounds(): {
-    allOf: typeof allOf;
-    anyOf: typeof anyOf;
-    noneOf: typeof noneOf;
-    oneOf: typeof oneOf;
-    optional: typeof optional;
-};
-type TCompounds = ReturnType<typeof compounds>;
-type KCompounds = keyof TCompounds;
-type TArgs = any[];
-type TRuleValue = any;
-type TRuleBase = (value: TRuleValue, ...args: TArgs) => TRuleReturn;
-type TRule = Record<string, TRuleBase>;
-type TBaseRules = typeof baseRules;
-type KBaseRules = keyof TBaseRules;
-declare function condition(value: any, callback: (value: any) => TRuleReturn): TRuleReturn;
-declare function endsWith(value: string, arg1: string): boolean;
-declare function equals(value: unknown, arg1: unknown): boolean;
-declare function greaterThan(value: number | string, gt: number | string): boolean;
-declare function greaterThanOrEquals(value: string | number, gte: string | number): boolean;
-declare function inside(value: unknown, arg1: string | unknown[]): boolean;
-// The module is named "isArrayValue" since it
-// is conflicting with a nested npm dependency.
-// We may need to revisit this in the future.
-declare function isArray(value: unknown): value is Array<unknown>;
-declare function isBetween(value: number | string, min: number | string, max: number | string): boolean;
-declare function isBlank(value: unknown): boolean;
-declare function isBoolean(value: unknown): value is boolean;
-declare function isEmpty(value: unknown): boolean;
-declare function isNaN(value: unknown): boolean;
-declare function isNegative(value: number | string): boolean;
-declare function isNull(value: unknown): value is null;
-declare function isNumber(value: unknown): value is number;
-declare function isNumeric(value: string | number): boolean;
-declare function isStringValue(v: unknown): v is string;
-declare function isTruthy(value: unknown): boolean;
-declare function isUndefined(value?: unknown): boolean;
-declare function lengthEquals(value: string | unknown[], arg1: string | number): boolean;
-declare function lessThan(value: string | number, lt: string | number): boolean;
-declare function lessThanOrEquals(value: string | number, lte: string | number): boolean;
-declare function longerThan(value: string | unknown[], arg1: string | number): boolean;
-declare function longerThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
-declare function matches(value: string, regex: RegExp | string): boolean;
-declare function numberEquals(value: string | number, eq: string | number): boolean;
-declare function shorterThan(value: string | unknown[], arg1: string | number): boolean;
-declare function shorterThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
-declare function startsWith(value: string, arg1: string): boolean;
-declare function shape(inputObject: Record<string, any>, shapeObject: TShapeObject): TRuleDetailedResult;
-declare function loose(inputObject: Record<string, any>, shapeObject: TShapeObject): TRuleDetailedResult;
-declare function isArrayOf(inputArray: any[], currentRule: TLazy): TRuleDetailedResult;
-declare const baseRules: {
-    condition: typeof condition;
-    doesNotEndWith: (value: string, arg1: string) => boolean;
-    doesNotStartWith: (value: string, arg1: string) => boolean;
-    endsWith: typeof endsWith;
-    equals: typeof equals;
-    greaterThan: typeof greaterThan;
-    greaterThanOrEquals: typeof greaterThanOrEquals;
-    gt: typeof greaterThan;
-    gte: typeof greaterThanOrEquals;
-    inside: typeof inside;
-    isArray: typeof isArray;
-    isBetween: typeof isBetween;
-    isBlank: typeof isBlank;
-    isBoolean: typeof isBoolean;
-    isEmpty: typeof isEmpty;
-    isEven: (value: any) => boolean;
-    isFalsy: (value: unknown) => boolean;
-    isNaN: typeof isNaN;
-    isNegative: typeof isNegative;
-    isNotArray: (value: unknown) => boolean;
-    isNotBetween: (value: string | number, min: string | number, max: string | number) => boolean;
-    isNotBlank: (value: unknown) => boolean;
-    isNotBoolean: (value: unknown) => boolean;
-    isNotEmpty: (value: unknown) => boolean;
-    isNotNaN: (value: unknown) => boolean;
-    isNotNull: (value: unknown) => boolean;
-    isNotNumber: (value: unknown) => boolean;
-    isNotNumeric: (value: string | number) => boolean;
-    isNotString: (v: unknown) => boolean;
-    isNotUndefined: (value?: unknown) => boolean;
-    isNull: typeof isNull;
-    isNumber: typeof isNumber;
-    isNumeric: typeof isNumeric;
-    isOdd: (value: any) => boolean;
-    isPositive: (value: string | number) => boolean;
-    isString: typeof isStringValue;
-    isTruthy: typeof isTruthy;
-    isUndefined: typeof isUndefined;
-    lengthEquals: typeof lengthEquals;
-    lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
-    lessThan: typeof lessThan;
-    lessThanOrEquals: typeof lessThanOrEquals;
-    longerThan: typeof longerThan;
-    longerThanOrEquals: typeof longerThanOrEquals;
-    lt: typeof lessThan;
-    lte: typeof lessThanOrEquals;
-    matches: typeof matches;
-    notEquals: (value: unknown, arg1: unknown) => boolean;
-    notInside: (value: unknown, arg1: string | unknown[]) => boolean;
-    notMatches: (value: string, regex: string | RegExp) => boolean;
-    numberEquals: typeof numberEquals;
-    numberNotEquals: (value: string | number, eq: string | number) => boolean;
-    shorterThan: typeof shorterThan;
-    shorterThanOrEquals: typeof shorterThanOrEquals;
-    startsWith: typeof startsWith;
-} & {
-    allOf: typeof allOf;
-    anyOf: typeof anyOf;
-    noneOf: typeof noneOf;
-    oneOf: typeof oneOf;
-    optional: typeof optional;
-} & {
-    shape: typeof shape;
-    loose: typeof loose;
-    isArrayOf: typeof isArrayOf;
-};
-type TRules<E = Record<string, unknown>> = Record<string, (...args: TArgs) => TRules & E> & {
-    [P in KCompounds]: (...args: DropFirst<Parameters<TCompounds[P]>> | TArgs) => TRules & E;
-} & {
-    [P in KBaseRules]: (...args: DropFirst<Parameters<TBaseRules[P]>> | TArgs) => TRules & E;
-};
-declare function enforceEager(value: TRuleValue): TRules;
-type TEnforceEager = typeof enforceEager;
-// Help needed improving the typings of this file.
-// Ideally, we'd be able to extend TShapeObject, but that's not possible.
-declare function partial<T extends Record<any, any>>(shapeObject: T): T;
-declare function modifiers(): {
-    partial: typeof partial;
-};
-type TModifiers = ReturnType<typeof modifiers>;
-declare const enforce: TEnforce;
-type TEnforce = TEnforceEager & TLazyRules & TEnforceMethods;
-type TEnforceMethods = TModifiers & {
-    context: () => TEnforceContext;
-    extend: (customRules: TRule) => void;
-};
+import { enforce } from 'n4s';
 /**
  * Reads the testObjects list and gets full validation result from it.
  */
@@ -227,34 +57,46 @@ interface IDone {
         cb: (res: TDraftResult) => void
     ]): IVestResult;
 }
-// eslint-disable-next-line max-lines-per-function
-declare function create<T extends (...args: any[]) => void>(suiteCallback: T): {
-    (...args: Parameters<T>): IVestResult;
+type CreateProperties = {
     get: () => TDraftResult;
     reset: () => void;
     remove: (fieldName: string) => void;
 };
+type CB = (...args: any[]) => void;
+type SuiteReturnType<T extends CB> = {
+    (...args: Parameters<T>): IVestResult;
+} & CreateProperties;
+declare function create<T extends CB>(suiteName: string, suiteCallback: T): SuiteReturnType<T>;
+declare function create<T extends CB>(suiteCallback: T): SuiteReturnType<T>;
+declare function each<T>(list: T[], callback: (arg: T, index: number) => void): void;
+declare enum TestSeverity {
+    Error = "error",
+    Warning = "warning"
+}
 declare class VestTest {
     fieldName: string;
     testFn: TTestFn;
     asyncTest?: TAsyncTest;
     groupName?: string;
     message?: string;
+    key?: null | string;
     id: string;
-    warns: boolean;
+    severity: TestSeverity;
     status: KStatus;
-    constructor(fieldName: string, testFn: TTestFn, { message, groupName }?: {
+    constructor(fieldName: string, testFn: TTestFn, { message, groupName, key }?: {
         message?: string;
         groupName?: string;
+        key?: string;
     });
     run(): TTestResult;
     setStatus(status: KStatus): void;
+    warns(): boolean;
     setPending(): void;
     fail(): void;
     done(): void;
     warn(): void;
     isFinalStatus(): boolean;
-    skip(): void;
+    skip(force?: boolean): void;
     cancel(): void;
     omit(): void;
     valueOf(): boolean;
@@ -288,35 +130,28 @@ declare function skip(item: TExclusionItem): void;
 declare namespace skip {
     var group: (item: TExclusionItem) => void;
 }
-declare function skipWhen(conditional: boolean | ((...args: any[]) => boolean), callback: (...args: any[]) => void): void;
-/**
- * Sets a running test to warn only mode.
- */
-declare function warn(): void;
 /**
  * Runs a group callback.
  */
 declare function group(groupName: string, tests: () => void): void;
-declare function optional$0(optionals: TOptionalsInput): void;
+declare function optional(optionals: TOptionalsInput): void;
 type TOptionalsInput = string | string[] | TOptionalsObject;
 type TOptionalsObject = Record<string, () => boolean>;
-declare function testBase(fieldName: string, ...args: [
-    message: string,
-    cb: TTestFn
-]): VestTest;
-declare function testBase(fieldName: string, ...args: [
-    cb: TTestFn
-]): VestTest;
+declare function skipWhen(conditional: boolean | ((draft: TDraftResult) => boolean), callback: (...args: any[]) => void): void;
+declare function testBase(fieldName: string, message: string, cb: TTestFn): VestTest;
+declare function testBase(fieldName: string, cb: TTestFn): VestTest;
+declare function testBase(fieldName: string, message: string, cb: TTestFn, key: string): VestTest;
+declare function testBase(fieldName: string, cb: TTestFn, key: string): VestTest;
 declare const _default: typeof testBase & {
-    each: (table: any[]) => {
-        (fieldName: TStringable, message: TStringable, cb: (...args: any[]) => TTestResult): VestTest[];
-        (fieldName: TStringable, cb: (...args: any[]) => TTestResult): VestTest[];
-    };
     memo: {
         (fieldName: string, test: TTestFn, deps: unknown[]): VestTest;
         (fieldName: string, message: string, test: TTestFn, deps: unknown[]): VestTest;
     };
 };
 declare const test: typeof _default;
-declare const VERSION = "4.0.0-dev-366a8b";
-export { test, create, only, skip, warn, group, optional$0 as optional, skipWhen, enforce, VERSION };
+/**
+ * Sets a running test to warn only mode.
+ */
+declare function warn(): void;
+declare const VERSION = "4.0.0-dev-e266d9";
+export { test, create, each, only, skip, warn, group, optional, skipWhen, enforce, VERSION };

package/docs/README.md

@@ -1,113 +0,0 @@
-![Vest](https://cdn.jsdelivr.net/gh/ealush/vest@assets/vest-logo.png 'Vest')
-
-# Vest 🦺 Declarative Validation Testing
-
-![Github Stars](https://githubbadges.com/star.svg?user=ealush&repo=vest&style=flat)
-![Npm downloads](https://img.shields.io/npm/dt/vest?label=Downloads&logo=npm)
-
-[![npm version](https://badge.fury.io/js/vest.svg)](https://badge.fury.io/js/vest) [![Build Status](https://travis-ci.org/ealush/vest.svg?branch=latest)](https://travis-ci.org/ealush/vest) [![Known Vulnerabilities](https://snyk.io/test/npm/vest/badge.svg)](https://snyk.io/test/npm/vest)
-![minifiedSize](https://img.shields.io/bundlephobia/min/vest?color=blue&logo=npm)
-
-[![Join discord](https://img.shields.io/discord/757686103292641312?label=Join%20Discord&logo=discord&logoColor=green)](https://discord.gg/WmADZpJnSe)
-
-- [Documentation homepage](https://vestjs.dev)
-- **Try vest live**
-  - [Vanilla JS Example](https://stackblitz.com/edit/vest-vanilla-support-example?file=validation.js)
-  - ReactJS Examples:
-    - [Example 1 (groups)](https://codesandbox.io/s/ecstatic-waterfall-4i2ne?file=/src/validate.js)
-    - [Example 2 (Async)](https://codesandbox.io/s/youthful-williamson-loijb?file=/src/validate.js)
-    - [Example 3](https://stackblitz.com/edit/vest-react-support-example?file=validation.js)
-    - [Example 4](https://stackblitz.com/edit/vest-react-registration?file=validate.js)
-    - [Example 5 (Password validator)](https://codesandbox.io/s/password-validator-example-6puvy?file=/src/validate.js)
-  - [VueJS Example](https://codesandbox.io/s/vest-vue-example-1j6r8?file=/src/validations.js)
-  - [Svelte Example](https://codesandbox.io/s/vestdocssvelteexample-k87t7?file=/validate.js)
-
-## Tutorials
-
-[Step By Step React Tutorial](https://dev.to/ealush/dead-simple-form-validation-with-vest-5gf8)
-
-## [Release Notes](https://github.com/ealush/vest/releases)
-
-## 🦺 What is Vest?
-
-Vest is a validations library for JS apps that derives its syntax from modern JS unit testing frameworks such as Mocha or Jest. It is easy to learn due to its use of already common declarative patterns.
-It works great with user-input validation and with validating upon user interaction to provide the best possible user experience.
-
-The idea behind Vest is that your validations can be described as a 'spec' or a contract that reflects your form or feature structure. Your validations run in production, and they are framework agnostic - meaning Vest works well with React, Angular, Vue, or even without a framework at all.
-
-Using Vest for form validation can reduce bloat, improve feature readability and maintainability.
-
-**Basic Example**
-![full](https://cdn.jsdelivr.net/gh/ealush/vest@assets/demos/full_3.gif 'full')
-
-**Memoized async test**
-![memo](https://cdn.jsdelivr.net/gh/ealush/vest@assets/demos/memo.gif 'memo')
-
-## ✅ Motivation
-
-Writing forms is an integral part of building web apps, and even though it may seem trivial at first - as your feature grows over time, so does your validation logic grows in complexity.
-
-Vest tries to remediate this by separating validation logic from feature logic so it is easier to maintain over time and refactor when needed.
-
-## ✨ Vest's features
-
-- 🎨 Framework agnostic (BYOUI)
-- ⚡️ Rich, extendable, assertions library (enforce) ([doc](http://vestjs.dev/#/enforce))
-- 🚥 Multiple validations for the same field
-- ⚠️ Warning (non failing) tests ([doc](http://vestjs.dev/#/warn))
-- 📝 Validate only the fields the user interacted with ([doc](http://vestjs.dev/#/exclusion))
-- ⏳ Memoize async validations to reduce calls to the server ([doc](http://vestjs.dev/#/test?id=testmemo-for-memoized-tests))
-- 🚦 Test grouping ([doc](http://vestjs.dev/#/group))
-
-## Example code ([Run in sandbox](https://codesandbox.io/s/vest-react-tutorial-finished-ztt8t?file=/src/validate.js))
-
-```js
-import { create, only, test, enforce, warn, skipWhen } from 'vest';
-
-export default create((data = {}, currentField) => {
-  only(currentField);
-
-  test('username', 'Username is required', () => {
-    enforce(data.username).isNotEmpty();
-  });
-
-  test('username', 'Username is too short', () => {
-    enforce(data.username).longerThanOrEquals(3);
-  });
-
-  test('password', 'Password is required', () => {
-    enforce(data.password).isNotEmpty();
-  });
-
-  test('password', 'Password must be at least 6 chars long', () => {
-    enforce(data.password).longerThanOrEquals(6);
-  });
-
-  test('password', 'Password is weak, Maybe add a number?', () => {
-    warn();
-    enforce(data.password).matches(/[0-9]/);
-  });
-
-  skipWhen(!data.password, () => {
-    test('confirm_password', 'Passwords do not match', () => {
-      enforce(data.confirm_password).equals(data.password);
-    });
-  });
-
-  test('email', 'Email Address is not valid', () => {
-    enforce(data.email).isEmail();
-  });
-
-  test('tos', () => {
-    enforce(data.tos).isTruthy();
-  });
-});
-```
-
-## Why Vest?
-
-- 🧠 Vest is really easy to learn. You can take your existing knowledge of unit tests and transfer it to validations.
-- ✏️ Vest takes into account user interaction and warn only validations.
-- 🧱 Your validations are structured, making it very simple to read and write. All validation files look the same.
-- 🖇 Your validation logic is separate from your feature logic, preventing the spaghetti code that's usually involved with writing validations.
-- 🧩 Validation logic is easy to share and reuse across features.

package/docs/_sidebar.md

@@ -1,14 +0,0 @@
-- [Getting Started](./getting_started)
-- [enforce](./enforce)
-- [The result object](./result)
-- [test](./test)
-  - [How to fail a test](./test#failing_a_test)
-  - [Warn only tests](./warn)
-  - [Grouping tests](./group)
-  - [Optional Tests](./optional)
-- Advanced cases
-  - [Cross Field Validations](./cross_field_validations)
-  - [Excluding or including tests](./exclusion)
-  - [Using with node](./node)
-  - [Utilities](./utilities)
-- [Migration Guides](./migration)

package/docs/cross_field_validations.md

@@ -1,33 +0,0 @@
-# Cross Field Validations
-
-Sometimes it is not enough to only validate a field by itself, because its validity is dependant on the validity or invalidity of a different field.
-
-Take for example the password confirmation field, by itself it serves no purpose, and as long as the password itself is not field, you might choose to not validate it to begin with. That's an **AND** relationship between fields. There can also be an **OR** relationship between fields, for example - either email address or phone number have to be filled, but neither is required as long the other was filled by the user.
-
-All these cases can be easily handled with Vest in different ways, depending on your requirements and validation strategy.
-
-## skipWhen for conditionally skipping a test
-
-Sometimes you might want to skip running a certain validation based on some criteria, for example - only test for password strength if password DOESN'T have Errors. You could access the intermediate validation result and use it mid-run.
-
-```js
-import { create, test, enforce } from 'vest';
-
-const suite = create((data = {}) => {
-  test('password', 'Password is required', () => {
-    enforce(data.password).isNotEmpty();
-  });
-  skipWhen(suite.get().hasErrors('password'), () => {
-    test('password', 'Password is weak', () => {
-      enforce(data.password).longerThan(8);
-    });
-  });
-});
-export default suite;
-```
-
-## Optional tests
-
-By default, all the tests inside Vest are required in order for the suite to be considered as "valid". Sometimes your app's logic may allow tests not to be filled out and you want them not to be accounted for in the suites validity. The optional utility allows you to specify logic to determine if a test is optional or not, for example - if it depends on a different test.
-
-Read more in the [optional tests doc](./optional).

package/docs/enforce.md

@@ -1,11 +0,0 @@
-# Enforce
-
-Enforce is Vest's assertion library. It is used to validate values within, or outside of a Vest test.
-
-```js
-import { enforce, test } from 'vest';
-
-test('username', 'Must be at least three characters long', () => {
-  enforce(username).longerThan(2);
-});
-```