@lucas-barake/effect-form 0.1.0

package/src/internal/dirty.ts

@@ -0,0 +1,96 @@
+/**
+ * Internal dirty tracking algorithms.
+ *
+ * @internal
+ */
+import * as Equal from "effect/Equal"
+import * as Utils from "effect/Utils"
+import { getNestedValue } from "./path.js"
+
+/**
+ * Recalculates dirty fields for an array after mutation.
+ * Clears all paths under the array and re-evaluates each item.
+ */
+export const recalculateDirtyFieldsForArray = (
+  dirtyFields: ReadonlySet<string>,
+  initialValues: unknown,
+  arrayPath: string,
+  newItems: ReadonlyArray<unknown>,
+): ReadonlySet<string> => {
+  const nextDirty = new Set(
+    Array.from(dirtyFields).filter(
+      (path) => path !== arrayPath && !path.startsWith(arrayPath + ".") && !path.startsWith(arrayPath + "["),
+    ),
+  )
+
+  const initialItems = (getNestedValue(initialValues, arrayPath) ?? []) as ReadonlyArray<unknown>
+
+  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 isEqual = Utils.structuralRegion(() => Equal.equals(newItem, initialItem))
+    if (!isEqual) {
+      nextDirty.add(itemPath)
+    }
+  }
+
+  if (newItems.length !== initialItems.length) {
+    nextDirty.add(arrayPath)
+  } else {
+    nextDirty.delete(arrayPath)
+  }
+
+  return nextDirty
+}
+
+/**
+ * Recalculates dirty fields for a subtree after value change.
+ * Clears the rootPath and all children, then re-evaluates recursively.
+ *
+ * @param rootPath - Empty string for full form, or a specific path for targeted update
+ */
+export const recalculateDirtySubtree = (
+  currentDirty: ReadonlySet<string>,
+  allInitial: unknown,
+  allValues: unknown,
+  rootPath: string = "",
+): ReadonlySet<string> => {
+  const nextDirty = new Set(currentDirty)
+
+  if (rootPath === "") {
+    nextDirty.clear()
+  } else {
+    for (const path of nextDirty) {
+      if (path === rootPath || path.startsWith(rootPath + ".") || path.startsWith(rootPath + "[")) {
+        nextDirty.delete(path)
+      }
+    }
+  }
+
+  const targetValue = rootPath ? getNestedValue(allValues, rootPath) : allValues
+  const targetInitial = rootPath ? getNestedValue(allInitial, rootPath) : allInitial
+
+  const recurse = (current: unknown, initial: unknown, path: string): void => {
+    if (Array.isArray(current)) {
+      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}]`)
+      }
+    } else if (current !== null && typeof current === "object") {
+      const initialObj = (initial ?? {}) as Record<string, unknown>
+      const allKeys = new Set([...Object.keys(current as object), ...Object.keys(initialObj)])
+      for (const key of allKeys) {
+        recurse((current as Record<string, unknown>)[key], initialObj[key], path ? `${path}.${key}` : key)
+      }
+    } else {
+      const isEqual = Utils.structuralRegion(() => Equal.equals(current, initial))
+      if (!isEqual && path) nextDirty.add(path)
+    }
+  }
+
+  recurse(targetValue, targetInitial, rootPath)
+  return nextDirty
+}

package/src/internal/path.ts

@@ -0,0 +1,93 @@
+/**
+ * Internal path utilities for form field operations.
+ *
+ * @internal
+ */
+
+const BRACKET_NOTATION_REGEX = /\[(\d+)\]/g
+
+/**
+ * Converts a schema path array to a dot/bracket notation string.
+ *
+ * @example
+ * schemaPathToFieldPath(["items", 0, "name"]) // "items[0].name"
+ */
+export const schemaPathToFieldPath = (path: ReadonlyArray<PropertyKey>): string => {
+  if (path.length === 0) return ""
+
+  let result = String(path[0])
+  for (let i = 1; i < path.length; i++) {
+    const segment = path[i]
+    if (typeof segment === "number") {
+      result += `[${segment}]`
+    } else {
+      result += `.${String(segment)}`
+    }
+  }
+  return result
+}
+
+/**
+ * Checks if a field path or any of its parent paths are in the dirty set.
+ */
+export const isPathOrParentDirty = (dirtyFields: ReadonlySet<string>, path: string): boolean => {
+  if (dirtyFields.has(path)) return true
+
+  let parent = path
+  while (true) {
+    const lastDot = parent.lastIndexOf(".")
+    const lastBracket = parent.lastIndexOf("[")
+    const splitIndex = Math.max(lastDot, lastBracket)
+
+    if (splitIndex === -1) break
+
+    parent = parent.substring(0, splitIndex)
+    if (dirtyFields.has(parent)) return true
+  }
+
+  return false
+}
+
+/**
+ * Gets a nested value from an object using dot/bracket notation path.
+ *
+ * @example
+ * getNestedValue({ items: [{ name: "A" }] }, "items[0].name") // "A"
+ */
+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
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return undefined
+    current = (current as Record<string, unknown>)[part]
+  }
+  return current
+}
+
+/**
+ * Sets a nested value in an object immutably using dot/bracket notation path.
+ *
+ * @example
+ * setNestedValue({ items: [{ name: "A" }] }, "items[0].name", "B")
+ * // { items: [{ name: "B" }] }
+ */
+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>
+
+  let current = result
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i]
+    if (Array.isArray(current[part])) {
+      current[part] = [...(current[part] as Array<unknown>)]
+    } else {
+      current[part] = { ...(current[part] as Record<string, unknown>) }
+    }
+    current = current[part] as Record<string, unknown>
+  }
+
+  current[parts[parts.length - 1]] = value
+  return result as T
+}

package/src/internal/weak-registry.ts

@@ -0,0 +1,60 @@
+/**
+ * Internal WeakRef-based registry for caching atoms.
+ *
+ * @internal
+ */
+
+/**
+ * A registry that uses WeakRef to allow garbage collection of cached values.
+ *
+ * @internal
+ */
+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>
+}
+
+/**
+ * Creates a WeakRef-based registry with automatic cleanup via FinalizationRegistry.
+ * Falls back to a regular Map in environments without WeakRef support.
+ *
+ * @internal
+ */
+export const createWeakRegistry = <V extends object>(): WeakRegistry<V> => {
+  if (typeof WeakRef === "undefined" || typeof FinalizationRegistry === "undefined") {
+    const map = new Map<string, V>()
+    return {
+      get: (key) => map.get(key),
+      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 registry = new FinalizationRegistry<string>((key) => {
+    map.delete(key)
+  })
+
+  return {
+    get: (key) => map.get(key)?.deref(),
+    set: (key, value) => {
+      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
+      }
+    },
+  }
+}