@angular/forms 21.1.0-next.1 → 21.1.0-next.2

package/fesm2022/_structure-chunk.mjs

@@ -1,34 +1,28 @@
 /**
- * @license Angular v21.1.0-next.1
+ * @license Angular v21.1.0-next.2
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
 
-import { computed, untracked, runInInjectionContext, linkedSignal, Injector, signal, APP_ID, effect, inject } from '@angular/core';
+import { untracked, computed, runInInjectionContext, Injector, linkedSignal, signal, APP_ID, effect, inject } from '@angular/core';
 import { AbstractControl } from '@angular/forms';
 import { SIGNAL } from '@angular/core/primitives/signals';
 
-function isArray(value) {
-  return Array.isArray(value);
-}
-function isObject(value) {
-  return (typeof value === 'object' || typeof value === 'function') && value != null;
+let boundPathDepth = 0;
+function getBoundPathDepth() {
+  return boundPathDepth;
 }
-
-function reduceChildren(node, initialValue, fn, shortCircuit) {
-  const childrenMap = node.structure.childrenMap();
-  if (!childrenMap) {
-    return initialValue;
-  }
-  let value = initialValue;
-  for (const child of childrenMap.values()) {
-    if (shortCircuit?.(value)) {
-      break;
+function setBoundPathDepthForResolution(fn, depth) {
+  return (...args) => {
+    try {
+      boundPathDepth = depth;
+      return fn(...args);
+    } finally {
+      boundPathDepth = 0;
     }
-    value = fn(child, value);
-  }
-  return value;
+  };
 }
+
 function shortCircuitFalse(value) {
   return !value;
 }
@@ -42,131 +36,11 @@ function getInjectorFromOptions(options) {
   return options.parent.structure.root.structure.injector;
 }
 
-function calculateValidationSelfStatus(state) {
-  if (state.errors().length > 0) {
-    return 'invalid';
-  }
-  if (state.pending()) {
-    return 'unknown';
-  }
-  return 'valid';
-}
-class FieldValidationState {
-  node;
-  constructor(node) {
-    this.node = node;
-  }
-  rawSyncTreeErrors = computed(() => {
-    if (this.shouldSkipValidation()) {
-      return [];
-    }
-    return [...this.node.logicNode.logic.syncTreeErrors.compute(this.node.context), ...(this.node.structure.parent?.validationState.rawSyncTreeErrors() ?? [])];
-  }, ...(ngDevMode ? [{
-    debugName: "rawSyncTreeErrors"
-  }] : []));
-  syncErrors = computed(() => {
-    if (this.shouldSkipValidation()) {
-      return [];
-    }
-    return [...this.node.logicNode.logic.syncErrors.compute(this.node.context), ...this.syncTreeErrors(), ...normalizeErrors(this.node.submitState.serverErrors())];
-  }, ...(ngDevMode ? [{
-    debugName: "syncErrors"
-  }] : []));
-  syncValid = computed(() => {
-    if (this.shouldSkipValidation()) {
-      return true;
-    }
-    return reduceChildren(this.node, this.syncErrors().length === 0, (child, value) => value && child.validationState.syncValid(), shortCircuitFalse);
-  }, ...(ngDevMode ? [{
-    debugName: "syncValid"
-  }] : []));
-  syncTreeErrors = computed(() => this.rawSyncTreeErrors().filter(err => err.field === this.node.fieldProxy), ...(ngDevMode ? [{
-    debugName: "syncTreeErrors"
-  }] : []));
-  rawAsyncErrors = computed(() => {
-    if (this.shouldSkipValidation()) {
-      return [];
-    }
-    return [...this.node.logicNode.logic.asyncErrors.compute(this.node.context), ...(this.node.structure.parent?.validationState.rawAsyncErrors() ?? [])];
-  }, ...(ngDevMode ? [{
-    debugName: "rawAsyncErrors"
-  }] : []));
-  asyncErrors = computed(() => {
-    if (this.shouldSkipValidation()) {
-      return [];
-    }
-    return this.rawAsyncErrors().filter(err => err === 'pending' || err.field === this.node.fieldProxy);
-  }, ...(ngDevMode ? [{
-    debugName: "asyncErrors"
-  }] : []));
-  errors = computed(() => [...this.syncErrors(), ...this.asyncErrors().filter(err => err !== 'pending')], ...(ngDevMode ? [{
-    debugName: "errors"
-  }] : []));
-  errorSummary = computed(() => reduceChildren(this.node, this.errors(), (child, result) => [...result, ...child.errorSummary()]), ...(ngDevMode ? [{
-    debugName: "errorSummary"
-  }] : []));
-  pending = computed(() => reduceChildren(this.node, this.asyncErrors().includes('pending'), (child, value) => value || child.validationState.asyncErrors().includes('pending')), ...(ngDevMode ? [{
-    debugName: "pending"
-  }] : []));
-  status = computed(() => {
-    if (this.shouldSkipValidation()) {
-      return 'valid';
-    }
-    let ownStatus = calculateValidationSelfStatus(this);
-    return reduceChildren(this.node, ownStatus, (child, value) => {
-      if (value === 'invalid' || child.validationState.status() === 'invalid') {
-        return 'invalid';
-      } else if (value === 'unknown' || child.validationState.status() === 'unknown') {
-        return 'unknown';
-      }
-      return 'valid';
-    }, v => v === 'invalid');
-  }, ...(ngDevMode ? [{
-    debugName: "status"
-  }] : []));
-  valid = computed(() => this.status() === 'valid', ...(ngDevMode ? [{
-    debugName: "valid"
-  }] : []));
-  invalid = computed(() => this.status() === 'invalid', ...(ngDevMode ? [{
-    debugName: "invalid"
-  }] : []));
-  shouldSkipValidation = computed(() => this.node.hidden() || this.node.disabled() || this.node.readonly(), ...(ngDevMode ? [{
-    debugName: "shouldSkipValidation"
-  }] : []));
-}
-function normalizeErrors(error) {
-  if (error === undefined) {
-    return [];
-  }
-  if (isArray(error)) {
-    return error;
-  }
-  return [error];
-}
-function addDefaultField(errors, field) {
-  if (isArray(errors)) {
-    for (const error of errors) {
-      error.field ??= field;
-    }
-  } else if (errors) {
-    errors.field ??= field;
-  }
-  return errors;
-}
-
-let boundPathDepth = 0;
-function getBoundPathDepth() {
-  return boundPathDepth;
+function isArray(value) {
+  return Array.isArray(value);
 }
-function setBoundPathDepthForResolution(fn, depth) {
-  return (...args) => {
-    try {
-      boundPathDepth = depth;
-      return fn(...args);
-    } finally {
-      boundPathDepth = 0;
-    }
-  };
+function isObject(value) {
+  return (typeof value === 'object' || typeof value === 'function') && value != null;
 }
 
 const DYNAMIC = Symbol();
@@ -229,10 +103,10 @@ class ArrayMergeLogic extends ArrayMergeIgnoreLogic {
     super(predicates, undefined);
   }
 }
-class AggregateMetadataMergeLogic extends AbstractLogic {
+class MetadataMergeLogic extends AbstractLogic {
   key;
   get defaultValue() {
-    return this.key.getInitial();
+    return this.key.reducer.getInitial();
   }
   constructor(predicates, key) {
     super(predicates);
@@ -240,13 +114,13 @@ class AggregateMetadataMergeLogic extends AbstractLogic {
   }
   compute(ctx) {
     if (this.fns.length === 0) {
-      return this.key.getInitial();
+      return this.key.reducer.getInitial();
     }
-    let acc = this.key.getInitial();
+    let acc = this.key.reducer.getInitial();
     for (let i = 0; i < this.fns.length; i++) {
       const item = this.fns[i](ctx);
       if (item !== IGNORED) {
-        acc = this.key.reduce(acc, item);
+        acc = this.key.reducer.reduce(acc, item);
       }
     }
     return acc;
@@ -278,8 +152,7 @@ class LogicContainer {
   syncErrors;
   syncTreeErrors;
   asyncErrors;
-  aggregateMetadataKeys = new Map();
-  metadataFactories = new Map();
+  metadata = new Map();
   constructor(predicates) {
     this.predicates = predicates;
     this.hidden = new BooleanOrLogic(predicates);
@@ -289,26 +162,17 @@ class LogicContainer {
     this.syncTreeErrors = ArrayMergeIgnoreLogic.ignoreNull(predicates);
     this.asyncErrors = ArrayMergeIgnoreLogic.ignoreNull(predicates);
   }
-  hasAggregateMetadata(key) {
-    return this.aggregateMetadataKeys.has(key);
-  }
-  getAggregateMetadataEntries() {
-    return this.aggregateMetadataKeys.entries();
-  }
-  getMetadataFactoryEntries() {
-    return this.metadataFactories.entries();
+  hasMetadata(key) {
+    return this.metadata.has(key);
   }
-  getAggregateMetadata(key) {
-    if (!this.aggregateMetadataKeys.has(key)) {
-      this.aggregateMetadataKeys.set(key, new AggregateMetadataMergeLogic(this.predicates, key));
-    }
-    return this.aggregateMetadataKeys.get(key);
+  getMetadataKeys() {
+    return this.metadata.keys();
   }
-  addMetadataFactory(key, factory) {
-    if (this.metadataFactories.has(key)) {
-      throw new Error(`Can't define value twice for the same MetadataKey`);
+  getMetadata(key) {
+    if (!this.metadata.has(key)) {
+      this.metadata.set(key, new MetadataMergeLogic(this.predicates, key));
     }
-    this.metadataFactories.set(key, factory);
+    return this.metadata.get(key);
   }
   mergeIn(other) {
     this.hidden.mergeIn(other.hidden);
@@ -317,11 +181,9 @@ class LogicContainer {
     this.syncErrors.mergeIn(other.syncErrors);
     this.syncTreeErrors.mergeIn(other.syncTreeErrors);
     this.asyncErrors.mergeIn(other.asyncErrors);
-    for (const [key, metadataLogic] of other.getAggregateMetadataEntries()) {
-      this.getAggregateMetadata(key).mergeIn(metadataLogic);
-    }
-    for (const [key, metadataFactory] of other.getMetadataFactoryEntries()) {
-      this.addMetadataFactory(key, metadataFactory);
+    for (const key of other.getMetadataKeys()) {
+      const metadataLogic = other.metadata.get(key);
+      this.getMetadata(key).mergeIn(metadataLogic);
     }
   }
 }
@@ -359,11 +221,8 @@ class LogicNodeBuilder extends AbstractLogicNodeBuilder {
   addAsyncErrorRule(logic) {
     this.getCurrent().addAsyncErrorRule(logic);
   }
-  addAggregateMetadataRule(key, logic) {
-    this.getCurrent().addAggregateMetadataRule(key, logic);
-  }
-  addMetadataFactory(key, factory) {
-    this.getCurrent().addMetadataFactory(key, factory);
+  addMetadataRule(key, logic) {
+    this.getCurrent().addMetadataRule(key, logic);
   }
   getChild(key) {
     if (key === DYNAMIC) {
@@ -435,11 +294,8 @@ class NonMergeableLogicNodeBuilder extends AbstractLogicNodeBuilder {
   addAsyncErrorRule(logic) {
     this.logic.asyncErrors.push(setBoundPathDepthForResolution(logic, this.depth));
   }
-  addAggregateMetadataRule(key, logic) {
-    this.logic.getAggregateMetadata(key).push(setBoundPathDepthForResolution(logic, this.depth));
-  }
-  addMetadataFactory(key, factory) {
-    this.logic.addMetadataFactory(key, setBoundPathDepthForResolution(factory, this.depth));
+  addMetadataRule(key, logic) {
+    this.logic.getMetadata(key).push(setBoundPathDepthForResolution(logic, this.depth));
   }
   getChild(key) {
     if (!this.children.has(key)) {
@@ -657,64 +513,196 @@ function assertPathIsCurrent(path) {
   }
 }
 
-class MetadataKey {
-  brand;
-  constructor() {}
+function metadata(path, key, logic) {
+  assertPathIsCurrent(path);
+  const pathNode = FieldPathNode.unwrapFieldPath(path);
+  pathNode.builder.addMetadataRule(key, logic);
+  return key;
 }
-function createMetadataKey() {
-  return new MetadataKey();
+const MetadataReducer = {
+  list() {
+    return {
+      reduce: (acc, item) => item === undefined ? acc : [...acc, item],
+      getInitial: () => []
+    };
+  },
+  min() {
+    return {
+      reduce: (acc, item) => {
+        if (acc === undefined || item === undefined) {
+          return acc ?? item;
+        }
+        return Math.min(acc, item);
+      },
+      getInitial: () => undefined
+    };
+  },
+  max() {
+    return {
+      reduce: (prev, next) => {
+        if (prev === undefined || next === undefined) {
+          return prev ?? next;
+        }
+        return Math.max(prev, next);
+      },
+      getInitial: () => undefined
+    };
+  },
+  or() {
+    return {
+      reduce: (prev, next) => prev || next,
+      getInitial: () => false
+    };
+  },
+  and() {
+    return {
+      reduce: (prev, next) => prev && next,
+      getInitial: () => true
+    };
+  },
+  override
+};
+function override(getInitial) {
+  return {
+    reduce: (_, item) => item,
+    getInitial: () => getInitial?.()
+  };
 }
-class AggregateMetadataKey {
-  reduce;
-  getInitial;
+class MetadataKey {
+  reducer;
+  create;
   brand;
-  constructor(reduce, getInitial) {
-    this.reduce = reduce;
-    this.getInitial = getInitial;
+  constructor(reducer, create) {
+    this.reducer = reducer;
+    this.create = create;
   }
 }
-function reducedMetadataKey(reduce, getInitial) {
-  return new AggregateMetadataKey(reduce, getInitial);
+function createMetadataKey(reducer) {
+  return new MetadataKey(reducer ?? MetadataReducer.override());
 }
-function listMetadataKey() {
-  return reducedMetadataKey((acc, item) => item === undefined ? acc : [...acc, item], () => []);
+function createManagedMetadataKey(create, reducer) {
+  return new MetadataKey(reducer ?? MetadataReducer.override(), create);
+}
+const REQUIRED = createMetadataKey(MetadataReducer.or());
+const MIN = createMetadataKey(MetadataReducer.max());
+const MAX = createMetadataKey(MetadataReducer.min());
+const MIN_LENGTH = createMetadataKey(MetadataReducer.max());
+const MAX_LENGTH = createMetadataKey(MetadataReducer.min());
+const PATTERN = createMetadataKey(MetadataReducer.list());
+
+function calculateValidationSelfStatus(state) {
+  if (state.errors().length > 0) {
+    return 'invalid';
+  }
+  if (state.pending()) {
+    return 'unknown';
+  }
+  return 'valid';
 }
-function minMetadataKey() {
-  return reducedMetadataKey((prev, next) => {
-    if (prev === undefined) {
-      return next;
+class FieldValidationState {
+  node;
+  constructor(node) {
+    this.node = node;
+  }
+  rawSyncTreeErrors = computed(() => {
+    if (this.shouldSkipValidation()) {
+      return [];
     }
-    if (next === undefined) {
-      return prev;
+    return [...this.node.logicNode.logic.syncTreeErrors.compute(this.node.context), ...(this.node.structure.parent?.validationState.rawSyncTreeErrors() ?? [])];
+  }, ...(ngDevMode ? [{
+    debugName: "rawSyncTreeErrors"
+  }] : []));
+  syncErrors = computed(() => {
+    if (this.shouldSkipValidation()) {
+      return [];
     }
-    return Math.min(prev, next);
-  }, () => undefined);
-}
-function maxMetadataKey() {
-  return reducedMetadataKey((prev, next) => {
-    if (prev === undefined) {
-      return next;
+    return [...this.node.logicNode.logic.syncErrors.compute(this.node.context), ...this.syncTreeErrors(), ...normalizeErrors(this.node.submitState.serverErrors())];
+  }, ...(ngDevMode ? [{
+    debugName: "syncErrors"
+  }] : []));
+  syncValid = computed(() => {
+    if (this.shouldSkipValidation()) {
+      return true;
     }
-    if (next === undefined) {
-      return prev;
+    return this.node.structure.reduceChildren(this.syncErrors().length === 0, (child, value) => value && child.validationState.syncValid(), shortCircuitFalse);
+  }, ...(ngDevMode ? [{
+    debugName: "syncValid"
+  }] : []));
+  syncTreeErrors = computed(() => this.rawSyncTreeErrors().filter(err => err.field === this.node.fieldProxy), ...(ngDevMode ? [{
+    debugName: "syncTreeErrors"
+  }] : []));
+  rawAsyncErrors = computed(() => {
+    if (this.shouldSkipValidation()) {
+      return [];
     }
-    return Math.max(prev, next);
-  }, () => undefined);
+    return [...this.node.logicNode.logic.asyncErrors.compute(this.node.context), ...(this.node.structure.parent?.validationState.rawAsyncErrors() ?? [])];
+  }, ...(ngDevMode ? [{
+    debugName: "rawAsyncErrors"
+  }] : []));
+  asyncErrors = computed(() => {
+    if (this.shouldSkipValidation()) {
+      return [];
+    }
+    return this.rawAsyncErrors().filter(err => err === 'pending' || err.field === this.node.fieldProxy);
+  }, ...(ngDevMode ? [{
+    debugName: "asyncErrors"
+  }] : []));
+  errors = computed(() => [...this.syncErrors(), ...this.asyncErrors().filter(err => err !== 'pending')], ...(ngDevMode ? [{
+    debugName: "errors"
+  }] : []));
+  errorSummary = computed(() => this.node.structure.reduceChildren(this.errors(), (child, result) => [...result, ...child.errorSummary()]), ...(ngDevMode ? [{
+    debugName: "errorSummary"
+  }] : []));
+  pending = computed(() => this.node.structure.reduceChildren(this.asyncErrors().includes('pending'), (child, value) => value || child.validationState.asyncErrors().includes('pending')), ...(ngDevMode ? [{
+    debugName: "pending"
+  }] : []));
+  status = computed(() => {
+    if (this.shouldSkipValidation()) {
+      return 'valid';
+    }
+    let ownStatus = calculateValidationSelfStatus(this);
+    return this.node.structure.reduceChildren(ownStatus, (child, value) => {
+      if (value === 'invalid' || child.validationState.status() === 'invalid') {
+        return 'invalid';
+      } else if (value === 'unknown' || child.validationState.status() === 'unknown') {
+        return 'unknown';
+      }
+      return 'valid';
+    }, v => v === 'invalid');
+  }, ...(ngDevMode ? [{
+    debugName: "status"
+  }] : []));
+  valid = computed(() => this.status() === 'valid', ...(ngDevMode ? [{
+    debugName: "valid"
+  }] : []));
+  invalid = computed(() => this.status() === 'invalid', ...(ngDevMode ? [{
+    debugName: "invalid"
+  }] : []));
+  shouldSkipValidation = computed(() => this.node.hidden() || this.node.disabled() || this.node.readonly(), ...(ngDevMode ? [{
+    debugName: "shouldSkipValidation"
+  }] : []));
 }
-function orMetadataKey() {
-  return reducedMetadataKey((prev, next) => prev || next, () => false);
+function normalizeErrors(error) {
+  if (error === undefined) {
+    return [];
+  }
+  if (isArray(error)) {
+    return error;
+  }
+  return [error];
 }
-function andMetadataKey() {
-  return reducedMetadataKey((prev, next) => prev && next, () => true);
+function addDefaultField(errors, field) {
+  if (isArray(errors)) {
+    for (const error of errors) {
+      error.field ??= field;
+    }
+  } else if (errors) {
+    errors.field ??= field;
+  }
+  return errors;
 }
-const REQUIRED = orMetadataKey();
-const MIN = maxMetadataKey();
-const MAX = minMetadataKey();
-const MIN_LENGTH = maxMetadataKey();
-const MAX_LENGTH = minMetadataKey();
-const PATTERN = listMetadataKey();
 
-const DEBOUNCER = reducedMetadataKey((_, item) => item, () => undefined);
+const DEBOUNCER = createMetadataKey();
 
 class FieldNodeContext {
   node;
@@ -789,31 +777,28 @@ class FieldMetadataState {
   metadata = new Map();
   constructor(node) {
     this.node = node;
-    untracked(() => runInInjectionContext(this.node.structure.injector, () => {
-      for (const [key, factory] of this.node.logicNode.logic.getMetadataFactoryEntries()) {
-        this.metadata.set(key, factory(this.node.context));
+    for (const key of this.node.logicNode.logic.getMetadataKeys()) {
+      if (key.create) {
+        const logic = this.node.logicNode.logic.getMetadata(key);
+        const result = untracked(() => runInInjectionContext(this.node.structure.injector, () => key.create(computed(() => logic.compute(this.node.context)))));
+        this.metadata.set(key, result);
       }
-    }));
+    }
   }
   get(key) {
-    if (key instanceof MetadataKey) {
-      return this.metadata.get(key);
-    }
-    if (!this.metadata.has(key)) {
-      const logic = this.node.logicNode.logic.getAggregateMetadata(key);
-      const result = computed(() => logic.compute(this.node.context), ...(ngDevMode ? [{
-        debugName: "result"
-      }] : []));
-      this.metadata.set(key, result);
+    if (this.has(key)) {
+      if (!this.metadata.has(key)) {
+        if (key.create) {
+          throw Error('Managed metadata cannot be created lazily');
+        }
+        const logic = this.node.logicNode.logic.getMetadata(key);
+        this.metadata.set(key, computed(() => logic.compute(this.node.context)));
+      }
     }
     return this.metadata.get(key);
   }
   has(key) {
-    if (key instanceof AggregateMetadataKey) {
-      return this.node.logicNode.logic.hasAggregateMetadata(key);
-    } else {
-      return this.metadata.has(key);
-    }
+    return this.node.logicNode.logic.hasMetadata(key);
   }
 }
 
@@ -830,7 +815,10 @@ const FIELD_PROXY_HANDLER = {
         return tgt.value().length;
       }
       if (p === Symbol.iterator) {
-        return Array.prototype[p];
+        return () => {
+          tgt.value();
+          return Array.prototype[Symbol.iterator].apply(tgt.fieldProxy);
+        };
       }
     }
     if (isObject(value)) {
@@ -885,6 +873,8 @@ function valueForWrite(sourceValue, newPropValue, prop) {
 
 class FieldNodeStructure {
   logic;
+  node;
+  createChildNode;
   identitySymbol = Symbol();
   _injector = undefined;
   get injector() {
@@ -894,32 +884,146 @@ class FieldNodeStructure {
     });
     return this._injector;
   }
-  constructor(logic) {
+  constructor(logic, node, createChildNode) {
     this.logic = logic;
+    this.node = node;
+    this.createChildNode = createChildNode;
   }
   children() {
-    return this.childrenMap()?.values() ?? [];
+    const map = this.childrenMap();
+    if (map === undefined) {
+      return [];
+    }
+    return Array.from(map.byPropertyKey.values()).map(child => untracked(child.reader));
   }
   getChild(key) {
+    const strKey = key.toString();
+    let reader = untracked(this.childrenMap)?.byPropertyKey.get(strKey)?.reader;
+    if (!reader) {
+      reader = this.createReader(strKey);
+    }
+    return reader();
+  }
+  reduceChildren(initialValue, fn, shortCircuit) {
     const map = this.childrenMap();
-    const value = this.value();
-    if (!map || !isObject(value)) {
-      return undefined;
+    if (!map) {
+      return initialValue;
     }
-    if (isArray(value)) {
-      const childValue = value[key];
-      if (isObject(childValue) && childValue.hasOwnProperty(this.identitySymbol)) {
-        key = childValue[this.identitySymbol];
+    let value = initialValue;
+    for (const child of map.byPropertyKey.values()) {
+      if (shortCircuit?.(value)) {
+        break;
       }
+      value = fn(untracked(child.reader), value);
     }
-    return map.get(typeof key === 'number' ? key.toString() : key);
+    return value;
   }
   destroy() {
     this.injector.destroy();
   }
+  createKeyInParent(options, identityInParent, initialKeyInParent) {
+    if (options.kind === 'root') {
+      return ROOT_KEY_IN_PARENT;
+    }
+    if (identityInParent === undefined) {
+      const key = initialKeyInParent;
+      return computed(() => {
+        if (this.parent.structure.getChild(key) !== this.node) {
+          throw new Error(`RuntimeError: orphan field, looking for property '${key}' of ${getDebugName(this.parent)}`);
+        }
+        return key;
+      });
+    } else {
+      let lastKnownKey = initialKeyInParent;
+      return computed(() => {
+        const parentValue = this.parent.structure.value();
+        if (!isArray(parentValue)) {
+          throw new Error(`RuntimeError: orphan field, expected ${getDebugName(this.parent)} to be an array`);
+        }
+        const data = parentValue[lastKnownKey];
+        if (isObject(data) && data.hasOwnProperty(this.parent.structure.identitySymbol) && data[this.parent.structure.identitySymbol] === identityInParent) {
+          return lastKnownKey;
+        }
+        for (let i = 0; i < parentValue.length; i++) {
+          const data = parentValue[i];
+          if (isObject(data) && data.hasOwnProperty(this.parent.structure.identitySymbol) && data[this.parent.structure.identitySymbol] === identityInParent) {
+            return lastKnownKey = i.toString();
+          }
+        }
+        throw new Error(`RuntimeError: orphan field, can't find element in array ${getDebugName(this.parent)}`);
+      });
+    }
+  }
+  createChildrenMap() {
+    return linkedSignal({
+      source: this.value,
+      computation: (value, previous) => {
+        if (!isObject(value)) {
+          return undefined;
+        }
+        const prevData = previous?.value ?? {
+          byPropertyKey: new Map()
+        };
+        let data;
+        const parentIsArray = isArray(value);
+        if (prevData !== undefined) {
+          if (parentIsArray) {
+            data = maybeRemoveStaleArrayFields(prevData, value, this.identitySymbol);
+          } else {
+            data = maybeRemoveStaleObjectFields(prevData, value);
+          }
+        }
+        for (const key of Object.keys(value)) {
+          let trackingKey = undefined;
+          const childValue = value[key];
+          if (childValue === undefined) {
+            if (prevData.byPropertyKey.has(key)) {
+              data ??= {
+                ...prevData
+              };
+              data.byPropertyKey.delete(key);
+            }
+            continue;
+          }
+          if (parentIsArray && isObject(childValue) && !isArray(childValue)) {
+            trackingKey = childValue[this.identitySymbol] ??= Symbol(ngDevMode ? `id:${globalId++}` : '');
+          }
+          let childNode;
+          if (trackingKey) {
+            if (!prevData.byTrackingKey?.has(trackingKey)) {
+              data ??= {
+                ...prevData
+              };
+              data.byTrackingKey ??= new Map();
+              data.byTrackingKey.set(trackingKey, this.createChildNode(key, trackingKey, parentIsArray));
+            }
+            childNode = (data ?? prevData).byTrackingKey.get(trackingKey);
+          }
+          const child = prevData.byPropertyKey.get(key);
+          if (child === undefined) {
+            data ??= {
+              ...prevData
+            };
+            data.byPropertyKey.set(key, {
+              reader: this.createReader(key),
+              node: childNode ?? this.createChildNode(key, trackingKey, parentIsArray)
+            });
+          } else if (childNode && childNode !== child.node) {
+            data ??= {
+              ...prevData
+            };
+            child.node = childNode;
+          }
+        }
+        return data ?? prevData;
+      }
+    });
+  }
+  createReader(key) {
+    return computed(() => this.childrenMap()?.byPropertyKey.get(key)?.node);
+  }
 }
 class RootFieldNodeStructure extends FieldNodeStructure {
-  node;
   fieldManager;
   value;
   get parent() {
@@ -935,15 +1039,15 @@ class RootFieldNodeStructure extends FieldNodeStructure {
     return ROOT_KEY_IN_PARENT;
   }
   childrenMap;
-  constructor(node, pathNode, logic, fieldManager, value, adapter, createChildNode) {
-    super(logic);
-    this.node = node;
+  constructor(node, logic, fieldManager, value, createChildNode) {
+    super(logic, node, createChildNode);
     this.fieldManager = fieldManager;
     this.value = value;
-    this.childrenMap = makeChildrenMapSignal(node, value, this.identitySymbol, pathNode, logic, adapter, createChildNode);
+    this.childrenMap = this.createChildrenMap();
   }
 }
 class ChildFieldNodeStructure extends FieldNodeStructure {
+  logic;
   parent;
   root;
   pathKeys;
@@ -953,47 +1057,25 @@ class ChildFieldNodeStructure extends FieldNodeStructure {
   get fieldManager() {
     return this.root.structure.fieldManager;
   }
-  constructor(node, pathNode, logic, parent, identityInParent, initialKeyInParent, adapter, createChildNode) {
-    super(logic);
+  constructor(node, logic, parent, identityInParent, initialKeyInParent, createChildNode) {
+    super(logic, node, createChildNode);
+    this.logic = logic;
     this.parent = parent;
     this.root = this.parent.structure.root;
+    this.keyInParent = this.createKeyInParent({
+      kind: 'child',
+      parent,
+      pathNode: undefined,
+      logic,
+      initialKeyInParent,
+      identityInParent,
+      fieldAdapter: undefined
+    }, identityInParent, initialKeyInParent);
     this.pathKeys = computed(() => [...parent.structure.pathKeys(), this.keyInParent()], ...(ngDevMode ? [{
       debugName: "pathKeys"
     }] : []));
-    if (identityInParent === undefined) {
-      const key = initialKeyInParent;
-      this.keyInParent = computed(() => {
-        if (parent.structure.childrenMap()?.get(key) !== node) {
-          throw new Error(`RuntimeError: orphan field, looking for property '${key}' of ${getDebugName(parent)}`);
-        }
-        return key;
-      }, ...(ngDevMode ? [{
-        debugName: "keyInParent"
-      }] : []));
-    } else {
-      let lastKnownKey = initialKeyInParent;
-      this.keyInParent = computed(() => {
-        const parentValue = parent.structure.value();
-        if (!isArray(parentValue)) {
-          throw new Error(`RuntimeError: orphan field, expected ${getDebugName(parent)} to be an array`);
-        }
-        const data = parentValue[lastKnownKey];
-        if (isObject(data) && data.hasOwnProperty(parent.structure.identitySymbol) && data[parent.structure.identitySymbol] === identityInParent) {
-          return lastKnownKey;
-        }
-        for (let i = 0; i < parentValue.length; i++) {
-          const data = parentValue[i];
-          if (isObject(data) && data.hasOwnProperty(parent.structure.identitySymbol) && data[parent.structure.identitySymbol] === identityInParent) {
-            return lastKnownKey = i.toString();
-          }
-        }
-        throw new Error(`RuntimeError: orphan field, can't find element in array ${getDebugName(parent)}`);
-      }, ...(ngDevMode ? [{
-        debugName: "keyInParent"
-      }] : []));
-    }
     this.value = deepSignal(this.parent.structure.value, this.keyInParent);
-    this.childrenMap = makeChildrenMapSignal(node, this.value, this.identitySymbol, pathNode, logic, adapter, createChildNode);
+    this.childrenMap = this.createChildrenMap();
     this.fieldManager.structures.add(this);
   }
 }
@@ -1006,80 +1088,50 @@ const ROOT_KEY_IN_PARENT = computed(() => {
 }, ...(ngDevMode ? [{
   debugName: "ROOT_KEY_IN_PARENT"
 }] : []));
-function makeChildrenMapSignal(node, valueSignal, identitySymbol, pathNode, logic, adapter, createChildNode) {
-  return linkedSignal({
-    source: valueSignal,
-    computation: (value, previous) => {
-      let childrenMap = previous?.value;
-      if (!isObject(value)) {
-        return undefined;
-      }
-      const isValueArray = isArray(value);
-      if (childrenMap !== undefined) {
-        let oldKeys = undefined;
-        if (isValueArray) {
-          oldKeys = new Set(childrenMap.keys());
-          for (let i = 0; i < value.length; i++) {
-            const childValue = value[i];
-            if (isObject(childValue) && childValue.hasOwnProperty(identitySymbol)) {
-              oldKeys.delete(childValue[identitySymbol]);
-            } else {
-              oldKeys.delete(i.toString());
-            }
-          }
-          for (const key of oldKeys) {
-            childrenMap.delete(key);
-          }
-        } else {
-          for (let key of childrenMap.keys()) {
-            if (!value.hasOwnProperty(key)) {
-              childrenMap.delete(key);
-            }
-          }
-        }
-      }
-      for (let key of Object.keys(value)) {
-        let trackingId = undefined;
-        const childValue = value[key];
-        if (childValue === undefined) {
-          childrenMap?.delete(key);
-          continue;
-        }
-        if (isValueArray && isObject(childValue) && !isArray(childValue)) {
-          trackingId = childValue[identitySymbol] ??= Symbol(ngDevMode ? `id:${globalId++}` : '');
-        }
-        const identity = trackingId ?? key;
-        if (childrenMap?.has(identity)) {
-          continue;
-        }
-        let childPath;
-        let childLogic;
-        if (isValueArray) {
-          childPath = pathNode.getChild(DYNAMIC);
-          childLogic = logic.getChild(DYNAMIC);
-        } else {
-          childPath = pathNode.getChild(key);
-          childLogic = logic.getChild(key);
-        }
-        childrenMap ??= new Map();
-        childrenMap.set(identity, createChildNode({
-          kind: 'child',
-          parent: node,
-          pathNode: childPath,
-          logic: childLogic,
-          initialKeyInParent: key,
-          identityInParent: trackingId,
-          fieldAdapter: adapter
-        }));
-      }
-      return childrenMap;
-    },
-    equal: () => false
-  });
-}
 function getDebugName(node) {
   return `<root>.${node.structure.pathKeys().join('.')}`;
 }
+function maybeRemoveStaleArrayFields(prevData, value, identitySymbol) {
+  let data;
+  const oldKeys = new Set(prevData.byPropertyKey.keys());
+  const oldTracking = new Set(prevData.byTrackingKey?.keys());
+  for (let i = 0; i < value.length; i++) {
+    const childValue = value[i];
+    oldKeys.delete(i.toString());
+    if (isObject(childValue) && childValue.hasOwnProperty(identitySymbol)) {
+      oldTracking.delete(childValue[identitySymbol]);
+    }
+  }
+  if (oldKeys.size > 0) {
+    data ??= {
+      ...prevData
+    };
+    for (const key of oldKeys) {
+      data.byPropertyKey.delete(key);
+    }
+  }
+  if (oldTracking.size > 0) {
+    data ??= {
+      ...prevData
+    };
+    for (const id of oldTracking) {
+      data.byTrackingKey?.delete(id);
+    }
+  }
+  return data;
+}
+function maybeRemoveStaleObjectFields(prevData, value) {
+  let data;
+  for (const key of prevData.byPropertyKey.keys()) {
+    if (!value.hasOwnProperty(key)) {
+      data ??= {
+        ...prevData
+      };
+      data.byPropertyKey.delete(key);
+    }
+  }
+  return data;
+}
 
 class FieldSubmitState {
   node;
@@ -1116,7 +1168,9 @@ class FieldNode {
     return this._context ??= new FieldNodeContext(this);
   }
   fieldProxy = new Proxy(() => this, FIELD_PROXY_HANDLER);
+  pathNode;
   constructor(options) {
+    this.pathNode = options.pathNode;
     this.fieldAdapter = options.fieldAdapter;
     this.structure = this.fieldAdapter.createStructure(this, options);
     this.validationState = this.fieldAdapter.createValidationState(this, options);
@@ -1191,26 +1245,23 @@ class FieldNode {
   get name() {
     return this.nodeState.name;
   }
-  metadataOrUndefined(key) {
-    return this.hasMetadata(key) ? this.metadata(key) : undefined;
-  }
   get max() {
-    return this.metadataOrUndefined(MAX);
+    return this.metadata(MAX);
   }
   get maxLength() {
-    return this.metadataOrUndefined(MAX_LENGTH);
+    return this.metadata(MAX_LENGTH);
   }
   get min() {
-    return this.metadataOrUndefined(MIN);
+    return this.metadata(MIN);
   }
   get minLength() {
-    return this.metadataOrUndefined(MIN_LENGTH);
+    return this.metadata(MIN_LENGTH);
   }
   get pattern() {
-    return this.metadataOrUndefined(PATTERN) ?? EMPTY;
+    return this.metadata(PATTERN) ?? EMPTY;
   }
   get required() {
-    return this.metadataOrUndefined(REQUIRED) ?? FALSE;
+    return this.metadata(REQUIRED) ?? FALSE;
   }
   metadata(key) {
     return this.metadataState.get(key);
@@ -1230,7 +1281,7 @@ class FieldNode {
     untracked(() => this._reset(value));
   }
   _reset(value) {
-    if (value) {
+    if (value !== undefined) {
       this.value.set(value);
     }
     this.nodeState.markAsUntouched();
@@ -1266,11 +1317,28 @@ class FieldNode {
   static newRoot(fieldManager, value, pathNode, adapter) {
     return adapter.newRoot(fieldManager, value, pathNode, adapter);
   }
-  static newChild(options) {
-    return options.fieldAdapter.newChild(options);
-  }
   createStructure(options) {
-    return options.kind === 'root' ? new RootFieldNodeStructure(this, options.pathNode, options.logic, options.fieldManager, options.value, options.fieldAdapter, FieldNode.newChild) : new ChildFieldNodeStructure(this, options.pathNode, options.logic, options.parent, options.identityInParent, options.initialKeyInParent, options.fieldAdapter, FieldNode.newChild);
+    return options.kind === 'root' ? new RootFieldNodeStructure(this, options.logic, options.fieldManager, options.value, this.newChild.bind(this)) : new ChildFieldNodeStructure(this, options.logic, options.parent, options.identityInParent, options.initialKeyInParent, this.newChild.bind(this));
+  }
+  newChild(key, trackingId, isArray) {
+    let childPath;
+    let childLogic;
+    if (isArray) {
+      childPath = this.pathNode.getChild(DYNAMIC);
+      childLogic = this.structure.logic.getChild(DYNAMIC);
+    } else {
+      childPath = this.pathNode.getChild(key);
+      childLogic = this.structure.logic.getChild(key);
+    }
+    return this.fieldAdapter.newChild({
+      kind: 'child',
+      parent: this,
+      pathNode: childPath,
+      logic: childLogic,
+      initialKeyInParent: key,
+      identityInParent: trackingId,
+      fieldAdapter: this.fieldAdapter
+    });
   }
 }
 const EMPTY = computed(() => [], ...(ngDevMode ? [{
@@ -1308,13 +1376,13 @@ class FieldNodeState {
   }
   dirty = computed(() => {
     const selfDirtyValue = this.selfDirty() && !this.isNonInteractive();
-    return reduceChildren(this.node, selfDirtyValue, (child, value) => value || child.nodeState.dirty(), shortCircuitTrue);
+    return this.node.structure.reduceChildren(selfDirtyValue, (child, value) => value || child.nodeState.dirty(), shortCircuitTrue);
   }, ...(ngDevMode ? [{
     debugName: "dirty"
   }] : []));
   touched = computed(() => {
     const selfTouchedValue = this.selfTouched() && !this.isNonInteractive();
-    return reduceChildren(this.node, selfTouchedValue, (child, value) => value || child.nodeState.touched(), shortCircuitTrue);
+    return this.node.structure.reduceChildren(selfTouchedValue, (child, value) => value || child.nodeState.touched(), shortCircuitTrue);
   }, ...(ngDevMode ? [{
     debugName: "touched"
   }] : []));
@@ -1340,8 +1408,8 @@ class FieldNodeState {
     debugName: "name"
   }] : []));
   debouncer = computed(() => {
-    if (this.node.logicNode.logic.hasAggregateMetadata(DEBOUNCER)) {
-      const debouncerLogic = this.node.logicNode.logic.getAggregateMetadata(DEBOUNCER);
+    if (this.node.logicNode.logic.hasMetadata(DEBOUNCER)) {
+      const debouncerLogic = this.node.logicNode.logic.getMetadata(DEBOUNCER);
       const debouncer = debouncerLogic.compute(this.node.context);
       if (debouncer) {
         return signal => debouncer(this.node.context, signal);
@@ -1506,5 +1574,5 @@ function markAllAsTouched(node) {
   }
 }
 
-export { AggregateMetadataKey, BasicFieldAdapter, DEBOUNCER, FieldNode, FieldNodeState, FieldNodeStructure, FieldPathNode, MAX, MAX_LENGTH, MIN, MIN_LENGTH, MetadataKey, PATTERN, REQUIRED, addDefaultField, andMetadataKey, apply, applyEach, applyWhen, applyWhenValue, assertPathIsCurrent, calculateValidationSelfStatus, createMetadataKey, form, getInjectorFromOptions, isArray, listMetadataKey, maxMetadataKey, minMetadataKey, normalizeFormArgs, orMetadataKey, reducedMetadataKey, schema, submit };
+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, isArray, metadata, normalizeFormArgs, schema, submit };
 //# sourceMappingURL=_structure-chunk.mjs.map