@lucas-barake/effect-form 0.14.0 → 0.16.0

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