@strictly/define 0.0.7 → 0.0.9

package/dist/index.d.cts

@@ -266,25 +266,27 @@ 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;
 type ValidationError<Type extends string, Data = {}> = Simplify<{
     type: Type;
 } & Data>;
-declare function isFunctionalValidator(v: Validator): v is FunctionalValidator;
-declare function isAnnotatedValidator(v: Validator): v is AnnotatedValidator;
+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;
@@ -402,9 +404,8 @@ type ValidatingUnionTypeDefWithError<T extends ValidatingUnionTypeDef, E2> = T e
 declare class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingType<T> {
     readonly definition: T;
     constructor(definition: T);
-    enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
-    required(): TypeDefBuilder<ValidatingTypeDefWithError<T, never>>;
-    required<RequiredError>(rule: Rule<RequiredError, ValueOfType<typeof this.narrow>>): TypeDefBuilder<ValidatingTypeDefWithError<T, RequiredError>>;
+    enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>> | Validator<ValueOfType<Type<T>>, E2, never, never>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
+    required(): TypeDefBuilder<T>;
     readonly(): TypeDefBuilder<T>;
     get _type(): TypeOfType<Type<T>>;
     get narrow(): ValidatingType<T>;
@@ -519,7 +520,7 @@ type ValueTypesOfDiscriminatedUnion<U extends UnionTypeDef> = U extends UnionTyp
     };
 } : never : never;
 
-declare class DefinedValidator<V, E, ValuePath extends string, Context> implements AnnotatedValidator<V | null | undefined, E, ValuePath, Context> {
+declare class DefinedValidator<V, E> implements AnnotatedValidator<V | null | undefined, E, never, never> {
     private readonly error;
     constructor(error: E);
     validate(v: V | null | undefined): E | null;
@@ -535,7 +536,7 @@ type MinimumStringLengthValidationError = {
     receivedLength: number;
     minimumLength: number;
 };
-declare class MinimumStringLengthValidator<ValuePath extends string, Context> implements AnnotatedValidator<string, MinimumStringLengthValidationError, ValuePath, Context> {
+declare class MinimumStringLengthValidator implements AnnotatedValidator<string, MinimumStringLengthValidationError, never, never> {
     private readonly minimumLength;
     constructor(minimumLength: number);
     validate(value: string): MinimumStringLengthValidationError | null;
@@ -545,8 +546,50 @@ declare class MinimumStringLengthValidator<ValuePath extends string, Context> im
     };
 }
 
+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.d.ts

@@ -266,25 +266,27 @@ 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;
 type ValidationError<Type extends string, Data = {}> = Simplify<{
     type: Type;
 } & Data>;
-declare function isFunctionalValidator(v: Validator): v is FunctionalValidator;
-declare function isAnnotatedValidator(v: Validator): v is AnnotatedValidator;
+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;
@@ -402,9 +404,8 @@ type ValidatingUnionTypeDefWithError<T extends ValidatingUnionTypeDef, E2> = T e
 declare class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingType<T> {
     readonly definition: T;
     constructor(definition: T);
-    enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
-    required(): TypeDefBuilder<ValidatingTypeDefWithError<T, never>>;
-    required<RequiredError>(rule: Rule<RequiredError, ValueOfType<typeof this.narrow>>): TypeDefBuilder<ValidatingTypeDefWithError<T, RequiredError>>;
+    enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>> | Validator<ValueOfType<Type<T>>, E2, never, never>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
+    required(): TypeDefBuilder<T>;
     readonly(): TypeDefBuilder<T>;
     get _type(): TypeOfType<Type<T>>;
     get narrow(): ValidatingType<T>;
@@ -519,7 +520,7 @@ type ValueTypesOfDiscriminatedUnion<U extends UnionTypeDef> = U extends UnionTyp
     };
 } : never : never;
 
-declare class DefinedValidator<V, E, ValuePath extends string, Context> implements AnnotatedValidator<V | null | undefined, E, ValuePath, Context> {
+declare class DefinedValidator<V, E> implements AnnotatedValidator<V | null | undefined, E, never, never> {
     private readonly error;
     constructor(error: E);
     validate(v: V | null | undefined): E | null;
@@ -535,7 +536,7 @@ type MinimumStringLengthValidationError = {
     receivedLength: number;
     minimumLength: number;
 };
-declare class MinimumStringLengthValidator<ValuePath extends string, Context> implements AnnotatedValidator<string, MinimumStringLengthValidationError, ValuePath, Context> {
+declare class MinimumStringLengthValidator implements AnnotatedValidator<string, MinimumStringLengthValidationError, never, never> {
     private readonly minimumLength;
     constructor(minimumLength: number);
     validate(value: string): MinimumStringLengthValidationError | null;
@@ -545,8 +546,50 @@ declare class MinimumStringLengthValidator<ValuePath extends string, Context> im
     };
 }
 
+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
@@ -640,6 +640,37 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
   }
 }
 
+// validation/validator.ts
+function isFunctionalValidator(v) {
+  return typeof v === "function";
+}
+function isAnnotatedValidator(v) {
+  return typeof v !== "function";
+}
+function validate(validator, v, valuePath, context) {
+  if (isAnnotatedValidator(validator)) {
+    return validator.validate(v, valuePath, context);
+  } else {
+    return validator(v, valuePath, context);
+  }
+}
+function annotations(validator, valuePath, context) {
+  if (isAnnotatedValidator(validator)) {
+    return validator.annotations(valuePath, context);
+  } else {
+    return {
+      required: false,
+      readonly: false
+    };
+  }
+}
+function mergeAnnotations(a1, a2) {
+  return {
+    readonly: a1.readonly || a2.readonly,
+    required: a1.required || a2.required
+  };
+}
+
 // types/type_of_type.ts
 import {
   map as map2,
@@ -733,23 +764,20 @@ var TypeDefBuilder = class _TypeDefBuilder {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
+        ...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) || rule(value);
+          return this.definition.rule(value) ?? validate(rule, value, null, null);
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       }
     );
   }
-  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
       }
@@ -954,31 +982,6 @@ function union(discriminator) {
   );
 }
 
-// validation/validator.ts
-function isFunctionalValidator(v) {
-  return typeof v === "function";
-}
-function isAnnotatedValidator(v) {
-  return typeof v !== "function";
-}
-function validate(validator, v, valuePath, context) {
-  if (isAnnotatedValidator(validator)) {
-    return validator.validate(v, valuePath, context);
-  } else {
-    return validator(v, valuePath, context);
-  }
-}
-function annotations(validator, valuePath, context) {
-  if (isAnnotatedValidator(validator)) {
-    return validator.annotations(valuePath, context);
-  } else {
-    return {
-      required: false,
-      readonly: false
-    };
-  }
-}
-
 // validation/validators/defined_validator.ts
 var DefinedValidator = class {
   constructor(error) {
@@ -1016,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
     };
   }
@@ -1025,6 +1097,9 @@ export {
   DefinedValidator,
   MinimumStringLengthValidationErrorType,
   MinimumStringLengthValidator,
+  OptionalValidatorProxy,
+  RegexpValidationErrorType,
+  RegexpValidator,
   TypeDefType,
   annotations,
   booleanType,
@@ -1042,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.7",
+  "version": "0.0.9",
   "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

@@ -1,6 +1,12 @@
 import {
   type IsFieldReadonly,
 } from '@strictly/base'
+import {
+  isAnnotatedValidator,
+  mergeAnnotations,
+  validate,
+  type Validator,
+} from 'validation/validator'
 import {
   type ObjectFieldKey,
   type RecordKeyType,
@@ -37,35 +43,26 @@ class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingType<T> {
   constructor(readonly definition: T) {
   }
 
-  enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>>) {
+  enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>> | Validator<ValueOfType<Type<T>>, E2, never, never>) {
     return new TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>(
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
+        ...(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) || rule(value)
+          return this.definition.rule(value) ?? validate(rule, value, null!, null!)
         },
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       } as any,
     )
   }
 
-  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<
@@ -47,11 +49,21 @@ export type ValidationError<Type extends string, Data = {}> = Simplify<
   } & Data
 >
 
-export function isFunctionalValidator(v: Validator): v is FunctionalValidator {
+export function isFunctionalValidator<
+  V,
+  E,
+  ValuePath extends string,
+  Context,
+>(v: Validator<V, E, ValuePath, Context>): v is FunctionalValidator<V, E, ValuePath, Context> {
   return typeof v === 'function'
 }
 
-export function isAnnotatedValidator(v: Validator): v is AnnotatedValidator {
+export function isAnnotatedValidator<
+  V,
+  E,
+  ValuePath extends string,
+  Context,
+>(v: Validator<V, E, ValuePath, Context>): v is AnnotatedValidator<V, E, ValuePath, Context> {
   return typeof v !== 'function'
 }
 
@@ -73,8 +85,7 @@ export function validate<
   if (isAnnotatedValidator(validator)) {
     return validator.validate(v, valuePath, context)
   } else {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return (validator as FunctionalValidator<V, E, ValuePath, Context>)(v, valuePath, context)
+    return validator(v, valuePath, context)
   }
 }
 
@@ -101,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/defined_validator.ts

@@ -1,8 +1,6 @@
 import { type AnnotatedValidator } from 'validation/validator'
 
-export class DefinedValidator<V, E, ValuePath extends string, Context>
-  implements AnnotatedValidator<V | null | undefined, E, ValuePath, Context>
-{
+export class DefinedValidator<V, E> implements AnnotatedValidator<V | null | undefined, E, never, never> {
   constructor(private readonly error: E) {
   }
 

package/validation/validators/minimum_string_length_validator.ts

@@ -10,8 +10,8 @@ export type MinimumStringLengthValidationError = {
   minimumLength: number,
 }
 
-export class MinimumStringLengthValidator<ValuePath extends string, Context>
-  implements AnnotatedValidator<string, MinimumStringLengthValidationError, ValuePath, Context>
+export class MinimumStringLengthValidator
+  implements AnnotatedValidator<string, MinimumStringLengthValidationError, never, never>
 {
   constructor(private readonly minimumLength: number) {
   }
@@ -29,7 +29,7 @@ export class MinimumStringLengthValidator<ValuePath extends string, Context>
 
   annotations() {
     return {
-      required: true,
+      required: this.minimumLength > 0,
       readonly: false,
     }
   }