Class AstTransformer

Hierarchy (View Summary)

TransformerSubTyped<Sparql11Nodes>
- AstTransformer

Index

Constructors

constructor

new AstTransformer(
defaultContext?: TransformContext,
defaultNodePreVisitor?: DefaultNodePreVisitor<Sparql11Nodes>,
): AstTransformer
Parameters
- OptionaldefaultContext: TransformContext
- OptionaldefaultNodePreVisitor: DefaultNodePreVisitor<Sparql11Nodes>
Returns AstTransformer
Inherited from TransformerSubTyped.constructor
- Defined in core/dist/esm/lib/transformers/TransformerSubTyped.d.ts:6

Properties

`Protected` `Readonly`defaultContext

defaultContext: TransformContext

`Protected`defaultNodePreVisitor

defaultNodePreVisitor: DefaultNodePreVisitor<Nodes>

`Protected`maxStackSize

maxStackSize: number

Methods

clone

clone(
newDefaultContext?: TransformContext,
newDefaultNodePreVisitor?: DefaultNodePreVisitor<Sparql11Nodes>,
): TransformerSubTyped<Sparql11Nodes>
Parameters
- OptionalnewDefaultContext: TransformContext
- OptionalnewDefaultNodePreVisitor: DefaultNodePreVisitor<Sparql11Nodes>
Returns TransformerSubTyped<Sparql11Nodes>
Inherited from TransformerSubTyped.clone
- Defined in core/dist/esm/lib/transformers/TransformerSubTyped.d.ts:7

`Protected`cloneObj

cloneObj<T>(obj: T): T
Protected
Function to shallow clone any type.
Type Parameters
- T
Parameters
- obj: T
Returns T
Inherited from TransformerSubTyped.cloneObj
- Defined in core/dist/esm/lib/transformers/TransformerObject.d.ts:50

transformNode

transformNode<Safe extends Safeness = "safe", OutType = unknown>(
    startObject: object,
    nodeCallBacks: {
        contextDef?: {
            preVisitor?: (
                orig: ContextDefinitionPrefix | ContextDefinitionBase,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<Safe, ContextDefinitionPrefix | ContextDefinitionBase>,
                orig: ContextDefinitionPrefix | ContextDefinitionBase,
            ) => unknown;
        };
        datasetClauses?: {
            preVisitor?: (orig: DatasetClauses) => TransformContext;
            transform?: (
                copy: SafeWrap<Safe, DatasetClauses>,
                orig: DatasetClauses,
            ) => unknown;
        };
        expression?: {
            preVisitor?: (
                orig:
                    | ExpressionOperation
                    | ExpressionPatternOperation
                    | ExpressionFunctionCall
                    | ExpressionAggregateDefault
                    | ExpressionAggregateOnWildcard
                    | ExpressionAggregateSeparator,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    | ExpressionOperation
                    | ExpressionPatternOperation
                    | ExpressionFunctionCall
                    | ExpressionAggregateDefault
                    | ExpressionAggregateOnWildcard
                    | ExpressionAggregateSeparator,
                >,
                orig:
                    | ExpressionOperation
                    | ExpressionPatternOperation
                    | ExpressionFunctionCall
                    | ExpressionAggregateDefault
                    | ExpressionAggregateOnWildcard
                    | ExpressionAggregateSeparator,
            ) => unknown;
        };
        graph?: {
            preVisitor?: (orig: GraphQuads) => TransformContext;
            transform?: (
                copy: SafeWrap<Safe, GraphQuads>,
                orig: GraphQuads,
            ) => unknown;
        };
        graphRef?: {
            preVisitor?: (
                orig:
                    | GraphRefDefault
                    | GraphRefNamed
                    | GraphRefAll
                    | GraphRefSpecific,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    GraphRefDefault
                    | GraphRefNamed
                    | GraphRefAll
                    | GraphRefSpecific,
                >,
                orig: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
            ) => unknown;
        };
        path?: {
            preVisitor?: (
                orig: PropertyPathChain | PathModified | PathNegated,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<Safe, PropertyPathChain | PathModified | PathNegated>,
                orig: PropertyPathChain | PathModified | PathNegated,
            ) => unknown;
        };
        pattern?: {
            preVisitor?: (
                orig:
                    | PatternBgp
                    | PatternGroup
                    | PatternUnion
                    | PatternOptional
                    | PatternMinus
                    | PatternGraph
                    | PatternService
                    | PatternFilter
                    | PatternBind
                    | PatternValues,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    | PatternBgp
                    | PatternGroup
                    | PatternUnion
                    | PatternOptional
                    | PatternMinus
                    | PatternGraph
                    | PatternService
                    | PatternFilter
                    | PatternBind
                    | PatternValues,
                >,
                orig:
                    | PatternBgp
                    | PatternGroup
                    | PatternUnion
                    | PatternOptional
                    | PatternMinus
                    | PatternGraph
                    | PatternService
                    | PatternFilter
                    | PatternBind
                    | PatternValues,
            ) => unknown;
        };
        query?: {
            preVisitor?: (
                orig: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    QuerySelect
                    | QueryConstruct
                    | QueryDescribe
                    | QueryAsk,
                >,
                orig: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
            ) => unknown;
        };
        solutionModifier?: {
            preVisitor?: (
                orig:
                    | SolutionModifierGroup
                    | SolutionModifierHaving
                    | SolutionModifierOrder
                    | SolutionModifierLimitOffset,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    | SolutionModifierGroup
                    | SolutionModifierHaving
                    | SolutionModifierOrder
                    | SolutionModifierLimitOffset,
                >,
                orig:
                    | SolutionModifierGroup
                    | SolutionModifierHaving
                    | SolutionModifierOrder
                    | SolutionModifierLimitOffset,
            ) => unknown;
        };
        term?: {
            preVisitor?: (
                orig:
                    | TermIriFull
                    | TermIriPrefixed
                    | TermVariable
                    | TermLiteralStr
                    | TermLiteralLangStr
                    | TermLiteralTyped
                    | TermBlank,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    | TermIriFull
                    | TermIriPrefixed
                    | TermVariable
                    | TermLiteralStr
                    | TermLiteralLangStr
                    | TermLiteralTyped
                    | TermBlank,
                >,
                orig:
                    | TermIriFull
                    | TermIriPrefixed
                    | TermVariable
                    | TermLiteralStr
                    | TermLiteralLangStr
                    | TermLiteralTyped
                    | TermBlank,
            ) => unknown;
        };
        triple?: {
            preVisitor?: (orig: TripleNesting) => TransformContext;
            transform?: (
                copy: SafeWrap<Safe, TripleNesting>,
                orig: TripleNesting,
            ) => unknown;
        };
        tripleCollection?: {
            preVisitor?: (
                orig: TripleCollectionList | TripleCollectionBlankNodeProperties,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    TripleCollectionList
                    | TripleCollectionBlankNodeProperties,
                >,
                orig: TripleCollectionList | TripleCollectionBlankNodeProperties,
            ) => unknown;
        };
        update?: {
            preVisitor?: (orig: Update) => TransformContext;
            transform?: (copy: SafeWrap<Safe, Update>, orig: Update) => unknown;
        };
        updateOperation?: {
            preVisitor?: (
                orig:
                    | UpdateOperationLoad
                    | UpdateOperationClear
                    | UpdateOperationDrop
                    | UpdateOperationCreate
                    | UpdateOperationAdd
                    | UpdateOperationMove
                    | UpdateOperationCopy
                    | UpdateOperationInsertData
                    | UpdateOperationDeleteData
                    | UpdateOperationDeleteWhere
                    | UpdateOperationModify,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    | UpdateOperationLoad
                    | UpdateOperationClear
                    | UpdateOperationDrop
                    | UpdateOperationCreate
                    | UpdateOperationAdd
                    | UpdateOperationMove
                    | UpdateOperationCopy
                    | UpdateOperationInsertData
                    | UpdateOperationDeleteData
                    | UpdateOperationDeleteWhere
                    | UpdateOperationModify,
                >,
                orig:
                    | UpdateOperationLoad
                    | UpdateOperationClear
                    | UpdateOperationDrop
                    | UpdateOperationCreate
                    | UpdateOperationAdd
                    | UpdateOperationMove
                    | UpdateOperationCopy
                    | UpdateOperationInsertData
                    | UpdateOperationDeleteData
                    | UpdateOperationDeleteWhere
                    | UpdateOperationModify,
            ) => unknown;
        };
        wildcard?: {
            preVisitor?: (orig: Wildcard) => TransformContext;
            transform?: (copy: SafeWrap<Safe, Wildcard>, orig: Wildcard) => unknown;
        };
    },
): Safe extends "unsafe" ? OutType : unknown
Transform a single node (Typed).
Type Parameters
- Safe extends Safeness = "safe"
- OutType = unknown
Parameters
- startObject: object
  the object from which we will start the transformation, potentially visiting and transforming its descendants along the way.
- nodeCallBacks: {
      contextDef?: {
          preVisitor?: (
              orig: ContextDefinitionPrefix | ContextDefinitionBase,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<Safe, ContextDefinitionPrefix | ContextDefinitionBase>,
              orig: ContextDefinitionPrefix | ContextDefinitionBase,
          ) => unknown;
      };
      datasetClauses?: {
          preVisitor?: (orig: DatasetClauses) => TransformContext;
          transform?: (
              copy: SafeWrap<Safe, DatasetClauses>,
              orig: DatasetClauses,
          ) => unknown;
      };
      expression?: {
          preVisitor?: (
              orig:
                  | ExpressionOperation
                  | ExpressionPatternOperation
                  | ExpressionFunctionCall
                  | ExpressionAggregateDefault
                  | ExpressionAggregateOnWildcard
                  | ExpressionAggregateSeparator,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  | ExpressionOperation
                  | ExpressionPatternOperation
                  | ExpressionFunctionCall
                  | ExpressionAggregateDefault
                  | ExpressionAggregateOnWildcard
                  | ExpressionAggregateSeparator,
              >,
              orig:
                  | ExpressionOperation
                  | ExpressionPatternOperation
                  | ExpressionFunctionCall
                  | ExpressionAggregateDefault
                  | ExpressionAggregateOnWildcard
                  | ExpressionAggregateSeparator,
          ) => unknown;
      };
      graph?: {
          preVisitor?: (orig: GraphQuads) => TransformContext;
          transform?: (
              copy: SafeWrap<Safe, GraphQuads>,
              orig: GraphQuads,
          ) => unknown;
      };
      graphRef?: {
          preVisitor?: (
              orig: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  GraphRefDefault
                  | GraphRefNamed
                  | GraphRefAll
                  | GraphRefSpecific,
              >,
              orig: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
          ) => unknown;
      };
      path?: {
          preVisitor?: (
              orig: PropertyPathChain | PathModified | PathNegated,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<Safe, PropertyPathChain | PathModified | PathNegated>,
              orig: PropertyPathChain | PathModified | PathNegated,
          ) => unknown;
      };
      pattern?: {
          preVisitor?: (
              orig:
                  | PatternBgp
                  | PatternGroup
                  | PatternUnion
                  | PatternOptional
                  | PatternMinus
                  | PatternGraph
                  | PatternService
                  | PatternFilter
                  | PatternBind
                  | PatternValues,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  | PatternBgp
                  | PatternGroup
                  | PatternUnion
                  | PatternOptional
                  | PatternMinus
                  | PatternGraph
                  | PatternService
                  | PatternFilter
                  | PatternBind
                  | PatternValues,
              >,
              orig:
                  | PatternBgp
                  | PatternGroup
                  | PatternUnion
                  | PatternOptional
                  | PatternMinus
                  | PatternGraph
                  | PatternService
                  | PatternFilter
                  | PatternBind
                  | PatternValues,
          ) => unknown;
      };
      query?: {
          preVisitor?: (
              orig: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  QuerySelect
                  | QueryConstruct
                  | QueryDescribe
                  | QueryAsk,
              >,
              orig: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
          ) => unknown;
      };
      solutionModifier?: {
          preVisitor?: (
              orig:
                  | SolutionModifierGroup
                  | SolutionModifierHaving
                  | SolutionModifierOrder
                  | SolutionModifierLimitOffset,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  | SolutionModifierGroup
                  | SolutionModifierHaving
                  | SolutionModifierOrder
                  | SolutionModifierLimitOffset,
              >,
              orig:
                  | SolutionModifierGroup
                  | SolutionModifierHaving
                  | SolutionModifierOrder
                  | SolutionModifierLimitOffset,
          ) => unknown;
      };
      term?: {
          preVisitor?: (
              orig:
                  | TermIriFull
                  | TermIriPrefixed
                  | TermVariable
                  | TermLiteralStr
                  | TermLiteralLangStr
                  | TermLiteralTyped
                  | TermBlank,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  | TermIriFull
                  | TermIriPrefixed
                  | TermVariable
                  | TermLiteralStr
                  | TermLiteralLangStr
                  | TermLiteralTyped
                  | TermBlank,
              >,
              orig:
                  | TermIriFull
                  | TermIriPrefixed
                  | TermVariable
                  | TermLiteralStr
                  | TermLiteralLangStr
                  | TermLiteralTyped
                  | TermBlank,
          ) => unknown;
      };
      triple?: {
          preVisitor?: (orig: TripleNesting) => TransformContext;
          transform?: (
              copy: SafeWrap<Safe, TripleNesting>,
              orig: TripleNesting,
          ) => unknown;
      };
      tripleCollection?: {
          preVisitor?: (
              orig: TripleCollectionList | TripleCollectionBlankNodeProperties,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  TripleCollectionList
                  | TripleCollectionBlankNodeProperties,
              >,
              orig: TripleCollectionList | TripleCollectionBlankNodeProperties,
          ) => unknown;
      };
      update?: {
          preVisitor?: (orig: Update) => TransformContext;
          transform?: (copy: SafeWrap<Safe, Update>, orig: Update) => unknown;
      };
      updateOperation?: {
          preVisitor?: (
              orig:
                  | UpdateOperationLoad
                  | UpdateOperationClear
                  | UpdateOperationDrop
                  | UpdateOperationCreate
                  | UpdateOperationAdd
                  | UpdateOperationMove
                  | UpdateOperationCopy
                  | UpdateOperationInsertData
                  | UpdateOperationDeleteData
                  | UpdateOperationDeleteWhere
                  | UpdateOperationModify,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  | UpdateOperationLoad
                  | UpdateOperationClear
                  | UpdateOperationDrop
                  | UpdateOperationCreate
                  | UpdateOperationAdd
                  | UpdateOperationMove
                  | UpdateOperationCopy
                  | UpdateOperationInsertData
                  | UpdateOperationDeleteData
                  | UpdateOperationDeleteWhere
                  | UpdateOperationModify,
              >,
              orig:
                  | UpdateOperationLoad
                  | UpdateOperationClear
                  | UpdateOperationDrop
                  | UpdateOperationCreate
                  | UpdateOperationAdd
                  | UpdateOperationMove
                  | UpdateOperationCopy
                  | UpdateOperationInsertData
                  | UpdateOperationDeleteData
                  | UpdateOperationDeleteWhere
                  | UpdateOperationModify,
          ) => unknown;
      };
      wildcard?: {
          preVisitor?: (orig: Wildcard) => TransformContext;
          transform?: (copy: SafeWrap<Safe, Wildcard>, orig: Wildcard) => unknown;
      };
  }
  a dictionary mapping the various node types to objects optionally containing preVisitor and transformer. The preVisitor allows you to provide TransformContext for the current object, altering how it will be transformed. The transformer allows you to manipulate the copy of the current object, and expects you to return the value that should take the current objects place.
Returns Safe extends "unsafe" ? OutType : unknown
the result of transforming the requested descendant operations (based on the preVisitor) using a transformer that works its way back up from the descendant to the startObject.
Inherited from TransformerSubTyped.transformNode
- Defined in core/dist/esm/lib/transformers/TransformerTyped.d.ts:28

transformNodeSpecific

transformNodeSpecific<Safe extends Safeness = "safe", OutType = unknown>(
    startObject: object,
    nodeCallBacks: {
        contextDef?: {
            preVisitor?: (
                orig: ContextDefinitionPrefix | ContextDefinitionBase,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<Safe, ContextDefinitionPrefix | ContextDefinitionBase>,
                orig: ContextDefinitionPrefix | ContextDefinitionBase,
            ) => unknown;
        };
        datasetClauses?: {
            preVisitor?: (orig: DatasetClauses) => TransformContext;
            transform?: (
                copy: SafeWrap<Safe, DatasetClauses>,
                orig: DatasetClauses,
            ) => unknown;
        };
        expression?: {
            preVisitor?: (
                orig:
                    | ExpressionOperation
                    | ExpressionPatternOperation
                    | ExpressionFunctionCall
                    | ExpressionAggregateDefault
                    | ExpressionAggregateOnWildcard
                    | ExpressionAggregateSeparator,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    | ExpressionOperation
                    | ExpressionPatternOperation
                    | ExpressionFunctionCall
                    | ExpressionAggregateDefault
                    | ExpressionAggregateOnWildcard
                    | ExpressionAggregateSeparator,
                >,
                orig:
                    | ExpressionOperation
                    | ExpressionPatternOperation
                    | ExpressionFunctionCall
                    | ExpressionAggregateDefault
                    | ExpressionAggregateOnWildcard
                    | ExpressionAggregateSeparator,
            ) => unknown;
        };
        graph?: {
            preVisitor?: (orig: GraphQuads) => TransformContext;
            transform?: (
                copy: SafeWrap<Safe, GraphQuads>,
                orig: GraphQuads,
            ) => unknown;
        };
        graphRef?: {
            preVisitor?: (
                orig:
                    | GraphRefDefault
                    | GraphRefNamed
                    | GraphRefAll
                    | GraphRefSpecific,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    GraphRefDefault
                    | GraphRefNamed
                    | GraphRefAll
                    | GraphRefSpecific,
                >,
                orig: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
            ) => unknown;
        };
        path?: {
            preVisitor?: (
                orig: PropertyPathChain | PathModified | PathNegated,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<Safe, PropertyPathChain | PathModified | PathNegated>,
                orig: PropertyPathChain | PathModified | PathNegated,
            ) => unknown;
        };
        pattern?: {
            preVisitor?: (
                orig:
                    | PatternBgp
                    | PatternGroup
                    | PatternUnion
                    | PatternOptional
                    | PatternMinus
                    | PatternGraph
                    | PatternService
                    | PatternFilter
                    | PatternBind
                    | PatternValues,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    | PatternBgp
                    | PatternGroup
                    | PatternUnion
                    | PatternOptional
                    | PatternMinus
                    | PatternGraph
                    | PatternService
                    | PatternFilter
                    | PatternBind
                    | PatternValues,
                >,
                orig:
                    | PatternBgp
                    | PatternGroup
                    | PatternUnion
                    | PatternOptional
                    | PatternMinus
                    | PatternGraph
                    | PatternService
                    | PatternFilter
                    | PatternBind
                    | PatternValues,
            ) => unknown;
        };
        query?: {
            preVisitor?: (
                orig: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    QuerySelect
                    | QueryConstruct
                    | QueryDescribe
                    | QueryAsk,
                >,
                orig: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
            ) => unknown;
        };
        solutionModifier?: {
            preVisitor?: (
                orig:
                    | SolutionModifierGroup
                    | SolutionModifierHaving
                    | SolutionModifierOrder
                    | SolutionModifierLimitOffset,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    | SolutionModifierGroup
                    | SolutionModifierHaving
                    | SolutionModifierOrder
                    | SolutionModifierLimitOffset,
                >,
                orig:
                    | SolutionModifierGroup
                    | SolutionModifierHaving
                    | SolutionModifierOrder
                    | SolutionModifierLimitOffset,
            ) => unknown;
        };
        term?: {
            preVisitor?: (
                orig:
                    | TermIriFull
                    | TermIriPrefixed
                    | TermVariable
                    | TermLiteralStr
                    | TermLiteralLangStr
                    | TermLiteralTyped
                    | TermBlank,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    | TermIriFull
                    | TermIriPrefixed
                    | TermVariable
                    | TermLiteralStr
                    | TermLiteralLangStr
                    | TermLiteralTyped
                    | TermBlank,
                >,
                orig:
                    | TermIriFull
                    | TermIriPrefixed
                    | TermVariable
                    | TermLiteralStr
                    | TermLiteralLangStr
                    | TermLiteralTyped
                    | TermBlank,
            ) => unknown;
        };
        triple?: {
            preVisitor?: (orig: TripleNesting) => TransformContext;
            transform?: (
                copy: SafeWrap<Safe, TripleNesting>,
                orig: TripleNesting,
            ) => unknown;
        };
        tripleCollection?: {
            preVisitor?: (
                orig: TripleCollectionList | TripleCollectionBlankNodeProperties,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    TripleCollectionList
                    | TripleCollectionBlankNodeProperties,
                >,
                orig: TripleCollectionList | TripleCollectionBlankNodeProperties,
            ) => unknown;
        };
        update?: {
            preVisitor?: (orig: Update) => TransformContext;
            transform?: (copy: SafeWrap<Safe, Update>, orig: Update) => unknown;
        };
        updateOperation?: {
            preVisitor?: (
                orig:
                    | UpdateOperationLoad
                    | UpdateOperationClear
                    | UpdateOperationDrop
                    | UpdateOperationCreate
                    | UpdateOperationAdd
                    | UpdateOperationMove
                    | UpdateOperationCopy
                    | UpdateOperationInsertData
                    | UpdateOperationDeleteData
                    | UpdateOperationDeleteWhere
                    | UpdateOperationModify,
            ) => TransformContext;
            transform?: (
                copy: SafeWrap<
                    Safe,
                    | UpdateOperationLoad
                    | UpdateOperationClear
                    | UpdateOperationDrop
                    | UpdateOperationCreate
                    | UpdateOperationAdd
                    | UpdateOperationMove
                    | UpdateOperationCopy
                    | UpdateOperationInsertData
                    | UpdateOperationDeleteData
                    | UpdateOperationDeleteWhere
                    | UpdateOperationModify,
                >,
                orig:
                    | UpdateOperationLoad
                    | UpdateOperationClear
                    | UpdateOperationDrop
                    | UpdateOperationCreate
                    | UpdateOperationAdd
                    | UpdateOperationMove
                    | UpdateOperationCopy
                    | UpdateOperationInsertData
                    | UpdateOperationDeleteData
                    | UpdateOperationDeleteWhere
                    | UpdateOperationModify,
            ) => unknown;
        };
        wildcard?: {
            preVisitor?: (orig: Wildcard) => TransformContext;
            transform?: (copy: SafeWrap<Safe, Wildcard>, orig: Wildcard) => unknown;
        };
    },
    nodeSpecificCallBacks: {
        contextDef?: {
            base?: {
                preVisitor?: (op: ContextDefinitionBase) => TransformContext;
                transform?: (op: SafeWrap<Safe, ContextDefinitionBase>) => unknown;
            };
            prefix?: {
                preVisitor?: (op: ContextDefinitionPrefix) => TransformContext;
                transform?: (op: SafeWrap<Safe, ContextDefinitionPrefix>) => unknown;
            };
        };
        datasetClauses?: {};
        expression?: {
            aggregate?: {
                preVisitor?: (
                    op:
                        | ExpressionAggregateDefault
                        | ExpressionAggregateOnWildcard
                        | ExpressionAggregateSeparator,
                ) => TransformContext;
                transform?: (
                    op: SafeWrap<
                        Safe,
                        | ExpressionAggregateDefault
                        | ExpressionAggregateOnWildcard
                        | ExpressionAggregateSeparator,
                    >,
                ) => unknown;
            };
            functionCall?: {
                preVisitor?: (op: ExpressionFunctionCall) => TransformContext;
                transform?: (op: SafeWrap<Safe, ExpressionFunctionCall>) => unknown;
            };
            operation?: {
                preVisitor?: (op: ExpressionOperation) => TransformContext;
                transform?: (op: SafeWrap<Safe, ExpressionOperation>) => unknown;
            };
            patternOperation?: {
                preVisitor?: (op: ExpressionPatternOperation) => TransformContext;
                transform?: (op: SafeWrap<Safe, ExpressionPatternOperation>) => unknown;
            };
        };
        graph?: {};
        graphRef?: {
            all?: {
                preVisitor?: (op: GraphRefAll) => TransformContext;
                transform?: (op: SafeWrap<Safe, GraphRefAll>) => unknown;
            };
            default?: {
                preVisitor?: (op: GraphRefDefault) => TransformContext;
                transform?: (op: SafeWrap<Safe, GraphRefDefault>) => unknown;
            };
            named?: {
                preVisitor?: (op: GraphRefNamed) => TransformContext;
                transform?: (op: SafeWrap<Safe, GraphRefNamed>) => unknown;
            };
            specific?: {
                preVisitor?: (op: GraphRefSpecific) => TransformContext;
                transform?: (op: SafeWrap<Safe, GraphRefSpecific>) => unknown;
            };
        };
        path?: {
            "!"?: {
                preVisitor?: (op: PathNegated) => TransformContext;
                transform?: (op: SafeWrap<Safe, PathNegated>) => unknown;
            };
            "?"?: {
                preVisitor?: (op: never) => TransformContext;
                transform?: (op: SafeWrap<Safe, never>) => unknown;
            };
            "*"?: {
                preVisitor?: (op: never) => TransformContext;
                transform?: (op: SafeWrap<Safe, never>) => unknown;
            };
            "/"?: {
                preVisitor?: (op: never) => TransformContext;
                transform?: (op: SafeWrap<Safe, never>) => unknown;
            };
            "^"?: {
                preVisitor?: (op: never) => TransformContext;
                transform?: (op: SafeWrap<Safe, never>) => unknown;
            };
            "+"?: {
                preVisitor?: (op: never) => TransformContext;
                transform?: (op: SafeWrap<Safe, never>) => unknown;
            };
            "|"?: {
                preVisitor?: (op: never) => TransformContext;
                transform?: (op: SafeWrap<Safe, never>) => unknown;
            };
        };
        pattern?: {
            bgp?: {
                preVisitor?: (op: PatternBgp) => TransformContext;
                transform?: (op: SafeWrap<Safe, PatternBgp>) => unknown;
            };
            bind?: {
                preVisitor?: (op: PatternBind) => TransformContext;
                transform?: (op: SafeWrap<Safe, PatternBind>) => unknown;
            };
            filter?: {
                preVisitor?: (op: PatternFilter) => TransformContext;
                transform?: (op: SafeWrap<Safe, PatternFilter>) => unknown;
            };
            graph?: {
                preVisitor?: (op: PatternGraph) => TransformContext;
                transform?: (op: SafeWrap<Safe, PatternGraph>) => unknown;
            };
            group?: {
                preVisitor?: (op: PatternGroup) => TransformContext;
                transform?: (op: SafeWrap<Safe, PatternGroup>) => unknown;
            };
            minus?: {
                preVisitor?: (op: PatternMinus) => TransformContext;
                transform?: (op: SafeWrap<Safe, PatternMinus>) => unknown;
            };
            optional?: {
                preVisitor?: (op: PatternOptional) => TransformContext;
                transform?: (op: SafeWrap<Safe, PatternOptional>) => unknown;
            };
            service?: {
                preVisitor?: (op: PatternService) => TransformContext;
                transform?: (op: SafeWrap<Safe, PatternService>) => unknown;
            };
            union?: {
                preVisitor?: (op: PatternUnion) => TransformContext;
                transform?: (op: SafeWrap<Safe, PatternUnion>) => unknown;
            };
            values?: {
                preVisitor?: (op: PatternValues) => TransformContext;
                transform?: (op: SafeWrap<Safe, PatternValues>) => unknown;
            };
        };
        query?: {
            ask?: {
                preVisitor?: (op: QueryAsk) => TransformContext;
                transform?: (op: SafeWrap<Safe, QueryAsk>) => unknown;
            };
            construct?: {
                preVisitor?: (op: QueryConstruct) => TransformContext;
                transform?: (op: SafeWrap<Safe, QueryConstruct>) => unknown;
            };
            describe?: {
                preVisitor?: (op: QueryDescribe) => TransformContext;
                transform?: (op: SafeWrap<Safe, QueryDescribe>) => unknown;
            };
            select?: {
                preVisitor?: (op: QuerySelect) => TransformContext;
                transform?: (op: SafeWrap<Safe, QuerySelect>) => unknown;
            };
        };
        solutionModifier?: {
            group?: {
                preVisitor?: (op: SolutionModifierGroup) => TransformContext;
                transform?: (op: SafeWrap<Safe, SolutionModifierGroup>) => unknown;
            };
            having?: {
                preVisitor?: (op: SolutionModifierHaving) => TransformContext;
                transform?: (op: SafeWrap<Safe, SolutionModifierHaving>) => unknown;
            };
            limitOffset?: {
                preVisitor?: (op: SolutionModifierLimitOffset) => TransformContext;
                transform?: (op: SafeWrap<Safe, SolutionModifierLimitOffset>) => unknown;
            };
            order?: {
                preVisitor?: (op: SolutionModifierOrder) => TransformContext;
                transform?: (op: SafeWrap<Safe, SolutionModifierOrder>) => unknown;
            };
        };
        term?: {
            blankNode?: {
                preVisitor?: (op: TermBlank) => TransformContext;
                transform?: (op: SafeWrap<Safe, TermBlank>) => unknown;
            };
            literal?: {
                preVisitor?: (
                    op: TermLiteralStr | TermLiteralLangStr | TermLiteralTyped,
                ) => TransformContext;
                transform?: (
                    op: SafeWrap<
                        Safe,
                        TermLiteralStr
                        | TermLiteralLangStr
                        | TermLiteralTyped,
                    >,
                ) => unknown;
            };
            namedNode?: {
                preVisitor?: (op: TermIriFull | TermIriPrefixed) => TransformContext;
                transform?: (
                    op: SafeWrap<Safe, TermIriFull | TermIriPrefixed>,
                ) => unknown;
            };
            variable?: {
                preVisitor?: (op: TermVariable) => TransformContext;
                transform?: (op: SafeWrap<Safe, TermVariable>) => unknown;
            };
        };
        triple?: {};
        tripleCollection?: {
            blankNodeProperties?: {
                preVisitor?: (
                    op: TripleCollectionBlankNodeProperties,
                ) => TransformContext;
                transform?: (
                    op: SafeWrap<Safe, TripleCollectionBlankNodeProperties>,
                ) => unknown;
            };
            list?: {
                preVisitor?: (op: TripleCollectionList) => TransformContext;
                transform?: (op: SafeWrap<Safe, TripleCollectionList>) => unknown;
            };
        };
        update?: {};
        updateOperation?: {
            add?: {
                preVisitor?: (op: UpdateOperationAdd) => TransformContext;
                transform?: (op: SafeWrap<Safe, UpdateOperationAdd>) => unknown;
            };
            clear?: {
                preVisitor?: (op: UpdateOperationClear) => TransformContext;
                transform?: (op: SafeWrap<Safe, UpdateOperationClear>) => unknown;
            };
            copy?: {
                preVisitor?: (op: UpdateOperationCopy) => TransformContext;
                transform?: (op: SafeWrap<Safe, UpdateOperationCopy>) => unknown;
            };
            create?: {
                preVisitor?: (op: UpdateOperationCreate) => TransformContext;
                transform?: (op: SafeWrap<Safe, UpdateOperationCreate>) => unknown;
            };
            deletedata?: {
                preVisitor?: (op: UpdateOperationDeleteData) => TransformContext;
                transform?: (op: SafeWrap<Safe, UpdateOperationDeleteData>) => unknown;
            };
            deletewhere?: {
                preVisitor?: (op: UpdateOperationDeleteWhere) => TransformContext;
                transform?: (op: SafeWrap<Safe, UpdateOperationDeleteWhere>) => unknown;
            };
            drop?: {
                preVisitor?: (op: UpdateOperationDrop) => TransformContext;
                transform?: (op: SafeWrap<Safe, UpdateOperationDrop>) => unknown;
            };
            insertdata?: {
                preVisitor?: (op: UpdateOperationInsertData) => TransformContext;
                transform?: (op: SafeWrap<Safe, UpdateOperationInsertData>) => unknown;
            };
            load?: {
                preVisitor?: (op: UpdateOperationLoad) => TransformContext;
                transform?: (op: SafeWrap<Safe, UpdateOperationLoad>) => unknown;
            };
            modify?: {
                preVisitor?: (op: UpdateOperationModify) => TransformContext;
                transform?: (op: SafeWrap<Safe, UpdateOperationModify>) => unknown;
            };
            move?: {
                preVisitor?: (op: UpdateOperationMove) => TransformContext;
                transform?: (op: SafeWrap<Safe, UpdateOperationMove>) => unknown;
            };
        };
        wildcard?: {};
    },
): Safe extends "unsafe" ? OutType : unknown
Transform a single node (Typed). Similar to this.transformNode but also allowing you to target the subTypes.
Type Parameters
- Safe extends Safeness = "safe"
- OutType = unknown
Parameters
- startObject: object
  the object from which we will start the transformation, potentially visiting and transforming its descendants along the way.
- nodeCallBacks: {
      contextDef?: {
          preVisitor?: (
              orig: ContextDefinitionPrefix | ContextDefinitionBase,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<Safe, ContextDefinitionPrefix | ContextDefinitionBase>,
              orig: ContextDefinitionPrefix | ContextDefinitionBase,
          ) => unknown;
      };
      datasetClauses?: {
          preVisitor?: (orig: DatasetClauses) => TransformContext;
          transform?: (
              copy: SafeWrap<Safe, DatasetClauses>,
              orig: DatasetClauses,
          ) => unknown;
      };
      expression?: {
          preVisitor?: (
              orig:
                  | ExpressionOperation
                  | ExpressionPatternOperation
                  | ExpressionFunctionCall
                  | ExpressionAggregateDefault
                  | ExpressionAggregateOnWildcard
                  | ExpressionAggregateSeparator,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  | ExpressionOperation
                  | ExpressionPatternOperation
                  | ExpressionFunctionCall
                  | ExpressionAggregateDefault
                  | ExpressionAggregateOnWildcard
                  | ExpressionAggregateSeparator,
              >,
              orig:
                  | ExpressionOperation
                  | ExpressionPatternOperation
                  | ExpressionFunctionCall
                  | ExpressionAggregateDefault
                  | ExpressionAggregateOnWildcard
                  | ExpressionAggregateSeparator,
          ) => unknown;
      };
      graph?: {
          preVisitor?: (orig: GraphQuads) => TransformContext;
          transform?: (
              copy: SafeWrap<Safe, GraphQuads>,
              orig: GraphQuads,
          ) => unknown;
      };
      graphRef?: {
          preVisitor?: (
              orig: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  GraphRefDefault
                  | GraphRefNamed
                  | GraphRefAll
                  | GraphRefSpecific,
              >,
              orig: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
          ) => unknown;
      };
      path?: {
          preVisitor?: (
              orig: PropertyPathChain | PathModified | PathNegated,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<Safe, PropertyPathChain | PathModified | PathNegated>,
              orig: PropertyPathChain | PathModified | PathNegated,
          ) => unknown;
      };
      pattern?: {
          preVisitor?: (
              orig:
                  | PatternBgp
                  | PatternGroup
                  | PatternUnion
                  | PatternOptional
                  | PatternMinus
                  | PatternGraph
                  | PatternService
                  | PatternFilter
                  | PatternBind
                  | PatternValues,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  | PatternBgp
                  | PatternGroup
                  | PatternUnion
                  | PatternOptional
                  | PatternMinus
                  | PatternGraph
                  | PatternService
                  | PatternFilter
                  | PatternBind
                  | PatternValues,
              >,
              orig:
                  | PatternBgp
                  | PatternGroup
                  | PatternUnion
                  | PatternOptional
                  | PatternMinus
                  | PatternGraph
                  | PatternService
                  | PatternFilter
                  | PatternBind
                  | PatternValues,
          ) => unknown;
      };
      query?: {
          preVisitor?: (
              orig: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  QuerySelect
                  | QueryConstruct
                  | QueryDescribe
                  | QueryAsk,
              >,
              orig: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
          ) => unknown;
      };
      solutionModifier?: {
          preVisitor?: (
              orig:
                  | SolutionModifierGroup
                  | SolutionModifierHaving
                  | SolutionModifierOrder
                  | SolutionModifierLimitOffset,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  | SolutionModifierGroup
                  | SolutionModifierHaving
                  | SolutionModifierOrder
                  | SolutionModifierLimitOffset,
              >,
              orig:
                  | SolutionModifierGroup
                  | SolutionModifierHaving
                  | SolutionModifierOrder
                  | SolutionModifierLimitOffset,
          ) => unknown;
      };
      term?: {
          preVisitor?: (
              orig:
                  | TermIriFull
                  | TermIriPrefixed
                  | TermVariable
                  | TermLiteralStr
                  | TermLiteralLangStr
                  | TermLiteralTyped
                  | TermBlank,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  | TermIriFull
                  | TermIriPrefixed
                  | TermVariable
                  | TermLiteralStr
                  | TermLiteralLangStr
                  | TermLiteralTyped
                  | TermBlank,
              >,
              orig:
                  | TermIriFull
                  | TermIriPrefixed
                  | TermVariable
                  | TermLiteralStr
                  | TermLiteralLangStr
                  | TermLiteralTyped
                  | TermBlank,
          ) => unknown;
      };
      triple?: {
          preVisitor?: (orig: TripleNesting) => TransformContext;
          transform?: (
              copy: SafeWrap<Safe, TripleNesting>,
              orig: TripleNesting,
          ) => unknown;
      };
      tripleCollection?: {
          preVisitor?: (
              orig: TripleCollectionList | TripleCollectionBlankNodeProperties,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  TripleCollectionList
                  | TripleCollectionBlankNodeProperties,
              >,
              orig: TripleCollectionList | TripleCollectionBlankNodeProperties,
          ) => unknown;
      };
      update?: {
          preVisitor?: (orig: Update) => TransformContext;
          transform?: (copy: SafeWrap<Safe, Update>, orig: Update) => unknown;
      };
      updateOperation?: {
          preVisitor?: (
              orig:
                  | UpdateOperationLoad
                  | UpdateOperationClear
                  | UpdateOperationDrop
                  | UpdateOperationCreate
                  | UpdateOperationAdd
                  | UpdateOperationMove
                  | UpdateOperationCopy
                  | UpdateOperationInsertData
                  | UpdateOperationDeleteData
                  | UpdateOperationDeleteWhere
                  | UpdateOperationModify,
          ) => TransformContext;
          transform?: (
              copy: SafeWrap<
                  Safe,
                  | UpdateOperationLoad
                  | UpdateOperationClear
                  | UpdateOperationDrop
                  | UpdateOperationCreate
                  | UpdateOperationAdd
                  | UpdateOperationMove
                  | UpdateOperationCopy
                  | UpdateOperationInsertData
                  | UpdateOperationDeleteData
                  | UpdateOperationDeleteWhere
                  | UpdateOperationModify,
              >,
              orig:
                  | UpdateOperationLoad
                  | UpdateOperationClear
                  | UpdateOperationDrop
                  | UpdateOperationCreate
                  | UpdateOperationAdd
                  | UpdateOperationMove
                  | UpdateOperationCopy
                  | UpdateOperationInsertData
                  | UpdateOperationDeleteData
                  | UpdateOperationDeleteWhere
                  | UpdateOperationModify,
          ) => unknown;
      };
      wildcard?: {
          preVisitor?: (orig: Wildcard) => TransformContext;
          transform?: (copy: SafeWrap<Safe, Wildcard>, orig: Wildcard) => unknown;
      };
  }
  a dictionary mapping the various operation types to objects optionally containing preVisitor and transformer. The preVisitor allows you to provide TransformContext for the current object, altering how it will be transformed. The transformer allows you to manipulate the copy of the current object, and expects you to return the value that should take the current objects place.
- nodeSpecificCallBacks: {
      contextDef?: {
          base?: {
              preVisitor?: (op: ContextDefinitionBase) => TransformContext;
              transform?: (op: SafeWrap<Safe, ContextDefinitionBase>) => unknown;
          };
          prefix?: {
              preVisitor?: (op: ContextDefinitionPrefix) => TransformContext;
              transform?: (op: SafeWrap<Safe, ContextDefinitionPrefix>) => unknown;
          };
      };
      datasetClauses?: {};
      expression?: {
          aggregate?: {
              preVisitor?: (
                  op:
                      | ExpressionAggregateDefault
                      | ExpressionAggregateOnWildcard
                      | ExpressionAggregateSeparator,
              ) => TransformContext;
              transform?: (
                  op: SafeWrap<
                      Safe,
                      | ExpressionAggregateDefault
                      | ExpressionAggregateOnWildcard
                      | ExpressionAggregateSeparator,
                  >,
              ) => unknown;
          };
          functionCall?: {
              preVisitor?: (op: ExpressionFunctionCall) => TransformContext;
              transform?: (op: SafeWrap<Safe, ExpressionFunctionCall>) => unknown;
          };
          operation?: {
              preVisitor?: (op: ExpressionOperation) => TransformContext;
              transform?: (op: SafeWrap<Safe, ExpressionOperation>) => unknown;
          };
          patternOperation?: {
              preVisitor?: (op: ExpressionPatternOperation) => TransformContext;
              transform?: (op: SafeWrap<Safe, ExpressionPatternOperation>) => unknown;
          };
      };
      graph?: {};
      graphRef?: {
          all?: {
              preVisitor?: (op: GraphRefAll) => TransformContext;
              transform?: (op: SafeWrap<Safe, GraphRefAll>) => unknown;
          };
          default?: {
              preVisitor?: (op: GraphRefDefault) => TransformContext;
              transform?: (op: SafeWrap<Safe, GraphRefDefault>) => unknown;
          };
          named?: {
              preVisitor?: (op: GraphRefNamed) => TransformContext;
              transform?: (op: SafeWrap<Safe, GraphRefNamed>) => unknown;
          };
          specific?: {
              preVisitor?: (op: GraphRefSpecific) => TransformContext;
              transform?: (op: SafeWrap<Safe, GraphRefSpecific>) => unknown;
          };
      };
      path?: {
          "!"?: {
              preVisitor?: (op: PathNegated) => TransformContext;
              transform?: (op: SafeWrap<Safe, PathNegated>) => unknown;
          };
          "?"?: {
              preVisitor?: (op: never) => TransformContext;
              transform?: (op: SafeWrap<Safe, never>) => unknown;
          };
          "*"?: {
              preVisitor?: (op: never) => TransformContext;
              transform?: (op: SafeWrap<Safe, never>) => unknown;
          };
          "/"?: {
              preVisitor?: (op: never) => TransformContext;
              transform?: (op: SafeWrap<Safe, never>) => unknown;
          };
          "^"?: {
              preVisitor?: (op: never) => TransformContext;
              transform?: (op: SafeWrap<Safe, never>) => unknown;
          };
          "+"?: {
              preVisitor?: (op: never) => TransformContext;
              transform?: (op: SafeWrap<Safe, never>) => unknown;
          };
          "|"?: {
              preVisitor?: (op: never) => TransformContext;
              transform?: (op: SafeWrap<Safe, never>) => unknown;
          };
      };
      pattern?: {
          bgp?: {
              preVisitor?: (op: PatternBgp) => TransformContext;
              transform?: (op: SafeWrap<Safe, PatternBgp>) => unknown;
          };
          bind?: {
              preVisitor?: (op: PatternBind) => TransformContext;
              transform?: (op: SafeWrap<Safe, PatternBind>) => unknown;
          };
          filter?: {
              preVisitor?: (op: PatternFilter) => TransformContext;
              transform?: (op: SafeWrap<Safe, PatternFilter>) => unknown;
          };
          graph?: {
              preVisitor?: (op: PatternGraph) => TransformContext;
              transform?: (op: SafeWrap<Safe, PatternGraph>) => unknown;
          };
          group?: {
              preVisitor?: (op: PatternGroup) => TransformContext;
              transform?: (op: SafeWrap<Safe, PatternGroup>) => unknown;
          };
          minus?: {
              preVisitor?: (op: PatternMinus) => TransformContext;
              transform?: (op: SafeWrap<Safe, PatternMinus>) => unknown;
          };
          optional?: {
              preVisitor?: (op: PatternOptional) => TransformContext;
              transform?: (op: SafeWrap<Safe, PatternOptional>) => unknown;
          };
          service?: {
              preVisitor?: (op: PatternService) => TransformContext;
              transform?: (op: SafeWrap<Safe, PatternService>) => unknown;
          };
          union?: {
              preVisitor?: (op: PatternUnion) => TransformContext;
              transform?: (op: SafeWrap<Safe, PatternUnion>) => unknown;
          };
          values?: {
              preVisitor?: (op: PatternValues) => TransformContext;
              transform?: (op: SafeWrap<Safe, PatternValues>) => unknown;
          };
      };
      query?: {
          ask?: {
              preVisitor?: (op: QueryAsk) => TransformContext;
              transform?: (op: SafeWrap<Safe, QueryAsk>) => unknown;
          };
          construct?: {
              preVisitor?: (op: QueryConstruct) => TransformContext;
              transform?: (op: SafeWrap<Safe, QueryConstruct>) => unknown;
          };
          describe?: {
              preVisitor?: (op: QueryDescribe) => TransformContext;
              transform?: (op: SafeWrap<Safe, QueryDescribe>) => unknown;
          };
          select?: {
              preVisitor?: (op: QuerySelect) => TransformContext;
              transform?: (op: SafeWrap<Safe, QuerySelect>) => unknown;
          };
      };
      solutionModifier?: {
          group?: {
              preVisitor?: (op: SolutionModifierGroup) => TransformContext;
              transform?: (op: SafeWrap<Safe, SolutionModifierGroup>) => unknown;
          };
          having?: {
              preVisitor?: (op: SolutionModifierHaving) => TransformContext;
              transform?: (op: SafeWrap<Safe, SolutionModifierHaving>) => unknown;
          };
          limitOffset?: {
              preVisitor?: (op: SolutionModifierLimitOffset) => TransformContext;
              transform?: (op: SafeWrap<Safe, SolutionModifierLimitOffset>) => unknown;
          };
          order?: {
              preVisitor?: (op: SolutionModifierOrder) => TransformContext;
              transform?: (op: SafeWrap<Safe, SolutionModifierOrder>) => unknown;
          };
      };
      term?: {
          blankNode?: {
              preVisitor?: (op: TermBlank) => TransformContext;
              transform?: (op: SafeWrap<Safe, TermBlank>) => unknown;
          };
          literal?: {
              preVisitor?: (
                  op: TermLiteralStr | TermLiteralLangStr | TermLiteralTyped,
              ) => TransformContext;
              transform?: (
                  op: SafeWrap<
                      Safe,
                      TermLiteralStr
                      | TermLiteralLangStr
                      | TermLiteralTyped,
                  >,
              ) => unknown;
          };
          namedNode?: {
              preVisitor?: (op: TermIriFull | TermIriPrefixed) => TransformContext;
              transform?: (
                  op: SafeWrap<Safe, TermIriFull | TermIriPrefixed>,
              ) => unknown;
          };
          variable?: {
              preVisitor?: (op: TermVariable) => TransformContext;
              transform?: (op: SafeWrap<Safe, TermVariable>) => unknown;
          };
      };
      triple?: {};
      tripleCollection?: {
          blankNodeProperties?: {
              preVisitor?: (
                  op: TripleCollectionBlankNodeProperties,
              ) => TransformContext;
              transform?: (
                  op: SafeWrap<Safe, TripleCollectionBlankNodeProperties>,
              ) => unknown;
          };
          list?: {
              preVisitor?: (op: TripleCollectionList) => TransformContext;
              transform?: (op: SafeWrap<Safe, TripleCollectionList>) => unknown;
          };
      };
      update?: {};
      updateOperation?: {
          add?: {
              preVisitor?: (op: UpdateOperationAdd) => TransformContext;
              transform?: (op: SafeWrap<Safe, UpdateOperationAdd>) => unknown;
          };
          clear?: {
              preVisitor?: (op: UpdateOperationClear) => TransformContext;
              transform?: (op: SafeWrap<Safe, UpdateOperationClear>) => unknown;
          };
          copy?: {
              preVisitor?: (op: UpdateOperationCopy) => TransformContext;
              transform?: (op: SafeWrap<Safe, UpdateOperationCopy>) => unknown;
          };
          create?: {
              preVisitor?: (op: UpdateOperationCreate) => TransformContext;
              transform?: (op: SafeWrap<Safe, UpdateOperationCreate>) => unknown;
          };
          deletedata?: {
              preVisitor?: (op: UpdateOperationDeleteData) => TransformContext;
              transform?: (op: SafeWrap<Safe, UpdateOperationDeleteData>) => unknown;
          };
          deletewhere?: {
              preVisitor?: (op: UpdateOperationDeleteWhere) => TransformContext;
              transform?: (op: SafeWrap<Safe, UpdateOperationDeleteWhere>) => unknown;
          };
          drop?: {
              preVisitor?: (op: UpdateOperationDrop) => TransformContext;
              transform?: (op: SafeWrap<Safe, UpdateOperationDrop>) => unknown;
          };
          insertdata?: {
              preVisitor?: (op: UpdateOperationInsertData) => TransformContext;
              transform?: (op: SafeWrap<Safe, UpdateOperationInsertData>) => unknown;
          };
          load?: {
              preVisitor?: (op: UpdateOperationLoad) => TransformContext;
              transform?: (op: SafeWrap<Safe, UpdateOperationLoad>) => unknown;
          };
          modify?: {
              preVisitor?: (op: UpdateOperationModify) => TransformContext;
              transform?: (op: SafeWrap<Safe, UpdateOperationModify>) => unknown;
          };
          move?: {
              preVisitor?: (op: UpdateOperationMove) => TransformContext;
              transform?: (op: SafeWrap<Safe, UpdateOperationMove>) => unknown;
          };
      };
      wildcard?: {};
  }
  Same as nodeCallBacks but using an additional level of indirection to indicate the subType.
Returns Safe extends "unsafe" ? OutType : unknown
the result of transforming the requested descendant operations (based on the preVisitor) using a transformer that works its way back up from the descendant to the startObject.
Inherited from TransformerSubTyped.transformNodeSpecific
- Defined in core/dist/esm/lib/transformers/TransformerSubTyped.d.ts:24

transformObject

transformObject(
    startObject: object,
    mapper: (copy: object, orig: object) => unknown,
    preVisitor?: (orig: object) => TransformContext,
): unknown
Recursively transforms all objects that are not arrays. Mapper is called on deeper objects first.
Parameters
- startObject: object
  object to start iterating from
- mapper: (copy: object, orig: object) => unknown
  mapper to transform the various objects - argument is a copy of the original
- OptionalpreVisitor: (orig: object) => TransformContext
  callback that is evaluated before iterating deeper. If continues is false, we do not iterate deeper, current object is still mapped. - default: true If shortcut is true, we do not iterate deeper, nor do we branch out, this mapper will be the last one called.
  
  Default false
Returns unknown
Inherited from TransformerSubTyped.transformObject
- Defined in core/dist/esm/lib/transformers/TransformerObject.d.ts:60

visitNode

visitNode(
    startObject: object,
    nodeCallBacks: {
        contextDef?: {
            preVisitor?: (
                op: ContextDefinitionPrefix | ContextDefinitionBase,
            ) => VisitContext;
            visitor?: (op: ContextDefinitionPrefix | ContextDefinitionBase) => void;
        };
        datasetClauses?: {
            preVisitor?: (op: DatasetClauses) => VisitContext;
            visitor?: (op: DatasetClauses) => void;
        };
        expression?: {
            preVisitor?: (
                op:
                    | ExpressionOperation
                    | ExpressionPatternOperation
                    | ExpressionFunctionCall
                    | ExpressionAggregateDefault
                    | ExpressionAggregateOnWildcard
                    | ExpressionAggregateSeparator,
            ) => VisitContext;
            visitor?: (
                op:
                    | ExpressionOperation
                    | ExpressionPatternOperation
                    | ExpressionFunctionCall
                    | ExpressionAggregateDefault
                    | ExpressionAggregateOnWildcard
                    | ExpressionAggregateSeparator,
            ) => void;
        };
        graph?: {
            preVisitor?: (op: GraphQuads) => VisitContext;
            visitor?: (op: GraphQuads) => void;
        };
        graphRef?: {
            preVisitor?: (
                op: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
            ) => VisitContext;
            visitor?: (
                op: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
            ) => void;
        };
        path?: {
            preVisitor?: (
                op: PropertyPathChain | PathModified | PathNegated,
            ) => VisitContext;
            visitor?: (op: PropertyPathChain | PathModified | PathNegated) => void;
        };
        pattern?: {
            preVisitor?: (
                op:
                    | PatternBgp
                    | PatternGroup
                    | PatternUnion
                    | PatternOptional
                    | PatternMinus
                    | PatternGraph
                    | PatternService
                    | PatternFilter
                    | PatternBind
                    | PatternValues,
            ) => VisitContext;
            visitor?: (
                op:
                    | PatternBgp
                    | PatternGroup
                    | PatternUnion
                    | PatternOptional
                    | PatternMinus
                    | PatternGraph
                    | PatternService
                    | PatternFilter
                    | PatternBind
                    | PatternValues,
            ) => void;
        };
        query?: {
            preVisitor?: (
                op: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
            ) => VisitContext;
            visitor?: (
                op: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
            ) => void;
        };
        solutionModifier?: {
            preVisitor?: (
                op:
                    | SolutionModifierGroup
                    | SolutionModifierHaving
                    | SolutionModifierOrder
                    | SolutionModifierLimitOffset,
            ) => VisitContext;
            visitor?: (
                op:
                    | SolutionModifierGroup
                    | SolutionModifierHaving
                    | SolutionModifierOrder
                    | SolutionModifierLimitOffset,
            ) => void;
        };
        term?: {
            preVisitor?: (
                op:
                    | TermIriFull
                    | TermIriPrefixed
                    | TermVariable
                    | TermLiteralStr
                    | TermLiteralLangStr
                    | TermLiteralTyped
                    | TermBlank,
            ) => VisitContext;
            visitor?: (
                op:
                    | TermIriFull
                    | TermIriPrefixed
                    | TermVariable
                    | TermLiteralStr
                    | TermLiteralLangStr
                    | TermLiteralTyped
                    | TermBlank,
            ) => void;
        };
        triple?: {
            preVisitor?: (op: TripleNesting) => VisitContext;
            visitor?: (op: TripleNesting) => void;
        };
        tripleCollection?: {
            preVisitor?: (
                op: TripleCollectionList | TripleCollectionBlankNodeProperties,
            ) => VisitContext;
            visitor?: (
                op: TripleCollectionList | TripleCollectionBlankNodeProperties,
            ) => void;
        };
        update?: {
            preVisitor?: (op: Update) => VisitContext;
            visitor?: (op: Update) => void;
        };
        updateOperation?: {
            preVisitor?: (
                op:
                    | UpdateOperationLoad
                    | UpdateOperationClear
                    | UpdateOperationDrop
                    | UpdateOperationCreate
                    | UpdateOperationAdd
                    | UpdateOperationMove
                    | UpdateOperationCopy
                    | UpdateOperationInsertData
                    | UpdateOperationDeleteData
                    | UpdateOperationDeleteWhere
                    | UpdateOperationModify,
            ) => VisitContext;
            visitor?: (
                op:
                    | UpdateOperationLoad
                    | UpdateOperationClear
                    | UpdateOperationDrop
                    | UpdateOperationCreate
                    | UpdateOperationAdd
                    | UpdateOperationMove
                    | UpdateOperationCopy
                    | UpdateOperationInsertData
                    | UpdateOperationDeleteData
                    | UpdateOperationDeleteWhere
                    | UpdateOperationModify,
            ) => void;
        };
        wildcard?: {
            preVisitor?: (op: Wildcard) => VisitContext;
            visitor?: (op: Wildcard) => void;
        };
    },
): void
Visit a selected subTree given a startObject, steering the visits based on Typed nodes. Will first call the preVisitor on the project and notice it should not iterate on its descendants. It then visits the project, and the outermost distinct, printing '21'. The pre-visitor visits starting from the root, going deeper, while the actual visitor goes in reverse.
Parameters
- startObject: object
  the object from which we will start visiting, potentially visiting its descendants along the way.
- nodeCallBacks: {
      contextDef?: {
          preVisitor?: (
              op: ContextDefinitionPrefix | ContextDefinitionBase,
          ) => VisitContext;
          visitor?: (op: ContextDefinitionPrefix | ContextDefinitionBase) => void;
      };
      datasetClauses?: {
          preVisitor?: (op: DatasetClauses) => VisitContext;
          visitor?: (op: DatasetClauses) => void;
      };
      expression?: {
          preVisitor?: (
              op:
                  | ExpressionOperation
                  | ExpressionPatternOperation
                  | ExpressionFunctionCall
                  | ExpressionAggregateDefault
                  | ExpressionAggregateOnWildcard
                  | ExpressionAggregateSeparator,
          ) => VisitContext;
          visitor?: (
              op:
                  | ExpressionOperation
                  | ExpressionPatternOperation
                  | ExpressionFunctionCall
                  | ExpressionAggregateDefault
                  | ExpressionAggregateOnWildcard
                  | ExpressionAggregateSeparator,
          ) => void;
      };
      graph?: {
          preVisitor?: (op: GraphQuads) => VisitContext;
          visitor?: (op: GraphQuads) => void;
      };
      graphRef?: {
          preVisitor?: (
              op: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
          ) => VisitContext;
          visitor?: (
              op: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
          ) => void;
      };
      path?: {
          preVisitor?: (
              op: PropertyPathChain | PathModified | PathNegated,
          ) => VisitContext;
          visitor?: (op: PropertyPathChain | PathModified | PathNegated) => void;
      };
      pattern?: {
          preVisitor?: (
              op:
                  | PatternBgp
                  | PatternGroup
                  | PatternUnion
                  | PatternOptional
                  | PatternMinus
                  | PatternGraph
                  | PatternService
                  | PatternFilter
                  | PatternBind
                  | PatternValues,
          ) => VisitContext;
          visitor?: (
              op:
                  | PatternBgp
                  | PatternGroup
                  | PatternUnion
                  | PatternOptional
                  | PatternMinus
                  | PatternGraph
                  | PatternService
                  | PatternFilter
                  | PatternBind
                  | PatternValues,
          ) => void;
      };
      query?: {
          preVisitor?: (
              op: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
          ) => VisitContext;
          visitor?: (
              op: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
          ) => void;
      };
      solutionModifier?: {
          preVisitor?: (
              op:
                  | SolutionModifierGroup
                  | SolutionModifierHaving
                  | SolutionModifierOrder
                  | SolutionModifierLimitOffset,
          ) => VisitContext;
          visitor?: (
              op:
                  | SolutionModifierGroup
                  | SolutionModifierHaving
                  | SolutionModifierOrder
                  | SolutionModifierLimitOffset,
          ) => void;
      };
      term?: {
          preVisitor?: (
              op:
                  | TermIriFull
                  | TermIriPrefixed
                  | TermVariable
                  | TermLiteralStr
                  | TermLiteralLangStr
                  | TermLiteralTyped
                  | TermBlank,
          ) => VisitContext;
          visitor?: (
              op:
                  | TermIriFull
                  | TermIriPrefixed
                  | TermVariable
                  | TermLiteralStr
                  | TermLiteralLangStr
                  | TermLiteralTyped
                  | TermBlank,
          ) => void;
      };
      triple?: {
          preVisitor?: (op: TripleNesting) => VisitContext;
          visitor?: (op: TripleNesting) => void;
      };
      tripleCollection?: {
          preVisitor?: (
              op: TripleCollectionList | TripleCollectionBlankNodeProperties,
          ) => VisitContext;
          visitor?: (
              op: TripleCollectionList | TripleCollectionBlankNodeProperties,
          ) => void;
      };
      update?: {
          preVisitor?: (op: Update) => VisitContext;
          visitor?: (op: Update) => void;
      };
      updateOperation?: {
          preVisitor?: (
              op:
                  | UpdateOperationLoad
                  | UpdateOperationClear
                  | UpdateOperationDrop
                  | UpdateOperationCreate
                  | UpdateOperationAdd
                  | UpdateOperationMove
                  | UpdateOperationCopy
                  | UpdateOperationInsertData
                  | UpdateOperationDeleteData
                  | UpdateOperationDeleteWhere
                  | UpdateOperationModify,
          ) => VisitContext;
          visitor?: (
              op:
                  | UpdateOperationLoad
                  | UpdateOperationClear
                  | UpdateOperationDrop
                  | UpdateOperationCreate
                  | UpdateOperationAdd
                  | UpdateOperationMove
                  | UpdateOperationCopy
                  | UpdateOperationInsertData
                  | UpdateOperationDeleteData
                  | UpdateOperationDeleteWhere
                  | UpdateOperationModify,
          ) => void;
      };
      wildcard?: {
          preVisitor?: (op: Wildcard) => VisitContext;
          visitor?: (op: Wildcard) => void;
      };
  }
  a dictionary mapping the various operation types to objects optionally containing preVisitor and visitor. The preVisitor allows you to provide VisitContext for the current object, altering how it will be visited. The visitor allows you to visit the object from deepest to the outermost object. This is useful if you for example want to manipulate the objects you visit during your visits, similar to this.transformNode.
Returns void
Inherited from TransformerSubTyped.visitNode
- Defined in core/dist/esm/lib/transformers/TransformerTyped.d.ts:49

visitNodeSpecific

visitNodeSpecific(
    startObject: object,
    nodeCallBacks: {
        contextDef?: {
            preVisitor?: (
                op: ContextDefinitionPrefix | ContextDefinitionBase,
            ) => VisitContext;
            visitor?: (op: ContextDefinitionPrefix | ContextDefinitionBase) => void;
        };
        datasetClauses?: {
            preVisitor?: (op: DatasetClauses) => VisitContext;
            visitor?: (op: DatasetClauses) => void;
        };
        expression?: {
            preVisitor?: (
                op:
                    | ExpressionOperation
                    | ExpressionPatternOperation
                    | ExpressionFunctionCall
                    | ExpressionAggregateDefault
                    | ExpressionAggregateOnWildcard
                    | ExpressionAggregateSeparator,
            ) => VisitContext;
            visitor?: (
                op:
                    | ExpressionOperation
                    | ExpressionPatternOperation
                    | ExpressionFunctionCall
                    | ExpressionAggregateDefault
                    | ExpressionAggregateOnWildcard
                    | ExpressionAggregateSeparator,
            ) => void;
        };
        graph?: {
            preVisitor?: (op: GraphQuads) => VisitContext;
            visitor?: (op: GraphQuads) => void;
        };
        graphRef?: {
            preVisitor?: (
                op: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
            ) => VisitContext;
            visitor?: (
                op: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
            ) => void;
        };
        path?: {
            preVisitor?: (
                op: PropertyPathChain | PathModified | PathNegated,
            ) => VisitContext;
            visitor?: (op: PropertyPathChain | PathModified | PathNegated) => void;
        };
        pattern?: {
            preVisitor?: (
                op:
                    | PatternBgp
                    | PatternGroup
                    | PatternUnion
                    | PatternOptional
                    | PatternMinus
                    | PatternGraph
                    | PatternService
                    | PatternFilter
                    | PatternBind
                    | PatternValues,
            ) => VisitContext;
            visitor?: (
                op:
                    | PatternBgp
                    | PatternGroup
                    | PatternUnion
                    | PatternOptional
                    | PatternMinus
                    | PatternGraph
                    | PatternService
                    | PatternFilter
                    | PatternBind
                    | PatternValues,
            ) => void;
        };
        query?: {
            preVisitor?: (
                op: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
            ) => VisitContext;
            visitor?: (
                op: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
            ) => void;
        };
        solutionModifier?: {
            preVisitor?: (
                op:
                    | SolutionModifierGroup
                    | SolutionModifierHaving
                    | SolutionModifierOrder
                    | SolutionModifierLimitOffset,
            ) => VisitContext;
            visitor?: (
                op:
                    | SolutionModifierGroup
                    | SolutionModifierHaving
                    | SolutionModifierOrder
                    | SolutionModifierLimitOffset,
            ) => void;
        };
        term?: {
            preVisitor?: (
                op:
                    | TermIriFull
                    | TermIriPrefixed
                    | TermVariable
                    | TermLiteralStr
                    | TermLiteralLangStr
                    | TermLiteralTyped
                    | TermBlank,
            ) => VisitContext;
            visitor?: (
                op:
                    | TermIriFull
                    | TermIriPrefixed
                    | TermVariable
                    | TermLiteralStr
                    | TermLiteralLangStr
                    | TermLiteralTyped
                    | TermBlank,
            ) => void;
        };
        triple?: {
            preVisitor?: (op: TripleNesting) => VisitContext;
            visitor?: (op: TripleNesting) => void;
        };
        tripleCollection?: {
            preVisitor?: (
                op: TripleCollectionList | TripleCollectionBlankNodeProperties,
            ) => VisitContext;
            visitor?: (
                op: TripleCollectionList | TripleCollectionBlankNodeProperties,
            ) => void;
        };
        update?: {
            preVisitor?: (op: Update) => VisitContext;
            visitor?: (op: Update) => void;
        };
        updateOperation?: {
            preVisitor?: (
                op:
                    | UpdateOperationLoad
                    | UpdateOperationClear
                    | UpdateOperationDrop
                    | UpdateOperationCreate
                    | UpdateOperationAdd
                    | UpdateOperationMove
                    | UpdateOperationCopy
                    | UpdateOperationInsertData
                    | UpdateOperationDeleteData
                    | UpdateOperationDeleteWhere
                    | UpdateOperationModify,
            ) => VisitContext;
            visitor?: (
                op:
                    | UpdateOperationLoad
                    | UpdateOperationClear
                    | UpdateOperationDrop
                    | UpdateOperationCreate
                    | UpdateOperationAdd
                    | UpdateOperationMove
                    | UpdateOperationCopy
                    | UpdateOperationInsertData
                    | UpdateOperationDeleteData
                    | UpdateOperationDeleteWhere
                    | UpdateOperationModify,
            ) => void;
        };
        wildcard?: {
            preVisitor?: (op: Wildcard) => VisitContext;
            visitor?: (op: Wildcard) => void;
        };
    },
    nodeSpecificCallBacks: {
        contextDef?: {
            base?: {
                preVisitor?: (op: ContextDefinitionBase) => VisitContext;
                visitor?: (op: ContextDefinitionBase) => void;
            };
            prefix?: {
                preVisitor?: (op: ContextDefinitionPrefix) => VisitContext;
                visitor?: (op: ContextDefinitionPrefix) => void;
            };
        };
        datasetClauses?: {};
        expression?: {
            aggregate?: {
                preVisitor?: (
                    op:
                        | ExpressionAggregateDefault
                        | ExpressionAggregateOnWildcard
                        | ExpressionAggregateSeparator,
                ) => VisitContext;
                visitor?: (
                    op:
                        | ExpressionAggregateDefault
                        | ExpressionAggregateOnWildcard
                        | ExpressionAggregateSeparator,
                ) => void;
            };
            functionCall?: {
                preVisitor?: (op: ExpressionFunctionCall) => VisitContext;
                visitor?: (op: ExpressionFunctionCall) => void;
            };
            operation?: {
                preVisitor?: (op: ExpressionOperation) => VisitContext;
                visitor?: (op: ExpressionOperation) => void;
            };
            patternOperation?: {
                preVisitor?: (op: ExpressionPatternOperation) => VisitContext;
                visitor?: (op: ExpressionPatternOperation) => void;
            };
        };
        graph?: {};
        graphRef?: {
            all?: {
                preVisitor?: (op: GraphRefAll) => VisitContext;
                visitor?: (op: GraphRefAll) => void;
            };
            default?: {
                preVisitor?: (op: GraphRefDefault) => VisitContext;
                visitor?: (op: GraphRefDefault) => void;
            };
            named?: {
                preVisitor?: (op: GraphRefNamed) => VisitContext;
                visitor?: (op: GraphRefNamed) => void;
            };
            specific?: {
                preVisitor?: (op: GraphRefSpecific) => VisitContext;
                visitor?: (op: GraphRefSpecific) => void;
            };
        };
        path?: {
            "!"?: {
                preVisitor?: (op: PathNegated) => VisitContext;
                visitor?: (op: PathNegated) => void;
            };
            "?"?: {
                preVisitor?: (op: never) => VisitContext;
                visitor?: (op: never) => void;
            };
            "*"?: {
                preVisitor?: (op: never) => VisitContext;
                visitor?: (op: never) => void;
            };
            "/"?: {
                preVisitor?: (op: never) => VisitContext;
                visitor?: (op: never) => void;
            };
            "^"?: {
                preVisitor?: (op: never) => VisitContext;
                visitor?: (op: never) => void;
            };
            "+"?: {
                preVisitor?: (op: never) => VisitContext;
                visitor?: (op: never) => void;
            };
            "|"?: {
                preVisitor?: (op: never) => VisitContext;
                visitor?: (op: never) => void;
            };
        };
        pattern?: {
            bgp?: {
                preVisitor?: (op: PatternBgp) => VisitContext;
                visitor?: (op: PatternBgp) => void;
            };
            bind?: {
                preVisitor?: (op: PatternBind) => VisitContext;
                visitor?: (op: PatternBind) => void;
            };
            filter?: {
                preVisitor?: (op: PatternFilter) => VisitContext;
                visitor?: (op: PatternFilter) => void;
            };
            graph?: {
                preVisitor?: (op: PatternGraph) => VisitContext;
                visitor?: (op: PatternGraph) => void;
            };
            group?: {
                preVisitor?: (op: PatternGroup) => VisitContext;
                visitor?: (op: PatternGroup) => void;
            };
            minus?: {
                preVisitor?: (op: PatternMinus) => VisitContext;
                visitor?: (op: PatternMinus) => void;
            };
            optional?: {
                preVisitor?: (op: PatternOptional) => VisitContext;
                visitor?: (op: PatternOptional) => void;
            };
            service?: {
                preVisitor?: (op: PatternService) => VisitContext;
                visitor?: (op: PatternService) => void;
            };
            union?: {
                preVisitor?: (op: PatternUnion) => VisitContext;
                visitor?: (op: PatternUnion) => void;
            };
            values?: {
                preVisitor?: (op: PatternValues) => VisitContext;
                visitor?: (op: PatternValues) => void;
            };
        };
        query?: {
            ask?: {
                preVisitor?: (op: QueryAsk) => VisitContext;
                visitor?: (op: QueryAsk) => void;
            };
            construct?: {
                preVisitor?: (op: QueryConstruct) => VisitContext;
                visitor?: (op: QueryConstruct) => void;
            };
            describe?: {
                preVisitor?: (op: QueryDescribe) => VisitContext;
                visitor?: (op: QueryDescribe) => void;
            };
            select?: {
                preVisitor?: (op: QuerySelect) => VisitContext;
                visitor?: (op: QuerySelect) => void;
            };
        };
        solutionModifier?: {
            group?: {
                preVisitor?: (op: SolutionModifierGroup) => VisitContext;
                visitor?: (op: SolutionModifierGroup) => void;
            };
            having?: {
                preVisitor?: (op: SolutionModifierHaving) => VisitContext;
                visitor?: (op: SolutionModifierHaving) => void;
            };
            limitOffset?: {
                preVisitor?: (op: SolutionModifierLimitOffset) => VisitContext;
                visitor?: (op: SolutionModifierLimitOffset) => void;
            };
            order?: {
                preVisitor?: (op: SolutionModifierOrder) => VisitContext;
                visitor?: (op: SolutionModifierOrder) => void;
            };
        };
        term?: {
            blankNode?: {
                preVisitor?: (op: TermBlank) => VisitContext;
                visitor?: (op: TermBlank) => void;
            };
            literal?: {
                preVisitor?: (
                    op: TermLiteralStr | TermLiteralLangStr | TermLiteralTyped,
                ) => VisitContext;
                visitor?: (
                    op: TermLiteralStr | TermLiteralLangStr | TermLiteralTyped,
                ) => void;
            };
            namedNode?: {
                preVisitor?: (op: TermIriFull | TermIriPrefixed) => VisitContext;
                visitor?: (op: TermIriFull | TermIriPrefixed) => void;
            };
            variable?: {
                preVisitor?: (op: TermVariable) => VisitContext;
                visitor?: (op: TermVariable) => void;
            };
        };
        triple?: {};
        tripleCollection?: {
            blankNodeProperties?: {
                preVisitor?: (
                    op: TripleCollectionBlankNodeProperties,
                ) => VisitContext;
                visitor?: (op: TripleCollectionBlankNodeProperties) => void;
            };
            list?: {
                preVisitor?: (op: TripleCollectionList) => VisitContext;
                visitor?: (op: TripleCollectionList) => void;
            };
        };
        update?: {};
        updateOperation?: {
            add?: {
                preVisitor?: (op: UpdateOperationAdd) => VisitContext;
                visitor?: (op: UpdateOperationAdd) => void;
            };
            clear?: {
                preVisitor?: (op: UpdateOperationClear) => VisitContext;
                visitor?: (op: UpdateOperationClear) => void;
            };
            copy?: {
                preVisitor?: (op: UpdateOperationCopy) => VisitContext;
                visitor?: (op: UpdateOperationCopy) => void;
            };
            create?: {
                preVisitor?: (op: UpdateOperationCreate) => VisitContext;
                visitor?: (op: UpdateOperationCreate) => void;
            };
            deletedata?: {
                preVisitor?: (op: UpdateOperationDeleteData) => VisitContext;
                visitor?: (op: UpdateOperationDeleteData) => void;
            };
            deletewhere?: {
                preVisitor?: (op: UpdateOperationDeleteWhere) => VisitContext;
                visitor?: (op: UpdateOperationDeleteWhere) => void;
            };
            drop?: {
                preVisitor?: (op: UpdateOperationDrop) => VisitContext;
                visitor?: (op: UpdateOperationDrop) => void;
            };
            insertdata?: {
                preVisitor?: (op: UpdateOperationInsertData) => VisitContext;
                visitor?: (op: UpdateOperationInsertData) => void;
            };
            load?: {
                preVisitor?: (op: UpdateOperationLoad) => VisitContext;
                visitor?: (op: UpdateOperationLoad) => void;
            };
            modify?: {
                preVisitor?: (op: UpdateOperationModify) => VisitContext;
                visitor?: (op: UpdateOperationModify) => void;
            };
            move?: {
                preVisitor?: (op: UpdateOperationMove) => VisitContext;
                visitor?: (op: UpdateOperationMove) => void;
            };
        };
        wildcard?: {};
    },
): void
Visit a selected subTree given a startObject, steering the visits based on Typed nodes. Similar to this.visitNode, but also allowing you to target subTypes. Will call the preVisitor on the outer distinct, then the visitor of the special distinct, followed by the visiting the outer distinct, printing '231'. The pre-visitor visits starting from the root, going deeper, while the actual visitor goes in reverse.
Parameters
- startObject: object
  the object from which we will start visiting, potentially visiting its descendants along the way.
- nodeCallBacks: {
      contextDef?: {
          preVisitor?: (
              op: ContextDefinitionPrefix | ContextDefinitionBase,
          ) => VisitContext;
          visitor?: (op: ContextDefinitionPrefix | ContextDefinitionBase) => void;
      };
      datasetClauses?: {
          preVisitor?: (op: DatasetClauses) => VisitContext;
          visitor?: (op: DatasetClauses) => void;
      };
      expression?: {
          preVisitor?: (
              op:
                  | ExpressionOperation
                  | ExpressionPatternOperation
                  | ExpressionFunctionCall
                  | ExpressionAggregateDefault
                  | ExpressionAggregateOnWildcard
                  | ExpressionAggregateSeparator,
          ) => VisitContext;
          visitor?: (
              op:
                  | ExpressionOperation
                  | ExpressionPatternOperation
                  | ExpressionFunctionCall
                  | ExpressionAggregateDefault
                  | ExpressionAggregateOnWildcard
                  | ExpressionAggregateSeparator,
          ) => void;
      };
      graph?: {
          preVisitor?: (op: GraphQuads) => VisitContext;
          visitor?: (op: GraphQuads) => void;
      };
      graphRef?: {
          preVisitor?: (
              op: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
          ) => VisitContext;
          visitor?: (
              op: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
          ) => void;
      };
      path?: {
          preVisitor?: (
              op: PropertyPathChain | PathModified | PathNegated,
          ) => VisitContext;
          visitor?: (op: PropertyPathChain | PathModified | PathNegated) => void;
      };
      pattern?: {
          preVisitor?: (
              op:
                  | PatternBgp
                  | PatternGroup
                  | PatternUnion
                  | PatternOptional
                  | PatternMinus
                  | PatternGraph
                  | PatternService
                  | PatternFilter
                  | PatternBind
                  | PatternValues,
          ) => VisitContext;
          visitor?: (
              op:
                  | PatternBgp
                  | PatternGroup
                  | PatternUnion
                  | PatternOptional
                  | PatternMinus
                  | PatternGraph
                  | PatternService
                  | PatternFilter
                  | PatternBind
                  | PatternValues,
          ) => void;
      };
      query?: {
          preVisitor?: (
              op: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
          ) => VisitContext;
          visitor?: (
              op: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
          ) => void;
      };
      solutionModifier?: {
          preVisitor?: (
              op:
                  | SolutionModifierGroup
                  | SolutionModifierHaving
                  | SolutionModifierOrder
                  | SolutionModifierLimitOffset,
          ) => VisitContext;
          visitor?: (
              op:
                  | SolutionModifierGroup
                  | SolutionModifierHaving
                  | SolutionModifierOrder
                  | SolutionModifierLimitOffset,
          ) => void;
      };
      term?: {
          preVisitor?: (
              op:
                  | TermIriFull
                  | TermIriPrefixed
                  | TermVariable
                  | TermLiteralStr
                  | TermLiteralLangStr
                  | TermLiteralTyped
                  | TermBlank,
          ) => VisitContext;
          visitor?: (
              op:
                  | TermIriFull
                  | TermIriPrefixed
                  | TermVariable
                  | TermLiteralStr
                  | TermLiteralLangStr
                  | TermLiteralTyped
                  | TermBlank,
          ) => void;
      };
      triple?: {
          preVisitor?: (op: TripleNesting) => VisitContext;
          visitor?: (op: TripleNesting) => void;
      };
      tripleCollection?: {
          preVisitor?: (
              op: TripleCollectionList | TripleCollectionBlankNodeProperties,
          ) => VisitContext;
          visitor?: (
              op: TripleCollectionList | TripleCollectionBlankNodeProperties,
          ) => void;
      };
      update?: {
          preVisitor?: (op: Update) => VisitContext;
          visitor?: (op: Update) => void;
      };
      updateOperation?: {
          preVisitor?: (
              op:
                  | UpdateOperationLoad
                  | UpdateOperationClear
                  | UpdateOperationDrop
                  | UpdateOperationCreate
                  | UpdateOperationAdd
                  | UpdateOperationMove
                  | UpdateOperationCopy
                  | UpdateOperationInsertData
                  | UpdateOperationDeleteData
                  | UpdateOperationDeleteWhere
                  | UpdateOperationModify,
          ) => VisitContext;
          visitor?: (
              op:
                  | UpdateOperationLoad
                  | UpdateOperationClear
                  | UpdateOperationDrop
                  | UpdateOperationCreate
                  | UpdateOperationAdd
                  | UpdateOperationMove
                  | UpdateOperationCopy
                  | UpdateOperationInsertData
                  | UpdateOperationDeleteData
                  | UpdateOperationDeleteWhere
                  | UpdateOperationModify,
          ) => void;
      };
      wildcard?: {
          preVisitor?: (op: Wildcard) => VisitContext;
          visitor?: (op: Wildcard) => void;
      };
  }
  a dictionary mapping the various operation types to objects optionally containing preVisitor and visitor. The preVisitor allows you to provide VisitContext for the current object, altering how it will be visited. The visitor allows you to visit the object from deepest to the outermost object. This is useful if you for example want to manipulate the objects you visit during your visits, similar to mapOperation.
- nodeSpecificCallBacks: {
      contextDef?: {
          base?: {
              preVisitor?: (op: ContextDefinitionBase) => VisitContext;
              visitor?: (op: ContextDefinitionBase) => void;
          };
          prefix?: {
              preVisitor?: (op: ContextDefinitionPrefix) => VisitContext;
              visitor?: (op: ContextDefinitionPrefix) => void;
          };
      };
      datasetClauses?: {};
      expression?: {
          aggregate?: {
              preVisitor?: (
                  op:
                      | ExpressionAggregateDefault
                      | ExpressionAggregateOnWildcard
                      | ExpressionAggregateSeparator,
              ) => VisitContext;
              visitor?: (
                  op:
                      | ExpressionAggregateDefault
                      | ExpressionAggregateOnWildcard
                      | ExpressionAggregateSeparator,
              ) => void;
          };
          functionCall?: {
              preVisitor?: (op: ExpressionFunctionCall) => VisitContext;
              visitor?: (op: ExpressionFunctionCall) => void;
          };
          operation?: {
              preVisitor?: (op: ExpressionOperation) => VisitContext;
              visitor?: (op: ExpressionOperation) => void;
          };
          patternOperation?: {
              preVisitor?: (op: ExpressionPatternOperation) => VisitContext;
              visitor?: (op: ExpressionPatternOperation) => void;
          };
      };
      graph?: {};
      graphRef?: {
          all?: {
              preVisitor?: (op: GraphRefAll) => VisitContext;
              visitor?: (op: GraphRefAll) => void;
          };
          default?: {
              preVisitor?: (op: GraphRefDefault) => VisitContext;
              visitor?: (op: GraphRefDefault) => void;
          };
          named?: {
              preVisitor?: (op: GraphRefNamed) => VisitContext;
              visitor?: (op: GraphRefNamed) => void;
          };
          specific?: {
              preVisitor?: (op: GraphRefSpecific) => VisitContext;
              visitor?: (op: GraphRefSpecific) => void;
          };
      };
      path?: {
          "!"?: {
              preVisitor?: (op: PathNegated) => VisitContext;
              visitor?: (op: PathNegated) => void;
          };
          "?"?: {
              preVisitor?: (op: never) => VisitContext;
              visitor?: (op: never) => void;
          };
          "*"?: {
              preVisitor?: (op: never) => VisitContext;
              visitor?: (op: never) => void;
          };
          "/"?: {
              preVisitor?: (op: never) => VisitContext;
              visitor?: (op: never) => void;
          };
          "^"?: {
              preVisitor?: (op: never) => VisitContext;
              visitor?: (op: never) => void;
          };
          "+"?: {
              preVisitor?: (op: never) => VisitContext;
              visitor?: (op: never) => void;
          };
          "|"?: {
              preVisitor?: (op: never) => VisitContext;
              visitor?: (op: never) => void;
          };
      };
      pattern?: {
          bgp?: {
              preVisitor?: (op: PatternBgp) => VisitContext;
              visitor?: (op: PatternBgp) => void;
          };
          bind?: {
              preVisitor?: (op: PatternBind) => VisitContext;
              visitor?: (op: PatternBind) => void;
          };
          filter?: {
              preVisitor?: (op: PatternFilter) => VisitContext;
              visitor?: (op: PatternFilter) => void;
          };
          graph?: {
              preVisitor?: (op: PatternGraph) => VisitContext;
              visitor?: (op: PatternGraph) => void;
          };
          group?: {
              preVisitor?: (op: PatternGroup) => VisitContext;
              visitor?: (op: PatternGroup) => void;
          };
          minus?: {
              preVisitor?: (op: PatternMinus) => VisitContext;
              visitor?: (op: PatternMinus) => void;
          };
          optional?: {
              preVisitor?: (op: PatternOptional) => VisitContext;
              visitor?: (op: PatternOptional) => void;
          };
          service?: {
              preVisitor?: (op: PatternService) => VisitContext;
              visitor?: (op: PatternService) => void;
          };
          union?: {
              preVisitor?: (op: PatternUnion) => VisitContext;
              visitor?: (op: PatternUnion) => void;
          };
          values?: {
              preVisitor?: (op: PatternValues) => VisitContext;
              visitor?: (op: PatternValues) => void;
          };
      };
      query?: {
          ask?: {
              preVisitor?: (op: QueryAsk) => VisitContext;
              visitor?: (op: QueryAsk) => void;
          };
          construct?: {
              preVisitor?: (op: QueryConstruct) => VisitContext;
              visitor?: (op: QueryConstruct) => void;
          };
          describe?: {
              preVisitor?: (op: QueryDescribe) => VisitContext;
              visitor?: (op: QueryDescribe) => void;
          };
          select?: {
              preVisitor?: (op: QuerySelect) => VisitContext;
              visitor?: (op: QuerySelect) => void;
          };
      };
      solutionModifier?: {
          group?: {
              preVisitor?: (op: SolutionModifierGroup) => VisitContext;
              visitor?: (op: SolutionModifierGroup) => void;
          };
          having?: {
              preVisitor?: (op: SolutionModifierHaving) => VisitContext;
              visitor?: (op: SolutionModifierHaving) => void;
          };
          limitOffset?: {
              preVisitor?: (op: SolutionModifierLimitOffset) => VisitContext;
              visitor?: (op: SolutionModifierLimitOffset) => void;
          };
          order?: {
              preVisitor?: (op: SolutionModifierOrder) => VisitContext;
              visitor?: (op: SolutionModifierOrder) => void;
          };
      };
      term?: {
          blankNode?: {
              preVisitor?: (op: TermBlank) => VisitContext;
              visitor?: (op: TermBlank) => void;
          };
          literal?: {
              preVisitor?: (
                  op: TermLiteralStr | TermLiteralLangStr | TermLiteralTyped,
              ) => VisitContext;
              visitor?: (
                  op: TermLiteralStr | TermLiteralLangStr | TermLiteralTyped,
              ) => void;
          };
          namedNode?: {
              preVisitor?: (op: TermIriFull | TermIriPrefixed) => VisitContext;
              visitor?: (op: TermIriFull | TermIriPrefixed) => void;
          };
          variable?: {
              preVisitor?: (op: TermVariable) => VisitContext;
              visitor?: (op: TermVariable) => void;
          };
      };
      triple?: {};
      tripleCollection?: {
          blankNodeProperties?: {
              preVisitor?: (op: TripleCollectionBlankNodeProperties) => VisitContext;
              visitor?: (op: TripleCollectionBlankNodeProperties) => void;
          };
          list?: {
              preVisitor?: (op: TripleCollectionList) => VisitContext;
              visitor?: (op: TripleCollectionList) => void;
          };
      };
      update?: {};
      updateOperation?: {
          add?: {
              preVisitor?: (op: UpdateOperationAdd) => VisitContext;
              visitor?: (op: UpdateOperationAdd) => void;
          };
          clear?: {
              preVisitor?: (op: UpdateOperationClear) => VisitContext;
              visitor?: (op: UpdateOperationClear) => void;
          };
          copy?: {
              preVisitor?: (op: UpdateOperationCopy) => VisitContext;
              visitor?: (op: UpdateOperationCopy) => void;
          };
          create?: {
              preVisitor?: (op: UpdateOperationCreate) => VisitContext;
              visitor?: (op: UpdateOperationCreate) => void;
          };
          deletedata?: {
              preVisitor?: (op: UpdateOperationDeleteData) => VisitContext;
              visitor?: (op: UpdateOperationDeleteData) => void;
          };
          deletewhere?: {
              preVisitor?: (op: UpdateOperationDeleteWhere) => VisitContext;
              visitor?: (op: UpdateOperationDeleteWhere) => void;
          };
          drop?: {
              preVisitor?: (op: UpdateOperationDrop) => VisitContext;
              visitor?: (op: UpdateOperationDrop) => void;
          };
          insertdata?: {
              preVisitor?: (op: UpdateOperationInsertData) => VisitContext;
              visitor?: (op: UpdateOperationInsertData) => void;
          };
          load?: {
              preVisitor?: (op: UpdateOperationLoad) => VisitContext;
              visitor?: (op: UpdateOperationLoad) => void;
          };
          modify?: {
              preVisitor?: (op: UpdateOperationModify) => VisitContext;
              visitor?: (op: UpdateOperationModify) => void;
          };
          move?: {
              preVisitor?: (op: UpdateOperationMove) => VisitContext;
              visitor?: (op: UpdateOperationMove) => void;
          };
      };
      wildcard?: {};
  }
  Same as nodeCallBacks but using an additional level of indirection to indicate the subType.
Returns void
Inherited from TransformerSubTyped.visitNodeSpecific
- Defined in core/dist/esm/lib/transformers/TransformerSubTyped.d.ts:55

visitObject

visitObject(
    startObject: object,
    visitor: (orig: object) => void,
    preVisitor?: (orig: object) => VisitContext,
): void
Visitor that visits all objects. Visits deeper objects first.
Parameters
- startObject: object
- visitor: (orig: object) => void
- OptionalpreVisitor: (orig: object) => VisitContext
Returns void
Inherited from TransformerSubTyped.visitObject
- Defined in core/dist/esm/lib/transformers/TransformerObject.d.ts:64

Class AstTransformer

Hierarchy (View Summary)

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns AstTransformer

Properties

Protected ReadonlydefaultContext

ProtecteddefaultNodePreVisitor

ProtectedmaxStackSize

Methods

clone

Parameters

Returns TransformerSubTyped<Sparql11Nodes>

ProtectedcloneObj

Type Parameters

Parameters

Returns T

transformNode

Type Parameters

Parameters

Returns Safe extends "unsafe" ? OutType : unknown

transformNodeSpecific

Type Parameters

Parameters

Returns Safe extends "unsafe" ? OutType : unknown

transformObject

Parameters

Returns unknown

visitNode

Parameters

Returns void

visitNodeSpecific

Parameters

Returns void

visitObject

Parameters

Returns void

Settings

On This Page

`Protected` `Readonly`defaultContext

`Protected`defaultNodePreVisitor

`Protected`maxStackSize

`Protected`cloneObj