build revisions and layout updates for toast

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,
+    );
+  };
+}