ConstTransform a single node (Typed) pre-order, the dual of this.transformObjectPreOrder with the same type specification as this.transformNode: a node is transformed before its descendants, and we iterate into the result of that transformation. This is what you want when a node has to travel deeper into the tree: the callback only describes how a node swaps places with the node right below it, the copy it sank into is dispatched in turn, and swaps places with the node below that one.
Contrary to this.transformNode, a callback does not just return the value taking the place of the node, it returns a PreOrderMappingReturn: that value, plus the TransformContext of that value. Since the callback decides what we iterate into, it is the one telling us how to iterate into it, so there is no separate preVisitor - it only completes the per type defaults of this transformer, which are looked up using the type of the node it was called on. A node without a callback is left alone: it keeps those defaults, but is never re-transformed.
Also contrary to this.transformNode, the descendants of the node given to the callback are not transformed yet: they are the nodes of the input tree itself.
the object from which we will start the transformation, potentially visiting and transforming its descendants along the way.
a dictionary mapping the various node types to a mapper. The mapper allows you to manipulate the copy of the current node, and expects you to return the value that should take the current nodes place, together with the context of that value. That context steers how we iterate into the returned value.
the result of transforming the startObject and the descendants of its rewrites.
the object from which we will start the transformation, potentially visiting and transforming its descendants along the way.
a dictionary mapping the various operation types to a mapper. The mapper allows you to manipulate the copy of the current operation, and expects you to return the value that should take the current operations place, together with the context of that value. That context steers how we iterate into the returned value.
Transform a single operation pre-order, the dual of mapOperation: an operation is mapped before its descendants, and we iterate into the result of that mapping. This is what you want for an operation that has to travel deeper into the tree, like a filter pushdown: the callback only describes how the filter swaps places with the operation right below it, and the filters it sank into are mapped in turn. e.g. sinking a filter into every branch of the unions below it:
Contrary to mapOperation, a callback returns the value taking the place of the operation together with the TransformContext of that value, so there is no separate preVisitor. The descendants of the operation it is called on are not mapped yet either - they are the operations of the input tree itself - so changing the properties of a descendant writes straight into that tree. Both are documented in detail on TransformerTyped.transformNodePreOrder.