@angular/forms 21.2.0-next.1 → 21.2.0-next.3

package/fesm2022/{_structure-chunk.mjs → _validation_errors-chunk.mjs}

@@ -1,11 +1,11 @@
 /**
- * @license Angular v21.2.0-next.1
+ * @license Angular v21.2.0-next.3
  * (c) 2010-2026 Google LLC. https://angular.dev/
  * License: MIT
  */
 
 import { untracked, ɵRuntimeError as _RuntimeError, computed, runInInjectionContext, Injector, linkedSignal, signal, APP_ID, effect, inject } from '@angular/core';
-import { AbstractControl } from '@angular/forms';
+import { AbstractControl, FormGroup, FormArray } from '@angular/forms';
 import { SIGNAL } from '@angular/core/primitives/signals';
 
 let boundPathDepth = 0;
@@ -628,7 +628,7 @@ class FieldValidationState {
   }, ...(ngDevMode ? [{
     debugName: "syncValid"
   }] : []));
-  syncTreeErrors = computed(() => this.rawSyncTreeErrors().filter(err => err.fieldTree === this.node.fieldProxy), ...(ngDevMode ? [{
+  syncTreeErrors = computed(() => this.rawSyncTreeErrors().filter(err => err.fieldTree === this.node.fieldTree), ...(ngDevMode ? [{
     debugName: "syncTreeErrors"
   }] : []));
   rawAsyncErrors = computed(() => {
@@ -643,7 +643,7 @@ class FieldValidationState {
     if (this.shouldSkipValidation()) {
       return [];
     }
-    return this.rawAsyncErrors().filter(err => err === 'pending' || err.fieldTree === this.node.fieldProxy);
+    return this.rawAsyncErrors().filter(err => err === 'pending' || err.fieldTree === this.node.fieldTree);
   }, ...(ngDevMode ? [{
     debugName: "asyncErrors"
   }] : []));
@@ -752,7 +752,7 @@ class FieldNodeContext {
             throw new _RuntimeError(1901, ngDevMode && `Cannot resolve path .${targetPathNode.keys.join('.')} relative to field ${['<root>', ...this.node.structure.pathKeys()].join('.')}.`);
           }
         }
-        return field.fieldProxy;
+        return field.fieldTree;
       }, ...(ngDevMode ? [{
         debugName: "resolver"
       }] : []));
@@ -830,7 +830,7 @@ const FIELD_PROXY_HANDLER = {
     const tgt = getTgt();
     const child = tgt.structure.getChild(p);
     if (child !== undefined) {
-      return child.fieldProxy;
+      return child.fieldTree;
     }
     const value = untracked(tgt.value);
     if (isArray(value)) {
@@ -840,7 +840,7 @@ const FIELD_PROXY_HANDLER = {
       if (p === Symbol.iterator) {
         return () => {
           tgt.value();
-          return Array.prototype[Symbol.iterator].apply(tgt.fieldProxy);
+          return Array.prototype[Symbol.iterator].apply(tgt.fieldTree);
         };
       }
     }
@@ -1186,6 +1186,7 @@ class FieldNode {
   nodeState;
   submitState;
   fieldAdapter;
+  controlValue;
   _context = undefined;
   get context() {
     return this._context ??= new FieldNodeContext(this);
@@ -1200,6 +1201,7 @@ class FieldNode {
     this.nodeState = this.fieldAdapter.createNodeState(this, options);
     this.metadataState = new FieldMetadataState(this);
     this.submitState = new FieldSubmitState(this);
+    this.controlValue = this.controlValueSignal();
   }
   focusBoundControl(options) {
     this.getBindingForFocus()?.focus(options);
@@ -1219,18 +1221,15 @@ class FieldNode {
       return undefined;
     }
   });
+  get fieldTree() {
+    return this.fieldProxy;
+  }
   get logicNode() {
     return this.structure.logic;
   }
   get value() {
     return this.structure.value;
   }
-  _controlValue = linkedSignal(() => this.value(), ...(ngDevMode ? [{
-    debugName: "_controlValue"
-  }] : []));
-  get controlValue() {
-    return this._controlValue.asReadonly();
-  }
   get keyInParent() {
     return this.structure.keyInParent;
   }
@@ -1312,6 +1311,12 @@ class FieldNode {
   markAsDirty() {
     this.nodeState.markAsDirty();
   }
+  markAsPristine() {
+    this.nodeState.markAsPristine();
+  }
+  markAsUntouched() {
+    this.nodeState.markAsUntouched();
+  }
   reset(value) {
     untracked(() => this._reset(value));
   }
@@ -1325,12 +1330,25 @@ class FieldNode {
       child._reset();
     }
   }
-  setControlValue(newValue) {
-    untracked(() => {
-      this._controlValue.set(newValue);
+  controlValueSignal() {
+    const controlValue = linkedSignal(this.value, ...(ngDevMode ? [{
+      debugName: "controlValue"
+    }] : []));
+    const {
+      set,
+      update
+    } = controlValue;
+    controlValue.set = newValue => {
+      set(newValue);
       this.markAsDirty();
       this.debounceSync();
-    });
+    };
+    controlValue.update = updateFn => {
+      update(updateFn);
+      this.markAsDirty();
+      this.debounceSync();
+    };
+    return controlValue;
   }
   sync() {
     this.value.set(this.controlValue());
@@ -1343,8 +1361,10 @@ class FieldNode {
     }
   }
   async debounceSync() {
-    this.pendingSync()?.abort();
-    const debouncer = this.nodeState.debouncer();
+    const debouncer = untracked(() => {
+      this.pendingSync()?.abort();
+      return this.nodeState.debouncer();
+    });
     if (debouncer) {
       const controller = new AbortController();
       const promise = debouncer(controller.signal);
@@ -1502,9 +1522,11 @@ class BasicFieldAdapter {
 class FormFieldManager {
   injector;
   rootName;
-  constructor(injector, rootName) {
+  submitOptions;
+  constructor(injector, rootName, submitOptions) {
     this.injector = injector;
     this.rootName = rootName ?? `${this.injector.get(APP_ID)}.form${nextFormId++}`;
+    this.submitOptions = submitOptions;
   }
   structures = new Set();
   createFieldManagementEffect(root) {
@@ -1552,11 +1574,11 @@ function form(...args) {
   const [model, schema, options] = normalizeFormArgs(args);
   const injector = options?.injector ?? inject(Injector);
   const pathNode = runInInjectionContext(injector, () => SchemaImpl.rootCompile(schema));
-  const fieldManager = new FormFieldManager(injector, options?.name);
+  const fieldManager = new FormFieldManager(injector, options?.name, options?.submission);
   const adapter = options?.adapter ?? new BasicFieldAdapter();
   const fieldRoot = FieldNode.newRoot(fieldManager, model, pathNode, adapter);
   fieldManager.createFieldManagementEffect(fieldRoot.structure);
-  return fieldRoot.fieldProxy;
+  return fieldRoot.fieldTree;
 }
 function applyEach(path, schema) {
   assertPathIsCurrent(path);
@@ -1581,30 +1603,64 @@ function applyWhenValue(path, predicate, schema) {
     value
   }) => predicate(value()), schema);
 }
-async function submit(form, action) {
-  const node = form();
-  const invalid = untracked(() => {
+async function submit(form, options) {
+  const node = untracked(form);
+  const field = options === undefined ? node.structure.root.fieldProxy : form;
+  const detail = {
+    root: node.structure.root.fieldProxy,
+    submitted: form
+  };
+  options = typeof options === 'function' ? {
+    action: options
+  } : options ?? node.structure.fieldManager.submitOptions;
+  const action = options?.action;
+  if (!action) {
+    throw new _RuntimeError(1915, (typeof ngDevMode === 'undefined' || ngDevMode) && 'Cannot submit form with no submit action. Specify the action when creating the form, or as an additional argument to `submit()`.');
+  }
+  const onInvalid = options?.onInvalid;
+  const ignoreValidators = options?.ignoreValidators ?? 'pending';
+  let shouldRunAction = true;
+  untracked(() => {
     markAllAsTouched(node);
-    return node.invalid();
+    if (ignoreValidators === 'none') {
+      shouldRunAction = node.valid();
+    } else if (ignoreValidators === 'pending') {
+      shouldRunAction = !node.invalid();
+    }
   });
-  if (invalid) {
-    return;
-  }
-  node.submitState.selfSubmitting.set(true);
   try {
-    const errors = await action(form);
-    errors && setSubmissionErrors(node, errors);
+    if (shouldRunAction) {
+      node.submitState.selfSubmitting.set(true);
+      const errors = await untracked(() => action?.(field, detail));
+      errors && setSubmissionErrors(node, errors);
+      return !errors || isArray(errors) && errors.length === 0;
+    } else {
+      untracked(() => onInvalid?.(field, detail));
+    }
+    return false;
   } finally {
     node.submitState.selfSubmitting.set(false);
   }
 }
+function schema(fn) {
+  return SchemaImpl.create(fn);
+}
+function markAllAsTouched(node) {
+  if (node.validationState.shouldSkipValidation()) {
+    return;
+  }
+  node.markAsTouched();
+  for (const child of node.structure.children()) {
+    markAllAsTouched(child);
+  }
+}
 function setSubmissionErrors(submittedField, errors) {
   if (!isArray(errors)) {
     errors = [errors];
   }
   const errorsByField = new Map();
   for (const error of errors) {
-    const errorWithField = addDefaultField(error, submittedField.fieldProxy);
+    const errorWithField = addDefaultField(error, submittedField.fieldTree);
     const field = errorWithField.fieldTree();
     let fieldErrors = errorsByField.get(field);
     if (!fieldErrors) {
@@ -1617,18 +1673,57 @@ function setSubmissionErrors(submittedField, errors) {
     field.submitState.submissionErrors.set(fieldErrors);
   }
 }
-function schema(fn) {
-  return SchemaImpl.create(fn);
+
+class CompatValidationError {
+  kind = 'compat';
+  control;
+  fieldTree;
+  context;
+  message;
+  constructor({
+    context,
+    kind,
+    control
+  }) {
+    this.context = context;
+    this.kind = kind;
+    this.control = control;
+  }
 }
-function markAllAsTouched(node) {
-  if (node.validationState.shouldSkipValidation()) {
-    return;
+function signalErrorsToValidationErrors(errors) {
+  if (errors.length === 0) {
+    return null;
   }
-  node.markAsTouched();
-  for (const child of node.structure.children()) {
-    markAllAsTouched(child);
+  const errObj = {};
+  for (const error of errors) {
+    errObj[error.kind] = error instanceof CompatValidationError ? error.context : error;
+  }
+  return errObj;
+}
+function reactiveErrorsToSignalErrors(errors, control) {
+  if (errors === null) {
+    return [];
   }
+  return Object.entries(errors).map(([kind, context]) => {
+    return new CompatValidationError({
+      context,
+      kind,
+      control
+    });
+  });
+}
+function extractNestedReactiveErrors(control) {
+  const errors = [];
+  if (control.errors) {
+    errors.push(...reactiveErrorsToSignalErrors(control.errors, control));
+  }
+  if (control instanceof FormGroup || control instanceof FormArray) {
+    for (const c of Object.values(control.controls)) {
+      errors.push(...extractNestedReactiveErrors(c));
+    }
+  }
+  return errors;
 }
 
-export { BasicFieldAdapter, DEBOUNCER, FieldNode, FieldNodeState, FieldNodeStructure, FieldPathNode, MAX, MAX_LENGTH, MIN, MIN_LENGTH, MetadataKey, MetadataReducer, PATTERN, REQUIRED, addDefaultField, apply, applyEach, applyWhen, applyWhenValue, assertPathIsCurrent, calculateValidationSelfStatus, createManagedMetadataKey, createMetadataKey, form, getInjectorFromOptions, metadata, normalizeFormArgs, schema, submit };
-//# sourceMappingURL=_structure-chunk.mjs.map
+export { BasicFieldAdapter, CompatValidationError, DEBOUNCER, FieldNode, FieldNodeState, FieldNodeStructure, FieldPathNode, MAX, MAX_LENGTH, MIN, MIN_LENGTH, MetadataKey, MetadataReducer, PATTERN, REQUIRED, addDefaultField, apply, applyEach, applyWhen, applyWhenValue, assertPathIsCurrent, calculateValidationSelfStatus, createManagedMetadataKey, createMetadataKey, extractNestedReactiveErrors, form, getInjectorFromOptions, metadata, normalizeFormArgs, schema, signalErrorsToValidationErrors, submit };
+//# sourceMappingURL=_validation_errors-chunk.mjs.map