Rename markup validator → structured validator

README.md

@@ -153,7 +153,7 @@ const env = cleanEnv(process.env, {
 ```
 ### TypeScript users
 
-You can use either one of `makeValidator`, `makeExactValidator` and `makeMarkupValidator`
+You can use either one of `makeValidator`, `makeExactValidator` and `makeStructuredValidator`
 depending on your use case.
 
 #### `makeValidator<BaseT>`
@@ -189,20 +189,20 @@ const MAX_RETRIES = int({ choices: [1, 2, 3, 4] })
 As you can see in this instance, _the output type is exactly `number`, the parameter type of
 `makeExactValidator`_. Also note that here, `int` is not parametrizable.
 
-#### `makeMarkupValidator`
+#### `makeStructuredValidator`
 
 This validator is meant for inputs which can produce arbitrary output types (e.g. `json`).
 The typing logic behaves differently here:
 
-- `makeMarkupValidator` has no type parameter.
+- `makeStructuredValidator` has no type parameter.
 - When no types can be inferred from context, output type defaults to any.
 - Otherwise, infers type from `default` or `devDefault`.
 - Also allows validator parametrized types.
 
 Below is an example of a validator for query parameters (e.g. `option1=foo&option2=bar`)
 
 ```ts
-const queryParams = makeMarkupValidator((input: string) => {
+const queryParams = makeStructuredValidator((input: string) => {
   const params = new URLSearchParams(input)
   return Object.fromEntries(params.entries())
 })

src/types.ts

@@ -70,12 +70,12 @@ export interface BaseValidator<BaseT> {
   <T extends BaseT>(spec: OptionalSpec<T>): OptionalValidatorSpec<T>
 }
 
-// Such validator inputs a markup language such as JSON.
+// Such validator inputs a structured input format such as JSON.
 // Because it can output complex types, including objects:
 // - it has no supertype
 // - it fallbacks to 'any' when no type information can be inferred
 //   from the spec object.
-export interface MarkupValidator {
+export interface StructuredValidator {
   // Defaults to any when no argument (prevents 'unknown')
   (): RequiredValidatorSpec<any>
   // Allow overriding output type with type parameter

src/validators.ts

@@ -1,4 +1,4 @@
-import { Spec, ValidatorSpec, BaseValidator, MarkupValidator, ExactValidator } from './types'
+import { Spec, ValidatorSpec, BaseValidator, StructuredValidator, ExactValidator } from './types'
 import { EnvError } from './errors'
 
 // Simplified adaptation of https://github.com/validatorjs/validator.js/blob/master/src/lib/isFQDN.js
@@ -74,7 +74,7 @@ export const makeExactValidator = <T>(parseFn: (input: string) => T): ExactValid
  * It default the output type to any if no type inference can be made.
  *
  * ```ts
- * const queryParams = makeMarkupValidator((input: string) => {
+ * const queryParams = makeStructuredValidator((input: string) => {
  *   // Implementation details
  * })
  * const OPTIONS = queryParams({ default: { option1: true, option2: false } })
@@ -84,8 +84,8 @@ export const makeExactValidator = <T>(parseFn: (input: string) => T): ExactValid
  * @param parseFn - A function to parse and validate input.
  * @returns A validator which output type is exactly `T`
  */
-export const makeMarkupValidator = (parseFn: (input: string) => unknown): MarkupValidator => {
-  return internalMakeValidator(parseFn) as MarkupValidator
+export const makeStructuredValidator = (parseFn: (input: string) => unknown): StructuredValidator => {
+  return internalMakeValidator(parseFn) as StructuredValidator
 }
 
 // We use exact validator here because narrowing down to either 'true' or 'false'
@@ -164,7 +164,7 @@ export const url = makeValidator<string>((x: string) => {
  * })
  * ```
  */
-export const json = makeMarkupValidator((x: string) => {
+export const json = makeStructuredValidator((x: string) => {
   try {
     return JSON.parse(x)
   } catch (e) {

tests/types.test.ts

@@ -5,7 +5,7 @@ import {
   num,
   RequiredValidatorSpec,
   OptionalValidatorSpec,
-  makeMarkupValidator,
+  makeStructuredValidator,
   json,
   makeValidator,
 } from '../src'
@@ -149,7 +149,7 @@ describe('validators types', () => {
     ).toEqualTypeOf<RequiredValidatorSpec<'foo' | 'bar'>>()
   })
   test('structured data validator', () => {
-    const validator = makeMarkupValidator(() => ({}))
+    const validator = makeStructuredValidator(() => ({}))
     expectTypeOf(validator()).toEqualTypeOf<RequiredValidatorSpec<any>>()
     expectTypeOf(validator({ default: {} as any })).toEqualTypeOf<RequiredValidatorSpec<any>>()
     expectTypeOf(validator({ default: undefined })).toEqualTypeOf<OptionalValidatorSpec<any>>()