@lucas-barake/effect-form 0.19.0 → 0.20.0

package/src/Validation.ts

@@ -1,96 +1,75 @@
-import * as Option from "effect/Option";
-import * as ParseResult from "effect/ParseResult";
-import type * as AST from "effect/SchemaAST";
-import { schemaPathToFieldPath } from "./Path.js";
+import * as Option from "effect/Option"
+import * as ParseResult from "effect/ParseResult"
+import type * as AST from "effect/SchemaAST"
+import { schemaPathToFieldPath } from "./Path.ts"
 
-export type ErrorSource = "field" | "refinement";
+export type ErrorSource = "field" | "refinement"
 
 export interface ErrorEntry {
-  readonly message: string;
-  readonly source: ErrorSource;
+  readonly message: string
+  readonly source: ErrorSource
+}
+
+interface IssueSourceEntry {
+  readonly path: ReadonlyArray<PropertyKey>
+  readonly source: ErrorSource
+  readonly issue: ParseResult.ParseIssue
 }
 
 const getBaseAST = (ast: AST.AST): AST.AST => {
   switch (ast._tag) {
     case "Refinement":
     case "Transformation":
-      return getBaseAST(ast.from);
+      return getBaseAST(ast.from)
     default:
-      return ast;
+      return ast
   }
-};
+}
 
 const isCompositeType = (ast: AST.AST): boolean => {
-  const base = getBaseAST(ast);
+  const base = getBaseAST(ast)
   switch (base._tag) {
     case "TypeLiteral": // Schema.Struct
     case "TupleType": // Schema.Tuple
     case "Declaration": // Schema.Class, Schema.TaggedClass
     case "Union": // Schema.Union
     case "Suspend": // Recursive schemas
-      return true;
+      return true
     default:
-      return false;
-  }
-};
-
-export const extractFirstError = (error: ParseResult.ParseError): Option.Option<string> => {
-  const issues = ParseResult.ArrayFormatter.formatErrorSync(error);
-  if (issues.length === 0) {
-    return Option.none();
+      return false
   }
-  return Option.some(issues[0].message);
-};
-
-export const routeErrors = (error: ParseResult.ParseError): Map<string, string> => {
-  const result = new Map<string, string>();
-  const issues = ParseResult.ArrayFormatter.formatErrorSync(error);
-
-  for (const issue of issues) {
-    const fieldPath = schemaPathToFieldPath(issue.path);
-    if (fieldPath && !result.has(fieldPath)) {
-      result.set(fieldPath, issue.message);
-    }
-  }
-
-  return result;
-};
+}
 
-const determineErrorSources = (error: ParseResult.ParseError): Map<string, ErrorSource> => {
-  const sources = new Map<string, ErrorSource>();
+const collectIssueSources = (error: ParseResult.ParseError): ReadonlyArray<IssueSourceEntry> => {
+  const entries: Array<IssueSourceEntry> = []
 
   const walk = (issue: ParseResult.ParseIssue, path: ReadonlyArray<PropertyKey>, source: ErrorSource): void => {
     switch (issue._tag) {
       case "Refinement":
         if (issue.kind === "Predicate" && isCompositeType(issue.ast.from) && path.length === 0) {
-          walk(issue.issue, path, "refinement");
+          walk(issue.issue, path, "refinement")
         } else {
-          walk(issue.issue, path, source);
+          walk(issue.issue, path, source)
         }
-        break;
+        break
       case "Pointer": {
-        const pointerPath = Array.isArray(issue.path) ? issue.path : [issue.path];
-        walk(issue.issue, [...path, ...pointerPath], source);
-        break;
+        const pointerPath = Array.isArray(issue.path) ? issue.path : [issue.path]
+        walk(issue.issue, [...path, ...pointerPath], source)
+        break
       }
       case "Composite": {
-        const issues = Array.isArray(issue.issues) ? issue.issues : [issue.issues];
+        const issues = Array.isArray(issue.issues) ? issue.issues : [issue.issues]
         for (const sub of issues) {
-          walk(sub, path, source);
+          walk(sub, path, source)
         }
-        break;
+        break
       }
       case "Type":
       case "Missing":
       case "Unexpected":
-      case "Forbidden": {
-        const fieldPath = schemaPathToFieldPath(path);
-        const key = fieldPath ?? "";
-        if (!sources.has(key)) {
-          sources.set(key, source);
-        }
-        break;
-      }
+      case "Forbidden":
+        entries.push({ path, source, issue })
+        break
       case "Transformation":
         if (
           issue.kind === "Transformation" &&
@@ -98,31 +77,88 @@ const determineErrorSources = (error: ParseResult.ParseError): Map<string, Error
           isCompositeType(issue.ast.from) &&
           path.length === 0
         ) {
-          walk(issue.issue, path, "refinement");
+          walk(issue.issue, path, "refinement")
         } else {
-          walk(issue.issue, path, source);
+          walk(issue.issue, path, source)
         }
-        break;
+        break
     }
-  };
+  }
 
-  walk(error.issue, [], "field");
-  return sources;
-};
+  walk(error.issue, [], "field")
+  return entries
+}
+
+const getIssueMessage = (issue: ParseResult.ParseIssue): string | undefined => {
+  const formatted = ParseResult.ArrayFormatter.formatIssueSync(issue)
+  return formatted[0]?.message
+}
+
+export const extractFirstError = (error: ParseResult.ParseError): Option.Option<string> => {
+  const issues = ParseResult.ArrayFormatter.formatErrorSync(error)
+  if (issues.length === 0) {
+    return Option.none()
+  }
+  return Option.some(issues[0].message)
+}
+
+export const routeErrors = (error: ParseResult.ParseError): Map<string, string> => {
+  const result = new Map<string, string>()
+  const issues = ParseResult.ArrayFormatter.formatErrorSync(error)
+
+  for (const issue of issues) {
+    const fieldPath = schemaPathToFieldPath(issue.path)
+    if (fieldPath && !result.has(fieldPath)) {
+      result.set(fieldPath, issue.message)
+    }
+  }
+
+  return result
+}
 
 export const routeErrorsWithSource = (error: ParseResult.ParseError): Map<string, ErrorEntry> => {
-  const result = new Map<string, ErrorEntry>();
-  const formattedIssues = ParseResult.ArrayFormatter.formatErrorSync(error);
-  const sources = determineErrorSources(error);
+  const result = new Map<string, ErrorEntry>()
+  const formattedIssues = ParseResult.ArrayFormatter.formatErrorSync(error)
+  const issueSources = collectIssueSources(error)
+  const messageSources = new Map<string, ErrorSource>()
+  const refinementPaths = new Set<string>()
+
+  for (const entry of issueSources) {
+    const fieldPath = schemaPathToFieldPath(entry.path) ?? ""
+    const message = getIssueMessage(entry.issue)
+    if (message !== undefined) {
+      const messageKey = `${fieldPath}::${message}`
+      const existing = messageSources.get(messageKey)
+      if (!existing || (existing === "field" && entry.source === "refinement")) {
+        messageSources.set(messageKey, entry.source)
+      }
+    }
+    if (entry.source === "refinement") {
+      refinementPaths.add(fieldPath)
+    }
+  }
 
   for (const issue of formattedIssues) {
-    const fieldPath = schemaPathToFieldPath(issue.path);
-    const key = fieldPath ?? "";
-    if (!result.has(key)) {
-      const source = sources.get(key) ?? "field";
-      result.set(key, { message: issue.message, source });
+    const fieldPath = schemaPathToFieldPath(issue.path) ?? ""
+    if (result.has(fieldPath)) continue
+    const preferredSource: ErrorSource = refinementPaths.has(fieldPath) ? "refinement" : "field"
+    const messageKey = `${fieldPath}::${issue.message}`
+    const issueSource = messageSources.get(messageKey) ?? "field"
+    if (preferredSource === "refinement" && issueSource !== "refinement") {
+      continue
     }
+    result.set(fieldPath, { message: issue.message, source: issueSource })
   }
 
-  return result;
-};
+  if (result.size < formattedIssues.length) {
+    for (const issue of formattedIssues) {
+      const fieldPath = schemaPathToFieldPath(issue.path) ?? ""
+      if (result.has(fieldPath)) continue
+      const messageKey = `${fieldPath}::${issue.message}`
+      const issueSource = messageSources.get(messageKey) ?? "field"
+      result.set(fieldPath, { message: issue.message, source: issueSource })
+    }
+  }
+
+  return result
+}

package/src/index.ts

@@ -1,34 +1,13 @@
+export * as Field from "./Field.ts"
 
-export * as Field from "./Field.js"
+export * as FieldState from "./FieldState.ts"
 
-/**
-   * Root anchor atom for the form's dependency graph.
-   * Mount this atom to keep all form state alive even when field components unmount.
-   *
-   * Useful for:
-   * - Multi-step wizards where steps unmount but state should persist
-   * - Conditional fields (toggles) where state should survive visibility changes
-   *
-   * @example
-   * ```tsx
-   * // Keep form state alive at wizard root level
-   * function Wizard() {
-   *   useAtomMount(step1Form.mount)
-   *   useAtomMount(step2Form.mount)
-   *   return currentStep === 1 ? <Step1 /> : <Step2 />
-   * }
-   * ```
-   */
-export * as FormAtoms from "./FormAtoms.js"
+export * as FormAtoms from "./FormAtoms.ts"
 
+export * as FormBuilder from "./FormBuilder.ts"
 
-export * as FormBuilder from "./FormBuilder.js"
+export * as Mode from "./Mode.ts"
 
+export * as Path from "./Path.ts"
 
-export * as Mode from "./Mode.js"
-
-
-export * as Path from "./Path.js"
-
-
-export * as Validation from "./Validation.js"
+export * as Validation from "./Validation.ts"

package/src/internal/dirty.ts

@@ -1,107 +1,107 @@
-import * as Equal from "effect/Equal";
-import * as Utils from "effect/Utils";
-import { getNestedValue, isPathUnderRoot } from "../Path.js";
+import * as Equal from "effect/Equal"
+import * as Utils from "effect/Utils"
+import { getNestedValue, isPathUnderRoot } from "../Path.ts"
 
 export const recalculateDirtyFieldsForArray = (
   dirtyFields: ReadonlySet<string>,
   initialValues: unknown,
   arrayPath: string,
-  newItems: ReadonlyArray<unknown>,
+  newItems: ReadonlyArray<unknown>
 ): ReadonlySet<string> => {
-  const initialItems = (getNestedValue(initialValues, arrayPath) ?? []) as ReadonlyArray<unknown>;
+  const initialItems = (getNestedValue(initialValues, arrayPath) ?? []) as ReadonlyArray<unknown>
 
   if (newItems === initialItems) {
-    return dirtyFields;
+    return dirtyFields
   }
 
   const nextDirty = new Set(
-    Array.from(dirtyFields).filter((path) => !isPathUnderRoot(path, arrayPath)),
-  );
+    Array.from(dirtyFields).filter((path) => !isPathUnderRoot(path, arrayPath))
+  )
 
-  const loopLength = Math.max(newItems.length, initialItems.length);
+  const loopLength = Math.max(newItems.length, initialItems.length)
   for (let i = 0; i < loopLength; i++) {
-    const itemPath = `${arrayPath}[${i}]`;
-    const newItem = newItems[i];
-    const initialItem = initialItems[i];
+    const itemPath = `${arrayPath}[${i}]`
+    const newItem = newItems[i]
+    const initialItem = initialItems[i]
 
-    if (newItem === initialItem) continue;
+    if (newItem === initialItem) continue
 
-    const isEqual = Utils.structuralRegion(() => Equal.equals(newItem, initialItem));
+    const isEqual = Utils.structuralRegion(() => Equal.equals(newItem, initialItem))
     if (!isEqual) {
-      nextDirty.add(itemPath);
+      nextDirty.add(itemPath)
     }
   }
 
   if (newItems.length !== initialItems.length) {
-    nextDirty.add(arrayPath);
+    nextDirty.add(arrayPath)
   } else {
-    nextDirty.delete(arrayPath);
+    nextDirty.delete(arrayPath)
   }
 
-  return nextDirty;
-};
+  return nextDirty
+}
 
 export const recalculateDirtySubtree = (
   currentDirty: ReadonlySet<string>,
   allInitial: unknown,
   allValues: unknown,
-  rootPath: string = "",
+  rootPath: string = ""
 ): ReadonlySet<string> => {
-  const targetValue = rootPath ? getNestedValue(allValues, rootPath) : allValues;
-  const targetInitial = rootPath ? getNestedValue(allInitial, rootPath) : allInitial;
+  const targetValue = rootPath ? getNestedValue(allValues, rootPath) : allValues
+  const targetInitial = rootPath ? getNestedValue(allInitial, rootPath) : allInitial
 
   if (targetValue === targetInitial) {
     if (rootPath === "") {
-      return new Set();
+      return new Set()
     }
 
-    let changed = false;
-    const nextDirty = new Set(currentDirty);
+    let changed = false
+    const nextDirty = new Set(currentDirty)
     for (const path of currentDirty) {
       if (isPathUnderRoot(path, rootPath)) {
-        nextDirty.delete(path);
-        changed = true;
+        nextDirty.delete(path)
+        changed = true
       }
     }
-    return changed ? nextDirty : currentDirty;
+    return changed ? nextDirty : currentDirty
   }
 
-  const nextDirty = new Set(currentDirty);
+  const nextDirty = new Set(currentDirty)
 
   if (rootPath === "") {
-    nextDirty.clear();
+    nextDirty.clear()
   } else {
     for (const path of nextDirty) {
       if (isPathUnderRoot(path, rootPath)) {
-        nextDirty.delete(path);
+        nextDirty.delete(path)
       }
     }
   }
 
   const recurse = (current: unknown, initial: unknown, path: string): void => {
-    if (current === initial) return;
+    if (current === initial) return
 
     if (Array.isArray(current)) {
-      const initialArr = (initial ?? []) as ReadonlyArray<unknown>;
+      const initialArr = (initial ?? []) as ReadonlyArray<unknown>
       for (let i = 0; i < Math.max(current.length, initialArr.length); i++) {
-        recurse(current[i], initialArr[i], path ? `${path}[${i}]` : `[${i}]`);
+        recurse(current[i], initialArr[i], path ? `${path}[${i}]` : `[${i}]`)
       }
     } else if (current !== null && typeof current === "object") {
-      const initialObj = (initial ?? {}) as Record<string, unknown>;
+      const initialObj = (initial ?? {}) as Record<string, unknown>
       for (const key in current as object) {
-        recurse((current as Record<string, unknown>)[key], initialObj[key], path ? `${path}.${key}` : key);
+        recurse((current as Record<string, unknown>)[key], initialObj[key], path ? `${path}.${key}` : key)
       }
       for (const key in initialObj) {
         if (!(key in (current as object))) {
-          recurse(undefined, initialObj[key], path ? `${path}.${key}` : key);
+          recurse(undefined, initialObj[key], path ? `${path}.${key}` : key)
         }
       }
     } else {
-      const isEqual = Utils.structuralRegion(() => Equal.equals(current, initial));
-      if (!isEqual && path) nextDirty.add(path);
+      const isEqual = Utils.structuralRegion(() => Equal.equals(current, initial))
+      if (!isEqual && path) nextDirty.add(path)
     }
-  };
+  }
 
-  recurse(targetValue, targetInitial, rootPath);
-  return nextDirty;
-};
+  recurse(targetValue, targetInitial, rootPath)
+  return nextDirty
+}

package/src/internal/weak-registry.ts

@@ -1,43 +1,43 @@
-export interface WeakRegistry<V extends object> {
-  readonly get: (key: string) => V | undefined;
-  readonly set: (key: string, value: V) => void;
-  readonly delete: (key: string) => boolean;
-  readonly clear: () => void;
-  readonly values: () => IterableIterator<V>;
+export interface WeakRegistry<V extends object,> {
+  readonly get: (key: string) => V | undefined
+  readonly set: (key: string, value: V) => void
+  readonly delete: (key: string) => boolean
+  readonly clear: () => void
+  readonly values: () => IterableIterator<V>
 }
 
-export const createWeakRegistry = <V extends object>(): WeakRegistry<V> => {
+export const createWeakRegistry = <V extends object,>(): WeakRegistry<V> => {
   if (typeof WeakRef === "undefined" || typeof FinalizationRegistry === "undefined") {
-    const map = new Map<string, V>();
+    const map = new Map<string, V>()
     return {
       get: (key) => map.get(key),
       set: (key, value) => {
-        map.set(key, value);
+        map.set(key, value)
       },
       delete: (key) => map.delete(key),
       clear: () => map.clear(),
-      values: () => map.values(),
-    };
+      values: () => map.values()
+    }
   }
 
-  const map = new Map<string, WeakRef<V>>();
+  const map = new Map<string, WeakRef<V>>()
   const registry = new FinalizationRegistry<string>((key) => {
-    map.delete(key);
-  });
+    map.delete(key)
+  })
 
   return {
     get: (key) => map.get(key)?.deref(),
     set: (key, value) => {
-      map.set(key, new WeakRef(value));
-      registry.register(value, key);
+      map.set(key, new WeakRef(value))
+      registry.register(value, key)
     },
     delete: (key) => map.delete(key),
     clear: () => map.clear(),
     *values() {
       for (const ref of map.values()) {
-        const value = ref.deref();
-        if (value !== undefined) yield value;
+        const value = ref.deref()
+        if (value !== undefined) yield value
       }
-    },
-  };
-};
+    }
+  }
+}

package/Field/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/Field.js",
-  "module": "../dist/esm/Field.js",
-  "types": "../dist/dts/Field.d.ts",
-  "sideEffects": []
-}

package/FormAtoms/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/FormAtoms.js",
-  "module": "../dist/esm/FormAtoms.js",
-  "types": "../dist/dts/FormAtoms.d.ts",
-  "sideEffects": []
-}

package/FormBuilder/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/FormBuilder.js",
-  "module": "../dist/esm/FormBuilder.js",
-  "types": "../dist/dts/FormBuilder.d.ts",
-  "sideEffects": []
-}

package/Mode/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/Mode.js",
-  "module": "../dist/esm/Mode.js",
-  "types": "../dist/dts/Mode.d.ts",
-  "sideEffects": []
-}

package/Path/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/Path.js",
-  "module": "../dist/esm/Path.js",
-  "types": "../dist/dts/Path.d.ts",
-  "sideEffects": []
-}

package/Validation/package.json

@@ -1,6 +0,0 @@
-{
-  "main": "../dist/cjs/Validation.js",
-  "module": "../dist/esm/Validation.js",
-  "types": "../dist/dts/Validation.d.ts",
-  "sideEffects": []
-}

package/dist/cjs/Field.js

@@ -1,94 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeField = exports.makeArrayField = exports.isFieldDef = exports.isArrayFieldDef = exports.getDefaultFromSchema = exports.getDefaultEncodedValues = exports.createTouchedRecord = exports.TypeId = void 0;
-var Schema = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/Schema"));
-function _interopRequireWildcard(e, t) {
-  if ("function" == typeof WeakMap) var r = new WeakMap(),
-    n = new WeakMap();
-  return (_interopRequireWildcard = function (e, t) {
-    if (!t && e && e.__esModule) return e;
-    var o,
-      i,
-      f = {
-        __proto__: null,
-        default: e
-      };
-    if (null === e || "object" != typeof e && "function" != typeof e) return f;
-    if (o = t ? n : r) {
-      if (o.has(e)) return o.get(e);
-      o.set(e, f);
-    }
-    for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]);
-    return f;
-  })(e, t);
-}
-const TypeId = exports.TypeId = /*#__PURE__*/Symbol.for("@lucas-barake/effect-form/Field");
-const isArrayFieldDef = def => def._tag === "array";
-exports.isArrayFieldDef = isArrayFieldDef;
-const isFieldDef = def => def._tag === "field";
-exports.isFieldDef = isFieldDef;
-const makeField = (key, schema) => ({
-  _tag: "field",
-  key,
-  schema
-});
-exports.makeField = makeField;
-const makeArrayField = (key, itemSchema) => ({
-  _tag: "array",
-  key,
-  itemSchema
-});
-exports.makeArrayField = makeArrayField;
-const getDefaultFromSchema = schema => {
-  const ast = schema.ast;
-  switch (ast._tag) {
-    case "StringKeyword":
-    case "TemplateLiteral":
-      return "";
-    case "NumberKeyword":
-      return 0;
-    case "BooleanKeyword":
-      return false;
-    case "TypeLiteral":
-      {
-        const result = {};
-        for (const prop of ast.propertySignatures) {
-          result[prop.name] = getDefaultFromSchema(Schema.make(prop.type));
-        }
-        return result;
-      }
-    case "Transformation":
-      return getDefaultFromSchema(Schema.make(ast.from));
-    case "Refinement":
-      return getDefaultFromSchema(Schema.make(ast.from));
-    case "Suspend":
-      return getDefaultFromSchema(Schema.make(ast.f()));
-    default:
-      return "";
-  }
-};
-exports.getDefaultFromSchema = getDefaultFromSchema;
-const getDefaultEncodedValues = fields => {
-  const result = {};
-  for (const [key, def] of Object.entries(fields)) {
-    if (isArrayFieldDef(def)) {
-      result[key] = [];
-    } else {
-      result[key] = "";
-    }
-  }
-  return result;
-};
-exports.getDefaultEncodedValues = getDefaultEncodedValues;
-const createTouchedRecord = (fields, value) => {
-  const result = {};
-  for (const key of Object.keys(fields)) {
-    result[key] = value;
-  }
-  return result;
-};
-exports.createTouchedRecord = createTouchedRecord;
-//# sourceMappingURL=Field.js.map

package/dist/cjs/Field.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Field.js","names":["Schema","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","TypeId","exports","Symbol","for","isArrayFieldDef","def","_tag","isFieldDef","makeField","key","schema","makeArrayField","itemSchema","getDefaultFromSchema","ast","result","prop","propertySignatures","name","make","type","from","getDefaultEncodedValues","fields","entries","createTouchedRecord","value","keys"],"sources":["../../src/Field.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}