Class LeafLogicNode

packages/forms/signals/src/schema/logic_node.ts:346–411

* A tree structure of `Logic` corresponding to a tree of fields. * This implementation represents a leaf in the sense that its logic is derived * from a single builder.

 * from a single builder.
 */
class LeafLogicNode implements LogicNode {
  /** The computed logic for this node. */
  readonly logic: LogicContainer;

  /**
   * Constructs a `LeafLogicNode`.
   * @param builder The `AbstractLogicNodeBuilder` from which to derive the logic.
   *   If undefined, an empty `Logic` instance is created.
   * @param predicates An array of predicates that gate the logic from the builder.
   */
  constructor(
    private builder: AbstractLogicNodeBuilder | undefined,
    private predicates: BoundPredicate[],
    /** The depth of this node in the field tree. */
    private depth: number,
  ) {
    this.logic = builder ? createLogic(builder, predicates, depth) : new LogicContainer([]);
  }

  // TODO: cache here, or just rely on the user of this API to do caching?
  /**
   * Retrieves the `LogicNode` for a child identified by the given property key.
   * @param key The property key of the child.
   * @returns The `LogicNode` for the specified child.
   */
  getChild(key: PropertyKey): LogicNode {
    // The logic for a particular child may be spread across multiple builders. We lazily combine
    // this logic at the time the child logic node is requested to be created.
    const childBuilders = this.builder ? getAllChildBuilders(this.builder, key) : [];
    if (childBuilders.length === 0) {
      return new LeafLogicNode(undefined, [], this.depth + 1);
    } else if (childBuilders.length === 1) {
      const {builder, predicates} = childBuilders[0];
      return new LeafLogicNode(
        builder,
        [...this.predicates, ...predicates.map((p) => bindLevel(p, this.depth))],
        this.depth + 1,
      );
    } else {
      const builtNodes = childBuilders.map(
        ({builder, predicates}) =>
          new LeafLogicNode(
            builder,
            [...this.predicates, ...predicates.map((p) => bindLevel(p, this.depth))],
            this.depth + 1,
          ),
      );
      return new CompositeLogicNode(builtNodes);
    }
  }

  hasLogic(builder: AbstractLogicNodeBuilder): boolean {
    if (!this.builder) {
      return false;
    }
    return this.builder.hasLogic(builder);
  }