@hookform/resolvers 3.7.0 → 3.9.0

package/fluentvalidation-ts/src/__tests__/Form-native-validation.tsx

@@ -0,0 +1,88 @@
+import { render, screen } from '@testing-library/react';
+import user from '@testing-library/user-event';
+import { Validator } from 'fluentvalidation-ts';
+import React from 'react';
+import { useForm } from 'react-hook-form';
+import { fluentValidationResolver } from '../fluentvalidation-ts';
+
+const USERNAME_REQUIRED_MESSAGE = 'username field is required';
+const PASSWORD_REQUIRED_MESSAGE = 'password field is required';
+
+type FormData = {
+  username: string;
+  password: string;
+};
+
+class FormDataValidator extends Validator<FormData> {
+  constructor() {
+    super();
+
+    this.ruleFor('username').notEmpty().withMessage(USERNAME_REQUIRED_MESSAGE);
+    this.ruleFor('password').notEmpty().withMessage(PASSWORD_REQUIRED_MESSAGE);
+  }
+}
+
+interface Props {
+  onSubmit: (data: FormData) => void;
+}
+
+function TestComponent({ onSubmit }: Props) {
+  const { register, handleSubmit } = useForm<FormData>({
+    resolver: fluentValidationResolver(new FormDataValidator()),
+    shouldUseNativeValidation: true,
+  });
+
+  return (
+    <form onSubmit={handleSubmit(onSubmit)}>
+      <input {...register('username')} placeholder="username" />
+
+      <input {...register('password')} placeholder="password" />
+
+      <button type="submit">submit</button>
+    </form>
+  );
+}
+
+test("form's native validation with fluentvalidation-ts", async () => {
+  const handleSubmit = vi.fn();
+  render(<TestComponent onSubmit={handleSubmit} />);
+
+  // username
+  let usernameField = screen.getByPlaceholderText(
+    /username/i,
+  ) as HTMLInputElement;
+  expect(usernameField.validity.valid).toBe(true);
+  expect(usernameField.validationMessage).toBe('');
+
+  // password
+  let passwordField = screen.getByPlaceholderText(
+    /password/i,
+  ) as HTMLInputElement;
+  expect(passwordField.validity.valid).toBe(true);
+  expect(passwordField.validationMessage).toBe('');
+
+  await user.click(screen.getByText(/submit/i));
+
+  // username
+  usernameField = screen.getByPlaceholderText(/username/i) as HTMLInputElement;
+  expect(usernameField.validity.valid).toBe(false);
+  expect(usernameField.validationMessage).toBe(USERNAME_REQUIRED_MESSAGE);
+
+  // password
+  passwordField = screen.getByPlaceholderText(/password/i) as HTMLInputElement;
+  expect(passwordField.validity.valid).toBe(false);
+  expect(passwordField.validationMessage).toBe(PASSWORD_REQUIRED_MESSAGE);
+
+  await user.type(screen.getByPlaceholderText(/username/i), 'joe');
+  await user.type(screen.getByPlaceholderText(/password/i), 'password');
+
+  // username
+  usernameField = screen.getByPlaceholderText(/username/i) as HTMLInputElement;
+  expect(usernameField.validity.valid).toBe(true);
+  expect(usernameField.validationMessage).toBe('');
+
+  // password
+  passwordField = screen.getByPlaceholderText(/password/i) as HTMLInputElement;
+  expect(passwordField.validity.valid).toBe(true);
+  expect(passwordField.validationMessage).toBe('');
+});

package/fluentvalidation-ts/src/__tests__/Form.tsx

@@ -0,0 +1,63 @@
+import { render, screen } from '@testing-library/react';
+import user from '@testing-library/user-event';
+import { Validator } from 'fluentvalidation-ts';
+import React from 'react';
+import { SubmitHandler, useForm } from 'react-hook-form';
+import { fluentValidationResolver } from '../fluentvalidation-ts';
+
+type FormData = {
+  username: string;
+  password: string;
+};
+
+class FormDataValidator extends Validator<FormData> {
+  constructor() {
+    super();
+
+    this.ruleFor('username')
+      .notEmpty()
+      .withMessage('username is a required field');
+    this.ruleFor('password')
+      .notEmpty()
+      .withMessage('password is a required field');
+  }
+}
+
+interface Props {
+  onSubmit: SubmitHandler<FormData>;
+}
+
+function TestComponent({ onSubmit }: Props) {
+  const {
+    register,
+    formState: { errors },
+    handleSubmit,
+  } = useForm({
+    resolver: fluentValidationResolver(new FormDataValidator()), // Useful to check TypeScript regressions
+  });
+
+  return (
+    <form onSubmit={handleSubmit(onSubmit)}>
+      <input {...register('username')} />
+      {errors.username && <span role="alert">{errors.username.message}</span>}
+
+      <input {...register('password')} />
+      {errors.password && <span role="alert">{errors.password.message}</span>}
+
+      <button type="submit">submit</button>
+    </form>
+  );
+}
+
+test("form's validation with Yup and TypeScript's integration", async () => {
+  const handleSubmit = vi.fn();
+  render(<TestComponent onSubmit={handleSubmit} />);
+
+  expect(screen.queryAllByRole('alert')).toHaveLength(0);
+
+  await user.click(screen.getByText(/submit/i));
+
+  expect(screen.getByText(/username is a required field/i)).toBeInTheDocument();
+  expect(screen.getByText(/password is a required field/i)).toBeInTheDocument();
+  expect(handleSubmit).not.toHaveBeenCalled();
+});

package/fluentvalidation-ts/src/__tests__/__fixtures__/data.ts

@@ -0,0 +1,121 @@
+import { Validator } from 'fluentvalidation-ts';
+import { Field, InternalFieldName } from 'react-hook-form';
+
+const beNumeric = (value: string | number | undefined) => !isNaN(Number(value));
+
+export type Schema = {
+  username: string;
+  password: string;
+  repeatPassword: string;
+  accessToken?: string;
+  birthYear?: number;
+  email?: string;
+  tags?: string[];
+  enabled?: boolean;
+  like?: {
+    id: number;
+    name: string;
+  }[];
+};
+
+export type SchemaWithWhen = {
+  name: string;
+  value: string;
+};
+
+export class SchemaValidator extends Validator<Schema> {
+  constructor() {
+    super();
+
+    this.ruleFor('username')
+      .notEmpty()
+      .matches(/^\w+$/)
+      .minLength(3)
+      .maxLength(30);
+
+    this.ruleFor('password')
+      .notEmpty()
+      .matches(/.*[A-Z].*/)
+      .withMessage('One uppercase character')
+      .matches(/.*[a-z].*/)
+      .withMessage('One lowercase character')
+      .matches(/.*\d.*/)
+      .withMessage('One number')
+      .matches(new RegExp('.*[`~<>?,./!@#$%^&*()\\-_+="\'|{}\\[\\];:\\\\].*'))
+      .withMessage('One special character')
+      .minLength(8)
+      .withMessage('Must be at least 8 characters in length');
+
+    this.ruleFor('repeatPassword')
+      .notEmpty()
+      .must((repeatPassword, data) => repeatPassword === data.password);
+
+    this.ruleFor('accessToken');
+    this.ruleFor('birthYear')
+      .must(beNumeric)
+      .inclusiveBetween(1900, 2013)
+      .when((birthYear) => birthYear != undefined);
+
+    this.ruleFor('email').emailAddress();
+    this.ruleFor('tags');
+    this.ruleFor('enabled');
+
+    this.ruleForEach('like').setValidator(() => new LikeValidator());
+  }
+}
+
+export class LikeValidator extends Validator<{
+  id: number;
+  name: string;
+}> {
+  constructor() {
+    super();
+
+    this.ruleFor('id').notNull();
+    this.ruleFor('name').notEmpty().length(4, 4);
+  }
+}
+
+export const validData = {
+  username: 'Doe',
+  password: 'Password123_',
+  repeatPassword: 'Password123_',
+  birthYear: 2000,
+  email: 'john@doe.com',
+  tags: ['tag1', 'tag2'],
+  enabled: true,
+  accesstoken: 'accesstoken',
+  like: [
+    {
+      id: 1,
+      name: 'name',
+    },
+  ],
+} as Schema;
+
+export const invalidData = {
+  password: '___',
+  email: '',
+  birthYear: 'birthYear',
+  like: [{ id: 'z' }],
+  // Must be set to "unknown", otherwise typescript knows that it is invalid
+} as unknown as Required<Schema>;
+
+export const fields: Record<InternalFieldName, Field['_f']> = {
+  username: {
+    ref: { name: 'username' },
+    name: 'username',
+  },
+  password: {
+    ref: { name: 'password' },
+    name: 'password',
+  },
+  email: {
+    ref: { name: 'email' },
+    name: 'email',
+  },
+  birthday: {
+    ref: { name: 'birthday' },
+    name: 'birthday',
+  },
+};

package/fluentvalidation-ts/src/__tests__/__snapshots__/fluentvalidation-ts.ts.snap

@@ -0,0 +1,129 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`fluentValidationResolver > should return a single error from fluentValidationResolver when validation fails 1`] = `
+{
+  "errors": {
+    "birthYear": {
+      "message": "Value is not valid",
+      "ref": undefined,
+      "type": "validation",
+    },
+    "email": {
+      "message": "Not a valid email address",
+      "ref": {
+        "name": "email",
+      },
+      "type": "validation",
+    },
+    "password": {
+      "message": "One uppercase character",
+      "ref": {
+        "name": "password",
+      },
+      "type": "validation",
+    },
+    "repeatPassword": {
+      "message": "Value is not valid",
+      "ref": undefined,
+      "type": "validation",
+    },
+  },
+  "values": {},
+}
+`;
+
+exports[`fluentValidationResolver > should return a single error from fluentValidationResolver with \`mode: sync\` when validation fails 1`] = `
+{
+  "errors": {
+    "birthYear": {
+      "message": "Value is not valid",
+      "ref": undefined,
+      "type": "validation",
+    },
+    "email": {
+      "message": "Not a valid email address",
+      "ref": {
+        "name": "email",
+      },
+      "type": "validation",
+    },
+    "password": {
+      "message": "One uppercase character",
+      "ref": {
+        "name": "password",
+      },
+      "type": "validation",
+    },
+    "repeatPassword": {
+      "message": "Value is not valid",
+      "ref": undefined,
+      "type": "validation",
+    },
+  },
+  "values": {},
+}
+`;
+
+exports[`fluentValidationResolver > should return all the errors from fluentValidationResolver when validation fails with \`validateAllFieldCriteria\` set to true 1`] = `
+{
+  "errors": {
+    "birthYear": {
+      "message": "Value is not valid",
+      "ref": undefined,
+      "type": "validation",
+    },
+    "email": {
+      "message": "Not a valid email address",
+      "ref": {
+        "name": "email",
+      },
+      "type": "validation",
+    },
+    "password": {
+      "message": "One uppercase character",
+      "ref": {
+        "name": "password",
+      },
+      "type": "validation",
+    },
+    "repeatPassword": {
+      "message": "Value is not valid",
+      "ref": undefined,
+      "type": "validation",
+    },
+  },
+  "values": {},
+}
+`;
+
+exports[`fluentValidationResolver > should return all the errors from fluentValidationResolver when validation fails with \`validateAllFieldCriteria\` set to true and \`mode: sync\` 1`] = `
+{
+  "errors": {
+    "birthYear": {
+      "message": "Value is not valid",
+      "ref": undefined,
+      "type": "validation",
+    },
+    "email": {
+      "message": "Not a valid email address",
+      "ref": {
+        "name": "email",
+      },
+      "type": "validation",
+    },
+    "password": {
+      "message": "One uppercase character",
+      "ref": {
+        "name": "password",
+      },
+      "type": "validation",
+    },
+    "repeatPassword": {
+      "message": "Value is not valid",
+      "ref": undefined,
+      "type": "validation",
+    },
+  },
+  "values": {},
+}
+`;

package/fluentvalidation-ts/src/__tests__/fluentvalidation-ts.ts

@@ -0,0 +1,113 @@
+/* eslint-disable no-console, @typescript-eslint/ban-ts-comment */
+import { fluentValidationResolver } from '..';
+import {
+  SchemaValidator,
+  fields,
+  invalidData,
+  validData,
+} from './__fixtures__/data';
+
+const shouldUseNativeValidation = false;
+
+const validator = new SchemaValidator();
+
+describe('fluentValidationResolver', () => {
+  it('should return values from fluentValidationResolver when validation pass', async () => {
+    const validatorSpy = vi.spyOn(validator, 'validate');
+
+    const result = await fluentValidationResolver(validator)(
+      validData,
+      undefined,
+      {
+        fields,
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(validatorSpy).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({ errors: {}, values: validData });
+  });
+
+  it('should return values from fluentValidationResolver with `mode: sync` when validation pass', async () => {
+    const validatorSpy = vi.spyOn(validator, 'validate');
+
+    const result = await fluentValidationResolver(validator)(
+      validData,
+      undefined,
+      { fields, shouldUseNativeValidation },
+    );
+
+    expect(validatorSpy).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({ errors: {}, values: validData });
+  });
+
+  it('should return a single error from fluentValidationResolver when validation fails', async () => {
+    const result = await fluentValidationResolver(validator)(
+      invalidData,
+      undefined,
+      {
+        fields,
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return a single error from fluentValidationResolver with `mode: sync` when validation fails', async () => {
+    const validateSpy = vi.spyOn(validator, 'validate');
+
+    const result = await fluentValidationResolver(validator)(
+      invalidData,
+      undefined,
+      { fields, shouldUseNativeValidation },
+    );
+
+    expect(validateSpy).toHaveBeenCalledTimes(1);
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return all the errors from fluentValidationResolver when validation fails with `validateAllFieldCriteria` set to true', async () => {
+    const result = await fluentValidationResolver(validator)(
+      invalidData,
+      undefined,
+      {
+        fields,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return all the errors from fluentValidationResolver when validation fails with `validateAllFieldCriteria` set to true and `mode: sync`', async () => {
+    const result = await fluentValidationResolver(validator)(
+      invalidData,
+      undefined,
+      {
+        fields,
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return values from fluentValidationResolver when validation pass & raw=true', async () => {
+    const schemaSpy = vi.spyOn(validator, 'validate');
+
+    const result = await fluentValidationResolver(validator)(
+      validData,
+      undefined,
+      {
+        fields,
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(schemaSpy).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({ errors: {}, values: validData });
+  });
+});

package/fluentvalidation-ts/src/fluentvalidation-ts.ts

@@ -0,0 +1,102 @@
+import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';
+import {
+  AsyncValidator,
+  ValidationErrors,
+  Validator,
+} from 'fluentvalidation-ts';
+import { FieldError, FieldValues, Resolver } from 'react-hook-form';
+
+function traverseObject<T>(
+  object: ValidationErrors<T>,
+  errors: Record<string, FieldError>,
+  parentIndices: (string | number)[] = [],
+) {
+  for (const key in object) {
+    const currentIndex = [...parentIndices, key];
+    const currentValue = object[key];
+
+    if (Array.isArray(currentValue)) {
+      currentValue.forEach((item: any, index: number) => {
+        traverseObject(item, errors, [...currentIndex, index]);
+      });
+    } else if (typeof currentValue === 'object' && currentValue !== null) {
+      traverseObject(currentValue, errors, currentIndex);
+    } else if (typeof currentValue === 'string') {
+      errors[currentIndex.join('.')] = {
+        type: 'validation',
+        message: currentValue,
+      };
+    }
+  }
+}
+
+const parseErrorSchema = <T>(
+  validationErrors: ValidationErrors<T>,
+  validateAllFieldCriteria: boolean,
+) => {
+  if (validateAllFieldCriteria) {
+    // TODO: check this but i think its always one validation error
+  }
+
+  const errors: Record<string, FieldError> = {};
+  traverseObject(validationErrors, errors);
+
+  return errors;
+};
+
+export function fluentValidationResolver<TFieldValues extends FieldValues>(
+  validator: Validator<TFieldValues>,
+): Resolver<TFieldValues> {
+  return async (values, _context, options) => {
+    const validationResult = validator.validate(values);
+    const isValid = Object.keys(validationResult).length === 0;
+
+    options.shouldUseNativeValidation && validateFieldsNatively({}, options);
+
+    return isValid
+      ? {
+          values: values,
+          errors: {},
+        }
+      : {
+          values: {},
+          errors: toNestErrors(
+            parseErrorSchema(
+              validationResult,
+              !options.shouldUseNativeValidation &&
+                options.criteriaMode === 'all',
+            ),
+            options,
+          ),
+        };
+  };
+}
+
+export function fluentAsyncValidationResolver<
+  TFieldValues extends FieldValues,
+  TValidator extends AsyncValidator<TFieldValues>,
+>(validator: TValidator): Resolver<TFieldValues> {
+  return async (values, _context, options) => {
+    const validationResult = await validator.validateAsync(values);
+    const isValid = Object.keys(validationResult).length === 0;
+
+    options.shouldUseNativeValidation && validateFieldsNatively({}, options);
+
+    return isValid
+      ? {
+          values: values,
+          errors: {},
+        }
+      : {
+          values: {},
+          errors: toNestErrors(
+            parseErrorSchema(
+              validationResult,
+              !options.shouldUseNativeValidation &&
+                options.criteriaMode === 'all',
+            ),
+            options,
+          ),
+        };
+  };
+}

package/fluentvalidation-ts/src/index.ts

@@ -0,0 +1 @@
+export * from './fluentvalidation-ts';

package/io-ts/dist/errorsToRecord.d.ts

@@ -1,5 +1,4 @@
 import { ValidationError } from 'io-ts';
-import * as ReadonlyArray from 'fp-ts/ReadonlyArray';
 import { ErrorObject } from './types';
 declare const errorsToRecord: (validateAllFieldCriteria: boolean) => (validationErrors: ReadonlyArray<ValidationError>) => ErrorObject;
 export default errorsToRecord;

package/io-ts/dist/io-ts.js

@@ -1,2 +1,2 @@
-var e=require("fp-ts/Either"),t=require("fp-ts/function"),n=require("@hookform/resolvers"),r=require("io-ts"),i=require("fp-ts/ReadonlyArray"),o=require("fp-ts/Option"),u=require("fp-ts/Semigroup"),a=require("fp-ts/ReadonlyRecord");function f(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach(function(n){if("default"!==n){var r=Object.getOwnPropertyDescriptor(e,n);Object.defineProperty(t,n,r.get?r:{enumerable:!0,get:function(){return e[n]}})}}),t.default=e,t}var c=/*#__PURE__*/f(e),p=/*#__PURE__*/f(i),s=/*#__PURE__*/f(o),l=/*#__PURE__*/f(u),d=/*#__PURE__*/f(a);function m(){return m=Object.assign?Object.assign.bind():function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},m.apply(this,arguments)}var y=function(e){return e.reduce(function(e,n,r){return t.pipe(n,c.fold(function(e){return(r>0?".":"")+e},function(e){return"["+e+"]"}),function(t){return""+e+t})},"")},v=["path"],g=[r.TaggedUnionType,r.UnionType,r.IntersectionType,r.ExactType,r.RefinementType],b=function(e){var n,r=t.pipe(n=e.context,p.filterMapWithIndex(function(e,t){var r=e-1,i=-1===r?void 0:n[r];return void 0===i||g.some(function(e){return i.type instanceof e})?s.none:s.some(t)}),p.map(function(e){return e.key}),p.map(function(e){return t.pipe(e,function(e){return parseInt(e,10)},c.fromPredicate(t.not(Number.isNaN),function(){return e}))}),p.toArray,y);return{message:t.pipe(e.message,c.fromNullable(e.context),c.mapLeft(t.flow(p.last,s.map(function(e){return"expected "+e.type.name+" but got "+JSON.stringify(e.actual)}),s.getOrElseW(function(){return t.absurd("Error context is missing name")}))),c.getOrElseW(t.identity)),type:t.pipe(e.context,p.last,s.map(function(e){return e.type.name}),s.getOrElse(function(){return"unknown"})),path:r}},O=function(e){return t.pipe(e,p.map(function(e){var t;return(t={})[e.path]={type:e.type,message:e.message},t}),function(e){return l.fold({concat:function(e,t){return Object.assign({},t,e)}})({},e)})},h={concat:function(e,t){var n;return m({},t,{types:m({},e.types,(n={},n[e.type]=e.message,n[t.type]=t.message,n))})}},j=function(e){return t.pipe(d.fromFoldableMap(h,p.Foldable)(e,function(e){return[e.path,e]}),d.map(function(e){return function(e,t){if(null==e)return{};var n,r,i={},o=Object.keys(e);for(r=0;r<o.length;r++)t.indexOf(n=o[r])>=0||(i[n]=e[n]);return i}(e,v)}))};exports.ioTsResolver=function(e){return function(r,i,o){return t.pipe(r,e.decode,c.mapLeft((u=!o.shouldUseNativeValidation&&"all"===o.criteriaMode,function(e){var n=u?j:O;return t.pipe(e,p.map(b),n)})),c.mapLeft(function(e){return n.toNestErrors(e,o)}),c.fold(function(e){return{values:{},errors:e}},function(e){return o.shouldUseNativeValidation&&n.validateFieldsNatively({},o),{values:e,errors:{}}}));var u}};
+var e=require("@hookform/resolvers"),n=require("fp-ts/Either"),t=require("fp-ts/function"),r=require("fp-ts/Option"),i=require("fp-ts/ReadonlyArray"),u=require("fp-ts/ReadonlyRecord"),o=require("fp-ts/Semigroup"),a=require("io-ts");function f(e){if(e&&e.__esModule)return e;var n=Object.create(null);return e&&Object.keys(e).forEach(function(t){if("default"!==t){var r=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(n,t,r.get?r:{enumerable:!0,get:function(){return e[t]}})}}),n.default=e,n}var c=/*#__PURE__*/f(n),p=/*#__PURE__*/f(r),s=/*#__PURE__*/f(i),l=/*#__PURE__*/f(u),d=/*#__PURE__*/f(o);function m(){return m=Object.assign?Object.assign.bind():function(e){for(var n=1;n<arguments.length;n++){var t=arguments[n];for(var r in t)({}).hasOwnProperty.call(t,r)&&(e[r]=t[r])}return e},m.apply(null,arguments)}var y=function(e){return e.reduce(function(e,n,r){return t.pipe(n,c.fold(function(e){return(r>0?".":"")+e},function(e){return"["+e+"]"}),function(n){return""+e+n})},"")},v=["path"],g=[a.TaggedUnionType,a.UnionType,a.IntersectionType,a.ExactType,a.RefinementType],O=function(e){var n,r=t.pipe(n=e.context,s.filterMapWithIndex(function(e,t){var r=e-1,i=-1===r?void 0:n[r];return void 0===i||g.some(function(e){return i.type instanceof e})?p.none:p.some(t)}),s.map(function(e){return e.key}),s.map(function(e){return t.pipe(e,function(e){return parseInt(e,10)},c.fromPredicate(t.not(Number.isNaN),function(){return e}))}),s.toArray,y);return{message:t.pipe(e.message,c.fromNullable(e.context),c.mapLeft(t.flow(s.last,p.map(function(e){return"expected "+e.type.name+" but got "+JSON.stringify(e.actual)}),p.getOrElseW(function(){return t.absurd("Error context is missing name")}))),c.getOrElseW(t.identity)),type:t.pipe(e.context,s.last,p.map(function(e){return e.type.name}),p.getOrElse(function(){return"unknown"})),path:r}},b=function(e){return t.pipe(e,s.map(function(e){var n;return(n={})[e.path]={type:e.type,message:e.message},n}),function(e){return d.fold({concat:function(e,n){return Object.assign({},n,e)}})({},e)})},h={concat:function(e,n){var t;return m({},n,{types:m({},e.types,(t={},t[e.type]=e.message,t[n.type]=n.message,t))})}},x=function(e){return t.pipe(l.fromFoldableMap(h,s.Foldable)(e,function(e){return[e.path,e]}),l.map(function(e){return function(e,n){if(null==e)return{};var t={};for(var r in e)if({}.hasOwnProperty.call(e,r)){if(n.indexOf(r)>=0)continue;t[r]=e[r]}return t}(e,v)}))};exports.ioTsResolver=function(n){return function(r,i,u){return t.pipe(r,n.decode,c.mapLeft((o=!u.shouldUseNativeValidation&&"all"===u.criteriaMode,function(e){var n=o?x:b;return t.pipe(e,s.map(O),n)})),c.mapLeft(function(n){return e.toNestErrors(n,u)}),c.fold(function(e){return{values:{},errors:e}},function(n){return u.shouldUseNativeValidation&&e.validateFieldsNatively({},u),{values:n,errors:{}}}));var o}};
 //# sourceMappingURL=io-ts.js.map