@lucas-barake/effect-form 0.15.0 → 0.16.0

package/src/Field.ts

@@ -1,29 +1,29 @@
-import * as Schema from "effect/Schema"
+import * as Schema from "effect/Schema";
 
-export const TypeId: unique symbol = Symbol.for("@lucas-barake/effect-form/Field")
+export const TypeId: unique symbol = Symbol.for("@lucas-barake/effect-form/Field");
 
-export type TypeId = typeof TypeId
+export type TypeId = typeof TypeId;
 
 export interface FieldDef<K extends string, S extends Schema.Schema.Any> {
-  readonly _tag: "field"
-  readonly key: K
-  readonly schema: S
+  readonly _tag: "field";
+  readonly key: K;
+  readonly schema: S;
 }
 
 export interface ArrayFieldDef<K extends string, S extends Schema.Schema.Any> {
-  readonly _tag: "array"
-  readonly key: K
-  readonly itemSchema: S
+  readonly _tag: "array";
+  readonly key: K;
+  readonly itemSchema: S;
 }
 
-export type AnyFieldDef = FieldDef<string, Schema.Schema.Any> | ArrayFieldDef<string, Schema.Schema.Any>
+export type AnyFieldDef = FieldDef<string, Schema.Schema.Any> | ArrayFieldDef<string, Schema.Schema.Any>;
 
-export type FieldsRecord = Record<string, AnyFieldDef>
+export type FieldsRecord = Record<string, AnyFieldDef>;
 
 export const isArrayFieldDef = (def: AnyFieldDef): def is ArrayFieldDef<string, Schema.Schema.Any> =>
-  def._tag === "array"
+  def._tag === "array";
 
-export const isFieldDef = (def: AnyFieldDef): def is FieldDef<string, Schema.Schema.Any> => def._tag === "field"
+export const isFieldDef = (def: AnyFieldDef): def is FieldDef<string, Schema.Schema.Any> => def._tag === "field";
 
 export const makeField = <K extends string, S extends Schema.Schema.Any>(
   key: K,
@@ -32,7 +32,7 @@ export const makeField = <K extends string, S extends Schema.Schema.Any>(
   _tag: "field",
   key,
   schema,
-})
+});
 
 export const makeArrayField = <K extends string, S extends Schema.Schema.Any>(
   key: K,
@@ -41,64 +41,64 @@ export const makeArrayField = <K extends string, S extends Schema.Schema.Any>(
   _tag: "array",
   key,
   itemSchema,
-})
+});
 
 export type EncodedFromFields<T extends FieldsRecord> = {
   readonly [K in keyof T]: T[K] extends FieldDef<any, infer S> ? Schema.Schema.Encoded<S>
     : T[K] extends ArrayFieldDef<any, infer S> ? ReadonlyArray<Schema.Schema.Encoded<S>>
-    : never
-}
+    : never;
+};
 
 export type DecodedFromFields<T extends FieldsRecord> = {
   readonly [K in keyof T]: T[K] extends FieldDef<any, infer S> ? Schema.Schema.Type<S>
     : T[K] extends ArrayFieldDef<any, infer S> ? ReadonlyArray<Schema.Schema.Type<S>>
-    : never
-}
+    : never;
+};
 
 export const getDefaultFromSchema = (schema: Schema.Schema.Any): unknown => {
-  const ast = schema.ast
+  const ast = schema.ast;
   switch (ast._tag) {
     case "StringKeyword":
     case "TemplateLiteral":
-      return ""
+      return "";
     case "NumberKeyword":
-      return 0
+      return 0;
     case "BooleanKeyword":
-      return false
+      return false;
     case "TypeLiteral": {
-      const result: Record<string, unknown> = {}
+      const result: Record<string, unknown> = {};
       for (const prop of ast.propertySignatures) {
-        result[prop.name as string] = getDefaultFromSchema(Schema.make(prop.type))
+        result[prop.name as string] = getDefaultFromSchema(Schema.make(prop.type));
       }
-      return result
+      return result;
     }
     case "Transformation":
-      return getDefaultFromSchema(Schema.make(ast.from))
+      return getDefaultFromSchema(Schema.make(ast.from));
     case "Refinement":
-      return getDefaultFromSchema(Schema.make(ast.from))
+      return getDefaultFromSchema(Schema.make(ast.from));
     case "Suspend":
-      return getDefaultFromSchema(Schema.make(ast.f()))
+      return getDefaultFromSchema(Schema.make(ast.f()));
     default:
-      return ""
+      return "";
   }
-}
+};
 
 export const getDefaultEncodedValues = (fields: FieldsRecord): Record<string, unknown> => {
-  const result: Record<string, unknown> = {}
+  const result: Record<string, unknown> = {};
   for (const [key, def] of Object.entries(fields)) {
     if (isArrayFieldDef(def)) {
-      result[key] = []
+      result[key] = [];
     } else {
-      result[key] = ""
+      result[key] = "";
     }
   }
-  return result
-}
+  return result;
+};
 
 export const createTouchedRecord = (fields: FieldsRecord, value: boolean): Record<string, boolean> => {
-  const result: Record<string, boolean> = {}
+  const result: Record<string, boolean> = {};
   for (const key of Object.keys(fields)) {
-    result[key] = value
+    result[key] = value;
   }
-  return result
-}
+  return result;
+};

package/src/FormAtoms.ts

@@ -81,6 +81,7 @@ export interface FormAtoms<TFields extends Field.FieldsRecord, R, A = void, E =
   readonly setValue: <S>(field: FormBuilder.FieldRef<S>) => Atom.Writable<void, S | ((prev: S) => S)>;
 
   readonly getFieldAtom: <S>(field: FormBuilder.FieldRef<S>) => Atom.Atom<Option.Option<S>>;
+  readonly getFieldIsDirty: (field: FormBuilder.FieldRef<any>) => Atom.Atom<boolean>;
 
   /**
    * Root anchor atom for the form's dependency graph.
@@ -550,6 +551,9 @@ export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = v
     return safeAtom;
   };
 
+  const getFieldIsDirty = (field: FormBuilder.FieldRef<any>): Atom.Atom<boolean> =>
+    getOrCreateFieldAtoms(field.key).isDirtyAtom;
+
   const mountAtom = Atom.readable((get) => {
     get(stateAtom);
     get(errorsAtom);
@@ -583,6 +587,7 @@ export const make = <TFields extends Field.FieldsRecord, R, A, E, SubmitArgs = v
     setValuesAtom,
     setValue,
     getFieldAtom,
+    getFieldIsDirty,
     mountAtom,
     keepAliveActiveAtom,
   } as FormAtoms<TFields, R, A, E, SubmitArgs>;

package/src/FormBuilder.ts

@@ -1,8 +1,8 @@
-import type * as Registry from "@effect-atom/atom/Registry"
-import type * as Effect from "effect/Effect"
-import type * as Option from "effect/Option"
-import * as Predicate from "effect/Predicate"
-import * as Schema from "effect/Schema"
+import type * as Registry from "@effect-atom/atom/Registry";
+import type * as Effect from "effect/Effect";
+import type * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
 
 import type {
   AnyFieldDef,
@@ -11,91 +11,91 @@ import type {
   EncodedFromFields,
   FieldDef,
   FieldsRecord,
-} from "./Field.js"
-import { isArrayFieldDef, isFieldDef, makeField } from "./Field.js"
+} from "./Field.js";
+import { isArrayFieldDef, isFieldDef, makeField } from "./Field.js";
 
 export interface SubmittedValues<TFields extends FieldsRecord> {
-  readonly encoded: EncodedFromFields<TFields>
-  readonly decoded: DecodedFromFields<TFields>
+  readonly encoded: EncodedFromFields<TFields>;
+  readonly decoded: DecodedFromFields<TFields>;
 }
 
-export const FieldTypeId: unique symbol = Symbol.for("@lucas-barake/effect-form/Field")
+export const FieldTypeId: unique symbol = Symbol.for("@lucas-barake/effect-form/Field");
 
-export type FieldTypeId = typeof FieldTypeId
+export type FieldTypeId = typeof FieldTypeId;
 
 export interface FieldRef<S> {
-  readonly [FieldTypeId]: FieldTypeId
-  readonly _S: S
-  readonly key: string
+  readonly [FieldTypeId]: FieldTypeId;
+  readonly _S: S;
+  readonly key: string;
 }
 
 export const makeFieldRef = <S>(key: string): FieldRef<S> => ({
   [FieldTypeId]: FieldTypeId,
   _S: undefined as any,
   key,
-})
+});
 
-export const TypeId: unique symbol = Symbol.for("@lucas-barake/effect-form/Form")
+export const TypeId: unique symbol = Symbol.for("@lucas-barake/effect-form/Form");
 
-export type TypeId = typeof TypeId
+export type TypeId = typeof TypeId;
 
 export interface FormState<TFields extends FieldsRecord> {
-  readonly values: EncodedFromFields<TFields>
-  readonly initialValues: EncodedFromFields<TFields>
-  readonly lastSubmittedValues: Option.Option<SubmittedValues<TFields>>
-  readonly touched: { readonly [K in keyof TFields]: boolean }
-  readonly submitCount: number
-  readonly dirtyFields: ReadonlySet<string>
+  readonly values: EncodedFromFields<TFields>;
+  readonly initialValues: EncodedFromFields<TFields>;
+  readonly lastSubmittedValues: Option.Option<SubmittedValues<TFields>>;
+  readonly touched: { readonly [K in keyof TFields]: boolean; };
+  readonly submitCount: number;
+  readonly dirtyFields: ReadonlySet<string>;
 }
 
 interface SyncRefinement {
-  readonly _tag: "sync"
-  readonly fn: (values: unknown) => Schema.FilterOutput
+  readonly _tag: "sync";
+  readonly fn: (values: unknown) => Schema.FilterOutput;
 }
 
 interface AsyncRefinement {
-  readonly _tag: "async"
-  readonly fn: (values: unknown) => Effect.Effect<Schema.FilterOutput, never, unknown>
+  readonly _tag: "async";
+  readonly fn: (values: unknown) => Effect.Effect<Schema.FilterOutput, never, unknown>;
 }
 
-type Refinement = SyncRefinement | AsyncRefinement
+type Refinement = SyncRefinement | AsyncRefinement;
 
 export interface FormBuilder<TFields extends FieldsRecord, R> {
-  readonly [TypeId]: TypeId
-  readonly fields: TFields
-  readonly refinements: ReadonlyArray<Refinement>
-  readonly _R?: R
+  readonly [TypeId]: TypeId;
+  readonly fields: TFields;
+  readonly refinements: ReadonlyArray<Refinement>;
+  readonly _R?: R;
 
   addField<K extends string, S extends Schema.Schema.Any>(
     this: FormBuilder<TFields, R>,
     field: FieldDef<K, S>,
-  ): FormBuilder<TFields & { readonly [key in K]: FieldDef<K, S> }, R | Schema.Schema.Context<S>>
+  ): FormBuilder<TFields & { readonly [key in K]: FieldDef<K, S>; }, R | Schema.Schema.Context<S>>;
 
   addField<K extends string, S extends Schema.Schema.Any>(
     this: FormBuilder<TFields, R>,
     field: ArrayFieldDef<K, S>,
-  ): FormBuilder<TFields & { readonly [key in K]: ArrayFieldDef<K, S> }, R | Schema.Schema.Context<S>>
+  ): FormBuilder<TFields & { readonly [key in K]: ArrayFieldDef<K, S>; }, R | Schema.Schema.Context<S>>;
 
   addField<K extends string, S extends Schema.Schema.Any>(
     this: FormBuilder<TFields, R>,
     key: K,
     schema: S,
-  ): FormBuilder<TFields & { readonly [key in K]: FieldDef<K, S> }, R | Schema.Schema.Context<S>>
+  ): FormBuilder<TFields & { readonly [key in K]: FieldDef<K, S>; }, R | Schema.Schema.Context<S>>;
 
   merge<TFields2 extends FieldsRecord, R2>(
     this: FormBuilder<TFields, R>,
     other: FormBuilder<TFields2, R2>,
-  ): FormBuilder<TFields & TFields2, R | R2>
+  ): FormBuilder<TFields & TFields2, R | R2>;
 
   refine(
     this: FormBuilder<TFields, R>,
     predicate: (values: DecodedFromFields<TFields>) => Schema.FilterOutput,
-  ): FormBuilder<TFields, R>
+  ): FormBuilder<TFields, R>;
 
   refineEffect<RD>(
     this: FormBuilder<TFields, R>,
     predicate: (values: DecodedFromFields<TFields>) => Effect.Effect<Schema.FilterOutput, never, RD>,
-  ): FormBuilder<TFields, R | Exclude<RD, Registry.AtomRegistry>>
+  ): FormBuilder<TFields, R | Exclude<RD, Registry.AtomRegistry>>;
 }
 
 const FormBuilderProto = {
@@ -107,76 +107,76 @@ const FormBuilderProto = {
   ): FormBuilder<any, any> {
     const field = typeof keyOrField === "string"
       ? makeField(keyOrField, schema!)
-      : keyOrField
-    const newSelf = Object.create(FormBuilderProto)
-    newSelf.fields = { ...this.fields, [field.key]: field }
-    newSelf.refinements = this.refinements
-    return newSelf
+      : keyOrField;
+    const newSelf = Object.create(FormBuilderProto);
+    newSelf.fields = { ...this.fields, [field.key]: field };
+    newSelf.refinements = this.refinements;
+    return newSelf;
   },
   merge<TFields extends FieldsRecord, R, TFields2 extends FieldsRecord, R2>(
     this: FormBuilder<TFields, R>,
     other: FormBuilder<TFields2, R2>,
   ): FormBuilder<TFields & TFields2, R | R2> {
-    const newSelf = Object.create(FormBuilderProto)
-    newSelf.fields = { ...this.fields, ...other.fields }
-    newSelf.refinements = [...this.refinements, ...other.refinements]
-    return newSelf
+    const newSelf = Object.create(FormBuilderProto);
+    newSelf.fields = { ...this.fields, ...other.fields };
+    newSelf.refinements = [...this.refinements, ...other.refinements];
+    return newSelf;
   },
   refine<TFields extends FieldsRecord, R>(
     this: FormBuilder<TFields, R>,
     predicate: (values: DecodedFromFields<TFields>) => Schema.FilterOutput,
   ): FormBuilder<TFields, R> {
-    const newSelf = Object.create(FormBuilderProto)
-    newSelf.fields = this.fields
+    const newSelf = Object.create(FormBuilderProto);
+    newSelf.fields = this.fields;
     newSelf.refinements = [
       ...this.refinements,
       { _tag: "sync" as const, fn: (values: unknown) => predicate(values as DecodedFromFields<TFields>) },
-    ]
-    return newSelf
+    ];
+    return newSelf;
   },
   refineEffect<TFields extends FieldsRecord, R, RD>(
     this: FormBuilder<TFields, R>,
     predicate: (values: DecodedFromFields<TFields>) => Effect.Effect<Schema.FilterOutput, never, RD>,
   ): FormBuilder<TFields, R | Exclude<RD, Registry.AtomRegistry>> {
-    const newSelf = Object.create(FormBuilderProto)
-    newSelf.fields = this.fields
+    const newSelf = Object.create(FormBuilderProto);
+    newSelf.fields = this.fields;
     newSelf.refinements = [
       ...this.refinements,
       { _tag: "async" as const, fn: (values: unknown) => predicate(values as DecodedFromFields<TFields>) },
-    ]
-    return newSelf
+    ];
+    return newSelf;
   },
-}
+};
 
-export const isFormBuilder = (u: unknown): u is FormBuilder<any, any> => Predicate.hasProperty(u, TypeId)
+export const isFormBuilder = (u: unknown): u is FormBuilder<any, any> => Predicate.hasProperty(u, TypeId);
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export const empty: FormBuilder<{}, never> = (() => {
-  const self = Object.create(FormBuilderProto)
-  self.fields = {}
-  self.refinements = []
-  return self
-})()
+  const self = Object.create(FormBuilderProto);
+  self.fields = {};
+  self.refinements = [];
+  return self;
+})();
 
 export const buildSchema = <TFields extends FieldsRecord, R>(
   self: FormBuilder<TFields, R>,
 ): Schema.Schema<DecodedFromFields<TFields>, EncodedFromFields<TFields>, R> => {
-  const schemaFields: Record<string, Schema.Schema.Any> = {}
+  const schemaFields: Record<string, Schema.Schema.Any> = {};
   for (const [key, def] of Object.entries(self.fields)) {
     if (isArrayFieldDef(def)) {
-      schemaFields[key] = Schema.Array(def.itemSchema)
+      schemaFields[key] = Schema.Array(def.itemSchema);
     } else if (isFieldDef(def)) {
-      schemaFields[key] = def.schema
+      schemaFields[key] = def.schema;
     }
   }
 
-  let schema: Schema.Schema<any, any, any> = Schema.Struct(schemaFields)
+  let schema: Schema.Schema<any, any, any> = Schema.Struct(schemaFields);
 
   for (const refinement of self.refinements) {
     if (refinement._tag === "sync") {
-      schema = schema.pipe(Schema.filter(refinement.fn))
+      schema = schema.pipe(Schema.filter(refinement.fn));
     } else {
-      schema = schema.pipe(Schema.filterEffect(refinement.fn))
+      schema = schema.pipe(Schema.filterEffect(refinement.fn));
     }
   }
 
@@ -184,5 +184,5 @@ export const buildSchema = <TFields extends FieldsRecord, R>(
     DecodedFromFields<TFields>,
     EncodedFromFields<TFields>,
     R
-  >
-}
+  >;
+};

package/src/Mode.ts

@@ -1,33 +1,33 @@
-import * as Duration from "effect/Duration"
+import * as Duration from "effect/Duration";
 
 export type FormMode =
   | "onSubmit"
   | "onBlur"
   | "onChange"
-  | { readonly onChange: { readonly debounce: Duration.DurationInput; readonly autoSubmit?: false } }
-  | { readonly onBlur: { readonly autoSubmit: true } }
-  | { readonly onChange: { readonly debounce: Duration.DurationInput; readonly autoSubmit: true } }
+  | { readonly onChange: { readonly debounce: Duration.DurationInput; readonly autoSubmit?: false; }; }
+  | { readonly onBlur: { readonly autoSubmit: true; }; }
+  | { readonly onChange: { readonly debounce: Duration.DurationInput; readonly autoSubmit: true; }; };
 
 export type FormModeWithoutAutoSubmit =
   | "onSubmit"
   | "onBlur"
   | "onChange"
-  | { readonly onChange: { readonly debounce: Duration.DurationInput; readonly autoSubmit?: false } }
+  | { readonly onChange: { readonly debounce: Duration.DurationInput; readonly autoSubmit?: false; }; };
 
 export interface ParsedMode {
-  readonly validation: "onSubmit" | "onBlur" | "onChange"
-  readonly debounce: number | null
-  readonly autoSubmit: boolean
+  readonly validation: "onSubmit" | "onBlur" | "onChange";
+  readonly debounce: number | null;
+  readonly autoSubmit: boolean;
 }
 
 export const parse = (mode: FormMode = "onSubmit"): ParsedMode => {
   if (typeof mode === "string") {
-    return { validation: mode, debounce: null, autoSubmit: false }
+    return { validation: mode, debounce: null, autoSubmit: false };
   }
   if ("onBlur" in mode) {
-    return { validation: "onBlur", debounce: null, autoSubmit: true }
+    return { validation: "onBlur", debounce: null, autoSubmit: true };
   }
-  const debounceMs = Duration.toMillis(mode.onChange.debounce)
-  const autoSubmit = mode.onChange.autoSubmit === true
-  return { validation: "onChange", debounce: debounceMs, autoSubmit }
-}
+  const debounceMs = Duration.toMillis(mode.onChange.debounce);
+  const autoSubmit = mode.onChange.autoSubmit === true;
+  return { validation: "onChange", debounce: debounceMs, autoSubmit };
+};

package/src/Path.ts

@@ -1,68 +1,68 @@
-const BRACKET_NOTATION_REGEX = /\[(\d+)\]/g
+const BRACKET_NOTATION_REGEX = /\[(\d+)\]/g;
 
 export const schemaPathToFieldPath = (path: ReadonlyArray<PropertyKey>): string => {
-  if (path.length === 0) return ""
+  if (path.length === 0) return "";
 
-  let result = String(path[0])
+  let result = String(path[0]);
   for (let i = 1; i < path.length; i++) {
-    const segment = path[i]
+    const segment = path[i];
     if (typeof segment === "number") {
-      result += `[${segment}]`
+      result += `[${segment}]`;
     } else {
-      result += `.${String(segment)}`
+      result += `.${String(segment)}`;
     }
   }
-  return result
-}
+  return result;
+};
 
 export const isPathUnderRoot = (path: string, rootPath: string): boolean =>
-  path === rootPath || path.startsWith(rootPath + ".") || path.startsWith(rootPath + "[")
+  path === rootPath || path.startsWith(rootPath + ".") || path.startsWith(rootPath + "[");
 
 export const isPathOrParentDirty = (dirtyFields: ReadonlySet<string>, path: string): boolean => {
-  if (dirtyFields.has(path)) return true
+  if (dirtyFields.has(path)) return true;
 
-  let parent = path
+  let parent = path;
   while (true) {
-    const lastDot = parent.lastIndexOf(".")
-    const lastBracket = parent.lastIndexOf("[")
-    const splitIndex = Math.max(lastDot, lastBracket)
+    const lastDot = parent.lastIndexOf(".");
+    const lastBracket = parent.lastIndexOf("[");
+    const splitIndex = Math.max(lastDot, lastBracket);
 
-    if (splitIndex === -1) break
+    if (splitIndex === -1) break;
 
-    parent = parent.substring(0, splitIndex)
-    if (dirtyFields.has(parent)) return true
+    parent = parent.substring(0, splitIndex);
+    if (dirtyFields.has(parent)) return true;
   }
 
-  return false
-}
+  return false;
+};
 
 export const getNestedValue = (obj: unknown, path: string): unknown => {
-  if (path === "") return obj
-  const parts = path.replace(BRACKET_NOTATION_REGEX, ".$1").split(".")
-  let current: unknown = obj
+  if (path === "") return obj;
+  const parts = path.replace(BRACKET_NOTATION_REGEX, ".$1").split(".");
+  let current: unknown = obj;
   for (const part of parts) {
-    if (current == null || typeof current !== "object") return undefined
-    current = (current as Record<string, unknown>)[part]
+    if (current == null || typeof current !== "object") return undefined;
+    current = (current as Record<string, unknown>)[part];
   }
-  return current
-}
+  return current;
+};
 
 export const setNestedValue = <T>(obj: T, path: string, value: unknown): T => {
-  if (path === "") return value as T
-  const parts = path.replace(BRACKET_NOTATION_REGEX, ".$1").split(".")
-  const result = { ...obj } as Record<string, unknown>
+  if (path === "") return value as T;
+  const parts = path.replace(BRACKET_NOTATION_REGEX, ".$1").split(".");
+  const result = { ...obj } as Record<string, unknown>;
 
-  let current = result
+  let current = result;
   for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i]
+    const part = parts[i];
     if (Array.isArray(current[part])) {
-      current[part] = [...(current[part] as Array<unknown>)]
+      current[part] = [...(current[part] as Array<unknown>)];
     } else {
-      current[part] = { ...(current[part] as Record<string, unknown>) }
+      current[part] = { ...(current[part] as Record<string, unknown>) };
     }
-    current = current[part] as Record<string, unknown>
+    current = current[part] as Record<string, unknown>;
   }
 
-  current[parts[parts.length - 1]] = value
-  return result as T
-}
+  current[parts[parts.length - 1]] = value;
+  return result as T;
+};