Class CompositeLogicNode

packages/forms/signals/src/schema/logic_node.ts:418–460

* A `LogicNode` that represents the composition of multiple `LogicNode` instances. * This is used when logic for a particular path is contributed by several distinct * builder branches that need to be merged.

 * builder branches that need to be merged.
 */
class CompositeLogicNode implements LogicNode {
  /** The merged logic from all composed nodes. */
  readonly logic: LogicContainer;

  /**
   * Constructs a `CompositeLogicNode`.
   * @param all An array of `LogicNode` instances to compose.
   */
  constructor(private all: LogicNode[]) {
    this.logic = new LogicContainer([]);
    for (const node of all) {
      this.logic.mergeIn(node.logic);
    }
  }

  /**
   * Retrieves the child `LogicNode` by composing the results of `getChild` from all
   * underlying `LogicNode` instances.
   * @param key The property key of the child.
   * @returns A `CompositeLogicNode` representing the composed child.
   */
  getChild(key: PropertyKey): LogicNode {
    return new CompositeLogicNode(this.all.flatMap((child) => child.getChild(key)));
  }

  /**
   * Checks whether the logic from a particular `AbstractLogicNodeBuilder` has been merged into this
   * node.
   * @param builder The builder to check for.
   * @returns True if the builder has been merged, false otherwise.
   */
  hasLogic(builder: AbstractLogicNodeBuilder): boolean {
    return this.all.some((node) => node.hasLogic(builder));
  }

  hasRules(): boolean {
    return this.all.some((node) => node.hasRules());
  }

  anyChildHasLogic(): boolean {
    return this.all.some((child) => child.anyChildHasLogic());
  }
}

/**
 * Gets all of the builders that contribute logic to the given child of the parent builder.