Function computeChildrenMap

packages/forms/signals/src/field/structure.ts:301–417

(
    value: unknown,
    prevData: ChildrenData | undefined,
    forceMaterialize: boolean,
  )

  }

  private computeChildrenMap(
    value: unknown,
    prevData: ChildrenData | undefined,
    forceMaterialize: boolean,
  ): ChildrenData | undefined {
    if (!isObject(value)) {
      // Non-object values have no children. This short-circuit path makes `childrenMap` fast
      // for primitive-valued fields.
      return undefined;
    }

    // Determine if we actually need to materialize children right now.
    // If not forced, and NO child has any logic rules, we can safely return `undefined`
    // to keep instantiation lazy. However, if `prevData` is already defined, we MUST
    // NOT return `undefined` or we will orphan the already instantiated children.
    if (!forceMaterialize && prevData === undefined) {
      // Check if any child of this field has logic rules. This check only needs to run once per
      // structure since the presence of schema logic rules is static across value changes.
      if (!(this._anyChildHasLogic ??= this.logic.anyChildHasLogic())) {
        return undefined;
      }
    }

    // Previous `ChildrenData` (immutable). This is also where we first initialize our map if
    // needed.
    prevData ??= {
      byPropertyKey: new Map(),
    };

    // The next `ChildrenData` object to be returned. Initialized lazily when we know there's
    // been a structural change to the model.
    let materializedChildren: MutableChildrenData | undefined;

    const parentIsArray = isArray(value);

    // Remove fields that have disappeared since the last time this map was computed.
    if (prevData !== undefined) {
      if (parentIsArray) {
        materializedChildren = maybeRemoveStaleArrayFields(prevData, value, this.identitySymbol);
      } else {
        materializedChildren = maybeRemoveStaleObjectFields(prevData, value);
      }
    }

    // Now, go through the values and add any new ones.
    for (const key of Object.keys(value)) {
      let trackingKey: TrackingKey | undefined = undefined;
      const childValue = value[key] as unknown;

      // Fields explicitly set to `undefined` are treated as if they don't exist.
      // This ensures that `{value: undefined}` and `{}` have the same behavior for their `value`
      // field.
      if (childValue === undefined) {
        // The value might have _become_ `undefined`, so we need to delete it here.
        if (prevData.byPropertyKey.has(key)) {
          materializedChildren ??= {...(prevData as MutableChildrenData)};
          materializedChildren.byPropertyKey.delete(key);
        }