Class AstTransformer

Hierarchy (View Summary)

TransformerSubTyped<Sparql11Nodes>
- AstTransformer

Index

Constructors

Properties

defaultContext defaultNodePreVisitor maxStackSize

Methods

clone cloneObj transformNode transformNodeSpecific transformObject traverseNodes traverseSubNodes visitNode visitNodeSpecific visitObject

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. The transformation calls the preVisitor from starting from the startObject. The preVisitor can dictate whether transformation should be stopped. Note that stopping the transformation also prevets further copying. The transformer itself transforms object starting with the deepest one that can be visited. The transformer callback is performed on a copy of the original.
Type Parameters
- Safe extends Safeness = "safe"
- OutType = unknown
Parameters
- 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;
      };
  }
Returns Safe extends "unsafe" ? OutType : unknown
Inherited from TransformerSubTyped.transformNode
- Defined in core/dist/esm/lib/transformers/TransformerTyped.d.ts:25

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
Shares the functionality and first two arguments with this.transformNode. The third argument allows you to also transform based on the subType of objects. Note that when a callback for the subtype is provided, the callback for the general type is NOT executed.
Type Parameters
- Safe extends Safeness = "safe"
- OutType = unknown
Parameters
- 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?: {};
  }
Returns Safe extends "unsafe" ? OutType : unknown
Inherited from TransformerSubTyped.transformNodeSpecific
- Defined in core/dist/esm/lib/transformers/TransformerSubTyped.d.ts:16

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

traverseNodes

traverseNodes(
    currentNode: Sparql11Nodes,
    traverse: {
        contextDef?: (
            op: ContextDefinitionPrefix | ContextDefinitionBase,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        datasetClauses?: (
            op: DatasetClauses,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        expression?: (
            op:
                | ExpressionOperation
                | ExpressionPatternOperation
                | ExpressionFunctionCall
                | ExpressionAggregateDefault
                | ExpressionAggregateOnWildcard
                | ExpressionAggregateSeparator,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        graph?: (op: GraphQuads) => SelectiveTraversalContext<Sparql11Nodes>;
        graphRef?: (
            op: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        path?: (
            op: PropertyPathChain | PathModified | PathNegated,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        pattern?: (
            op:
                | PatternBgp
                | PatternGroup
                | PatternUnion
                | PatternOptional
                | PatternMinus
                | PatternGraph
                | PatternService
                | PatternFilter
                | PatternBind
                | PatternValues,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        query?: (
            op: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        solutionModifier?: (
            op:
                | SolutionModifierGroup
                | SolutionModifierHaving
                | SolutionModifierOrder
                | SolutionModifierLimitOffset,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        term?: (
            op:
                | TermIriFull
                | TermIriPrefixed
                | TermVariable
                | TermLiteralStr
                | TermLiteralLangStr
                | TermLiteralTyped
                | TermBlank,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        triple?: (op: TripleNesting) => SelectiveTraversalContext<Sparql11Nodes>;
        tripleCollection?: (
            op: TripleCollectionList | TripleCollectionBlankNodeProperties,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        update?: (op: Update) => SelectiveTraversalContext<Sparql11Nodes>;
        updateOperation?: (
            op:
                | UpdateOperationLoad
                | UpdateOperationClear
                | UpdateOperationDrop
                | UpdateOperationCreate
                | UpdateOperationAdd
                | UpdateOperationMove
                | UpdateOperationCopy
                | UpdateOperationInsertData
                | UpdateOperationDeleteData
                | UpdateOperationDeleteWhere
                | UpdateOperationModify,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        wildcard?: (op: Wildcard) => SelectiveTraversalContext<Sparql11Nodes>;
    },
): void
Traverses only selected nodes as returned by the function.
Parameters
- currentNode: Sparql11Nodes
- traverse: {
      contextDef?: (
          op: ContextDefinitionPrefix | ContextDefinitionBase,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      datasetClauses?: (
          op: DatasetClauses,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      expression?: (
          op:
              | ExpressionOperation
              | ExpressionPatternOperation
              | ExpressionFunctionCall
              | ExpressionAggregateDefault
              | ExpressionAggregateOnWildcard
              | ExpressionAggregateSeparator,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      graph?: (op: GraphQuads) => SelectiveTraversalContext<Sparql11Nodes>;
      graphRef?: (
          op: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      path?: (
          op: PropertyPathChain | PathModified | PathNegated,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      pattern?: (
          op:
              | PatternBgp
              | PatternGroup
              | PatternUnion
              | PatternOptional
              | PatternMinus
              | PatternGraph
              | PatternService
              | PatternFilter
              | PatternBind
              | PatternValues,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      query?: (
          op: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      solutionModifier?: (
          op:
              | SolutionModifierGroup
              | SolutionModifierHaving
              | SolutionModifierOrder
              | SolutionModifierLimitOffset,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      term?: (
          op:
              | TermIriFull
              | TermIriPrefixed
              | TermVariable
              | TermLiteralStr
              | TermLiteralLangStr
              | TermLiteralTyped
              | TermBlank,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      triple?: (op: TripleNesting) => SelectiveTraversalContext<Sparql11Nodes>;
      tripleCollection?: (
          op: TripleCollectionList | TripleCollectionBlankNodeProperties,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      update?: (op: Update) => SelectiveTraversalContext<Sparql11Nodes>;
      updateOperation?: (
          op:
              | UpdateOperationLoad
              | UpdateOperationClear
              | UpdateOperationDrop
              | UpdateOperationCreate
              | UpdateOperationAdd
              | UpdateOperationMove
              | UpdateOperationCopy
              | UpdateOperationInsertData
              | UpdateOperationDeleteData
              | UpdateOperationDeleteWhere
              | UpdateOperationModify,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      wildcard?: (op: Wildcard) => SelectiveTraversalContext<Sparql11Nodes>;
  }
Returns void
Inherited from TransformerSubTyped.traverseNodes
- Defined in core/dist/esm/lib/transformers/TransformerTyped.d.ts:48

traverseSubNodes

traverseSubNodes(
    currentNode: Sparql11Nodes,
    traverseNode: {
        contextDef?: (
            op: ContextDefinitionPrefix | ContextDefinitionBase,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        datasetClauses?: (
            op: DatasetClauses,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        expression?: (
            op:
                | ExpressionOperation
                | ExpressionPatternOperation
                | ExpressionFunctionCall
                | ExpressionAggregateDefault
                | ExpressionAggregateOnWildcard
                | ExpressionAggregateSeparator,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        graph?: (op: GraphQuads) => SelectiveTraversalContext<Sparql11Nodes>;
        graphRef?: (
            op: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        path?: (
            op: PropertyPathChain | PathModified | PathNegated,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        pattern?: (
            op:
                | PatternBgp
                | PatternGroup
                | PatternUnion
                | PatternOptional
                | PatternMinus
                | PatternGraph
                | PatternService
                | PatternFilter
                | PatternBind
                | PatternValues,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        query?: (
            op: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        solutionModifier?: (
            op:
                | SolutionModifierGroup
                | SolutionModifierHaving
                | SolutionModifierOrder
                | SolutionModifierLimitOffset,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        term?: (
            op:
                | TermIriFull
                | TermIriPrefixed
                | TermVariable
                | TermLiteralStr
                | TermLiteralLangStr
                | TermLiteralTyped
                | TermBlank,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        triple?: (op: TripleNesting) => SelectiveTraversalContext<Sparql11Nodes>;
        tripleCollection?: (
            op: TripleCollectionList | TripleCollectionBlankNodeProperties,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        update?: (op: Update) => SelectiveTraversalContext<Sparql11Nodes>;
        updateOperation?: (
            op:
                | UpdateOperationLoad
                | UpdateOperationClear
                | UpdateOperationDrop
                | UpdateOperationCreate
                | UpdateOperationAdd
                | UpdateOperationMove
                | UpdateOperationCopy
                | UpdateOperationInsertData
                | UpdateOperationDeleteData
                | UpdateOperationDeleteWhere
                | UpdateOperationModify,
        ) => SelectiveTraversalContext<Sparql11Nodes>;
        wildcard?: (op: Wildcard) => SelectiveTraversalContext<Sparql11Nodes>;
    },
    traverseSubNode: {
        contextDef?: {
            base?: (
                op: ContextDefinitionBase,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            prefix?: (
                op: ContextDefinitionPrefix,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
        };
        datasetClauses?: {};
        expression?: {
            aggregate?: (
                op:
                    | ExpressionAggregateDefault
                    | ExpressionAggregateOnWildcard
                    | ExpressionAggregateSeparator,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            functionCall?: (
                op: ExpressionFunctionCall,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            operation?: (
                op: ExpressionOperation,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            patternOperation?: (
                op: ExpressionPatternOperation,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
        };
        graph?: {};
        graphRef?: {
            all?: (op: GraphRefAll) => SelectiveTraversalContext<Sparql11Nodes>;
            default?: (
                op: GraphRefDefault,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            named?: (op: GraphRefNamed) => SelectiveTraversalContext<Sparql11Nodes>;
            specific?: (
                op: GraphRefSpecific,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
        };
        path?: {
            "!"?: (op: PathNegated) => SelectiveTraversalContext<Sparql11Nodes>;
            "?"?: (op: never) => SelectiveTraversalContext<Sparql11Nodes>;
            "*"?: (op: never) => SelectiveTraversalContext<Sparql11Nodes>;
            "/"?: (op: never) => SelectiveTraversalContext<Sparql11Nodes>;
            "^"?: (op: never) => SelectiveTraversalContext<Sparql11Nodes>;
            "+"?: (op: never) => SelectiveTraversalContext<Sparql11Nodes>;
            "|"?: (op: never) => SelectiveTraversalContext<Sparql11Nodes>;
        };
        pattern?: {
            bgp?: (op: PatternBgp) => SelectiveTraversalContext<Sparql11Nodes>;
            bind?: (op: PatternBind) => SelectiveTraversalContext<Sparql11Nodes>;
            filter?: (op: PatternFilter) => SelectiveTraversalContext<Sparql11Nodes>;
            graph?: (op: PatternGraph) => SelectiveTraversalContext<Sparql11Nodes>;
            group?: (op: PatternGroup) => SelectiveTraversalContext<Sparql11Nodes>;
            minus?: (op: PatternMinus) => SelectiveTraversalContext<Sparql11Nodes>;
            optional?: (
                op: PatternOptional,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            service?: (
                op: PatternService,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            union?: (op: PatternUnion) => SelectiveTraversalContext<Sparql11Nodes>;
            values?: (op: PatternValues) => SelectiveTraversalContext<Sparql11Nodes>;
        };
        query?: {
            ask?: (op: QueryAsk) => SelectiveTraversalContext<Sparql11Nodes>;
            construct?: (
                op: QueryConstruct,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            describe?: (
                op: QueryDescribe,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            select?: (op: QuerySelect) => SelectiveTraversalContext<Sparql11Nodes>;
        };
        solutionModifier?: {
            group?: (
                op: SolutionModifierGroup,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            having?: (
                op: SolutionModifierHaving,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            limitOffset?: (
                op: SolutionModifierLimitOffset,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            order?: (
                op: SolutionModifierOrder,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
        };
        term?: {
            blankNode?: (
                op: TermBlank,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            literal?: (
                op: TermLiteralStr | TermLiteralLangStr | TermLiteralTyped,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            namedNode?: (
                op: TermIriFull | TermIriPrefixed,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            variable?: (op: TermVariable) => SelectiveTraversalContext<Sparql11Nodes>;
        };
        triple?: {};
        tripleCollection?: {
            blankNodeProperties?: (
                op: TripleCollectionBlankNodeProperties,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            list?: (
                op: TripleCollectionList,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
        };
        update?: {};
        updateOperation?: {
            add?: (
                op: UpdateOperationAdd,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            clear?: (
                op: UpdateOperationClear,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            copy?: (
                op: UpdateOperationCopy,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            create?: (
                op: UpdateOperationCreate,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            deletedata?: (
                op: UpdateOperationDeleteData,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            deletewhere?: (
                op: UpdateOperationDeleteWhere,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            drop?: (
                op: UpdateOperationDrop,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            insertdata?: (
                op: UpdateOperationInsertData,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            load?: (
                op: UpdateOperationLoad,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            modify?: (
                op: UpdateOperationModify,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
            move?: (
                op: UpdateOperationMove,
            ) => SelectiveTraversalContext<Sparql11Nodes>;
        };
        wildcard?: {};
    },
): void
Similar to this.traverseNodes but also allows you to match based on the subtype of objects.
Parameters
- currentNode: Sparql11Nodes
- traverseNode: {
      contextDef?: (
          op: ContextDefinitionPrefix | ContextDefinitionBase,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      datasetClauses?: (
          op: DatasetClauses,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      expression?: (
          op:
              | ExpressionOperation
              | ExpressionPatternOperation
              | ExpressionFunctionCall
              | ExpressionAggregateDefault
              | ExpressionAggregateOnWildcard
              | ExpressionAggregateSeparator,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      graph?: (op: GraphQuads) => SelectiveTraversalContext<Sparql11Nodes>;
      graphRef?: (
          op: GraphRefDefault | GraphRefNamed | GraphRefAll | GraphRefSpecific,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      path?: (
          op: PropertyPathChain | PathModified | PathNegated,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      pattern?: (
          op:
              | PatternBgp
              | PatternGroup
              | PatternUnion
              | PatternOptional
              | PatternMinus
              | PatternGraph
              | PatternService
              | PatternFilter
              | PatternBind
              | PatternValues,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      query?: (
          op: QuerySelect | QueryConstruct | QueryDescribe | QueryAsk,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      solutionModifier?: (
          op:
              | SolutionModifierGroup
              | SolutionModifierHaving
              | SolutionModifierOrder
              | SolutionModifierLimitOffset,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      term?: (
          op:
              | TermIriFull
              | TermIriPrefixed
              | TermVariable
              | TermLiteralStr
              | TermLiteralLangStr
              | TermLiteralTyped
              | TermBlank,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      triple?: (op: TripleNesting) => SelectiveTraversalContext<Sparql11Nodes>;
      tripleCollection?: (
          op: TripleCollectionList | TripleCollectionBlankNodeProperties,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      update?: (op: Update) => SelectiveTraversalContext<Sparql11Nodes>;
      updateOperation?: (
          op:
              | UpdateOperationLoad
              | UpdateOperationClear
              | UpdateOperationDrop
              | UpdateOperationCreate
              | UpdateOperationAdd
              | UpdateOperationMove
              | UpdateOperationCopy
              | UpdateOperationInsertData
              | UpdateOperationDeleteData
              | UpdateOperationDeleteWhere
              | UpdateOperationModify,
      ) => SelectiveTraversalContext<Sparql11Nodes>;
      wildcard?: (op: Wildcard) => SelectiveTraversalContext<Sparql11Nodes>;
  }
- traverseSubNode: {
      contextDef?: {
          base?: (
              op: ContextDefinitionBase,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          prefix?: (
              op: ContextDefinitionPrefix,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
      };
      datasetClauses?: {};
      expression?: {
          aggregate?: (
              op:
                  | ExpressionAggregateDefault
                  | ExpressionAggregateOnWildcard
                  | ExpressionAggregateSeparator,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          functionCall?: (
              op: ExpressionFunctionCall,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          operation?: (
              op: ExpressionOperation,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          patternOperation?: (
              op: ExpressionPatternOperation,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
      };
      graph?: {};
      graphRef?: {
          all?: (op: GraphRefAll) => SelectiveTraversalContext<Sparql11Nodes>;
          default?: (
              op: GraphRefDefault,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          named?: (op: GraphRefNamed) => SelectiveTraversalContext<Sparql11Nodes>;
          specific?: (
              op: GraphRefSpecific,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
      };
      path?: {
          "!"?: (op: PathNegated) => SelectiveTraversalContext<Sparql11Nodes>;
          "?"?: (op: never) => SelectiveTraversalContext<Sparql11Nodes>;
          "*"?: (op: never) => SelectiveTraversalContext<Sparql11Nodes>;
          "/"?: (op: never) => SelectiveTraversalContext<Sparql11Nodes>;
          "^"?: (op: never) => SelectiveTraversalContext<Sparql11Nodes>;
          "+"?: (op: never) => SelectiveTraversalContext<Sparql11Nodes>;
          "|"?: (op: never) => SelectiveTraversalContext<Sparql11Nodes>;
      };
      pattern?: {
          bgp?: (op: PatternBgp) => SelectiveTraversalContext<Sparql11Nodes>;
          bind?: (op: PatternBind) => SelectiveTraversalContext<Sparql11Nodes>;
          filter?: (op: PatternFilter) => SelectiveTraversalContext<Sparql11Nodes>;
          graph?: (op: PatternGraph) => SelectiveTraversalContext<Sparql11Nodes>;
          group?: (op: PatternGroup) => SelectiveTraversalContext<Sparql11Nodes>;
          minus?: (op: PatternMinus) => SelectiveTraversalContext<Sparql11Nodes>;
          optional?: (
              op: PatternOptional,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          service?: (op: PatternService) => SelectiveTraversalContext<Sparql11Nodes>;
          union?: (op: PatternUnion) => SelectiveTraversalContext<Sparql11Nodes>;
          values?: (op: PatternValues) => SelectiveTraversalContext<Sparql11Nodes>;
      };
      query?: {
          ask?: (op: QueryAsk) => SelectiveTraversalContext<Sparql11Nodes>;
          construct?: (
              op: QueryConstruct,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          describe?: (op: QueryDescribe) => SelectiveTraversalContext<Sparql11Nodes>;
          select?: (op: QuerySelect) => SelectiveTraversalContext<Sparql11Nodes>;
      };
      solutionModifier?: {
          group?: (
              op: SolutionModifierGroup,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          having?: (
              op: SolutionModifierHaving,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          limitOffset?: (
              op: SolutionModifierLimitOffset,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          order?: (
              op: SolutionModifierOrder,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
      };
      term?: {
          blankNode?: (op: TermBlank) => SelectiveTraversalContext<Sparql11Nodes>;
          literal?: (
              op: TermLiteralStr | TermLiteralLangStr | TermLiteralTyped,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          namedNode?: (
              op: TermIriFull | TermIriPrefixed,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          variable?: (op: TermVariable) => SelectiveTraversalContext<Sparql11Nodes>;
      };
      triple?: {};
      tripleCollection?: {
          blankNodeProperties?: (
              op: TripleCollectionBlankNodeProperties,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          list?: (
              op: TripleCollectionList,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
      };
      update?: {};
      updateOperation?: {
          add?: (
              op: UpdateOperationAdd,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          clear?: (
              op: UpdateOperationClear,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          copy?: (
              op: UpdateOperationCopy,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          create?: (
              op: UpdateOperationCreate,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          deletedata?: (
              op: UpdateOperationDeleteData,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          deletewhere?: (
              op: UpdateOperationDeleteWhere,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          drop?: (
              op: UpdateOperationDrop,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          insertdata?: (
              op: UpdateOperationInsertData,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          load?: (
              op: UpdateOperationLoad,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          modify?: (
              op: UpdateOperationModify,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
          move?: (
              op: UpdateOperationMove,
          ) => SelectiveTraversalContext<Sparql11Nodes>;
      };
      wildcard?: {};
  }
Returns void
Inherited from TransformerSubTyped.traverseSubNodes
- Defined in core/dist/esm/lib/transformers/TransformerSubTyped.d.ts:52

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
Similar to this.transformNode, but without copying the startObject. The pre-visitor visits starting from the root, going deeper, while the actual visitor goes in reverse.
Parameters
- 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;
      };
  }
Returns void
Inherited from TransformerSubTyped.visitNode
- Defined in core/dist/esm/lib/transformers/TransformerTyped.d.ts:37

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
Similar to this.visitNode but also allows you to match based on the subtype of objects. When both nodeCallBack and NodeSpecific callBack are matched, will only visit nodeSpecifCallback
Parameters
- 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?: {};
  }
Returns void
Inherited from TransformerSubTyped.visitNodeSpecific
- Defined in core/dist/esm/lib/transformers/TransformerSubTyped.d.ts:33

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

traverseNodes

Parameters

Returns void

traverseSubNodes

Parameters

Returns void

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