@lucas-barake/effect-form 0.15.0 → 0.16.0

package/src/Validation.ts

@@ -1,95 +1,95 @@
-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.js";
 
-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;
 }
 
 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
+      return false;
   }
-}
+};
 
 export const extractFirstError = (error: ParseResult.ParseError): Option.Option<string> => {
-  const issues = ParseResult.ArrayFormatter.formatErrorSync(error)
+  const issues = ParseResult.ArrayFormatter.formatErrorSync(error);
   if (issues.length === 0) {
-    return Option.none()
+    return Option.none();
   }
-  return Option.some(issues[0].message)
-}
+  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)
+  const result = new Map<string, string>();
+  const issues = ParseResult.ArrayFormatter.formatErrorSync(error);
 
   for (const issue of issues) {
-    const fieldPath = schemaPathToFieldPath(issue.path)
+    const fieldPath = schemaPathToFieldPath(issue.path);
     if (fieldPath && !result.has(fieldPath)) {
-      result.set(fieldPath, issue.message)
+      result.set(fieldPath, issue.message);
     }
   }
 
-  return result
-}
+  return result;
+};
 
 const determineErrorSources = (error: ParseResult.ParseError): Map<string, ErrorSource> => {
-  const sources = new Map<string, ErrorSource>()
+  const sources = new Map<string, ErrorSource>();
 
   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 ?? ""
+        const fieldPath = schemaPathToFieldPath(path);
+        const key = fieldPath ?? "";
         if (!sources.has(key)) {
-          sources.set(key, source)
+          sources.set(key, source);
         }
-        break
+        break;
       }
       case "Transformation":
         if (
@@ -98,31 +98,31 @@ 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 sources;
+};
 
 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 sources = determineErrorSources(error);
 
   for (const issue of formattedIssues) {
-    const fieldPath = schemaPathToFieldPath(issue.path)
-    const key = fieldPath ?? ""
+    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 source = sources.get(key) ?? "field";
+      result.set(key, { message: issue.message, source });
     }
   }
 
-  return result
-}
+  return result;
+};

package/src/internal/dirty.ts

@@ -1,6 +1,6 @@
-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.js";
 
 export const recalculateDirtyFieldsForArray = (
   dirtyFields: ReadonlySet<string>,
@@ -8,38 +8,38 @@ export const recalculateDirtyFieldsForArray = (
   arrayPath: string,
   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)),
-  )
+  );
 
-  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>,
@@ -47,61 +47,61 @@ export const recalculateDirtySubtree = (
   allValues: unknown,
   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>
+  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> => {
   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(),
-    }
+    };
   }
 
-  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;
       }
     },
-  }
-}
+  };
+};