+2 -2

benchmark/suite.js

··· 6 6 const document = graphql.parse(kitchenSink, { noLocation: true }); 7 7 8 8 suite('parse kitchen sink query', () => { 9 9 - benchmark('0no-co/graphql.web', () => { 9 9 + benchmark('0no-co/graphql.web', () => { 10 10 graphqlWeb.parse(kitchenSink); 11 11 }); 12 12 ··· 16 16 }); 17 17 18 18 suite('print kitchen sink query', () => { 19 19 - benchmark('0no-co/graphql.web', () => { 19 19 + benchmark('0no-co/graphql.web', () => { 20 20 graphqlWeb.print(document); 21 21 }); 22 22

+3 -1

src/__tests__/parser.test.ts

··· 6 6 7 7 describe('print', () => { 8 8 it('prints the kitchen sink document like graphql.js does', () => { 9 9 - const sink = readFileSync(__dirname + '/../../benchmark/kitchen_sink.graphql', { encoding: 'utf8' }); 9 9 + const sink = readFileSync(__dirname + '/../../benchmark/kitchen_sink.graphql', { 10 10 + encoding: 'utf8', 11 11 + }); 10 12 const doc = parse(sink); 11 13 expect(doc).toMatchSnapshot(); 12 14 expect(doc).toEqual(graphql_parse(sink, { noLocation: true }));

+3 -10

src/ast.ts

··· 52 52 readonly loc?: Location; 53 53 } 54 54 55 55 - export type DefinitionNode = 56 56 - | OperationDefinitionNode 57 57 - | FragmentDefinitionNode; 58 58 - export type ExecutableDefinitionNode = 59 59 - | OperationDefinitionNode 60 60 - | FragmentDefinitionNode; 55 55 + export type DefinitionNode = OperationDefinitionNode | FragmentDefinitionNode; 56 56 + export type ExecutableDefinitionNode = OperationDefinitionNode | FragmentDefinitionNode; 61 57 62 58 export interface OperationDefinitionNode { 63 59 readonly kind: Kind.OPERATION_DEFINITION; ··· 92 88 selections: ReadonlyArray<SelectionNode>; 93 89 } 94 90 95 95 - export declare type SelectionNode = 96 96 - | FieldNode 97 97 - | FragmentSpreadNode 98 98 - | InlineFragmentNode; 91 91 + export declare type SelectionNode = FieldNode | FragmentSpreadNode | InlineFragmentNode; 99 92 100 93 export interface FieldNode { 101 94 readonly kind: Kind.FIELD;

+1 -1

src/error.ts

··· 17 17 positions?: Maybe<ReadonlyArray<number>>, 18 18 path?: Maybe<ReadonlyArray<string | number>>, 19 19 originalError?: Maybe<Error>, 20 20 - extensions?: Maybe<Extensions>, 20 20 + extensions?: Maybe<Extensions> 21 21 ) { 22 22 super(message); 23 23

+38 -63

src/parser.ts

··· 18 18 function advance(pattern: RegExp) { 19 19 pattern.lastIndex = idx; 20 20 if (pattern.test(input)) { 21 21 - const match = input.slice(idx, idx = pattern.lastIndex); 21 21 + const match = input.slice(idx, (idx = pattern.lastIndex)); 22 22 return match; 23 23 } 24 24 } ··· 56 56 const nameRe = /[_\w][_\d\w]*/y; 57 57 function name(): ast.NameNode | undefined { 58 58 let match: string | undefined; 59 59 - if (match = advance(nameRe)) { 59 59 + if ((match = advance(nameRe))) { 60 60 return { 61 61 kind: Kind.NAME, 62 62 value: match, ··· 81 81 let match: string | undefined; 82 82 if (advance(nullRe)) { 83 83 out = { kind: Kind.NULL }; 84 84 - } else if (match = advance(boolRe)) { 84 84 + } else if ((match = advance(boolRe))) { 85 85 out = { 86 86 kind: Kind.BOOLEAN, 87 87 value: match === 'true', ··· 94 94 value: match.slice(1), 95 95 }, 96 96 }; 97 97 - } else if (match = advance(floatRe)) { 97 97 + } else if ((match = advance(floatRe))) { 98 98 out = { 99 99 kind: Kind.FLOAT, 100 100 value: match, 101 101 }; 102 102 - } else if (match = advance(intRe)) { 102 102 + } else if ((match = advance(intRe))) { 103 103 out = { 104 104 kind: Kind.INT, 105 105 value: match, 106 106 }; 107 107 - } else if (match = advance(nameRe)) { 107 107 + } else if ((match = advance(nameRe))) { 108 108 out = { 109 109 kind: Kind.ENUM, 110 110 value: match, 111 111 }; 112 112 - } else if (match = advance(blockStringRe)) { 112 112 + } else if ((match = advance(blockStringRe))) { 113 113 out = { 114 114 kind: Kind.STRING, 115 115 value: blockString(match.slice(3, -3)), 116 116 block: true, 117 117 }; 118 118 - } else if (match = advance(stringRe)) { 118 118 + } else if ((match = advance(stringRe))) { 119 119 out = { 120 120 kind: Kind.STRING, 121 121 - value: complexStringRe.test(match) 122 122 - ? JSON.parse(match) as string 123 123 - : match.slice(1, -1), 121 121 + value: complexStringRe.test(match) ? (JSON.parse(match) as string) : match.slice(1, -1), 124 122 block: false, 125 123 }; 126 126 - } else if (out = list(constant) || object(constant)) { 124 124 + } else if ((out = list(constant) || object(constant))) { 127 125 return out; 128 126 } 129 127 ··· 137 135 idx++; 138 136 ignored(); 139 137 const values: ast.ValueNode[] = []; 140 140 - while (match = value(constant)) 141 141 - values.push(match); 142 142 - if (input.charCodeAt(idx++) !== 93 /*']'*/) 143 143 - throw error(Kind.LIST); 138 138 + while ((match = value(constant))) values.push(match); 139 139 + if (input.charCodeAt(idx++) !== 93 /*']'*/) throw error(Kind.LIST); 144 140 ignored(); 145 141 return { 146 142 kind: Kind.LIST, ··· 155 151 ignored(); 156 152 const fields: ast.ObjectFieldNode[] = []; 157 153 let _name: ast.NameNode | undefined; 158 158 - while (_name = name()) { 154 154 + while ((_name = name())) { 159 155 ignored(); 160 160 - if (input.charCodeAt(idx++) !== 58 /*':'*/) 161 161 - throw error(Kind.OBJECT_FIELD); 156 156 + if (input.charCodeAt(idx++) !== 58 /*':'*/) throw error(Kind.OBJECT_FIELD); 162 157 ignored(); 163 158 const _value = value(constant); 164 164 - if (!_value) 165 165 - throw error(Kind.OBJECT_FIELD); 159 159 + if (!_value) throw error(Kind.OBJECT_FIELD); 166 160 fields.push({ 167 161 kind: Kind.OBJECT_FIELD, 168 162 name: _name, 169 163 value: _value, 170 164 }); 171 165 } 172 172 - if (input.charCodeAt(idx++) !== 125 /*'}'*/) 173 173 - throw error(Kind.OBJECT); 166 166 + if (input.charCodeAt(idx++) !== 125 /*'}'*/) throw error(Kind.OBJECT); 174 167 ignored(); 175 168 return { 176 169 kind: Kind.OBJECT, ··· 186 179 idx++; 187 180 ignored(); 188 181 let _name: ast.NameNode | undefined; 189 189 - while (_name = name()) { 182 182 + while ((_name = name())) { 190 183 ignored(); 191 191 - if (input.charCodeAt(idx++) !== 58 /*':'*/) 192 192 - throw error(Kind.ARGUMENT); 184 184 + if (input.charCodeAt(idx++) !== 58 /*':'*/) throw error(Kind.ARGUMENT); 193 185 ignored(); 194 186 const _value = value(constant); 195 195 - if (!_value) 196 196 - throw error(Kind.ARGUMENT); 187 187 + if (!_value) throw error(Kind.ARGUMENT); 197 188 args.push({ 198 189 kind: Kind.ARGUMENT, 199 190 name: _name, 200 191 value: _value, 201 192 }); 202 193 } 203 203 - if (!args.length || input.charCodeAt(idx++) !== 41 /*')'*/) 204 204 - throw error(Kind.ARGUMENT); 194 194 + if (!args.length || input.charCodeAt(idx++) !== 41 /*')'*/) throw error(Kind.ARGUMENT); 205 195 ignored(); 206 196 } 207 197 return args; ··· 216 206 while (input.charCodeAt(idx) === 64 /*'@'*/) { 217 207 idx++; 218 208 const _name = name(); 219 219 - if (!_name) 220 220 - throw error(Kind.DIRECTIVE); 209 209 + if (!_name) throw error(Kind.DIRECTIVE); 221 210 ignored(); 222 211 directives.push({ 223 212 kind: Kind.DIRECTIVE, ··· 239 228 ignored(); 240 229 _alias = _name; 241 230 _name = name(); 242 242 - if (!_name) 243 243 - throw error(Kind.FIELD); 231 231 + if (!_name) throw error(Kind.FIELD); 244 232 ignored(); 245 233 } 246 234 return { ··· 261 249 idx++; 262 250 ignored(); 263 251 const _type = type(); 264 264 - if (!_type || input.charCodeAt(idx++) !== 93 /*']'*/) 265 265 - throw error(Kind.LIST_TYPE); 252 252 + if (!_type || input.charCodeAt(idx++) !== 93 /*']'*/) throw error(Kind.LIST_TYPE); 266 253 match = { 267 254 kind: Kind.LIST_TYPE, 268 255 type: _type, 269 256 }; 270 270 - } else if (match = name()) { 257 257 + } else if ((match = name())) { 271 258 match = { 272 259 kind: Kind.NAMED_TYPE, 273 260 name: match, ··· 294 281 if (advance(typeConditionRe)) { 295 282 ignored(); 296 283 const _name = name(); 297 297 - if (!_name) 298 298 - throw error(Kind.NAMED_TYPE); 284 284 + if (!_name) throw error(Kind.NAMED_TYPE); 299 285 ignored(); 300 286 return { 301 287 kind: Kind.NAMED_TYPE, ··· 323 309 const _typeCondition = typeCondition(); 324 310 const _directives = directives(false); 325 311 const _selectionSet = selectionSet(); 326 326 - if (!_selectionSet) 327 327 - throw error(Kind.INLINE_FRAGMENT); 312 312 + if (!_selectionSet) throw error(Kind.INLINE_FRAGMENT); 328 313 return { 329 314 kind: Kind.INLINE_FRAGMENT, 330 315 typeCondition: _typeCondition, ··· 342 327 idx++; 343 328 ignored(); 344 329 const selections: ast.SelectionNode[] = []; 345 345 - while (match = fragmentSpread() || field()) 346 346 - selections.push(match); 330 330 + while ((match = fragmentSpread() || field())) selections.push(match); 347 331 if (!selections.length || input.charCodeAt(idx++) !== 125 /*'}'*/) 348 332 throw error(Kind.SELECTION_SET); 349 333 ignored(); ··· 361 345 if (input.charCodeAt(idx) === 40 /*'('*/) { 362 346 idx++; 363 347 ignored(); 364 364 - while (match = advance(variableRe)) { 348 348 + while ((match = advance(variableRe))) { 365 349 ignored(); 366 366 - if (input.charCodeAt(idx++) !== 58 /*':'*/) 367 367 - throw error(Kind.VARIABLE_DEFINITION); 350 350 + if (input.charCodeAt(idx++) !== 58 /*':'*/) throw error(Kind.VARIABLE_DEFINITION); 368 351 const _type = type(); 369 369 - if (!_type) 370 370 - throw error(Kind.VARIABLE_DEFINITION); 352 352 + if (!_type) throw error(Kind.VARIABLE_DEFINITION); 371 353 let _defaultValue: ast.ValueNode | undefined; 372 354 if (input.charCodeAt(idx) === 61 /*'='*/) { 373 355 idx++; 374 356 ignored(); 375 357 _defaultValue = value(true); 376 376 - if (!_defaultValue) 377 377 - throw error(Kind.VARIABLE_DEFINITION); 358 358 + if (!_defaultValue) throw error(Kind.VARIABLE_DEFINITION); 378 359 } 379 360 ignored(); 380 361 vars.push({ ··· 391 372 directives: directives(true), 392 373 }); 393 374 } 394 394 - if (input.charCodeAt(idx++) !== 41 /*')'*/) 395 395 - throw error(Kind.VARIABLE_DEFINITION); 375 375 + if (input.charCodeAt(idx++) !== 41 /*')'*/) throw error(Kind.VARIABLE_DEFINITION); 396 376 ignored(); 397 377 } 398 378 return vars; ··· 403 383 if (advance(fragmentDefinitionRe)) { 404 384 ignored(); 405 385 const _name = name(); 406 406 - if (!_name) 407 407 - throw error(Kind.FRAGMENT_DEFINITION); 386 386 + if (!_name) throw error(Kind.FRAGMENT_DEFINITION); 408 387 ignored(); 409 388 const _typeCondition = typeCondition(); 410 410 - if (!_typeCondition) 411 411 - throw error(Kind.FRAGMENT_DEFINITION); 389 389 + if (!_typeCondition) throw error(Kind.FRAGMENT_DEFINITION); 412 390 const _directives = directives(false); 413 391 const _selectionSet = selectionSet(); 414 414 - if (!_selectionSet) 415 415 - throw error(Kind.FRAGMENT_DEFINITION); 392 392 + if (!_selectionSet) throw error(Kind.FRAGMENT_DEFINITION); 416 393 return { 417 394 kind: Kind.FRAGMENT_DEFINITION, 418 395 name: _name, ··· 429 406 let _name: ast.NameNode | undefined; 430 407 let _variableDefinitions: ast.VariableDefinitionNode[] = []; 431 408 let _directives: ast.DirectiveNode[] = []; 432 432 - if (_operation = advance(operationDefinitionRe)) { 409 409 + if ((_operation = advance(operationDefinitionRe))) { 433 410 ignored(); 434 411 _name = name(); 435 412 _variableDefinitions = variableDefinitions(); ··· 452 429 let match: ast.DefinitionNode | void; 453 430 ignored(); 454 431 const definitions: ast.DefinitionNode[] = []; 455 455 - while (match = fragmentDefinition() || operationDefinition()) 456 456 - definitions.push(match); 457 457 - if (idx !== input.length) 458 458 - throw error(Kind.DOCUMENT); 432 432 + while ((match = fragmentDefinition() || operationDefinition())) definitions.push(match); 433 433 + if (idx !== input.length) throw error(Kind.DOCUMENT); 459 434 return { 460 435 kind: Kind.DOCUMENT, 461 436 definitions,

+29 -44

src/printer.ts

··· 9 9 return '"""\n' + string.replace(/"""/g, '\\"""') + '\n"""'; 10 10 } 11 11 12 12 - const hasItems = <T>( 13 13 - array: ReadonlyArray<T> | undefined | null 14 14 - ): array is ReadonlyArray<T> => !!(array && array.length); 12 12 + const hasItems = <T>(array: ReadonlyArray<T> | undefined | null): array is ReadonlyArray<T> => 13 13 + !!(array && array.length); 15 14 16 15 const MAX_LINE_LENGTH = 80; 17 16 ··· 19 18 let out: string; 20 19 switch (node.kind) { 21 20 case Kind.OPERATION_DEFINITION: 22 22 - if (node.operation === 'query' && !node.name && !hasItems(node.variableDefinitions) && !hasItems(node.directives)) { 21 21 + if ( 22 22 + node.operation === 'query' && 23 23 + !node.name && 24 24 + !hasItems(node.variableDefinitions) && 25 25 + !hasItems(node.directives) 26 26 + ) { 23 27 return print(node.selectionSet); 24 28 } 25 29 out = node.operation; 26 26 - if (node.name) 27 27 - out += ' ' + node.name.value; 30 30 + if (node.name) out += ' ' + node.name.value; 28 31 if (hasItems(node.variableDefinitions)) { 29 32 if (!node.name) out += ' '; 30 33 out += '(' + node.variableDefinitions.map(print).join(', ') + ')'; 31 34 } 32 32 - if (hasItems(node.directives)) 33 33 - out += ' ' + node.directives.map(print).join(' '); 35 35 + if (hasItems(node.directives)) out += ' ' + node.directives.map(print).join(' '); 34 36 return out + ' ' + print(node.selectionSet); 35 37 36 38 case Kind.VARIABLE_DEFINITION: 37 37 - out = print(node.variable) + 38 38 - ': ' + 39 39 - print(node.type); 40 40 - if (node.defaultValue) 41 41 - out += ' = ' + print(node.defaultValue); 42 42 - if (hasItems(node.directives)) 43 43 - out += ' ' + node.directives.map(print).join(' '); 39 39 + out = print(node.variable) + ': ' + print(node.type); 40 40 + if (node.defaultValue) out += ' = ' + print(node.defaultValue); 41 41 + if (hasItems(node.directives)) out += ' ' + node.directives.map(print).join(' '); 44 42 return out; 45 43 46 44 case Kind.FIELD: 47 47 - out = (node.alias ? print(node.alias) + ': ' : '') + node.name.value 45 45 + out = (node.alias ? print(node.alias) + ': ' : '') + node.name.value; 48 46 if (hasItems(node.arguments)) { 49 47 const args = node.arguments.map(print); 50 48 const argsLine = out + '(' + args.join(', ') + ')'; 51 51 - out = argsLine.length > MAX_LINE_LENGTH 52 52 - ? out + '(\n ' + args.join('\n').replace(/\n/g, '\n ') + '\n)' 53 53 - : argsLine; 49 49 + out = 50 50 + argsLine.length > MAX_LINE_LENGTH 51 51 + ? out + '(\n ' + args.join('\n').replace(/\n/g, '\n ') + '\n)' 52 52 + : argsLine; 54 53 } 55 55 - if (hasItems(node.directives)) 56 56 - out += ' ' + node.directives.map(print).join(' '); 57 57 - return node.selectionSet 58 58 - ? out + ' ' + print(node.selectionSet) 59 59 - : out; 54 54 + if (hasItems(node.directives)) out += ' ' + node.directives.map(print).join(' '); 55 55 + return node.selectionSet ? out + ' ' + print(node.selectionSet) : out; 60 56 61 57 case Kind.STRING: 62 62 - return node.block 63 63 - ? printBlockString(node.value) 64 64 - : printString(node.value); 58 58 + return node.block ? printBlockString(node.value) : printString(node.value); 65 59 66 60 case Kind.BOOLEAN: 67 61 return '' + node.value; ··· 88 82 return '$' + node.name.value; 89 83 90 84 case Kind.DOCUMENT: 91 91 - return hasItems(node.definitions) 92 92 - ? node.definitions.map(print).join('\n\n') 93 93 - : ''; 85 85 + return hasItems(node.definitions) ? node.definitions.map(print).join('\n\n') : ''; 94 86 95 87 case Kind.SELECTION_SET: 96 96 - return '{\n ' + 97 97 - node.selections.map(print).join('\n').replace(/\n/g, '\n ') + 98 98 - '\n}'; 88 88 + return '{\n ' + node.selections.map(print).join('\n').replace(/\n/g, '\n ') + '\n}'; 99 89 100 90 case Kind.ARGUMENT: 101 91 return node.name.value + ': ' + print(node.value); 102 92 103 93 case Kind.FRAGMENT_SPREAD: 104 94 out = '...' + node.name.value; 105 105 - if (hasItems(node.directives)) 106 106 - out += ' ' + node.directives.map(print).join(' '); 95 95 + if (hasItems(node.directives)) out += ' ' + node.directives.map(print).join(' '); 107 96 return out; 108 97 109 98 case Kind.INLINE_FRAGMENT: 110 99 out = '...'; 111 111 - if (node.typeCondition) 112 112 - out += ' on ' + node.typeCondition.name.value; 113 113 - if (hasItems(node.directives)) 114 114 - out += ' ' + node.directives.map(print).join(' '); 100 100 + if (node.typeCondition) out += ' on ' + node.typeCondition.name.value; 101 101 + if (hasItems(node.directives)) out += ' ' + node.directives.map(print).join(' '); 115 102 return out + ' ' + print(node.selectionSet); 116 103 117 104 case Kind.FRAGMENT_DEFINITION: 118 105 out = 'fragment ' + node.name.value; 119 106 out += ' on ' + node.typeCondition.name.value; 120 120 - if (hasItems(node.directives)) 121 121 - out += ' ' + node.directives.map(print).join(' '); 107 107 + if (hasItems(node.directives)) out += ' ' + node.directives.map(print).join(' '); 122 108 return out + ' ' + print(node.selectionSet); 123 123 - 109 109 + 124 110 case Kind.DIRECTIVE: 125 111 out = '@' + node.name.value; 126 126 - if (hasItems(node.arguments)) 127 127 - out += '(' + node.arguments.map(print).join(', ') + ')'; 112 112 + if (hasItems(node.arguments)) out += '(' + node.arguments.map(print).join(', ') + ')'; 128 113 return out; 129 114 130 115 case Kind.NAMED_TYPE:

+5 -10

src/values.ts

··· 4 4 5 5 export function valueFromASTUntyped( 6 6 node: ValueNode, 7 7 - variables?: Maybe<Record<string, any>>, 7 7 + variables?: Maybe<Record<string, any>> 8 8 ): unknown { 9 9 switch (node.kind) { 10 10 case Kind.NULL: ··· 19 19 return node.value; 20 20 case Kind.LIST: { 21 21 const values: unknown[] = []; 22 22 - for (const value of node.values) 23 23 - values.push(valueFromASTUntyped(value, variables)); 22 22 + for (const value of node.values) values.push(valueFromASTUntyped(value, variables)); 24 23 return values; 25 24 } 26 25 case Kind.OBJECT: { ··· 37 36 export function valueFromTypeNode( 38 37 node: ValueNode, 39 38 type: TypeNode, 40 40 - variables?: Maybe<Record<string, any>>, 39 39 + variables?: Maybe<Record<string, any>> 41 40 ): unknown { 42 41 if (node.kind === Kind.VARIABLE) { 43 42 const variableName = node.name.value; 44 44 - return variables 45 45 - ? valueFromTypeNode(variables[variableName], type, variables) 46 46 - : undefined; 43 43 + return variables ? valueFromTypeNode(variables[variableName], type, variables) : undefined; 47 44 } else if (type.kind === Kind.NON_NULL_TYPE) { 48 48 - return node.kind !== Kind.NULL 49 49 - ? valueFromTypeNode(node, type, variables) 50 50 - : undefined 45 45 + return node.kind !== Kind.NULL ? valueFromTypeNode(node, type, variables) : undefined; 51 46 } else if (node.kind === Kind.NULL) { 52 47 return null; 53 48 } else if (type.kind === Kind.LIST_TYPE) {

+8 -12

src/visitor.ts

··· 6 6 export function visit<R>(root: ASTNode, visitor: ASTReducer<R>): R; 7 7 8 8 export function visit(node: ASTNode, visitor: ASTVisitor | ASTReducer<any>) { 9 9 - const ancestors: Array<ASTNode | ReadonlyArray<ASTNode>>= []; 9 9 + const ancestors: Array<ASTNode | ReadonlyArray<ASTNode>> = []; 10 10 const path: Array<string | number> = []; 11 11 12 12 function traverse( 13 13 node: ASTNode, 14 14 key?: string | number | undefined, 15 15 - parent?: ASTNode | ReadonlyArray<ASTNode> | undefined, 15 15 + parent?: ASTNode | ReadonlyArray<ASTNode> | undefined 16 16 ) { 17 17 let hasEdited = false; 18 18 19 19 - const enter = visitor[node.kind] && visitor[node.kind].enter || visitor[node.kind]; 20 20 - const resultEnter = 21 21 - enter && enter.call(visitor, node, key, parent, path, ancestors); 19 19 + const enter = (visitor[node.kind] && visitor[node.kind].enter) || visitor[node.kind]; 20 20 + const resultEnter = enter && enter.call(visitor, node, key, parent, path, ancestors); 22 21 if (resultEnter === false) { 23 22 return node; 24 23 } else if (resultEnter === null) { ··· 71 70 72 71 if (parent) ancestors.pop(); 73 72 const leave = visitor[node.kind] && visitor[node.kind].leave; 74 74 - const resultLeave = 75 75 - leave && leave.call(visitor, node, key, parent, path, ancestors); 73 73 + const resultLeave = leave && leave.call(visitor, node, key, parent, path, ancestors); 76 74 if (resultLeave === BREAK) { 77 75 throw BREAK; 78 76 } else if (resultLeave !== undefined) { ··· 96 94 export type ASTVisitor = EnterLeaveVisitor<ASTNode> | KindVisitor; 97 95 98 96 type KindVisitor = { 99 99 - readonly [NodeT in ASTNode as NodeT['kind']]?: 100 100 - | ASTVisitFn<NodeT> 101 101 - | EnterLeaveVisitor<NodeT>; 97 97 + readonly [NodeT in ASTNode as NodeT['kind']]?: ASTVisitFn<NodeT> | EnterLeaveVisitor<NodeT>; 102 98 }; 103 99 104 100 interface EnterLeaveVisitor<TVisitedNode extends ASTNode> { ··· 111 107 key: string | number | undefined, 112 108 parent: ASTNode | ReadonlyArray<ASTNode> | undefined, 113 109 path: ReadonlyArray<string | number>, 114 114 - ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>>, 110 110 + ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>> 115 111 ) => any; 116 112 117 113 export type ASTReducer<R> = { ··· 126 122 key: string | number | undefined, 127 123 parent: ASTNode | ReadonlyArray<ASTNode> | undefined, 128 124 path: ReadonlyArray<string | number>, 129 129 - ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>>, 125 125 + ancestors: ReadonlyArray<ASTNode | ReadonlyArray<ASTNode>> 130 126 ) => R; 131 127 132 128 type ReducedField<T, R> = T extends null | undefined