Method resolve

packages/forms/signals/src/field/context.ts:67–113

* Resolves a target path relative to this context. * @param target The path to resolve * @returns The field corresponding to the target path.

(target: SchemaPath<U, SchemaPathRules>)

   * @returns The field corresponding to the target path.
   */
  private resolve<U>(target: SchemaPath<U, SchemaPathRules>): ReadonlyFieldTree<U> {
    if (!this.cache.has(target)) {
      const resolver = computed<ReadonlyFieldTree<unknown>>(() => {
        const targetPathNode = FieldPathNode.unwrapFieldPath(target);

        // First, find the field where the root our target path was merged in.
        // We determine this by walking up the field tree from the current field and looking for
        // the place where the LogicNodeBuilder from the target path's root was merged in.
        // We always make sure to walk up at least as far as the depth of the path we were bound to.
        // This ensures that we do not accidentally match on the wrong application of a recursively
        // applied schema.
        let field: FieldNode | undefined = this.node;
        let stepsRemaining = getBoundPathDepth();
        while (stepsRemaining > 0 || !field.structure.logic.hasLogic(targetPathNode.root.builder)) {
          stepsRemaining--;
          field = field.structure.parent;
          if (field === undefined) {
            throw new RuntimeError(
              RuntimeErrorCode.PATH_NOT_IN_FIELD_TREE,
              ngDevMode && 'Path is not part of this field tree.',
            );
          }
        }

        // Now, we can navigate to the target field using the relative path in the target path node
        // to traverse down from the field we just found.
        for (let key of targetPathNode.keys) {
          field = field.structure.getChild(key);
          if (field === undefined) {
            throw new RuntimeError(
              RuntimeErrorCode.PATH_RESOLUTION_FAILED,
              ngDevMode &&
                `Cannot resolve path .${targetPathNode.keys.join('.')} relative to field ${[
                  '<root>',
                  ...this.node.structure.pathKeys(),
                ].join('.')}.`,
            );
          }
        }

        return field.fieldTree;
      });

      this.cache.set(target, resolver);
    }
    return this.cache.get(target)!() as ReadonlyFieldTree<U>;
  }

  get fieldTree(): ReadonlyFieldTree<unknown> {
    return this.node.fieldProxy;