@strictly/define 0.0.8 → 0.0.10

package/dist/index.d.ts

@@ -266,13 +266,14 @@ type InternalFlattenedTypeDefsOfUnionChildren<T extends ValidatingUnionTypeDef,
     readonly [K in keyof Unions]: InternalFlattenedTypeDefsOfChildren<Unions[K], SegmentOverride, Path, `${Qualifier}${K}:`, Depth>;
 }[keyof Unions]> : never : never;
 
+type Annotations = {
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
 type FunctionalValidator<V = any, E = any, ValuePath extends string = any, Context = any> = (v: V, valuePath: ValuePath, context: Context) => E | null;
 type AnnotatedValidator<V = any, E = any, ValuePath extends string = any, Context = any> = {
     readonly validate: (v: V, valuePath: ValuePath, context: Context) => E | null;
-    readonly annotations: (valuePath: ValuePath, context: Context) => {
-        readonly required: boolean;
-        readonly readonly: boolean;
-    };
+    readonly annotations: (valuePath: ValuePath, context: Context) => Annotations;
 };
 type Validator<V = any, E = any, ValuePath extends string = any, Context = any> = FunctionalValidator<V, E, ValuePath, Context> | AnnotatedValidator<V, E, ValuePath, Context>;
 type ErrorOfValidator<V extends Validator> = V extends Validator<infer _V, infer E> ? E : never;
@@ -282,9 +283,10 @@ type ValidationError<Type extends string, Data = {}> = Simplify<{
 declare function isFunctionalValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is FunctionalValidator<V, E, ValuePath, Context>;
 declare function isAnnotatedValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is AnnotatedValidator<V, E, ValuePath, Context>;
 declare function validate<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, v: V, valuePath: ValuePath, context: Context): E | null;
-declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): {
-    readonly required: boolean;
-    readonly readonly: boolean;
+declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): Annotations;
+declare function mergeAnnotations(a1: Annotations, a2: Annotations): {
+    readonly: boolean;
+    required: boolean;
 };
 
 type ValidatorOfValidatingType<T extends ValidatingTypeDef, ValuePath extends string, Context> = T extends ValidatingTypeDef<infer E> ? Validator<ValueOfTypeDef<ReadonlyOfTypeDef<T>>, E, ValuePath, Context> : never;
@@ -403,8 +405,7 @@ declare class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingT
     readonly definition: T;
     constructor(definition: T);
     enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>> | Validator<ValueOfType<Type<T>>, E2, never, never>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
-    required(): TypeDefBuilder<ValidatingTypeDefWithError<T, never>>;
-    required<RequiredError>(rule: Rule<RequiredError, ValueOfType<typeof this.narrow>>): TypeDefBuilder<ValidatingTypeDefWithError<T, RequiredError>>;
+    required(): TypeDefBuilder<T>;
     readonly(): TypeDefBuilder<T>;
     get _type(): TypeOfType<Type<T>>;
     get narrow(): ValidatingType<T>;
@@ -545,8 +546,50 @@ declare class MinimumStringLengthValidator implements AnnotatedValidator<string,
     };
 }
 
+declare class OptionalValidatorProxy<V, V1 extends V, E, ValuePath extends string, Context> implements AnnotatedValidator<V, E, ValuePath, Context> {
+    private readonly proxied;
+    private readonly isRequired;
+    static createNullable<V, E, ValuePath extends string, Context>(proxied: AnnotatedValidator<NonNullable<V>, E, ValuePath, Context>): OptionalValidatorProxy<V, NonNullable<V>, E, ValuePath, Context>;
+    static createNullableOrEmptyString<V extends string | null | undefined, E, ValuePath extends string, Context>(proxied: AnnotatedValidator<NonNullable<V>, E, ValuePath, Context>): OptionalValidatorProxy<V, NonNullable<V>, E, ValuePath, Context>;
+    constructor(proxied: AnnotatedValidator<V1, E, ValuePath, Context>, isRequired: (v: V) => v is V1);
+    validate(v: V, valuePath: ValuePath, context: Context): E | null;
+    annotations(valuePath: ValuePath, context: Context): {
+        required: boolean;
+        readonly: boolean;
+    };
+}
+
+declare const RegexpValidationErrorType = "regexp";
+type RegexpValidationError<Intent extends string> = {
+    type: typeof RegexpValidationErrorType;
+    intent: Intent;
+};
+declare class RegexpValidator<Intent extends string> implements AnnotatedValidator<string, RegexpValidationError<Intent>, never, never> {
+    private readonly regexp;
+    private readonly intent;
+    /**
+     * Extremely permissive email validator
+     */
+    static readonly email: RegexpValidator<"email">;
+    /**
+     * Extremely permissive phone number validator
+     */
+    static readonly phone: RegexpValidator<"phone">;
+    private readonly negate;
+    private readonly required;
+    constructor(regexp: RegExp, intent: Intent, { negate, required, }?: {
+        negate?: boolean;
+        required?: boolean;
+    });
+    validate(value: string): RegexpValidationError<Intent> | null;
+    annotations(): {
+        required: boolean;
+        readonly: boolean;
+    };
+}
+
 type ValidatorsOfValues<FlattenedValues extends Readonly<Record<string, any>>, TypePathsToValuePaths extends Readonly<Record<keyof FlattenedValues, string>> = Readonly<Record<keyof FlattenedValues, any>>, Context = any> = {
     readonly [K in keyof FlattenedValues]: Validator<FlattenedValues[K], any, TypePathsToValuePaths[K], Context>;
 };
 
-export { type Accessor, type AnnotatedValidator, type AnyValueType, DefinedValidator, type ErrorOfValidator, type FlattenedAccessorsOfType, type FlattenedTypesOfType, type FlattenedValuesOfType, type FunctionalValidator, type InternalJsonPathsOf, type IsStrictUnion, type ListTypeDef, type LiteralTypeDef, type Mapper, type MinimumStringLengthValidationError, MinimumStringLengthValidationErrorType, MinimumStringLengthValidator, type MobxObservable, type MobxValueOfType, type NonMobxObservable, type ObjectFieldKey, type ObjectTypeDef, type ObjectTypeDefFields, type PathsOfType, type ReadonlyOfTypeDef, type ReadonlyTypeOfType, type RecordKeyType, type RecordTypeDef, type Setter, type StrictListTypeDef, type StrictLiteralTypeDef, type StrictObjectTypeDef, type StrictObjectTypeDefFields, type StrictRecordTypeDef, type StrictType, type StrictTypeDef, type StrictUnionTypeDef, type Type, type TypeDef, TypeDefType, type UnionKey, type UnionTypeDef, type ValidationError, type Validator, type ValidatorsOfValues, type ValueOfType, type ValueOfTypeDef, type ValueToTypePathsOfType, type ValueTypesOfDiscriminatedUnion, annotations, booleanType, copy, flattenAccessorsOfType, flattenJsonValueToTypePathsOf, flattenTypesOfType, flattenValidatorsOfValidatingType, flattenValueTo, flattenValuesOfType, getUnionTypeDef, isAnnotatedValidator, isFunctionalValidator, jsonPath, jsonPathPop, list, literal, mobxCopy, nullType, nullable, numberType, object, record, stringType, union, validate, valuePathToTypePath };
+export { type Accessor, type AnnotatedValidator, type Annotations, type AnyValueType, DefinedValidator, type ErrorOfValidator, type FlattenedAccessorsOfType, type FlattenedTypesOfType, type FlattenedValuesOfType, type FunctionalValidator, type InternalJsonPathsOf, type IsStrictUnion, type ListTypeDef, type LiteralTypeDef, type Mapper, type MinimumStringLengthValidationError, MinimumStringLengthValidationErrorType, MinimumStringLengthValidator, type MobxObservable, type MobxValueOfType, type NonMobxObservable, type ObjectFieldKey, type ObjectTypeDef, type ObjectTypeDefFields, OptionalValidatorProxy, type PathsOfType, type ReadonlyOfTypeDef, type ReadonlyTypeOfType, type RecordKeyType, type RecordTypeDef, type RegexpValidationError, RegexpValidationErrorType, RegexpValidator, type Setter, type StrictListTypeDef, type StrictLiteralTypeDef, type StrictObjectTypeDef, type StrictObjectTypeDefFields, type StrictRecordTypeDef, type StrictType, type StrictTypeDef, type StrictUnionTypeDef, type Type, type TypeDef, TypeDefType, type UnionKey, type UnionTypeDef, type ValidationError, type Validator, type ValidatorsOfValues, type ValueOfType, type ValueOfTypeDef, type ValueToTypePathsOfType, type ValueTypesOfDiscriminatedUnion, annotations, booleanType, copy, flattenAccessorsOfType, flattenJsonValueToTypePathsOf, flattenTypesOfType, flattenValidatorsOfValidatingType, flattenValueTo, flattenValuesOfType, getUnionTypeDef, isAnnotatedValidator, isFunctionalValidator, jsonPath, jsonPathPop, list, literal, mergeAnnotations, mobxCopy, nullType, nullable, numberType, object, record, stringType, union, validate, valuePathToTypePath };

package/dist/index.js

@@ -392,7 +392,7 @@ function flattenTypeTo({ definition }, mapper2) {
   return reduce4(
     typeDefs,
     function(acc, key, typeDef) {
-      acc[key] = mapper2(typeDef);
+      acc[key] = mapper2(typeDef, key);
       return acc;
     },
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -664,6 +664,12 @@ function annotations(validator, valuePath, context) {
     };
   }
 }
+function mergeAnnotations(a1, a2) {
+  return {
+    readonly: a1.readonly || a2.readonly,
+    required: a1.required || a2.required
+  };
+}
 
 // types/type_of_type.ts
 import {
@@ -758,7 +764,7 @@ var TypeDefBuilder = class _TypeDefBuilder {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
-        ...isAnnotatedValidator(rule) ? rule.annotations(null, null) : {},
+        ...isAnnotatedValidator(rule) ? mergeAnnotations(rule.annotations(null, null), this.definition) : {},
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         rule: (value) => {
           return this.definition.rule(value) ?? validate(rule, value, null, null);
@@ -767,15 +773,11 @@ var TypeDefBuilder = class _TypeDefBuilder {
       }
     );
   }
-  required(rule) {
+  required() {
     return new _TypeDefBuilder(
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        rule: (v) => {
-          return this.definition.rule(v) || rule?.(v);
-        },
         required: true
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       }
@@ -1017,7 +1019,76 @@ var MinimumStringLengthValidator = class {
   }
   annotations() {
     return {
-      required: true,
+      required: this.minimumLength > 0,
+      readonly: false
+    };
+  }
+};
+
+// validation/validators/optional_validator_proxy.ts
+var OptionalValidatorProxy = class _OptionalValidatorProxy {
+  constructor(proxied, isRequired) {
+    this.proxied = proxied;
+    this.isRequired = isRequired;
+  }
+  static createNullable(proxied) {
+    return new _OptionalValidatorProxy(proxied, (v) => v != null);
+  }
+  static createNullableOrEmptyString(proxied) {
+    return new _OptionalValidatorProxy(proxied, (v) => v != null && v !== "");
+  }
+  validate(v, valuePath, context) {
+    if (this.isRequired(v)) {
+      return this.proxied.validate(v, valuePath, context);
+    }
+    return null;
+  }
+  annotations(valuePath, context) {
+    return {
+      ...this.proxied.annotations(valuePath, context),
+      required: false
+    };
+  }
+};
+
+// validation/validators/regexp_validator.ts
+var RegexpValidationErrorType = "regexp";
+var RegexpValidator = class _RegexpValidator {
+  constructor(regexp, intent, {
+    negate = false,
+    required = false
+  } = {}) {
+    this.regexp = regexp;
+    this.intent = intent;
+    this.negate = negate;
+    this.required = required;
+  }
+  /**
+   * Extremely permissive email validator
+   */
+  static email = new _RegexpValidator(/^[^\s@]+@[^\s@]+\.[^\s@]+$/, "email");
+  /**
+   * Extremely permissive phone number validator
+   */
+  static phone = new _RegexpValidator(
+    /^(\+\d{1,4}[\s]*)?(((\([\d\s-]{1,6}\))|\d)[\s-]*){3,14}(\d|(\(\d+\)))$/,
+    "phone"
+  );
+  negate;
+  required;
+  validate(value) {
+    const passes = this.regexp.test(value);
+    if (!passes && !this.negate || passes && this.negate) {
+      return {
+        type: RegexpValidationErrorType,
+        intent: this.intent
+      };
+    }
+    return null;
+  }
+  annotations() {
+    return {
+      required: this.required,
       readonly: false
     };
   }
@@ -1026,6 +1097,9 @@ export {
   DefinedValidator,
   MinimumStringLengthValidationErrorType,
   MinimumStringLengthValidator,
+  OptionalValidatorProxy,
+  RegexpValidationErrorType,
+  RegexpValidator,
   TypeDefType,
   annotations,
   booleanType,
@@ -1043,6 +1117,7 @@ export {
   jsonPathPop,
   list,
   literal,
+  mergeAnnotations,
   mobxCopy,
   nullType,
   nullable,

package/index.ts

@@ -23,4 +23,6 @@ export * from './types/value_types_of_discriminated_union'
 export * from './validation/validator'
 export * from './validation/validators/defined_validator'
 export * from './validation/validators/minimum_string_length_validator'
+export * from './validation/validators/optional_validator_proxy'
+export * from './validation/validators/regexp_validator'
 export * from './validation/validators_of_values'

package/package.json

@@ -35,7 +35,7 @@
     "test:watch": "vitest"
   },
   "type": "module",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "exports": {
     ".": {
       "import": {

package/transformers/flatteners/flatten_type_to.ts

@@ -18,7 +18,7 @@ import { jsonPath } from './json_path'
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type AnyValueType = any
 
-export type Mapper<R> = (t: StrictTypeDef) => R
+export type Mapper<R> = (t: StrictTypeDef, key: string) => R
 
 export function flattenTypeTo<M, R extends Readonly<Record<string, M>>>(
   { definition }: StrictType,
@@ -29,7 +29,7 @@ export function flattenTypeTo<M, R extends Readonly<Record<string, M>>>(
   return reduce(
     typeDefs,
     function (acc, key, typeDef) {
-      acc[key] = mapper(typeDef)
+      acc[key] = mapper(typeDef, key)
       return acc
     },
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions

package/types/builders.ts

@@ -3,6 +3,7 @@ import {
 } from '@strictly/base'
 import {
   isAnnotatedValidator,
+  mergeAnnotations,
   validate,
   type Validator,
 } from 'validation/validator'
@@ -47,7 +48,7 @@ class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingType<T> {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
-        ...(isAnnotatedValidator(rule) ? rule.annotations(null!, null!) : {}),
+        ...(isAnnotatedValidator(rule) ? mergeAnnotations(rule.annotations(null!, null!), this.definition) : {}),
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         rule: (value: any) => {
           return this.definition.rule(value) ?? validate(rule, value, null!, null!)
@@ -57,21 +58,11 @@ class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingType<T> {
     )
   }
 
-  required(): TypeDefBuilder<ValidatingTypeDefWithError<T, never>>
-  required<
-    RequiredError,
-  >(rule: Rule<RequiredError, ValueOfType<typeof this.narrow>>): TypeDefBuilder<
-    ValidatingTypeDefWithError<T, RequiredError>
-  >
-  required<RequiredError = never>(rule?: Rule<RequiredError, ValueOfType<typeof this.narrow>>) {
-    return new TypeDefBuilder<ValidatingTypeDefWithError<T, RequiredError>>(
+  required(): TypeDefBuilder<T> {
+    return new TypeDefBuilder<T>(
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        rule: (v: any) => {
-          return this.definition.rule(v) || rule?.(v)
-        },
         required: true,
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       } as any,

package/validation/validator.ts

@@ -1,5 +1,10 @@
 import { type Simplify } from 'type-fest'
 
+export type Annotations = {
+  readonly required: boolean,
+  readonly readonly: boolean,
+}
+
 export type FunctionalValidator<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   V = any,
@@ -22,10 +27,7 @@ export type AnnotatedValidator<
   Context = any,
 > = {
   readonly validate: (v: V, valuePath: ValuePath, context: Context) => E | null,
-  readonly annotations: (valuePath: ValuePath, context: Context) => {
-    readonly required: boolean,
-    readonly readonly: boolean,
-  },
+  readonly annotations: (valuePath: ValuePath, context: Context) => Annotations,
 }
 
 export type Validator<
@@ -110,3 +112,10 @@ export function annotations<
     }
   }
 }
+
+export function mergeAnnotations(a1: Annotations, a2: Annotations) {
+  return {
+    readonly: a1.readonly || a2.readonly,
+    required: a1.required || a2.required,
+  }
+}

package/validation/validators/minimum_string_length_validator.ts

@@ -29,7 +29,7 @@ export class MinimumStringLengthValidator
 
   annotations() {
     return {
-      required: true,
+      required: this.minimumLength > 0,
       readonly: false,
     }
   }

package/validation/validators/optional_validator_proxy.ts

@@ -0,0 +1,52 @@
+import { type AnnotatedValidator } from 'validation/validator'
+
+export class OptionalValidatorProxy<
+  V,
+  V1 extends V,
+  E,
+  ValuePath extends string,
+  Context,
+> implements AnnotatedValidator<
+  V,
+  E,
+  ValuePath,
+  Context
+> {
+  static createNullable<
+    V,
+    E,
+    ValuePath extends string,
+    Context,
+  >(proxied: AnnotatedValidator<NonNullable<V>, E, ValuePath, Context>) {
+    return new OptionalValidatorProxy(proxied, (v: V) => v != null)
+  }
+
+  static createNullableOrEmptyString<
+    V extends string | null | undefined,
+    E,
+    ValuePath extends string,
+    Context,
+  >(proxied: AnnotatedValidator<NonNullable<V>, E, ValuePath, Context>) {
+    return new OptionalValidatorProxy(proxied, (v: V): v is NonNullable<V> => v != null && v !== '')
+  }
+
+  constructor(
+    private readonly proxied: AnnotatedValidator<V1, E, ValuePath, Context>,
+    private readonly isRequired: (v: V) => v is V1,
+  ) {
+  }
+
+  validate(v: V, valuePath: ValuePath, context: Context): E | null {
+    if (this.isRequired(v)) {
+      return this.proxied.validate(v, valuePath, context)
+    }
+    return null
+  }
+
+  annotations(valuePath: ValuePath, context: Context) {
+    return {
+      ...this.proxied.annotations(valuePath, context),
+      required: false,
+    }
+  }
+}

package/validation/validators/regexp_validator.ts

@@ -0,0 +1,61 @@
+import {
+  type AnnotatedValidator,
+} from 'validation/validator'
+
+export const RegexpValidationErrorType = 'regexp'
+
+export type RegexpValidationError<Intent extends string> = {
+  type: typeof RegexpValidationErrorType,
+  intent: Intent,
+}
+
+export class RegexpValidator<Intent extends string>
+  implements AnnotatedValidator<string, RegexpValidationError<Intent>, never, never>
+{
+  /**
+   * Extremely permissive email validator
+   */
+  static readonly email = new RegexpValidator(/^[^\s@]+@[^\s@]+\.[^\s@]+$/, 'email')
+
+  /**
+   * Extremely permissive phone number validator
+   */
+  static readonly phone = new RegexpValidator(/^(\+\d{1,4}[\s]*)?(((\([\d\s-]{1,6}\))|\d)[\s-]*){3,14}(\d|(\(\d+\)))$/,
+    'phone')
+
+  private readonly negate: boolean
+  private readonly required: boolean
+
+  constructor(
+    private readonly regexp: RegExp,
+    private readonly intent: Intent,
+    {
+      negate = false,
+      required = false,
+    }: {
+      negate?: boolean,
+      required?: boolean,
+    } = {},
+  ) {
+    this.negate = negate
+    this.required = required
+  }
+
+  validate(value: string): RegexpValidationError<Intent> | null {
+    const passes = this.regexp.test(value)
+    if (!passes && !this.negate || passes && this.negate) {
+      return {
+        type: RegexpValidationErrorType,
+        intent: this.intent,
+      }
+    }
+    return null
+  }
+
+  annotations() {
+    return {
+      required: this.required,
+      readonly: false,
+    }
+  }
+}

package/validation/validators/specs/minimum_string_length_validator.tests.ts

@@ -0,0 +1,76 @@
+import {
+  MinimumStringLengthValidationErrorType,
+  MinimumStringLengthValidator,
+} from 'validation/validators/minimum_string_length_validator'
+
+describe('MinimumStringLengthValidator', () => {
+  describe('required', () => {
+    it.each([
+      1,
+      2,
+      100,
+    ])('is required when the string length is %s', (minimumLength) => {
+      const validator = new MinimumStringLengthValidator(minimumLength)
+      expect(validator.annotations().required).toBeTruthy()
+    })
+
+    it('is not required when the string length is zero', () => {
+      const validator = new MinimumStringLengthValidator(0)
+      expect(validator.annotations().required).toBeFalsy()
+    })
+  })
+
+  describe('validation', () => {
+    it.each([
+      [
+        1,
+        'a',
+      ],
+      [
+        2,
+        'asdf',
+      ],
+      [
+        0,
+        '',
+      ],
+      [
+        20,
+        '12345678901234567890',
+      ],
+    ])('passes validation with minimum length %s and value "%s"', (minimumLength, value) => {
+      const validator = new MinimumStringLengthValidator(minimumLength)
+      expect(validator.validate(value)).toBeNull()
+    })
+
+    it.each([
+      [
+        1,
+        '',
+        0,
+      ],
+      [
+        2,
+        'a',
+        1,
+      ],
+      [
+        20,
+        '1234567890123456789',
+        19,
+      ],
+      [
+        100,
+        '',
+        0,
+      ],
+    ])('fails validation with minimum length %s and value "%s', (minimumLength, value, receivedLength) => {
+      const validator = new MinimumStringLengthValidator(minimumLength)
+      expect(validator.validate(value)).toEqual({
+        type: MinimumStringLengthValidationErrorType,
+        minimumLength,
+        receivedLength,
+      })
+    })
+  })
+})

package/validation/validators/specs/regexp_validator.tests.ts

@@ -0,0 +1,108 @@
+import {
+  RegexpValidationErrorType,
+  RegexpValidator,
+} from 'validation/validators/regexp_validator'
+
+describe('RegexpValidator', () => {
+  describe('phone', () => {
+    it.each([
+      '0403545000',
+      '+12 (1800) 000 000',
+      '1-2-3-4-5-6',
+      '+1 394 3234 000 (2)',
+      '1234',
+    ])('accepts "%s"', (phoneNumber) => {
+      expect(RegexpValidator.phone.validate(phoneNumber)).toBeNull()
+    })
+
+    it.each([
+      '',
+      'ABC',
+      '1',
+      ' 0412345678',
+      '----1245456',
+      '1      2',
+      '234234+234',
+    ])('rejects "%s"', (phoneNumber) => {
+      expect(RegexpValidator.phone.validate(phoneNumber)).toEqual({
+        type: RegexpValidationErrorType,
+        intent: 'phone',
+      })
+    })
+  })
+
+  describe('email', () => {
+    it.each([
+      'x@y.z',
+      'support@company.com',
+      '...@......',
+      '1234@3454.23',
+    ])('accepts "%s"', (email) => {
+      expect(RegexpValidator.email.validate(email)).toBeNull()
+    })
+
+    it.each([
+      '',
+      '@@@@',
+      'email',
+      '@bee.com',
+      'aaa@bbb',
+      'a a@b b.c c',
+    ])('rejects "%s"', (email) => {
+      expect(RegexpValidator.email.validate(email)).toEqual({
+        type: RegexpValidationErrorType,
+        intent: 'email',
+      })
+    })
+  })
+
+  describe('required', () => {
+    it.each([
+      true,
+      false,
+    ])('exposes required %s', (required) => {
+      const validator = new RegexpValidator(/a/, 'test', {
+        required,
+      })
+      expect(validator.annotations().required).toBe(required)
+    })
+  })
+
+  describe('general', () => {
+    // not here to test if regexp works
+    it.each([
+      [
+        '^a$',
+        'a',
+      ],
+      [
+        '^\\w+$',
+        'asdf',
+      ],
+    ])('passes validation with regexp "%s" and value "%s"', (regexpString, value) => {
+      const regexp = new RegExp(regexpString)
+      const validator = new RegexpValidator(regexp, 'test')
+      expect(validator.validate(value)).toBeNull()
+    })
+
+    it.each([
+      [
+        '^$',
+        'something',
+        'empty',
+      ],
+      [
+        '^\\w+$',
+        '',
+        'non-empty',
+      ],
+    ])('fails validation with regexp "%s" and value "%s', (regexpString, value, intent) => {
+      const regexp = new RegExp(regexpString)
+      const validator = new RegexpValidator(regexp, intent)
+      expect(validator.validate(value)).toEqual({
+        type: RegexpValidationErrorType,
+        intent,
+      })
+    })
+  })
+})