build revisions and layout updates for toast

node_modules/@hookform/resolvers/effect-ts/dist/effect-ts.d.ts

@@ -0,0 +1,11 @@
+import { Schema } from 'effect';
+import { ParseOptions } from 'effect/SchemaAST';
+import { FieldValues, Resolver } from 'react-hook-form';
+export declare function effectTsResolver<Input extends FieldValues, Context, Output>(schema: Schema.Schema<Output, Input>, schemaOptions?: ParseOptions, resolverOptions?: {
+    mode?: 'async' | 'sync';
+    raw?: false;
+}): Resolver<Input, Context, Output>;
+export declare function effectTsResolver<Input extends FieldValues, Context, Output>(schema: Schema.Schema<Output, Input>, schemaOptions: ParseOptions | undefined, resolverOptions: {
+    mode?: 'async' | 'sync';
+    raw: true;
+}): Resolver<Input, Context, Input>;

node_modules/@hookform/resolvers/effect-ts/dist/effect-ts.js

@@ -0,0 +1,2 @@
+var e=require("@hookform/resolvers"),r=require("effect"),t=require("effect/ParseResult"),o=require("react-hook-form");exports.effectTsResolver=function(n,a){return void 0===a&&(a={errors:"all",onExcessProperty:"ignore"}),function(s,f,i){return t.decodeUnknown(n,a)(s).pipe(r.Effect.catchAll(function(e){return r.Effect.flip(t.ArrayFormatter.formatIssue(e))}),r.Effect.mapError(function(r){var t=!i.shouldUseNativeValidation&&"all"===i.criteriaMode,n=r.reduce(function(e,r){var n=r.path.join(".");if(e[n]||(e[n]={message:r.message,type:r._tag}),t){var a=e[n].types,s=a&&a[String(r._tag)];e[n]=o.appendErrors(n,t,e,r._tag,s?[].concat(s,r.message):r.message)}return e},{});return e.toNestErrors(n,i)}),r.Effect.tap(function(){return r.Effect.sync(function(){return i.shouldUseNativeValidation&&e.validateFieldsNatively({},i)})}),r.Effect.match({onFailure:function(e){return{errors:e,values:{}}},onSuccess:function(e){return{errors:{},values:e}}}),r.Effect.runPromise)}};
+//# sourceMappingURL=effect-ts.js.map

node_modules/@hookform/resolvers/effect-ts/dist/effect-ts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-ts.js","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema } from 'effect';\nimport { ArrayFormatter, decodeUnknown } from 'effect/ParseResult';\nimport { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect.ts schema validation\n * @param {Schema.Schema<TFieldValues, I>} schema - The Effect.ts schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect.ts validation options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) => {\n    return decodeUnknown(\n      schema,\n      schemaOptions,\n    )(values).pipe(\n      Effect.catchAll((parseIssue) =>\n        Effect.flip(ArrayFormatter.formatIssue(parseIssue)),\n      ),\n      Effect.mapError((issues) => {\n        const validateAllFieldCriteria =\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n        const errors = issues.reduce(\n          (acc, error) => {\n            const key = error.path.join('.');\n\n            if (!acc[key]) {\n              acc[key] = { message: error.message, type: error._tag };\n            }\n\n            if (validateAllFieldCriteria) {\n              const types = acc[key].types;\n              const messages = types && types[String(error._tag)];\n\n              acc[key] = appendErrors(\n                key,\n                validateAllFieldCriteria,\n                acc,\n                error._tag,\n                messages\n                  ? ([] as string[]).concat(messages as string[], error.message)\n                  : error.message,\n              ) as FieldError;\n            }\n\n            return acc;\n          },\n          {} as Record<string, FieldError>,\n        );\n\n        return toNestErrors(errors, options);\n      }),\n      Effect.tap(() =>\n        Effect.sync(\n          () =>\n            options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options),\n        ),\n      ),\n      Effect.match({\n        onFailure: (errors) => ({ errors, values: {} }),\n        onSuccess: (result) => ({ errors: {}, values: result }),\n      }),\n      Effect.runPromise,\n    );\n  };\n}\n"],"names":["schema","schemaOptions","errors","onExcessProperty","values","_","options","decodeUnknown","pipe","Effect","catchAll","parseIssue","flip","ArrayFormatter","formatIssue","mapError","issues","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","error","key","path","join","message","type","_tag","types","messages","String","appendErrors","concat","toNestErrors","tap","sync","validateFieldsNatively","match","onFailure","onSuccess","result","runPromise"],"mappings":"+IA4CgB,SACdA,EACAC,GAEA,YAFAA,IAAAA,IAAAA,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,WAE1D,SAACC,EAAQC,EAAGC,GACjB,OAAOC,EAAaA,cAClBP,EACAC,EAFKM,CAGLH,GAAQI,KACRC,EAAMA,OAACC,SAAS,SAACC,GACf,OAAAF,SAAOG,KAAKC,EAAAA,eAAeC,YAAYH,GAAY,GAErDF,EAAAA,OAAOM,SAAS,SAACC,GACf,IAAMC,GACHX,EAAQY,2BAAsD,QAAzBZ,EAAQa,aAE1CjB,EAASc,EAAOI,OACpB,SAACC,EAAKC,GACJ,IAAMC,EAAMD,EAAME,KAAKC,KAAK,KAM5B,GAJKJ,EAAIE,KACPF,EAAIE,GAAO,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG/CX,EAA0B,CAC5B,IAAMY,EAAQR,EAAIE,GAAKM,MACjBC,EAAWD,GAASA,EAAME,OAAOT,EAAMM,OAE7CP,EAAIE,GAAOS,EAAYA,aACrBT,EACAN,EACAI,EACAC,EAAMM,KACNE,EACK,GAAgBG,OAAOH,EAAsBR,EAAMI,SACpDJ,EAAMI,QAEd,CAEA,OAAOL,CACT,EACA,CAAgC,GAGlC,OAAOa,eAAahC,EAAQI,EAC9B,GACAG,EAAAA,OAAO0B,IAAI,WAAA,OACT1B,EAAAA,OAAO2B,KACL,kBACE9B,EAAQY,2BACRmB,EAAsBA,uBAAC,GAAI/B,EAAQ,EACtC,GAEHG,EAAAA,OAAO6B,MAAM,CACXC,UAAW,SAACrC,GAAM,MAAM,CAAEA,OAAAA,EAAQE,OAAQ,GAAI,EAC9CoC,UAAW,SAACC,GAAY,MAAA,CAAEvC,OAAQ,CAAA,EAAIE,OAAQqC,EAAQ,IAExDhC,EAAAA,OAAOiC,WAEX,CACF"}

node_modules/@hookform/resolvers/effect-ts/dist/effect-ts.mjs

@@ -0,0 +1,2 @@
+import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{Effect as t}from"effect";import{decodeUnknown as o,ArrayFormatter as n}from"effect/ParseResult";import{appendErrors as a}from"react-hook-form";function i(i,s){return void 0===s&&(s={errors:"all",onExcessProperty:"ignore"}),function(u,c,f){return o(i,s)(u).pipe(t.catchAll(function(r){return t.flip(n.formatIssue(r))}),t.mapError(function(e){var t=!f.shouldUseNativeValidation&&"all"===f.criteriaMode,o=e.reduce(function(r,e){var o=e.path.join(".");if(r[o]||(r[o]={message:e.message,type:e._tag}),t){var n=r[o].types,i=n&&n[String(e._tag)];r[o]=a(o,t,r,e._tag,i?[].concat(i,e.message):e.message)}return r},{});return r(o,f)}),t.tap(function(){return t.sync(function(){return f.shouldUseNativeValidation&&e({},f)})}),t.match({onFailure:function(r){return{errors:r,values:{}}},onSuccess:function(r){return{errors:{},values:r}}}),t.runPromise)}}export{i as effectTsResolver};
+//# sourceMappingURL=effect-ts.module.js.map

node_modules/@hookform/resolvers/effect-ts/dist/effect-ts.modern.mjs

@@ -0,0 +1,2 @@
+import{toNestErrors as e,validateFieldsNatively as r}from"@hookform/resolvers";import{Effect as o}from"effect";import{decodeUnknown as t,ArrayFormatter as s}from"effect/ParseResult";import{appendErrors as a}from"react-hook-form";function i(i,n={errors:"all",onExcessProperty:"ignore"}){return(c,m,l)=>t(i,n)(c).pipe(o.catchAll(e=>o.flip(s.formatIssue(e))),o.mapError(r=>{const o=!l.shouldUseNativeValidation&&"all"===l.criteriaMode,t=r.reduce((e,r)=>{const t=r.path.join(".");if(e[t]||(e[t]={message:r.message,type:r._tag}),o){const s=e[t].types,i=s&&s[String(r._tag)];e[t]=a(t,o,e,r._tag,i?[].concat(i,r.message):r.message)}return e},{});return e(t,l)}),o.tap(()=>o.sync(()=>l.shouldUseNativeValidation&&r({},l))),o.match({onFailure:e=>({errors:e,values:{}}),onSuccess:e=>({errors:{},values:e})}),o.runPromise)}export{i as effectTsResolver};
+//# sourceMappingURL=effect-ts.modern.mjs.map

node_modules/@hookform/resolvers/effect-ts/dist/effect-ts.modern.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-ts.modern.mjs","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema } from 'effect';\nimport { ArrayFormatter, decodeUnknown } from 'effect/ParseResult';\nimport { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect.ts schema validation\n * @param {Schema.Schema<TFieldValues, I>} schema - The Effect.ts schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect.ts validation options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) => {\n    return decodeUnknown(\n      schema,\n      schemaOptions,\n    )(values).pipe(\n      Effect.catchAll((parseIssue) =>\n        Effect.flip(ArrayFormatter.formatIssue(parseIssue)),\n      ),\n      Effect.mapError((issues) => {\n        const validateAllFieldCriteria =\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n        const errors = issues.reduce(\n          (acc, error) => {\n            const key = error.path.join('.');\n\n            if (!acc[key]) {\n              acc[key] = { message: error.message, type: error._tag };\n            }\n\n            if (validateAllFieldCriteria) {\n              const types = acc[key].types;\n              const messages = types && types[String(error._tag)];\n\n              acc[key] = appendErrors(\n                key,\n                validateAllFieldCriteria,\n                acc,\n                error._tag,\n                messages\n                  ? ([] as string[]).concat(messages as string[], error.message)\n                  : error.message,\n              ) as FieldError;\n            }\n\n            return acc;\n          },\n          {} as Record<string, FieldError>,\n        );\n\n        return toNestErrors(errors, options);\n      }),\n      Effect.tap(() =>\n        Effect.sync(\n          () =>\n            options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options),\n        ),\n      ),\n      Effect.match({\n        onFailure: (errors) => ({ errors, values: {} }),\n        onSuccess: (result) => ({ errors: {}, values: result }),\n      }),\n      Effect.runPromise,\n    );\n  };\n}\n"],"names":["effectTsResolver","schema","schemaOptions","errors","onExcessProperty","values","_","options","decodeUnknown","pipe","Effect","catchAll","parseIssue","flip","ArrayFormatter","formatIssue","mapError","issues","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","error","key","path","join","message","type","_tag","types","messages","String","appendErrors","concat","toNestErrors","tap","sync","validateFieldsNatively","match","onFailure","onSuccess","result","runPromise"],"mappings":"8OA4CgBA,EACdC,EACAC,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,WAEjE,MAAO,CAACC,EAAQC,EAAGC,IACVC,EACLP,EACAC,EAFKM,CAGLH,GAAQI,KACRC,EAAOC,SAAUC,GACfF,EAAOG,KAAKC,EAAeC,YAAYH,KAEzCF,EAAOM,SAAUC,IACf,MAAMC,GACHX,EAAQY,2BAAsD,QAAzBZ,EAAQa,aAE1CjB,EAASc,EAAOI,OACpB,CAACC,EAAKC,KACJ,MAAMC,EAAMD,EAAME,KAAKC,KAAK,KAM5B,GAJKJ,EAAIE,KACPF,EAAIE,GAAO,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG/CX,EAA0B,CAC5B,MAAMY,EAAQR,EAAIE,GAAKM,MACjBC,EAAWD,GAASA,EAAME,OAAOT,EAAMM,OAE7CP,EAAIE,GAAOS,EACTT,EACAN,EACAI,EACAC,EAAMM,KACNE,EACK,GAAgBG,OAAOH,EAAsBR,EAAMI,SACpDJ,EAAMI,QAEd,CAEA,OAAOL,GAET,CAAgC,GAGlC,OAAOa,EAAahC,EAAQI,EAAO,GAErCG,EAAO0B,IAAI,IACT1B,EAAO2B,KACL,IACE9B,EAAQY,2BACRmB,EAAuB,CAAA,EAAI/B,KAGjCG,EAAO6B,MAAM,CACXC,UAAYrC,IAAY,CAAEA,SAAQE,OAAQ,KAC1CoC,UAAYC,IAAY,CAAEvC,OAAQ,CAAE,EAAEE,OAAQqC,MAEhDhC,EAAOiC,WAGb"}

node_modules/@hookform/resolvers/effect-ts/dist/effect-ts.module.js

@@ -0,0 +1,2 @@
+import{toNestErrors as r,validateFieldsNatively as e}from"@hookform/resolvers";import{Effect as t}from"effect";import{decodeUnknown as o,ArrayFormatter as n}from"effect/ParseResult";import{appendErrors as a}from"react-hook-form";function i(i,s){return void 0===s&&(s={errors:"all",onExcessProperty:"ignore"}),function(u,c,f){return o(i,s)(u).pipe(t.catchAll(function(r){return t.flip(n.formatIssue(r))}),t.mapError(function(e){var t=!f.shouldUseNativeValidation&&"all"===f.criteriaMode,o=e.reduce(function(r,e){var o=e.path.join(".");if(r[o]||(r[o]={message:e.message,type:e._tag}),t){var n=r[o].types,i=n&&n[String(e._tag)];r[o]=a(o,t,r,e._tag,i?[].concat(i,e.message):e.message)}return r},{});return r(o,f)}),t.tap(function(){return t.sync(function(){return f.shouldUseNativeValidation&&e({},f)})}),t.match({onFailure:function(r){return{errors:r,values:{}}},onSuccess:function(r){return{errors:{},values:r}}}),t.runPromise)}}export{i as effectTsResolver};
+//# sourceMappingURL=effect-ts.module.js.map

node_modules/@hookform/resolvers/effect-ts/dist/effect-ts.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-ts.module.js","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema } from 'effect';\nimport { ArrayFormatter, decodeUnknown } from 'effect/ParseResult';\nimport { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect.ts schema validation\n * @param {Schema.Schema<TFieldValues, I>} schema - The Effect.ts schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect.ts validation options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) => {\n    return decodeUnknown(\n      schema,\n      schemaOptions,\n    )(values).pipe(\n      Effect.catchAll((parseIssue) =>\n        Effect.flip(ArrayFormatter.formatIssue(parseIssue)),\n      ),\n      Effect.mapError((issues) => {\n        const validateAllFieldCriteria =\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n        const errors = issues.reduce(\n          (acc, error) => {\n            const key = error.path.join('.');\n\n            if (!acc[key]) {\n              acc[key] = { message: error.message, type: error._tag };\n            }\n\n            if (validateAllFieldCriteria) {\n              const types = acc[key].types;\n              const messages = types && types[String(error._tag)];\n\n              acc[key] = appendErrors(\n                key,\n                validateAllFieldCriteria,\n                acc,\n                error._tag,\n                messages\n                  ? ([] as string[]).concat(messages as string[], error.message)\n                  : error.message,\n              ) as FieldError;\n            }\n\n            return acc;\n          },\n          {} as Record<string, FieldError>,\n        );\n\n        return toNestErrors(errors, options);\n      }),\n      Effect.tap(() =>\n        Effect.sync(\n          () =>\n            options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options),\n        ),\n      ),\n      Effect.match({\n        onFailure: (errors) => ({ errors, values: {} }),\n        onSuccess: (result) => ({ errors: {}, values: result }),\n      }),\n      Effect.runPromise,\n    );\n  };\n}\n"],"names":["effectTsResolver","schema","schemaOptions","errors","onExcessProperty","values","_","options","decodeUnknown","pipe","Effect","catchAll","parseIssue","flip","ArrayFormatter","formatIssue","mapError","issues","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","error","key","path","join","message","type","_tag","types","messages","String","appendErrors","concat","toNestErrors","tap","sync","validateFieldsNatively","match","onFailure","onSuccess","result","runPromise"],"mappings":"qOA4CgB,SAAAA,EACdC,EACAC,GAEA,YAFAA,IAAAA,IAAAA,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,WAE1D,SAACC,EAAQC,EAAGC,GACjB,OAAOC,EACLP,EACAC,EAFKM,CAGLH,GAAQI,KACRC,EAAOC,SAAS,SAACC,GACf,OAAAF,EAAOG,KAAKC,EAAeC,YAAYH,GAAY,GAErDF,EAAOM,SAAS,SAACC,GACf,IAAMC,GACHX,EAAQY,2BAAsD,QAAzBZ,EAAQa,aAE1CjB,EAASc,EAAOI,OACpB,SAACC,EAAKC,GACJ,IAAMC,EAAMD,EAAME,KAAKC,KAAK,KAM5B,GAJKJ,EAAIE,KACPF,EAAIE,GAAO,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG/CX,EAA0B,CAC5B,IAAMY,EAAQR,EAAIE,GAAKM,MACjBC,EAAWD,GAASA,EAAME,OAAOT,EAAMM,OAE7CP,EAAIE,GAAOS,EACTT,EACAN,EACAI,EACAC,EAAMM,KACNE,EACK,GAAgBG,OAAOH,EAAsBR,EAAMI,SACpDJ,EAAMI,QAEd,CAEA,OAAOL,CACT,EACA,CAAgC,GAGlC,OAAOa,EAAahC,EAAQI,EAC9B,GACAG,EAAO0B,IAAI,WAAA,OACT1B,EAAO2B,KACL,kBACE9B,EAAQY,2BACRmB,EAAuB,GAAI/B,EAAQ,EACtC,GAEHG,EAAO6B,MAAM,CACXC,UAAW,SAACrC,GAAM,MAAM,CAAEA,OAAAA,EAAQE,OAAQ,GAAI,EAC9CoC,UAAW,SAACC,GAAY,MAAA,CAAEvC,OAAQ,CAAA,EAAIE,OAAQqC,EAAQ,IAExDhC,EAAOiC,WAEX,CACF"}

node_modules/@hookform/resolvers/effect-ts/dist/effect-ts.umd.js

@@ -0,0 +1,2 @@
+!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@hookform/resolvers"),require("effect"),require("effect/ParseResult"),require("react-hook-form")):"function"==typeof define&&define.amd?define(["exports","@hookform/resolvers","effect","effect/ParseResult","react-hook-form"],r):r((e||self).hookformResolversEffectTs={},e.hookformResolvers,e.Effect,e.EffectParseResult,e.ReactHookForm)}(this,function(e,r,t,o,f){e.effectTsResolver=function(e,n){return void 0===n&&(n={errors:"all",onExcessProperty:"ignore"}),function(s,a,i){return o.decodeUnknown(e,n)(s).pipe(t.Effect.catchAll(function(e){return t.Effect.flip(o.ArrayFormatter.formatIssue(e))}),t.Effect.mapError(function(e){var t=!i.shouldUseNativeValidation&&"all"===i.criteriaMode,o=e.reduce(function(e,r){var o=r.path.join(".");if(e[o]||(e[o]={message:r.message,type:r._tag}),t){var n=e[o].types,s=n&&n[String(r._tag)];e[o]=f.appendErrors(o,t,e,r._tag,s?[].concat(s,r.message):r.message)}return e},{});return r.toNestErrors(o,i)}),t.Effect.tap(function(){return t.Effect.sync(function(){return i.shouldUseNativeValidation&&r.validateFieldsNatively({},i)})}),t.Effect.match({onFailure:function(e){return{errors:e,values:{}}},onSuccess:function(e){return{errors:{},values:e}}}),t.Effect.runPromise)}}});
+//# sourceMappingURL=effect-ts.umd.js.map

node_modules/@hookform/resolvers/effect-ts/dist/effect-ts.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-ts.umd.js","sources":["../src/effect-ts.ts"],"sourcesContent":["import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';\nimport { Effect, Schema } from 'effect';\nimport { ArrayFormatter, decodeUnknown } from 'effect/ParseResult';\nimport { ParseOptions } from 'effect/SchemaAST';\nimport {\n  type FieldError,\n  FieldValues,\n  Resolver,\n  appendErrors,\n} from 'react-hook-form';\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions?: ParseOptions,\n  resolverOptions?: {\n    mode?: 'async' | 'sync';\n    raw?: false;\n  },\n): Resolver<Input, Context, Output>;\n\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions | undefined,\n  resolverOptions: {\n    mode?: 'async' | 'sync';\n    raw: true;\n  },\n): Resolver<Input, Context, Input>;\n\n/**\n * Creates a resolver for react-hook-form using Effect.ts schema validation\n * @param {Schema.Schema<TFieldValues, I>} schema - The Effect.ts schema to validate against\n * @param {ParseOptions} [schemaOptions] - Optional Effect.ts validation options\n * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form\n * @example\n * const schema = Schema.Struct({\n *   name: Schema.String,\n *   age: Schema.Number\n * });\n *\n * useForm({\n *   resolver: effectTsResolver(schema)\n * });\n */\nexport function effectTsResolver<Input extends FieldValues, Context, Output>(\n  schema: Schema.Schema<Output, Input>,\n  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },\n): Resolver<Input, Context, Output | Input> {\n  return (values, _, options) => {\n    return decodeUnknown(\n      schema,\n      schemaOptions,\n    )(values).pipe(\n      Effect.catchAll((parseIssue) =>\n        Effect.flip(ArrayFormatter.formatIssue(parseIssue)),\n      ),\n      Effect.mapError((issues) => {\n        const validateAllFieldCriteria =\n          !options.shouldUseNativeValidation && options.criteriaMode === 'all';\n\n        const errors = issues.reduce(\n          (acc, error) => {\n            const key = error.path.join('.');\n\n            if (!acc[key]) {\n              acc[key] = { message: error.message, type: error._tag };\n            }\n\n            if (validateAllFieldCriteria) {\n              const types = acc[key].types;\n              const messages = types && types[String(error._tag)];\n\n              acc[key] = appendErrors(\n                key,\n                validateAllFieldCriteria,\n                acc,\n                error._tag,\n                messages\n                  ? ([] as string[]).concat(messages as string[], error.message)\n                  : error.message,\n              ) as FieldError;\n            }\n\n            return acc;\n          },\n          {} as Record<string, FieldError>,\n        );\n\n        return toNestErrors(errors, options);\n      }),\n      Effect.tap(() =>\n        Effect.sync(\n          () =>\n            options.shouldUseNativeValidation &&\n            validateFieldsNatively({}, options),\n        ),\n      ),\n      Effect.match({\n        onFailure: (errors) => ({ errors, values: {} }),\n        onSuccess: (result) => ({ errors: {}, values: result }),\n      }),\n      Effect.runPromise,\n    );\n  };\n}\n"],"names":["schema","schemaOptions","errors","onExcessProperty","values","_","options","decodeUnknown","pipe","Effect","catchAll","parseIssue","flip","ArrayFormatter","formatIssue","mapError","issues","validateAllFieldCriteria","shouldUseNativeValidation","criteriaMode","reduce","acc","error","key","path","join","message","type","_tag","types","messages","String","appendErrors","concat","toNestErrors","tap","sync","validateFieldsNatively","match","onFailure","onSuccess","result","runPromise"],"mappings":"+fA4CgB,SACdA,EACAC,GAEA,YAFAA,IAAAA,IAAAA,EAA8B,CAAEC,OAAQ,MAAOC,iBAAkB,WAE1D,SAACC,EAAQC,EAAGC,GACjB,OAAOC,EAAaA,cAClBP,EACAC,EAFKM,CAGLH,GAAQI,KACRC,EAAMA,OAACC,SAAS,SAACC,GACf,OAAAF,SAAOG,KAAKC,EAAAA,eAAeC,YAAYH,GAAY,GAErDF,EAAAA,OAAOM,SAAS,SAACC,GACf,IAAMC,GACHX,EAAQY,2BAAsD,QAAzBZ,EAAQa,aAE1CjB,EAASc,EAAOI,OACpB,SAACC,EAAKC,GACJ,IAAMC,EAAMD,EAAME,KAAKC,KAAK,KAM5B,GAJKJ,EAAIE,KACPF,EAAIE,GAAO,CAAEG,QAASJ,EAAMI,QAASC,KAAML,EAAMM,OAG/CX,EAA0B,CAC5B,IAAMY,EAAQR,EAAIE,GAAKM,MACjBC,EAAWD,GAASA,EAAME,OAAOT,EAAMM,OAE7CP,EAAIE,GAAOS,EAAYA,aACrBT,EACAN,EACAI,EACAC,EAAMM,KACNE,EACK,GAAgBG,OAAOH,EAAsBR,EAAMI,SACpDJ,EAAMI,QAEd,CAEA,OAAOL,CACT,EACA,CAAgC,GAGlC,OAAOa,eAAahC,EAAQI,EAC9B,GACAG,EAAAA,OAAO0B,IAAI,WAAA,OACT1B,EAAAA,OAAO2B,KACL,kBACE9B,EAAQY,2BACRmB,EAAsBA,uBAAC,GAAI/B,EAAQ,EACtC,GAEHG,EAAAA,OAAO6B,MAAM,CACXC,UAAW,SAACrC,GAAM,MAAM,CAAEA,OAAAA,EAAQE,OAAQ,GAAI,EAC9CoC,UAAW,SAACC,GAAY,MAAA,CAAEvC,OAAQ,CAAA,EAAIE,OAAQqC,EAAQ,IAExDhC,EAAAA,OAAOiC,WAEX,CACF"}

node_modules/@hookform/resolvers/effect-ts/dist/index.d.ts

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

node_modules/@hookform/resolvers/effect-ts/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@hookform/resolvers/effect-ts",
+  "amdName": "hookformResolversEffectTs",
+  "version": "1.0.0",
+  "private": true,
+  "description": "React Hook Form validation resolver: effect-ts",
+  "main": "dist/effect-ts.js",
+  "module": "dist/effect-ts.module.js",
+  "umd:main": "dist/effect-ts.umd.js",
+  "source": "src/index.ts",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "peerDependencies": {
+    "@hookform/resolvers": "^2.0.0",
+    "effect": "^3.10.3",
+    "react-hook-form": "^7.55.0"
+  }
+}

node_modules/@hookform/resolvers/effect-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 { Schema } from 'effect';
+import React from 'react';
+import { useForm } from 'react-hook-form';
+import { effectTsResolver } from '..';
+
+const USERNAME_REQUIRED_MESSAGE = 'username field is required';
+const PASSWORD_REQUIRED_MESSAGE = 'password field is required';
+
+const schema = Schema.Struct({
+  username: Schema.String.pipe(
+    Schema.nonEmptyString({ message: () => USERNAME_REQUIRED_MESSAGE }),
+  ),
+  password: Schema.String.pipe(
+    Schema.nonEmptyString({ message: () => PASSWORD_REQUIRED_MESSAGE }),
+  ),
+});
+
+interface FormData {
+  username: string;
+  password: string;
+}
+
+interface Props {
+  onSubmit: (data: FormData) => void;
+}
+
+function TestComponent({ onSubmit }: Props) {
+  const { register, handleSubmit } = useForm<FormData>({
+    resolver: effectTsResolver(schema),
+    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 effect-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('');
+});

node_modules/@hookform/resolvers/effect-ts/src/__tests__/Form.tsx

@@ -0,0 +1,85 @@
+import { render, screen } from '@testing-library/react';
+import user from '@testing-library/user-event';
+import { Schema } from 'effect';
+import React from 'react';
+import { useForm } from 'react-hook-form';
+import { effectTsResolver } from '..';
+
+const USERNAME_REQUIRED_MESSAGE = 'username field is required';
+const PASSWORD_REQUIRED_MESSAGE = 'password field is required';
+
+const schema = Schema.Struct({
+  username: Schema.String.pipe(
+    Schema.nonEmptyString({ message: () => USERNAME_REQUIRED_MESSAGE }),
+  ),
+  password: Schema.String.pipe(
+    Schema.nonEmptyString({ message: () => PASSWORD_REQUIRED_MESSAGE }),
+  ),
+});
+
+type FormData = Schema.Schema.Type<typeof schema>;
+
+function TestComponent({
+  onSubmit,
+}: {
+  onSubmit: (data: FormData) => void;
+}) {
+  const {
+    register,
+    handleSubmit,
+    formState: { errors },
+  } = useForm({
+    resolver: effectTsResolver(schema),
+  });
+
+  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 Zod 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 field is required/i)).toBeInTheDocument();
+  expect(screen.getByText(/password field is required/i)).toBeInTheDocument();
+  expect(handleSubmit).not.toHaveBeenCalled();
+});
+
+export function TestComponentManualType({
+  onSubmit,
+}: {
+  onSubmit: (data: FormData) => void;
+}) {
+  const {
+    register,
+    handleSubmit,
+    formState: { errors },
+  } = useForm<Schema.Schema.Type<typeof schema>, undefined, FormData>({
+    resolver: effectTsResolver(schema), // 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>
+  );
+}

node_modules/@hookform/resolvers/effect-ts/src/__tests__/__fixtures__/data.ts

@@ -0,0 +1,124 @@
+import { Schema } from 'effect';
+import { Field, InternalFieldName } from 'react-hook-form';
+
+export const schema = Schema.Struct({
+  username: Schema.String.pipe(
+    Schema.nonEmptyString({ message: () => 'A username is required' }),
+  ),
+  password: Schema.String.pipe(
+    Schema.pattern(new RegExp('.*[A-Z].*'), {
+      message: () => 'At least 1 uppercase letter.',
+    }),
+    Schema.pattern(new RegExp('.*[a-z].*'), {
+      message: () => 'At least 1 lowercase letter.',
+    }),
+    Schema.pattern(new RegExp('.*\\d.*'), {
+      message: () => 'At least 1 number.',
+    }),
+    Schema.pattern(
+      new RegExp('.*[`~<>?,./!@#$%^&*()\\-_+="\'|{}\\[\\];:\\\\].*'),
+      {
+        message: () => 'At least 1 special character.',
+      },
+    ),
+    Schema.minLength(8, { message: () => 'Must be at least 8 characters.' }),
+  ),
+  accessToken: Schema.Union(Schema.String, Schema.Number),
+  birthYear: Schema.Number.pipe(
+    Schema.greaterThan(1900, {
+      message: () => 'Must be greater than the year 1900',
+    }),
+    Schema.filter((value) => value < new Date().getFullYear(), {
+      message: () => 'Must be before the current year.',
+    }),
+  ),
+  email: Schema.String.pipe(
+    Schema.pattern(
+      new RegExp(
+        /^(?!\.)(?!.*\.\.)([A-Z0-9_+-.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9-]*\.)+[A-Z]{2,}$/i,
+      ),
+      {
+        message: () => 'A valid email address is required.',
+      },
+    ),
+  ),
+  tags: Schema.Array(
+    Schema.Struct({
+      name: Schema.String,
+    }),
+  ),
+  luckyNumbers: Schema.Array(Schema.Number),
+  enabled: Schema.Boolean,
+  animal: Schema.Union(Schema.String, Schema.Literal('bird', 'snake')),
+  vehicles: Schema.Array(
+    Schema.Union(
+      Schema.Struct({
+        type: Schema.Literal('car'),
+        brand: Schema.String,
+        horsepower: Schema.Number,
+      }),
+      Schema.Struct({
+        type: Schema.Literal('bike'),
+        speed: Schema.Number,
+      }),
+    ),
+  ),
+});
+
+export const validData: Schema.Schema.Type<typeof schema> = {
+  accessToken: 'abcd1234',
+  animal: 'dog',
+  birthYear: 2000,
+  email: 'johnDoe@here.there',
+  enabled: true,
+  luckyNumbers: [1, 2, 3, 4, 5],
+  password: 'Super#Secret123',
+  tags: [{ name: 'move' }, { name: 'over' }, { name: 'zod' }, { name: ';)' }],
+  username: 'johnDoe',
+  vehicles: [
+    { type: 'bike', speed: 5 },
+    { type: 'car', brand: 'BMW', horsepower: 150 },
+  ],
+};
+
+export const invalidData = {
+  username: 'test',
+  password: 'Password123',
+  repeatPassword: 'Password123',
+  birthYear: 2000,
+  accessToken: '1015d809-e99d-41ec-b161-981a3c243df8',
+  email: 'john@doe.com',
+  tags: [{ name: 'test' }],
+  enabled: true,
+  animal: ['dog'],
+  luckyNumbers: [1, 2, '3'],
+  like: [
+    {
+      id: '1',
+      name: 'name',
+    },
+  ],
+  vehicles: [
+    { type: 'car', brand: 'BMW', horsepower: 150 },
+    { type: 'car', brand: 'Mercedes' },
+  ],
+} as any as Schema.Schema.Type<typeof 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',
+  },
+};

node_modules/@hookform/resolvers/effect-ts/src/__tests__/__snapshots__/effect-ts.ts.snap

@@ -0,0 +1,74 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`effectTsResolver > should return a single error from effectTsResolver when validation fails 1`] = `
+{
+  "errors": {
+    "animal": {
+      "message": "Expected string, actual ["dog"]",
+      "ref": undefined,
+      "type": "Type",
+    },
+    "luckyNumbers": [
+      ,
+      ,
+      {
+        "message": "Expected number, actual "3"",
+        "ref": undefined,
+        "type": "Type",
+      },
+    ],
+    "password": {
+      "message": "At least 1 special character.",
+      "ref": {
+        "name": "password",
+      },
+      "type": "Refinement",
+    },
+    "vehicles": [
+      ,
+      {
+        "horsepower": {
+          "message": "is missing",
+          "ref": undefined,
+          "type": "Missing",
+        },
+      },
+    ],
+  },
+  "values": {},
+}
+`;
+
+exports[`effectTsResolver > should return all the errors from effectTsResolver when validation fails with \`validateAllFieldCriteria\` set to true 1`] = `
+{
+  "errors": {
+    "phoneNumber": {
+      "message": "Please enter a valid phone number in international format.",
+      "ref": {
+        "name": "phoneNumber",
+      },
+      "type": "Refinement",
+      "types": {
+        "Refinement": "Please enter a valid phone number in international format.",
+        "Type": "Expected undefined, actual "123"",
+      },
+    },
+  },
+  "values": {},
+}
+`;
+
+exports[`effectTsResolver > should return the first error from effectTsResolver when validation fails with \`validateAllFieldCriteria\` set to firstError 1`] = `
+{
+  "errors": {
+    "phoneNumber": {
+      "message": "Please enter a valid phone number in international format.",
+      "ref": {
+        "name": "phoneNumber",
+      },
+      "type": "Refinement",
+    },
+  },
+  "values": {},
+}
+`;

node_modules/@hookform/resolvers/effect-ts/src/__tests__/effect-ts.ts

@@ -0,0 +1,146 @@
+import { Schema } from 'effect';
+import { Resolver, useForm } from 'react-hook-form';
+import { SubmitHandler } from 'react-hook-form';
+import { effectTsResolver } from '..';
+import { fields, invalidData, schema, validData } from './__fixtures__/data';
+
+const shouldUseNativeValidation = false;
+
+describe('effectTsResolver', () => {
+  it('should return values from effectTsResolver when validation pass', async () => {
+    const result = await effectTsResolver(schema)(validData, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(result).toEqual({ errors: {}, values: validData });
+  });
+
+  it('should return a single error from effectTsResolver when validation fails', async () => {
+    const result = await effectTsResolver(schema)(invalidData, undefined, {
+      fields,
+      shouldUseNativeValidation,
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return the first error from effectTsResolver when validation fails with `validateAllFieldCriteria` set to firstError', async () => {
+    const SignupSchema = Schema.Struct({
+      phoneNumber: Schema.optional(
+        Schema.String.pipe(
+          Schema.pattern(/^\+\d{7,15}$/, {
+            message: () =>
+              'Please enter a valid phone number in international format.',
+          }),
+        ),
+      ),
+    });
+
+    const result = await effectTsResolver(SignupSchema)(
+      { phoneNumber: '123' },
+      undefined,
+      {
+        fields: {
+          phoneNumber: {
+            ref: { name: 'phoneNumber' },
+            name: 'phoneNumber',
+          },
+        },
+        criteriaMode: 'firstError',
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(result).toMatchSnapshot();
+  });
+
+  it('should return all the errors from effectTsResolver when validation fails with `validateAllFieldCriteria` set to true', async () => {
+    const SignupSchema = Schema.Struct({
+      phoneNumber: Schema.optional(
+        Schema.String.pipe(
+          Schema.pattern(/^\+\d{7,15}$/, {
+            message: () =>
+              'Please enter a valid phone number in international format.',
+          }),
+        ),
+      ),
+    });
+
+    const result = await effectTsResolver(SignupSchema)(
+      { phoneNumber: '123' },
+      undefined,
+      {
+        fields: {
+          phoneNumber: {
+            ref: { name: 'phoneNumber' },
+            name: 'phoneNumber',
+          },
+        },
+        criteriaMode: 'all',
+        shouldUseNativeValidation,
+      },
+    );
+
+    expect(result).toMatchSnapshot();
+  });
+
+  /**
+   * Type inference tests
+   */
+  it('should correctly infer the output type from a effectTs schema', () => {
+    const resolver = effectTsResolver(Schema.Struct({ id: Schema.Number }));
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<Readonly<{ id: number }>, unknown, Readonly<{ id: number }>>
+    >();
+  });
+
+  it('should correctly infer the output type from a effectTs schema using a transform', () => {
+    const resolver = effectTsResolver(
+      Schema.Struct({
+        id: Schema.transform(Schema.Number, Schema.String, {
+          decode: (val) => String(val),
+          encode: (val) => Number(val),
+        }),
+      }),
+    );
+
+    expectTypeOf(resolver).toEqualTypeOf<
+      Resolver<Readonly<{ id: number }>, unknown, Readonly<{ id: string }>>
+    >();
+  });
+
+  it('should correctly infer the output type from a effectTs schema for the handleSubmit function in useForm', () => {
+    const schema = Schema.Struct({ id: Schema.Number });
+
+    const form = useForm({
+      resolver: effectTsResolver(schema),
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit)
+      .parameter(0)
+      .toEqualTypeOf<SubmitHandler<Readonly<{ id: number }>>>();
+  });
+
+  it('should correctly infer the output type from a effectTs schema with a transform for the handleSubmit function in useForm', () => {
+    const schema = Schema.Struct({
+      id: Schema.transform(Schema.Number, Schema.String, {
+        decode: (val) => String(val),
+        encode: (val) => Number(val),
+      }),
+    });
+
+    const form = useForm({
+      resolver: effectTsResolver(schema),
+    });
+
+    expectTypeOf(form.watch('id')).toEqualTypeOf<number>();
+
+    expectTypeOf(form.handleSubmit)
+      .parameter(0)
+      .toEqualTypeOf<SubmitHandler<Readonly<{ id: string }>>>();
+  });
+});

node_modules/@hookform/resolvers/effect-ts/src/effect-ts.ts

@@ -0,0 +1,105 @@
+import { toNestErrors, validateFieldsNatively } from '@hookform/resolvers';
+import { Effect, Schema } from 'effect';
+import { ArrayFormatter, decodeUnknown } from 'effect/ParseResult';
+import { ParseOptions } from 'effect/SchemaAST';
+import {
+  type FieldError,
+  FieldValues,
+  Resolver,
+  appendErrors,
+} from 'react-hook-form';
+
+export function effectTsResolver<Input extends FieldValues, Context, Output>(
+  schema: Schema.Schema<Output, Input>,
+  schemaOptions?: ParseOptions,
+  resolverOptions?: {
+    mode?: 'async' | 'sync';
+    raw?: false;
+  },
+): Resolver<Input, Context, Output>;
+
+export function effectTsResolver<Input extends FieldValues, Context, Output>(
+  schema: Schema.Schema<Output, Input>,
+  schemaOptions: ParseOptions | undefined,
+  resolverOptions: {
+    mode?: 'async' | 'sync';
+    raw: true;
+  },
+): Resolver<Input, Context, Input>;
+
+/**
+ * Creates a resolver for react-hook-form using Effect.ts schema validation
+ * @param {Schema.Schema<TFieldValues, I>} schema - The Effect.ts schema to validate against
+ * @param {ParseOptions} [schemaOptions] - Optional Effect.ts validation options
+ * @returns {Resolver<Schema.Schema.Type<typeof schema>>} A resolver function compatible with react-hook-form
+ * @example
+ * const schema = Schema.Struct({
+ *   name: Schema.String,
+ *   age: Schema.Number
+ * });
+ *
+ * useForm({
+ *   resolver: effectTsResolver(schema)
+ * });
+ */
+export function effectTsResolver<Input extends FieldValues, Context, Output>(
+  schema: Schema.Schema<Output, Input>,
+  schemaOptions: ParseOptions = { errors: 'all', onExcessProperty: 'ignore' },
+): Resolver<Input, Context, Output | Input> {
+  return (values, _, options) => {
+    return decodeUnknown(
+      schema,
+      schemaOptions,
+    )(values).pipe(
+      Effect.catchAll((parseIssue) =>
+        Effect.flip(ArrayFormatter.formatIssue(parseIssue)),
+      ),
+      Effect.mapError((issues) => {
+        const validateAllFieldCriteria =
+          !options.shouldUseNativeValidation && options.criteriaMode === 'all';
+
+        const errors = issues.reduce(
+          (acc, error) => {
+            const key = error.path.join('.');
+
+            if (!acc[key]) {
+              acc[key] = { message: error.message, type: error._tag };
+            }
+
+            if (validateAllFieldCriteria) {
+              const types = acc[key].types;
+              const messages = types && types[String(error._tag)];
+
+              acc[key] = appendErrors(
+                key,
+                validateAllFieldCriteria,
+                acc,
+                error._tag,
+                messages
+                  ? ([] as string[]).concat(messages as string[], error.message)
+                  : error.message,
+              ) as FieldError;
+            }
+
+            return acc;
+          },
+          {} as Record<string, FieldError>,
+        );
+
+        return toNestErrors(errors, options);
+      }),
+      Effect.tap(() =>
+        Effect.sync(
+          () =>
+            options.shouldUseNativeValidation &&
+            validateFieldsNatively({}, options),
+        ),
+      ),
+      Effect.match({
+        onFailure: (errors) => ({ errors, values: {} }),
+        onSuccess: (result) => ({ errors: {}, values: result }),
+      }),
+      Effect.runPromise,
+    );
+  };
+}

node_modules/@hookform/resolvers/effect-ts/src/index.ts

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